StreamChunk

abstract val chunks: Stream[E, Chunk[A]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[E1 >: E, A1 >: A](that: StreamChunk[E1, A1]): StreamChunk[E1, A1]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def dropWhile(pred: (A) ⇒ Boolean): StreamChunk[E, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(pred: (A) ⇒ Boolean): StreamChunk[E, A]

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

def filterNot(pred: (A) ⇒ Boolean): StreamChunk[E, A]

def finalize(): Unit

final def flatMap[E1 >: E, B](f0: (A) ⇒ StreamChunk[E1, B]): StreamChunk[E1, B]

def flattenChunks: Stream[E, A]

def foldLazy[E1 >: E, A1 >: A, S](s: S)(cont: (S) ⇒ Boolean)(f: (S, A1) ⇒ IO[E1, S]): IO[E1, S]

def foldLazyChunks[E1 >: E, A1 >: A, S](s: S)(cont: (S) ⇒ Boolean)(f: (S, Chunk[A1]) ⇒ IO[E1, S]): IO[E1, S]

Executes an effectful fold over the stream of chunks.

def foldLeft[A1 >: A, S](s: S)(f: (S, A1) ⇒ S): IO[E, S]

final def foreach[E1 >: E](f: (A) ⇒ IO[E1, Unit]): IO[E1, Unit]

final def foreach0[E1 >: E](f: (A) ⇒ IO[E1, Boolean]): IO[E1, Unit]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): StreamChunk[E, B]

final def mapAccum[S1, B](s1: S1)(f1: (S1, A) ⇒ (S1, B)): StreamChunk[E, B]

def mapConcat[B](f: (A) ⇒ Chunk[B]): StreamChunk[E, B]

final def mapM[E1 >: E, B](f0: (A) ⇒ IO[E1, B]): StreamChunk[E1, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def run[E1 >: E, A0, A1 >: A, B](sink: Sink[E1, A0, Chunk[A1], B]): IO[E1, B]

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

final def synchronized[T0](arg0: ⇒ T0): T0

def takeWhile(pred: (A) ⇒ Boolean): StreamChunk[E, A]

final def toQueue[E1 >: E, A1 >: A](capacity: Int = 1): Managed[Nothing, Queue[Take[E1, Chunk[A1]]]]

final def toQueueWith[E1 >: E, A1 >: A, Z](f: (Queue[Take[E1, Chunk[A1]]]) ⇒ IO[E1, Z], capacity: Int = 1): IO[E1, Z]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withEffect[E1 >: E](f0: (A) ⇒ IO[E1, Unit]): StreamChunk[E1, A]

def zipWithIndex: StreamChunk[E, (A, Int)]