final case class Failure[+E](cause: Cause[E]) extends Exit[E, Nothing] with Product with Serializable
- Alphabetic
- By Inheritance
- Failure
- Exit
- ZIO
- ZIOVersionSpecific
- ZIOPlatformSpecific
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!(implicit ev1: <:<[E, Throwable], ev2: CanFail[E], trace: Trace): ZIO[Any, Nothing, Nothing]
A symbolic alias for
orDie
.A symbolic alias for
orDie
.- Definition Classes
- ZIO
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
&>[E1 >: E, B](that: Exit[E1, B]): Exit[E1, B]
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]
- Definition Classes
- Exit
-
final
def
&>[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): 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.
- Definition Classes
- ZIO
-
final
def
*>[E1 >: E, B](that: Exit[E1, B]): Exit[E1, B]
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]
- Definition Classes
- Exit
-
final
def
*>[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, B]
A variant of
flatMap
that ignores the value produced by this effect.A variant of
flatMap
that ignores the value produced by this effect.- Definition Classes
- ZIO
-
final
def
<&[E1 >: E, B](that: Exit[E1, B]): Exit[E1, Nothing]
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]
- Definition Classes
- Exit
-
final
def
<&[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, Nothing]
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.
- Definition Classes
- ZIO
-
final
def
<&>[E1 >: E, B](that: Exit[E1, B])(implicit zippable: Zippable[Nothing, B]): Exit[E1, Out]
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]
- Definition Classes
- Exit
-
final
def
<&>[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit zippable: Zippable[Nothing, B], trace: Trace): ZIO[R1, E1, Out]
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.
- Definition Classes
- ZIO
-
final
def
<*[E1 >: E, B](that: Exit[E1, B]): Exit[E1, Nothing]
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]
- Definition Classes
- Exit
-
final
def
<*[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, Nothing]
Sequences the specified effect after this effect, but ignores the value produced by the effect.
Sequences the specified effect after this effect, but ignores the value produced by the effect.
- Definition Classes
- ZIO
-
final
def
<*>[E1 >: E, B](that: Exit[E1, B])(implicit zippable: Zippable[Nothing, B]): Exit[E1, Out]
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]
- Definition Classes
- Exit
-
final
def
<*>[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit zippable: Zippable[Nothing, B], trace: Trace): ZIO[R1, E1, Out]
Sequentially zips this effect with the specified effect, combining the results into a tuple.
Sequentially zips this effect with the specified effect, combining the results into a tuple.
- Definition Classes
- ZIO
-
final
def
<+>[R1 <: Any, E1, B](that: ⇒ ZIO[R1, E1, B])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Either[Nothing, B]]
A symbolic alias for
orElseEither
.A symbolic alias for
orElseEither
.- Definition Classes
- ZIO
-
final
def
<>[R1 <: Any, E2, A1 >: Nothing](that: ⇒ ZIO[R1, E2, A1])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, A1]
Operator alias for
orElse
.Operator alias for
orElse
.- Definition Classes
- ZIO
-
final
def
<|>[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, Either[Nothing, B]]
A symbolic alias for
raceEither
.A symbolic alias for
raceEither
.- Definition Classes
- ZIO
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
@@[LowerR <: UpperR, UpperR <: Any, LowerE >: E, UpperE >: LowerE, LowerA >: Nothing, UpperA >: LowerA](aspect: ⇒ ZIOAspect[LowerR, UpperR, LowerE, UpperE, LowerA, UpperA])(implicit trace: Trace): ZIO[UpperR, LowerE, LowerA]
Returns a new effect that applies the specified aspect to this effect.
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).
- Definition Classes
- ZIO
-
final
def
absolve[E1 >: E, B](implicit ev: IsSubtypeOfOutput[Nothing, Either[E1, B]], trace: Trace): ZIO[Any, 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
.- Definition Classes
- ZIO
-
final
def
absorb(implicit ev: IsSubtypeOfError[E, Throwable], trace: Trace): RIO[Any, Nothing]
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
- Definition Classes
- ZIO
-
final
def
absorbWith(f: (E) ⇒ Throwable)(implicit trace: Trace): RIO[Any, Nothing]
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
Attempts to convert defects into a failure, throwing away all information about the cause of the failure.
- Definition Classes
- ZIO
-
final
def
as[B](b: ⇒ B)(implicit trace: Trace): ZIO[Any, E, B]
Maps the success value of this effect to the specified constant value.
-
final
def
asExit[B](b: B): Exit[E, B]
Replaces the success value with the one provided.
Replaces the success value with the one provided.
- Definition Classes
- Exit
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
final
def
asLeft(implicit trace: Trace): ZIO[Any, E, Either[Nothing, Nothing]]
Maps the success value of this effect to a left value.
Maps the success value of this effect to a left value.
- Definition Classes
- ZIO
-
final
def
asLeftError(implicit trace: Trace): ZIO[Any, Either[E, Nothing], Nothing]
Maps the error value of this effect to a left value.
Maps the error value of this effect to a left value.
- Definition Classes
- ZIO
-
final
def
asRight(implicit trace: Trace): ZIO[Any, E, Either[Nothing, Nothing]]
Maps the success value of this effect to a right value.
Maps the success value of this effect to a right value.
- Definition Classes
- ZIO
-
final
def
asRightError(implicit trace: Trace): ZIO[Any, Either[Nothing, E], Nothing]
Maps the error value of this effect to a right value.
Maps the error value of this effect to a right value.
- Definition Classes
- ZIO
-
final
def
asSome(implicit trace: Trace): ZIO[Any, E, Option[Nothing]]
Maps the success value of this effect to an optional value.
Maps the success value of this effect to an optional value.
- Definition Classes
- ZIO
-
final
def
asSomeError(implicit trace: Trace): ZIO[Any, Option[E], Nothing]
Maps the error value of this effect to an optional value.
Maps the error value of this effect to an optional value.
- Definition Classes
- ZIO
-
final
def
awaitAllChildren(implicit trace: Trace): ZIO[Any, E, Nothing]
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 a new effect that will not succeed with its value before first waiting for the end of all child fibers forked by the effect.
- Definition Classes
- ZIO
-
final
def
cached(timeToLive: ⇒ zio.Duration)(implicit trace: Trace): ZIO[Any, Nothing, IO[E, Nothing]]
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.- Definition Classes
- ZIO
-
final
def
cachedInvalidate(timeToLive0: ⇒ zio.Duration)(implicit trace: Trace): ZIO[Any, Nothing, (IO[E, Nothing], UIO[Unit])]
Returns an effect that, if evaluated, will return the cached result of this effect.
Returns an effect that, if evaluated, will return the cached result of this effect. Cached results will expire after
timeToLive
duration. In addition, returns an effect that can be used to invalidate the current cached value before thetimeToLive
duration expires.- Definition Classes
- ZIO
-
final
def
catchAll[R1 <: Any, E2, A1 >: Nothing](h: (E) ⇒ ZIO[R1, E2, A1])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, A1]
Recovers from all errors.
Recovers from all errors.
openFile("config.json").catchAll(_ => ZIO.succeed(defaultConfig))
- Definition Classes
- ZIO
-
final
def
catchAllCause[R1 <: Any, E2, A1 >: Nothing](h: (Cause[E]) ⇒ ZIO[R1, E2, A1])(implicit trace: Trace): ZIO[R1, E2, A1]
Recovers from all errors with provided Cause.
Recovers from all errors with provided Cause.
openFile("config.json").catchAllCause(_ => ZIO.succeed(defaultConfig))
- Definition Classes
- ZIO
- See also
absorb, sandbox, mapErrorCause - other functions that can recover from defects
-
final
def
catchAllDefect[R1 <: Any, E1 >: E, A1 >: Nothing](h: (Throwable) ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): ZIO[R1, E1, A1]
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.
- Definition Classes
- ZIO
-
final
def
catchAllTrace[R1 <: Any, E2, A1 >: Nothing](h: ((E, StackTrace)) ⇒ ZIO[R1, E2, A1])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, A1]
A version of
catchAll
that gives you the (optional) trace of the error.A version of
catchAll
that gives you the (optional) trace of the error.- Definition Classes
- ZIO
-
final
def
catchNonFatalOrDie[R1 <: Any, E2, A1 >: Nothing](h: (E) ⇒ ZIO[R1, E2, A1])(implicit ev1: CanFail[E], ev2: <:<[E, Throwable], trace: Trace): ZIO[R1, E2, A1]
Recovers from all NonFatal Throwables.
Recovers from all NonFatal Throwables.
openFile("data.json").catchNonFatalOrDie(_ => openFile("backup.json"))
- Definition Classes
- ZIO
-
final
def
catchSome[R1 <: Any, E1 >: E, A1 >: Nothing](pf: PartialFunction[E, ZIO[R1, E1, A1]])(implicit ev: CanFail[E], trace: Trace): 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") }
- Definition Classes
- ZIO
-
final
def
catchSomeCause[R1 <: Any, E1 >: E, A1 >: Nothing](pf: PartialFunction[Cause[E], ZIO[R1, E1, A1]])(implicit trace: Trace): 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") }
- Definition Classes
- ZIO
-
final
def
catchSomeDefect[R1 <: Any, E1 >: E, A1 >: Nothing](pf: PartialFunction[Throwable, ZIO[R1, E1, A1]])(implicit trace: Trace): ZIO[R1, E1, A1]
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.
- Definition Classes
- ZIO
-
final
def
catchSomeTrace[R1 <: Any, E1 >: E, A1 >: Nothing](pf: PartialFunction[(E, StackTrace), ZIO[R1, E1, A1]])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, A1]
A version of
catchSome
that gives you the trace of the error.A version of
catchSome
that gives you the trace of the error.- Definition Classes
- ZIO
-
final
def
cause(implicit trace: Trace): URIO[Any, Cause[E]]
Returns an effect that succeeds with the cause of failure of this effect, or
Cause.empty
if the effect did succeed.Returns an effect that succeeds with the cause of failure of this effect, or
Cause.empty
if the effect did succeed.- Definition Classes
- ZIO
- val cause: Cause[E]
-
final
def
causeOption: Option[Cause[E]]
Returns an option of the cause of failure.
Returns an option of the cause of failure.
- Definition Classes
- Exit
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
collect[E1 >: E, B](e: ⇒ E1)(pf: PartialFunction[Nothing, B])(implicit trace: Trace): ZIO[Any, E1, B]
Fail with
e
if the suppliedPartialFunction
does not match, otherwise succeed with the returned value.Fail with
e
if the suppliedPartialFunction
does not match, otherwise succeed with the returned value.- Definition Classes
- ZIO
-
final
def
collectZIO[R1 <: Any, E1 >: E, B](e: ⇒ E1)(pf: PartialFunction[Nothing, ZIO[R1, E1, B]])(implicit trace: Trace): ZIO[R1, E1, B]
Fail with
e
if the suppliedPartialFunction
does not match, otherwise continue with the returned value.Fail with
e
if the suppliedPartialFunction
does not match, otherwise continue with the returned value.- Definition Classes
- ZIO
-
final
def
daemonChildren(implicit trace: Trace): ZIO[Any, E, Nothing]
Returns a new effect that will not supervise any fibers forked by this effect.
Returns a new effect that will not supervise any fibers forked by this effect.
- Definition Classes
- ZIO
-
final
def
debug(prefix: ⇒ String)(implicit trace: Trace): ZIO[Any, E, Nothing]
Taps the effect, printing the result of calling
.toString
on the value.Taps the effect, printing the result of calling
.toString
on the value. Prefixes the output with the given message.- Definition Classes
- ZIO
-
final
def
debug(implicit trace: Trace): ZIO[Any, E, Nothing]
Taps the effect, printing the result of calling
.toString
on the value.Taps the effect, printing the result of calling
.toString
on the value.- Definition Classes
- ZIO
-
final
def
delay(duration: ⇒ zio.Duration)(implicit trace: Trace): ZIO[Any, E, Nothing]
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.
- Definition Classes
- ZIO
-
def
diffFiberRefs(implicit trace: Trace): ZIO[Any, E, (Patch, Nothing)]
Returns a new workflow that executes this one and captures the changes in
FiberRef
values.Returns a new workflow that executes this one and captures the changes in
FiberRef
values.- Definition Classes
- ZIO
-
final
def
disconnect(implicit trace: Trace): ZIO[Any, E, Nothing]
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.
- Definition Classes
- ZIO
-
final
def
either(implicit ev: CanFail[E], trace: Trace): URIO[Any, Either[E, Nothing]]
Returns an effect whose failure and success have been lifted into an
Either
.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.- Definition Classes
- ZIO
-
final
def
ensuring[R1 <: Any](finalizer: ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
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
, seeZIO#acquireReleaseWith
.- Definition Classes
- ZIO
-
final
def
ensuringChild[R1 <: Any](f: (Fiber[Any, Iterable[Any]]) ⇒ ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
Acts on the children of this fiber (collected into a single fiber), guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
Acts on the children of this fiber (collected into a single fiber), guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
- Definition Classes
- ZIO
-
def
ensuringChildren[R1 <: Any](children: (Chunk[Fiber.Runtime[Any, Any]]) ⇒ ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
Acts on the children of this fiber, guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
Acts on the children of this fiber, guaranteeing the specified callback will be invoked, whether or not this effect succeeds.
- Definition Classes
- ZIO
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
eventually(implicit ev: CanFail[E], trace: Trace): URIO[Any, Nothing]
Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
- Definition Classes
- ZIO
-
final
def
exists(p: (Nothing) ⇒ Boolean): Boolean
- Definition Classes
- Exit
-
final
def
exit(implicit trace: Trace): URIO[Any, Exit[E, Nothing]]
Returns an effect that semantically runs the effect on a fiber, producing an zio.Exit for the completion value of the fiber.
-
final
def
exitCode(implicit trace: Trace): URIO[Any, ExitCode]
Maps this effect to the default exit codes.
Maps this effect to the default exit codes.
- Definition Classes
- ZIO
-
final
def
filterOrDie(p: (Nothing) ⇒ Boolean)(t: ⇒ Throwable)(implicit trace: Trace): ZIO[Any, E, Nothing]
Dies with specified
Throwable
if the predicate fails.Dies with specified
Throwable
if the predicate fails.- Definition Classes
- ZIO
-
final
def
filterOrDieMessage(p: (Nothing) ⇒ Boolean)(message: ⇒ String)(implicit trace: Trace): ZIO[Any, E, Nothing]
Dies with a java.lang.RuntimeException having the specified text message if the predicate fails.
Dies with a java.lang.RuntimeException having the specified text message if the predicate fails.
- Definition Classes
- ZIO
-
final
def
filterOrDieWith(p: (Nothing) ⇒ Boolean)(t: (Nothing) ⇒ Throwable)(implicit trace: Trace): ZIO[Any, E, Nothing]
Dies with
t
if the predicate fails.Dies with
t
if the predicate fails.- Definition Classes
- ZIO
-
final
def
filterOrElse[R1 <: Any, E1 >: E, A1 >: Nothing](p: (Nothing) ⇒ Boolean)(zio: ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): ZIO[R1, E1, A1]
Supplies
zio
if the predicate fails.Supplies
zio
if the predicate fails.- Definition Classes
- ZIO
-
final
def
filterOrElseWith[R1 <: Any, E1 >: E, A1 >: Nothing](p: (Nothing) ⇒ Boolean)(f: (Nothing) ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): ZIO[R1, E1, A1]
Applies
f
if the predicate fails.Applies
f
if the predicate fails.- Definition Classes
- ZIO
-
final
def
filterOrFail[E1 >: E](p: (Nothing) ⇒ Boolean)(e: ⇒ E1)(implicit trace: Trace): ZIO[Any, E1, Nothing]
Fails with
e
if the predicate fails.Fails with
e
if the predicate fails.- Definition Classes
- ZIO
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
firstSuccessOf[R1 <: Any, E1 >: E, A1 >: Nothing](rest: ⇒ Iterable[ZIO[R1, E1, A1]])(implicit trace: Trace): ZIO[R1, E1, A1]
Returns an effect that runs this effect and in case of failure, runs each of the specified effects in order until one of them succeeds.
Returns an effect that runs this effect and in case of failure, runs each of the specified effects in order until one of them succeeds.
- Definition Classes
- ZIO
-
final
def
flatMap[R1, E1 >: E, B](k: (Nothing) ⇒ ZIO[R1, E1, B])(implicit trace: Trace): 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. -
final
def
flatMapError[R1 <: Any, E2](f: (E) ⇒ URIO[R1, E2])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, Nothing]
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))
- Definition Classes
- ZIO
-
final
def
flatMapExit[E1 >: E, A1](f: (Nothing) ⇒ Exit[E1, A1]): Exit[E1, A1]
Flat maps over the value type.
Flat maps over the value type.
- Definition Classes
- Exit
-
final
def
flatMapExitZIO[E1 >: E, R, E2, A1](f: (Nothing) ⇒ ZIO[R, E2, Exit[E1, A1]]): ZIO[R, E2, Exit[E1, A1]]
Flat maps over the value type.
Flat maps over the value type.
- Definition Classes
- Exit
-
final
def
flatten[R1 <: Any, E1 >: E, B](implicit ev1: IsSubtypeOfOutput[Nothing, ZIO[R1, E1, B]], trace: Trace): 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.
- Definition Classes
- ZIO
-
final
def
flattenErrorOption[E1, E2 <: E1](default: ⇒ E2)(implicit ev: IsSubtypeOfError[E, Option[E1]], trace: Trace): ZIO[Any, E1, Nothing]
Unwraps the optional error, defaulting to the provided value.
Unwraps the optional error, defaulting to the provided value.
- Definition Classes
- ZIO
-
final
def
flattenExit[E1 >: E, B](implicit ev: <:<[Nothing, Exit[E1, B]]): Exit[E1, B]
Flattens an Exit of an Exit into a single Exit value.
Flattens an Exit of an Exit into a single Exit value.
- Definition Classes
- Exit
-
final
def
flip(implicit trace: Trace): ZIO[Any, Nothing, 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.
- Definition Classes
- ZIO
-
final
def
flipWith[R1, A1, E1](f: (ZIO[Any, Nothing, E]) ⇒ ZIO[R1, A1, E1])(implicit trace: Trace): ZIO[R1, E1, A1]
Swaps the error/value parameters, applies the function
f
and flips the parameters backSwaps the error/value parameters, applies the function
f
and flips the parameters back- Definition Classes
- ZIO
-
final
def
fold[B](failure: (E) ⇒ B, success: (Nothing) ⇒ B)(implicit ev: CanFail[E], trace: Trace): URIO[Any, 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
.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
.- Definition Classes
- ZIO
-
final
def
foldCause[B](failure: (Cause[E]) ⇒ B, success: (Nothing) ⇒ B)(implicit trace: Trace): URIO[Any, B]
A more powerful version of
fold
that allows recovering from any kind of failure except external interruption.A more powerful version of
fold
that allows recovering from any kind of failure except external interruption.- Definition Classes
- ZIO
-
final
def
foldCauseZIO[R, E2, B](failure: (Cause[E]) ⇒ ZIO[R, E2, B], success: (Nothing) ⇒ ZIO[R, E2, B])(implicit trace: Trace): ZIO[R, E2, B]
A more powerful version of
foldZIO
that allows recovering from any kind of failure except external interruption. -
final
def
foldExit[Z](failed: (Cause[E]) ⇒ Z, completed: (Nothing) ⇒ Z): Z
Folds over the value or cause.
Folds over the value or cause.
- Definition Classes
- Exit
-
final
def
foldExitZIO[R, E1, B](failed: (Cause[E]) ⇒ ZIO[R, E1, B], completed: (Nothing) ⇒ ZIO[R, E1, B])(implicit trace: Trace): ZIO[R, E1, B]
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]
- Definition Classes
- Exit
-
final
def
foldTraceZIO[R1 <: Any, E2, B](failure: ((E, StackTrace)) ⇒ ZIO[R1, E2, B], success: (Nothing) ⇒ ZIO[R1, E2, B])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, B]
A version of
foldZIO
that gives you the trace of the error.A version of
foldZIO
that gives you the trace of the error.- Definition Classes
- ZIO
-
final
def
foldZIO[R1 <: Any, E2, B](failure: (E) ⇒ ZIO[R1, E2, B], success: (Nothing) ⇒ ZIO[R1, E2, B])(implicit ev: CanFail[E], trace: Trace): 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.- Definition Classes
- ZIO
-
final
def
forEachZIO[R1 <: Any, E2, B](f: (Nothing) ⇒ ZIO[R1, E2, B])(implicit trace: Trace): ZIO[R1, E2, Option[B]]
Returns a new effect that will pass the success value of this effect to the provided callback.
Returns a new effect that will pass the success value of this effect to the provided callback. If this effect fails, then the failure will be ignored.
- Definition Classes
- ZIO
-
final
def
foreach[R, E1 >: E, B](f: (Nothing) ⇒ ZIO[R, E1, B])(implicit trace: Trace): ZIO[R, Nothing, Exit[E1, B]]
Applies the function
f
to the successful result of theExit
and returns the result in a newExit
.Applies the function
f
to the successful result of theExit
and returns the result in a newExit
.- Definition Classes
- Exit
-
final
def
forever(implicit trace: Trace): ZIO[Any, E, Nothing]
- Definition Classes
- ZIO
-
final
def
fork(implicit trace: Trace): URIO[Any, Fiber.Runtime[E, Nothing]]
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 asraceWith
,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
- Definition Classes
- ZIO
-
final
def
forkDaemon(implicit trace: Trace): URIO[Any, Fiber.Runtime[E, Nothing]]
Forks the effect into a new fiber attached to the global scope.
Forks the effect into a new fiber attached to the global scope. Because the new fiber is attached to the global scope, when the fiber executing the returned effect terminates, the forked fiber will continue running.
- Definition Classes
- ZIO
-
final
def
forkIn(scope: ⇒ Scope)(implicit trace: Trace): URIO[Any, Fiber.Runtime[E, Nothing]]
Forks the effect in the specified scope.
Forks the effect in the specified scope. The fiber will be interrupted when the scope is closed.
- Definition Classes
- ZIO
-
final
def
forkScoped(implicit trace: Trace): ZIO[Scope, Nothing, Fiber.Runtime[E, Nothing]]
Forks the fiber in a Scope, interrupting it when the scope is closed.
-
final
def
forkWithErrorHandler[R1 <: Any](handler: (E) ⇒ URIO[R1, Any])(implicit trace: Trace): URIO[R1, Fiber.Runtime[E, Nothing]]
Like fork but handles an error with the provided handler.
Like fork but handles an error with the provided handler.
- Definition Classes
- ZIO
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
getOrElse[A1 >: Nothing](orElse: (Cause[E]) ⇒ A1): A1
Retrieves the
A
if succeeded, or else returns the specified defaultA
.Retrieves the
A
if succeeded, or else returns the specified defaultA
.- Definition Classes
- Exit
-
final
def
getOrThrow()(implicit ev: <:<[E, Throwable], unsafe: Unsafe): Nothing
- Definition Classes
- Exit
-
final
def
getOrThrowFiberFailure()(implicit unsafe: Unsafe): Nothing
- Definition Classes
- Exit
-
final
def
head[B](implicit ev: IsSubtypeOfOutput[Nothing, List[B]], trace: Trace): ZIO[Any, 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.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.- Definition Classes
- ZIO
-
final
def
ignore(implicit trace: Trace): URIO[Any, Unit]
Returns a new effect that ignores the success or failure of this effect.
Returns a new effect that ignores the success or failure of this effect.
- Definition Classes
- ZIO
-
final
def
ignoreLogged(implicit trace: Trace): URIO[Any, Unit]
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.
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.
- Definition Classes
- ZIO
-
final
def
interruptAllChildren(implicit trace: Trace): ZIO[Any, E, Nothing]
Returns a new effect that will not succeed with its value before first interrupting all child fibers forked by the effect.
Returns a new effect that will not succeed with its value before first interrupting all child fibers forked by the effect.
- Definition Classes
- ZIO
-
final
def
interruptStatus(flag: ⇒ InterruptStatus)(implicit trace: Trace): ZIO[Any, E, Nothing]
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.- Definition Classes
- ZIO
-
final
def
interruptible(implicit trace: Trace): ZIO[Any, E, Nothing]
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.
- Definition Classes
- ZIO
-
final
def
intoPromise[E1 >: E, A1 >: Nothing](p: ⇒ Promise[E1, A1])(implicit trace: Trace): URIO[Any, 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.
- Definition Classes
- ZIO
-
final
def
isFailure: Boolean
Determines if the result is a failure.
Determines if the result is a failure.
- Definition Classes
- Exit
-
final
def
isFailure(implicit trace: Trace): URIO[Any, Boolean]
Returns whether this effect is a failure.
Returns whether this effect is a failure.
- Definition Classes
- ZIO
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
isInterrupted: Boolean
Determines if the result is interrupted.
Determines if the result is interrupted.
- Definition Classes
- Exit
-
final
def
isInterruptedOnly: Boolean
- Definition Classes
- Exit
-
final
def
isSuccess: Boolean
Determines if the result is a success.
Determines if the result is a success.
- Definition Classes
- Exit
-
final
def
isSuccess(implicit trace: Trace): URIO[Any, Boolean]
Returns whether this effect is a success.
Returns whether this effect is a success.
- Definition Classes
- ZIO
-
final
def
left[B, C](implicit ev: IsSubtypeOfOutput[Nothing, Either[B, C]], trace: Trace): ZIO[Any, Either[E, C], B]
"Zooms in" on the value in the
Left
side of anEither
, moving the possibility that the value is aRight
to the error channel."Zooms in" on the value in the
Left
side of anEither
, moving the possibility that the value is aRight
to the error channel.- Definition Classes
- ZIO
-
final
def
leftWith[R1, E1, A1, B, B1, C, C1](f: (ZIO[Any, Either[E, C], B]) ⇒ ZIO[R1, Either[E1, C1], B1])(implicit ev: IsSubtypeOfOutput[Nothing, Either[B, C]], trace: Trace): ZIO[R1, E1, Either[B1, C1]]
Performs the specified operation while "zoomed in" on the
Left
case of anEither
.Performs the specified operation while "zoomed in" on the
Left
case of anEither
.- Definition Classes
- ZIO
-
final
def
logError(message: ⇒ String)(implicit trace: Trace): ZIO[Any, E, Nothing]
Logs the cause of failure of this workflow with the specified message.
Logs the cause of failure of this workflow with the specified message.
- Definition Classes
- ZIO
-
final
def
logError(implicit trace: Trace): ZIO[Any, E, Nothing]
Logs the cause of failure of this workflow.
Logs the cause of failure of this workflow.
- Definition Classes
- ZIO
-
def
logSpan(label: ⇒ String)(implicit trace: Trace): ZIO[Any, E, Nothing]
Adjusts the label for the current logging span.
Adjusts the label for the current logging span.
parseRequest(req).logSpan("parsing")
- Definition Classes
- ZIO
-
final
def
map[B](f: (Nothing) ⇒ B)(implicit trace: Trace): ZIO[Any, E, B]
Returns an effect whose success is mapped by the specified
f
function. -
final
def
mapAttempt[B](f: (Nothing) ⇒ B)(implicit ev: IsSubtypeOfError[E, Throwable], trace: Trace): RIO[Any, B]
Returns an effect whose success is mapped by the specified side effecting
f
function, translating any thrown exceptions into typed failed effects.Returns an effect whose success is mapped by the specified side effecting
f
function, translating any thrown exceptions into typed failed effects.- Definition Classes
- ZIO
-
final
def
mapBoth[E2, B](f: (E) ⇒ E2, g: (Nothing) ⇒ B)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E2, B]
Returns an effect whose failure and success channels have been mapped by the specified pair of functions,
f
andg
. -
final
def
mapBothExit[E1, A1](f: (E) ⇒ E1, g: (Nothing) ⇒ A1): Exit[E1, A1]
Maps over both the error and value type.
Maps over both the error and value type.
- Definition Classes
- Exit
-
final
def
mapError[E2](f: (E) ⇒ E2)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E2, Nothing]
Returns an effect with its error channel mapped using the specified function.
-
final
def
mapErrorCause[E2](h: (Cause[E]) ⇒ Cause[E2])(implicit trace: Trace): ZIO[Any, E2, Nothing]
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
.- Definition Classes
- Exit → ZIO
- See also
absorb, sandbox, catchAllCause - other functions for dealing with defects
-
final
def
mapErrorCauseExit[E1](f: (Cause[E]) ⇒ Cause[E1]): Exit[E1, Nothing]
Maps over the cause type.
Maps over the cause type.
- Definition Classes
- Exit
-
final
def
mapErrorExit[E1](f: (E) ⇒ E1): Exit[E1, Nothing]
Maps over the error type.
Maps over the error type.
- Definition Classes
- Exit
-
final
def
mapExit[A1](f: (Nothing) ⇒ A1): Exit[E, A1]
Maps over the value type.
Maps over the value type.
- Definition Classes
- Exit
-
final
def
memoize(implicit trace: Trace): UIO[ZIO[Any, E, Nothing]]
Returns an effect that, if evaluated, will return the lazily computed result of this effect.
Returns an effect that, if evaluated, will return the lazily computed result of this effect.
- Definition Classes
- ZIO
-
final
def
merge[A1 >: Nothing](implicit ev1: IsSubtypeOfError[E, A1], ev2: CanFail[E], trace: Trace): URIO[Any, A1]
Returns a new effect where the error channel has been merged into the success channel to their common combined type.
Returns a new effect where the error channel has been merged into the success channel to their common combined type.
- Definition Classes
- ZIO
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
negate(implicit ev: IsSubtypeOfOutput[Nothing, Boolean], trace: Trace): ZIO[Any, E, Boolean]
Returns a new effect where boolean value of this effect is negated.
Returns a new effect where boolean value of this effect is negated.
- Definition Classes
- ZIO
-
final
def
none[B](implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], trace: Trace): ZIO[Any, Option[E], Unit]
Requires the option produced by this value to be
None
.Requires the option produced by this value to be
None
.- Definition Classes
- ZIO
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
onDone[R1 <: Any](error: (E) ⇒ ZIO[R1, Nothing, Any], success: (Nothing) ⇒ ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R1, Nothing, Unit]
- Definition Classes
- ZIO
-
final
def
onDoneCause[R1 <: Any](error: (Cause[E]) ⇒ ZIO[R1, Nothing, Any], success: (Nothing) ⇒ ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R1, Nothing, Unit]
- Definition Classes
- ZIO
-
final
def
onError[R1 <: Any](cleanup: (Cause[E]) ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
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.
- Definition Classes
- ZIO
-
final
def
onExecutionContext(ec: ⇒ ExecutionContext)(implicit trace: Trace): ZIO[Any, E, Nothing]
Executes the effect on the specified
ExecutionContext
and then shifts back to the default one.Executes the effect on the specified
ExecutionContext
and then shifts back to the default one.- Definition Classes
- ZIO
-
final
def
onExecutor(executor: ⇒ Executor)(implicit trace: Trace): ZIO[Any, E, Nothing]
Returns an effect which is guaranteed to be executed on the specified executor.
Returns an effect which is guaranteed to be executed on the specified executor. The specified effect will always run on the specified executor, even in the presence of asynchronous boundaries.
This is useful when an effect must be executed somewhere, for example: on a UI thread, inside a client library's thread pool, inside a blocking thread pool, inside a low-latency thread pool, or elsewhere.
The
onExecutor
function composes with the innermostonExecutor
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.- Definition Classes
- ZIO
-
final
def
onExit[R1 <: Any](cleanup: (Exit[E, Nothing]) ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
Ensures that a cleanup functions runs, whether this effect succeeds, fails, or is interrupted.
Ensures that a cleanup functions runs, whether this effect succeeds, fails, or is interrupted.
- Definition Classes
- ZIO
-
final
def
onInterrupt[R1 <: Any](cleanup: (Set[FiberId]) ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
Calls the specified function, and runs the effect it returns, if this effect is interrupted.
Calls the specified function, and runs the effect it returns, if this effect is interrupted.
- Definition Classes
- ZIO
-
final
def
onInterrupt[R1 <: Any](cleanup: ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
Runs the specified effect if this effect is interrupted.
Runs the specified effect if this effect is interrupted.
- Definition Classes
- ZIO
-
final
def
onTermination[R1 <: Any](cleanup: (Cause[Nothing]) ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1, E, Nothing]
Runs the specified effect if this effect is terminated, either because of a defect or because of interruption.
Runs the specified effect if this effect is terminated, either because of a defect or because of interruption.
- Definition Classes
- ZIO
-
final
def
once(implicit trace: Trace): UIO[ZIO[Any, E, Unit]]
Returns an effect that will be executed at most once, even if it is evaluated multiple times.
Returns an effect that will be executed at most once, even if it is evaluated multiple times.
- Definition Classes
- ZIO
-
final
def
option(implicit ev: CanFail[E], trace: Trace): URIO[Any, Option[Nothing]]
Executes this effect, skipping the error but returning optionally the success.
Executes this effect, skipping the error but returning optionally the success.
- Definition Classes
- ZIO
-
final
def
orDie(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E], trace: Trace): URIO[Any, Nothing]
Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.
Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.
- Definition Classes
- ZIO
-
final
def
orDieWith(f: (E) ⇒ Throwable)(implicit ev: CanFail[E], trace: Trace): URIO[Any, Nothing]
Keeps none of the errors, and terminates the fiber with them, using the specified function to convert the
E
into aThrowable
.Keeps none of the errors, and terminates the fiber with them, using the specified function to convert the
E
into aThrowable
.- Definition Classes
- ZIO
-
final
def
orElse[R1 <: Any, E2, A1 >: Nothing](that: ⇒ ZIO[R1, E2, A1])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, A1]
Executes this effect and returns its value, if it succeeds, but otherwise executes the specified effect.
Executes this effect and returns its value, if it succeeds, but otherwise executes the specified effect.
- Definition Classes
- ZIO
-
final
def
orElseEither[R1 <: Any, E2, B](that: ⇒ ZIO[R1, E2, B])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E2, Either[Nothing, 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.
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.
- Definition Classes
- ZIO
-
final
def
orElseFail[E1](e1: ⇒ E1)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E1, Nothing]
Executes this effect and returns its value, if it succeeds, but otherwise fails with the specified error.
-
final
def
orElseFailExit[E1](e1: ⇒ E1): Exit[E1, Nothing]
Replaces the error value with the one provided.
Replaces the error value with the one provided.
- Definition Classes
- Exit
-
final
def
orElseOptional[R1 <: Any, E1, A1 >: Nothing](that: ⇒ ZIO[R1, Option[E1], A1])(implicit ev: IsSubtypeOfError[E, Option[E1]], trace: Trace): ZIO[R1, Option[E1], A1]
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.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.- Definition Classes
- ZIO
-
final
def
orElseSucceed[A1 >: Nothing](a1: ⇒ A1)(implicit ev: CanFail[E], trace: Trace): URIO[Any, A1]
Executes this effect and returns its value, if it succeeds, but otherwise succeeds with the specified value.
Executes this effect and returns its value, if it succeeds, but otherwise succeeds with the specified value.
- Definition Classes
- ZIO
-
final
def
parallelErrors[E1 >: E](implicit trace: Trace): ZIO[Any, ::[E1], Nothing]
Exposes all parallel errors in a single call
Exposes all parallel errors in a single call
- Definition Classes
- ZIO
-
final
def
parallelFinalizers(implicit trace: Trace): ZIO[Any, E, Nothing]
Returns a new scoped workflow that runs finalizers added to the scope of this workflow in parallel.
Returns a new scoped workflow that runs finalizers added to the scope of this workflow in parallel.
- Definition Classes
- ZIO
-
macro
def
provide[E1 >: E](layer: ZLayer[_, E1, _]*): ZIO[Any, E1, Nothing]
Automatically assembles a layer for the ZIO effect.
Automatically assembles a layer for the ZIO effect.
- Definition Classes
- ZIOVersionSpecific
-
final
def
provideEnvironment(r: ⇒ ZEnvironment[Any])(implicit trace: Trace): IO[E, Nothing]
Provides the
ZIO
effect with its required environment, which eliminates its dependency onR
.Provides the
ZIO
effect with its required environment, which eliminates its dependency onR
.- Definition Classes
- ZIO
-
final
def
provideLayer[E1 >: E, R0](layer: ⇒ ZLayer[R0, E1, Any])(implicit trace: Trace): ZIO[R0, E1, Nothing]
Provides a layer to the ZIO effect, which translates it to another level.
Provides a layer to the ZIO effect, which translates it to another level.
- Definition Classes
- ZIO
-
def
provideSome[R0]: ProvideSomeLayerPartiallyApplied[R0, Any, E, Nothing]
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)
- Definition Classes
- ZIOVersionSpecific
-
final
def
provideSomeEnvironment[R0](f: (ZEnvironment[R0]) ⇒ ZEnvironment[Any])(implicit trace: Trace): ZIO[R0, E, Nothing]
Transforms the environment being provided to this effect with the specified function.
Transforms the environment being provided to this effect with the specified function.
- Definition Classes
- ZIO
-
final
def
provideSomeLayer[R0]: ProvideSomeLayer[R0, Any, E, Nothing]
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)
- Definition Classes
- ZIO
-
final
def
race[R1 <: Any, E1 >: E, A1 >: Nothing](that: ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): 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.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
, performl.disconnect race r.disconnect
, which disconnects left and right interrupt signal, allowing a fast return, with interruption performed in the background.- Definition Classes
- ZIO
-
final
def
raceAll[R1 <: Any, E1 >: E, A1 >: Nothing](ios0: ⇒ Iterable[ZIO[R1, E1, A1]])(implicit trace: Trace): 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
- Definition Classes
- ZIO
-
final
def
raceEither[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, Either[Nothing, 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.
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
, performl.disconnect raceEither r.disconnect
, which disconnects left and right interrupt signal, allowing the earliest possible return.- Definition Classes
- ZIO
-
final
def
raceFirst[R1 <: Any, E1 >: E, A1 >: Nothing](that: ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): 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.
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
, performl.disconnect raceFirst r.disconnect
, which disconnects left and right interrupt signal, allowing a fast return, with interruption performed in the background.- Definition Classes
- ZIO
-
final
def
raceWith[R1 <: Any, E1, E2, B, C](that: ⇒ ZIO[R1, E1, B])(leftDone: (Exit[E, Nothing], Fiber[E1, B]) ⇒ ZIO[R1, E2, C], rightDone: (Exit[E1, B], Fiber[E, Nothing]) ⇒ ZIO[R1, E2, C])(implicit trace: Trace): 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.
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.
- Definition Classes
- ZIO
-
final
def
refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E], trace: Trace): ZIO[Any, E1, Nothing]
Keeps some of the errors, and terminates the fiber with the rest
Keeps some of the errors, and terminates the fiber with the rest
- Definition Classes
- ZIO
-
final
def
refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) ⇒ Throwable)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E1, Nothing]
Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the
E
into aThrowable
.Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the
E
into aThrowable
.- Definition Classes
- ZIO
-
final
def
reject[E1 >: E](pf: PartialFunction[Nothing, E1])(implicit trace: Trace): ZIO[Any, E1, Nothing]
Fail with the returned value if the
PartialFunction
matches, otherwise continue with our held value.Fail with the returned value if the
PartialFunction
matches, otherwise continue with our held value.- Definition Classes
- ZIO
-
final
def
rejectZIO[R1 <: Any, E1 >: E](pf: PartialFunction[Nothing, ZIO[R1, E1, E1]])(implicit trace: Trace): ZIO[R1, E1, Nothing]
Continue with the returned computation if the
PartialFunction
matches, translating the successful match into a failure, otherwise continue with our held value.Continue with the returned computation if the
PartialFunction
matches, translating the successful match into a failure, otherwise continue with our held value.- Definition Classes
- ZIO
-
final
def
repeat[R1 <: Any, B](schedule: ⇒ Schedule[R1, Nothing, B])(implicit trace: Trace): ZIO[R1, E, B]
Returns a new effect that repeats this effect according to the specified schedule or until the first failure.
Returns a new effect that repeats this effect according to the specified schedule or until the first failure. Scheduled recurrences are in addition to the first execution, so that
io.repeat(Schedule.once)
yields an effect that executesio
, and then if that succeeds, executesio
an additional time.- Definition Classes
- ZIO
-
final
def
repeatN(n: ⇒ Int)(implicit trace: Trace): ZIO[Any, E, Nothing]
Returns a new effect that repeats this effect the specified number of times or until the first failure.
Returns a new effect that repeats this effect the specified number of times or until the first failure. Repeats are in addition to the first execution, so that
io.repeatN(1)
yields an effect that executesio
, and then if that succeeds, executesio
an additional time.- Definition Classes
- ZIO
-
final
def
repeatOrElse[R1 <: Any, E2, B](schedule: ⇒ Schedule[R1, Nothing, B], orElse: (E, Option[B]) ⇒ ZIO[R1, E2, B])(implicit trace: Trace): ZIO[R1, E2, B]
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 executesio
, and then if that succeeds, executesio
an additional time.- Definition Classes
- ZIO
-
final
def
repeatOrElseEither[R1 <: Any, B, E2, C](schedule0: ⇒ Schedule[R1, Nothing, B], orElse: (E, Option[B]) ⇒ ZIO[R1, E2, C])(implicit trace: Trace): ZIO[R1, E2, Either[C, B]]
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 executesio
, and then if that succeeds, executesio
an additional time.- Definition Classes
- ZIO
-
final
def
repeatUntil(p: (Nothing) ⇒ Boolean)(implicit trace: Trace): ZIO[Any, E, Nothing]
Repeats this effect until its value satisfies the specified predicate or until the first failure.
Repeats this effect until its value satisfies the specified predicate or until the first failure.
- Definition Classes
- ZIO
-
final
def
repeatUntilEquals[A1 >: Nothing](a: ⇒ A1)(implicit trace: Trace): ZIO[Any, E, A1]
Repeats this effect until its value is equal to the specified value or until the first failure.
Repeats this effect until its value is equal to the specified value or until the first failure.
- Definition Classes
- ZIO
-
final
def
repeatUntilZIO[R1 <: Any](f: (Nothing) ⇒ URIO[R1, Boolean])(implicit trace: Trace): ZIO[R1, E, Nothing]
Repeats this effect until its value satisfies the specified effectful predicate or until the first failure.
Repeats this effect until its value satisfies the specified effectful predicate or until the first failure.
- Definition Classes
- ZIO
-
final
def
repeatWhile(p: (Nothing) ⇒ Boolean)(implicit trace: Trace): ZIO[Any, E, Nothing]
Repeats this effect while its value satisfies the specified predicate or until the first failure.
Repeats this effect while its value satisfies the specified predicate or until the first failure.
- Definition Classes
- ZIO
-
final
def
repeatWhileEquals[A1 >: Nothing](a: ⇒ A1)(implicit trace: Trace): ZIO[Any, E, A1]
Repeats this effect for as long as its value is equal to the specified value or until the first failure.
Repeats this effect for as long as its value is equal to the specified value or until the first failure.
- Definition Classes
- ZIO
-
final
def
repeatWhileZIO[R1 <: Any](f: (Nothing) ⇒ URIO[R1, Boolean])(implicit trace: Trace): ZIO[R1, E, Nothing]
Repeats this effect while its value satisfies the specified effectful predicate or until the first failure.
Repeats this effect while its value satisfies the specified effectful predicate or until the first failure.
- Definition Classes
- ZIO
-
final
def
replicateZIO(n: ⇒ Int)(implicit trace: Trace): ZIO[Any, E, Iterable[Nothing]]
Performs this effect the specified number of times and collects the results.
Performs this effect the specified number of times and collects the results.
- Definition Classes
- ZIO
-
final
def
replicateZIODiscard(n: ⇒ Int)(implicit trace: Trace): ZIO[Any, E, Unit]
Performs this effect the specified number of times, discarding the results.
Performs this effect the specified number of times, discarding the results.
- Definition Classes
- ZIO
-
final
def
resurrect(implicit ev1: IsSubtypeOfError[E, Throwable], trace: Trace): RIO[Any, Nothing]
Unearth the unchecked failure of the effect.
Unearth the unchecked failure of the effect. (opposite of
orDie
)val f0: Task[Unit] = ZIO.fail(new Exception("failing")).unit val f1: UIO[Unit] = f0.orDie val f2: Task[Unit] = f1.resurrect
- Definition Classes
- ZIO
-
final
def
retry[R1 <: Any, S](policy: ⇒ Schedule[R1, E, S])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E, Nothing]
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".- Definition Classes
- ZIO
-
final
def
retryN(n: ⇒ Int)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E, Nothing]
Retries this effect the specified number of times.
Retries this effect the specified number of times.
- Definition Classes
- ZIO
-
final
def
retryOrElse[R1 <: Any, A1 >: Nothing, S, E1](policy: ⇒ Schedule[R1, E, S], orElse: (E, S) ⇒ ZIO[R1, E1, A1])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, A1]
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.
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.
- Definition Classes
- ZIO
-
final
def
retryOrElseEither[R1 <: Any, Out, E1, B](schedule0: ⇒ Schedule[R1, E, Out], orElse: (E, Out) ⇒ ZIO[R1, E1, B])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Either[B, Nothing]]
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.
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.
- Definition Classes
- ZIO
-
final
def
retryUntil(f: (E) ⇒ Boolean)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E, Nothing]
Retries this effect until its error satisfies the specified predicate.
Retries this effect until its error satisfies the specified predicate.
- Definition Classes
- ZIO
-
final
def
retryUntilEquals[E1 >: E](e: ⇒ E1)(implicit ev: CanFail[E1], trace: Trace): ZIO[Any, E1, Nothing]
Retries this effect until its error is equal to the specified error.
Retries this effect until its error is equal to the specified error.
- Definition Classes
- ZIO
-
final
def
retryUntilZIO[R1 <: Any](f: (E) ⇒ URIO[R1, Boolean])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E, Nothing]
Retries this effect until its error satisfies the specified effectful predicate.
Retries this effect until its error satisfies the specified effectful predicate.
- Definition Classes
- ZIO
-
final
def
retryWhile(f: (E) ⇒ Boolean)(implicit ev: CanFail[E], trace: Trace): ZIO[Any, E, Nothing]
Retries this effect while its error satisfies the specified predicate.
Retries this effect while its error satisfies the specified predicate.
- Definition Classes
- ZIO
-
final
def
retryWhileEquals[E1 >: E](e: ⇒ E1)(implicit ev: CanFail[E1], trace: Trace): ZIO[Any, E1, Nothing]
Retries this effect for as long as its error is equal to the specified error.
Retries this effect for as long as its error is equal to the specified error.
- Definition Classes
- ZIO
-
final
def
retryWhileZIO[R1 <: Any](f: (E) ⇒ URIO[R1, Boolean])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E, Nothing]
Retries this effect while its error satisfies the specified effectful predicate.
Retries this effect while its error satisfies the specified effectful predicate.
- Definition Classes
- ZIO
-
final
def
right[B, C](implicit ev: IsSubtypeOfOutput[Nothing, Either[B, C]], trace: Trace): ZIO[Any, Either[B, E], C]
"Zooms in" on the value in the
Right
side of anEither
, moving the possibility that the value is aLeft
to the error channel."Zooms in" on the value in the
Right
side of anEither
, moving the possibility that the value is aLeft
to the error channel.- Definition Classes
- ZIO
-
final
def
rightWith[R1, E1, A1, B, B1, C, C1](f: (ZIO[Any, Either[B, E], C]) ⇒ ZIO[R1, Either[B1, E1], C1])(implicit ev: IsSubtypeOfOutput[Nothing, Either[B, C]], trace: Trace): ZIO[R1, E1, Either[B1, C1]]
Performs the specified operation while "zoomed in" on the
Right
case of anEither
.Performs the specified operation while "zoomed in" on the
Right
case of anEither
.- Definition Classes
- ZIO
-
final
def
sandbox(implicit trace: Trace): ZIO[Any, Cause[E], Nothing]
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) }
- Definition Classes
- ZIO
-
final
def
sandboxWith[R1 <: Any, E2, B](f: (ZIO[R1, Cause[E], Nothing]) ⇒ ZIO[R1, Cause[E2], B])(implicit trace: Trace): 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] = 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
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
- Definition Classes
- ZIO
-
final
def
schedule[R1 <: Any, B](schedule: ⇒ Schedule[R1, Any, B])(implicit trace: Trace): ZIO[R1, E, B]
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.
- Definition Classes
- ZIO
-
final
def
scheduleFork[R1 <: Any, B](schedule: ⇒ Schedule[R1, Any, B])(implicit trace: Trace): ZIO[R1 with Scope, Nothing, Fiber.Runtime[E, B]]
Runs this effect according to the specified schedule in a new fiber attached to the current scope.
Runs this effect according to the specified schedule in a new fiber attached to the current scope.
- Definition Classes
- ZIO
-
final
def
scheduleFrom[R1 <: Any, A1 >: Nothing, B](a: ⇒ A1)(schedule0: ⇒ Schedule[R1, A1, B])(implicit trace: Trace): ZIO[R1, E, B]
Runs this effect according to the specified schedule starting from the specified input value.
Runs this effect according to the specified schedule starting from the specified input value.
- Definition Classes
- ZIO
-
final
def
sequentialFinalizers(implicit trace: Trace): ZIO[Any, E, Nothing]
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.
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.
- Definition Classes
- ZIO
-
final
def
some[B](implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], trace: Trace): ZIO[Any, Option[E], B]
Converts an option on values into an option on errors.
Converts an option on values into an option on errors.
- Definition Classes
- ZIO
-
final
def
someOrElse[B](default: ⇒ B)(implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], trace: Trace): ZIO[Any, E, B]
Extracts the optional value, or returns the given 'default'.
Extracts the optional value, or returns the given 'default'.
- Definition Classes
- ZIO
-
final
def
someOrElseZIO[B, R1 <: Any, E1 >: E](default: ⇒ ZIO[R1, E1, B])(implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], trace: Trace): ZIO[R1, E1, B]
Extracts the optional value, or executes the effect 'default'.
Extracts the optional value, or executes the effect 'default'.
- Definition Classes
- ZIO
-
final
def
someOrFail[B, E1 >: E](e: ⇒ E1)(implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], trace: Trace): ZIO[Any, E1, B]
Extracts the optional value, or fails with the given error 'e'.
Extracts the optional value, or fails with the given error 'e'.
- Definition Classes
- ZIO
-
final
def
someOrFailException[B, E1 >: E](implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], ev2: <:<[NoSuchElementException, E1], trace: Trace): ZIO[Any, E1, B]
Extracts the optional value, or fails with a java.util.NoSuchElementException
Extracts the optional value, or fails with a java.util.NoSuchElementException
- Definition Classes
- ZIO
-
final
def
someWith[R1, E1, A1, B, B1](f: (ZIO[Any, Option[E], B]) ⇒ ZIO[R1, Option[E1], B1])(implicit ev: IsSubtypeOfOutput[Nothing, Option[B]], trace: Trace): ZIO[R1, E1, Option[B1]]
Perfoms the specified operation while "zoomed in" on the
Some
case of anOption
.Perfoms the specified operation while "zoomed in" on the
Some
case of anOption
.- Definition Classes
- ZIO
-
final
def
summarized[R1 <: Any, E1 >: E, B, C](summary0: ⇒ ZIO[R1, E1, B])(f: (B, B) ⇒ C)(implicit trace: Trace): ZIO[R1, E1, (C, Nothing)]
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.
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.
- Definition Classes
- ZIO
-
final
def
supervised(supervisor: ⇒ Supervisor[Any])(implicit trace: Trace): ZIO[Any, E, Nothing]
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 with the behavior of this one, but where all child fibers forked in the effect are reported to the specified supervisor.
- Definition Classes
- ZIO
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
final
def
tap[R1 <: Any, E1 >: E](f: (Nothing) ⇒ ZIO[R1, E1, Any])(implicit trace: Trace): ZIO[R1, E1, Nothing]
Returns an effect that effectfully "peeks" at the success of this effect.
Returns an effect that effectfully "peeks" at the success of this effect.
readFile("data.json").tap(printLine)
- Definition Classes
- ZIO
-
final
def
tapBoth[R1 <: Any, E1 >: E](f: (E) ⇒ ZIO[R1, E1, Any], g: (Nothing) ⇒ ZIO[R1, E1, Any])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Nothing]
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(_))
- Definition Classes
- ZIO
-
final
def
tapDefect[R1 <: Any, E1 >: E](f: (Cause[Nothing]) ⇒ ZIO[R1, E1, Any])(implicit trace: Trace): ZIO[R1, E1, Nothing]
Returns an effect that effectually "peeks" at the defect of this effect.
Returns an effect that effectually "peeks" at the defect of this effect.
- Definition Classes
- ZIO
-
final
def
tapEither[R1 <: Any, E1 >: E](f: (Either[E, Nothing]) ⇒ ZIO[R1, E1, Any])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Nothing]
Returns an effect that effectfully "peeks" at the result of this effect.
Returns an effect that effectfully "peeks" at the result of this effect.
readFile("data.json").tapEither(result => log(result.fold("Error: " + _, "Success: " + _)))
- Definition Classes
- ZIO
-
final
def
tapError[R1 <: Any, E1 >: E](f: (E) ⇒ ZIO[R1, E1, Any])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Nothing]
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(_))
- Definition Classes
- ZIO
-
final
def
tapErrorCause[R1 <: Any, E1 >: E](f: (Cause[E]) ⇒ ZIO[R1, E1, Any])(implicit trace: Trace): ZIO[R1, E1, Nothing]
Returns an effect that effectually "peeks" at the cause of the failure of this effect.
Returns an effect that effectually "peeks" at the cause of the failure of this effect.
readFile("data.json").tapErrorCause(logCause(_))
- Definition Classes
- ZIO
-
final
def
tapErrorTrace[R1 <: Any, E1 >: E](f: ((E, StackTrace)) ⇒ ZIO[R1, E1, Any])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Nothing]
A version of
tapError
that gives you the trace of the error.A version of
tapError
that gives you the trace of the error.- Definition Classes
- ZIO
-
final
def
tapSome[R1 <: Any, E1 >: E](f: PartialFunction[Nothing, ZIO[R1, E1, Any]])(implicit trace: Trace): ZIO[R1, E1, Nothing]
Returns an effect that effectfully "peeks" at the success of this effect.
Returns an effect that effectfully "peeks" at the success of this effect. If the partial function isn't defined at the input, the result is equivalent to the original effect.
readFile("data.json").tapSome { case content if content.nonEmpty => putStrLn(content) }
- Definition Classes
- ZIO
-
final
def
tapSomeError[R1 <: Any, E1 >: E](f: PartialFunction[E, ZIO[R1, E1, Any]])(implicit ev: CanFail[E], trace: Trace): ZIO[R1, E1, Nothing]
Returns an effect that effectfully "peeks" at the failure of this effect.
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.
- Definition Classes
- ZIO
-
final
def
timed(implicit trace: Trace): ZIO[Any, E, (zio.Duration, Nothing)]
Returns a new effect that executes this one and times the execution.
Returns a new effect that executes this one and times the execution.
- Definition Classes
- ZIO
-
final
def
timedWith[R1 <: Any, E1 >: E](nanoTime: ⇒ ZIO[R1, E1, Long])(implicit trace: Trace): ZIO[R1, E1, (zio.Duration, Nothing)]
A more powerful variation of
timed
that allows specifying the workflow that will be used to calculate the current time.A more powerful variation of
timed
that allows specifying the workflow that will be used to calculate the current time.- Definition Classes
- ZIO
-
final
def
timeout(d: ⇒ zio.Duration)(implicit trace: Trace): ZIO[Any, E, Option[Nothing]]
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.
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)
, useeffect.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.- Definition Classes
- ZIO
-
final
def
timeoutFail[E1 >: E](e: ⇒ E1)(d: ⇒ zio.Duration)(implicit trace: Trace): ZIO[Any, E1, Nothing]
The same as timeout, but instead of producing a
None
in the event of timeout, it will produce the specified error. -
final
def
timeoutFailCause[E1 >: E](cause: ⇒ Cause[E1])(d: ⇒ zio.Duration)(implicit trace: Trace): ZIO[Any, E1, Nothing]
The same as timeout, but instead of producing a
None
in the event of timeout, it will produce the specified failure. -
final
def
timeoutTo[B](b: ⇒ B): TimeoutTo[Any, E, Nothing, 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
ZIO.succeed(1).timeoutTo(None)(Some(_))(1.second)
- Definition Classes
- ZIO
-
final
def
toEither: Either[Throwable, Nothing]
Converts the
Exit
to anEither[Throwable, A]
, by wrapping the cause inFiberFailure
(if the result is failed).Converts the
Exit
to anEither[Throwable, A]
, by wrapping the cause inFiberFailure
(if the result is failed).- Definition Classes
- Exit
-
final
def
toFuture(implicit ev2: IsSubtypeOfError[E, Throwable], trace: Trace): URIO[Any, CancelableFuture[Nothing]]
Converts the effect into a scala.concurrent.Future.
Converts the effect into a scala.concurrent.Future.
- Definition Classes
- ZIO
-
final
def
toFutureWith(f: (E) ⇒ Throwable)(implicit trace: Trace): URIO[Any, CancelableFuture[Nothing]]
Converts the effect into a scala.concurrent.Future.
Converts the effect into a scala.concurrent.Future.
- Definition Classes
- ZIO
-
def
toPromiseJS(implicit ev: IsSubtypeOfError[E, Throwable], trace: Trace): URIO[Any, scala.scalajs.js.Promise[Nothing]]
Converts the current
ZIO
to a Scala.js promise.Converts the current
ZIO
to a Scala.js promise.- Definition Classes
- ZIOPlatformSpecific
-
def
toPromiseJSWith(f: (E) ⇒ Throwable)(implicit trace: Trace): URIO[Any, scala.scalajs.js.Promise[Nothing]]
Converts the current
ZIO
to a Scala.js promise and maps the error type withf
.Converts the current
ZIO
to a Scala.js promise and maps the error type withf
.- Definition Classes
- ZIOPlatformSpecific
-
final
def
toTry(implicit ev: <:<[E, Throwable]): Try[Nothing]
- Definition Classes
- Exit
- final def trace: Trace
-
final
def
uncause[E1 >: E](implicit ev: IsSubtypeOfOutput[Nothing, Cause[E1]], trace: Trace): ZIO[Any, E1, Unit]
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.
-
final
def
unexit[E1 >: E, A2](implicit ev: <:<[Nothing, Exit[E1, A2]], trace: Trace): ZIO[Any, E1, A2]
- Definition Classes
- ZIO
-
final
def
uninterruptible(implicit trace: Trace): ZIO[Any, E, Nothing]
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).
- Definition Classes
- ZIO
-
final
def
unit(implicit trace: Trace): ZIO[Any, E, Unit]
Returns the effect resulting from mapping the success of this effect to unit.
-
final
def
unitExit: Exit[E, Unit]
Discards the value.
Discards the value.
- Definition Classes
- Exit
-
final
def
unleft[E1, B](implicit ev: IsSubtypeOfError[E, Either[E1, B]], trace: Trace): ZIO[Any, E1, Either[Nothing, B]]
Converts a
ZIO[R, Either[E, B], A]
into aZIO[R, E, Either[A, B]]
.Converts a
ZIO[R, Either[E, B], A]
into aZIO[R, E, Either[A, B]]
. The inverse ofleft
.- Definition Classes
- ZIO
-
final
def
unless(p: ⇒ Boolean)(implicit trace: Trace): ZIO[Any, E, Option[Nothing]]
The moral equivalent of
if (!p) exp
The moral equivalent of
if (!p) exp
- Definition Classes
- ZIO
-
final
def
unlessZIO[R1 <: Any, E1 >: E](p: ⇒ ZIO[R1, E1, Boolean])(implicit trace: Trace): ZIO[R1, E1, Option[Nothing]]
The moral equivalent of
if (!p) exp
whenp
has side-effectsThe moral equivalent of
if (!p) exp
whenp
has side-effects- Definition Classes
- ZIO
-
final
def
unrefine[E1 >: E](pf: PartialFunction[Throwable, E1])(implicit trace: Trace): ZIO[Any, E1, Nothing]
Takes some fiber failures and converts them into errors.
Takes some fiber failures and converts them into errors.
- Definition Classes
- ZIO
-
final
def
unrefineTo[E1 >: E](implicit arg0: ClassTag[E1], trace: Trace): ZIO[Any, E1, Nothing]
Takes some fiber failures and converts them into errors.
Takes some fiber failures and converts them into errors.
- Definition Classes
- ZIO
-
final
def
unrefineWith[E1](pf: PartialFunction[Throwable, E1])(f: (E) ⇒ E1)(implicit trace: Trace): ZIO[Any, E1, Nothing]
Takes some fiber failures and converts them into errors, using the specified function to convert the
E
into anE1
.Takes some fiber failures and converts them into errors, using the specified function to convert the
E
into anE1
.- Definition Classes
- ZIO
-
final
def
unright[E1, B](implicit ev: IsSubtypeOfError[E, Either[B, E1]], trace: Trace): ZIO[Any, E1, Either[B, Nothing]]
Converts a
ZIO[R, Either[B, E], A]
into aZIO[R, E, Either[B, A]]
.Converts a
ZIO[R, Either[B, E], A]
into aZIO[R, E, Either[B, A]]
. The inverse ofright
.- Definition Classes
- ZIO
-
final
def
unsandbox[E1](implicit ev: IsSubtypeOfError[E, Cause[E1]], trace: Trace): ZIO[Any, E1, Nothing]
The inverse operation to
sandbox
.The inverse operation to
sandbox
. Submerges the full cause of failure.- Definition Classes
- ZIO
-
final
def
unsome[E1](implicit ev: IsSubtypeOfError[E, Option[E1]], trace: Trace): ZIO[Any, E1, Option[Nothing]]
Converts an option on errors into an option on values.
Converts an option on errors into an option on values.
- Definition Classes
- ZIO
-
final
def
untraced: Exit[E, Nothing]
Returns an untraced exit value.
Returns an untraced exit value.
- Definition Classes
- Exit
-
final
def
updateService[M]: UpdateService[Any, E, Nothing, M]
Updates a service in the environment of this effect.
Updates a service in the environment of this effect.
- Definition Classes
- ZIO
-
final
def
updateServiceAt[Service]: UpdateServiceAt[Any, E, Nothing, Service]
Updates a service at the specified key in the environment of this effect.
Updates a service at the specified key in the environment of this effect.
- Definition Classes
- ZIO
-
final
def
validate[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit zippable: Zippable[Nothing, B], trace: Trace): ZIO[R1, E1, Out]
Sequentially zips the this result with the specified result.
Sequentially zips the this result with the specified result. Combines both
Cause[E1]
when both effects fail.- Definition Classes
- ZIO
-
final
def
validatePar[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, (Nothing, B)]
Returns an effect that executes both this effect and the specified effect, in parallel.
Returns an effect that executes both this effect and the specified effect, in parallel. Combines both Cause[E1]
when both effects fail.
- Definition Classes
- ZIO
-
final
def
validateWith[R1 <: Any, E1 >: E, B, C](that: ⇒ ZIO[R1, E1, B])(f: (Nothing, B) ⇒ C)(implicit trace: Trace): ZIO[R1, E1, C]
Sequentially zips this effect with the specified effect using the specified combiner function.
Sequentially zips this effect with the specified effect using the specified combiner function. Combines the causes in case both effect fail.
- Definition Classes
- ZIO
-
final
def
validateWithPar[R1 <: Any, E1 >: E, B, C](that: ⇒ ZIO[R1, E1, B])(f: (Nothing, B) ⇒ C)(implicit trace: Trace): 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 both sides fail, then the cause will be combined.- Definition Classes
- ZIO
-
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
- @throws( ... ) @native()
-
final
def
when(p: ⇒ Boolean)(implicit trace: Trace): ZIO[Any, E, Option[Nothing]]
The moral equivalent of
if (p) exp
The moral equivalent of
if (p) exp
- Definition Classes
- ZIO
-
final
def
whenFiberRef[S](ref: ⇒ FiberRef[S])(f: (S) ⇒ Boolean)(implicit trace: Trace): ZIO[Any, E, (S, Option[Nothing])]
Executes this workflow when value of the specified
FiberRef
satisfies the predicate.Executes this workflow when value of the specified
FiberRef
satisfies the predicate.- Definition Classes
- ZIO
-
final
def
whenRef[S](ref: ⇒ Ref[S])(f: (S) ⇒ Boolean)(implicit trace: Trace): ZIO[Any, E, (S, Option[Nothing])]
Executes this workflow when the value of the
Ref
satisfies the predicate.Executes this workflow when the value of the
Ref
satisfies the predicate.- Definition Classes
- ZIO
-
final
def
whenZIO[R1 <: Any, E1 >: E](p: ⇒ ZIO[R1, E1, Boolean])(implicit trace: Trace): ZIO[R1, E1, Option[Nothing]]
The moral equivalent of
if (p) exp
whenp
has side-effectsThe moral equivalent of
if (p) exp
whenp
has side-effects- Definition Classes
- ZIO
-
final
def
withClock[B <: Clock](clock: ⇒ B)(implicit tag: Tag[B], trace: Trace): ZIO[Any, E, Nothing]
Executes this workflow with the specified implementation of the clock service.
Executes this workflow with the specified implementation of the clock service.
- Definition Classes
- ZIO
-
final
def
withConfigProvider[B <: ConfigProvider](configProvider: ⇒ B)(implicit tag: Tag[B], trace: Trace): ZIO[Any, E, Nothing]
Executes this workflow with the specified configuration provider.
Executes this workflow with the specified configuration provider.
- Definition Classes
- ZIO
-
final
def
withConsole[B <: Console](console: ⇒ B)(implicit tag: Tag[B], trace: Trace): ZIO[Any, E, Nothing]
Executes this workflow with the specified implementation of the console service.
Executes this workflow with the specified implementation of the console service.
- Definition Classes
- ZIO
-
final
def
withEarlyRelease(implicit trace: Trace): ZIO[Scope, E, (UIO[Unit], Nothing)]
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.
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.
- Definition Classes
- ZIO
-
final
def
withFinalizer[R1 <: Any](finalizer: (Nothing) ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1 with Scope, E, Nothing]
Treats this effect as the acquisition of a resource and adds the specified finalizer to the current scope.
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.
- Definition Classes
- ZIO
-
final
def
withFinalizerExit[R1 <: Any](finalizer: (Nothing, Exit[Any, Any]) ⇒ URIO[R1, Any])(implicit trace: Trace): ZIO[R1 with Scope, E, Nothing]
A more powerful variant of
withFinalizer
that allows the finalizer to depend on theExit
value that the scope is closed with.A more powerful variant of
withFinalizer
that allows the finalizer to depend on theExit
value that the scope is closed with.- Definition Classes
- ZIO
-
final
def
withLogger[B <: ZLogger[String, Any]](logger: ⇒ B)(implicit tag: Tag[B], trace: Trace): ZIO[Any, E, Nothing]
Executes this workflow with the specified logger added.
Executes this workflow with the specified logger added.
- Definition Classes
- ZIO
-
final
def
withParallelism(n: ⇒ Int)(implicit trace: Trace): ZIO[Any, E, Nothing]
Runs this effect with the specified maximum number of fibers for parallel operators.
Runs this effect with the specified maximum number of fibers for parallel operators.
- Definition Classes
- ZIO
-
def
withParallelismUnbounded(implicit trace: Trace): ZIO[Any, E, Nothing]
Runs this effect with an unbounded maximum number of fibers for parallel operators.
Runs this effect with an unbounded maximum number of fibers for parallel operators.
- Definition Classes
- ZIO
-
final
def
withRandom[B <: Random](random: ⇒ B)(implicit tag: Tag[B], trace: Trace): ZIO[Any, E, Nothing]
Executes this workflow with the specified implementation of the random service.
Executes this workflow with the specified implementation of the random service.
- Definition Classes
- ZIO
-
final
def
withRuntimeFlags(patch: Patch)(implicit trace: Trace): ZIO[Any, E, Nothing]
Returns a new ZIO effect that will update the runtime flags according to the specified patch within the scope of this ZIO effect.
Returns a new ZIO effect that will update the runtime flags according to the specified patch within the scope of this ZIO effect.
- Definition Classes
- ZIO
-
final
def
withSystem[B <: System](system: ⇒ B)(implicit tag: Tag[B], trace: Trace): ZIO[Any, E, Nothing]
Executes this workflow with the specified implementation of the system service.
Executes this workflow with the specified implementation of the system service.
- Definition Classes
- ZIO
-
final
def
zip[E1 >: E, B](that: Exit[E1, B])(implicit zippable: Zippable[Nothing, B]): Exit[E1, Out]
Named alias for
<*>
.Named alias for
<*>
.- Definition Classes
- Exit
-
final
def
zip[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit zippable: Zippable[Nothing, B], trace: Trace): ZIO[R1, E1, Out]
A named alias for
<*>
.A named alias for
<*>
.- Definition Classes
- ZIO
-
final
def
zipLeft[E1 >: E, B](that: Exit[E1, B]): Exit[E1, Nothing]
Named alias for
<*
.Named alias for
<*
.- Definition Classes
- Exit
-
final
def
zipLeft[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, Nothing]
A named alias for
<*
.A named alias for
<*
.- Definition Classes
- ZIO
-
final
def
zipPar[E1 >: E, B](that: Exit[E1, B])(implicit zippable: Zippable[Nothing, B]): Exit[E1, Out]
Named alias for
<&>
.Named alias for
<&>
.- Definition Classes
- Exit
-
final
def
zipPar[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit zippable: Zippable[Nothing, B], trace: Trace): ZIO[R1, E1, Out]
A named alias for
<&>
.A named alias for
<&>
.- Definition Classes
- ZIO
-
final
def
zipParLeft[E1 >: E, B](that: Exit[E1, B]): Exit[E1, Nothing]
Named alias for
<&
.Named alias for
<&
.- Definition Classes
- Exit
-
final
def
zipParLeft[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, Nothing]
A named alias for
<&
.A named alias for
<&
.- Definition Classes
- ZIO
-
final
def
zipParRight[E1 >: E, B](that: Exit[E1, B]): Exit[E1, B]
Named alias for
&>
.Named alias for
&>
.- Definition Classes
- Exit
-
final
def
zipParRight[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, B]
A named alias for
&>
.A named alias for
&>
.- Definition Classes
- ZIO
-
final
def
zipRight[E1 >: E, B](that: Exit[E1, B]): Exit[E1, B]
Named alias for
*>
.Named alias for
*>
.- Definition Classes
- Exit
-
final
def
zipRight[R1 <: Any, E1 >: E, B](that: ⇒ ZIO[R1, E1, B])(implicit trace: Trace): ZIO[R1, E1, B]
A named alias for
*>
.A named alias for
*>
.- Definition Classes
- ZIO
-
final
def
zipWith[E1 >: E, B, C](that: Exit[E1, B])(f: (Nothing, B) ⇒ C, g: (Cause[E], Cause[E1]) ⇒ Cause[E1]): Exit[E1, C]
Zips this together with the specified result using the combination functions.
Zips this together with the specified result using the combination functions.
- Definition Classes
- Exit
-
final
def
zipWith[R1 <: Any, E1 >: E, B, C](that: ⇒ ZIO[R1, E1, B])(f: (Nothing, B) ⇒ C)(implicit trace: Trace): ZIO[R1, E1, C]
Sequentially zips this effect with the specified effect using the specified combiner function.
Sequentially zips this effect with the specified effect using the specified combiner function.
- Definition Classes
- ZIO
-
final
def
zipWithPar[R1 <: Any, E1 >: E, B, C](that: ⇒ ZIO[R1, E1, B])(f: (Nothing, B) ⇒ C)(implicit trace: Trace): 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.- Definition Classes
- ZIO
Deprecated Value Members
-
final
def
raceAwait[R1 <: Any, E1 >: E, A1 >: Nothing](that: ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): ZIO[R1, E1, A1]
- Definition Classes
- ZIO
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.7) use race
-
final
def
raceFirstAwait[R1 <: Any, E1 >: E, A1 >: Nothing](that: ⇒ ZIO[R1, E1, A1])(implicit trace: Trace): ZIO[R1, E1, A1]
- Definition Classes
- ZIO
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.7) use raceFirst
-
final
def
unary_![R1 <: Any, E1 >: E](implicit ev: <:<[Nothing, Boolean], trace: Trace): ZIO[R1, E1, Boolean]
Returns the logical negation of the
Boolean
value returned by this effect.Returns the logical negation of the
Boolean
value returned by this effect.- Definition Classes
- ZIO
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.6) use negate