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
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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, specified effect result returned.
Returns an effect that executes both this effect and the specified effect, in parallel, specified 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, 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]): 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
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
final
def
bimap[E2, B](f: (E) ⇒ E2, g: (A) ⇒ B): 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
bracketExit[R1 <: R, E1 >: E, B](release: (A, Exit[E1, B]) ⇒ ZIO[R1, Nothing, _], use: (A) ⇒ ZIO[R1, E1, B]): ZIO[R1, E1, B]
Shorthand for the uncurried version of
ZIO.bracketExit
. -
final
def
bracketExit[R1 <: R, E1 >: E, A1 >: A]: BracketExitAcquire[R1, E1, A1]
Shorthand for the curried version of
ZIO.bracketExit
. -
final
def
bracketOnError[R1 <: R, E1 >: E, B](release: (A) ⇒ ZIO[R1, Nothing, _])(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: ZIO[R1, Nothing, _], 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
catchAll[R1 <: R, E2, A1 >: A](h: (E) ⇒ ZIO[R1, E2, A1]): ZIO[R1, E2, A1]
Recovers from all errors.
Recovers from all errors.
openFile("config.json").catchAll(_ => IO.succeed(defaultConfig))
-
final
def
catchSome[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[E, ZIO[R1, E1, A1]]): 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") }
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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
const[B](b: ⇒ B): ZIO[R, E, B]
Maps this effect to the specified constant while preserving the effects of this effect.
-
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
either: ZIO[R, Nothing, 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: ZIO[R1, Nothing, _]): 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
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- final def first[R1 <: R, A1 >: A]: ZIO[R1, E, (A1, R1)]
-
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) ⇒ ZIO[R1, Nothing, E2]): 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
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](err: (E) ⇒ B, succ: (A) ⇒ B): ZIO[R, Nothing, 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
. -
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]): 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: ZIO[R, Nothing, 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
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[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
handleChildrenWith[R1 <: R](supervisor: (Iterable[Fiber[_, _]]) ⇒ ZIO[R1, Nothing, _]): ZIO[R1, E, A]
Supervises this effect, which ensures that any fibers that are forked by the effect are handled by the provided supervisor.
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
interruptChildren: ZIO[R, E, A]
Returns a new effect that ensures that any fibers that are forked by the effect are interrupted when this effect completes.
-
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]
- final def left[R1 <: R, C]: ZIO[Either[R1, C], E, Either[A, C]]
-
final
def
lock(executor: Executor): ZIO[R, E, A]
Returns an effect whose execution is locked to the specified executor.
Returns an effect whose execution is locked to the specified executor. 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.
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): 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
memoize: ZIO[R, Nothing, 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
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]) ⇒ ZIO[R1, Nothing, _]): 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
onInterrupt[R1 <: R](cleanup: ZIO[R1, Nothing, _]): ZIO[R1, E, A]
Runs the specified effect if this effect is interrupted.
-
final
def
onTermination[R1 <: R](cleanup: (Cause[Nothing]) ⇒ ZIO[R1, Nothing, _]): 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: ZIO[R, Nothing, Option[A]]
Executes this effect, skipping the error but returning optionally the success.
-
final
def
orDie[E1 >: E](implicit ev: <:<[E1, Throwable]): ZIO[R, Nothing, 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): ZIO[R, Nothing, 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]): 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]): 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
provide(r: R): IO[E, A]
Provides the
ZIO
effect with its required environment, which eliminates its dependency onR
. -
final
def
provideManaged[E1 >: E](r0: Managed[E1, 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): 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](console => new Console with Logging { val console = console val logging = new Logging { def log(line: String) = console.putStrLn(line) } } )
-
final
def
provideSomeM[R0, E1 >: E](r0: ZIO[R0, E1, 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: ZIO[Console, Nothing, Console with Logging] = ??? effect.provideSomeM(r0)
-
final
def
provideSomeManaged[R0, E1 >: E](r0: ZManaged[R0, E1, 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 ev: <:<[E, Throwable]): 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): 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], ev: <:<[E, Throwable]): 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: ZSchedule[R1, A, B]): ZIO[R1 with Clock, 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: ZSchedule[R1, A, B], orElse: (E, Option[B]) ⇒ ZIO[R1, E2, B]): ZIO[R1 with Clock, 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: ZSchedule[R1, A, B], orElse: (E, Option[B]) ⇒ ZIO[R1 with Clock, E2, C]): ZIO[R1 with Clock, 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: ZSchedule[R1, E1, S]): ZIO[R1 with Clock, E1, 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: ZSchedule[R1, E1, S], orElse: (E1, S) ⇒ ZIO[R1, E2, A2]): ZIO[R1 with Clock, 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: ZSchedule[R1, E1, S], orElse: (E1, S) ⇒ ZIO[R1, E2, B]): ZIO[R1 with Clock, 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.
- final def right[R1 <: R, C]: ZIO[Either[C, R1], E, Either[C, A]]
-
final
def
run: ZIO[R, Nothing, 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 second[R1 <: R, A1 >: A]: ZIO[R1, E, (R1, A1)]
-
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
supervised: ZIO[R, E, A]
Enables supervision for this effect.
Enables supervision for this effect. This will cause fibers forked by this effect to be tracked and will enable their inspection via ZIO.children.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
final
def
tap[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, _]): 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, _], g: (A) ⇒ ZIO[R1, E1, _]): 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, _]): 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
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]): ZIO[R, Nothing, 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]): ZIO[R, Nothing, Future[A]]
Converts the effect into a scala.concurrent.Future.
-
final
def
toFutureWith(f: (E) ⇒ Throwable): ZIO[R, Nothing, Future[A]]
Converts the effect into a scala.concurrent.Future.
-
final
def
toManaged[R1 <: R](release: (A) ⇒ ZIO[R1, Nothing, _]): ZManaged[R1, E, A]
Converts this ZIO to zio.Managed.
-
final
def
toManaged_: ZManaged[R, E, A]
Converts this ZIO to zio.ZManaged with no release action.
-
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
unsupervised: ZIO[R, E, A]
Disables supervision for this effect.
Disables supervision for this effect. This will cause fibers forked by this effect to not be tracked or appear in the list returned by ZIO.children.
-
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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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: ZIO[R1, Nothing, Boolean]): ZIO[R1, E1, Unit]
The moral equivalent of
if (p) exp
whenp
has side-effects -
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]