abstract class ZSink[-R, +E, -I, +L, +Z] extends AnyRef
- Self Type
- ZSink[R, E, I, L, Z]
- Alphabetic
- By Inheritance
- ZSink
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def &>[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Z1]
Operator alias for zipParRight.
- final def *>[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z1]
Operator alias for zipRight.
- final def <&[R1 <: R, E1 >: E, I1 <: I, L1 >: L](that: ZSink[R1, E1, I1, L1, Any]): ZSink[R1, E1, I1, L1, Z]
Operator alias for zipParLeft.
- final def <&>[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, (Z, Z1)]
Operator alias for zipPar.
- final def <*[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z]
Operator alias for zipLeft.
- final def <*>[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, (Z, Z1)]
Operator alias for zip.
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def as[Z2](z: => Z2): ZSink[R, E, I, L, Z2]
Replaces this sink's result with the provided value.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collectAllWhileWith[S](z: S)(p: (Z) => Boolean)(f: (S, Z) => S)(implicit ev: <:<[L, I]): ZSink[R, E, I, L, S]
Repeatedly runs the sink for as long as its results satisfy the predicate
p
.Repeatedly runs the sink for as long as its results satisfy the predicate
p
. The sink's results will be accumulated using the stepping functionf
. - def contramap[I2](f: (I2) => I): ZSink[R, E, I2, L, Z]
Transforms this sink's input elements.
- def contramapChunks[I2](f: (Chunk[I2]) => Chunk[I]): ZSink[R, E, I2, L, Z]
Transforms this sink's input chunks.
Transforms this sink's input chunks.
f
must preserve chunking-invariance - def contramapChunksM[R1 <: R, E1 >: E, I2](f: (Chunk[I2]) => ZIO[R1, E1, Chunk[I]]): ZSink[R1, E1, I2, L, Z]
Effectfully transforms this sink's input chunks.
Effectfully transforms this sink's input chunks.
f
must preserve chunking-invariance - def contramapM[R1 <: R, E1 >: E, I2](f: (I2) => ZIO[R1, E1, I]): ZSink[R1, E1, I2, L, Z]
Effectfully transforms this sink's input elements.
- def dimap[I2, Z2](f: (I2) => I, g: (Z) => Z2): ZSink[R, E, I2, L, Z2]
Transforms both inputs and result of this sink using the provided functions.
- def dimapChunks[I2, Z2](f: (Chunk[I2]) => Chunk[I], g: (Z) => Z2): ZSink[R, E, I2, L, Z2]
Transforms both input chunks and result of this sink using the provided functions.
- def dimapChunksM[R1 <: R, E1 >: E, I2, Z2](f: (Chunk[I2]) => ZIO[R1, E1, Chunk[I]], g: (Z) => ZIO[R1, E1, Z2]): ZSink[R1, E1, I2, L, Z2]
Effectfully transforms both input chunks and result of this sink using the provided functions.
Effectfully transforms both input chunks and result of this sink using the provided functions.
f
andg
must preserve chunking-invariance - def dimapM[R1 <: R, E1 >: E, I2, Z2](f: (I2) => ZIO[R1, E1, I], g: (Z) => ZIO[R1, E1, Z2]): ZSink[R1, E1, I2, L, Z2]
Effectfully transforms both inputs and result of this sink using the provided functions.
- def dropLeftover: ZSink[R, E, I, Nothing, Z]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def exposeLeftover: ZSink[R, E, I, Nothing, (Z, Chunk[L])]
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatMap[R1 <: R, E1 >: E, I2 <: I, L2, Z2](f: (Z) => ZSink[R1, E1, I2, L2, Z2])(implicit ev: <:<[L, I2]): ZSink[R1, E1, I2, L2, Z2]
Runs this sink until it yields a result, then uses that result to create another sink from the provided function which will continue to run until it yields a result.
Runs this sink until it yields a result, then uses that result to create another sink from the provided function which will continue to run until it yields a result.
This function essentially runs sinks in sequence.
- def foldM[R1 <: R, E2, I2 <: I, L2, Z2](failure: (E) => ZSink[R1, E2, I2, L2, Z2], success: (Z) => ZSink[R1, E2, I2, L2, Z2])(implicit ev: <:<[L, I2]): ZSink[R1, E2, I2, L2, Z2]
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def map[Z2](f: (Z) => Z2): ZSink[R, E, I, L, Z2]
Transforms this sink's result.
- def mapError[E2](f: (E) => E2): ZSink[R, E2, I, L, Z]
Transforms the errors emitted by this sink using
f
. - def mapM[R1 <: R, E1 >: E, Z2](f: (Z) => ZIO[R1, E1, Z2]): ZSink[R1, E1, I, L, Z2]
Effectfully transforms this sink's result.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def provide(r: R)(implicit ev: NeedsEnv[R]): ZSink[Any, E, I, L, Z]
Provides the sink with its required environment, which eliminates its dependency on
R
. - val push: ZManaged[R, Nothing, Push[R, E, I, L, Z]]
- final def race[R1 <: R, E1 >: E, A0, I1 <: I, L1 >: L, Z1 >: Z](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Z1]
Runs both sinks in parallel on the input, , returning the result or the error from the one that finishes first.
- final def raceBoth[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Either[Z, Z1]]
Runs both sinks in parallel on the input, returning the result or the error from the one that finishes first.
- final def summarized[R1 <: R, E1 >: E, B, C](summary: ZIO[R1, E1, B])(f: (B, B) => C): ZSink[R1, E1, I, L, (Z, C)]
Summarize a sink by running an effect when the sink starts and again when it completes
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- final def timed: ZSink[R with Clock, E, I, L, (Z, Duration)]
Returns the sink that executes this one and times its execution.
- def toString(): String
- Definition Classes
- AnyRef → Any
- def toTransducer(implicit ev: <:<[L, I]): ZTransducer[R, E, I, Z]
Converts this sink to a transducer that feeds incoming elements to the sink and emits the sink's results as outputs.
Converts this sink to a transducer that feeds incoming elements to the sink and emits the sink's results as outputs. The sink will be restarted when it ends.
- def untilOutputM[R1 <: R, E1 >: E](f: (Z) => ZIO[R1, E1, Boolean])(implicit ev: <:<[L, I]): ZSink[R1, E1, I, L, Option[Z]]
Creates a sink that produces values until one verifies the predicate
f
. - final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def zip[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, (Z, Z1)]
Feeds inputs to this sink until it yields a result, then switches over to the provided sink until it yields a result, combining the two results in a tuple.
- final def zipLeft[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z]
Like zip, but keeps only the result from the
that
sink. - final def zipPar[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, (Z, Z1)]
Runs both sinks in parallel on the input and combines the results in a tuple.
- final def zipParLeft[R1 <: R, E1 >: E, I1 <: I, L1 >: L](that: ZSink[R1, E1, I1, L1, Any]): ZSink[R1, E1, I1, L1, Z]
Like zipPar, but keeps only the result from this sink.
- final def zipParRight[R1 <: R, E1 >: E, I1 <: I, Z1, L1 >: L](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Z1]
Like zipPar, but keeps only the result from the
that
sink. - final def zipRight[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z1]
Like zip, but keeps only the result from this sink.
- final def zipWith[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(f: (Z, Z1) => Z2)(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z2]
Feeds inputs to this sink until it yields a result, then switches over to the provided sink until it yields a result, finally combining the two results with
f
. - final def zipWithPar[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(f: (Z, Z1) => Z2): ZSink[R1, E1, I1, L1, Z2]
Runs both sinks in parallel on the input and combines the results using the provided function.
- final def |[R1 <: R, E1 >: E, A0, I1 <: I, L1 >: L, Z1 >: Z](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Z1]
Operator alias for race.