Submerges the error case of an Either into the ZManaged. The inverse operation of ZManaged.either.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource but handles Exit. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not require access to the resource. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire and release actions will be performed uninterruptibly.

Creates new ZManaged from a ZIO value that uses a ReleaseMap and returns a resource and a finalizer.

The correct usage of this constructor consists of:

• Properly registering a finalizer in the ReleaseMap as part of the ZIO value;
• Managing interruption safety - take care to use ZIO.uninterruptible or ZIO.uninterruptibleMask to verify that the finalizer is registered in the ReleaseMap after acquiring the value;
• Returning the finalizer returned from ReleaseMap#add. This is important to prevent double-finalization.

Returns a managed effect that describes shifting to the blocking executor as the acquire action and shifting back to the original executor as the release action.

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 discard the results. For a parallel version, see collectAllParDiscard.

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. For a sequential version, see collectAllDiscard.

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 models failure with the specified error. The moral equivalent of throw for pure code.

Creates an effect that executes a finalizer stored in a Ref. The Ref is yielded as the result of the effect, allowing for control flows that require mutating finalizers.

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.

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.

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.

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] 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.

For a sequential version of this method, see foreachDiscard.

Creates a ZManaged from an AutoCloseable resource. The resource's close method will be used as the release action.

Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A]. The acquisition step is performed interruptibly.

Creates a ZManaged from a Reservation produced by an effect. Evaluating the effect that produces the reservation will be performed *uninterruptibly*, while the acquisition step of the reservation will be performed *interruptibly*. The release step will be performed uninterruptibly as usual.

This two-phase acquisition allows for resource acquisition flows that can be safely interrupted and released.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed interruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed uninterruptibly. You usually want the ZManaged.fromZIO variant.

Iterates with the specified effectual function. The moral equivalent of:

var s = initial

while (cont(s)) {
  s = body(s)
}

s

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:

var s = initial

while (cont(s)) {
  body(s)
  s = inc(s)
}

Returns a memoized version of the specified resourceful function in the context of a managed scope. Each time the memoized function is evaluated a new resource will be acquired, if the function has not already been evaluated with that input, or else the previously acquired resource will be returned. All resources acquired by evaluating the function will be released at the end of the scope.

Merges an Iterable[ZManaged] to a single ZManaged, 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)

Returns an ZManaged 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.

Accesses the specified service in the environment of the effect.

def foo(int: Int) = ZManaged.serviceWith[Foo](_.foo(int))

Effectfully accesses the specified managed service in the environment of the effect .

Especially useful for creating "accessor" methods on Services' companion objects accessing managed resources.

trait Foo {
  def start(): ZManaged[Any, Nothing, Unit]
}

def start: ZManaged[Foo, Nothing, Unit] =
  ZManaged.serviceWithManaged[Foo](_.start())

Effectfully accesses the specified service in the environment of the effect.

def foo(int: Int) = ZManaged.serviceWith[Foo](_.foo(int))

Returns a ZManaged value that represents a managed resource that can be safely swapped within the scope of the ZManaged. The function provided inside the ZManaged can be used to switch the resource currently in use.

When the resource is switched, the finalizer for the previous finalizer will be executed uninterruptibly. If the effect executing inside the ZManaged#use is interrupted, the finalizer for the resource currently in use is guaranteed to execute.

This constructor can be used to create an expressive control flow that uses several instances of a managed resource. For example:

def makeWriter: Task[FileWriter]
trait FileWriter {
  def write(data: Int): Task[Unit]
  def close: UIO[Unit]
}

val elements = List(1, 2, 3, 4)
val writingProgram =
  ZManaged.switchable[Any, Throwable, FileWriter].use { switchWriter =>
    ZIO.foreachDiscard(elements) { element =>
      for {
        writer <- switchWriter(makeWriter.toManaged(_.close))
        _      <- writer.write(element)
      } yield ()
    }
  }

The inverse operation to sandbox. Submerges the full cause of failure.

Create a managed that accesses the environment.

Create a managed that accesses the environment.

Create a managed that accesses the environment.

Create a managed that accesses the environment.

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 collectAllDiscard.

Unlike collectAllParDiscard, 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_.

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 from left to right, and discard the results. For a parallel version, see collectAllPar_.

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.

Lifts a synchronous side-effect into a ZManaged[R, Throwable, A], translating any thrown exceptions into typed failed effects.

Lifts a by-name, pure value into a Managed.

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.

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.

Unlike foreachParDiscard, 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.

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.

For a sequential version of this method, see foreach_.

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.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed interruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed uninterruptibly. You usually want the ZManaged.fromZIO variant.

Lifts a function R => A into a ZManaged[R, Nothing, A].

Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.

Returns an effect that models failure with the specified Cause.

Runs onTrue if the result of b is true and onFalse otherwise.

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)
}

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource but handles Exit. The acquire and release actions will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not require access to the resource. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

Creates a ZManaged from a Reservation produced by an effect. Evaluating the effect that produces the reservation will be performed *uninterruptibly*, while the acquisition step of the reservation will be performed *interruptibly*. The release step will be performed uninterruptibly as usual.

This two-phase acquisition allows for resource acquisition flows that can be safely interrupted and released.

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

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.

Merges an Iterable[ZManaged] to a single ZManaged, 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)

Unlike mergeAllPar, this method will use at most up to n fibers.

Reduces an Iterable[IO] to a single IO, working in parallel.

Unlike mergeAllPar, this method will use at most up to n fibers.

This is not implemented in terms of ZIO.foreach / ZManaged.zipWithPar as otherwise all reservation phases would always run, causing unnecessary work

Requires that the given ZManaged[E, Option[A]] contain a value. If there is no value, then the specified error will be raised.

Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A]. The acquisition step is performed interruptibly.

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.

The moral equivalent of if (!p) exp when p has side-effects