An Exit[E, A] describes the result of executing an IO value. The result is either succeeded with a value A, or failed with a Cause[E].
Attributes
Members list
Value members
Concrete methods
Parallelly zips the this result with the specified result discarding the first element of the tuple or else returns the failed Cause[E1]
Parallelly zips the this result with the specified result discarding the first element of the tuple or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Sequentially zips the this result with the specified result discarding the first element of the tuple or else returns the failed Cause[E1]
Sequentially zips the this result with the specified result discarding the first element of the tuple or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Parallelly zips the this result with the specified result discarding the second element of the tuple or else returns the failed Cause[E1]
Parallelly zips the this result with the specified result discarding the second element of the tuple or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Parallelly zips the this result with the specified result or else returns the failed Cause[E1]
Parallelly zips the this result with the specified result or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Sequentially zips the this result with the specified result discarding the second element of the tuple or else returns the failed Cause[E1]
Sequentially zips the this result with the specified result discarding the second element of the tuple or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Sequentially zips the this result with the specified result or else returns the failed Cause[E1]
Sequentially zips the this result with the specified result or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Replaces the success value with the one provided.
Returns an option of the cause of failure.
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.
Flat maps over the value type.
Flat maps over the value type.
Flattens an Exit of an Exit into a single Exit value.
Folds over the value or cause.
Sequentially zips the this result with the specified result or else returns the failed Cause[E1]
Sequentially zips the this result with the specified result or else returns the failed Cause[E1]
Attributes
- Source
- ZIO.scala
Applies the function f to the successful result of the Exit and returns the result in a new Exit.
Applies the function f to the successful result of the Exit and returns the result in a new Exit.
Attributes
- Source
- ZIO.scala
Retrieves the A if succeeded, or else returns the specified default A.
Attributes
- Source
- ZIO.scala
Attributes
- Source
- ZIO.scala
Determines if the result is a failure.
Determines if the result is interrupted.
Attributes
- Source
- ZIO.scala
Determines if the result is a success.
Maps over both the error and value type.
Maps over the cause type.
Maps over the error type.
Maps over the value type.
Replaces the error value with the one provided.
Converts the Exit to an Either[Throwable, A], by wrapping the cause in FiberFailure (if the result is failed).
Converts the Exit to an Either[Throwable, A], by wrapping the cause in FiberFailure (if the result is failed).
Attributes
- Source
- ZIO.scala
Discards the value.
Returns an untraced exit value.
Named alias for ``.
Named alias for <*.
Named alias for ``.
Named alias for <&.
Named alias for &>.
Named alias for *>.
Zips this together with the specified result using the combination functions.
Zips this together with the specified result using the combination functions.
Attributes
- Source
- ZIO.scala
Inherited methods
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.
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. If either side fails, then the other side will be interrupted.
Returns a new effect that applies the specified aspect to this effect. Aspects are "transformers" that modify the behavior of their input in some well-defined way (for example, adding a timeout).
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. Cached results will expire after timeToLive duration.
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.
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.
Attributes
Recovers from all errors with provided Cause.
Recovers from all errors with provided Cause.
openFile("config.json").catchAllCause(_ => ZIO.succeed(defaultConfig))
Attributes
- See also
-
absorb, sandbox, mapErrorCause - other functions that can recover from defects
- Inherited from:
- ZIO
- Source
- ZIO.scala
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.
Attributes
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.
Attributes
Returns an effect that is delayed from this effect by the specified zio.Duration.
Returns an effect that is delayed from this effect by the specified zio.Duration.
Attributes
Returns an effect that is always interruptible, but whose interruption will be performed in the background.
Returns an effect that is always interruptible, but whose interruption will be performed in the background.
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.
Attributes
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.
Attributes
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.
Attributes
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.
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.
Creates a composite effect that represents this effect followed by another one that may depend on the error produced by this one.
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 swaps the error/success cases. This allows you to use all methods on the error channel, possibly before flipping 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.
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.
Attributes
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.
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
Attributes
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.
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, but which also logs failures at the Debug level, just in case the failure turns out to be important.
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.
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.
Attributes
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.
Attributes
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 an effect whose success is mapped by the specified side effecting f function, translating any thrown exceptions into typed failed effects.
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. This can be used to transform errors while preserving the original structure of Cause.
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.
Attributes
- See also
-
absorb, sandbox, catchAllCause - other functions for dealing with defects
- Inherited from:
- ZIO
- Source
- ZIO.scala
Executes the specified success or error callback depending on the result of this effect, synchronously completing the effect before returning.
Executes the specified success or cause-based error callback depending on the result of this effect, synchronously completing the effect before returning.
Runs the specified effect if this effect fails, providing the error to the effect if it exists. The provided effect will not be interrupted.
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.
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.
Attributes
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.
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.
Attributes
- Inherited from:
- Product
Attributes
- Inherited from:
- Product
Attributes
- Inherited from:
- Product
Attributes
- Inherited from:
- Product
Automatically assembles a layer for the ZIO effect, which translates it to another level.
Automatically assembles a layer for the ZIO effect, which translates it to another level.
Attributes
- Inherited from:
- ZIOVersionSpecific (hidden)
- Source
- ZIOVersionSpecific.scala
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.provideSome[Random](clockLayer)
Attributes
- Inherited from:
- ZIOVersionSpecific (hidden)
- Source
- ZIOVersionSpecific.scala
Equivalent to provideSome, but does not require providing the remainder type
Equivalent to provideSome, but does not require providing the remainder type
val clockLayer: ZLayer[Any, Nothing, Clock] = ???
val zio: ZIO[Clock with Random, Nothing, Unit] = ???
val zio2 = zio.provideSome(clockLayer) // Inferred type is ZIO[Random, Nothing, Unit]
Note for Intellij users: By default, Intellij will not show correct type on hover. To fix this enable Use types reported by Scala compiler (experimental) in Settings | Languages & Frameworks | Scala | Editor
Attributes
- Inherited from:
- ZIOVersionSpecific (hidden)
- Source
- ZIOVersionSpecific.scala
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[Logging with Database, Nothing, Unit] = ???
val loggingLayer: ZLayer[Any, Nothing, Logging] = ???
val zio2 = zio.provideSomeLayer[Database](loggingLayer)
Attributes
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.
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 interrupt signal, allowing a fast return, with interruption performed in the background.
Attributes
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. If neither effect succeeds, then the composed effect will fail with some error.
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.
Attributes
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.
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.
Attributes
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, using the specified function to convert the E into a Throwable.
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. 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. 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.
Attributes
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 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.
Attributes
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.
Attributes
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.
Attributes
Unearth the unchecked failure of the effect. (opposite of orDie)
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 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.
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] =
ZIO.succeed(5 / 0) *> ZIO.fail(DomainError())
val caught: IO[DomainError, Unit] =
veryBadIO.sandbox.mapError(_.untraced).catchAll {
case Cause.Die(_: ArithmeticException) =>
// Caught defect: divided by zero!
ZIO.unit
case Cause.Fail(_) =>
// Caught error: DomainError!
ZIO.unit
case cause =>
// Caught unknown defects, shouldn't recover!
ZIO.refailCause(cause)
}
Attributes
Companion helper to sandbox. Allows recovery, and partial recovery, from errors and defects alike, as in:
Companion helper to sandbox. Allows recovery, and partial recovery, from errors and defects alike, as in:
case class DomainError()
val veryBadIO: IO[DomainError, Unit] =
ZIO.succeed(5 / 0) *> ZIO.fail(DomainError())
val caught: IO[DomainError, Unit] =
veryBadIO.sandboxWith[Any, DomainError, Unit](_.catchSome {
case Cause.Die(_: ArithmeticException, _)=>
// Caught defect: divided by zero!
ZIO.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
Attributes
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.
Attributes
Returns a new scoped workflow that runs finalizers added to the scope of this workflow sequentially in the reverse of the order in which they were added. Note that finalizers are run sequentially by default so this only has meaning if used within a scope where finalizers are being run in parallel.
Returns a new scoped workflow that runs finalizers added to the scope of this workflow sequentially in the reverse of the order in which they were added. Note that finalizers are run sequentially by default so this only has meaning if used within a scope where finalizers are being run in parallel.
Attributes
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. If the partial function isn't defined at the input, the result is equivalent to the original 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)
}
Attributes
Returns an effect that effectfully "peeks" at the failure of this effect. If the partial function isn't defined at the input, the result is equivalent to the original effect.
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.
Attributes
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
ZIO.succeed(1).timeoutTo(None)(Some(_))(1.second)
Attributes
Attributes
- Inherited from:
- ZIOPlatformSpecific (hidden)
- Source
- ZIOPlatformSpecific.scala
Attributes
- Inherited from:
- ZIOPlatformSpecific (hidden)
- Source
- ZIOPlatformSpecific.scala
Converts the effect into a scala.concurrent.Future.
Converts the effect into a scala.concurrent.Future.
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.
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.
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).
Attributes
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. 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. If both sides fail, then the cause will be combined.
Returns a new scoped workflow that returns the result of this workflow as well as a finalizer that can be run to close the scope of this workflow.
Treats this effect as the acquisition of a resource and adds the specified finalizer to the current scope. This effect will be run uninterruptibly and the finalizer will be run when the scope is closed.
Returns a new ZIO effect that will update the runtime flags according to the specified patch within the scope of this ZIO effect.
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.