ZStream

Type Members

final class AccessPartiallyApplied[R] extends AnyVal
final class AccessStreamPartiallyApplied[R] extends AnyVal
final class AccessZIOPartiallyApplied[R] extends AnyVal
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, -R, +E, +A] extends AnyVal
type Pull[-R, +E, +A] = ZIO[R, Option[E], Chunk[A]]
implicit final class RefineToOrDieOps[R, E <: Throwable, A] extends AnyVal
sealed trait TerminationStrategy extends AnyRef
final class UpdateService[-R, +E, +A, M] extends AnyVal
trait ZStreamConstructor[Input] extends AnyRef

A ZStreamConstructor[Input] knows how to construct a ZStream value from an input of type Input.
A ZStreamConstructor[Input] knows how to construct a ZStream value from an input of type Input. This allows the type of the ZStream value constructed to depend on Input.
trait ZStreamConstructorLowPriority1 extends ZStreamConstructorLowPriority2
trait ZStreamConstructorLowPriority2 extends ZStreamConstructorLowPriority3
trait ZStreamConstructorLowPriority3 extends AnyRef
trait ZStreamConstructorPlatformSpecific extends ZStreamConstructorLowPriority1

Definition Classes
ZStreamPlatformSpecificConstructors
type Take[+E, +A] = Exit[Option[E], Chunk[A]]

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use zio.stream.Take instead

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.
object Take
object TerminationStrategy
object ZStreamConstructor extends ZStreamConstructorPlatformSpecific
def absolve[R, E, O](xs: ZStream[R, E, Either[E, O]]): ZStream[R, E, O]

Submerges the error case of an Either into the ZStream.
def access[R]: AccessPartiallyApplied[R]

Accesses the environment of the stream.
def accessStream[R]: AccessStreamPartiallyApplied[R]

Accesses the environment of the stream in the context of a stream.
def accessZIO[R]: AccessZIOPartiallyApplied[R]

