ZIO
Related Docs:
object ZIO
| package zio
An integer that identifies the term in the ZIO sum type to which this
instance belongs (e.g.
An integer that identifies the term in the ZIO sum type to which this
instance belongs (e.g. IO.Tags.Succeed).
A symbolic alias for orDie.
Returns the logical conjunction of the Boolean value returned by this
effect and the Boolean value returned by the specified effect.
Returns the logical conjunction of the Boolean value returned by this
effect and the Boolean value returned by the specified effect. This
operator has "short circuiting" behavior so if the value returned by this
effect is false the specified effect will not be evaluated.
Returns an effect that executes both this effect and the specified effect, in parallel, returning result of provided effect.
Returns an effect that executes both this effect and the specified effect, in parallel, returning result of provided effect. If either side fails, then the other side will be interrupted.
A variant of flatMap that ignores the value produced by this effect.
Returns an effect that executes both this effect and the specified effect, in parallel, this effect result returned.
Returns an effect that executes both this effect and the specified effect, in parallel, this effect result returned. If either side fails, then the other side will be interrupted.
Returns an effect that executes both this effect and the specified effect, in parallel, combining their results into a tuple.
Returns an effect that executes both this effect and the specified effect, in parallel, combining their results into a tuple. If either side fails, then the other side will be interrupted.
Sequences the specified effect after this effect, but ignores the value produced by the effect.
Sequentially zips this effect with the specified effect, combining the results into a tuple.
A symbolic alias for orElseEither.
Operator alias for orElse.
A symbolic alias for raceEither.
Syntax for adding aspects.
Returns an effect that submerges the error case of an Either into the
ZIO.
Returns an effect that submerges the error case of an Either into the
ZIO. The inverse operation of ZIO.either.
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
Uncurried version.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but it doesn't allocate intermediate zio.ZIO.AcquireDiscard and zio.ZIO.ReleaseDiscard objects.
A less powerful variant of acquireReleaseWith where the resource acquired
by this effect is not needed.
Shorthand for the curried version of ZIO.acquireReleaseExitWith.
Shorthand for the uncurried version of ZIO.acquireReleaseExitWith.
Executes the release effect only if there was an error.
Shorthand for the curried version of ZIO.acquireReleaseWith.
Shorthand for the uncurried version of ZIO.acquireReleaseWith.
Maps the success value of this effect to the specified constant value.
Maps the success value of this effect to a left value.
Maps the error value of this effect to a left value.
Maps the success value of this effect to a right value.
Maps the error value of this effect to a right value.
Maps the success value of this effect to an optional value.
Maps the error value of this effect to an optional value.
Returns a new effect that will not succeed with its value before first waiting for the end of all child fibers forked by the effect.
Returns an effect that, if evaluated, will return the cached result of this effect.
Returns an effect that, if evaluated, will return the cached result of this
effect. Cached results will expire after timeToLive duration.
Returns an effect that, if evaluated, will return the cached result of this effect.
Returns an effect that, if evaluated, will return the cached result of this
effect. Cached results will expire after timeToLive duration. In
addition, returns an effect that can be used to invalidate the current
cached value before the timeToLive duration expires.
Recovers from all errors.
Recovers from all errors.
openFile("config.json").catchAll(_ => IO.succeed(defaultConfig))
Recovers from all errors with provided Cause.
Recovers from all errors with provided Cause.
openFile("config.json").catchAllCause(_ => IO.succeed(defaultConfig))
absorb, sandbox, mapErrorCause - other functions that can recover from defects
Recovers from all defects with provided function.
Recovers from all defects with provided function.
effect.catchSomeDefect(_ => backup())WARNING: There is no sensible way to recover from defects. This method should be used only at the boundary between ZIO and an external system, to transmit information on a defect for diagnostic or explanatory purposes.
A version of catchAll that gives you the (optional) trace of the error.
Recovers from all NonFatal Throwables.
Recovers from all NonFatal Throwables.
openFile("data.json").catchNonFatalOrDie(_ => openFile("backup.json"))
Recovers from some or all of the error cases.
Recovers from some or all of the error cases.
openFile("data.json").catchSome { case _: FileNotFoundException => openFile("backup.json") }
Recovers from some or all of the error cases with provided cause.
Recovers from some or all of the error cases with provided cause.
openFile("data.json").catchSomeCause { case c if (c.interrupted) => openFile("backup.json") }
Recovers from some or all of the defects with provided partial function.
Recovers from some or all of the defects with provided partial function.
effect.catchSomeDefect {
case _: SecurityException => backup()
}WARNING: There is no sensible way to recover from defects. This method should be used only at the boundary between ZIO and an external system, to transmit information on a defect for diagnostic or explanatory purposes.
A version of catchSome that gives you the trace of the error.
Returns an effect that succeeds with the cause of failure of this effect,
or Cause.empty if the effect did succeed.
Fail with e if the supplied PartialFunction does not match, otherwise
succeed with the returned value.
Fail with e if the supplied PartialFunction does not match, otherwise
continue with the returned value.
Taps the effect, printing the result of calling .toString on the value.
Taps the effect, printing the result of calling .toString on the value.
Prefixes the output with the given message.
Taps the effect, printing the result of calling .toString on the value
Returns an effect that is delayed from this effect by the specified zio.Duration.
Returns an effect whose interruption will be disconnected from the fiber's own interruption, being performed in the background without slowing down the fiber's interruption.
Returns an effect whose interruption will be disconnected from the fiber's own interruption, being performed in the background without slowing down the fiber's interruption.
This method is useful to create "fast interrupting" effects. For example, if you call this on an acquire release effect, then even if the effect is "stuck" in acquire or release, its interruption will return immediately, while the acquire / release are performed in the background.
See timeout and race for other applications.
Returns an effect whose failure and success have been lifted into an
Either.The resulting effect cannot fail, because the failure case has
been exposed as part of the Either success case.
Returns an effect whose failure and success have been lifted into an
Either.The resulting effect cannot fail, because the failure case has
been exposed as part of the Either success case.
This method is useful for recovering from ZIO effects that may fail.
The error parameter of the returned ZIO is Nothing, since it is
guaranteed the ZIO effect does not model failure.
Returns an effect that, if this effect _starts_ execution, then the
specified finalizer is guaranteed to begin execution, whether this effect
succeeds, fails, or is interrupted.
Returns an effect that, if this effect _starts_ execution, then the
specified finalizer is guaranteed to begin execution, whether this effect
succeeds, fails, or is interrupted.
For use cases that need access to the effect's result, see ZIO#onExit.
Finalizers offer very powerful guarantees, but they are low-level, and
should generally not be used for releasing resources. For higher-level
logic built on ensuring, see ZIO#acquireReleaseWith.
Acts on the children of this fiber (collected into a single fiber), guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
Acts on the children of this fiber, guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
Returns an effect that semantically runs the effect on a fiber, producing an zio.Exit for the completion value of the fiber.
Maps this effect to the default exit codes.
Dies with specified Throwable if the predicate fails.
Dies with a java.lang.RuntimeException having the specified text message if the predicate fails.
Supplies zio if the predicate fails.
Applies f if the predicate fails.
Fails with e if the predicate fails.
Returns an effect that runs this effect and in case of failure, runs each of the specified effects in order until one of them succeeds.
Returns an effect that models the execution of this effect, followed by the
passing of its value to the specified continuation function k, followed
by the effect that it returns.
Returns an effect that models the execution of this effect, followed by the
passing of its value to the specified continuation function k, followed
by the effect that it returns.
val parsed = readFile("foo.txt").flatMap(file => parseFile(file))
Creates a composite effect that represents this effect followed by another one that may depend on the error produced by this one.
Creates a composite effect that represents this effect followed by another one that may depend on the error produced by this one.
val parsed = readFile("foo.txt").flatMapError(error => logErrorToFile(error))
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
This method can be used to "flatten" nested effects.
Unwraps the optional error, defaulting to the provided value.
Returns an effect that swaps the error/success cases.
Returns an effect that swaps the error/success cases. This allows you to use all methods on the error channel, possibly before flipping back.
Swaps the error/value parameters, applies the function f and flips the
parameters back
Folds over the failure value or the success value to yield an effect that
does not fail, but succeeds with the value returned by the left or right
function passed to fold.
A more powerful version of fold that allows recovering from any kind of
failure except interruptions.
A more powerful version of foldZIO that allows recovering from any kind
of failure except interruptions.
A version of foldZIO that gives you the trace of the error.
Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.
Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.
This method has better performance than either since no intermediate
value is allocated and does not require subsequent calls to flatMap to
define the next effect.
The error parameter of the returned IO may be chosen arbitrarily, since
it will depend on the IOs returned by the given continuations.
Returns a new effect that will pass the success value of this effect to the provided callback.
Returns a new effect that will pass the success value of this effect to the provided callback. If this effect fails, then the failure will be ignored.
Repeats this effect forever (until the first error).
Repeats this effect forever (until the first error). For more sophisticated
schedules, see the repeat method.
Returns an effect that forks this effect into its own separate fiber, returning the fiber immediately, without waiting for it to begin executing the effect.
Returns an effect that forks this effect into its own separate fiber, returning the fiber immediately, without waiting for it to begin executing the effect.
You can use the fork method whenever you want to execute an effect in a
new fiber, concurrently and without "blocking" the fiber executing other
effects. Using fibers can be tricky, so instead of using this method
directly, consider other higher-level methods, such as raceWith,
zipPar, and so forth.
The fiber returned by this method has methods to interrupt the fiber and to wait for it to finish executing the effect. See zio.Fiber for more information.
Whenever you use this method to launch a new fiber, the new fiber is attached to the parent fiber's scope. This means when the parent fiber terminates, the child fiber will be terminated as well, ensuring that no fibers leak. This behavior is called "auto supervision", and if this behavior is not desired, you may use the forkDaemon or forkIn methods.
for { fiber <- subtask.fork // Do stuff... a <- fiber.join } yield a
Forks the effect into a new fiber attached to the global scope.
Forks the effect into a new fiber attached to the global scope. Because the new fiber is attached to the global scope, when the fiber executing the returned effect terminates, the forked fiber will continue running.
Forks the fiber in a ZManaged.
Forks the fiber in a ZManaged. Using the ZManaged value will execute the effect in the fiber, while ensuring its interruption when the effect supplied to ZManaged#use completes.
Like fork but handles an error with the provided handler.
Returns a successful effect with the head of the list if the list is
non-empty or fails with the error None if the list is empty.
Returns a new effect that ignores the success or failure of this effect.
Returns a new effect whose scope will be extended by the specified scope.
Returns a new effect whose scope will be extended by the specified scope. This means any finalizers associated with the effect will not be executed until the specified scope is closed.
Automatically assembles a layer for the ZIO effect.
Automatically assembles a layer for the ZIO effect.
Automatically constructs the part of the environment that is not part of
the ZEnv, leaving an effect that only depends on the ZEnv.
Automatically constructs the part of the environment that is not part of
the ZEnv, leaving an effect that only depends on the ZEnv. This will
also satisfy transitive ZEnv requirements with ZEnv.any, allowing them
to be provided later.
val zio: ZIO[OldLady with Console, Nothing, Unit] = ??? val oldLadyLayer: ZLayer[Fly, Nothing, OldLady] = ??? val flyLayer: ZLayer[Blocking, Nothing, Fly] = ??? // The ZEnv you use later will provide both Blocking to flyLayer and Console to zio val zio2 : ZIO[ZEnv, Nothing, Unit] = zio.injectCustom(oldLadyLayer, flyLayer)
Splits the environment into two parts, assembling one part using the
specified layer and leaving the remainder R0.
Splits the environment into two parts, assembling one part using the
specified layer and leaving the remainder R0.
val clockLayer: ZLayer[Any, Nothing, Clock] = ??? val zio: ZIO[Clock with Random, Nothing, Unit] = ??? val zio2 = zio.injectSome[Random](clockLayer)
Returns a new effect that will not succeed with its value before first interrupting all child fibers forked by the effect.
Switches the interrupt status for this effect.
Switches the interrupt status for this effect. If true is used, then the
effect becomes interruptible (the default), while if false is used, then
the effect becomes uninterruptible. These changes are compositional, so
they only affect regions of the effect.
Returns a new effect that performs the same operations as this effect, but interruptibly, even if composed inside of an uninterruptible region.
Returns a new effect that performs the same operations as this effect, but interruptibly, even if composed inside of an uninterruptible region.
Note that effects are interruptible by default, so this function only has meaning if used within an uninterruptible region.
WARNING: This operator "punches holes" into effects, allowing them to be interrupted in unexpected places. Do not use this operator unless you know exactly what you are doing. Instead, you should use ZIO.uninterruptibleMask.
Returns an effect that keeps or breaks a promise based on the result of this effect.
Returns an effect that keeps or breaks a promise based on the result of this effect. Synchronizes interruption, so if this effect is interrupted, the specified promise will be interrupted, too.
Returns whether this effect is a failure.
Returns whether this effect is a success.
"Zooms in" on the value in the Left side of an Either, moving the
possibility that the value is a Right to the error channel.
Returns an effect whose success is mapped by the specified f function.
Returns an effect whose success is mapped by the specified side effecting
f function, translating any thrown exceptions into typed failed effects.
Returns an effect whose failure and success channels have been mapped by
the specified pair of functions, f and g.
Returns an effect with its error channel mapped using the specified function.
Returns an effect with its error channel mapped using the specified function. This can be used to lift a "smaller" error into a "larger" error.
Returns an effect with its full cause of failure mapped using the specified function.
Returns an effect with its full cause of failure mapped using the specified
function. This can be used to transform errors while preserving the
original structure of Cause.
absorb, sandbox, catchAllCause - other functions for dealing with defects
Returns an effect that, if evaluated, will return the lazily computed result of this effect.
Returns a new effect where the error channel has been merged into the success channel to their common combined type.
Returns a new effect where boolean value of this effect is negated.
Requires the option produced by this value to be None.
Runs the specified effect if this effect fails, providing the error to the effect if it exists.
Runs the specified effect if this effect fails, providing the error to the effect if it exists. The provided effect will not be interrupted.
Executes the effect on the specified ExecutionContext and then shifts
back to the default one.
Returns an effect which is guaranteed to be executed on the specified executor.
Returns an effect which is guaranteed to be executed on the specified executor. The specified effect will always run on the specified executor, even in the presence of asynchronous boundaries.
This is useful when an effect must be executed somewhere, for example: on a UI thread, inside a client library's thread pool, inside a blocking thread pool, inside a low-latency thread pool, or elsewhere.
The onExecutor function composes with the innermost onExecutor taking
priority. Use of this method does not alter the execution semantics of
other effects composed with this one, making it easy to compositionally
reason about where effects are running.
Ensures that a cleanup functions runs, whether this effect succeeds, fails, or is interrupted.
Calls the specified function, and runs the effect it returns, if this effect is interrupted.
Runs the specified effect if this effect is interrupted.
Runs the specified effect if this effect is terminated, either because of a defect or because of interruption.
Returns an effect that will be executed at most once, even if it is evaluated multiple times.
Executes this effect, skipping the error but returning optionally the success.
Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.
Keeps none of the errors, and terminates the fiber with them, using the
specified function to convert the E into a Throwable.
Executes this effect and returns its value, if it succeeds, but otherwise executes the specified effect.
Returns an effect that will produce the value of this effect, unless it fails, in which case, it will produce the value of the specified effect.
Executes this effect and returns its value, if it succeeds, but otherwise fails with the specified error.
Returns an effect that will produce the value of this effect, unless it
fails with the None value, in which case it will produce the value of the
specified effect.
Executes this effect and returns its value, if it succeeds, but otherwise succeeds with the specified value.
Returns a new effect that will utilize the specified scope to supervise any fibers forked within the original effect.
Exposes all parallel errors in a single call
Provides a layer to the ZIO effect, which translates it to another level.
Provides the part of the environment that is not part of the ZEnv,
leaving an effect that only depends on the ZEnv.
Provides the part of the environment that is not part of the ZEnv,
leaving an effect that only depends on the ZEnv.
val zio: ZIO[ZEnv with Logging, Nothing, Unit] = ??? val loggingLayer: ZLayer[Any, Nothing, Logging] = ??? val zio2 = zio.provideCustom(loggingLayer)
Provides the ZIO effect with its required environment, which eliminates
its dependency on R.
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 zio: ZIO[Clock with Random, Nothing, Unit] = ??? val clockLayer: ZLayer[Any, Nothing, Clock] = ??? val zio2 = zio.provideSome[Random](clockLayer)
Transforms the environment being provided to this effect with the specified function.
Returns an effect that races this effect with the specified effect,
returning the first successful A from the faster side.
Returns an effect that races this effect with the specified effect,
returning the first successful A from the faster side. If one effect
succeeds, the other will be interrupted. If neither succeeds, then the
effect will fail with some error.
WARNING: The raced effect will safely interrupt the "loser", but will not
resume until the loser has been cleanly terminated. If early return is
desired, then instead of performing l race r, perform l.disconnect race
r.disconnect, which disconnects left and right interruption signals,
allowing a fast return, with interruption performed in the background.
Note that if the race is embedded into an uninterruptible region, then
because the loser cannot be interrupted, it will be allowed to continue
executing in the background, without delaying the return of the race.
Returns an effect that races this effect with all the specified effects, yielding the value of the first effect to succeed with a value.
Returns an effect that races this effect with all the specified effects, yielding the value of the first effect to succeed with a value. Losers of the race will be interrupted immediately
Returns an effect that races this effect with the specified effect, yielding the first result to succeed.
Returns an effect that races this effect with the specified effect, yielding the first result to succeed. If neither effect succeeds, then the composed effect will fail with some error.
WARNING: The raced effect will safely interrupt the "loser", but will not
resume until the loser has been cleanly terminated. If early return is
desired, then instead of performing l raceEither r, perform l.disconnect
raceEither r.disconnect, which disconnects left and right interrupt
signal, allowing the earliest possible return.
Returns an effect that races this effect with the specified effect, yielding the first result to complete, whether by success or failure.
Returns an effect that races this effect with the specified effect, yielding the first result to complete, whether by success or failure. If neither effect completes, then the composed effect will not complete.
WARNING: The raced effect will safely interrupt the "loser", but will not
resume until the loser has been cleanly terminated. If early return is
desired, then instead of performing l raceFirst r, perform l.disconnect
raceFirst r.disconnect, which disconnects left and right interrupt signal,
allowing a fast return, with interruption performed in the background.
Returns an effect that races this effect with the specified effect, calling the specified finisher as soon as one result or the other has been computed.
Keeps some of the errors, and terminates the fiber with the rest
Keeps some of the errors, and terminates the fiber with the rest, using the
specified function to convert the E into a Throwable.
Fail with the returned value if the PartialFunction matches, otherwise
continue with our held value.
Continue with the returned computation if the PartialFunction matches,
translating the successful match into a failure, otherwise continue with
our held value.
Returns a new effect that repeats this effect according to the specified schedule or until the first failure.
Returns a new effect that repeats this effect according to the specified
schedule or until the first failure. Scheduled recurrences are in addition
to the first execution, so that io.repeat(Schedule.once) yields an effect
that executes io, and then if that succeeds, executes io an additional
time.
Returns a new effect that repeats this effect the specified number of times or until the first failure.
Returns a new effect that repeats this effect the specified number of times
or until the first failure. Repeats are in addition to the first execution,
so that io.repeatN(1) yields an effect that executes io, and then if
that succeeds, executes io an additional time.
Returns a new effect that repeats this effect according to the specified schedule or until the first failure, at which point, the failure value and schedule output are passed to the specified handler.
Returns a new effect that repeats this effect according to the specified schedule or until the first failure, at which point, the failure value and schedule output are passed to the specified handler.
Scheduled recurrences are in addition to the first execution, so that
io.repeat(Schedule.once) yields an effect that executes io, and then if
that succeeds, executes io an additional time.
Returns a new effect that repeats this effect according to the specified schedule or until the first failure, at which point, the failure value and schedule output are passed to the specified handler.
Returns a new effect that repeats this effect according to the specified schedule or until the first failure, at which point, the failure value and schedule output are passed to the specified handler.
Scheduled recurrences are in addition to the first execution, so that
io.repeat(Schedule.once) yields an effect that executes io, and then if
that succeeds, executes io an additional time.
Repeats this effect until its value satisfies the specified predicate or until the first failure.
Repeats this effect until its value is equal to the specified value or until the first failure.
Repeats this effect until its value satisfies the specified effectful predicate or until the first failure.
Repeats this effect while its value satisfies the specified predicate or until the first failure.
Repeats this effect for as long as its value is equal to the specified value or until the first failure.
Repeats this effect while its value satisfies the specified effectful predicate or until the first failure.
Performs this effect the specified number of times and collects the results.
Performs this effect the specified number of times, discarding the results.
Returns a new effect that will utilize the default scope (fiber scope) to supervise any fibers forked within the original effect.
Unearth the unchecked failure of the effect.
Unearth the unchecked failure of the effect. (opposite of orDie)
val f0: Task[Unit] = ZIO.fail(new Exception("failing")).unit val f1: UIO[Unit] = f0.orDie val f2: Task[Unit] = f1.resurrect
Retries with the specified retry policy.
Retries with the specified retry policy. Retries are done following the
failure of the original io (up to a fixed maximum with once or recurs
for example), so that that io.retry(Schedule.once) means "execute io
and in case of failure, try again once".
Retries this effect the specified number of times.
Retries with the specified schedule, until it fails, and then both the value produced by the schedule together with the last error are passed to the recovery function.
Returns an effect that retries this effect with the specified schedule when it fails, until the schedule is done, then both the value produced by the schedule together with the last error are passed to the specified recovery function.
Retries this effect until its error satisfies the specified predicate.
Retries this effect until its error is equal to the specified error.
Retries this effect until its error satisfies the specified effectful predicate.
Retries this effect while its error satisfies the specified predicate.
Retries this effect for as long as its error is equal to the specified error.
Retries this effect while its error satisfies the specified effectful predicate.
"Zooms in" on the value in the Right side of an Either, moving the
possibility that the value is a Left to the error channel.
Exposes the full cause of failure of this effect.
Exposes the full cause of failure of this effect.
final case class DomainError() val veryBadIO: IO[DomainError, Unit] = IO.succeed(5 / 0) *> IO.fail(DomainError()) val caught: IO[DomainError, Unit] = veryBadIO.sandbox.mapError(_.untraced).catchAll { case Cause.Die(_: ArithmeticException) => // Caught defect: divided by zero! IO.unit case Cause.Fail(_) => // Caught error: DomainError! IO.unit case cause => // Caught unknown defects, shouldn't recover! IO.failCause(cause) }
Companion helper to sandbox.
Companion helper to sandbox. Allows recovery, and partial recovery, from
errors and defects alike, as in:
case class DomainError() val veryBadIO: IO[DomainError, Unit] = IO.succeed(5 / 0) *> IO.fail(DomainError()) val caught: IO[DomainError, Unit] = veryBadIO.sandboxWith(_.catchSome { case Cause.Die(_: ArithmeticException)=> // Caught defect: divided by zero! IO.succeed(0) })
Using sandboxWith with catchSome is better than using
io.sandbox.catchAll with a partial match, because in the latter, if the
match fails, the original defects will be lost and replaced by a
MatchError
Runs this effect according to the specified schedule.
Runs this effect according to the specified schedule.
See scheduleFrom for a variant that allows the schedule's decision to depend on the result of this effect.
Runs this effect according to the specified schedule starting from the specified input value.
Converts an option on values into an option on errors.
Extracts the optional value, or returns the given 'default'.
Extracts the optional value, or executes the effect 'default'.
Extracts the optional value, or fails with the given error 'e'.
Extracts the optional value, or fails with a java.util.NoSuchElementException
Summarizes a effect by computing some value before and after execution, and then combining the values to produce a summary, together with the result of execution.
Returns an effect with the behavior of this one, but where all child fibers forked in the effect are reported to the specified supervisor.
Returns an effect that effectfully "peeks" at the success of this effect.
Returns an effect that effectfully "peeks" at the success of this effect.
readFile("data.json").tap(printLine)
Returns an effect that effectfully "peeks" at the failure or success of this effect.
Returns an effect that effectfully "peeks" at the failure or success of this effect.
readFile("data.json").tapBoth(logError(_), logData(_))
Returns an effect that effectually "peeks" at the defect of this effect.
Returns an effect that effectfully "peeks" at the result of this effect.
Returns an effect that effectfully "peeks" at the result of this effect.
readFile("data.json").tapEither(result => log(result.fold("Error: " + _, "Success: " + _)))
Returns an effect that effectfully "peeks" at the failure of this effect.
Returns an effect that effectfully "peeks" at the failure of this effect.
readFile("data.json").tapError(logError(_))
Returns an effect that effectually "peeks" at the cause of the failure of this effect.
Returns an effect that effectually "peeks" at the cause of the failure of this effect.
readFile("data.json").tapErrorCause(logCause(_))
A version of tapError that gives you the trace of the error.
Returns an effect that effectfully "peeks" at the success of this effect.
Returns an effect that effectfully "peeks" at the success of this effect. If the partial function isn't defined at the input, the result is equivalent to the original effect.
readFile("data.json").tapSome { case content if content.nonEmpty => putStrLn(content) }
Returns a new effect that executes this one and times the execution.
A more powerful variation of timed that allows specifying the Clock.
Returns an effect that will timeout this effect, returning None if the
timeout elapses before the effect has produced a value; and returning
Some of the produced value otherwise.
Returns an effect that will timeout this effect, returning None if the
timeout elapses before the effect has produced a value; and returning
Some of the produced value otherwise.
If the timeout elapses without producing a value, the running effect will be safely interrupted.
WARNING: The effect returned by this method will not itself return until
the underlying effect is actually interrupted. This leads to more
predictable resource utilization. If early return is desired, then instead
of using effect.timeout(d), use effect.disconnect.timeout(d), which
first disconnects the effect's interruption signal before performing the
timeout, resulting in earliest possible return, before an underlying effect
has been successfully interrupted.
The same as timeout, but instead of producing a None in the event of
timeout, it will produce the specified error.
The same as timeout, but instead of producing a None in the event of
timeout, it will produce the specified failure.
Returns an effect that will timeout this effect, returning either the
default value if the timeout elapses before the effect has produced a
value; and or returning the result of applying the function f to the
success value of the effect.
Returns an effect that will timeout this effect, returning either the
default value if the timeout elapses before the effect has produced a
value; and or returning the result of applying the function f to the
success value of the effect.
If the timeout elapses without producing a value, the running effect will be safely interrupted
IO.succeed(1).timeoutTo(None)(Some(_))(1.second)
Converts the effect into a scala.concurrent.Future.
Converts the effect into a scala.concurrent.Future.
Constructs a layer from this effect.
Constructs a layer from this effect, which must return one or more services.
Converts this ZIO to zio.ZManaged with no release action.
Converts this ZIO to zio.ZManaged with no release action. It will be performed interruptibly.
Converts this ZIO to zio.Managed.
Converts this ZIO to zio.Managed. This ZIO and the provided release action will be performed uninterruptibly.
Returns the logical negation of the Boolean value returned by this
effect.
When this effect succeeds with a cause, then this method returns a new effect that either fails with the cause that this effect succeeded with, or succeeds with unit, depending on whether the cause is empty.
When this effect succeeds with a cause, then this method returns a new effect that either fails with the cause that this effect succeeded with, or succeeds with unit, depending on whether the cause is empty.
This operation is the opposite of cause.
Performs this effect uninterruptibly.
Performs this effect uninterruptibly. This will prevent the effect from being terminated externally, but the effect may fail for internal reasons (e.g. an uncaught error) or terminate due to defect.
Uninterruptible effects may recover from all failure causes (including interruption of an inner effect that has been made interruptible).
Returns the effect resulting from mapping the success of this effect to unit.
Converts a ZIO[R, Either[E, B], A] into a ZIO[R, E, Either[A, B]].
Converts a ZIO[R, Either[E, B], A] into a ZIO[R, E, Either[A, B]]. The
inverse of left.
The moral equivalent of if (!p) exp
The moral equivalent of if (!p) exp when p has side-effects
Takes some fiber failures and converts them into errors.
Takes some fiber failures and converts them into errors.
Takes some fiber failures and converts them into errors, using the
specified function to convert the E into an E1.
Converts a ZIO[R, Either[B, E], A] into a ZIO[R, E, Either[B, A]].
Converts a ZIO[R, Either[B, E], A] into a ZIO[R, E, Either[B, A]]. The
inverse of right.
The inverse operation to sandbox.
The inverse operation to sandbox. Submerges the full cause of failure.
Converts an option on errors into an option on values.
Updates a service in the environment of this effect.
Updates a service at the specified key in the environment of this effect.
Sequentially zips the this result with the specified result.
Sequentially zips the this result with the specified result. Combines both
Cause[E1] when both effects fail.
Returns an effect that executes both this effect and the specified effect, in parallel.
Returns an effect that executes both this effect and the specified effect,
in parallel. Combines both Cause[E1] when both effects fail.
Sequentially zips this effect with the specified effect using the specified combiner function.
Sequentially zips this effect with the specified effect using the specified combiner function. Combines the causes in case both effect fail.
Returns an effect that executes both this effect and the specified effect,
in parallel, combining their results with the specified f function.
Returns an effect that executes both this effect and the specified effect,
in parallel, combining their results with the specified f function. If
both sides fail, then the cause will be combined.
The moral equivalent of if (p) exp
The moral equivalent of if (p) exp when p has side-effects
Runs this effect with the specified maximum number of fibers for parallel operators.
Runs this effect with an unbounded maximum number of fibers for parallel operators.
Runs this effect on the specified runtime configuration, restoring the old runtime configuration when it completes execution.
A named alias for &&& or <*>.
A named alias for <*.
A named alias for <&>.
A named alias for <&.
A named alias for &>.
A named alias for *>.
Sequentially zips this effect with the specified effect using the specified combiner function.
Returns an effect that executes both this effect and the specified effect,
in parallel, combining their results with the specified f function.
Returns an effect that executes both this effect and the specified effect,
in parallel, combining their results with the specified f function. If
either side fails, then the other side will be interrupted.
Returns the logical conjunction of the Boolean value returned by this
effect and the Boolean value returned by the specified effect.
Returns the logical conjunction of the Boolean value returned by this
effect and the Boolean value returned by the specified effect. This
operator has "short circuiting" behavior so if the value returned by this
effect is true the specified effect will not be evaluated.
Sequentially zips this effect with the specified effect, combining the results into a tuple.
Sequentially zips this effect with the specified effect, combining the results into a tuple.
(Since version 2.0.0) use zip
Alias for flatMap.
Alias for flatMap.
val parsed = readFile("foo.txt") >>= parseFile
(Since version 2.0.0) use flatMap
Maps the success value of this effect to a service.
Maps the success value of this effect to a service.
(Since version 2.0.0) use toLayer
Returns an effect whose failure and success channels have been mapped by
the specified pair of functions, f and g.
Returns an effect whose failure and success channels have been mapped by
the specified pair of functions, f and g.
(Since version 2.0.0) use mapBoth
Shorthand for the curried version of ZIO.bracket.
Shorthand for the curried version of ZIO.bracket.
(Since version 2.0.0) use acquireReleaseWith
Shorthand for the uncurried version of ZIO.bracket.
Shorthand for the uncurried version of ZIO.bracket.
(Since version 2.0.0) use acquireReleaseWith
Shorthand for the curried version of ZIO.bracketExit.
Shorthand for the curried version of ZIO.bracketExit.
(Since version 2.0.0) use acquireReleaseExitWith
Shorthand for the uncurried version of ZIO.bracketExit.
Shorthand for the uncurried version of ZIO.bracketExit.
(Since version 2.0.0) use acquireReleaseExitWith
Executes the release effect only if there was an error.
Executes the release effect only if there was an error.
(Since version 2.0.0) use acquireReleaseOnErrorWith
Uncurried version.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but it doesn't allocate intermediate zio.ZIO.AcquireDiscard and zio.ZIO.ReleaseDiscard objects.
(Since version 2.0.0) use acquireRelease
A less powerful variant of bracket where the resource acquired by this
effect is not needed.
A less powerful variant of bracket where the resource acquired by this
effect is not needed.
(Since version 2.0.0) use acquireRelease
Fail with e if the supplied PartialFunction does not match, otherwise
continue with the returned value.
Fail with e if the supplied PartialFunction does not match, otherwise
continue with the returned value.
(Since version 2.0.0) use collectZIO
Supplies zio if the predicate fails.
Supplies zio if the predicate fails.
(Since version 2.0.0) use filterOrElse
A more powerful version of fold that allows recovering from any kind of
failure except interruptions.
A more powerful version of fold that allows recovering from any kind of
failure except interruptions.
(Since version 2.0.0) use foldCauseZIO
Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.
Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.
This method has better performance than either since no intermediate
value is allocated and does not require subsequent calls to flatMap to
define the next effect.
The error parameter of the returned IO may be chosen arbitrarily, since
it will depend on the IOs returned by the given continuations.
(Since version 2.0.0) use foldZIO
A version of foldM that gives you the trace of the error.
A version of foldM that gives you the trace of the error.
(Since version 2.0.0) use foldTraceZIO
Forks an effect that will be executed without unhandled failures being reported.
Forks an effect that will be executed without unhandled failures being reported. This is useful for implementing combinators that handle failures themselves.
(Since version 2.0.0) use fork
Forks an effect that will be executed on the specified ExecutionContext.
Forks an effect that will be executed on the specified ExecutionContext.
(Since version 2.0.0) use onExecutionContext(ec).fork
Unwraps the optional success of this effect, but can fail with an None value.
Unwraps the optional success of this effect, but can fail with an None value.
(Since version 2.0.0) use some
Returns an effect which is guaranteed to be executed on the specified executor.
Returns an effect which is guaranteed to be executed on the specified executor. The specified effect will always run on the specified executor, even in the presence of asynchronous boundaries.
This is useful when an effect must be executed somewhere, for example: on a UI thread, inside a client library's thread pool, inside a blocking thread pool, inside a low-latency thread pool, or elsewhere.
The lock function composes with the innermost lock taking priority. Use
of this method does not alter the execution semantics of other effects
composed with this one, making it easy to compositionally reason about
where effects are running.
(Since version 2.0.0) use onExecutor
Executes the effect on the specified ExecutionContext and then shifts
back to the default one.
Executes the effect on the specified ExecutionContext and then shifts
back to the default one.
(Since version 2.0.0) use onExecutionContext
Returns an effect whose success is mapped by the specified side effecting
f function, translating any thrown exceptions into typed failed effects.
Returns an effect whose success is mapped by the specified side effecting
f function, translating any thrown exceptions into typed failed effects.
(Since version 2.0.0) use mapAttempt
Executes the effect on the specified ExecutionContext and then shifts
back to the default one.
Executes the effect on the specified ExecutionContext and then shifts
back to the default one.
(Since version 2.0.0) use onExecutionContext
Converts an option on errors into an option on values.
Converts an option on errors into an option on values.
(Since version 2.0.0) use unsome
Provides the part of the environment that is not part of the ZEnv,
leaving an effect that only depends on the ZEnv.
Provides the part of the environment that is not part of the ZEnv,
leaving an effect that only depends on the ZEnv.
val zio: ZIO[ZEnv with Logging, Nothing, Unit] = ??? val loggingLayer: ZLayer[Any, Nothing, Logging] = ??? val zio2 = zio.provideCustomLayer(loggingLayer)
(Since version 2.0.0) use provideCustom
Provides a layer to the ZIO effect, which translates it to another level.
Provides a layer to the ZIO effect, which translates it to another level.
(Since version 2.0.0) use provide
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 zio: ZIO[Clock with Random, Nothing, Unit] = ??? val clockLayer: ZLayer[Any, Nothing, Clock] = ??? val zio2 = zio.provideSomeLayer[Random](clockLayer)
(Since version 2.0.0) use provideSome
Continue with the returned computation if the PartialFunction matches,
translating the successful match into a failure, otherwise continue with
our held value.
Continue with the returned computation if the PartialFunction matches,
translating the successful match into a failure, otherwise continue with
our held value.
(Since version 2.0.0) use rejectZIO
Repeats this effect until its value satisfies the specified effectful predicate or until the first failure.
Repeats this effect until its value satisfies the specified effectful predicate or until the first failure.
(Since version 2.0.0) use repeatUntilZIO
Repeats this effect while its value satisfies the specified effectful predicate or until the first failure.
Repeats this effect while its value satisfies the specified effectful predicate or until the first failure.
(Since version 2.0.0) use repeatWhileZIO
Performs this effect the specified number of times and collects the results.
Performs this effect the specified number of times and collects the results.
(Since version 2.0.0) use replicateZIO
Performs this effect the specified number of times, discarding the results.
Performs this effect the specified number of times, discarding the results.
(Since version 2.0.0) use replicateZIODiscard
Retries this effect until its error satisfies the specified effectful predicate.
Retries this effect until its error satisfies the specified effectful predicate.
(Since version 2.0.0) use retryUntilZIO
Retries this effect while its error satisfies the specified effectful predicate.
Retries this effect while its error satisfies the specified effectful predicate.
(Since version 2.0.0) use retryWhileZIO
Returns an effect that semantically runs the effect on a fiber, producing an zio.Exit for the completion value of the fiber.
Returns an effect that semantically runs the effect on a fiber, producing an zio.Exit for the completion value of the fiber.
(Since version 2.0.0) use exit
Extracts the optional value, or executes the effect 'default'.
Extracts the optional value, or executes the effect 'default'.
(Since version 2.0.0) use someOrElseZIO
Returns an effect that effectually "peeks" at the cause of the failure of this effect.
Returns an effect that effectually "peeks" at the cause of the failure of this effect.
readFile("data.json").tapCause(logCause(_))(Since version 2.0.0) use tapErrorCause
The same as timeout, but instead of producing a None in the event of
timeout, it will produce the specified failure.
The same as timeout, but instead of producing a None in the event of
timeout, it will produce the specified failure.
(Since version 2.0.0) use timeoutFailCause
Returns an effect that keeps or breaks a promise based on the result of this effect.
Returns an effect that keeps or breaks a promise based on the result of this effect. Synchronizes interruption, so if this effect is interrupted, the specified promise will be interrupted, too.
(Since version 2.0.0) use intoPromise
Constructs a layer from this effect, which must return one or more services.
Constructs a layer from this effect, which must return one or more services.
(Since version 2.0.0) use toLayerEnvironment
Converts this ZIO to zio.ZManaged with no release action.
Converts this ZIO to zio.ZManaged with no release action. It will be performed interruptibly.
(Since version 2.0.0) use toManaged
The moral equivalent of if (!p) exp when p has side-effects
The moral equivalent of if (!p) exp when p has side-effects
(Since version 2.0.0) use unlessZIO
Converts an option on errors into an option on values.
Converts an option on errors into an option on values.
(Since version 2.0.0) use unsome
The moral equivalent of if (p) exp when p has side-effects
The moral equivalent of if (p) exp when p has side-effects
(Since version 2.0.0) use whenZIO
A
ZIO[R, E, A]value is an immutable value that lazily describes a workflow or job. The workflow requires some environmentR, and may fail with an error of typeE, or succeed with a value of typeA.These lazy workflows, referred to as _effects_, can be informally thought of as functions in the form:
R => Either[E, A]ZIO effects model resourceful interaction with the outside world, including synchronous, asynchronous, concurrent, and parallel interaction.
ZIO effects use a fiber-based concurrency model, with built-in support for scheduling, fine-grained interruption, structured concurrency, and high scalability.
To run an effect, you need a
Runtime, which is capable of executing effects. Runtimes bundle a thread pool together with the environment that effects need.