ZStream

Type Members

final class AccessPartiallyApplied[R] extends AnyVal
final class AccessStreamPartiallyApplied[R] extends AnyVal
final class AccessZIOPartiallyApplied[R] extends AnyVal
final class Connection extends AnyRef

Accepted connection made to a specific channel AsynchronousServerSocketChannel
Accepted connection made to a specific channel AsynchronousServerSocketChannel

Definition Classes
ZStreamPlatformSpecificConstructors
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 type ZIO[R, Option[E], Chunk[A]], where succeeding with a Chunk[A] indicates to emit those elements, failing with Some[E] indicates to terminate with that error, and failing with None indicates to terminate with an end of stream signal.
sealed trait 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.
implicit final class PipelineSyntax[Env, Err, Elem] extends AnyVal

Provides syntax for applying pipelines to streams.
final class ProvideSomeServices[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
final class ServiceAtPartiallyApplied[Service] 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, +A, M] extends AnyVal
final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal
final class WhenCaseZIO[R, E, A] extends AnyVal
final class WhenZIO[R, E] 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
object Connection

Definition Classes
ZStreamPlatformSpecificConstructors
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]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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*)(implicit trace: ZTraceElement): 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: (Emit[R, E, A, Unit]) ⇒ Unit, outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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: (Emit[R, E, A, Unit]) ⇒ Either[Canceler[R], ZStream[R, E, A]], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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 asyncManaged[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Unit) ⇒ ZManaged[R, E, Any], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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 to None.

Definition Classes
ZStreamPlatformSpecificConstructors
def asyncMaybe[R, E, A](register: (Emit[R, E, A, Unit]) ⇒ Option[ZStream[R, E, A]], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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: (Emit[R, E, A, Unit]) ⇒ ZIO[R, E, Any], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): ZStream[R, E, O]

Concatenates all of the streams in the chunk to one stream.
def die(ex: ⇒ Throwable)(implicit trace: ZTraceElement): ZStream[Any, Nothing, Nothing]

The stream that dies with the ex.
def dieMessage(msg: ⇒ String)(implicit trace: ZTraceElement): ZStream[Any, Nothing, Nothing]

The stream that dies with an exception described by msg.
def done[E, A](exit: Exit[E, A])(implicit trace: ZTraceElement): ZStream[Any, E, A]

The stream that ends with the zio.Exit value exit.
def empty(implicit trace: ZTraceElement): ZStream[Any, Nothing, Nothing]

The empty stream
def environment[R](implicit trace: ZTraceElement): 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 execute[R, E](zio: ZIO[R, E, Any])(implicit trace: ZTraceElement): ZStream[R, E, Nothing]

Creates a stream that executes the specified effect but emits no elements.
def fail[E](error: ⇒ E)(implicit trace: ZTraceElement): ZStream[Any, E, Nothing]

The stream that always fails with the error
def failCause[E](cause: ⇒ Cause[E])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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], trace: ZTraceElement): Out
def fromChunk[O](c0: ⇒ Chunk[O])(implicit trace: ZTraceElement): ZStream[Any, Nothing, O]

Creates a stream from a zio.Chunk of values
Creates a stream from a zio.Chunk of values
returns
a finite stream of values
def fromChunkHub[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]*)(implicit trace: ZTraceElement): ZStream[Any, Nothing, O]

Creates a stream from an arbitrary number of chunks.
def fromFile(path: ⇒ Path, chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[Any, 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): ZStream[Any, IOException, Byte]

Creates a stream from a java.io.InputStream
def fromInputStreamManaged[R](is: ZManaged[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): ZStream[R, 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.
def fromIterable[O](as: ⇒ Iterable[O])(implicit trace: ZTraceElement): ZStream[Any, Nothing, O]

Creates a stream from an iterable collection of values
def fromIterableZIO[R, E, O](iterable: ZIO[R, E, Iterable[O]])(implicit trace: ZTraceElement): 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 = DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[Any, Throwable, A]
def fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]], maxChunkSize: Int = DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[R, Throwable, A]

Creates a stream from a managed iterator
def fromIteratorSucceed[A](iterator: ⇒ Iterator[A], maxChunkSize: Int = DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[Any, Nothing, A]

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

Creates a stream from an iterator that may potentially throw exceptions
def fromJavaIterator[A](iterator: ⇒ Iterator[A])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): ZStream[R, Throwable, A]

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

Creates a stream from a Java iterator
def fromJavaIteratorZIO[R, A](iterator: ZIO[R, Throwable, Iterator[A]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): ZStream[Any, 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]])(implicit trace: ZTraceElement): 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 fromJavaStreamSucceed[R, A](stream: ⇒ java.util.stream.Stream[A])(implicit trace: ZTraceElement): ZStream[R, Nothing, A]

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