Accesses the environment of the stream in the context of an effect.
def acquireReleaseExitWith[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 acquireReleaseWith[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 apply[A](as: A*): ZStream[Any, Nothing, A]

Creates a pure stream from a variable list of values
final def asInstanceOf[T0]: T0

Definition Classes
Any
def async[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
def asyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
def asyncMaybe[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
def asyncZIO[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
def blocking[R, E, A](stream: ZStream[R, E, A]): ZStream[R, E, A]

Locks the execution of the specified stream to the blocking executor.
Locks the execution of the specified stream to the blocking executor. Any streams that are composed after this one will automatically be shifted back to the previous executor.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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.
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: Any): Boolean

Definition Classes
AnyRef → Any
def fail[E](error: ⇒ E): ZStream[Any, E, Nothing]

The stream that always fails with the error
def failCause[E](cause: ⇒ Cause[E]): ZStream[Any, E, Nothing]

The stream that always fails with cause.
def finalize(): Unit

Attributes
protected[java.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 from[Input](input: ⇒ Input)(implicit constructor: ZStreamConstructor[Input]): Out
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 queue 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 queue of values.
Creates a stream from a queue 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 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 fromIterable[O](as: ⇒ Iterable[O]): ZStream[Any, Nothing, O]

Creates a stream from an iterable collection of values
def fromIterableZIO[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]): ZStream[Any, Throwable, A]
def fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

Creates a stream from a managed iterator
def fromIteratorSucceed[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

Creates a stream from an iterator
def fromIteratorZIO[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

Creates a stream from an iterator that may potentially throw exceptions
def fromJavaIterator[A](iterator: ⇒ Iterator[A]): ZStream[Any, Throwable, A]

Creates a stream from a Java iterator that may throw exceptions
def fromJavaIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

Creates a stream from a managed iterator
def fromJavaIteratorSucceed[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

Creates a stream from a Java iterator
def fromJavaIteratorZIO[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 fromPull[R, E, A](zio: ZManaged[R, Nothing, ZIO[R, Option[E], Chunk[A]]]): ZStream[R, E, A]
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 queue of values
Creates a stream from a queue 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 queue of values.
Creates a stream from a queue 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 fromSchedule[R, A](schedule: Schedule[R, Any, A]): ZStream[R with Has[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 fromTQueue[A](queue: TQueue[A]): ZStream[Any, Nothing, A]

Creates a stream from a zio.stm.TQueue of values.
def fromZIO[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 fromZIOOption[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
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
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 to outputBuffer 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
final def notifyAll(): Unit

Definition Classes
AnyRef
def paginate[R, E, A, S](s: S)(f: (S) ⇒ (A, Option[S])): ZStream[Any, Nothing, A]

Like unfold, but allows the emission of values to end one step further than the unfolding of the state.
Like unfold, 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 paginateChunkZIO[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (Chunk[A], Option[S])]): ZStream[R, E, A]

Like unfoldChunkZIO, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldChunkZIO, 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 paginateZIO[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (A, Option[S])]): ZStream[R, E, A]

Like unfoldZIO, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldZIO, 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 repeatWith[R, A](a: ⇒ A, schedule: Schedule[R, A, _]): ZStream[R with Has[Clock], Nothing, A]

Repeats the value using the provided schedule.
def repeatZIO[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 repeatZIOChunk[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 repeatZIOChunkOption[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 repeatZIOOption[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 repeatZIOWith[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any]): ZStream[R with Has[Clock], E, A]

Creates a stream from an effect producing a value of type A, which is repeated using the specified schedule.
def service[A](implicit arg0: zio.Tag[A]): ZStream[Has[A], Nothing, A]

Accesses the specified service in the environment of the effect.
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 effect.
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 effect.
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 effect.
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: zio.Duration): ZStream[Has[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 unfoldChunkZIO[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 unfoldZIO[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( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
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.

Deprecated Value Members

def accessM[R]: AccessZIOPartiallyApplied[R]

Accesses the environment of the stream in the context of an effect.
Accesses the environment of the stream in the context of an effect.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use accessZIO
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
Creates a stream from a single value that will get cleaned up after the stream is consumed

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseWith
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
Creates a stream from a single value that will get cleaned up after the stream is consumed

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseExitWith
def effectAsync[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use async
def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncInterrupt
def effectAsyncM[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncZIO
def effectAsyncMaybe[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncMaybe
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
Creates a stream from an effect producing a value of type A

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromZIO
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
Creates a stream from an effect producing a value of type A or an empty Stream

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromZIOOption
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]
Creates a stream from an effect producing a value of type Iterable[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromIterableZIO
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
Creates a stream from an iterator that may potentially throw exceptions

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromIteratorZIO
def fromIteratorTotal[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

Creates a stream from an iterator
Creates a stream from an iterator

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromIteratorSucceed
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
Creates a stream from a Java iterator that may potentially throw exceptions

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromJavaIteratorZIO
def fromJavaIteratorTotal[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

Creates a stream from a Java iterator
Creates a stream from a Java iterator

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromJavaIteratorSucceed
def halt[E](cause: ⇒ Cause[E]): ZStream[Any, E, Nothing]

The stream that always halts with cause.
The stream that always halts with cause.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use failCause
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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use paginateChunkZIO
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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use paginateZIO
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.
Creates a stream from an effect producing a value of type A which repeats forever.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use repeatZIO
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.
Creates a stream from an effect producing chunks of A values which repeats forever.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use repeatZIOChunk
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.
Creates a stream from an effect producing chunks of A values until it fails with None.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use repeatZIOChunkOption
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.
Creates a stream from an effect producing values of type A until it fails with None.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use repeatZIOOption
def repeatEffectWith[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any]): ZStream[R with Has[Clock], E, A]

Creates a stream from an effect producing a value of type A, which is repeated using the specified schedule.
Creates a stream from an effect producing a value of type A, which is repeated using the specified schedule.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use repeatZIOWith
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
Creates a stream by effectfully peeling off the "layers" of a value of type S

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use unfoldChunkZIO
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
Creates a stream by effectfully peeling off the "layers" of a value of type S

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use unfoldZIO

Related Docs: class ZStream | package experimental

object ZStream extends ZStreamPlatformSpecificConstructors

Type Members

final class AccessPartiallyApplied[R] extends AnyVal

final class AccessStreamPartiallyApplied[R] extends AnyVal

final class AccessZIOPartiallyApplied[R] extends AnyVal

final class GroupBy[-R, +E, +K, +V] extends AnyRef

final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal

type Pull[-R, +E, +A] = ZIO[R, Option[E], Chunk[A]]

implicit final class RefineToOrDieOps[R, E <: Throwable, A] extends AnyVal

sealed trait TerminationStrategy extends AnyRef

final class UpdateService[-R, +E, +A, M] extends AnyVal

trait ZStreamConstructor[Input] extends AnyRef

trait ZStreamConstructorLowPriority1 extends ZStreamConstructorLowPriority2

trait ZStreamConstructorLowPriority2 extends ZStreamConstructorLowPriority3

trait ZStreamConstructorLowPriority3 extends AnyRef

trait ZStreamConstructorPlatformSpecific extends ZStreamConstructorLowPriority1

type Take[+E, +A] = Exit[Option[E], Chunk[A]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val DefaultChunkSize: Int(4096)

object Take

object TerminationStrategy

object ZStreamConstructor extends ZStreamConstructorPlatformSpecific

def absolve[R, E, O](xs: ZStream[R, E, Either[E, O]]): ZStream[R, E, O]

def access[R]: AccessPartiallyApplied[R]

def accessStream[R]: AccessStreamPartiallyApplied[R]

def accessZIO[R]: AccessZIOPartiallyApplied[R]

def acquireReleaseExitWith[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) ⇒ URIO[R, Any]): ZStream[R, E, A]

def acquireReleaseWith[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ URIO[R, Any]): ZStream[R, E, A]

def apply[A](as: A*): ZStream[Any, Nothing, A]

final def asInstanceOf[T0]: T0

def async[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ Unit, outputBuffer: Int = 16): ZStream[R, E, A]

def asyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ Either[Canceler[R], ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

def asyncMaybe[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ Option[ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

def asyncZIO[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ ZIO[R, E, Any], outputBuffer: Int = 16): ZStream[R, E, A]

def blocking[R, E, A](stream: ZStream[R, E, A]): ZStream[R, E, A]

def clone(): AnyRef

def concatAll[R, E, O](streams: Chunk[ZStream[R, E, O]]): ZStream[R, E, O]

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]

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]

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]

def die(ex: ⇒ Throwable): ZStream[Any, Nothing, Nothing]

def dieMessage(msg: ⇒ String): ZStream[Any, Nothing, Nothing]

def done[E, A](exit: Exit[E, A]): ZStream[Any, E, A]

val empty: ZStream[Any, Nothing, Nothing]

def environment[R]: ZStream[R, Nothing, R]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[E](error: ⇒ E): ZStream[Any, E, Nothing]

def failCause[E](cause: ⇒ Cause[E]): ZStream[Any, E, Nothing]

def finalize(): Unit

def finalizer[R](finalizer: URIO[R, Any]): ZStream[R, Nothing, Any]

def from[Input](input: ⇒ Input)(implicit constructor: ZStreamConstructor[Input]): Out

def fromChunk[O](c: ⇒ Chunk[O]): ZStream[Any, Nothing, O]

def fromChunkHub[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

def fromChunkHubManaged[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZManaged[Any, Nothing, ZStream[R, E, O]]

def fromChunkHubManagedWithShutdown[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZManaged[Any, Nothing, ZStream[R, E, O]]

def fromChunkHubWithShutdown[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

def fromChunkQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

def fromChunkQueueWithShutdown[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

def fromChunks[O](cs: Chunk[O]*): ZStream[Any, Nothing, O]

def fromHub[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, A]

def fromHubManaged[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZManaged[Any, Nothing, ZStream[R, E, A]]

def fromHubManagedWithShutdown[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZManaged[Any, Nothing, ZStream[R, E, A]]

def fromHubWithShutdown[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, A]

def fromIterable[O](as: ⇒ Iterable[O]): ZStream[Any, Nothing, O]

def fromIterableZIO[R, E, O](iterable: ZIO[R, E, Iterable[O]]): ZStream[R, E, O]

def fromIterator[A](iterator: ⇒ Iterator[A]): ZStream[Any, Throwable, A]

def fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

def fromIteratorSucceed[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

def fromIteratorZIO[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

def fromJavaIterator[A](iterator: ⇒ Iterator[A]): ZStream[Any, Throwable, A]

def fromJavaIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

def fromJavaIteratorSucceed[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

def fromJavaIteratorZIO[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

def fromPull[R, E, A](zio: ZManaged[R, Nothing, ZIO[R, Option[E], Chunk[A]]]): ZStream[R, E, A]