SinkPure

abstract def extractPure(s: State): Either[E, B]

abstract def initialPure: Step[State, Nothing]

abstract def stepPure(s: State, a: A): Step[State, A0]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def ?: Sink[Nothing, A0, A, Option[B]]

Returns a new sink that tries to produce the B, but if there is an error in stepping or extraction, produces None.

final def asInstanceOf[T0]: T0

final def chunked[A1 >: A0, A2 <: A]: Sink[E, A1, Chunk[A2], B]

Takes a Sink, and lifts it to be chunked in its input and output.

def clone(): AnyRef

final def const[C](c: ⇒ C): Sink[E, A0, A, C]

def contramap[C](f: (C) ⇒ A): SinkPure[E, A0, C, B]

final def contramapM[E1 >: E, C](f: (C) ⇒ IO[E1, A]): Sink[E1, A0, C, B]

def dimap[C, D](f: (C) ⇒ A)(g: (B) ⇒ D): SinkPure[E, A0, C, D]

final def dropWhile[A1 <: A](pred: (A1) ⇒ Boolean): Sink[E, A0, A1, B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extract(s: State): IO[E, B]

def filter[A1 <: A](f: (A1) ⇒ Boolean): SinkPure[E, A0, A1, B]

Filters the inputs fed to this sink.

final def filterM[E1 >: E, A1 <: A](f: (A1) ⇒ IO[E1, Boolean]): Sink[E1, A0, A1, B]

Effectfully filters the inputs fed to this sink.

final def filterNot[A1 <: A](f: (A1) ⇒ Boolean): Sink[E, A0, A1, B]

final def filterNotM[E1 >: E, A1 <: A](f: (A1) ⇒ IO[E1, Boolean]): Sink[E1, A0, A1, B]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def initial: IO[Nothing, Step[State, Nothing]]

final def isInstanceOf[T0]: Boolean

def map[C](f: (B) ⇒ C): SinkPure[E, A0, A, C]

Maps the value produced by this sink.

def mapError[E1](f: (E) ⇒ E1): Sink[E1, A0, A, B]

final def mapM[E1 >: E, C](f: (B) ⇒ IO[E1, C]): Sink[E1, A0, A, C]

Effectfully maps the value produced by this sink.

def mapRemainder[A1](f: (A0) ⇒ A1): SinkPure[E, A1, A, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def optional: Sink[Nothing, A0, A, Option[B]]

A named alias for ?.

final def race[E1 >: E, A2 >: A0, A1 <: A, B1 >: B](that: Sink[E1, A2, A1, B1]): Sink[E1, A2, A1, B1]

Runs both sinks in parallel on the input, returning the result from the one that finishes successfully first.

final def raceBoth[E1 >: E, A2 >: A0, A1 <: A, C](that: Sink[E1, A2, A1, C]): Sink[E1, A2, A1, Either[B, C]]

Runs both sinks in parallel on the input, returning the result from the one that finishes successfully first.

def step(s: State, a: A): IO[Nothing, Step[State, A0]]

def stepChunk[A1 <: A](state: State, as: Chunk[A1]): IO[E, Step[State, A0]]

def stepChunkPure[A1 <: A](s: State, as: Chunk[A1]): Step[State, A0]

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

final def takeWhile[A1 <: A](pred: (A1) ⇒ Boolean): Sink[E, A0, A1, B]

def toString(): String

final def untilOutput(f: (B) ⇒ Boolean): Sink[E, A0, A, B]

final def update(state: Step[State, Nothing]): Sink[E, A0, A, B]

final def void: Sink[E, A0, A, Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def |[E1 >: E, A2 >: A0, A1 <: A, B1 >: B](that: Sink[E1, A2, A1, B1]): Sink[E1, A2, A1, B1]

A named alias for race.