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

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
Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZStreamChunk
  2. Serializable
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

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. final def buffer(capacity: Int): ZStreamChunk[R, E, A]

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

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

    Note

    Prefer capacities that are powers of 2 for better performance.

  7. final def bufferDropping(capacity: Int): ZStreamChunk[R, E, A]

    Allows a faster producer to progress independently of a slower consumer by buffering elements into a dropping queue.

    Allows a faster producer to progress independently of a slower consumer by buffering elements into a dropping queue.

    Note

    Prefer capacities that are powers of 2 for better performance.

  8. final def bufferSliding(capacity: Int): ZStreamChunk[R, E, A]

    Allows a faster producer to progress independently of a slower consumer by buffering elements into a sliding queue.

    Allows a faster producer to progress independently of a slower consumer by buffering elements into a sliding queue.

    Note

    Prefer capacities that are powers of 2 for better performance.

  9. final def bufferUnbounded: ZStreamChunk[R, E, A]

    Allows a faster producer to progress independently of a slower consumer by buffering elements into an unbounded queue.

  10. final def catchAll[R1 <: R, E2, A1 >: A](f: (E) => ZStreamChunk[R1, E2, A1])(implicit ev: CanFail[E]): ZStreamChunk[R1, E2, A1]

    Switches over to the stream produced by the provided function in case this one fails with a typed error.

  11. final def catchAllCause[R1 <: R, E2, A1 >: A](f: (Cause[E]) => ZStreamChunk[R1, E2, A1]): ZStreamChunk[R1, E2, A1]

    Switches over to the stream produced by the provided function in case this one fails.

    Switches over to the stream produced by the provided function in case this one fails. Allows recovery from all errors, except external interruption.

  12. final def chunkN(chunkSize: Int): ZStreamChunk[R, E, A]

    Chunks the stream with specified chunkSize

    Chunks the stream with specified chunkSize

    chunkSize

    size of the chunk

  13. val chunks: ZStream[R, E, Chunk[A]]
  14. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  15. final def collect[B](p: PartialFunction[A, B]): ZStreamChunk[R, E, B]

    Collects a filtered, mapped subset of the stream.

  16. def collectWhile[B](p: PartialFunction[A, B]): ZStreamChunk[R, E, B]

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

  17. def drop(n: Int): ZStreamChunk[R, E, A]

    Drops the specified number of elements from this stream.

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

    Drops all elements of the stream until the specified predicate evaluates to true.

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

  20. final def either(implicit ev: CanFail[E]): ZStreamChunk[R, Nothing, Either[E, A]]

    Returns a stream whose failures and successes have been lifted into an Either.

    Returns a stream whose failures and successes have been lifted into an Either. The resulting stream cannot fail, because the failures have been exposed as part of the Either success case.

    Note

    the stream will end as soon as the first error occurs.

  21. final def ensuring[R1 <: R](fin: ZIO[R1, Nothing, Any]): ZStreamChunk[R1, E, A]

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

  22. final def ensuringFirst[R1 <: R](fin: ZIO[R1, Nothing, Any]): ZStreamChunk[R1, E, A]

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

  23. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  25. 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.

  26. final def filterM[R1 <: R, E1 >: E](pred: (A) => ZIO[R1, E1, Boolean]): ZStreamChunk[R1, E1, A]

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

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

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

  30. def flattenChunks: ZStream[R, E, A]

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

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

    Executes a pure fold over the stream of values - reduces all elements in the stream to a value of type S.

    Executes a pure fold over the stream of values - reduces all elements in the stream to a value of type S. See ZStream.fold

  32. final def foldM[R1 <: R, E1 >: E, A1 >: A, S](s: S)(f: (S, A1) => ZIO[R1, E1, S]): ZIO[R1, E1, S]

    Executes an effectful fold over the stream of values.

    Executes an effectful fold over the stream of values. See ZStream.foldM

  33. final def foldManaged[A1 >: A, S](s: S)(f: (S, A1) => S): ZManaged[R, E, S]

    Executes a pure fold over the stream of values.

    Executes a pure fold over the stream of values. Returns a Managed value that represents the scope of the stream. See ZStream.foldManaged

  34. final def foldManagedM[R1 <: R, E1 >: E, A1 >: A, S](s: S)(f: (S, A1) => ZIO[R1, E1, S]): ZManaged[R1, E1, S]

    Executes an effectful fold over the stream of values.

    Executes an effectful fold over the stream of values. Returns a Managed value that represents the scope of the stream. See ZStream.foldManagedM

  35. final def foldWhile[A1 >: A, S](s: S)(cont: (S) => Boolean)(f: (S, A1) => S): ZIO[R, E, S]

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

    Reduces the elements in the stream to a value of type S. Stops the fold early when the condition is not fulfilled. See ZStream.foldWhile

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

    Executes an effectful fold over the stream of values.

    Executes an effectful fold over the stream of values. Stops the fold early when the condition is not fulfilled. See ZStream.foldWhileM

  37. def foldWhileManaged[A1 >: A, S](s: S)(cont: (S) => Boolean)(f: (S, A1) => S): ZManaged[R, E, S]

    Executes a pure fold over the stream of values.

    Executes a pure fold over the stream of values. Stops the fold early when the condition is not fulfilled. See ZStream.foldWhileManaged

  38. final def foldWhileManagedM[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.

    Executes an effectful fold over the stream of values. Stops the fold early when the condition is not fulfilled. See ZStream.foldWhileManagedM

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

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

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

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

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

  46. final def mapAccumM[R1 <: R, E1 >: E, S1, B](s1: S1)(f1: (S1, A) => ZIO[R1, E1, (S1, B)]): ZStreamChunk[R1, E1, B]

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

  47. final def mapConcat[B](f: (A) => Iterable[B]): ZStreamChunk[R, E, B]

    Maps each element to an iterable and flattens the iterables into the output of this stream.

  48. def mapConcatChunk[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.

  49. final def mapConcatChunkM[R1 <: R, E1 >: E, B](f: (A) => ZIO[R1, E1, Chunk[B]]): ZStreamChunk[R1, E1, B]

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

  50. final def mapConcatM[R1 <: R, E1 >: E, B](f: (A) => ZIO[R1, E1, Iterable[B]]): ZStreamChunk[R1, E1, B]

    Effectfully maps each element to an iterable and flattens the iterables into the output of this stream.

  51. final def mapError[E1](f: (E) => E1)(implicit ev: CanFail[E]): ZStreamChunk[R, E1, A]

    Transforms the errors that possibly result from this stream.

  52. final def mapErrorCause[E1](f: (Cause[E]) => Cause[E1]): ZStreamChunk[R, E1, A]

    Transforms the errors that possibly result from this stream.

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

  54. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  55. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  56. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  57. final def orElse[R1 <: R, E2, A1 >: A](that: => ZStreamChunk[R1, E2, A1])(implicit ev: CanFail[E]): ZStreamChunk[R1, E2, A1]

    Switches to the provided stream in case this one fails with a typed error.

    Switches to the provided stream in case this one fails with a typed error.

    See also ZStream#catchAll.

  58. final def process: ZManaged[R, Nothing, Pull[R, E, A]]
  59. final def provide(r: R)(implicit ev: NeedsEnv[R]): StreamChunk[E, A]

    Provides the stream with its required environment, which eliminates its dependency on R.

  60. final def provideSome[R0](env: (R0) => R)(implicit ev: NeedsEnv[R]): ZStreamChunk[R0, E, A]

    Provides some of the environment required to run this effect, leaving the remainder R0.

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

  62. final 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]).

  63. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  64. def take(n: Int): ZStreamChunk[R, E, A]

    Takes the specified number of elements from this stream.

  65. def takeUntil(pred: (A) => Boolean): ZStreamChunk[R, E, A]

    Takes all elements of the stream until the specified predicate evaluates to true.

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

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

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

  68. def toInputStream(implicit ev0: <:<[E, Throwable], ev1: <:<[A, Byte]): ZManaged[R, E, InputStream]
    Annotations
    @silent("never used")
  69. final def toQueue[E1 >: E, A1 >: A](capacity: Int = 2): ZManaged[R, Nothing, Queue[Take[E1, Chunk[A1]]]]

    Converts the stream to a managed queue.

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

  70. final def toQueueUnbounded[E1 >: E, A1 >: A]: ZManaged[R, Nothing, Queue[Take[E1, Chunk[A1]]]]

    Converts the stream into an unbounded managed queue.

    Converts the stream into an unbounded managed queue. After the managed queue is used, the queue will never again produce values and should be discarded.

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

  72. def toString(): String
    Definition Classes
    AnyRef → Any
  73. final def via[R2, E2, B](f: (ZStreamChunk[R, E, A]) => ZStreamChunk[R2, E2, B]): ZStreamChunk[R2, E2, B]

    Threads the stream through the transformation function f.

  74. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  75. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  76. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  77. final def zipWithIndex: ZStreamChunk[R, E, (A, Long)]

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

