Packages

trait ZStream[-R, +E, +A] extends Serializable

A Stream[E, A] represents an effectful stream that can produce values of type A, or potentially fail with a value of type E.

Streams have a very similar API to Scala collections, making them immediately familiar to most developers. Unlike Scala collections, streams can be used on effectful streams of data, such as HTTP connections, files, and so forth.

Streams do not leak resources. This guarantee holds in the presence of early termination (not all of a stream is consumed), failure, or even interruption.

Thanks to only first-order types, appropriate variance annotations, and specialized effect type (ZIO), streams feature extremely good type inference and should almost never require specification of any type parameters.

Self Type
ZStream[R, E, A]
Linear Supertypes
Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZStream
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def fold[R1 <: R, E1 >: E, A1 >: A, S]: Fold[R1, E1, A1, S]

    Executes an effectful fold over the stream of values.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ++[R1 <: R, E1 >: E, A1 >: A](other: ZStream[R1, E1, A1]): ZStream[R1, E1, A1]

    Concatenates with another stream in strict order

  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. final def buffer(capacity: Int): ZStream[R, E, A]

    Allow a faster producer to progress independently of a slower consumer by buffering up to capacity elements in a queue.

    Allow a faster producer to progress independently of a slower consumer by buffering up to capacity elements in a queue.

    Note

    when possible, prefer capacities that are powers of 2 for better performance.

  7. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  8. def collect[B](pf: PartialFunction[A, B]): ZStream[R, E, B]

    Performs a filter and map in a single step.

  9. def collectWhile[B](pred: PartialFunction[A, B]): ZStream[R, E, B]

    Transforms all elements of the stream for as long as the specified partial function is defined.

  10. final def concat[R1 <: R, E1 >: E, A1 >: A](other: ZStream[R1, E1, A1]): ZStream[R1, E1, A1]

    Appends another stream to this stream.

    Appends another stream to this stream. The concatenated stream will first emit the elements of this stream, and then emit the elements of the other stream.

  11. final def drain: ZStream[R, E, Nothing]

    Converts this stream to a stream that executes its effects but emits no elements.

    Converts this stream to a stream that executes its effects but emits no elements. Useful for sequencing effects using streams:

    (Stream(1, 2, 3).tap(i => ZIO(println(i))) ++
  Stream.lift(ZIO(println("Done!"))).drain ++
  Stream(4, 5, 6).tap(i => ZIO(println(i)))).run(Sink.drain)
  12. final def drop(n: Int): ZStream[R, E, A]

    Drops the specified number of elements from this stream.

  13. def dropWhile(pred: (A) ⇒ Boolean): ZStream[R, E, A]

    Drops all elements of the stream for as long as the specified predicate evaluates to true.

  14. def ensuring[R1 <: R](fin: ZIO[R1, Nothing, _]): ZStream[R1, E, A]

    Executes the provided finalizer after this stream's finalizers run.

  15. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  17. def filter(pred: (A) ⇒ Boolean): ZStream[R, E, A]

    Filters this stream by the specified predicate, retaining all elements for which the predicate evaluates to true.

  18. final def filterM[R1 <: R, E1 >: E](pred: (A) ⇒ ZIO[R1, E1, Boolean]): ZStream[R1, E1, A]

    Filters this stream by the specified effectful predicate, retaining all elements for which the predicate evaluates to true.

  19. final def filterNot(pred: (A) ⇒ Boolean): ZStream[R, E, A]

    Filters this stream by the specified predicate, removing all elements for which the predicate evaluates to true.

  20. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  21. final def flatMap[R1 <: R, E1 >: E, B](f0: (A) ⇒ ZStream[R1, E1, B]): ZStream[R1, E1, B]

    Returns a stream made of the concatenation in strict order of all the streams produced by passing each element of this stream to f0

  22. final def flatMapPar[R1 <: R, E1 >: E, B](n: Long, outputBuffer: Int = 16)(f: (A) ⇒ ZStream[R1, E1, B]): ZStream[R1, E1, B]

    Maps each element of this stream to another stream and returns the non-deterministic merge of those streams, executing up to n inner streams concurrently.

    Maps each element of this stream to another stream and returns the non-deterministic merge of those streams, executing up to n inner streams concurrently. Up to outputBuffer elements of the produced streams may be buffered in memory by this operator.

  23. def foldLeft[A1 >: A, S](s: S)(f: (S, A1) ⇒ S): ZManaged[R, E, S]

    Reduces the elements in the stream to a value of type S

  24. final def foreach[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Unit]): ZIO[R1, E1, Unit]

    Consumes all elements of the stream, passing them to the specified callback.

  25. final def foreachManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Unit]): ZManaged[R1, E1, Unit]

    Like ZStream#foreach, but returns a ZManaged so the finalization order can be controlled.

  26. final def foreachWhile[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Boolean]): ZIO[R1, E1, Unit]

    Consumes elements of the stream, passing them to the specified callback, and terminating consumption when the callback returns false.

  27. final def foreachWhileManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Boolean]): ZManaged[R1, E1, Unit]

    Like ZStream#foreachWhile, but returns a ZManaged so the finalization order can be controlled.

  28. def forever: ZStream[R, E, A]

    Repeats this stream forever.

  29. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  30. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  31. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  32. def map[B](f0: (A) ⇒ B): ZStream[R, E, B]

    Returns a stream made of the elements of this stream transformed with f0

  33. def mapAccum[S1, B](s1: S1)(f1: (S1, A) ⇒ (S1, B)): ZStream[R, E, B]

    Statefully maps over the elements of this stream to produce new elements.

  34. final def mapAccumM[E1 >: E, S1, B](s1: S1)(f1: (S1, A) ⇒ IO[E1, (S1, B)]): ZStream[R, E1, B]

    Statefully and effectfully maps over the elements of this stream to produce new elements.

  35. def mapConcat[B](f: (A) ⇒ Chunk[B]): ZStream[R, E, B]

    Maps each element to a chunk, and flattens the chunks into the output of this stream.

  36. def mapConcatM[R1 <: R, E1 >: E, B](f: (A) ⇒ ZIO[R1, E1, Chunk[B]]): ZStream[R1, E1, B]

    Effectfully maps each element to a chunk, and flattens the chunks into the output of this stream.

  37. final def mapM[R1 <: R, E1 >: E, B](f: (A) ⇒ ZIO[R1, E1, B]): ZStream[R1, E1, B]

    Maps over elements of the stream with the specified effectful function.

  38. final def mapMPar[R1 <: R, E1 >: E, B](n: Int)(f: (A) ⇒ ZIO[R1, E1, B]): ZStream[R1, E1, B]

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently.

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. Transformed elements will be emitted in the original order.

  39. final def mapMParUnordered[R1 <: R, E1 >: E, B](n: Long)(f: (A) ⇒ ZIO[R1, E1, B]): ZStream[R1, E1, B]

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently.

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. The element order is not enforced by this combinator, and elements may be reordered.

  40. final def merge[R1 <: R, E1 >: E, A1 >: A](that: ZStream[R1, E1, A1], capacity: Int = 2): ZStream[R1, E1, A1]

    Merges this stream and the specified stream together.

  41. final def mergeEither[R1 <: R, E1 >: E, B](that: ZStream[R1, E1, B], capacity: Int = 2): ZStream[R1, E1, Either[A, B]]

    Merges this stream and the specified stream together to produce a stream of eithers.

  42. final def mergeWith[R1 <: R, E1 >: E, B, C](that: ZStream[R1, E1, B], capacity: Int = 2)(l: (A) ⇒ C, r: (B) ⇒ C): ZStream[R1, E1, C]

    Merges this stream and the specified stream together to a common element type with the specified mapping functions.

  43. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  44. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  45. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  46. final def peel[R1 <: R, E1 >: E, A1 >: A, B](sink: ZSink[R1, E1, A1, A1, B]): ZManaged[R1, E1, (B, ZStream[R1, E1, A1])]

    Peels off enough material from the stream to construct an R using the provided Sink, and then returns both the R and the remainder of the Stream in a managed resource.

    Peels off enough material from the stream to construct an R using the provided Sink, and then returns both the R and the remainder of the Stream in a managed resource. Like all Managed resources, the provided remainder is valid only within the scope of Managed.

  47. def repeat[R1 <: R](schedule: ZSchedule[R1, Unit, _]): ZStream[R1 with Clock, E, A]

    Repeats the entire stream using the specified schedule.

    Repeats the entire stream using the specified schedule. The stream will execute normally, and then repeat again according to the provided schedule.

  48. def run[R1 <: R, E1 >: E, A0, A1 >: A, B](sink: ZSink[R1, E1, A0, A1, B]): ZIO[R1, E1, B]

    Runs the sink on the stream to produce either the sink's result or an error.

  49. def runCollect: ZIO[R, E, List[A]]

    Runs the stream and collects all of its elements in a list.

    Runs the stream and collects all of its elements in a list.

    Equivalent to run(Sink.collectAll[A]).

  50. def runDrain: ZIO[R, E, Unit]

    Runs the stream purely for its effects.

    Runs the stream purely for its effects. Any elements emitted by the stream are discarded.

    Equivalent to run(Sink.drain).

  51. def spaced[R1 <: R, B](schedule: ZSchedule[R1, A, B]): ZStream[R1 with Clock, E, A]

    Repeats elements of the stream using the provided schedule.

  52. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  53. final def take(n: Int): ZStream[R, E, A]

    Takes the specified number of elements from this stream.

  54. def takeWhile(pred: (A) ⇒ Boolean): ZStream[R, E, A]

    Takes all elements of the stream for as long as the specified predicate evaluates to true.

  55. final def tap[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, _]): ZStream[R1, E1, A]

    Adds an effect to consumption of every element of the stream.

  56. final def toQueue[E1 >: E, A1 >: A](capacity: Int = 2): ZManaged[R, E1, Queue[Take[E1, A1]]]

    Converts the stream to a managed queue.

    Converts the stream to a managed queue. After managed queue is used, the queue will never again produce values and should be discarded.

  57. def toString(): String
    Definition Classes
    AnyRef → Any
  58. final def transduce[R1 <: R, E1 >: E, A1 >: A, C](sink: ZSink[R1, E1, A1, A1, C]): ZStream[R1, E1, C]

    Applies a transducer to the stream, which converts one or more elements of type A into elements of type C.

  59. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  60. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  61. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  62. final def zip[R1 <: R, E1 >: E, B](that: ZStream[R1, E1, B], lc: Int = 2, rc: Int = 2): ZStream[R1, E1, (A, B)]

    Zips this stream together with the specified stream.

  63. final def zipWith[R1 <: R, E1 >: E, B, C](that: ZStream[R1, E1, B], lc: Int = 2, rc: Int = 2)(f0: (Option[A], Option[B]) ⇒ Option[C]): ZStream[R1, E1, C]

    Zips two streams together with a specified function.

  64. def zipWithIndex: ZStream[R, E, (A, Int)]

    Zips this stream together with the index of elements of the stream.

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped