final class ZSink[-R, +E, -In, +L, +Z] extends AnyVal
- Self Type
- ZSink[R, E, In, L, Z]
- Alphabetic
- By Inheritance
- ZSink
- AnyVal
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
##(): Int
- Definition Classes
- Any
-
def
&>[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z1]
Operator alias for zipParRight.
-
def
*>[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z1]
Operator alias for zipRight.
-
def
<&[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z]
Operator alias for zipParLeft.
-
def
<&>[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit zippable: Zippable[Z, Z1], trace: Trace): ZSink[R1, E1, In1, L1, Out]
Operator alias for zipPar.
-
def
<*[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z]
Operator alias for zipLeft.
-
def
<*>[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit zippable: Zippable[Z, Z1], ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Out]
Operator alias for zip.
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- Any
-
def
as[Z2](z: ⇒ Z2)(implicit trace: Trace): ZSink[R, E, In, L, Z2]
Replaces this sink's result with the provided value.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- val channel: ZChannel[R, ZNothing, Chunk[In], Any, E, Chunk[L], Z]
-
def
collectAll(implicit ev: <:<[L, In], trace: Trace): ZSink[R, E, In, L, Chunk[Z]]
Repeatedly runs the sink and accumulates its results into a chunk
-
def
collectAllWhileWith[S](z: ⇒ S)(p: (Z) ⇒ Boolean)(f: (S, Z) ⇒ S)(implicit ev: <:<[L, In], trace: Trace): ZSink[R, E, In, 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
collectLeftover(implicit trace: Trace): ZSink[R, E, In, Nothing, (Z, Chunk[L])]
Collects the leftovers from the stream when the sink succeeds and returns them as part of the sink's result
-
def
contramap[In1](f: (In1) ⇒ In)(implicit trace: Trace): ZSink[R, E, In1, L, Z]
Transforms this sink's input elements.
-
def
contramapChunks[In1](f: (Chunk[In1]) ⇒ Chunk[In])(implicit trace: Trace): ZSink[R, E, In1, 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, In1](f: (Chunk[In1]) ⇒ ZIO[R1, E1, Chunk[In]])(implicit trace: Trace): ZSink[R1, E1, In1, 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, In1](f: (In1) ⇒ ZIO[R1, E1, In])(implicit trace: Trace): ZSink[R1, E1, In1, L, Z]
Effectfully transforms this sink's input elements.
-
def
dimap[In1, Z1](f: (In1) ⇒ In, g: (Z) ⇒ Z1)(implicit trace: Trace): ZSink[R, E, In1, L, Z1]
Transforms both inputs and result of this sink using the provided functions.
-
def
dimapChunks[In1, Z1](f: (Chunk[In1]) ⇒ Chunk[In], g: (Z) ⇒ Z1)(implicit trace: Trace): ZSink[R, E, In1, L, Z1]
Transforms both input chunks and result of this sink using the provided functions.
-
def
dimapChunksZIO[R1 <: R, E1 >: E, In1, Z1](f: (Chunk[In1]) ⇒ ZIO[R1, E1, Chunk[In]], g: (Z) ⇒ ZIO[R1, E1, Z1])(implicit trace: Trace): ZSink[R1, E1, In1, L, Z1]
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, In1, Z1](f: (In1) ⇒ ZIO[R1, E1, In], g: (Z) ⇒ ZIO[R1, E1, Z1])(implicit trace: Trace): ZSink[R1, E1, In1, L, Z1]
Effectfully transforms both inputs and result of this sink using the provided functions.
-
final
def
ensuring[R1 <: R](finalizer: ⇒ URIO[R1, Any])(implicit trace: Trace): ZSink[R1, E, In, L, Z]
Returns a new sink with an attached finalizer.
Returns a new sink with an attached finalizer. The finalizer is guaranteed to be executed so long as the sink begins execution (and regardless of whether or not it completes).
-
final
def
ensuringWith[R1 <: R](finalizer: (Exit[E, Z]) ⇒ URIO[R1, Any])(implicit trace: Trace): ZSink[R1, E, In, L, Z]
Returns a new sink with an attached finalizer.
Returns a new sink with an attached finalizer. The finalizer is guaranteed to be executed so long as the sink begins execution (and regardless of whether or not it completes).
-
def
filterInput[In1 <: In](p: (In1) ⇒ Boolean)(implicit trace: Trace): ZSink[R, E, In1, L, Z]
Filters the sink's input with the given predicate
-
def
filterInputZIO[R1 <: R, E1 >: E, In1 <: In](p: (In1) ⇒ ZIO[R1, E1, Boolean])(implicit trace: Trace): ZSink[R1, E1, In1, L, Z]
Filters the sink's input with the given ZIO predicate
-
def
findZIO[R1 <: R, E1 >: E](f: (Z) ⇒ ZIO[R1, E1, Boolean])(implicit ev: <:<[L, In], trace: Trace): ZSink[R1, E1, In, L, Option[Z]]
Creates a sink that produces values until one verifies the predicate
f
. -
def
flatMap[R1 <: R, E1 >: E, In1 <: In, L1 >: L <: In1, Z1](f: (Z) ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z1]
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, In1 <: In, L1 >: L <: In1, Z1](failure: (E) ⇒ ZSink[R1, E2, In1, L1, Z1], success: (Z) ⇒ ZSink[R1, E2, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E2, In1, L1, Z1]
Folds over the result of the sink
-
def
getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
-
def
ignoreLeftover(implicit trace: Trace): ZSink[R, E, In, Nothing, Z]
Drains the remaining elements from the stream after the sink finishes
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
map[Z2](f: (Z) ⇒ Z2)(implicit trace: Trace): ZSink[R, E, In, L, Z2]
Transforms this sink's result.
-
def
mapError[E2](f: (E) ⇒ E2)(implicit trace: Trace): ZSink[R, E2, In, L, Z]
Transforms the errors emitted by this sink using
f
. -
def
mapErrorCause[E2](f: (Cause[E]) ⇒ Cause[E2])(implicit trace: Trace): ZSink[R, E2, In, L, Z]
Transforms the full causes of failures emitted by this sink.
-
def
mapLeftover[L2](f: (L) ⇒ L2)(implicit trace: Trace): ZSink[R, E, In, L2, Z]
Transforms the leftovers emitted by this sink using
f
. -
def
mapZIO[R1 <: R, E1 >: E, Z1](f: (Z) ⇒ ZIO[R1, E1, Z1])(implicit trace: Trace): ZSink[R1, E1, In, L, Z1]
Effectfully transforms this sink's result.
-
def
orElse[R1 <: R, In1 <: In, E2 >: E, L1 >: L, Z1 >: Z](that: ⇒ ZSink[R1, E2, In1, L1, Z1])(implicit trace: Trace): ZSink[R1, E2, In1, L1, Z1]
Switch to another sink in case of failure
-
def
provideEnvironment(r: ⇒ ZEnvironment[R])(implicit trace: Trace): ZSink[Any, E, In, L, Z]
Provides the sink with its required environment, which eliminates its dependency on
R
. -
def
provideLayer[E1 >: E, R0](layer: ⇒ ZLayer[R0, E1, R])(implicit trace: Trace): ZSink[R0, E1, In, L, Z]
Provides a layer to the sink, which translates it to another level.
-
def
provideSomeEnvironment[R0](f: (ZEnvironment[R0]) ⇒ ZEnvironment[R])(implicit trace: Trace): ZSink[R0, E, In, L, Z]
Transforms the environment being provided to the sink with the specified function.
-
def
provideSomeLayer[R0]: ProvideSomeLayer[R0, R, E, In, L, Z]
Splits the environment into two parts, providing one part using the specified layer and leaving the remainder
R0
.Splits the environment into two parts, providing one part using the specified layer and leaving the remainder
R0
.val loggingLayer: ZLayer[Any, Nothing, Logging] = ??? val sink: ZSink[Logging with Database, Nothing, Unit] = ??? val sink2 = sink.provideSomeLayer[Database](loggingLayer)
-
def
race[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L, Z1 >: Z](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit trace: Trace): ZSink[R1, E1, In1, L1, Z1]
Runs both sinks in parallel on the input, , returning the result or the error from the one that finishes first.
-
def
raceBoth[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L, Z2](that: ⇒ ZSink[R1, E1, In1, L1, Z2], capacity: ⇒ Int = 16)(implicit trace: Trace): ZSink[R1, E1, In1, L1, Either[Z, Z2]]
Runs both sinks in parallel on the input, returning the result or the error from the one that finishes first.
-
def
raceWith[R1 <: R, E1 >: E, A0, In1 <: In, L1 >: L, Z1, Z2](that: ⇒ ZSink[R1, E1, In1, L1, Z1], capacity: ⇒ Int = 16)(leftDone: (Exit[E, Z]) ⇒ MergeDecision[R1, E1, Z1, E1, Z2], rightDone: (Exit[E1, Z1]) ⇒ MergeDecision[R1, E, Z, E1, Z2])(implicit trace: Trace): ZSink[R1, E1, In1, L1, Z2]
Runs both sinks in parallel on the input, using the specified merge function as soon as one result or the other has been computed.
- def refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E], trace: Trace): ZSink[R, E1, In, L, Z]
- def refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) ⇒ Throwable)(implicit ev: CanFail[E], trace: Trace): ZSink[R, E1, In, L, Z]
-
def
splitWhere[In1 <: In](f: (In1) ⇒ Boolean)(implicit ev: <:<[L, In1], trace: Trace): ZSink[R, E, In1, In1, Z]
Splits the sink on the specified predicate, returning a new sink that consumes elements until an element after the first satisfies the specified predicate.
-
def
summarized[R1 <: R, E1 >: E, B, C](summary: ⇒ ZIO[R1, E1, B])(f: (B, B) ⇒ C)(implicit trace: Trace): ZSink[R1, E1, In, L, (Z, C)]
Summarize a sink by running an effect when the sink starts and again when it completes
-
def
timed(implicit trace: Trace): ZSink[R, E, In, L, (Z, zio.Duration)]
Returns the sink that executes this one and times its execution.
-
def
toChannel: ZChannel[R, ZNothing, Chunk[In], Any, E, Chunk[L], Z]
Converts ths sink to its underlying channel
-
def
toString(): String
- Definition Classes
- Any
-
def
zip[R1 <: R, In1 <: In, E1 >: E, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit zippable: Zippable[Z, Z1], ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Out]
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 into a tuple.
-
def
zipLeft[R1 <: R, In1 <: In, E1 >: E, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z]
Like zip, but keeps only the result from the
that
sink. -
def
zipPar[R1 <: R, In1 <: In, E1 >: E, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit zippable: Zippable[Z, Z1], trace: Trace): ZSink[R1, E1, In1, L1, Out]
Runs both sinks in parallel on the input and combines the results in a tuple.
-
def
zipParLeft[R1 <: R, In1 <: In, E1 >: E, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit trace: Trace): ZSink[R1, E1, In1, L1, Z]
Like zipPar, but keeps only the result from this sink.
-
def
zipParRight[R1 <: R, In1 <: In, E1 >: E, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit trace: Trace): ZSink[R1, E1, In1, L1, Z1]
Like zipPar, but keeps only the result from the
that
sink. -
def
zipRight[R1 <: R, In1 <: In, E1 >: E, L1 >: L <: In1, Z1](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, L1, Z1]
Like zip, but keeps only the result from this sink.
-
def
zipWith[R1 <: R, E1 >: E, In1 <: In, L1 >: L <: In1, Z1, Z2](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(f: (Z, Z1) ⇒ Z2)(implicit ev: <:<[L, In1], trace: Trace): ZSink[R1, E1, In1, 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
. -
def
zipWithPar[R1 <: R, E1 >: E, In1 <: In, L1 >: L <: In1, Z1, Z2](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(f: (Z, Z1) ⇒ Z2)(implicit trace: Trace): ZSink[R1, E1, In1, L1, Z2]
Runs both sinks in parallel on the input and combines the results using the provided function.
-
def
|[R1 <: R, E1 >: E, In1 <: In, L1 >: L, Z1 >: Z](that: ⇒ ZSink[R1, E1, In1, L1, Z1])(implicit trace: Trace): ZSink[R1, E1, In1, L1, Z1]
Operator alias for race.