trait
ZSink[-R, +E, +A0, -A, +B] extends AnyRef
Type Members
-
abstract
type
State
Abstract Value Members
-
abstract
def
extract(state: State): ZIO[R, E, B]
-
-
abstract
def
step(state: State, a: A): ZIO[R, E, Step[State, A0]]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: Any): Boolean
-
-
final
def
asInstanceOf[T0]: T0
-
final
def
chunked[A1 >: A0, A2 <: A]: ZSink[R, E, A1, Chunk[A2], B]
-
def
clone(): AnyRef
-
final
def
const[C](c: ⇒ C): ZSink[R, E, A0, A, C]
-
def
contramap[C](f: (C) ⇒ A): ZSink[R, E, A0, C, B]
-
final
def
contramapM[R1 <: R, E1 >: E, C](f: (C) ⇒ ZIO[R1, E1, A]): ZSink[R1, E1, A0, C, B]
-
def
dimap[C, D](f: (C) ⇒ A)(g: (B) ⇒ D): ZSink[R, E, A0, C, D]
-
final
def
dropWhile[A1 <: A](pred: (A1) ⇒ Boolean): ZSink[R, E, A0, A1, B]
-
-
-
def
filter[A1 <: A](f: (A1) ⇒ Boolean): ZSink[R, E, A0, A1, B]
-
final
def
filterM[R1 <: R, E1 >: E, A1 <: A](f: (A1) ⇒ IO[E1, Boolean]): ZSink[R1, E1, A0, A1, B]
-
final
def
filterNot[A1 <: A](f: (A1) ⇒ Boolean): ZSink[R, E, A0, A1, B]
-
final
def
filterNotM[E1 >: E, A1 <: A](f: (A1) ⇒ IO[E1, Boolean]): ZSink[R, E1, A0, A1, B]
-
def
finalize(): Unit
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
final
def
isInstanceOf[T0]: Boolean
-
def
map[C](f: (B) ⇒ C): ZSink[R, E, A0, A, C]
-
def
mapError[E1](f: (E) ⇒ E1): ZSink[R, E1, A0, A, B]
-
final
def
mapM[R1 <: R, E1 >: E, C](f: (B) ⇒ ZIO[R1, E1, C]): ZSink[R1, E1, A0, A, C]
-
def
mapRemainder[A1](f: (A0) ⇒ A1): ZSink[R, E, A1, A, B]
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
optional: ZSink[R, Nothing, A0, A, Option[B]]
-
def
provideSome[R1](f: (R1) ⇒ R): ZSink[R1, E, A0, A, B]
-
final
def
race[R1 <: R, E1 >: E, A2 >: A0, A1 <: A, B1 >: B](that: ZSink[R1, E1, A2, A1, B1]): ZSink[R1, E1, A2, A1, B1]
-
final
def
raceBoth[R1 <: R, E1 >: E, A2 >: A0, A1 <: A, C](that: ZSink[R1, E1, A2, A1, C]): ZSink[R1, E1, A2, A1, Either[B, C]]
-
def
stepChunk[A1 <: A](state: State, as: Chunk[A1]): ZIO[R, E, Step[State, A0]]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
final
def
takeWhile[A1 <: A](pred: (A1) ⇒ Boolean): ZSink[R, E, A0, A1, B]
-
def
toString(): String
-
final
def
untilOutput(f: (B) ⇒ Boolean): ZSink[R, E, A0, A, B]
-
final
def
update(state: Step[State, Nothing]): ZSink[R, E, A0, A, B]
-
final
def
void: ZSink[R, E, A0, A, Unit]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
final
def
|[R1 <: R, E1 >: E, A2 >: A0, A1 <: A, B1 >: B](that: ZSink[R1, E1, A2, A1, B1]): ZSink[R1, E1, A2, A1, B1]
A
Sink[E, A0, A, B]
consumes values of typeA
, ultimately producing either an error of typeE
, or a value of typeB
together with a remainder of typeA0
.Sinks form monads and combine in the usual ways.