ZStream

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Connection

final val DefaultChunkSize: Int(4096)

The default chunk size used by the various combinators and constructors of ZStream.

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

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

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

Creates a stream from an asynchronous callback that can be called multiple times.

def asyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], Chunk[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.

def asyncMaybe[R, E, A](register: ((ZIO[R, Option[E], Chunk[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.

def asyncZIO[R, E, A](register: ((ZIO[R, Option[E], Chunk[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.

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.

def clone(): AnyRef

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.

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.

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.

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

def equals(arg0: Any): Boolean

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

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

Constructs a ZStream value of the appropriate type for the specified input.

def fromBlockingIterator[A](iterator: ⇒ Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Throwable, A]

Creates a stream from an blocking iterator that may throw exceptions.

def fromBlockingJavaIterator[A](iter: ⇒ Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Throwable, A]

Creates a stream from an blocking Java iterator that may throw exceptions.

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

Creates a stream from a zio.Chunk 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.

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.

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.

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.

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

Creates a stream from an arbitrary number of chunks.

def fromFile(path: ⇒ Path, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Any, Throwable, Byte]

Creates a stream of bytes from a file at the specified path.

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.

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.

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.

def fromInputStream(is: ⇒ InputStream, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Any, IOException, Byte]

Creates a stream from a java.io.InputStream.

def fromInputStreamManaged[R](is: ZManaged[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Byte]

Creates a stream from a managed java.io.InputStream value.

def fromInputStreamZIO[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Byte]

Creates a stream from a java.io.InputStream.

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], maxChunkSize: Int = 1): ZStream[Any, Throwable, A]

Creates a stream from an iterator that may throw exceptions.

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], maxChunkSize: Int = 1): ZStream[Any, Nothing, A]

Creates a stream from an iterator that does not throw exceptions.

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

final def fromJavaStream[A](stream: ⇒ java.util.stream.Stream[A]): ZStream[Any, Throwable, A]

Creates a stream from a Java stream

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

final def fromJavaStreamSucceed[A](stream: ⇒ java.util.stream.Stream[A]): ZStream[Any, Nothing, A]

Creates a stream from a Java stream

final def fromJavaStreamZIO[R, A](stream: ZIO[R, Throwable, java.util.stream.Stream[A]]): ZStream[R, Throwable, A]

Creates a stream from a Java stream

def fromOutputStreamWriter(write: (OutputStream) ⇒ Unit, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Any, Throwable, Byte]

Creates a stream from a callback that writes to java.io.OutputStream.

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

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.

def fromReader(reader: ⇒ Reader, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Any, IOException, Char]

Creates a stream from java.io.Reader.

def fromReaderManaged[R](reader: ⇒ ZManaged[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Char]

Creates a stream from managed java.io.Reader.

def fromReaderZIO[R](reader: ⇒ ZIO[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Char]

Creates a stream from an effect producing java.io.Reader.

final def fromResource(path: String, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Any, IOException, Byte]

Creates a stream from the resource specified in path

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.

def fromSocketServer(port: Int, host: Option[String] = None): ZStream[Any, 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 used

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[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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.

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

val never: ZStream[Any, Nothing, Nothing]

The stream that never produces any value or fails with any error.

final def notify(): Unit

final def notifyAll(): Unit

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.

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.

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.

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.

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 serviceWith[Service]: ServiceWithPartiallyApplied[Service]

Effectfully 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

def tick(interval: zio.Duration): ZStream[Has[Clock], Nothing, Unit]

A stream that emits Unit values spaced by the specified duration.

def toString(): String

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

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

final def wait(arg0: Long): Unit

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 whenCaseZIO[R, E, A](a: ZIO[R, E, A]): WhenCaseZIO[R, E, A]

Returns the resulting stream when the given PartialFunction is defined for the given effectful value, otherwise returns an empty stream.

def whenZIO[R, E](b: ZIO[R, E, Boolean]): WhenZIO[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.

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.

def accessM[R]: AccessZIOPartiallyApplied[R]

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

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 effectAsync[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Unit) ⇒ Unit, outputBuffer: Int = 16): ZStream[R, E, A]

Creates a stream from an asynchronous callback that can be called multiple times.

def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], Chunk[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.

def effectAsyncM[R, E, A](register: ((ZIO[R, Option[E], Chunk[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.

def effectAsyncMaybe[R, E, A](register: ((ZIO[R, Option[E], Chunk[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.

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 fromInputStreamEffect[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Byte]

Creates a stream from a java.io.InputStream.

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 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 fromIteratorTotal[A](iterator: ⇒ Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Nothing, A]

Creates a stream from an iterator that does not 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 fromJavaIteratorTotal[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

Creates a stream from a Java iterator

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

final def fromJavaStreamTotal[A](stream: ⇒ java.util.stream.Stream[A]): ZStream[Any, Nothing, A]

Creates a stream from a Java stream

def fromReaderEffect[R](reader: ⇒ ZIO[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Char]

Creates a stream from an effect producing java.io.Reader.

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

The stream that always halts with cause.

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.

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.

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 Has[Clock], E, A]

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

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

def whenCaseM[R, E, A](a: ZIO[R, E, A]): WhenCaseZIO[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]): WhenZIO[R, E]

Returns the specified stream if the given effectful condition is satisfied, otherwise returns an empty stream.