Deprecated Value Members

  1. final def provideM[E1 >: E](r: IO[E1, R])(implicit ev: NeedsEnv[R]): StreamChunk[E1, A]

    An effectful version of provide, useful when the act of provision requires an effect.

    An effectful version of provide, useful when the act of provision requires an effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use provideLayer

  2. final def provideManaged[E1 >: E](m: Managed[E1, R])(implicit ev: NeedsEnv[R]): StreamChunk[E1, A]

    Uses the given Managed to provide the environment required to run this stream, leaving no outstanding environments.

    Uses the given Managed to provide the environment required to run this stream, leaving no outstanding environments.

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use provideLayer

  3. final def provideSomeM[R0, E1 >: E](env: ZIO[R0, E1, R])(implicit ev: NeedsEnv[R]): ZStreamChunk[R0, E1, A]

    Effectfully provides some of the environment required to run this effect leaving the remainder R0.

    Effectfully provides some of the environment required to run this effect leaving the remainder R0.

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use provideSomeLayer

  4. final def provideSomeManaged[R0, E1 >: E](env: ZManaged[R0, E1, R])(implicit ev: NeedsEnv[R]): ZStreamChunk[R0, E1, A]

    Uses the given Managed to provide some of the environment required to run this stream, leaving the remainder R0.

    Uses the given Managed to provide some of the environment required to run this stream, leaving the remainder R0.

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use provideSomeLayer

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped