Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##: Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  final val DefaultChunkSize: Int(4096)

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

5.  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.

6.  def access[R]: AccessPartiallyApplied[R]

   Accesses the environment of the stream.

7.  def accessM[R]: AccessMPartiallyApplied[R]

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

8.  def accessStream[R]: AccessStreamPartiallyApplied[R]

   Accesses the environment of the stream in the context of a stream.

9.  def apply[A](as: A*): ZStream[Any, Nothing, A]

   Creates a pure stream from a variable list of values

10.  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.

    Creates a new ZStream from a managed effect that yields chunks. The effect will be evaluated repeatedly until it fails with a None (to signify stream end) or a Some(E) (to signify stream failure).

    The stream evaluation guarantees proper acquisition and release of the ZManaged.

11.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

12.  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

13.  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

14.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.CloneNotSupportedException]) @native()

15.  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.

16.  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.

17.  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.

18.  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.

19.  def die(ex: => Throwable): ZStream[Any, Nothing, Nothing]

    The stream that dies with the ex.

20.  def dieMessage(msg: => String): ZStream[Any, Nothing, Nothing]

    The stream that dies with an exception described by msg.

21.  def done[E, A](exit: Exit[E, A]): ZStream[Any, E, A]

    The stream that ends with the zio.Exit value exit.

22.  def effectAsync[R, E, A](register: (Emit[R, E, A, Unit]) => Unit, outputBuffer: Int = 16): ZStream[R, E, A]

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

    Creates a stream from an asynchronous callback that can be called multiple times. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

    Definition Classes

    ZStreamPlatformSpecificConstructors

