- Companion:
- class
Type members
Classlikes
- Companion:
- object
Value members
Concrete methods
Submerges the error case of an Either
into the ZIO
. The inverse
operation of IO.either
.
Submerges the error case of an Either
into the ZIO
. The inverse
operation of IO.either
.
Accesses the environment of the effect.
Accesses the environment of the effect.
val portNumber = effect.access(_.config.portNumber)
Effectfully accesses the environment of the effect.
Effectfully accesses the environment of the effect.
Makes an explicit check to see if the fiber has been interrupted, and if so, performs self-interruption
Makes an explicit check to see if the fiber has been interrupted, and if so, performs self-interruption
When this effect represents acquisition of a resource (for example, opening
a file, launching a thread, etc.), bracket
can be used to ensure the
acquisition is not interrupted and the resource is always released.
When this effect represents acquisition of a resource (for example, opening
a file, launching a thread, etc.), bracket
can be used to ensure the
acquisition is not interrupted and the resource is always released.
The function does two things:
- Ensures this effect, which acquires the resource, will not be
interrupted. Of course, acquisition may fail for internal reasons (an
uncaught exception). 2. Ensures the
release
effect will not be interrupted, and will be executed so long as this effect successfully acquires the resource.
In between acquisition and release of the resource, the use
effect is
executed.
If the release
effect fails, then the entire effect will fail even if the
use
effect succeeds. If this fail-fast behavior is not desired, errors
produced by the release
effect can be caught and ignored.
openFile("data.json").bracket(closeFile) { file =>
for {
header <- readHeader(file)
...
} yield result
}
Uncurried version. Doesn't offer curried syntax and have worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketAcquire and zio.ZIO.BracketRelease objects.
Uncurried version. Doesn't offer curried syntax and have worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketAcquire and zio.ZIO.BracketRelease objects.
Acquires a resource, uses the resource, and then releases the resource.
Neither the acquisition nor the release will be interrupted, and the
resource is guaranteed to be released, so long as the acquire
effect
succeeds. If use
fails, then after release, the returned effect will fail
with the same error.
Acquires a resource, uses the resource, and then releases the resource.
Neither the acquisition nor the release will be interrupted, and the
resource is guaranteed to be released, so long as the acquire
effect
succeeds. If use
fails, then after release, the returned effect will fail
with the same error.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketExitAcquire and zio.ZIO.BracketExitRelease objects.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketExitAcquire and zio.ZIO.BracketExitRelease objects.
Checks the interrupt status, and produces the effect returned by the specified callback.
Checks the interrupt status, and produces the effect returned by the specified callback.
Checks the ZIO Tracing status, and produces the effect returned by the specified callback.
Checks the ZIO Tracing status, and produces the effect returned by the specified callback.
Evaluate each effect in the structure from left to right, collecting the
the successful values and discarding the empty cases. For a parallel
version, see collectPar
.
Evaluate each effect in the structure from left to right, collecting the
the successful values and discarding the empty cases. For a parallel
version, see collectPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate effect if present, and return its result as Option[A]
.
Evaluate effect if present, and return its result as Option[A]
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure from left to right, and collect the
results. For a parallel version, see collectAllPar
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Evaluate each effect in the structure in parallel, and collect the results.
For a sequential version, see collectAll
.
Unlike collectAllPar
, this method will use at most n
fibers.
Evaluate each effect in the structure in parallel, and discard the results.
For a sequential version, see collectAll_
.
Evaluate each effect in the structure in parallel, and discard the results.
For a sequential version, see collectAll_
.
Unlike collectAllPar_
, this method will use at most n
fibers.
Evaluate each effect in the structure in parallel, and discard the results.
For a sequential version, see collectAll_
.
Evaluate each effect in the structure in parallel, and discard the results.
For a sequential version, see collectAll_
.
Evaluate and run each effect in the structure and collect discarding failed ones.
Evaluate and run each effect in the structure and collect discarding failed ones.
Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
Unlike collectAllSuccessesPar
, this method will use at most up to n
fibers.
Evaluate each effect in the structure with collectAll
, and collect the
results with given partial function.
Evaluate each effect in the structure with collectAll
, and collect the
results with given partial function.
Evaluate each effect in the structure with collectAllPar
, and collect the
results with given partial function.
Evaluate each effect in the structure with collectAllPar
, and collect the
results with given partial function.
Evaluate each effect in the structure with collectAllPar
, and collect the
results with given partial function.
Evaluate each effect in the structure with collectAllPar
, and collect the
results with given partial function.
Unlike collectAllWithPar
, this method will use at most up to n
fibers.
Evaluate each effect in the structure from left to right, and discard the
results. For a parallel version, see collectAllPar_
.
Evaluate each effect in the structure from left to right, and discard the
results. For a parallel version, see collectAllPar_
.
Collects the first element of the Iterable[A]
for which the effectual
function f
returns Some
.
Collects the first element of the Iterable[A]
for which the effectual
function f
returns Some
.
Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.
Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.
Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.
Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.
Unlike collectPar
, this method will use at most up to n
fibers.
Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise
Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise
For effectful conditionals, see ZIO.ifM
Prints the specified message to the console for debugging purposes.
Prints the specified message to the console for debugging purposes.
Returns information about the current fiber, such as its identity.
Returns information about the current fiber, such as its identity.
Constructs an effect based on information about the current fiber, such as its identity.
Constructs an effect based on information about the current fiber, such as its identity.
Returns an effect that dies with the specified Throwable
. This method can
be used for terminating a fiber because a defect has been detected in the
code.
Returns an effect that dies with the specified Throwable
. This method can
be used for terminating a fiber because a defect has been detected in the
code.
Returns an effect that dies with a java.lang.RuntimeException having the specified text message. This method can be used for terminating a fiber because a defect has been detected in the code.
Returns an effect that dies with a java.lang.RuntimeException having the specified text message. This method can be used for terminating a fiber because a defect has been detected in the code.
Imports a synchronous side-effect into a pure ZIO
value, translating any
thrown exceptions into typed failed effects creating with ZIO.fail
.
Imports a synchronous side-effect into a pure ZIO
value, translating any
thrown exceptions into typed failed effects creating with ZIO.fail
.
def putStrLn(line: String): Task[Unit] = Task.effect(println(line))
Imports an asynchronous side-effect into a pure ZIO
value. See
effectAsyncMaybe
for the more expressive variant of this function that
can return a value synchronously.
Imports an asynchronous side-effect into a pure ZIO
value. See
effectAsyncMaybe
for the more expressive variant of this function that
can return a value synchronously.
The callback function ZIO[R, E, A] => Any
must be called at most once.
The list of fibers, that may complete the async callback, is used to provide better diagnostics.
Imports an asynchronous side-effect into a ZIO effect. The side-effect has the option of returning the value synchronously, which is useful in cases where it cannot be determined if the effect is synchronous or asynchronous until the side-effect is actually executed. The effect also has the option of returning a canceler, which will be used by the runtime to cancel the asynchronous effect if the fiber executing the effect is interrupted.
Imports an asynchronous side-effect into a ZIO effect. The side-effect has the option of returning the value synchronously, which is useful in cases where it cannot be determined if the effect is synchronous or asynchronous until the side-effect is actually executed. The effect also has the option of returning a canceler, which will be used by the runtime to cancel the asynchronous effect if the fiber executing the effect is interrupted.
If the register function returns a value synchronously, then the callback
function ZIO[R, E, A] => Any
must not be called. Otherwise the callback
function must be called at most once.
The list of fibers, that may complete the async callback, is used to provide better diagnostics.
Imports an asynchronous effect into a pure ZIO
value. This formulation is
necessary when the effect is itself expressed in terms of ZIO
.
Imports an asynchronous effect into a pure ZIO
value. This formulation is
necessary when the effect is itself expressed in terms of ZIO
.
Imports an asynchronous effect into a pure ZIO
value, possibly returning
the value synchronously.
Imports an asynchronous effect into a pure ZIO
value, possibly returning
the value synchronously.
If the register function returns a value synchronously, then the callback
function ZIO[R, E, A] => Any
must not be called. Otherwise the callback
function must be called at most once.
The list of fibers, that may complete the async callback, is used to provide better diagnostics.
Returns a lazily constructed effect, whose construction may itself require
effects. When no environment is required (i.e., when R == Any) it is
conceptually equivalent to flatten(effect(io))
.
Returns a lazily constructed effect, whose construction may itself require
effects. When no environment is required (i.e., when R == Any) it is
conceptually equivalent to flatten(effect(io))
.
Returns a lazily constructed effect, whose construction may itself require
effects. The effect must not throw any exceptions. When no environment is
required (i.e., when R == Any) it is conceptually equivalent to
flatten(effectTotal(zio))
. If you wonder if the effect throws exceptions,
do not use this method, use Task.effectSuspend or
ZIO.effectSuspend.
Returns a lazily constructed effect, whose construction may itself require
effects. The effect must not throw any exceptions. When no environment is
required (i.e., when R == Any) it is conceptually equivalent to
flatten(effectTotal(zio))
. If you wonder if the effect throws exceptions,
do not use this method, use Task.effectSuspend or
ZIO.effectSuspend.
Returns a lazily constructed effect, whose construction may itself require
effects. The effect must not throw any exceptions. When no environment is
required (i.e., when R == Any) it is conceptually equivalent to
flatten(effectTotal(zio))
. If you wonder if the effect throws exceptions,
do not use this method, use Task.effectSuspend or
ZIO.effectSuspend.
Returns a lazily constructed effect, whose construction may itself require
effects. The effect must not throw any exceptions. When no environment is
required (i.e., when R == Any) it is conceptually equivalent to
flatten(effectTotal(zio))
. If you wonder if the effect throws exceptions,
do not use this method, use Task.effectSuspend or
ZIO.effectSuspend.
Returns a lazily constructed effect, whose construction may itself require
effects. When no environment is required (i.e., when R == Any) it is
conceptually equivalent to flatten(effect(io))
.
Returns a lazily constructed effect, whose construction may itself require
effects. When no environment is required (i.e., when R == Any) it is
conceptually equivalent to flatten(effect(io))
.
Imports a total synchronous effect into a pure ZIO
value. The effect must
not throw any exceptions. If you wonder if the effect throws exceptions,
then do not use this method, use Task.effect, IO.effect, or
ZIO.effect.
Imports a total synchronous effect into a pure ZIO
value. The effect must
not throw any exceptions. If you wonder if the effect throws exceptions,
then do not use this method, use Task.effect, IO.effect, or
ZIO.effect.
val nanoTime: UIO[Long] = IO.effectTotal(System.nanoTime())
Determines whether any element of the Iterable[A]
satisfies the effectual
predicate f
.
Determines whether any element of the Iterable[A]
satisfies the effectual
predicate f
.
Returns an effect that models failure with the specified error. The moral
equivalent of throw
for pure code.
Returns an effect that models failure with the specified error. The moral
equivalent of throw
for pure code.
Filters the collection using the specified effectual predicate.
Filters the collection using the specified effectual predicate.
Filters the Set[A] using the specified effectual predicate.
Filters the Set[A] using the specified effectual predicate.
Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.
Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.
Filters the Set[A] using the specified effectual predicate, removing all elements that satisfy the predicate.
Filters the Set[A] using the specified effectual predicate, removing all elements that satisfy the predicate.
Filters the collection in parallel using the specified effectual predicate, removing all elements that satisfy the predicate. See [[filterNot[R,E,A,Collection*]] for a sequential version of it.
Filters the collection in parallel using the specified effectual predicate, removing all elements that satisfy the predicate. See [[filterNot[R,E,A,Collection*]] for a sequential version of it.
Filters the Set[A] in parallel using the specified effectual predicate, removing all elements that satisfy the predicate. See filterNot for a sequential version of it.
Filters the Set[A] in parallel using the specified effectual predicate, removing all elements that satisfy the predicate. See filterNot for a sequential version of it.
Filters the collection in parallel using the specified effectual predicate. See [[filter[R,E,A,Collection*]] for a sequential version of it.
Filters the collection in parallel using the specified effectual predicate. See [[filter[R,E,A,Collection*]] for a sequential version of it.
Filters the Set[A] in parallel using the specified effectual predicate. See [[filter[R,E,A,Collection*]] for a sequential version of it.
Filters the Set[A] in parallel using the specified effectual predicate. See [[filter[R,E,A,Collection*]] for a sequential version of it.
Returns an effectful function that extracts out the first element of a tuple.
Returns an effectful function that extracts out the first element of a tuple.
Returns an effect that runs the first effect and in case of failure, runs each of the specified effects in order until one of them succeeds.
Returns an effect that runs the first effect and in case of failure, runs each of the specified effects in order until one of them succeeds.
Returns an effect that first executes the outer effect, and then executes the inner effect, returning the value from the inner effect, and effectively flattening a nested effect.
Returns an effect that first executes the outer effect, and then executes the inner effect, returning the value from the inner effect, and effectively flattening a nested effect.
Folds an Iterable[A] using an effectual function f, working sequentially from left to right.
Folds an Iterable[A] using an effectual function f, working sequentially from left to right.
Folds an Iterable[A] using an effectual function f, working sequentially from right to left.
Folds an Iterable[A] using an effectual function f, working sequentially from right to left.
Determines whether all elements of the Iterable[A]
satisfy the effectual
predicate f
.
Determines whether all elements of the Iterable[A]
satisfy the effectual
predicate f
.
Applies the function f
to each element of the Collection[A]
and returns
the results in a new Collection[B]
.
Applies the function f
to each element of the Collection[A]
and returns
the results in a new Collection[B]
.
For a parallel version of this method, see foreachPar
. If you do not need
the results, see foreach_
for a more efficient implementation.
Applies the function f
to each element of the Set[A]
and returns the
results in a new Set[B]
.
Applies the function f
to each element of the Set[A]
and returns the
results in a new Set[B]
.
For a parallel version of this method, see foreachPar
. If you do not need
the results, see foreach_
for a more efficient implementation.
Applies the function f
to each element of the Array[A]
and returns the
results in a new Array[B]
.
Applies the function f
to each element of the Array[A]
and returns the
results in a new Array[B]
.
For a parallel version of this method, see foreachPar
. If you do not need
the results, see foreach_
for a more efficient implementation.
Applies the function f
to each element of the Map[Key, Value]
and
returns the results in a new Map[Key2, Value2]
.
Applies the function f
to each element of the Map[Key, Value]
and
returns the results in a new Map[Key2, Value2]
.
For a parallel version of this method, see foreachPar
. If you do not need
the results, see foreach_
for a more efficient implementation.
Applies the function f
if the argument is non-empty and returns the
results in a new Option[B]
.
Applies the function f
if the argument is non-empty and returns the
results in a new Option[B]
.
Applies the function f
to each element of the NonEmptyChunk[A]
and
returns the results in a new NonEmptyChunk[B]
.
Applies the function f
to each element of the NonEmptyChunk[A]
and
returns the results in a new NonEmptyChunk[B]
.
For a parallel version of this method, see foreachPar
. If you do not need
the results, see foreach_
for a more efficient implementation.
Applies the function f
to each element of the Collection[A]
and returns
the result in a new Collection[B]
using the specified execution strategy.
Applies the function f
to each element of the Collection[A]
and returns
the result in a new Collection[B]
using the specified execution strategy.
Applies the function f
to each element of the Collection[A]
in
parallel, and returns the results in a new Collection[B]
.
Applies the function f
to each element of the Collection[A]
in
parallel, and returns the results in a new Collection[B]
.
For a sequential version of this method, see foreach
.
Applies the function f
to each element of the Set[A]
in parallel, and
returns the results in a new Set[B]
.
Applies the function f
to each element of the Set[A]
in parallel, and
returns the results in a new Set[B]
.
For a sequential version of this method, see foreach
.
Applies the function f
to each element of the Array[A]
in parallel, and
returns the results in a new Array[B]
.
Applies the function f
to each element of the Array[A]
in parallel, and
returns the results in a new Array[B]
.
For a sequential version of this method, see foreach
.
Applies the function f
to each element of the Map[Key, Value]
in
parallel and returns the results in a new Map[Key2, Value2]
.
Applies the function f
to each element of the Map[Key, Value]
in
parallel and returns the results in a new Map[Key2, Value2]
.
For a sequential version of this method, see foreach
.
Applies the function f
to each element of the NonEmptyChunk[A]
in
parallel, and returns the results in a new NonEmptyChunk[B]
.
Applies the function f
to each element of the NonEmptyChunk[A]
in
parallel, and returns the results in a new NonEmptyChunk[B]
.
For a sequential version of this method, see foreach
.
Applies the function f
to each element of the Collection[A]
in
parallel, and returns the results in a new Collection[B]
.
Applies the function f
to each element of the Collection[A]
in
parallel, and returns the results in a new Collection[B]
.
Unlike foreachPar
, this method will use at most up to n
fibers.
Applies the function f
to each element of the Iterable[A]
and runs
produced effects in parallel, discarding the results.
Applies the function f
to each element of the Iterable[A]
and runs
produced effects in parallel, discarding the results.
Unlike foreachPar_
, this method will use at most up to n
fibers.
Applies the function f
to each element of the Iterable[A]
and runs
produced effects in parallel, discarding the results.
Applies the function f
to each element of the Iterable[A]
and runs
produced effects in parallel, discarding the results.
For a sequential version of this method, see foreach_
.
Optimized to avoid keeping full tree of effects, so that method could be able to handle large input sequences. Behaves almost like this code:
as.foldLeft(ZIO.unit) { (acc, a) => acc.zipParLeft(f(a)) }
Additionally, interrupts all effects on any failure.
Applies the function f
to each element of the Iterable[A]
and runs
produced effects sequentially.
Applies the function f
to each element of the Iterable[A]
and runs
produced effects sequentially.
Equivalent to foreach(as)(f).unit
, but without the cost of building the
list of results.
Returns an effect that forks all of the specified values, and returns a composite fiber that produces a list of their results, in order.
Returns an effect that forks all of the specified values, and returns a composite fiber that produces a list of their results, in order.
Returns an effect that forks all of the specified values, and returns a composite fiber that produces unit. This version is faster than forkAll in cases where the results of the forked fibers are not needed.
Returns an effect that forks all of the specified values, and returns a composite fiber that produces unit. This version is faster than forkAll in cases where the results of the forked fibers are not needed.
Retrieves the scope that will be used to supervise forked effects.
Retrieves the scope that will be used to supervise forked effects.
Captures the fork scope, before overriding it with the specified new scope, passing a function that allows restoring the fork scope to what it was originally.
Captures the fork scope, before overriding it with the specified new scope, passing a function that allows restoring the fork scope to what it was originally.
Retrieves the scope that will be used to supervise forked effects.
Retrieves the scope that will be used to supervise forked effects.
Creates a ZIO
value that represents the exit value of the specified
fiber.
Creates a ZIO
value that represents the exit value of the specified
fiber.
Creates a ZIO
value that represents the exit value of the specified
fiber.
Creates a ZIO
value that represents the exit value of the specified
fiber.
Lifts a function returning Future into an effect that requires the input to the function.
Lifts a function returning Future into an effect that requires the input to the function.
Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.
Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.
Imports a function that creates a scala.concurrent.Future from an
scala.concurrent.ExecutionContext into a ZIO
.
Imports a function that creates a scala.concurrent.Future from an
scala.concurrent.ExecutionContext into a ZIO
.
Imports a function that creates a scala.concurrent.Future from an
scala.concurrent.ExecutionContext into a ZIO
. The provided
ExecutionContext
will interrupt the Future
between asynchronous
operations such as map
and flatMap
if this effect is interrupted. Note
that no attempt will be made to interrupt a Future
blocking on a
synchronous operation and that the Future
must be created using the
provided ExecutionContext
.
Imports a function that creates a scala.concurrent.Future from an
scala.concurrent.ExecutionContext into a ZIO
. The provided
ExecutionContext
will interrupt the Future
between asynchronous
operations such as map
and flatMap
if this effect is interrupted. Note
that no attempt will be made to interrupt a Future
blocking on a
synchronous operation and that the Future
must be created using the
provided ExecutionContext
.
Lifts an Option
into a ZIO
but preserves the error as an option in the
error channel, making it easier to compose in some scenarios.
Lifts an Option
into a ZIO
but preserves the error as an option in the
error channel, making it easier to compose in some scenarios.
Imports a scala.concurrent.Promise we generate a future from promise, and we pass to [fromFuture] to transform into Task[A]
Imports a scala.concurrent.Promise we generate a future from promise, and we pass to [fromFuture] to transform into Task[A]
Lifts an Option into a ZIO, if the option is not defined it fails with NoSuchElementException.
Lifts an Option into a ZIO, if the option is not defined it fails with NoSuchElementException.
Lifts an Option into a IO, if the option is not defined it fails with Unit.
Lifts an Option into a IO, if the option is not defined it fails with Unit.
Lifts an Option into a ZIO. If the option is not defined, fail with the e
value.
Lifts an Option into a ZIO. If the option is not defined, fail with the e
value.
Returns an effect that models failure with the specified Cause
.
Returns an effect that models failure with the specified Cause
.
Returns an effect that models failure with the specified Cause
.
Returns an effect that models failure with the specified Cause
.
This version takes in a lazily-evaluated trace that can be attached to the
Cause
via Cause.Traced
.
Returns the identity effectful function, which performs no effects
Returns the identity effectful function, which performs no effects
Runs onTrue
if the result of b
is true
and onFalse
otherwise.
Runs onTrue
if the result of b
is true
and onFalse
otherwise.
Returns an effect that is interrupted as if by the specified fiber.
Returns an effect that is interrupted as if by the specified fiber.
Makes the effect interruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
Makes the effect interruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
Iterates with the specified effectual function. The moral equivalent of:
Iterates with the specified effectual function. The moral equivalent of:
var s = initial
while (cont(s)) {
s = body(s)
}
s
Returns an effect with the value on the left part.
Returns an effect with the value on the left part.
Loops with the specified effectual function, collecting the results into a list. The moral equivalent of:
Loops with the specified effectual function, collecting the results into a list. The moral equivalent of:
var s = initial
var as = List.empty[A]
while (cont(s)) {
as = body(s) :: as
s = inc(s)
}
as.reverse
Loops with the specified effectual function purely for its effects. The moral equivalent of:
Loops with the specified effectual function purely for its effects. The moral equivalent of:
var s = initial
while (cont(s)) {
body(s)
s = inc(s)
}
Sequentially zips the specified effects using the specified combiner function.
Sequentially zips the specified effects using the specified combiner function.
Sequentially zips the specified effects using the specified combiner function.
Sequentially zips the specified effects using the specified combiner function.
Sequentially zips the specified effects using the specified combiner function.
Sequentially zips the specified effects using the specified combiner function.
Returns an effect that executes the specified effects in parallel,
combining their results with the specified f
function. If any effect
fails, then the other effects will be interrupted.
Returns an effect that executes the specified effects in parallel,
combining their results with the specified f
function. If any effect
fails, then the other effects will be interrupted.
Returns an effect that executes the specified effects in parallel,
combining their results with the specified f
function. If any effect
fails, then the other effects will be interrupted.
Returns an effect that executes the specified effects in parallel,
combining their results with the specified f
function. If any effect
fails, then the other effects will be interrupted.
Returns an effect that executes the specified effects in parallel,
combining their results with the specified f
function. If any effect
fails, then the other effects will be interrupted.
Returns an effect that executes the specified effects in parallel,
combining their results with the specified f
function. If any effect
fails, then the other effects will be interrupted.
Returns a memoized version of the specified effectual function.
Returns a memoized version of the specified effectual function.
Merges an Iterable[IO]
to a single IO, working sequentially.
Merges an Iterable[IO]
to a single IO, working sequentially.
Merges an Iterable[IO]
to a single IO, working in parallel.
Merges an Iterable[IO]
to a single IO, working in parallel.
Due to the parallel nature of this combinator, f
must be both:
- commutative:
f(a, b) == f(b, a)
- associative:
f(a, f(b, c)) == f(f(a, b), c)
It's unsafe to execute side effects inside f
, as f
may be executed more
than once for some of in
elements during effect execution.
Merges an Iterable[IO]
to a single IO, working in with up to n
fibers
in parallel.
Merges an Iterable[IO]
to a single IO, working in with up to n
fibers
in parallel.
Due to the parallel nature of this combinator, f
must be both:
- commutative:
f(a, b) == f(b, a)
- associative:
f(a, f(b, c)) == f(f(a, b), c)
It's unsafe to execute side effects inside f
, as f
may be executed more
than once for some of in
elements during effect execution.
Lifts an Option into a IO. If the option is empty it succeeds with Unit. If the option is defined it fails with the content.
Lifts an Option into a IO. If the option is empty it succeeds with Unit. If the option is defined it fails with the content.
Lifts an Option into a IO. If the option is empty it succeeds with Unit. If the option is defined it fails with an error adapted with f.
Lifts an Option into a IO. If the option is empty it succeeds with Unit. If the option is defined it fails with an error adapted with f.
Returns a new effect where boolean value of this effect is negated.
Returns a new effect where boolean value of this effect is negated.
Feeds elements of type A
to a function f
that returns an effect.
Collects all successes and failures in a tupled fashion.
Feeds elements of type A
to a function f
that returns an effect.
Collects all successes and failures in a tupled fashion.
Feeds elements of type A
to a function f
that returns an effect.
Collects all successes and failures in parallel and returns the result as a
tuple.
Feeds elements of type A
to a function f
that returns an effect.
Collects all successes and failures in parallel and returns the result as a
tuple.
Feeds elements of type A
to a function f
that returns an effect.
Collects all successes and failures in parallel and returns the result as a
tuple.
Feeds elements of type A
to a function f
that returns an effect.
Collects all successes and failures in parallel and returns the result as a
tuple.
Unlike partitionPar, this method will use at most up to n
fibers.
Given an environment R
, returns a function that can supply the
environment to programs that require it, removing their need for any
specific environment.
Given an environment R
, returns a function that can supply the
environment to programs that require it, removing their need for any
specific environment.
This is similar to dependency injection, and the provide
function can be
thought of as inject
.
Races an IO[E, A]
against zero or more other effects. Yields either the
first success or the last failure.
Races an IO[E, A]
against zero or more other effects. Yields either the
first success or the last failure.
Returns an effect that races this effect with all the specified effects, yielding the first result to complete, whether by success or failure. If neither effect completes, then the composed effect will not complete.
Returns an effect that races this effect with all the specified effects, 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 "losers", but will not
resume until the losers have been cleanly terminated. If early return is
desired, then instead of performing ZIO.raceFirst(l, rs)
, perform
ZIO.raceFirst(l.disconnect, rs.map(_.disconnect))
, which disconnects left
and rights interrupt signal, allowing a fast return, with interruption
performed in the background.
Reduces an Iterable[IO]
to a single IO
, working sequentially.
Reduces an Iterable[IO]
to a single IO
, working sequentially.
Reduces an Iterable[IO]
to a single IO
, working in parallel.
Reduces an Iterable[IO]
to a single IO
, working in parallel.
Reduces an Iterable[IO]
to a single IO
, working in up to n
fibers in
parallel.
Reduces an Iterable[IO]
to a single IO
, working in up to n
fibers in
parallel.
Replicates the given effect n
times. If 0 or negative numbers are given,
an empty Iterable
will be returned. This method is more efficient than
using List.fill
or similar methods, because the returned Iterable
consumes only a small amount of heap regardless of n
.
Replicates the given effect n
times. If 0 or negative numbers are given,
an empty Iterable
will be returned. This method is more efficient than
using List.fill
or similar methods, because the returned Iterable
consumes only a small amount of heap regardless of n
.
Performs this effect the specified number of times and collects the results.
Performs this effect the specified number of times and collects the results.
Performs this effect the specified number of times, discarding the results.
Performs this effect the specified number of times, discarding the results.
Requires that the given ZIO[R, E, Option[A]]
contain a value. If there is
no value, then the specified error will be raised.
Requires that the given ZIO[R, E, Option[A]]
contain a value. If there is
no value, then the specified error will be raised.
Acquires a resource, uses the resource, and then releases the resource.
However, unlike bracket
, the separation of these phases allows the
acquisition to be interruptible.
Acquires a resource, uses the resource, and then releases the resource.
However, unlike bracket
, the separation of these phases allows the
acquisition to be interruptible.
Useful for concurrent data structures and other cases where the 'deallocator' can tell if the allocation succeeded or not just by inspecting internal / external state.
Returns an effect with the value on the right part.
Returns an effect with the value on the right part.
Returns an effect that accesses the runtime, which can be used to (unsafely) execute tasks. This is useful for integration with legacy code that must call back into ZIO code.
Returns an effect that accesses the runtime, which can be used to (unsafely) execute tasks. This is useful for integration with legacy code that must call back into ZIO code.
Passes the fiber's scope to the specified function, which creates an effect that will be returned from this method.
Passes the fiber's scope to the specified function, which creates an effect that will be returned from this method.
Returns an effectful function that extracts out the second element of a tuple.
Returns an effectful function that extracts out the second element of a tuple.
Accesses the specified service in the environment of the effect.
Accesses the specified service in the environment of the effect.
Effectfully accesses the specified service in the environment of the effect.
Effectfully accesses the specified service in the environment of the effect.
Especially useful for creating "accessor" methods on Services' companion objects.
def foo(int: Int) = ZIO.serviceWith[Foo](_.foo(int))
Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.
Accesses the specified services in the environment of the effect.
Returns an effect that shifts execution to the specified executor. This is useful to specify a default executor that effects sequenced after this one will be run on if they are not shifted somewhere else. It can also be used to implement higher level operators to manage where an effect is run such as ZIO!.lock and ZIO!.on.
Returns an effect that shifts execution to the specified executor. This is useful to specify a default executor that effects sequenced after this one will be run on if they are not shifted somewhere else. It can also be used to implement higher level operators to manage where an effect is run such as ZIO!.lock and ZIO!.on.
Returns an effect that suspends for the specified duration. This method is asynchronous, and does not actually block the fiber executing the effect.
Returns an effect that suspends for the specified duration. This method is asynchronous, and does not actually block the fiber executing the effect.
Returns an effect that models success with the specified value.
Returns an effect that models success with the specified value.
Returns an effectful function that merely swaps the elements in a Tuple2
.
Returns an effectful function that merely swaps the elements in a Tuple2
.
Transplants specified effects so that when those effects fork other effects, the forked effects will be governed by the scope of the fiber that executes this effect.
Transplants specified effects so that when those effects fork other effects, the forked effects will be governed by the scope of the fiber that executes this effect.
This can be used to "graft" deep grandchildren onto a higher-level scope, effectively extending their lifespans into the parent scope.
Sequentially zips the specified effects. Specialized version of mapN.
Sequentially zips the specified effects. Specialized version of mapN.
Sequentially zips the specified effects. Specialized version of mapN.
Sequentially zips the specified effects. Specialized version of mapN.
Sequentially zips the specified effects. Specialized version of mapN.
Sequentially zips the specified effects. Specialized version of mapN.
Zips the specified effects in parallel. Specialized version of mapParN.
Zips the specified effects in parallel. Specialized version of mapParN.
Zips the specified effects in parallel. Specialized version of mapParN.
Zips the specified effects in parallel. Specialized version of mapParN.
Zips the specified effects in parallel. Specialized version of mapParN.
Zips the specified effects in parallel. Specialized version of mapParN.
Makes the effect uninterruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
Makes the effect uninterruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
The moral equivalent of if (!p) exp
when p
has side-effects
The moral equivalent of if (!p) exp
when p
has side-effects
The inverse operation IO.sandboxed
The inverse operation IO.sandboxed
Terminates with exceptions on the Left
side of the Either
error, if it
exists. Otherwise extracts the contained IO[E, A]
Feeds elements of type A
to f
and accumulates all errors in error
channel or successes in success channel.
Feeds elements of type A
to f
and accumulates all errors in error
channel or successes in success channel.
This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partition.
Feeds elements of type A
to f
and accumulates all errors in error
channel or successes in success channel.
Feeds elements of type A
to f
and accumulates all errors in error
channel or successes in success channel.
This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partition.
Feeds elements of type A
to f
until it succeeds. Returns first success
or the accumulation of all errors.
Feeds elements of type A
to f
until it succeeds. Returns first success
or the accumulation of all errors.
Feeds elements of type A
to f
, in parallel, until it succeeds. Returns
first success or the accumulation of all errors.
Feeds elements of type A
to f
, in parallel, until it succeeds. Returns
first success or the accumulation of all errors.
In case of success all other running fibers are terminated.
Feeds elements of type A
to f
and accumulates, in parallel, all errors
in error channel or successes in success channel.
Feeds elements of type A
to f
and accumulates, in parallel, all errors
in error channel or successes in success channel.
This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partitionPar.
Feeds elements of type A
to f
and accumulates, in parallel, all errors
in error channel or successes in success channel.
Feeds elements of type A
to f
and accumulates, in parallel, all errors
in error channel or successes in success channel.
This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partitionPar.
Feeds elements of type A
to f
in parallel and accumulates all errors,
discarding the successes.
Feeds elements of type A
to f
in parallel and accumulates all errors,
discarding the successes.
Feeds elements of type A
to f
and accumulates all errors, discarding
the successes.
Feeds elements of type A
to f
and accumulates all errors, discarding
the successes.
Runs an effect when the supplied PartialFunction
matches for the given
value, otherwise does nothing.
Runs an effect when the supplied PartialFunction
matches for the given
value, otherwise does nothing.
Runs an effect when the supplied PartialFunction
matches for the given
effectful value, otherwise does nothing.
Runs an effect when the supplied PartialFunction
matches for the given
effectful value, otherwise does nothing.
The moral equivalent of if (p) exp
when p
has side-effects
The moral equivalent of if (p) exp
when p
has side-effects
Inherited methods
Concrete fields
Returns the Fiber.Id
of the fiber executing the effect that calls this
method.
Returns the Fiber.Id
of the fiber executing the effect that calls this
method.
Returns an effect that is interrupted as if by the fiber calling this method.
Returns an effect that is interrupted as if by the fiber calling this method.
Returns a effect that will never produce anything. The moral equivalent of
while(true) {}
, only without the wasted CPU cycles. Fibers that suspended
running this effect are automatically garbage collected on the JVM, because
they cannot be reactivated.
Returns a effect that will never produce anything. The moral equivalent of
while(true) {}
, only without the wasted CPU cycles. Fibers that suspended
running this effect are automatically garbage collected on the JVM, because
they cannot be reactivated.
Returns an effect that yields to the runtime system, starting on a fresh stack. Manual use of this method can improve fairness, at the cost of overhead.
Returns an effect that yields to the runtime system, starting on a fresh stack. Manual use of this method can improve fairness, at the cost of overhead.