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
- 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, 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])(implicit zippable: Zippable[Z, Z1]): ZSink[R1, E1, I1, L1, Out]
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 zippable: Zippable[Z, Z1], ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Out]
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( ... ) @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
contramapChunksZIO[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
contramapZIO[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
dimapChunksZIO[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
dimapZIO[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: Any): 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 foldSink[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[_]
- 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
mapZIO[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
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
final
def
timed: ZSink[R with Has[Clock], E, I, L, (Z, zio.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
untilOutputZIO[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( ... )
-
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, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit zippable: Zippable[Z, Z1], ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Out]
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])(implicit zippable: Zippable[Z, Z1]): ZSink[R1, E1, I1, L1, Out]
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.
Deprecated Value Members
-
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- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use contramapChunksZIO
-
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.
Effectfully transforms this sink's input elements.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use contramapZIO
-
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- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use dimapChunksZIO
-
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.
Effectfully transforms both inputs and result of this sink using the provided functions.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use dimapZIO
-
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]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldSink
-
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.
Effectfully transforms this sink's result.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use mapZIO
-
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
.Creates a sink that produces values until one verifies the predicate
f
.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use untilOutputZIO