object ZStream extends ZStreamPlatformSpecificConstructors
- Alphabetic
- By Inheritance
- ZStream
- ZStreamPlatformSpecificConstructors
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final class AccessMPartiallyApplied[R] extends AnyVal
- final class AccessPartiallyApplied[R] extends AnyVal
- final class AccessStreamPartiallyApplied[R] extends AnyVal
- trait Emit[+R, -E, -A, +B] extends (ZIO[R, Option[E], Chunk[A]]) => B
An
Emit[R, E, A, B]
represents an asynchronous callback that can be called multiple times.An
Emit[R, E, A, B]
represents an asynchronous callback that can be called multiple times. The callback can be called with a value of typeZIO[R, Option[E], Chunk[A]]
, where succeeding with aChunk[A]
indicates to emit those elements, failing withSome[E]
indicates to terminate with that error, and failing withNone
indicates to terminate with an end of stream signal. - final class GroupBy[-R, +E, +K, +V] extends AnyRef
Representation of a grouped stream.
Representation of a grouped stream. This allows to filter which groups will be processed. Once this is applied all groups will be processed in parallel and the results will be merged in arbitrary order.
- final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
- type Pull[-R, +E, +O] = ZIO[R, Option[E], Chunk[O]]
- implicit final class RefineToOrDieOps[R, E <: Throwable, A] extends AnyVal
- final class ServiceWithPartiallyApplied[Service] extends AnyVal
- final class ServiceWithStreamPartiallyApplied[Service] extends AnyVal
- implicit final class SortedByKey[R, E, K, A] extends AnyRef
Provides extension methods for streams that are sorted by distinct keys.
- implicit final class SyntaxOps[-R, +E, O] extends AnyRef
- sealed trait TerminationStrategy extends AnyRef
- final class UpdateService[-R, +E, +O, M] extends AnyVal
- final class WhenCaseM[R, E, A] extends AnyVal
- final class WhenM[R, E] extends AnyVal
- class Connection extends AnyRef
Accepted connection made to a specific channel
AsynchronousServerSocketChannel
Accepted connection made to a specific channel
AsynchronousServerSocketChannel
- Definition Classes
- ZStreamPlatformSpecificConstructors
Deprecated Type Members
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final val DefaultChunkSize: Int(4096)
The default chunk size used by the various combinators and constructors of ZStream.
- def absolve[R, E, O](xs: ZStream[R, E, Either[E, O]]): ZStream[R, E, O]
Submerges the error case of an
Either
into theZStream
. - def access[R]: AccessPartiallyApplied[R]
Accesses the environment of the stream.
- def accessM[R]: AccessMPartiallyApplied[R]
Accesses the environment of the stream in the context of an effect.
- def accessStream[R]: AccessStreamPartiallyApplied[R]
Accesses the environment of the stream in the context of a stream.
- def apply[A](as: A*): ZStream[Any, Nothing, A]
Creates a pure stream from a variable list of values
- def apply[R, E, O](process: ZManaged[R, Nothing, ZIO[R, Option[E], Chunk[O]]]): ZStream[R, E, O]
Creates a new ZStream from a managed effect that yields chunks.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) => URIO[R, Any]): ZStream[R, E, A]
Creates a stream from a single value that will get cleaned up after the stream is consumed
- def bracketExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) => URIO[R, Any]): ZStream[R, E, A]
Creates a stream from a single value that will get cleaned up after the stream is consumed
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def concatAll[R, E, O](streams: Chunk[ZStream[R, E, O]]): ZStream[R, E, O]
Concatenates all of the streams in the chunk to one stream.
- def crossN[R, E, A, B, C, D, F](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C], zStream4: ZStream[R, E, D])(f: (A, B, C, D) => F): ZStream[R, E, F]
Composes the specified streams to create a cartesian product of elements with a specified function.
Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent stream would be run multiple times, for every combination of elements in the prior streams.
See also ZStream#zipN[R,E,A,B,C,D,F]* for the more common point-wise variant.
- def crossN[R, E, A, B, C, D](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C])(f: (A, B, C) => D): ZStream[R, E, D]
Composes the specified streams to create a cartesian product of elements with a specified function.
Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent stream would be run multiple times, for every combination of elements in the prior streams.
See also ZStream#zipN[R,E,A,B,C,D]* for the more common point-wise variant.
- def crossN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) => C): ZStream[R, E, C]
Composes the specified streams to create a cartesian product of elements with a specified function.
Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent streams would be run multiple times, for every combination of elements in the prior streams.
See also ZStream#zipN[R,E,A,B,C]* for the more common point-wise variant.
- def die(ex: => Throwable): ZStream[Any, Nothing, Nothing]
The stream that dies with the
ex
. - def dieMessage(msg: => String): ZStream[Any, Nothing, Nothing]
The stream that dies with an exception described by
msg
. - def done[E, A](exit: Exit[E, A]): ZStream[Any, E, A]
The stream that ends with the zio.Exit value
exit
. - def effectAsync[R, E, A](register: (Emit[R, E, A, Unit]) => Unit, outputBuffer: Int = 16): ZStream[R, E, A]
Creates a stream from an asynchronous callback that can be called multiple times.
Creates a stream from an asynchronous callback that can be called multiple times. The optionality of the error type
E
can be used to signal the end of the stream, by setting it toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def effectAsyncInterrupt[R, E, A](register: (Emit[R, E, A, Unit]) => Either[Canceler[R], ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]
Creates a stream from an asynchronous callback that can be called multiple times.
Creates a stream from an asynchronous callback that can be called multiple times. The registration of the callback returns either a canceler or synchronously returns a stream. The optionality of the error type
E
can be used to signal the end of the stream, by setting it toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def effectAsyncM[R, E, A](register: (Emit[R, E, A, Unit]) => ZIO[R, E, Any], outputBuffer: Int = 16): ZStream[R, E, A]
Creates a stream from an asynchronous callback that can be called multiple times The registration of the callback itself returns an effect.
Creates a stream from an asynchronous callback that can be called multiple times The registration of the callback itself returns an effect. The optionality of the error type
E
can be used to signal the end of the stream, by setting it toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def effectAsyncManaged[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) => Unit) => ZManaged[R, E, Any], outputBuffer: Int = 16): ZStream[R, E, A]
Creates a stream from an asynchronous callback that can be called multiple times.
Creates a stream from an asynchronous callback that can be called multiple times. The registration of the callback itself returns an a managed resource. The optionality of the error type
E
can be used to signal the end of the stream, by setting it toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def effectAsyncMaybe[R, E, A](register: (Emit[R, E, A, Unit]) => Option[ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]
Creates a stream from an asynchronous callback that can be called multiple times.
Creates a stream from an asynchronous callback that can be called multiple times. The registration of the callback can possibly return the stream synchronously. The optionality of the error type
E
can be used to signal the end of the stream, by setting it toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- val empty: ZStream[Any, Nothing, Nothing]
The empty stream
- def environment[R]: ZStream[R, Nothing, R]
Accesses the whole environment of the stream.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def execute[R, E, A](zio: ZIO[R, E, A]): ZStream[R, E, Nothing]
Creates a zio.stream.ZStream from the given effect and drains it
- def fail[E](error: => E): ZStream[Any, E, Nothing]
The stream that always fails with the
error
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def finalizer[R](finalizer: URIO[R, Any]): ZStream[R, Nothing, Any]
Creates a one-element stream that never fails and executes the finalizer when it ends.
- def fromBlockingIterator[A](iterator: => Iterator[A], maxChunkSize: Int = 1): ZStream[Blocking, Throwable, A]
Creates a stream from an blocking iterator that may throw exceptions.
Creates a stream from an blocking iterator that may throw exceptions.
- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromBlockingJavaIterator[A](iter: => Iterator[A], maxChunkSize: Int = 1): ZStream[Blocking, Throwable, A]
Creates a stream from an blocking Java iterator that may throw exceptions.
Creates a stream from an blocking Java iterator that may throw exceptions.
- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromChunk[O](c: => Chunk[O]): ZStream[Any, Nothing, O]
Creates a stream from a zio.Chunk of values
Creates a stream from a zio.Chunk of values
- c
a chunk of values
- returns
a finite stream of values
- def fromChunkHub[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]
Creates a stream from a subscription to a hub.
- def fromChunkHubManaged[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZManaged[Any, Nothing, ZStream[R, E, O]]
Creates a stream from a subscription to a hub in the context of a managed effect.
Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.
- def fromChunkHubManagedWithShutdown[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZManaged[Any, Nothing, ZStream[R, E, O]]
Creates a stream from a subscription to a hub in the context of a managed effect.
Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.
The hub will be shut down once the stream is closed.
- def fromChunkHubWithShutdown[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]
Creates a stream from a subscription to a hub.
Creates a stream from a subscription to a hub.
The hub will be shut down once the stream is closed.
- def fromChunkQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]
Creates a stream from a zio.ZQueue of values
- def fromChunkQueueWithShutdown[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]
Creates a stream from a zio.ZQueue of values.
Creates a stream from a zio.ZQueue of values. The queue will be shutdown once the stream is closed.
- def fromChunks[O](cs: Chunk[O]*): ZStream[Any, Nothing, O]
Creates a stream from an arbitrary number of chunks.
- def fromEffect[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]
Creates a stream from an effect producing a value of type
A
- def fromEffectOption[R, E, A](fa: ZIO[R, Option[E], A]): ZStream[R, E, A]
Creates a stream from an effect producing a value of type
A
or an empty Stream - def fromFile(path: => Path, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, Throwable, Byte]
Creates a stream of bytes from a file at the specified path.
Creates a stream of bytes from a file at the specified path.
- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromHub[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, A]
Creates a stream from a subscription to a hub.
- def fromHubManaged[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZManaged[Any, Nothing, ZStream[R, E, A]]
Creates a stream from a subscription to a hub in the context of a managed effect.
Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.
- def fromHubManagedWithShutdown[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZManaged[Any, Nothing, ZStream[R, E, A]]
Creates a stream from a subscription to a hub in the context of a managed effect.
Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.
The hub will be shut down once the stream is closed.
- def fromHubWithShutdown[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, A]
Creates a stream from a subscription to a hub.
Creates a stream from a subscription to a hub.
The hub will be shut down once the stream is closed.
- def fromInputStream(is: => InputStream, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, IOException, Byte]
Creates a stream from a
java.io.InputStream
.Creates a stream from a
java.io.InputStream
. Note: the input stream will not be explicitly closed after it is exhausted.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromInputStreamEffect[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, IOException, Byte]
Creates a stream from a
java.io.InputStream
.Creates a stream from a
java.io.InputStream
. Ensures that the input stream is closed after it is exhausted.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromInputStreamManaged[R](is: ZManaged[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, IOException, Byte]
Creates a stream from a managed
java.io.InputStream
value.Creates a stream from a managed
java.io.InputStream
value.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromIterable[O](as: => Iterable[O]): ZStream[Any, Nothing, O]
Creates a stream from an iterable collection of values
- def fromIterableM[R, E, O](iterable: ZIO[R, E, Iterable[O]]): ZStream[R, E, O]
Creates a stream from an effect producing a value of type
Iterable[A]
- def fromIterator[A](iterator: => Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Throwable, A]
Creates a stream from an iterator that may throw exceptions.
- def fromIteratorEffect[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]
Creates a stream from an iterator that may potentially throw exceptions
- def fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]
Creates a stream from a managed iterator
- def fromIteratorTotal[A](iterator: => Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Nothing, A]
Creates a stream from an iterator that does not throw exceptions.
- def fromJavaIterator[A](iterator: => Iterator[A]): ZStream[Any, Throwable, A]
Creates a stream from a Java iterator that may throw exceptions
- def fromJavaIteratorEffect[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]
Creates a stream from a Java iterator that may potentially throw exceptions
- def fromJavaIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]
Creates a stream from a managed iterator
- def fromJavaIteratorTotal[A](iterator: => Iterator[A]): ZStream[Any, Nothing, A]
Creates a stream from a Java iterator
- final def fromJavaStream[A](stream: => java.util.stream.Stream[A]): ZStream[Any, Throwable, A]
Creates a stream from a Java stream
Creates a stream from a Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
- final def fromJavaStreamEffect[R, A](stream: ZIO[R, Throwable, java.util.stream.Stream[A]]): ZStream[R, Throwable, A]
Creates a stream from a Java stream
Creates a stream from a Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
- final def fromJavaStreamManaged[R, A](stream: ZManaged[R, Throwable, java.util.stream.Stream[A]]): ZStream[R, Throwable, A]
Creates a stream from a managed Java stream
Creates a stream from a managed Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
- final def fromJavaStreamTotal[A](stream: => java.util.stream.Stream[A]): ZStream[Any, Nothing, A]
Creates a stream from a Java stream
Creates a stream from a Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromOutputStreamWriter(write: (OutputStream) => Unit, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, Throwable, Byte]
Creates a stream from a callback that writes to
java.io.OutputStream
.Creates a stream from a callback that writes to
java.io.OutputStream
. Note: the input stream will be closed after thewrite
is done.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, O]
Creates a stream from a zio.ZQueue of values
Creates a stream from a zio.ZQueue of values
- maxChunkSize
Maximum number of queued elements to put in one chunk in the stream
- def fromQueueWithShutdown[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, O]
Creates a stream from a zio.ZQueue of values.
Creates a stream from a zio.ZQueue of values. The queue will be shutdown once the stream is closed.
- maxChunkSize
Maximum number of queued elements to put in one chunk in the stream
- def fromReader(reader: => Reader, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, IOException, Char]
Creates a stream from
java.io.Reader
.Creates a stream from
java.io.Reader
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromReaderEffect[R](reader: => ZIO[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, IOException, Char]
Creates a stream from an effect producing
java.io.Reader
.Creates a stream from an effect producing
java.io.Reader
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromReaderManaged[R](reader: => ZManaged[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, IOException, Char]
Creates a stream from managed
java.io.Reader
.Creates a stream from managed
java.io.Reader
.- Definition Classes
- ZStreamPlatformSpecificConstructors
- final def fromResource(path: String, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, IOException, Byte]
Creates a stream from the resource specified in
path
Creates a stream from the resource specified in
path
- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromSchedule[R, A](schedule: Schedule[R, Any, A]): ZStream[R with Clock, Nothing, A]
Creates a stream from a zio.Schedule that does not require any further input.
Creates a stream from a zio.Schedule that does not require any further input. The stream will emit an element for each value output from the schedule, continuing for as long as the schedule continues.
- def fromSocketServer(port: Int, host: Option[String] = None): ZStream[Blocking, Throwable, Connection]
Create a stream of accepted connection from server socket Emit socket
Connection
from which you can read / write and ensure it is closed after it is usedCreate a stream of accepted connection from server socket Emit socket
Connection
from which you can read / write and ensure it is closed after it is used- Definition Classes
- ZStreamPlatformSpecificConstructors
- def fromTQueue[A](queue: TQueue[A]): ZStream[Any, Nothing, A]
Creates a stream from a zio.stm.TQueue of values.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def halt[E](cause: => Cause[E]): ZStream[Any, E, Nothing]
The stream that always halts with
cause
. - def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterate[A](a: A)(f: (A) => A): ZStream[Any, Nothing, A]
The infinite stream of iterative function application: a, f(a), f(f(a)), f(f(f(a))), ...
- def managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]
Creates a single-valued stream from a managed resource
- def mergeAll[R, E, O](n: Int, outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]
Merges a variable list of streams in a non-deterministic fashion.
Merges a variable list of streams in a non-deterministic fashion. Up to
n
streams may be consumed in parallel and up tooutputBuffer
chunks may be buffered by this operator. - def mergeAllUnbounded[R, E, O](outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]
Like mergeAll, but runs all streams concurrently.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- val never: ZStream[Any, Nothing, Nothing]
The stream that never produces any value or fails with any error.
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def paginate[R, E, A, S](s: S)(f: (S) => (A, Option[S])): ZStream[Any, Nothing, A]
Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state. This is useful for embedding paginated APIs, hence the name.
- def paginateChunk[A, S](s: S)(f: (S) => (Chunk[A], Option[S])): ZStream[Any, Nothing, A]
Like unfoldChunk, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldChunk, but allows the emission of values to end one step further than the unfolding of the state. This is useful for embedding paginated APIs, hence the name.
- def paginateChunkM[R, E, A, S](s: S)(f: (S) => ZIO[R, E, (Chunk[A], Option[S])]): ZStream[R, E, A]
Like unfoldChunkM, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldChunkM, but allows the emission of values to end one step further than the unfolding of the state. This is useful for embedding paginated APIs, hence the name.
- def paginateM[R, E, A, S](s: S)(f: (S) => ZIO[R, E, (A, Option[S])]): ZStream[R, E, A]
Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state. This is useful for embedding paginated APIs, hence the name.
- def range(min: Int, max: Int, chunkSize: Int = DefaultChunkSize): ZStream[Any, Nothing, Int]
Constructs a stream from a range of integers (lower bound included, upper bound not included)
- def repeat[A](a: => A): ZStream[Any, Nothing, A]
Repeats the provided value infinitely.
- def repeatEffect[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]
Creates a stream from an effect producing a value of type
A
which repeats forever. - def repeatEffectChunk[R, E, A](fa: ZIO[R, E, Chunk[A]]): ZStream[R, E, A]
Creates a stream from an effect producing chunks of
A
values which repeats forever. - def repeatEffectChunkOption[R, E, A](fa: ZIO[R, Option[E], Chunk[A]]): ZStream[R, E, A]
Creates a stream from an effect producing chunks of
A
values until it fails with None. - def repeatEffectOption[R, E, A](fa: ZIO[R, Option[E], A]): ZStream[R, E, A]
Creates a stream from an effect producing values of type
A
until it fails with None. - def repeatEffectWith[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any]): ZStream[R with Clock, E, A]
Creates a stream from an effect producing a value of type
A
, which is repeated using the specified schedule. - def repeatWith[R, A](a: => A, schedule: Schedule[R, A, _]): ZStream[R with Clock, Nothing, A]
Repeats the value using the provided schedule.
- def service[A](implicit arg0: zio.Tag[A]): ZStream[Has[A], Nothing, A]
Accesses the specified service in the environment of the stream.
- def serviceWith[Service]: ServiceWithPartiallyApplied[Service]
Accesses the specified service in the environment of the stream in the context of an effect.
- def serviceWithStream[Service]: ServiceWithStreamPartiallyApplied[Service]
Accesses the specified service in the environment of the stream in the context of a stream.
- def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): ZStream[Has[A] with Has[B] with Has[C] with Has[D], Nothing, (A, B, C, D)]
Accesses the specified services in the environment of the stream.
- def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): ZStream[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]
Accesses the specified services in the environment of the stream.
- def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): ZStream[Has[A] with Has[B], Nothing, (A, B)]
Accesses the specified services in the environment of the stream.
- def succeed[A](a: => A): ZStream[Any, Nothing, A]
Creates a single-valued pure stream
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tick(interval: Duration): ZStream[Clock, Nothing, Unit]
A stream that emits Unit values spaced by the specified duration.
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unfold[S, A](s: S)(f: (S) => Option[(A, S)]): ZStream[Any, Nothing, A]
Creates a stream by peeling off the "layers" of a value of type
S
- def unfoldChunk[S, A](s: S)(f: (S) => Option[(Chunk[A], S)]): ZStream[Any, Nothing, A]
Creates a stream by peeling off the "layers" of a value of type
S
. - def unfoldChunkM[R, E, A, S](s: S)(f: (S) => ZIO[R, E, Option[(Chunk[A], S)]]): ZStream[R, E, A]
Creates a stream by effectfully peeling off the "layers" of a value of type
S
- def unfoldM[R, E, A, S](s: S)(f: (S) => ZIO[R, E, Option[(A, S)]]): ZStream[R, E, A]
Creates a stream by effectfully peeling off the "layers" of a value of type
S
- val unit: ZStream[Any, Nothing, Unit]
A stream that contains a single
Unit
value. - def unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]]): ZStream[R, E, A]
Creates a stream produced from an effect
- def unwrapManaged[R, E, A](fa: ZManaged[R, E, ZStream[R, E, A]]): ZStream[R, E, A]
Creates a stream produced from a ZManaged
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def when[R, E, O](b: => Boolean)(zStream: => ZStream[R, E, O]): ZStream[R, E, O]
Returns the specified stream if the given condition is satisfied, otherwise returns an empty stream.
- def whenCase[R, E, A, O](a: => A)(pf: PartialFunction[A, ZStream[R, E, O]]): ZStream[R, E, O]
Returns the resulting stream when the given
PartialFunction
is defined for the given value, otherwise returns an empty stream. - def whenCaseM[R, E, A](a: ZIO[R, E, A]): WhenCaseM[R, E, A]
Returns the resulting stream when the given
PartialFunction
is defined for the given effectful value, otherwise returns an empty stream. - def whenM[R, E](b: ZIO[R, E, Boolean]): WhenM[R, E]
Returns the specified stream if the given effectful condition is satisfied, otherwise returns an empty stream.
- def zipN[R, E, A, B, C, D, F](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C], zStream4: ZStream[R, E, D])(f: (A, B, C, D) => F): ZStream[R, E, F]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function.Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function. If any effect fails, then the other effects will be interrupted. - def zipN[R, E, A, B, C, D](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C])(f: (A, B, C) => D): ZStream[R, E, D]
Zips with specified streams together with the specified function.
- def zipN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) => C): ZStream[R, E, C]
Zips the specified streams together with the specified function.
- object Take
- object TerminationStrategy
- object Connection
- Definition Classes
- ZStreamPlatformSpecificConstructors