ZStream

Type Members

type Fold[R, E, +A, S] = ZManaged[R, Nothing, (S, (S) ⇒ Boolean, (S, A) ⇒ ZIO[R, E, S]) ⇒ ZManaged[R, E, S]]
implicit final class unTake[-R, +E, +A] extends AnyVal

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 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
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 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 a stream that emits no elements, never fails and executes the finalizer before 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: Long, 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 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 TaskR value to create a ZStream of byte chunks, backed by the resulting InputStream.
Uses the provided TaskR 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 fromQueue[R, E, A](queue: ZQueue[_, _, R, E, _, A]): ZStream[R, E, A]

Creates a stream from a zio.ZQueue of values
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 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: Long, 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 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 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 succeedLazy[A](a: ⇒ A): Stream[Nothing, A]

Creates a single, lazily-evaluated-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 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 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( ... )

Related Docs: trait ZStream | package stream

object ZStream extends ZStreamPlatformSpecific with Serializable

Type Members

type Fold[R, E, +A, S] = ZManaged[R, Nothing, (S, (S) ⇒ Boolean, (S, A) ⇒ ZIO[R, E, S]) ⇒ ZManaged[R, E, S]]

implicit final class unTake[-R, +E, +A] extends AnyVal

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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]

def clone(): AnyRef

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

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

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: Long, 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 fromQueue[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 managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]

final def mergeAll[R, E, A](n: Long, 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 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 succeedLazy[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 def unwrap[R, E, A](fa: ZIO[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

Inherited from Serializable

Inherited from Serializable

Inherited from ZStreamPlatformSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped