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
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]

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