object ZStream extends ZStreamPlatformSpecificConstructors
- Alphabetic
- By Inheritance
- ZStream
- ZStreamPlatformSpecificConstructors
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- final class AccessMPartiallyApplied[R] extends AnyVal
- final class AccessPartiallyApplied[R] extends AnyVal
- final class AccessStreamPartiallyApplied[R] extends AnyVal
-
final
class
GroupBy[-R, +E, +K, +V] extends AnyRef
Representation of a grouped stream.
Representation of a grouped stream. This allows to filter which groups will be processed. Once this is applied all groups will be processed in parallel and the results will be merged in arbitrary order.
- final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
- type Pull[-R, +E, +O] = ZIO[R, Option[E], Chunk[O]]
- sealed trait TerminationStrategy extends AnyRef
-
type
Take[+E, +A] = Exit[Option[E], Chunk[A]]
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use zio.stream.Take instead
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
val
DefaultChunkSize: Int(4096)
The default chunk size used by the various combinators and constructors of ZStream.
-
def
absolve[R, E, O](xs: ZStream[R, E, Either[E, O]]): ZStream[R, E, O]
Submerges the error case of an
Either
into theZStream
. -
def
access[R]: AccessPartiallyApplied[R]
Accesses the environment of the stream.
-
def
accessM[R]: AccessMPartiallyApplied[R]
Accesses the environment of the stream in the context of an effect.
-
def
accessStream[R]: AccessStreamPartiallyApplied[R]
Accesses the environment of the stream in the context of a stream.
-
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
- Definition Classes
- Any
-
def
bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, 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]) ⇒ ZIO[R, Nothing, Any]): 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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
concatAll[R, E, O](streams: Chunk[ZStream[R, E, O]]): ZStream[R, E, O]
Concatenates all of the streams in the chunk to one stream.
-
def
crossN[R, E, A, B, C, D, F](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C], zStream4: ZStream[R, E, D])(f: (A, B, C, D) ⇒ F): ZStream[R, E, F]
Composes the specified streams to create a cartesian product of elements with a specified function.
Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent stream would be run multiple times, for every combination of elements in the prior streams.
See also ZStream#zipN[R,E,A,B,C,D,F]* for the more common point-wise variant.
-
def
crossN[R, E, A, B, C, D](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C])(f: (A, B, C) ⇒ D): ZStream[R, E, D]
Composes the specified streams to create a cartesian product of elements with a specified function.
Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent stream would be run multiple times, for every combination of elements in the prior streams.
See also ZStream#zipN[R,E,A,B,C,D]* for the more common point-wise variant.
-
def
crossN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) ⇒ C): ZStream[R, E, C]
Composes the specified streams to create a cartesian product of elements with a specified function.
Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent streams would be run multiple times, for every combination of elements in the prior streams.
See also ZStream#zipN[R,E,A,B,C]* for the more common point-wise variant.
-
def
die(ex: ⇒ Throwable): ZStream[Any, Nothing, Nothing]
The stream that dies with the
ex
. -
def
dieMessage(msg: ⇒ String): ZStream[Any, Nothing, Nothing]
The stream that dies with an exception described by
msg
. -
def
done[E, A](exit: Exit[E, A]): ZStream[Any, E, A]
The stream that ends with the zio.Exit value
exit
. -
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.
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 toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
-
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.
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 toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
-
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.
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 toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
-
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.
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 toNone
.- Definition Classes
- ZStreamPlatformSpecificConstructors
-
val
empty: ZStream[Any, Nothing, Nothing]
The empty stream
-
def
environment[R]: ZStream[R, Nothing, R]
Accesses the whole environment of the stream.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
fail[E](error: ⇒ E): ZStream[Any, E, Nothing]
The stream that always fails with the
error
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
finalizer[R](finalizer: ZIO[R, Nothing, Any]): ZStream[R, Nothing, Any]
Creates a one-element stream that never fails and executes the finalizer when it ends.
-
def
fromChunk[O](c: ⇒ Chunk[O]): ZStream[Any, Nothing, O]
Creates a stream from a zio.Chunk of values
Creates a stream from a zio.Chunk of values
- c
a chunk of values
- returns
a finite stream of values
-
def
fromChunkQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]
Creates a stream from a zio.ZQueue 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 zio.ZQueue of values.
Creates a stream from a zio.ZQueue of values. The queue will be shutdown once the stream is closed.
-
def
fromChunks[O](cs: Chunk[O]*): ZStream[Any, Nothing, O]
Creates a stream from an arbitrary number of chunks.
-
def
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
fromFile(path: ⇒ Path, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, 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
fromInputStream(is: ⇒ InputStream, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, IOException, Byte]
Creates a stream from a java.io.InputStream Note: the input stream will not be explicitly closed after it is exhausted.
Creates a stream from a java.io.InputStream Note: the input stream will not be explicitly closed after it is exhausted.
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
def
fromInputStreamEffect[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, 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.
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
def
fromInputStreamManaged[R](is: ZManaged[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, IOException, Byte]
Creates a stream from a managed java.io.InputStream value.
Creates a stream from a managed java.io.InputStream value.
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
def
fromIterable[O](as: ⇒ Iterable[O]): ZStream[Any, Nothing, O]
Creates a stream from an iterable collection of values
-
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 fromIterator[A](iterator: ⇒ Iterator[A]): ZStream[Any, Throwable, 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
fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]
Creates a stream from a managed iterator
-
def
fromIteratorTotal[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]
Creates a stream from an iterator
-
def
fromJavaIterator[A](iterator: ⇒ Iterator[A]): ZStream[Any, Throwable, A]
Creates a stream from a Java iterator that may 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
fromJavaIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]
Creates a stream from a managed iterator
-
def
fromJavaIteratorTotal[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]
Creates a stream from a Java iterator
-
final
def
fromJavaStream[R, A](stream: ⇒ java.util.stream.Stream[A]): ZStream[R, Throwable, A]
Creates a stream from a Java stream
Creates a stream from a Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
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
Creates a stream from a Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
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
Creates a stream from a managed Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
final
def
fromJavaStreamTotal[A](stream: ⇒ java.util.stream.Stream[A]): ZStream[Any, Nothing, A]
Creates a stream from a Java stream
Creates a stream from a Java stream
- Definition Classes
- ZStreamPlatformSpecificConstructors
-
def
fromQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O]): ZStream[R, E, O]
Creates a stream from a zio.ZQueue of values
-
def
fromQueueWithShutdown[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O]): ZStream[R, E, O]
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.
-
def
fromSchedule[R, A](schedule: Schedule[R, Any, A]): ZStream[R, Nothing, A]
Creates a stream from a zio.Schedule that does not require any further input.
Creates a stream from a zio.Schedule that does not require any further input. The stream will emit an element for each value output from the schedule, continuing for as long as the schedule continues.
-
def
fromTQueue[A](queue: TQueue[A]): ZStream[Any, Nothing, A]
Creates a stream from a zio.stm.TQueue of values.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
halt[E](cause: ⇒ Cause[E]): ZStream[Any, E, Nothing]
The stream that always halts with
cause
. -
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
iterate[A](a: A)(f: (A) ⇒ A): ZStream[Any, Nothing, A]
The infinite stream of iterative function application: a, f(a), f(f(a)), f(f(f(a))), ...
-
def
managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]
Creates a single-valued stream from a managed resource
-
def
mergeAll[R, E, O](n: Int, outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]
Merges a variable list of streams in a non-deterministic fashion.
Merges a variable list of streams in a non-deterministic fashion. Up to
n
streams may be consumed in parallel and up tooutputBuffer
chunks may be buffered by this operator. -
def
mergeAllUnbounded[R, E, O](outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]
Like mergeAll, but runs all streams concurrently.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
val
never: ZStream[Any, Nothing, Nothing]
The stream that never produces any value or fails with any error.
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
paginate[R, E, A, S](s: S)(f: (S) ⇒ (A, Option[S])): ZStream[Any, Nothing, 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.
-
def
paginateM[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (A, Option[S])]): ZStream[R, E, A]
Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state.
Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state. This is useful for embedding paginated APIs, hence the name.
-
def
range(min: Int, max: Int): ZStream[Any, Nothing, Int]
Constructs a stream from a range of integers (lower bound included, upper bound not included)
-
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, _]): ZStream[R, E, A]
Creates a stream from an effect producing a value of type
A
which repeats using the specified schedule -
def
service[A](implicit arg0: zio.Tag[A]): ZStream[Has[A], Nothing, A]
Accesses the specified service in the environment of the effect.
-
def
services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): ZStream[Has[A] with Has[B] with Has[C] with Has[D], Nothing, (A, B, C, D)]
Accesses the specified services in the environment of the effect.
-
def
services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): ZStream[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]
Accesses the specified services in the environment of the effect.
-
def
services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): ZStream[Has[A] with Has[B], Nothing, (A, B)]
Accesses the specified services in the environment of the effect.
-
def
succeed[A](a: ⇒ A): ZStream[Any, Nothing, A]
Creates a single-valued pure stream
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unfold[S, A](s: S)(f0: (S) ⇒ Option[(A, S)]): ZStream[Any, Nothing, A]
Creates a stream by peeling off the "layers" of a value of type
S
-
def
unfoldChunkM[R, E, A, S](s: S)(f0: (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)(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
-
val
unit: ZStream[Any, Nothing, Unit]
A stream that contains a single
Unit
value. -
def
unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]]): ZStream[R, E, A]
Creates a stream produced from an effect
-
def
unwrapManaged[R, E, A](fa: ZManaged[R, E, ZStream[R, E, A]]): ZStream[R, E, A]
Creates a stream produced from a ZManaged
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
zipN[R, E, A, B, C, D, F](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C], zStream4: ZStream[R, E, D])(f: (A, B, C, D) ⇒ F): ZStream[R, E, F]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function.Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function. If any effect fails, then the other effects will be interrupted. -
def
zipN[R, E, A, B, C, D](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C])(f: (A, B, C) ⇒ D): ZStream[R, E, D]
Zips with specified streams together with the specified function.
-
def
zipN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) ⇒ C): ZStream[R, E, C]
Zips the specified streams together with the specified function.
- object Take
- object TerminationStrategy