Definition Classes
ZStreamPlatformSpecificConstructors
final def fromJavaStreamZIO[R, A](stream: ZIO[R, Throwable, java.util.stream.Stream[A]])(implicit trace: ZTraceElement): ZStream[R, Throwable, 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)(implicit trace: ZTraceElement): ZStream[Any, 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 the write is done.

Definition Classes
ZStreamPlatformSpecificConstructors
def fromPull[R, E, A](zio: ZManaged[R, Nothing, ZIO[R, Option[E], Chunk[A]]])(implicit trace: ZTraceElement): ZStream[R, E, A]
def fromQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O], maxChunkSize: Int = DefaultChunkSize)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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 fromReader(reader: ⇒ Reader, chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[Any, IOException, Char]

Creates a stream from java.io.Reader.
Creates a stream from java.io.Reader.

Definition Classes
ZStreamPlatformSpecificConstructors
def fromReaderManaged[R](reader: ⇒ ZManaged[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[R, IOException, Char]

Creates a stream from managed java.io.Reader.
Creates a stream from managed java.io.Reader.

Definition Classes
ZStreamPlatformSpecificConstructors
def fromReaderZIO[R](reader: ⇒ ZIO[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[R, 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
final def fromResource(path: String, chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[Any, 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])(implicit trace: ZTraceElement): 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 fromSocketServer(port: Int, host: Option[String] = None)(implicit trace: ZTraceElement): 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
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

Definition Classes
ZStreamPlatformSpecificConstructors
def fromTQueue[A](queue: TQueue[A])(implicit trace: ZTraceElement): ZStream[Any, Nothing, A]

Creates a stream from a zio.stm.TQueue of values.
def fromZIO[R, E, A](fa: ZIO[R, E, A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]*)(implicit trace: ZTraceElement): 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]*)(implicit trace: ZTraceElement): ZStream[R, E, O]

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

Definition Classes
AnyRef
def never(implicit trace: ZTraceElement): 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]))(implicit trace: ZTraceElement): 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]))(implicit trace: ZTraceElement): 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])])(implicit trace: ZTraceElement): 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])])(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): ZStream[Any, Nothing, Int]

Constructs a stream from a range of integers (lower bound included, upper bound not included)
def repeat[A](a: ⇒ A)(implicit trace: ZTraceElement): ZStream[Any, Nothing, A]

Repeats the provided value infinitely.
def repeatWithSchedule[R, A](a: ⇒ A, schedule: Schedule[R, A, _])(implicit trace: ZTraceElement): ZStream[R with Has[Clock], Nothing, A]

Repeats the value using the provided schedule.
def repeatZIO[R, E, A](fa: ZIO[R, E, A])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): ZStream[R, E, A]

Creates a stream from an effect producing values of type A until it fails with None.
def repeatZIOWithSchedule[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any])(implicit trace: ZTraceElement): 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], trace: ZTraceElement): ZStream[Has[A], Nothing, A]

Accesses the specified service in the environment of the effect.
def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

Accesses the service corresponding to the specified key in the environment.
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 succeed[A](a: ⇒ A)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)])(implicit trace: ZTraceElement): 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)])(implicit trace: ZTraceElement): 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)]])(implicit trace: ZTraceElement): 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)]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): ZStream[R, E, A]

Creates a stream produced from an effect
def unwrapManaged[R, E, A](fa: ZManaged[R, E, ZStream[R, E, A]])(implicit trace: ZTraceElement): 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 when[R, E, O](b: ⇒ Boolean)(zStream: ⇒ ZStream[R, E, O])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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.

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])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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 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)(implicit trace: ZTraceElement): 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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use cross
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)(implicit trace: ZTraceElement): 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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use cross
def crossN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) ⇒ C)(implicit trace: ZTraceElement): 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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use cross
def effectAsync[R, E, A](register: (Emit[R, E, A, Unit]) ⇒ Unit, outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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: (Emit[R, E, A, Unit]) ⇒ Either[Canceler[R], ZStream[R, E, A]], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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: (Emit[R, E, A, Unit]) ⇒ ZIO[R, E, Any], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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: (Emit[R, E, A, Unit]) ⇒ Option[ZStream[R, E, A]], outputBuffer: Int = 16)(implicit trace: ZTraceElement): 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 fromBlockingIterator[A](iterator: ⇒ Iterator[A])(implicit trace: ZTraceElement): ZStream[Any, Throwable, A]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use blocking(fromIterator())
def fromBlockingJavaIterator[A](iter: ⇒ Iterator[A])(implicit trace: ZTraceElement): ZStream[Any, 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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use blocking(fromJavaIterator())
def fromEffect[R, E, A](fa: ZIO[R, E, A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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 fromInputStreamEffect[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[R, 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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromInputStreamZIO
def fromIterableM[R, E, O](iterable: ZIO[R, E, Iterable[O]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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], maxChunkSize: Int = DefaultChunkSize)(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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
final def fromJavaStreamEffect[R, A](stream: ZIO[R, Throwable, java.util.stream.Stream[A]])(implicit trace: ZTraceElement): ZStream[R, Throwable, A]

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

Definition Classes
ZStreamPlatformSpecificConstructors
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromJavaStreamZIO
final def fromJavaStreamTotal[A](stream: ⇒ java.util.stream.Stream[A])(implicit trace: ZTraceElement): ZStream[Any, Nothing, A]

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

Definition Classes
ZStreamPlatformSpecificConstructors
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromJavaStreamSucceed
def fromReaderEffect[R](reader: ⇒ ZIO[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize)(implicit trace: ZTraceElement): ZStream[R, 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
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromReaderZIO
def halt[E](cause: ⇒ Cause[E])(implicit trace: ZTraceElement): 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])])(implicit trace: ZTraceElement): 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])])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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 repeatWith[R, A](a: ⇒ A, schedule: Schedule[R, A, _])(implicit trace: ZTraceElement): ZStream[R with Has[Clock], Nothing, A]

