abstract class ZSink[-R, +E, -I, +Z] extends AnyRef
- Self Type
- ZSink[R, E, I, Z]
- Alphabetic
- By Inheritance
- ZSink
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]
Operator alias for zipParRight.
-
final
def
*>[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]
Operator alias for zipRight.
-
final
def
<&[R1 <: R, E1 >: E, I1 <: I](that: ZSink[R1, E1, I1, Any]): ZSink[R1, E1, I1, Z]
Operator alias for zipParLeft.
-
final
def
<&>[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (Z, Z1)]
Operator alias for zipPar.
-
final
def
<*[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z]
Operator alias for zipLeft.
-
final
def
<*>[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (Z, Z1)]
Operator alias for zip.
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
as[Z2](z: ⇒ Z2): ZSink[R, E, I, 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( ... ) @native()
-
def
collectAllWhileWith[S](z: S)(p: (Z) ⇒ Boolean)(f: (S, Z) ⇒ S): ZSink[R, E, I, 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, Z]
Transforms this sink's input elements.
-
def
contramapChunks[I2](f: (Chunk[I2]) ⇒ Chunk[I]): ZSink[R, E, I2, Z]
Transforms this sink's input chunks.
-
def
contramapChunksM[R1 <: R, E1 >: E, I2](f: (Chunk[I2]) ⇒ ZIO[R1, E1, Chunk[I]]): ZSink[R1, E1, I2, Z]
Effectfully transforms this sink's input chunks.
-
def
contramapM[R1 <: R, E1 >: E, I2](f: (I2) ⇒ ZIO[R1, E1, I]): ZSink[R1, E1, I2, Z]
Effectfully transforms this sink's input elements.
-
def
dimap[I2, Z2](f: (I2) ⇒ I, g: (Z) ⇒ Z2): ZSink[R, E, I2, 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, 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, Z2]
Effectfully transforms both input chunks and result of this sink using the provided functions.
-
def
dimapM[R1 <: R, E1 >: E, I2, Z2](f: (I2) ⇒ ZIO[R1, E1, I], g: (Z) ⇒ ZIO[R1, E1, Z2]): ZSink[R1, E1, I2, Z2]
Effectfully transforms both inputs and result of this sink using the provided functions.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flatMap[R1 <: R, E1 >: E, I2 <: I, Z2](f: (Z) ⇒ ZSink[R1, E1, I2, Z2]): ZSink[R1, E1, I2, 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 foldCauseM[R1 <: R, E2, I2 <: I, Z2](failure: (Cause[E]) ⇒ ZSink[R1, E2, I2, Z2], success: (Z) ⇒ ZSink[R1, E2, I2, Z2]): ZSink[R1, E2, I2, Z2]
- def foldM[R1 <: R, E2, I2 <: I, Z2](failure: (E) ⇒ ZSink[R1, E2, I2, Z2], success: (Z) ⇒ ZSink[R1, E2, I2, Z2]): ZSink[R1, E2, I2, Z2]
-
final
def
getClass(): Class[_]
- 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, Z2]
Transforms this sink's result.
-
def
mapError[E2](f: (E) ⇒ E2): ZSink[R, E2, I, 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, 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()
- val push: ZManaged[R, Nothing, Push[R, E, I, Z]]
-
final
def
race[R1 <: R, E1 >: E, A0, I1 <: I, Z1 >: Z](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, 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, A0, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, 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
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
toTransducer: 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]): ZSink[R1, E1, I, Option[Z]]
Creates a sink that produces values until one verifies the predicate
f
. -
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( ... ) @native()
-
final
def
zip[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (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, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z]
Like zip, but keeps only the result from the
that
sink. -
final
def
zipPar[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (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](that: ZSink[R1, E1, I1, Any]): ZSink[R1, E1, I1, Z]
Like zipPar, but keeps only the result from this sink.
-
final
def
zipParRight[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]
Like zipPar, but keeps only the result from the
that
sink. -
final
def
zipRight[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]
Like zip, but keeps only the result from this sink.
-
final
def
zipWith[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1])(f: (Z, Z1) ⇒ Z2): ZSink[R1, E1, I1, 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, Z1, Z2](that: ZSink[R1, E1, I1, Z1])(f: (Z, Z1) ⇒ Z2): ZSink[R1, E1, I1, 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, Z1 >: Z](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]
Operator alias for race.