23.  def effectAsyncInterrupt[R, E, A](register: (Emit[R, E, 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 to None.

    Definition Classes

    ZStreamPlatformSpecificConstructors

24.  def effectAsyncM[R, E, A](register: (Emit[R, E, 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 to None.

    Definition Classes

    ZStreamPlatformSpecificConstructors

25.  def effectAsyncManaged[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) => Unit) => ZManaged[R, E, Any], 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 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

26.  def effectAsyncMaybe[R, E, A](register: (Emit[R, E, A, Unit]) => Option[ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

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

    Creates a stream from an asynchronous callback that can be called multiple times. The registration of the callback can possibly return the stream synchronously. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

    Definition Classes

    ZStreamPlatformSpecificConstructors

27.  val empty: ZStream[Any, Nothing, Nothing]

    The empty stream

28.  def environment[R]: ZStream[R, Nothing, R]

    Accesses the whole environment of the stream.

29.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

30.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

31.  def execute[R, E, A](zio: ZIO[R, E, A]): ZStream[R, E, Nothing]

    Creates a zio.stream.ZStream from the given effect and drains it

32.  def fail[E](error: => E): ZStream[Any, E, Nothing]

    The stream that always fails with the error

33.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.Throwable])

34.  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.

35.  def fromBlockingIterator[A](iterator: => Iterator[A], maxChunkSize: Int = 1): ZStream[Blocking, Throwable, A]

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

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

    Definition Classes

    ZStreamPlatformSpecificConstructors

36.  def fromBlockingJavaIterator[A](iter: => Iterator[A], maxChunkSize: Int = 1): ZStream[Blocking, 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.

    Definition Classes

    ZStreamPlatformSpecificConstructors

37.  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

38.  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.

39.  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.

    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.

40.  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.

    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.

41.  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.

    Creates a stream from a subscription to a hub.

    The hub will be shut down once the stream is closed.

42.  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

43.  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.

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

    Creates a stream from an arbitrary number of chunks.

45.  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

46.  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

47.  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

48.  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.

49.  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.

    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.

50.  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.

    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.

51.  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.

    Creates a stream from a subscription to a hub.

    The hub will be shut down once the stream is closed.

52.  def fromInputStream(is: => InputStream, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, IOException, Byte]

    Creates a stream from a java.io.InputStream.

    Creates a stream from a java.io.InputStream. Note: the input stream will not be explicitly closed after it is exhausted.

    Definition Classes

    ZStreamPlatformSpecificConstructors

53.  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

54.  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

55.  def fromIterable[O](as: => Iterable[O]): ZStream[Any, Nothing, O]

    Creates a stream from an iterable collection of values

56.  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]

57.  def fromIterator[A](iterator: => Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Throwable, A]

    Creates a stream from an iterator that may throw exceptions.

58.  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

59.  def fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from a managed iterator

60.  def fromIteratorTotal[A](iterator: => Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Nothing, A]

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

61.  def fromJavaIterator[A](iterator: => Iterator[A]): ZStream[Any, Throwable, A]

    Creates a stream from a Java iterator that may throw exceptions

62.  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

63.  def fromJavaIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from a managed iterator

64.  def fromJavaIteratorTotal[A](iterator: => Iterator[A]): ZStream[Any, Nothing, A]

    Creates a stream from a Java iterator

65.  final def fromJavaStream[A](stream: => java.util.stream.Stream[A]): ZStream[Any, Throwable, A]

    Creates a stream from a Java stream

    Creates a stream from a Java stream

    Definition Classes

    ZStreamPlatformSpecificConstructors

66.  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

67.  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

68.  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

69.  def fromOutputStreamWriter(write: (OutputStream) => Unit, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, 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

70.  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 zio.ZQueue of values

    Creates a stream from a zio.ZQueue of values

    maxChunkSize

    Maximum number of queued elements to put in one chunk in the stream

71.  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 zio.ZQueue of values.

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

72.  def fromReader(reader: => Reader, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Blocking, IOException, Char]

    Creates a stream from java.io.Reader.

    Creates a stream from java.io.Reader.

    Definition Classes

    ZStreamPlatformSpecificConstructors

73.  def fromReaderEffect[R](reader: => ZIO[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, 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

74.  def fromReaderManaged[R](reader: => ZManaged[R, IOException, Reader], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R with Blocking, IOException, Char]

    Creates a stream from managed java.io.Reader.

    Creates a stream from managed java.io.Reader.

    Definition Classes

    ZStreamPlatformSpecificConstructors

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

    Creates a stream from the resource specified in path

    Creates a stream from the resource specified in path

    Definition Classes

    ZStreamPlatformSpecificConstructors

76.  def fromSchedule[R, A](schedule: Schedule[R, Any, A]): ZStream[R with 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.

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

78.  def fromTQueue[A](queue: TQueue[A]): ZStream[Any, Nothing, A]

    Creates a stream from a zio.stm.TQueue of values.

79.  final def getClass(): Class[_ <: AnyRef]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

80.  def halt[E](cause: => Cause[E]): ZStream[Any, E, Nothing]

    The stream that always halts with cause.

81.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

82.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

83.  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))), ...

84.  def managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]

    Creates a single-valued stream from a managed resource

85.  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 to outputBuffer chunks may be buffered by this operator.

86.  def mergeAllUnbounded[R, E, O](outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]

    Like mergeAll, but runs all streams concurrently.

87.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

88.  val never: ZStream[Any, Nothing, Nothing]

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

89.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

90.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

91.  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.

92.  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.

    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.

93.  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.

    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.

94.  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.

95.  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)

96.  def repeat[A](a: => A): ZStream[Any, Nothing, A]

    Repeats the provided value infinitely.

97.  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.

98.  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.

99.  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.

100.  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.

101.  def repeatEffectWith[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any]): ZStream[R with Clock, E, A]

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

102.  def repeatWith[R, A](a: => A, schedule: Schedule[R, A, _]): ZStream[R with Clock, Nothing, A]

     Repeats the value using the provided schedule.

103.  def service[A](implicit arg0: zio.Tag[A]): ZStream[Has[A], Nothing, A]

     Accesses the specified service in the environment of the stream.

104.  def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

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

105.  def serviceWithStream[Service]: ServiceWithStreamPartiallyApplied[Service]

     Accesses the specified service in the environment of the stream in the context of a stream.

106.  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 stream.

107.  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 stream.

108.  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 stream.

109.  def succeed[A](a: => A): ZStream[Any, Nothing, A]

     Creates a single-valued pure stream

110.  final def synchronized[T0](arg0: => T0): T0

     Definition Classes

     AnyRef

111.  def tick(interval: Duration): ZStream[Clock, Nothing, Unit]

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

112.  def toString(): String

     Definition Classes

     AnyRef → Any

113.  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

114.  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.

115.  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

116.  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

117.  val unit: ZStream[Any, Nothing, Unit]

     A stream that contains a single Unit value.

118.  def unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

     Creates a stream produced from an effect

119.  def unwrapManaged[R, E, A](fa: ZManaged[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

     Creates a stream produced from a ZManaged

120.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

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

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

122.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException]) @native()

123.  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.

124.  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.

125.  def whenCaseM[R, E, A](a: ZIO[R, E, A]): WhenCaseM[R, E, A]

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

126.  def whenM[R, E](b: ZIO[R, E, Boolean]): WhenM[R, E]

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

127.  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.

128.  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.

129.  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.

130.  object Take
131.  object TerminationStrategy
132.  object Connection

     Definition Classes

     ZStreamPlatformSpecificConstructors