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.  val chunks: ZStream[R, E, Chunk[A]]
11.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

12.  final def collect[B](p: PartialFunction[A, B]): ZStreamChunk[R, E, B]

    Collects a filtered, mapped subset of the stream.

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

    Drops the specified number of elements from this stream.

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

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): ZStreamChunk[R, E, A]

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

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

19.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

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

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

21.  def flattenChunks: ZStream[R, E, A]

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

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

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

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

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

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

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

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

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

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

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

32.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

33.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

34.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

35.  def map[B](f: (A) ⇒ B): ZStreamChunk[R, E, B]

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

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

37.  def mapConcat[B](f: (A) ⇒ Iterable[B]): ZStreamChunk[R, E, B]

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

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

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

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

    Definition Classes

    AnyRef

41.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

42.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

43.  final def process: ZManaged[R, E, Pull[R, E, A]]
44.  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.

45.  final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

46.  def take(n: Int): ZStreamChunk[R, E, A]

    Takes the specified number of elements from this stream.

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

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

49.  def toInputStream(implicit ev0: <:<[E, Throwable], ev1: <:<[A, Byte]): ZManaged[R, E, InputStream]

    Annotations

    @silent( "never used" )

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

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

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

53.  def toString(): String

    Definition Classes

    AnyRef → Any

54.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

57.  final def zipWithIndex: ZStreamChunk[R, E, (A, Int)]

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