ZStream

Type Members

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.
type Pull[-R, +E, +A] = ZIO[R, Option[E], A]

Describes an effectful pull from a stream.
Describes an effectful pull from a stream. The optionality of the error channel denotes normal termination of the stream when None and an error when Some(e: E).

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
object GroupBy
object Pull
final def apply[R, E, A](pull: ZManaged[R, E, Pull[R, E, A]]): ZStream[R, E, A]

Creates a stream from a scoped Pull.
final def apply[A](as: A*): Stream[Nothing, A]

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

Definition Classes
Any
final def bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, _]): ZStream[R, E, A]

Creates a stream from a single value that will get cleaned up after the stream is consumed
final def bracketExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[_, _]) ⇒ ZIO[R, Nothing, _]): 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[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def die(ex: Throwable): Stream[Nothing, Nothing]

The stream that always dies with ex.
final def dieMessage(msg: String): Stream[Nothing, Nothing]

The stream that always dies with an exception described by msg.
final def effectAsync[R, E, A](register: ((ZIO[R, Option[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 to None.
final def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Either[Canceler, 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.
final def effectAsyncM[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ ZIO[R, E, _], 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.
final def effectAsyncMaybe[R, E, A](register: ((ZIO[R, Option[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 to None.
final val empty: Stream[Nothing, Nothing]

The empty stream
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

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

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

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def finalizer[R](finalizer: ZIO[R, Nothing, _]): ZStream[R, Nothing, Nothing]

Creates an empty stream that never fails and executes the finalizer when it ends.
final def flatten[R, E, A](fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

Flattens nested streams.
final def flattenPar[R, E, A](n: Int, outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

Flattens a stream of streams into a stream by executing a non-deterministic concurrent merge.
Flattens a stream of streams into a stream by executing a non-deterministic concurrent merge. Up to n streams may be consumed in parallel and up to outputBuffer elements may be buffered by this operator.
final def flattenParUnbounded[R, E, A](outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

Like flattenPar, but executes all streams concurrently.
final def fromChunk[A](c: Chunk[A]): Stream[Nothing, A]

Creates a stream from a zio.Chunk of values
final 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 fromInputStream(is: InputStream, chunkSize: Int = ZStreamChunk.DefaultChunkSize): ZStreamChunk[Blocking, IOException, Byte]

Uses the provided RIO value to create a ZStream of byte chunks, backed by the resulting InputStream.
Uses the provided RIO value to create a ZStream of byte chunks, backed by the resulting InputStream. When data from the InputStream is exhausted, the stream will close it.

Definition Classes
ZStreamPlatformSpecific
final def fromIterable[A](as: Iterable[A]): Stream[Nothing, A]

Creates a stream from an iterable collection of values
final def fromIterator[R, E, A](iterator: ZIO[R, E, Iterator[A]]): ZStream[R, E, A]

Creates a stream from an iterator
final def fromIteratorManaged[R, E, A](iterator: ZManaged[R, E, Iterator[A]]): ZStream[R, E, A]

Creates a stream from an iterator
final def fromPull[R, E, A](pull: Pull[R, E, A]): ZStream[R, E, A]

Creates a stream from a Pull.
final def fromQueue[R, E, A](queue: ZQueue[_, _, R, E, _, A]): ZStream[R, E, A]

Creates a stream from a zio.ZQueue of values
final def fromQueueWithShutdown[R, E, A](queue: ZQueue[_, _, R, E, _, A]): ZStream[R, E, A]

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.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def halt[E](cause: Cause[E]): ZStream[Any, E, Nothing]

The stream that always halts with cause.
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final 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))), ...
final def managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]

Creates a single-valued stream from a managed resource
final def mergeAll[R, E, A](n: Int, outputBuffer: Int = 16)(streams: ZStream[R, E, A]*): ZStream[R, E, A]

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 elements may be buffered by this operator.
final def mergeAllUnbounded[R, E, A](outputBuffer: Int = 16)(streams: ZStream[R, E, A]*): ZStream[R, E, A]

Like mergeAll, but runs all streams concurrently.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final val never: Stream[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
final def paginate[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.
final def range(min: Int, max: Int): Stream[Nothing, Int]

Constructs a stream from a range of integers (inclusive).
final 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
final def repeatEffectWith[R, E, A](fa: ZIO[R, E, A], schedule: ZSchedule[R, Unit, _]): ZStream[R with Clock, E, A]

Creates a stream from an effect producing a value of type A which repeats using the specified schedule
final def succeed[A](a: A): Stream[Nothing, A]

Creates a single-valued pure stream
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def unfold[S, A](s: S)(f0: (S) ⇒ Option[(A, S)]): Stream[Nothing, A]

Creates a stream by peeling off the "layers" of a value of type S
final def unfoldM[R, E, A, S](s: S)(f0: (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
final val unit: Stream[Nothing, Unit]

The stream of units
final def unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

Creates a stream produced from an effect
final 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( ... )

Deprecated Value Members

final def succeedLazy[A](a: ⇒ A): Stream[Nothing, A]

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use succeed

Related Docs: class ZStream | package stream

object ZStream extends ZStreamPlatformSpecific with Serializable

Type Members

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

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

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object GroupBy

object Pull

final def apply[R, E, A](pull: ZManaged[R, E, Pull[R, E, A]]): ZStream[R, E, A]

final def apply[A](as: A*): Stream[Nothing, A]

final def asInstanceOf[T0]: T0

final def bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, _]): ZStream[R, E, A]

final def bracketExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[_, _]) ⇒ ZIO[R, Nothing, _]): ZStream[R, E, A]

def clone(): AnyRef

final def die(ex: Throwable): Stream[Nothing, Nothing]

final def dieMessage(msg: String): Stream[Nothing, Nothing]

final def effectAsync[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Unit, outputBuffer: Int = 16): ZStream[R, E, A]

final def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Either[Canceler, ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

final def effectAsyncM[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ ZIO[R, E, _], outputBuffer: Int = 16): ZStream[R, E, A]

final def effectAsyncMaybe[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Option[ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

final val empty: Stream[Nothing, Nothing]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fail[E](error: E): Stream[E, Nothing]

def finalize(): Unit

final def finalizer[R](finalizer: ZIO[R, Nothing, _]): ZStream[R, Nothing, Nothing]

final def flatten[R, E, A](fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

final def flattenPar[R, E, A](n: Int, outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

final def flattenParUnbounded[R, E, A](outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

final def fromChunk[A](c: Chunk[A]): Stream[Nothing, A]

final def fromEffect[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]

def fromInputStream(is: InputStream, chunkSize: Int = ZStreamChunk.DefaultChunkSize): ZStreamChunk[Blocking, IOException, Byte]

final def fromIterable[A](as: Iterable[A]): Stream[Nothing, A]

final def fromIterator[R, E, A](iterator: ZIO[R, E, Iterator[A]]): ZStream[R, E, A]

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

final def fromPull[R, E, A](pull: Pull[R, E, A]): ZStream[R, E, A]

final def fromQueue[R, E, A](queue: ZQueue[_, _, R, E, _, A]): ZStream[R, E, A]

final def fromQueueWithShutdown[R, E, A](queue: ZQueue[_, _, R, E, _, A]): ZStream[R, E, A]

final def getClass(): Class[_]

final def halt[E](cause: Cause[E]): ZStream[Any, E, Nothing]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def iterate[A](a: A)(f: (A) ⇒ A): ZStream[Any, Nothing, A]

final def managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]

final def mergeAll[R, E, A](n: Int, outputBuffer: Int = 16)(streams: ZStream[R, E, A]*): ZStream[R, E, A]

final def mergeAllUnbounded[R, E, A](outputBuffer: Int = 16)(streams: ZStream[R, E, A]*): ZStream[R, E, A]

final def ne(arg0: AnyRef): Boolean

final val never: Stream[Nothing, Nothing]

final def notify(): Unit

final def notifyAll(): Unit

final def paginate[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (A, Option[S])]): ZStream[R, E, A]

final def range(min: Int, max: Int): Stream[Nothing, Int]

final def repeatEffect[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]

final def repeatEffectWith[R, E, A](fa: ZIO[R, E, A], schedule: ZSchedule[R, Unit, _]): ZStream[R with Clock, E, A]

final def succeed[A](a: A): Stream[Nothing, A]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def unfold[S, A](s: S)(f0: (S) ⇒ Option[(A, S)]): Stream[Nothing, A]

final def unfoldM[R, E, A, S](s: S)(f0: (S) ⇒ ZIO[R, E, Option[(A, S)]]): ZStream[R, E, A]

final val unit: Stream[Nothing, Unit]

final def unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

final def unwrapManaged[R, E, A](fa: ZManaged[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Deprecated Value Members

final def succeedLazy[A](a: ⇒ A): Stream[Nothing, A]

Inherited from Serializable

Inherited from Serializable

Inherited from ZStreamPlatformSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped