ZSink

Type Members

type Push[-R, +E, -I, +Z] = (Option[Chunk[I]]) ⇒ ZIO[R, Either[E, Z], Unit]

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object Push
def apply[R, E, I, Z](push: ZManaged[R, Nothing, Push[R, E, I, Z]]): ZSink[R, E, I, Z]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collectAll[A]: ZSink[Any, Nothing, A, List[A]]

A sink that collects all of its inputs into a list.
def collectAllToMap[A, K](key: (A) ⇒ K)(f: (A, A) ⇒ A): ZSink[Any, Nothing, A, Map[K, A]]

A sink that collects all of its inputs into a map.
A sink that collects all of its inputs into a map. The keys are extracted from inputs using the keying function key; if multiple inputs use the same key, they are merged using the f function.
def collectAllToSet[A]: ZSink[Any, Nothing, A, Set[A]]

A sink that collects all of its inputs into a set.
val count: ZSink[Any, Nothing, Any, Long]

A sink that counts the number of elements fed to it.
def die(e: ⇒ Throwable): ZSink[Any, Nothing, Any, Nothing]

Creates a sink halting with the specified Throwable.
def dieMessage(m: ⇒ String): ZSink[Any, Nothing, Any, Nothing]

Creates a sink halting with the specified message, wrapped in a RuntimeException.
val drain: ZSink[Any, Nothing, Any, Unit]

A sink that ignores its inputs.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail[E](e: ⇒ E): ZSink[Any, E, Any, Nothing]

A sink that always fails with the specified error.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fold[I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, I) ⇒ S): ZSink[Any, Nothing, I, S]

A sink that folds its inputs with the provided function, termination predicate and initial state.
def foldChunks[I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, Chunk[I]) ⇒ S): ZSink[Any, Nothing, I, S]

A sink that folds its input chunks with the provided function, termination predicate and initial state.
def foldChunksM[R, E, I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, Chunk[I]) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state.
A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state.
This sink may terminate in the middle of a chunk and discard the rest of it. See the discussion on the ZSink class scaladoc on sinks vs. transducers.
def foldLeft[I, S](z: S)(f: (S, I) ⇒ S): ZSink[Any, Nothing, I, S]

A sink that folds its inputs with the provided function and initial state.
def foldLeftChunks[I, S](z: S)(f: (S, Chunk[I]) ⇒ S): ZSink[Any, Nothing, I, S]

A sink that folds its input chunks with the provided function and initial state.
def foldLeftChunksM[R, E, I, S](z: S)(f: (S, Chunk[I]) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

A sink that effectfully folds its input chunks with the provided function and initial state.
def foldLeftM[R, E, I, S](z: S)(f: (S, I) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

A sink that effectfully folds its inputs with the provided function and initial state.
def foldM[R, E, I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, I) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

A sink that effectfully folds its inputs with the provided function, termination predicate and initial state.
A sink that effectfully folds its inputs with the provided function, termination predicate and initial state.
This sink may terminate in the middle of a chunk and discard the rest of it. See the discussion on the ZSink class scaladoc on sinks vs. transducers.
def foreach[R, E, I](f: (I) ⇒ ZIO[R, E, Any]): ZSink[R, E, I, Unit]

A sink that executes the provided effectful function for every element fed to it.
def fromEffect[R, E, Z](b: ⇒ ZIO[R, E, Z]): ZSink[R, E, Any, Z]

Creates a single-value sink produced from an effect
final def fromOutputStream(os: OutputStream): ZSink[Blocking, IOException, Byte, Int]

Uses the provided OutputStream to create a ZSink that consumes byte chunks and writes them to the OutputStream.
Uses the provided OutputStream to create a ZSink that consumes byte chunks and writes them to the OutputStream. The sink will yield the count of bytes written.
The caller of this function is responsible for closing the OutputStream.

Definition Classes
ZSinkPlatformSpecificConstructors
def fromPush[R, E, I, Z](sink: Push[R, E, I, Z]): ZSink[R, E, I, Z]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def halt[E](e: ⇒ Cause[E]): ZSink[Any, E, Any, Nothing]

Creates a sink halting with a specified cause.
def hashCode(): Int

Definition Classes
AnyRef → Any
def head[I]: ZSink[Any, Nothing, I, Option[I]]

Creates a sink containing the first value.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def last[I]: ZSink[Any, Nothing, I, Option[I]]

Creates a sink containing the last value.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def succeed[Z](z: ⇒ Z): ZSink[Any, Nothing, Any, Z]

A sink that immediately ends with the specified value.
def sum[A](implicit A: Numeric[A]): ZSink[Any, Nothing, A, A]

A sink that sums incoming numeric values.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: class ZSink | package stream

object ZSink extends ZSinkPlatformSpecificConstructors

Type Members

type Push[-R, +E, -I, +Z] = (Option[Chunk[I]]) ⇒ ZIO[R, Either[E, Z], Unit]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Push

def apply[R, E, I, Z](push: ZManaged[R, Nothing, Push[R, E, I, Z]]): ZSink[R, E, I, Z]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collectAll[A]: ZSink[Any, Nothing, A, List[A]]

def collectAllToMap[A, K](key: (A) ⇒ K)(f: (A, A) ⇒ A): ZSink[Any, Nothing, A, Map[K, A]]

def collectAllToSet[A]: ZSink[Any, Nothing, A, Set[A]]

val count: ZSink[Any, Nothing, Any, Long]

def die(e: ⇒ Throwable): ZSink[Any, Nothing, Any, Nothing]

def dieMessage(m: ⇒ String): ZSink[Any, Nothing, Any, Nothing]

val drain: ZSink[Any, Nothing, Any, Unit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[E](e: ⇒ E): ZSink[Any, E, Any, Nothing]

def finalize(): Unit

def fold[I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, I) ⇒ S): ZSink[Any, Nothing, I, S]

def foldChunks[I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, Chunk[I]) ⇒ S): ZSink[Any, Nothing, I, S]

def foldChunksM[R, E, I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, Chunk[I]) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

def foldLeft[I, S](z: S)(f: (S, I) ⇒ S): ZSink[Any, Nothing, I, S]

def foldLeftChunks[I, S](z: S)(f: (S, Chunk[I]) ⇒ S): ZSink[Any, Nothing, I, S]

def foldLeftChunksM[R, E, I, S](z: S)(f: (S, Chunk[I]) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

def foldLeftM[R, E, I, S](z: S)(f: (S, I) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

def foldM[R, E, I, S](z: S)(contFn: (S) ⇒ Boolean)(f: (S, I) ⇒ ZIO[R, E, S]): ZSink[R, E, I, S]

def foreach[R, E, I](f: (I) ⇒ ZIO[R, E, Any]): ZSink[R, E, I, Unit]

def fromEffect[R, E, Z](b: ⇒ ZIO[R, E, Z]): ZSink[R, E, Any, Z]

final def fromOutputStream(os: OutputStream): ZSink[Blocking, IOException, Byte, Int]

def fromPush[R, E, I, Z](sink: Push[R, E, I, Z]): ZSink[R, E, I, Z]

final def getClass(): Class[_]

def halt[E](e: ⇒ Cause[E]): ZSink[Any, E, Any, Nothing]

def hashCode(): Int

def head[I]: ZSink[Any, Nothing, I, Option[I]]

final def isInstanceOf[T0]: Boolean

def last[I]: ZSink[Any, Nothing, I, Option[I]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def succeed[Z](z: ⇒ Z): ZSink[Any, Nothing, Any, Z]

def sum[A](implicit A: Numeric[A]): ZSink[Any, Nothing, A, A]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from ZSinkPlatformSpecificConstructors

Inherited from AnyRef

Inherited from Any

Ungrouped