Repeats the value using the provided schedule.
Repeats the value using the provided schedule.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use repeatWithSchedule
def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D], trace: ZTraceElement): 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.
Accesses the specified services in the environment of the effect.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use service
def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], trace: ZTraceElement): ZStream[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]

Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use service
def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], trace: ZTraceElement): ZStream[Has[A] with Has[B], Nothing, (A, B)]

Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use service
def unfoldChunkM[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, Option[(Chunk[A], S)]])(implicit trace: ZTraceElement): 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)]])(implicit trace: ZTraceElement): 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
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.
Returns the resulting stream when the given PartialFunction is defined for the given effectful value, otherwise returns an empty stream.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use whenCaseZIO
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.
Returns the specified stream if the given effectful condition is satisfied, otherwise returns an empty stream.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use whenZIO
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)(implicit trace: ZTraceElement): 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.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zip
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)(implicit trace: ZTraceElement): ZStream[R, E, D]

Zips with specified streams together with the specified function.
Zips with specified streams together with the specified function.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zip
def zipN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) ⇒ C)(implicit trace: ZTraceElement): ZStream[R, E, C]

Zips the specified streams together with the specified function.
Zips the specified streams together with the specified function.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zip

Related Docs: class ZStream | package stream

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 Connection extends AnyRef

trait Emit[+R, -E, -A, +B] extends (ZIO[R, Option[E], Chunk[A]]) ⇒ B

sealed trait GroupBy[-R, +E, +K, +V] extends AnyRef

implicit final class PipelineSyntax[Env, Err, Elem] extends AnyVal

final class ProvideSomeServices[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

final class ServiceAtPartiallyApplied[Service] extends AnyVal

final class ServiceWithPartiallyApplied[Service] extends AnyVal

final class ServiceWithStreamPartiallyApplied[Service] extends AnyVal

implicit final class SortedByKey[R, E, K, A] extends AnyRef

implicit final class SyntaxOps[-R, +E, O] extends AnyRef

sealed trait TerminationStrategy extends AnyRef

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

final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal

final class WhenCaseZIO[R, E, A] extends AnyVal

final class WhenZIO[R, E] 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

object Connection

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]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): ZStream[R, E, A]

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

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

final def asInstanceOf[T0]: T0

def async[R, E, A](register: (Emit[R, E, A, Unit]) ⇒ Unit, outputBuffer: Int = 16)(implicit trace: ZTraceElement): ZStream[R, E, A]

def asyncInterrupt[R, E, A](register: (Emit[R, E, A, Unit]) ⇒ Either[Canceler[R], ZStream[R, E, A]], outputBuffer: Int = 16)(implicit trace: ZTraceElement): ZStream[R, E, A]

def asyncManaged[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Unit) ⇒ ZManaged[R, E, Any], outputBuffer: Int = 16)(implicit trace: ZTraceElement): ZStream[R, E, A]

def asyncMaybe[R, E, A](register: (Emit[R, E, A, Unit]) ⇒ Option[ZStream[R, E, A]], outputBuffer: Int = 16)(implicit trace: ZTraceElement): ZStream[R, E, A]

def asyncZIO[R, E, A](register: (Emit[R, E, A, Unit]) ⇒ ZIO[R, E, Any], outputBuffer: Int = 16)(implicit trace: ZTraceElement): ZStream[R, E, A]

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

def clone(): AnyRef

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

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

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

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

def empty(implicit trace: ZTraceElement): ZStream[Any, Nothing, Nothing]

def environment[R](implicit trace: ZTraceElement): ZStream[R, Nothing, R]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute[R, E](zio: ZIO[R, E, Any])(implicit trace: ZTraceElement): ZStream[R, E, Nothing]

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

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

def finalize(): Unit

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

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

def fromChunk[O](c0: ⇒ Chunk[O])(implicit trace: ZTraceElement): ZStream[Any, Nothing, O]

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

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

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

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

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

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

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

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

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

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

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