ZIO
Related Docs:
trait ZIO
| package zio
A ZIOConstructor[Input] knows how to construct a ZIO value from an
input of type Input.
A ZIOConstructor[Input] knows how to construct a ZIO value from an
input of type Input. This allows the type of the ZIO value constructed
to depend on Input. The constructed ZIO value is guaranteed not to
require any services not included in Environment or to be able to fail in
any ways not described by Error.
The level of parallelism for parallel operators.
Submerges the error case of an Either into the ZIO.
Submerges the error case of an Either into the ZIO. The inverse
operation of IO.either.
Constructs a scoped resource from an acquire and release effect.
Constructs a scoped resource from an acquire and release effect. If
acquire successfully completes execution then release will be added to
the finalizers associated with the scope of this effect and is guaranteed
to be run when the scope is closed.
The acquire and release effects will be run uninterruptibly.
A more powerful variant of acquireRelease that allows the release
effect to depend on the Exit value specified when the scope is closed.
Acquires a resource, uses the resource, and then releases the resource.
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.
A variant of acquireRelease that allows the acquire effect to be
interruptible.
A variant of acquireRelease that allows the acquire effect to be
interruptible. Since the acquire effect could be interrupted after
partially acquiring resources, the release effect is not allowed to
access the resource produced by acquire and must independently determine
what finalization, if any, needs to be performed (e.g. by examining in
memory state).
A more powerful variant of acquireReleaseInterruptible that allows the
release effect to depend on the Exit value specified when the scope is
closed.
Given an effect representing acquisition of a resource (for example,
opening a file, launching a thread, etc.), acquireReleaseWith can be used
to ensure the acquisition is not interrupted and the resource is always
released.
Given an effect representing acquisition of a resource (for example,
opening a file, launching a thread, etc.), acquireReleaseWith can be used
to ensure the acquisition is not interrupted and the resource is always
released.
The function does two things:
acquire effect will not be interrupted. Of course,
acquisition may fail for internal reasons (an uncaught exception).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.
ZIO.acquireReleaseWith(openFile("data.json"))(closeFile) { file => for { header <- readHeader(file) ... } yield result }
Adds a finalizer to the scope of this effect.
Adds a finalizer to the scope of this effect. The finalizer is guaranteed to be run when the scope is closed.
A more powerful variant of addFinalizer that allows the finalizer to
depend on the Exit value that the scope is closed with.
Makes an explicit check to see if the fiber has been interrupted, and if so, performs self-interruption
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
This method allows you to specify the fiber id that is responsible for
invoking callbacks provided to the register function. This is called the
"blocking fiber", because it is stopping the fiber executing the async
effect from making progress (although it is not "blocking" a thread).
Specifying this fiber id in cases where it is known will improve
diagnostics, but not affect the behavior of the returned effect.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
With this variant, you can specify either a way to cancel the asynchrounous action, or you can return the result right away if no asynchronous operation is required.
This method allows you to specify the fiber id that is responsible for
invoking callbacks provided to the register function. This is called the
"blocking fiber", because it is stopping the fiber executing the async
effect from making progress (although it is not "blocking" a thread).
Specifying this fiber id in cases where it is known will improve
diagnostics, but not affect the behavior of the returned effect.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
With this variant, the registration function may return the result right away, if it turns out that no asynchronous operation is required to complete the operation.
This method allows you to specify the fiber id that is responsible for
invoking callbacks provided to the register function. This is called the
"blocking fiber", because it is stopping the fiber executing the async
effect from making progress (although it is not "blocking" a thread).
Specifying this fiber id in cases where it is known will improve
diagnostics, but not affect the behavior of the returned effect.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.
With this variant, the registration function may return a ZIO effect.
Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.
Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.
This method should be used whenever you want to take arbitrary code, which may throw exceptions or not be type safe, and convert it into a ZIO effect, which can safely execute that code whenever the effect is executed.
def printLine(line: String): Task[Unit] = ZIO.attempt(println(line))
Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.
Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.
This method should be used whenever you want to take arbitrary code, which may throw exceptions or not be type safe, and convert it into a ZIO effect, which can safely execute that code whenever the effect is executed.
This variant expects that the provided code will engage in blocking I/O, and therefore, pro-actively executes the code on a dedicated blocking thread pool, so it won't interfere with the main thread pool that ZIO uses.
Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.
Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.
This method should be used whenever you want to take arbitrary code, which may throw exceptions or not be type safe, and convert it into a ZIO effect, which can safely execute that code whenever the effect is executed.
This variant expects that the provided code will engage in blocking I/O, and therefore, pro-actively executes the code on a dedicated blocking thread pool, so it won't interfere with the main thread pool that ZIO uses.
Additionally, this variant allows you to specify an effect that will cancel the blocking operation. This effect will be executed if the fiber that is executing the blocking effect is interrupted for any reason.
This function is the same as attempt, except that it only exposes
IOException, treating any other exception as fatal.
This function is the same as attempt, except that it only exposes
IOException, treating any other exception as fatal.
Imports a synchronous effect that does blocking IO into a pure value.
Imports a synchronous effect that does blocking IO into a pure value.
If the returned ZIO is interrupted, the blocked thread running the
synchronous effect will be interrupted via Thread.interrupt.
Note that this adds significant overhead. For performance sensitive
applications consider using attemptBlocking or
attemptBlockingCancelable.
Returns a new effect that, when executed, will execute the original effect on the blocking thread pool.
Retrieves the executor for all blocking tasks.
Checks the interrupt status, and produces the effect returned by the specified callback.
Retrieves the Clock service for this workflow.
Retrieves the Clock service for this workflow and uses it to run the
specified workflow.
Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.
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.
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.
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 each effect in the structure from left to right, and collect the results.
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.
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.
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 discard the results.
Evaluate each effect in the structure from left to right, and discard the
results. For a parallel version, see collectAllParDiscard.
Evaluate each effect in the structure in parallel, and collect the results.
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.
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.
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.
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 discard the results.
Evaluate each effect in the structure in parallel, and discard the results.
For a sequential version, see collectAllDiscard.
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 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.
Collects the first element of the Iterable[A] for which the effectual
function f returns Some.
Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.
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 in parallel, collecting the the successful values and discarding the empty cases.
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.ifZIO
Uses the default config provider to load the specified config, or fail with an error of type Config.Error.
Retrieves the default config provider, and passes it to the specified function, which may return an effect that uses the provider to perform some work or compute some value.
Retrieves the Console service for this workflow.
Retrieves the Console service for this workflow and uses it to run the
specified workflow.
Prints the specified message to the console for debugging purposes.
Returns 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.
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.
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 from a zio.Exit value.
Accesses the whole environment of the effect.
Accesses the environment of the effect.
Effectually accesses the environment of the effect.
Retrieves the executor for this effect.
Constructs an effect based on the current executor.
Determines whether any element of the Iterable[A] satisfies the effectual
predicate f.
Returns an effect that models failure with the specified error.
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 Cause.
Returns the FiberId of the fiber executing the effect that calls this
method.
Constructs an effect based on the FiberId of the fiber executing the
effect that calls this method.
Filters the Set[A] using the specified effectual predicate.
Filters the collection using the specified effectual predicate.
Filters the Set[A] 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] in parallel using the specified effectual predicate, removing all elements that satisfy the predicate.
Filters the Set[A] in parallel using the specified effectual predicate, removing all elements that satisfy the predicate.
See zio.ZIO.filterNot[R,E,A](as:Set* for a sequential version.
Filters the collection in parallel using the specified effectual predicate, emoving all elements that satisfy the predicate.
Filters the collection in parallel using the specified effectual predicate, emoving all elements that satisfy the predicate.
See zio.ZIO.filterNot[R,E,A,Collection* for a sequential version.
Filters the Set[A] in parallel using the specified effectual predicate.
Filters the Set[A] in parallel using the specified effectual predicate.
See zio.ZIO.filter[R,E,A,Collection* for a sequential version.
Filters the collection in parallel using the specified effectual predicate.
Filters the collection in parallel using the specified effectual predicate.
See zio.ZIO.filter[R,E,A,Collection* for a sequential version.
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.
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.
Determines whether all elements of the Iterable[A] satisfy the effectual
predicate f.
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 foreachDiscard 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 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 foreachDiscard 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 foreachDiscard 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 foreachDiscard for a more efficient implementation.
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 foreachDiscard for a more efficient implementation.
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.
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 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 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 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 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 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 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 foreachDiscard.
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.
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.
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.
Constructs a ZIO value of the appropriate type for the specified input.
Lifts an Either into a ZIO value.
Lifts an Either into a ZIO value.
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.
Returns an effect that, when executed, will both create and launch a scala.concurrent.Future, feeding it an scala.concurrent.ExecutionContext that is backed by ZIO's own executor.
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.
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.js promise into a ZIO.
Imports a Scala.js promise into a ZIO.
Imports a scala.concurrent.Promise we generate a future from promise, and we pass to [fromFuture] to transform into Task[A]
Lifts a Try into a ZIO.
Returns a collection of all FiberRef values for the fiber running this
effect.
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 ZIO.
Lifts an Option into a ZIO. If the option is not defined, fail with the e
value.
Gets a state from the environment.
Gets a state from the environment and uses it to run the specified function.
Runs onTrue if the result of b is true and onFalse otherwise.
Like never, but fibers that running this effect won't be garbage collected unless interrupted.
Inherits values from all FiberRef instances into current fiber.
Returns an effect that is interrupted as if by the fiber calling this method.
Returns an effect that is interrupted as if by the specified fiber.
Prefix form of ZIO#interruptible.
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.
Retrieves the definition of a fatal error.
Constructs an effect based on the definition of a fatal error.
Iterates with the specified effectual function.
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.
Logs the specified message at the current log level.
Annotates each log in this effect with the specified log annotation.
Annotates each log in this effect with the specified log annotation.
Annotates each log in this effect with the specified log annotation.
Retrieves the log annotations associated with the current scope.
Logs the specified message and cause at the current log level.
Logs the specified cause at the current log level.
Logs the specified message at the debug log level.
Logs the specified cause at the debug log level..
Logs the specified cause at the debug log level.
Logs the specified message at the error log level.
Logs the specified cause as an error.
Logs the specified cause as an error.
Logs the specified message at the fatal log level.
Logs the specified cause at the fatal log level.
Logs the specified cause at the fatal log level.
Logs the specified message at the informational log level.
Logs the specified cause at the informational log level..
Logs the specified cause at the informational log level.
Sets the log level for this effect.
Sets the log level for this effect.
ZIO.logLevel(LogLevel.Warning) {
ZIO.log("The response time exceeded its threshold!")
}
Adjusts the label for the current logging span.
Adjusts the label for the current logging span.
ZIO.logSpan("parsing") { parseRequest(req) }
Logs the specified message at the trace log level.
Logs the specified cause at the trace log level..
Logs the specified cause at the trace log level.
Logs the specified message at the warning log level.
Logs the specified cause at the warning log level..
Logs the specified cause at the warning log level.
Retrieves the current loggers for this effect.
Constructs an effect based on the current loggers.
Loops with the specified effectual function, collecting the results into a list.
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.
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) }
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 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:
f(a, b) == f(b, a)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.
Returns a effect that will never produce anything.
Returns a effect that will never produce anything. The moral equivalent of
while(true) {}, only without the wasted CPU cycles. Fibers that execute
this effect will be automatically garbage collected on the JVM when no
explicit references to them are held, because they cannot be reactivated.
Returns an effect that succeeds with the None value.
Lifts an Option into a ZIO.
Lifts an Option into a ZIO. If the option is empty it succeeds with Unit. If the option is defined it fails with the content.
Lifts an Option into a ZIO.
Lifts an Option into a ZIO. 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 an effect that will execute the specified effect fully on the provided executor, before potentially returning to the previous executor.
Returns an effect that will execute the specified effect fully on the provided executor, before potentially returning to the previous executor. See ZIO!.onExecutor.
Returns a new scoped workflow that runs finalizers added to the scope of this workflow in parallel.
Retrieves the maximum number of fibers for parallel operators or None if
it is unbounded.
Retrieves the current maximum number of fibers for parallel operators and uses it to run the specified effect.
Feeds elements of type A to a function f that returns an effect.
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.
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.
Applies the specified changes to the FiberRef values for the fiber
running this workflow.
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.
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.
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.
Retrieves the Random service for this workflow and uses it to run the
specified workflow.
Reduces an Iterable[IO] to a single IO, working sequentially.
Reduces an Iterable[IO] to a single IO, working in parallel.
Replicates the given effect n times.
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, discarding the results.
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.
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.
Retrieves an effect that succeeds with the current runtime flags, which govern behavior and features of the runtime system.
Returns the current scope.
Accesses the current scope and uses it to perform the specified effect.
Scopes all resources used in this effect to the lifetime of the effect, ensuring that their finalizers are run as soon as this effect completes execution, whether by success, failure, or interruption.
Scopes all resources used in this effect to the lifetime of the effect, ensuring that their finalizers are run as soon as this effect completes execution, whether by success, failure, or interruption.
ZIO.scoped {
openFile(name).flatMap(useFile)
}
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.
Accesses the specified service in the environment of the effect.
Accesses the service corresponding to the specified key in the environment.
Accesses the specified service in the environment of the effect.
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))
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.serviceWithZIO[Foo](_.foo(int))
Sets the FiberRef values for the fiber running this effect to the values
in the specified collection of FiberRef values.
Sets a state in the environment to the specified value.
Returns an effect that shifts execution to the specified executor.
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!.onExecutor and ZIO!.onExecutionContext.
Returns an effect that suspends for the specified duration.
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 with the optional value.
Capture ZIO stack trace at the current point.
Provides a stateful ZIO workflow with its initial state, resulting in a workflow that is ready to be run.
Provides a stateful ZIO workflow with its initial state, resulting in a workflow that is ready to be run.
ZIO.stateful(0) { for { _ <- ZIO.updateState[Int](_ + 1) state <- ZIO.getState[Int] } yield assertTrue(state == 1) }
Returns an effect that models success with the specified value.
Returns an effect that models success with the specified value.
Returns a synchronous effect that does blocking and succeeds with the specified value.
Returns a synchronous effect that does blocking and succeeds with the specified value.
Returns a lazily constructed effect, whose construction may itself require effects.
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.
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(succeed(zio)). If you wonder if the effect throws exceptions, do
not use this method, use ZIO.suspend.
Retrieves the System service for this workflow.
Retrieves the System service for this workflow and uses it to run the
specified workflow.
Tags each metric in this effect with the specific tag.
Tags each metric in this effect with the specific tag.
Tags each metric in this effect with the specific tag.
Retrieves the metric tags associated with the current scope.
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.
Prefix form of ZIO#uninterruptible.
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.
An effect that succeeds with a unit value.
The moral equivalent of if (!p) exp
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]
Returns an effect indicating that execution is no longer required to be performed on the current executor.
Returns an effect indicating that execution is no longer required to be performed on the current executor. The runtime may continue executing on this executor for efficiency but will not automatically shift back to it after completing an effect on another executor.
Updates the FiberRef values for the fiber running this effect using the
specified function.
Updates the runtime flags.
Updates the runtime flags. This may have a performance impact. For a
higher-performance variant, see ZIO#withRuntimeFlags.
Updates a state in the environment with the specified function.
Scopes all resources acquired by resource to the lifetime of use
without effecting the scope of any resources acquired by use.
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 and accumulates all errors, discarding
the successes.
Feeds elements of type A to f until it succeeds.
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.
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.
The moral equivalent of if (p) exp
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.
The moral equivalent of if (p) exp when p has side-effects
A low-level while-loop with direct support in the ZIO runtime.
A low-level while-loop with direct support in the ZIO runtime. The only reason to use this constructor is performance.
See ZIO.iterate for a user-friendly version of this operator that is compatible with purely functional code.
Locally installs a supervisor and an effect that succeeds with all the children that have been forked in the returned effect.
Executes the specified workflow with the specified implementation of the clock service.
Sets the implementation of the clock service to the specified value and restores it to its original value when the scope is closed.
Executes the specified workflow with the specified configuration provider.
Sets the configuration provider to the specified value and restores it to its original value when the scope is closed.
Executes the specified workflow with the specified implementation of the console service.
Sets the implementation of the console service to the specified value and restores it to its original value when the scope is closed.
Runs the specified effect with the specified maximum number of fibers for parallel operators.
Runs the specified effect with an unbounded maximum number of fibers for parallel operators.
Executes the specified workflow with the specified implementation of the random service.
Sets the implementation of the random service to the specified value and restores it to its original value when the scope is closed.
Executes the specified workflow with the specified implementation of the system service.
Sets the implementation of the system service to the specified value and restores it to its original value when the scope is closed.
Returns an effect that yields to the runtime system, starting on a fresh stack.
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.