sealed trait ZIO[-R, +E, +A] extends Serializable
A ZIO[R, E, A]
("Zee-Oh of Are Eeh Aye") is an immutable data structure
that models an effectful program. The effect requires an environment R
,
and the effect may fail with an error E
or produce a single A
.
Conceptually, this structure is equivalent to ReaderT[R, EitherT[UIO, E, ?]]
for some infallible effect monad UIO
, but because monad transformers
perform poorly in Scala, this data structure bakes in the reader effect of
ReaderT
with the recoverable error effect of EitherT
without runtime
overhead.
ZIO
values are ordinary immutable values, and may be used like any other
value in purely functional code. Because ZIO
values just *model* effects
(like input / output), which must be interpreted by a separate runtime system,
ZIO
values are entirely pure and do not violate referential transparency.
ZIO
values can efficiently describe the following classes of effects:
- Pure Values —
ZIO.succeed
- Error Effects —
ZIO.fail
- Synchronous Effects —
IO.effect
- Asynchronous Effects —
IO.effectAsync
- Concurrent Effects —
IO#fork
- Resource Effects —
IO#bracket
- Contextual Effects —
ZIO.access
The concurrency model is based on fibers, a user-land lightweight thread, which permit cooperative multitasking, fine-grained interruption, and very high performance with large numbers of concurrently executing fibers.
ZIO
values compose with other ZIO
values in a variety of ways to build
complex, rich, interactive applications. See the methods on ZIO
for more
details about how to compose ZIO
values.
In order to integrate with Scala, ZIO
values must be interpreted into the
Scala runtime. This process of interpretation executes the effects described
by a given immutable ZIO
value. For more information on interpreting ZIO
values, see the default interpreter in DefaultRuntime
or the safe main function in
App
.
- Self Type
- ZIO[R, E, A]
- Alphabetic
- By Inheritance
- ZIO
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def &&&[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, (A, B)]
Sequentially zips this effect with the specified effect, combining the results into a tuple.
- final def &>[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, B]
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, interrupted the result.
- final def *>[R1 <: R, E1 >: E, B](that: => ZIO[R1, E1, B]): ZIO[R1, E1, B]
A variant of
flatMap
that ignores the value produced by this effect. - final def +++[R1, B, E1 >: E](that: ZIO[R1, E1, B]): ZIO[Either[R, R1], E1, Either[A, B]]
- final def <&[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, A]
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, interrupted the result.
- final def <&>[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, (A, B)]
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, interrupted the result.
- final def <*[R1 <: R, E1 >: E, B](that: => ZIO[R1, E1, B]): ZIO[R1, E1, A]
Sequences the specified effect after this effect, but ignores the value produced by the effect.
- final def <*>[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, (A, B)]
Alias for
&&&
. - final def <<<[R1, E1 >: E](that: ZIO[R1, E1, R]): ZIO[R1, E1, A]
- final def <>[R1 <: R, E2, A1 >: A](that: => ZIO[R1, E2, A1])(implicit ev: CanFail[E]): ZIO[R1, E2, A1]
Operator alias for
orElse
. - final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def >>=[R1 <: R, E1 >: E, B](k: (A) => ZIO[R1, E1, B]): ZIO[R1, E1, B]
Alias for
flatMap
.Alias for
flatMap
.val parsed = readFile("foo.txt") >>= parseFile
- final def >>>[R1 >: A, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R, E1, B]
- final def absolve[R1 <: R, E1, B](implicit ev1: <:<[ZIO[R, E, A], ZIO[R1, E1, Either[E1, B]]]): ZIO[R1, E1, B]
Returns an effect that submerges the error case of an
Either
into theZIO
.Returns an effect that submerges the error case of an
Either
into theZIO
. The inverse operation ofZIO.either
. - final def absorb(implicit ev: <:<[E, Throwable]): ZIO[R, Throwable, A]
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
- final def absorbWith(f: (E) => Throwable): ZIO[R, Throwable, A]
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
- final def andThen[R1 >: A, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R, E1, B]
- final def as[B](b: => B): ZIO[R, E, B]
Maps the success value of this effect to the specified constant value.
- final def asError[E1](e1: => E1)(implicit ev: CanFail[E]): ZIO[R, E1, A]
Maps the error value of this effect to the specified constant value.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- final def bimap[E2, B](f: (E) => E2, g: (A) => B)(implicit ev: CanFail[E]): ZIO[R, E2, B]
Returns an effect whose failure and success channels have been mapped by the specified pair of functions,
f
andg
. - final def bracket[R1 <: R, E1 >: E]: BracketAcquire[R1, E1, A]
Shorthand for the curried version of
ZIO.bracket
. - final def bracket[R1 <: R, E1 >: E, B](release: (A) => URIO[R1, Any], use: (A) => ZIO[R1, E1, B]): ZIO[R1, E1, B]
Shorthand for the uncurried version of
ZIO.bracket
. - final def bracketExit[R1 <: R, E1 >: E, A1 >: A]: BracketExitAcquire[R1, E1, A1]
Shorthand for the curried version of
ZIO.bracketExit
. - final def bracketExit[R1 <: R, E1 >: E, B](release: (A, Exit[E1, B]) => URIO[R1, Any], use: (A) => ZIO[R1, E1, B]): ZIO[R1, E1, B]
Shorthand for the uncurried version of
ZIO.bracketExit
. - final def bracketOnError[R1 <: R, E1 >: E, B](release: (A) => URIO[R1, Any])(use: (A) => ZIO[R1, E1, B]): ZIO[R1, E1, B]
Executes the release effect only if there was an error.
- final def bracket_[R1 <: R, E1 >: E, B](release: URIO[R1, Any], use: ZIO[R1, E1, B]): ZIO[R1, E1, B]
Uncurried version.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but it doesn't allocate intermediate zio.ZIO.BracketAcquire_ and zio.ZIO.BracketRelease_ objects.
- final def bracket_[R1 <: R, E1 >: E]: BracketAcquire_[R1, E1]
A less powerful variant of
bracket
where the resource acquired by this effect is not needed. - final def cached(timeToLive: Duration): ZIO[R with Clock, Nothing, IO[E, A]]
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. - final def catchAll[R1 <: R, E2, A1 >: A](h: (E) => ZIO[R1, E2, A1])(implicit ev: CanFail[E]): ZIO[R1, E2, A1]
Recovers from all errors.
Recovers from all errors.
openFile("config.json").catchAll(_ => IO.succeed(defaultConfig))
- final def catchAllCause[R1 <: R, E2, A1 >: A](h: (Cause[E]) => ZIO[R1, E2, A1]): ZIO[R1, E2, A1]
Recovers from all errors with provided Cause.
Recovers from all errors with provided Cause.
openFile("config.json").catchAllCause(_ => IO.succeed(defaultConfig))
- See also
absorb, sandbox, mapErrorCause - other functions that can recover from defects
- final def catchSome[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[E, ZIO[R1, E1, A1]])(implicit ev: CanFail[E]): ZIO[R1, E1, A1]
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") }
- final def catchSomeCause[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[Cause[E], ZIO[R1, E1, A1]]): ZIO[R1, E1, A1]
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") }
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- final def collect[E1 >: E, B](e: E1)(pf: PartialFunction[A, B]): ZIO[R, E1, B]
Fail with
e
if the suppliedPartialFunction
does not match, otherwise succeed with the returned value. - final def collectM[R1 <: R, E1 >: E, B](e: E1)(pf: PartialFunction[A, ZIO[R1, E1, B]]): ZIO[R1, E1, B]
Fail with
e
if the suppliedPartialFunction
does not match, otherwise continue with the returned value. - final def compose[R1, E1 >: E](that: ZIO[R1, E1, R]): ZIO[R1, E1, A]
- final def daemon: ZIO[R, E, A]
Turns on daemon mode for this region, which means that any fibers forked in this region will be daemon fibers—new roots in the fiber graph and invisible to the their (otherwise) parent fiber, and not interrupted when their (otherwise) parent fiber is interrupted.
- final def daemonStatus(status: DaemonStatus): ZIO[R, E, A]
Changes the daemon mode status for this region, either turning it off (the default), or turning it on.
- final def delay(duration: Duration): ZIO[R with Clock, E, A]
Returns an effect that is delayed from this effect by the specified zio.duration.Duration.
- final def doUntil(f: (A) => Boolean): ZIO[R, E, A]
Repeats this effect until its result satisfies the specified predicate.
- final def doWhile(f: (A) => Boolean): ZIO[R, E, A]
Repeats this effect while its result satisfies the specified predicate.
- final def either(implicit ev: CanFail[E]): URIO[R, Either[E, A]]
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 theEither
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 theEither
success case.This method is useful for recovering from
ZIO
effects that may fail.The error parameter of the returned
ZIO
isNothing
, since it is guaranteed theZIO
effect does not model failure. - final def ensuring[R1 <: R](finalizer: URIO[R1, Any]): ZIO[R1, E, A]
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.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
, seeZIO#bracket
. - final def ensuringChild[R1 <: R](f: (Fiber[Any, List[Any]]) => ZIO[R1, Nothing, Any]): ZIO[R1, E, A]
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.
- final def ensuringChildren[R1 <: R](f: (Iterable[Fiber[Any, Any]]) => ZIO[R1, Nothing, Any]): ZIO[R1, E, A]
Acts on the children of this fiber, guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def eventually(implicit ev: CanFail[E]): URIO[R, A]
Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
- final def filterOrDie(p: (A) => Boolean)(t: => Throwable): ZIO[R, E, A]
Dies with specified
Throwable
if the predicate fails. - final def filterOrDieMessage(p: (A) => Boolean)(message: => String): ZIO[R, E, A]
Dies with a java.lang.RuntimeException having the specified text message if the predicate fails.
- final def filterOrElse[R1 <: R, E1 >: E, A1 >: A](p: (A) => Boolean)(f: (A) => ZIO[R1, E1, A1]): ZIO[R1, E1, A1]
Applies
f
if the predicate fails. - final def filterOrElse_[R1 <: R, E1 >: E, A1 >: A](p: (A) => Boolean)(zio: => ZIO[R1, E1, A1]): ZIO[R1, E1, A1]
Supplies
zio
if the predicate fails. - final def filterOrFail[E1 >: E](p: (A) => Boolean)(e: => E1): ZIO[R, E1, A]
Fails with
e
if the predicate fails. - def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def firstSuccessOf[R1 <: R, E1 >: E, A1 >: A](rest: Iterable[ZIO[R1, E1, A1]]): ZIO[R1, E1, A1]
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
- def flatMap[R1 <: R, E1 >: E, B](k: (A) => ZIO[R1, E1, B]): ZIO[R1, E1, B]
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))
- final def flatMapError[R1 <: R, E2](f: (E) => URIO[R1, E2])(implicit ev: CanFail[E]): ZIO[R1, E2, A]
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))
- final def flatten[R1 <: R, E1 >: E, B](implicit ev1: <:<[A, ZIO[R1, E1, B]]): ZIO[R1, E1, B]
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.
- final def flattenErrorOption[E1, E2 <: E1](default: E2)(implicit ev: <:<[E, Option[E1]]): ZIO[R, E1, A]
- final def flip: ZIO[R, A, E]
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.
- final def flipWith[R1, A1, E1](f: (ZIO[R, A, E]) => ZIO[R1, A1, E1]): ZIO[R1, E1, A1]
Swaps the error/value parameters, applies the function
f
and flips the parameters back - final def fold[B](failure: (E) => B, success: (A) => B)(implicit ev: CanFail[E]): URIO[R, B]
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
. - final def foldCause[B](failure: (Cause[E]) => B, success: (A) => B): URIO[R, B]
A more powerful version of
fold
that allows recovering from any kind of failure except interruptions. - def foldCauseM[R1 <: R, E2, B](failure: (Cause[E]) => ZIO[R1, E2, B], success: (A) => ZIO[R1, E2, B]): ZIO[R1, E2, B]
A more powerful version of
foldM
that allows recovering from any kind of failure except interruptions. - final def foldM[R1 <: R, E2, B](failure: (E) => ZIO[R1, E2, B], success: (A) => ZIO[R1, E2, B])(implicit ev: CanFail[E]): ZIO[R1, E2, B]
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 toflatMap
to define the next effect.The error parameter of the returned
IO
may be chosen arbitrarily, since it will depend on theIO
s returned by the given continuations. - final def forever: ZIO[R, E, Nothing]
Repeats this effect forever (until the first error).
Repeats this effect forever (until the first error). For more sophisticated schedules, see the
repeat
method. - final def fork: URIO[R, Fiber[E, A]]
Returns an effect that forks this effect into its own separate fiber, returning the fiber immediately, without waiting for it to compute its value.
Returns an effect that forks this effect into its own separate fiber, returning the fiber immediately, without waiting for it to compute its value.
The returned fiber can be used to interrupt the forked fiber, await its result, or join the fiber. See zio.Fiber for more information.
for { fiber <- subtask.fork // Do stuff... a <- fiber.join } yield a
- final def forkAs(name: String): URIO[R, Fiber[E, A]]
Forks the effect into a new independent fiber, with the specified name.
- final def forkOn(ec: ExecutionContext): ZIO[R, E, Fiber[E, A]]
Forks an effect that will be executed on the specified
ExecutionContext
. - final def get[E1 >: E, B](implicit ev1: =:=[E1, Nothing], ev2: <:<[A, Option[B]]): ZIO[R, Unit, B]
Unwraps the optional success of this effect, but can fail with unit value.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def handleChildrenWith[R1 <: R, E1 >: E](f: (Iterable[Fiber[Any, Any]]) => URIO[R1, Any]): ZIO[R1, E1, A]
Returns a new effect that, on exit of this effect, invokes the specified handler with all forked (non-daemon) children of this effect.
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def head[B](implicit ev: <:<[A, List[B]]): ZIO[R, Option[E], B]
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. - final def ignore: URIO[R, Unit]
Returns a new effect that ignores the success or failure of this effect.
- final def interruptStatus(flag: InterruptStatus): ZIO[R, E, A]
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 iffalse
is used, then the effect becomes uninterruptible. These changes are compositional, so they only affect regions of the effect. - final def interruptible: ZIO[R, E, A]
Performs this effect interruptibly.
Performs this effect interruptibly. Because this is the default, this operation only has additional meaning if the effect is located within an uninterruptible section.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def join[R1, E1 >: E, A1 >: A](that: ZIO[R1, E1, A1]): ZIO[Either[R, R1], E1, A1]
Joins this effect with the specified effect.
- def left[B, C](implicit ev: <:<[A, Either[B, C]]): ZIO[R, Option[E], B]
Returns a successful effect if the value is
Left
, or fails with the errorNone
. - def leftOrFail[B, C, E1 >: E](e: E1)(implicit ev: <:<[A, Either[B, C]]): ZIO[R, E1, B]
Returns a successful effect if the value is
Left
, or fails with the error e. - def leftOrFailException[B, C, E1 >: NoSuchElementException](implicit ev: <:<[A, Either[B, C]], ev2: <:<[E, E1]): ZIO[R, E1, B]
Returns a successful effect if the value is
Left
, or fails with a java.util.NoSuchElementException. - final def lock(executor: Executor): ZIO[R, E, A]
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 executued 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 innermostlock
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. - def map[B](f: (A) => B): ZIO[R, E, B]
Returns an effect whose success is mapped by the specified
f
function. - final def mapError[E2](f: (E) => E2)(implicit ev: CanFail[E]): ZIO[R, E2, A]
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.
- final def mapErrorCause[E2](h: (Cause[E]) => Cause[E2]): ZIO[R, E2, A]
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
.- See also
absorb, sandbox, catchAllCause - other functions for dealing with defects
- final def memoize: URIO[R, IO[E, A]]
Returns an effect that, if evaluated, will return the lazily computed result of this effect.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def nonDaemon: ZIO[R, E, A]
Turns off daemon mode for this region, which means that any fibers forked in this region will not be daemon fibers, so they will be visible as children of their parent fiber, and interrupted when their parent fiber is interrupted.
- final def none[B](implicit ev: <:<[A, Option[B]]): ZIO[R, Option[E], Unit]
Requires the option produced by this value to be
None
. - final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def on(ec: ExecutionContext): ZIO[R, E, A]
Executes the effect on the specified
ExecutionContext
and then shifts back to the default one. - final def onError[R1 <: R](cleanup: (Cause[E]) => URIO[R1, Any]): ZIO[R1, E, A]
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.
- final def onFirst[R1 <: R, A1 >: A]: ZIO[R1, E, (A1, R1)]
Propagates the success value to the first element of a tuple, but passes the effect input
R
along unmodified as the second element of the tuple. - final def onInterrupt[R1 <: R](cleanup: URIO[R1, Any]): ZIO[R1, E, A]
Runs the specified effect if this effect is externally interrupted.
- final def onLeft[R1 <: R, C]: ZIO[Either[R1, C], E, Either[A, C]]
- final def onRight[R1 <: R, C]: ZIO[Either[C, R1], E, Either[C, A]]
- final def onSecond[R1 <: R, A1 >: A]: ZIO[R1, E, (R1, A1)]
Propagates the success value to the second element of a tuple, but passes the effect input
R
along unmodified as the first element of the tuple. - final def onTermination[R1 <: R](cleanup: (Cause[Nothing]) => URIO[R1, Any]): ZIO[R1, E, A]
Runs the specified effect if this effect is terminated, either because of a defect or because of interruption.
- final def option(implicit ev: CanFail[E]): URIO[R, Option[A]]
Executes this effect, skipping the error but returning optionally the success.
- final def optional[E1](implicit ev: <:<[E, Option[E1]]): ZIO[R, E1, Option[A]]
Converts an option on errors into an option on values.
- final def orDie[E1 >: E](implicit ev1: <:<[E1, Throwable], ev2: CanFail[E]): URIO[R, A]
Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.
- final def orDieWith(f: (E) => Throwable)(implicit ev: CanFail[E]): URIO[R, A]
Keeps none of the errors, and terminates the fiber with them, using the specified function to convert the
E
into aThrowable
. - final def orElse[R1 <: R, E2, A1 >: A](that: => ZIO[R1, E2, A1])(implicit ev: CanFail[E]): ZIO[R1, E2, A1]
Executes this effect and returns its value, if it succeeds, but otherwise executes the specified effect.
- final def orElseEither[R1 <: R, E2, B](that: => ZIO[R1, E2, B])(implicit ev: CanFail[E]): ZIO[R1, E2, Either[A, B]]
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.
- final def parallelErrors[E1 >: E]: ZIO[R, ::[E1], A]
Exposes all parallel errors in a single call
- final def provide(r: R)(implicit ev: NeedsEnv[R]): IO[E, A]
Provides the
ZIO
effect with its required environment, which eliminates its dependency onR
. - final def provideM[E1 >: E](r: ZIO[Any, E1, R])(implicit ev: NeedsEnv[R]): ZIO[Any, E1, A]
An effectual version of
provide
, useful when the act of provision requires an effect. - final def provideManaged[E1 >: E](r0: Managed[E1, R])(implicit ev: NeedsEnv[R]): IO[E1, A]
Uses the given Managed[E1, R] to the environment required to run this effect, leaving no outstanding environments and returning IO[E1, A]
- final def provideSome[R0](f: (R0) => R)(implicit ev: NeedsEnv[R]): ZIO[R0, E, A]
Provides some of the environment required to run this effect, leaving the remainder
R0
.Provides some of the environment required to run this effect, leaving the remainder
R0
.val effect: ZIO[Console with Logging, Nothing, Unit] = ??? effect.provideSome[Console](env => new Console with Logging { val console = env.console val logging = new Logging.Service[Any] { def log(line: String) = console.putStrLn(line) } } )
- final def provideSomeM[R0, E1 >: E](r0: ZIO[R0, E1, R])(implicit ev: NeedsEnv[R]): ZIO[R0, E1, A]
An effectful version of
provideSome
, useful when the act of partial provision requires an effect.An effectful version of
provideSome
, useful when the act of partial provision requires an effect.val effect: ZIO[Console with Logging, Nothing, Unit] = ??? val r0: URIO[Console, Console with Logging] = ??? effect.provideSomeM(r0)
- final def provideSomeManaged[R0, E1 >: E](r0: ZManaged[R0, E1, R])(implicit ev: NeedsEnv[R]): ZIO[R0, E1, A]
Uses the given ZManaged[R0, E1, R] to provide some of the environment required to run this effect, leaving the remainder
R0
. - final def race[R1 <: R, E1 >: E, A1 >: A](that: ZIO[R1, E1, A1]): ZIO[R1, E1, A1]
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. - def raceAll[R1 <: R, E1 >: E, A1 >: A](ios: Iterable[ZIO[R1, E1, A1]]): ZIO[R1, E1, A1]
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
- final def raceAttempt[R1 <: R, E1 >: E, A1 >: A](that: ZIO[R1, E1, A1]): ZIO[R1, E1, A1]
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.
- final def raceEither[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, Either[A, B]]
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.
- final def raceWith[R1 <: R, E1, E2, B, C](that: ZIO[R1, E1, B])(leftDone: (Exit[E, A], Fiber[E1, B]) => ZIO[R1, E2, C], rightDone: (Exit[E1, B], Fiber[E, A]) => ZIO[R1, E2, C]): ZIO[R1, E2, C]
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.
- final def refailWithTrace: ZIO[R, E, A]
Attach a wrapping trace pointing to this location in case of error.
Attach a wrapping trace pointing to this location in case of error.
Useful when joining fibers to make the resulting trace mention the
join
point, otherwise only the traces of joined fibers are included.for { badFiber <- UIO(1 / 0).fork _ <- badFiber.join.refailWithTrace } yield ()
- final def refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: <:<[E, Throwable], ev2: CanFail[E]): ZIO[R, E1, A]
Keeps some of the errors, and terminates the fiber with the rest
- final def refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) => Throwable)(implicit ev: CanFail[E]): ZIO[R, E1, A]
Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the
E
into aThrowable
. - final def refineToOrDie[E1](implicit arg0: ClassTag[E1], ev1: <:<[E, Throwable], ev2: CanFail[E]): ZIO[R, E1, A]
Keeps some of the errors, and terminates the fiber with the rest.
- final def reject[R1 <: R, E1 >: E](pf: PartialFunction[A, E1]): ZIO[R1, E1, A]
Fail with the returned value if the
PartialFunction
matches, otherwise continue with our held value. - final def rejectM[R1 <: R, E1 >: E](pf: PartialFunction[A, ZIO[R1, E1, E1]]): ZIO[R1, E1, A]
Continue with the returned computation if the
PartialFunction
matches, translating the successful match into a failure, otherwise continue with our held value. - final def repeat[R1 <: R, B](schedule: Schedule[R1, A, B]): ZIO[R1, E, B]
Repeats this effect with the specified schedule until the schedule completes, or until the first failure.
Repeats this effect with the specified schedule until the schedule completes, or until the first failure. Repeats are done in addition to the first execution so that
io.repeat(Schedule.once)
means "execute io and in case of success repeatio
once". - final def repeatOrElse[R1 <: R, E2, B](schedule: Schedule[R1, A, B], orElse: (E, Option[B]) => ZIO[R1, E2, B]): ZIO[R1, E2, B]
Repeats this effect with the specified schedule until the schedule completes, or until the first failure.
Repeats this effect with the specified schedule until the schedule completes, or until the first failure. In the event of failure the progress to date, together with the error, will be passed to the specified handler.
- final def repeatOrElseEither[R1 <: R, B, E2, C](schedule: Schedule[R1, A, B], orElse: (E, Option[B]) => ZIO[R1, E2, C]): ZIO[R1, E2, Either[C, B]]
Repeats this effect with the specified schedule until the schedule completes, or until the first failure.
Repeats this effect with the specified schedule until the schedule completes, or until the first failure. In the event of failure the progress to date, together with the error, will be passed to the specified handler.
- final def retry[R1 <: R, E1 >: E, S](policy: Schedule[R1, E1, S])(implicit ev: CanFail[E]): ZIO[R1, E, A]
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 withonce
orrecurs
for example), so that thatio.retry(Schedule.once)
means "executeio
and in case of failure, try again once". - final def retryOrElse[R1 <: R, A2 >: A, E1 >: E, S, E2](policy: Schedule[R1, E1, S], orElse: (E, S) => ZIO[R1, E2, A2])(implicit ev: CanFail[E]): ZIO[R1, E2, A2]
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.
- final def retryOrElseEither[R1 <: R, E1 >: E, S, E2, B](policy: Schedule[R1, E1, S], orElse: (E, S) => ZIO[R1, E2, B])(implicit ev: CanFail[E]): ZIO[R1, E2, Either[B, A]]
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.
- def right[B, C](implicit ev: <:<[A, Either[B, C]]): ZIO[R, Option[E], C]
Returns a succesful effect if the value is
Right
, or fails with the errorNone
. - def rightOrFail[B, C, E1 >: E](e: E1)(implicit ev: <:<[A, Either[B, C]]): ZIO[R, E1, C]
Returns a successful effect if the value is
Right
, or fails with the given error 'e'. - def rightOrFailException[B, C, E1 >: NoSuchElementException](implicit ev: <:<[A, Either[B, C]], ev2: <:<[E, E1]): ZIO[R, E1, C]
Returns a successful effect if the value is
Right
, or fails with a java.util.NoSuchElementException. - final def run: URIO[R, Exit[E, A]]
Returns an effect that semantically runs the effect on a fiber, producing an zio.Exit for the completion value of the fiber.
- final def sandbox: ZIO[R, Cause[E], A]
Exposes the full cause of failure of this effect.
Exposes the full cause of failure of this effect.
case class DomainError() val veryBadIO: IO[DomainError, Unit] = IO.effectTotal(5 / 0) *> IO.fail(DomainError()) val caught: UIO[Unit] = veryBadIO.sandbox.catchAll { case Cause.Die(_: ArithmeticException) => // Caught defect: divided by zero! IO.succeed(0) case Cause.Fail(e) => // Caught error: DomainError! IO.succeed(0) case cause => // Caught unknown defects, shouldn't recover! IO.halt(cause) * }
- final def sandboxWith[R1 <: R, E2, B](f: (ZIO[R1, Cause[E], A]) => ZIO[R1, Cause[E2], B]): ZIO[R1, E2, B]
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.effectTotal(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
withcatchSome
is better than usingio.sandbox.catchAll
with a partial match, because in the latter, if the match fails, the original defects will be lost and replaced by aMatchError
- final def some[B](implicit ev: <:<[A, Option[B]]): ZIO[R, Option[E], B]
- def some[A](a: A): UIO[Option[A]]
Returns an effect with the optional value.
- def someOrFail[B, E1 >: E](e: E1)(implicit ev: <:<[A, Option[B]]): ZIO[R, E1, B]
Extracts the optional value, or fails with the given error 'e'.
- def someOrFailException[B, E1 >: E](implicit ev: <:<[A, Option[B]], ev2: <:<[NoSuchElementException, E1]): ZIO[R, E1, B]
Extracts the optional value, or fails with a java.util.NoSuchElementException
- final def succeed[A](a: A): UIO[A]
Returns an effect that models success with the specified strictly- evaluated value.
- final def summarized[R1 <: R, E1 >: E, B, C](f: (B, B) => C)(summary: ZIO[R1, E1, B]): ZIO[R1, E1, (C, A)]
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.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- final def tap[R1 <: R, E1 >: E](f: (A) => ZIO[R1, E1, Any]): ZIO[R1, E1, A]
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(putStrLn)
- final def tapBoth[R1 <: R, E1 >: E](f: (E) => ZIO[R1, E1, Any], g: (A) => ZIO[R1, E1, Any])(implicit ev: CanFail[E]): ZIO[R1, E1, A]
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(_))
- final def tapError[R1 <: R, E1 >: E](f: (E) => ZIO[R1, E1, Any])(implicit ev: CanFail[E]): ZIO[R1, E1, A]
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(_))
- final def timed: ZIO[R with Clock, E, (Duration, A)]
Returns a new effect that executes this one and times the execution.
- final def timedWith[R1 <: R, E1 >: E](nanoTime: ZIO[R1, E1, Long]): ZIO[R1, E1, (Duration, A)]
A more powerful variation of
timed
that allows specifying the clock. - final def timeout(d: Duration): ZIO[R with Clock, E, Option[A]]
Returns an effect that will timeout this effect, returning
None
if the timeout elapses before the effect has produced a value; and returningSome
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 returningSome
of the produced value otherwise.If the timeout elapses without producing a value, the running effect will be safely interrupted
- final def timeoutFail[E1 >: E](e: E1)(d: Duration): ZIO[R with Clock, E1, A]
The same as timeout, but instead of producing a
None
in the event of timeout, it will produce the specified error. - final def timeoutFork(d: Duration): ZIO[R with Clock, E, Either[Fiber[E, A], A]]
Returns an effect that will attempt to timeout this effect, but will not wait for the running effect to terminate if the timeout elapses without producing a value.
Returns an effect that will attempt to timeout this effect, but will not wait for the running effect to terminate if the timeout elapses without producing a value. Returns
Right
with the produced value if the effect completes before the timeout orLeft
with the interrupting fiber otherwise. - final def timeoutTo[R1 <: R, E1 >: E, A1 >: A, B](b: B): TimeoutTo[R1, E1, A1, B]
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)
- final def to[E1 >: E, A1 >: A](p: Promise[E1, A1]): URIO[R, Boolean]
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.
- final def toFuture(implicit ev2: <:<[E, Throwable]): URIO[R, CancelableFuture[E, A]]
Converts the effect into a scala.concurrent.Future.
- final def toFutureWith(f: (E) => Throwable): URIO[R, CancelableFuture[E, A]]
Converts the effect into a scala.concurrent.Future.
- final def toManaged[R1 <: R](release: (A) => URIO[R1, Any]): ZManaged[R1, E, A]
Converts this ZIO to zio.Managed.
Converts this ZIO to zio.Managed. This ZIO and the provided release action will be performed uninterruptibly.
- final def toManaged_: ZManaged[R, E, A]
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.
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def traced: ZIO[R, E, A]
Enables ZIO tracing for this effect.
Enables ZIO tracing for this effect. Because this is the default, this operation only has an additional meaning if the effect is located within an
untraced
section, or the current fiber has been spawned by a parent inside anuntraced
section. - final def tracingStatus(flag: TracingStatus): ZIO[R, E, A]
Toggles ZIO tracing support for this effect.
Toggles ZIO tracing support for this effect. If
true
is used, then the effect will accumulate traces, while iffalse
is used, then tracing is disabled. These changes are compositional, so they only affect regions of the effect. - final def uninterruptible: ZIO[R, E, A]
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).
- final def unit: ZIO[R, E, Unit]
Returns the effect resulting from mapping the success of this effect to unit.
- final def unsandbox[R1 <: R, E1, A1 >: A](implicit ev1: <:<[ZIO[R, E, A], ZIO[R1, Cause[E1], A1]]): ZIO[R1, E1, A1]
The inverse operation to
sandbox
.The inverse operation to
sandbox
. Submerges the full cause of failure. - final def untraced: ZIO[R, E, A]
Disables ZIO tracing facilities for the duration of the effect.
Disables ZIO tracing facilities for the duration of the effect.
Note: ZIO tracing is cached, as such after the first iteration it has a negligible effect on performance of hot-spots (Additional hash map lookup per flatMap). As such, using
untraced
sections is not guaranteed to result in a noticeable performance increase. - final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def when[R1 <: R, E1 >: E](b: Boolean): ZIO[R1, E1, Unit]
The moral equivalent of
if (p) exp
- final def whenM[R1 <: R, E1 >: E](b: URIO[R1, Boolean]): ZIO[R1, E1, Unit]
The moral equivalent of
if (p) exp
whenp
has side-effects - final def withFilter[E1 >: E](predicate: (A) => Boolean)(implicit ev1: <:<[NoSuchElementException, E1], ev2: CanFail[E]): ZIO[R, E1, A]
Enables to check conditions in the value produced by ZIO If the condition is not satisfied, it fails with NoSuchElementException this provide the syntax sugar in for-comprehension: for { (i, j) <- io1 positive <- io2 if positive > 0 } yield ()
- final def zip[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, (A, B)]
A named alias for
&&&
or<*>
. - final def zipLeft[R1 <: R, E1 >: E, B](that: => ZIO[R1, E1, B]): ZIO[R1, E1, A]
A named alias for
<*
. - final def zipPar[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, (A, B)]
A named alias for
<&>
. - final def zipParLeft[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, A]
A named alias for
<&
. - final def zipParRight[R1 <: R, E1 >: E, B](that: ZIO[R1, E1, B]): ZIO[R1, E1, B]
A named alias for
&>
. - final def zipRight[R1 <: R, E1 >: E, B](that: => ZIO[R1, E1, B]): ZIO[R1, E1, B]
A named alias for
*>
. - final def zipWith[R1 <: R, E1 >: E, B, C](that: => ZIO[R1, E1, B])(f: (A, B) => C): ZIO[R1, E1, C]
Sequentially zips this effect with the specified effect using the specified combiner function.
- final def zipWithPar[R1 <: R, E1 >: E, B, C](that: ZIO[R1, E1, B])(f: (A, B) => C): ZIO[R1, E1, C]
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. - final def |||[R1, E1 >: E, A1 >: A](that: ZIO[R1, E1, A1]): ZIO[Either[R, R1], E1, A1]
Deprecated Value Members
- final def const[B](b: => B): ZIO[R, E, B]
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use as
- final def succeedLazy[A](a: => A): UIO[A]
Returns an effect that models success with the specified lazily-evaluated value.
Returns an effect that models success with the specified lazily-evaluated value. This method should not be used to capture effects. See
ZIO.effectTotal
for capturing total effects, andZIO.effect
for capturing partial effects.- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use effectTotal
- final def void: ZIO[R, E, Unit]
Returns the effect resulting from mapping the success of this effect to unit.
Returns the effect resulting from mapping the success of this effect to unit.
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use unit