object ZStream extends ZStreamPlatformSpecificConstructors

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZStream
  2. ZStreamPlatformSpecificConstructors
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final class AccessMPartiallyApplied[R] extends AnyVal
  2. final class AccessPartiallyApplied[R] extends AnyVal
  3. final class AccessStreamPartiallyApplied[R] extends AnyVal
  4. 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.

  5. final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
  6. type Pull[-R, +E, +O] = ZIO[R, Option[E], Chunk[O]]
  7. sealed trait TerminationStrategy extends AnyRef
  8. final class UpdateService[-R, +E, +O, M] extends AnyVal

Deprecated Type Members

  1. type Take[+E, +A] = Exit[Option[E], Chunk[A]]
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use zio.stream.Take instead

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. val empty: ZStream[Any, Nothing, Nothing]

    The empty stream

  23. def environment[R]: ZStream[R, Nothing, R]

    Accesses the whole environment of the stream.

  24. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  25. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  26. def fail[E](error: => E): ZStream[Any, E, Nothing]

    The stream that always fails with the error

  27. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  28. 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.

  29. 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

  30. 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

  31. 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.

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

    Creates a stream from an arbitrary number of chunks.

  33. 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

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

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

    Creates a stream from a java.io.InputStream

    Creates a stream from a java.io.InputStream

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

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

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

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

    Definition Classes
    ZStreamPlatformSpecificConstructors
  38. def fromIterable[O](as: => Iterable[O]): ZStream[Any, Nothing, O]

    Creates a stream from an iterable collection of values

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

  40. def fromIterator[A](iterator: => Iterator[A]): ZStream[Any, Throwable, A]
  41. 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

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

    Creates a stream from a managed iterator

  43. def fromIteratorTotal[A](iterator: => Iterator[A]): ZStream[Any, Nothing, A]

    Creates a stream from an iterator

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

    Creates a stream from a Java iterator that may throw exceptions

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

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

    Creates a stream from a managed iterator

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

    Creates a stream from a Java iterator

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

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

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

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

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

  52. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  53. def halt[E](cause: => Cause[E]): ZStream[Any, E, Nothing]

    The stream that always halts with cause.

  54. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  55. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  56. 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))), ...

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

    Creates a single-valued stream from a managed resource

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

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

    Like mergeAll, but runs all streams concurrently.

  60. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  61. val never: ZStream[Any, Nothing, Nothing]

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

  62. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  63. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  64. 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.

  65. 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.

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

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

    Repeats the provided value infinitely.

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

  69. 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.

  70. 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.

  71. 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.

  72. 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

  73. def repeatWith[R, A](a: => A, schedule: Schedule[R, A, _]): ZStream[R, Nothing, A]

    Repeats the value using the provided schedule.

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

    Accesses the specified service in the environment of the effect.

  75. 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.

  76. 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.

  77. 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.

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

    Creates a single-valued pure stream

  79. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  80. def tick(interval: Duration): ZStream[Clock, Nothing, Unit]

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

  81. def toString(): String
    Definition Classes
    AnyRef → Any
  82. 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

  83. 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

  84. 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

  85. val unit: ZStream[Any, Nothing, Unit]

    A stream that contains a single Unit value.

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

    Creates a stream produced from an effect

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

    Creates a stream produced from a ZManaged

  88. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  89. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  90. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  91. 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.

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

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

  94. object Take
  95. object TerminationStrategy

Inherited from ZStreamPlatformSpecificConstructors

Inherited from AnyRef

Inherited from Any

Ungrouped