Packages

class ZStreamChunk[-R, +E, +A] extends AnyRef

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

ZStreamChunk differs from ZStream in that elements in the stream are processed in batches, which is orders of magnitude more efficient than dealing with each element individually.

ZStreamChunk is particularly suited for situations where you are dealing with values of primitive types, e.g. those coming off a java.io.InputStream

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

Instance Constructors

  1. new ZStreamChunk(chunks: ZStream[R, E, Chunk[A]])

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](that: ZStreamChunk[R1, E1, A1]): ZStreamChunk[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. val chunks: ZStream[R, E, Chunk[A]]
  7. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  8. final def collect[B](p: PartialFunction[A, B]): ZStreamChunk[R, E, B]

    Collects a filtered, mapped subset of the stream.

  9. final def dropWhile(pred: (A) => Boolean): ZStreamChunk[R, E, A]

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

  10. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  12. def filter(pred: (A) => Boolean): ZStreamChunk[R, E, A]

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

  13. final def filterNot(pred: (A) => Boolean): ZStreamChunk[R, E, A]

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

  14. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  15. final def flatMap[R1 <: R, E1 >: E, B](f0: (A) => ZStreamChunk[R1, E1, B]): ZStreamChunk[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

  16. final def flattenChunks: ZStream[R, E, A]

    Returns a stream made of the concatenation of all the chunks in this stream

  17. final def fold[R1 <: R, E1 >: E, A1 >: A, S](s: S)(cont: (S) => Boolean)(f: (S, A1) => ZIO[R1, E1, S]): ZIO[R1, E1, S]
  18. final def foldChunks[R1 <: R, E1 >: E, A1 >: A, S](s: S)(cont: (S) => Boolean)(f: (S, Chunk[A1]) => ZIO[R1, E1, S]): ZIO[R1, E1, S]
  19. final def foldChunksManaged[R1 <: R, E1 >: E, A1 >: A, S](s: S)(cont: (S) => Boolean)(f: (S, Chunk[A1]) => ZIO[R1, E1, S]): ZManaged[R1, E1, S]

    Executes an effectful fold over the stream of chunks.

  20. def foldLeft[A1 >: A, S](s: S)(f: (S, A1) => S): ZIO[R, E, S]

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

  21. final def foldManaged[R1 <: R, E1 >: E, A1 >: A, S](s: S)(cont: (S) => Boolean)(f: (S, A1) => ZIO[R1, E1, S]): ZManaged[R1, E1, S]

    Executes an effectful fold over the stream of values.

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

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

  24. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  25. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  26. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  27. def map[B](f: (A) => B): ZStreamChunk[R, E, B]

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

  28. final def mapAccum[S1, B](s1: S1)(f1: (S1, A) => (S1, B)): ZStreamChunk[R, E, B]

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

  29. def mapConcat[B](f: (A) => Chunk[B]): ZStreamChunk[R, E, B]

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

  30. final def mapM[R1 <: R, E1 >: E, B](f0: (A) => ZIO[R1, E1, B]): ZStreamChunk[R1, E1, B]

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

  31. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  32. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  33. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  34. final def process: ZManaged[R, E, Pull[R, E, A]]
  35. final def run[R1 <: R, E1 >: E, A0, A1 >: A, B](sink: ZSink[R1, E1, A0, Chunk[A1], B]): ZIO[R1, E1, B]

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

  36. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  37. final def takeWhile(pred: (A) => Boolean): ZStreamChunk[R, E, A]

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

  38. final def tap[R1 <: R, E1 >: E](f0: (A) => ZIO[R1, E1, _]): ZStreamChunk[R1, E1, A]

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

  39. final def toQueue[E1 >: E, A1 >: A](capacity: Int = 2): ZManaged[R, E1, Queue[Take[E1, Chunk[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 chunks and should be discarded.

  40. final def toQueueWith[R1 <: R, E1 >: E, A1 >: A, Z](f: (Queue[Take[E1, Chunk[A1]]]) => ZIO[R1, E1, Z], capacity: Int = 1): ZIO[R1, E1, Z]

    Converts the stream to a managed queue and immediately consume its elements.

  41. def toString(): String
    Definition Classes
    AnyRef → Any
  42. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  43. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  44. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  45. final def zipWithIndex: ZStreamChunk[R, E, (A, Int)]

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

Inherited from AnyRef

Inherited from Any

Ungrouped