object ZManaged extends Serializable
- Alphabetic
- By Inheritance
- ZManaged
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final class AccessMPartiallyApplied[R] extends AnyVal
- final class AccessManagedPartiallyApplied[R] extends AnyVal
- final class AccessPartiallyApplied[R] extends AnyVal
- type Finalizer = (Exit[Any, Any]) => UIO[Any]
A finalizer used in a ReleaseMap.
A finalizer used in a ReleaseMap. The Exit value passed to it is the result of executing ZManaged#use or an arbitrary value passed into ReleaseMap#release.
- final class IfM[R, E] extends AnyVal
- trait PreallocationScope extends AnyRef
A scope in which resources can be safely preallocated.
A scope in which resources can be safely preallocated. Passing a ZManaged to the
apply
method will create (inside an effect) a managed resource which is already acquired and cannot fail. - final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
- trait ReleaseMap extends AnyRef
A
ReleaseMap
represents the finalizers associated with a scope.A
ReleaseMap
represents the finalizers associated with a scope.The design of
ReleaseMap
is inspired by ResourceT, written by Michael Snoyman @snoyberg. (https://github.com/snoyberg/conduit/blob/master/resourcet/Control/Monad/Trans/Resource/Internal.hs) - trait Scope extends AnyRef
A scope in which ZManaged values can be safely allocated.
A scope in which ZManaged values can be safely allocated. Passing a managed resource to the
apply
method will return an effect that allocates the resource and returns it with an early-release handle.
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def absolve[R, E, A](v: ZManaged[R, E, Either[E, A]]): ZManaged[R, E, A]
Submerges the error case of an
Either
into theZManaged
.Submerges the error case of an
Either
into theZManaged
. The inverse operation ofZManaged.either
. - def access[R]: AccessPartiallyApplied[R]
Create a managed that accesses the environment.
- def accessM[R]: AccessMPartiallyApplied[R]
Create a managed that accesses the environment.
- def accessManaged[R]: AccessManagedPartiallyApplied[R]
Create a managed that accesses the environment.
- def apply[R, E, A](run: ZIO[(R, ReleaseMap), E, (Finalizer, A)]): ZManaged[R, E, A]
Creates new ZManaged from a ZIO value that uses a ReleaseMap and returns a resource and a finalizer.
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.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collect[R, E, A, B](in: Iterable[A])(f: (A) => ZManaged[R, Option[E], B]): ZManaged[R, E, List[B]]
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
. - def collectAll[R, E, A](ms: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[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
. - def collectAllPar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]
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
. - def collectAllParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]
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
.Unlike
CollectAllPar
, this method will use at mostn
fibers. - def collectAllParN_[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]
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
collectAll_
.Unlike
CollectAllPar_
, this method will use at mostn
fibers. - def collectAllPar_[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]
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
collectAll_
. - def collectAll_[R, E, A](ms: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]
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
collectAllPar_
. - def collectPar[R, E, A, B](in: Iterable[A])(f: (A) => ZManaged[R, Option[E], B]): ZManaged[R, E, List[B]]
Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.
- def collectParN[R, E, A, B](n: Int)(in: Iterable[A])(f: (A) => ZManaged[R, Option[E], B]): ZManaged[R, E, List[B]]
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 ton
fibers. - def die(t: => Throwable): ZManaged[Any, Nothing, Nothing]
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. - def dieMessage(message: => String): ZManaged[Any, Nothing, Nothing]
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.
- def done[E, A](r: => Exit[E, A]): ZManaged[Any, E, A]
Returns an effect from a lazily evaluated zio.Exit value.
- def effect[A](r: => A): ZManaged[Any, Throwable, A]
Lifts a synchronous side-effect into a
ZManaged[R, Throwable, A]
, translating any thrown exceptions into typed failed effects. - def effectTotal[A](r: => A): ZManaged[Any, Nothing, A]
Lifts a by-name, pure value into a Managed.
- def environment[R]: ZManaged[R, Nothing, R]
Accesses the whole environment of the effect.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def fail[E](error: => E): ZManaged[Any, E, Nothing]
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. - lazy val fiberId: ZManaged[Any, Nothing, Id]
Returns an effect that succeeds with the
Fiber.Id
of the caller. - def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def finalizer[R](f: ZIO[R, Nothing, Any]): ZManaged[R, Nothing, Unit]
Creates an effect that only executes the provided finalizer as its release action.
- def finalizerExit[R](f: (Exit[Any, Any]) => ZIO[R, Nothing, Any]): ZManaged[R, Nothing, Unit]
Creates an effect that only executes the provided function as its release action.
- def finalizerRef[R](initial: Finalizer): ZManaged[R, Nothing, Ref[Finalizer]]
Creates an effect that executes a finalizer stored in a Ref.
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. - def first[A, B]: ZManaged[(A, B), Nothing, A]
Returns an effectful function that extracts out the first element of a tuple.
- def flatten[R, E, A](zManaged: ZManaged[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
This method can be used to "flatten" nested effects.
- def flattenM[R, E, A](zManaged: ZManaged[R, E, ZIO[R, E, A]]): ZManaged[R, E, A]
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
This method can be used to "flatten" nested effects.
- def foldLeft[R, E, S, A](in: Iterable[A])(zero: S)(f: (S, A) => ZManaged[R, E, S]): ZManaged[R, E, S]
Folds an Iterable[A] using an effectual function f, working sequentially from left to right.
- final def foreach[R, E, A1, A2](in: Option[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, Option[A2]]
Applies the function
f
if the argument is non-empty and returns the results in a newOption[A2]
. - def foreach[R, E, A1, A2](as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]
Applies the function
f
to each element of theIterable[A]
and returns the results in a newList[B]
.Applies the function
f
to each element of theIterable[A]
and returns the results in a newList[B]
.For a parallel version of this method, see
foreachPar
. If you do not need the results, seeforeach_
for a more efficient implementation. - final def foreachExec[R, E, A, B](as: Iterable[A])(exec: ExecutionStrategy)(f: (A) => ZManaged[R, E, B]): ZManaged[R, E, List[B]]
Applies the function
f
to each element of theIterable[A]
and returns the result in a newList[B]
using the specified execution strategy. - def foreachPar[R, E, A1, A2](as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]
Applies the function
f
to each element of theIterable[A]
in parallel, and returns the results in a newList[B]
.Applies the function
f
to each element of theIterable[A]
in parallel, and returns the results in a newList[B]
.For a sequential version of this method, see
foreach
. - def foreachParN[R, E, A1, A2](n: Int)(as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]
Applies the function
f
to each element of theIterable[A]
in parallel, and returns the results in a newList[B]
.Applies the function
f
to each element of theIterable[A]
in parallel, and returns the results in a newList[B]
.Unlike
foreachPar
, this method will use at most up ton
fibers. - def foreachParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.Unlike
foreachPar_
, this method will use at most up ton
fibers. - def foreachPar_[R, E, A](as: Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.For a sequential version of this method, see
foreach_
. - def foreach_[R, E, A](as: Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and runs produced effects sequentially.Applies the function
f
to each element of theIterable[A]
and runs produced effects sequentially.Equivalent to
foreach(as)(f).unit
, but without the cost of building the list of results. - def fromAutoCloseable[R, E, A <: AutoCloseable](fa: ZIO[R, E, A]): ZManaged[R, E, A]
Creates a ZManaged from an
AutoCloseable
resource.Creates a ZManaged from an
AutoCloseable
resource. The resource'sclose
method will be used as the release action. - def fromEffect[R, E, A](fa: ZIO[R, E, A]): ZManaged[R, E, A]
Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action.
Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed interruptibly.
- def fromEffectUninterruptible[R, E, A](fa: ZIO[R, E, A]): ZManaged[R, E, A]
Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action.
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.fromEffect variant.
- def fromEither[E, A](v: => Either[E, A]): ZManaged[Any, E, A]
Lifts an
Either
into aZManaged
value. - def fromFunction[R, A](f: (R) => A): ZManaged[R, Nothing, A]
Lifts a function
R => A
into aZManaged[R, Nothing, A]
. - def fromFunctionM[R, E, A](f: (R) => ZManaged[Any, E, A]): ZManaged[R, E, A]
Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def halt[E](cause: => Cause[E]): ZManaged[Any, E, Nothing]
Returns an effect that models failure with the specified
Cause
. - def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def identity[R]: ZManaged[R, Nothing, R]
Returns the identity effectful function, which performs no effects
- def ifM[R, E](b: ZManaged[R, E, Boolean]): IfM[R, E]
Runs
onTrue
if the result ofb
istrue
andonFalse
otherwise. - lazy val interrupt: ZManaged[Any, Nothing, Nothing]
Returns an effect that is interrupted as if by the fiber calling this method.
- def interruptAs(fiberId: => Id): ZManaged[Any, Nothing, Nothing]
Returns an effect that is interrupted as if by the specified fiber.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterate[R, E, S](initial: S)(cont: (S) => Boolean)(body: (S) => ZManaged[R, E, S]): ZManaged[R, E, S]
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
- def loop[R, E, A, S](initial: S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZManaged[R, E, A]): ZManaged[R, E, List[A]]
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
- def loop_[R, E, S](initial: S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
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) }
- def make[R, R1 <: R, E, A](acquire: ZIO[R, E, A])(release: (A) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]
Lifts a
ZIO[R, E, A]
intoZManaged[R, E, A]
with a release action.Lifts a
ZIO[R, E, A]
intoZManaged[R, E, A]
with a release action. The acquire and release actions will be performed uninterruptibly. - def makeEffect[A](acquire: => A)(release: (A) => Any): ZManaged[Any, Throwable, A]
Lifts a synchronous effect into
ZManaged[R, Throwable, A]
with a release action.Lifts a synchronous effect into
ZManaged[R, Throwable, A]
with a release action. The acquire and release actions will be performed uninterruptibly. - def makeExit[R, R1 <: R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]
Lifts a
ZIO[R, E, A]
intoZManaged[R, E, A]
with a release action that handlesExit
.Lifts a
ZIO[R, E, A]
intoZManaged[R, E, A]
with a release action that handlesExit
. The acquire and release actions will be performed uninterruptibly. - def makeInterruptible[R, E, A](acquire: ZIO[R, E, A])(release: (A) => ZIO[R, Nothing, Any]): ZManaged[R, E, A]
Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action.
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.
- def makeReserve[R, E, A](reservation: ZIO[R, E, Reservation[R, E, A]]): ZManaged[R, E, A]
Creates a ZManaged from a Reservation produced by an effect.
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. For an example, see Semaphore#withPermitsManaged.
- def mapN[R, E, A, B, C, D, F](zManaged1: ZManaged[R, E, A], zManaged2: ZManaged[R, E, B], zManaged3: ZManaged[R, E, C], zManaged4: ZManaged[R, E, D])(f: (A, B, C, D) => F): ZManaged[R, E, F]
Sequentially zips the specified effects using the specified combiner function.
- def mapN[R, E, A, B, C, D](zManaged1: ZManaged[R, E, A], zManaged2: ZManaged[R, E, B], zManaged3: ZManaged[R, E, C])(f: (A, B, C) => D): ZManaged[R, E, D]
Sequentially zips the specified effects using the specified combiner function.
- def mapN[R, E, A, B, C](zManaged1: ZManaged[R, E, A], zManaged2: ZManaged[R, E, B])(f: (A, B) => C): ZManaged[R, E, C]
Sequentially zips the specified effects using the specified combiner function.
- def mapParN[R, E, A, B, C, D, F](zManaged1: ZManaged[R, E, A], zManaged2: ZManaged[R, E, B], zManaged3: ZManaged[R, E, C], zManaged4: ZManaged[R, E, D])(f: (A, B, C, D) => F): ZManaged[R, E, F]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
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. - def mapParN[R, E, A, B, C, D](zManaged1: ZManaged[R, E, A], zManaged2: ZManaged[R, E, B], zManaged3: ZManaged[R, E, C])(f: (A, B, C) => D): ZManaged[R, E, D]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
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. - def mapParN[R, E, A, B, C](zManaged1: ZManaged[R, E, A], zManaged2: ZManaged[R, E, B])(f: (A, B) => C): ZManaged[R, E, C]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
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. - def mergeAll[R, E, A, B](in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) => B): ZManaged[R, E, B]
Merges an
Iterable[ZManaged]
to a singleZManaged
, working sequentially. - def mergeAllPar[R, E, A, B](in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) => B): ZManaged[R, E, B]
Merges an
Iterable[ZManaged]
to a singleZManaged
, working in parallel.Merges an
Iterable[ZManaged]
to a singleZManaged
, 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)
- def mergeAllParN[R, E, A, B](n: Int)(in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) => B): ZManaged[R, E, B]
Merges an
Iterable[ZManaged]
to a singleZManaged
, working in parallel.Merges an
Iterable[ZManaged]
to a singleZManaged
, 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 ton
fibers. - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- lazy val never: ZManaged[Any, Nothing, Nothing]
Returns a
ZManaged
that never acquires a resource. - final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- lazy val preallocationScope: Managed[Nothing, PreallocationScope]
Creates a scope in which resources can be safely preallocated.
- def reduceAll[R, E, A](a: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) => A): ZManaged[R, E, A]
Reduces an
Iterable[IO]
to a singleIO
, working sequentially. - def reduceAllPar[R, E, A](a: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) => A): ZManaged[R, E, A]
Reduces an
Iterable[IO]
to a singleIO
, working in parallel. - def reduceAllParN[R, E, A](n: Int)(a: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) => A): ZManaged[R, E, A]
Reduces an
Iterable[IO]
to a singleIO
, working in parallel.Reduces an
Iterable[IO]
to a singleIO
, working in parallel.Unlike
mergeAllPar
, this method will use at most up ton
fibers.This is not implemented in terms of ZIO.foreach / ZManaged.zipWithPar as otherwise all reservation phases would always run, causing unnecessary work
- lazy val releaseMap: ZManaged[Any, Nothing, ReleaseMap]
Provides access to the entire map of resources allocated by this ZManaged.
- def require[R, E, A](error: => E): (ZManaged[R, E, Option[A]]) => ZManaged[R, E, A]
Requires that the given
ZManaged[E, Option[A]]
contain a value.Requires that the given
ZManaged[E, Option[A]]
contain a value. If there is no value, then the specified error will be raised. - def reserve[R, E, A](reservation: Reservation[R, E, A]): ZManaged[R, E, A]
Lifts a pure
Reservation[R, E, A]
intoZManaged[R, E, A]
.Lifts a pure
Reservation[R, E, A]
intoZManaged[R, E, A]
. The acquisition step is performed interruptibly. - def sandbox[R, E, A](v: ZManaged[R, E, A]): ZManaged[R, Cause[E], A]
- lazy val scope: Managed[Nothing, Scope]
Creates a scope in which resources can be safely allocated into together with a release action.
- def second[A, B]: ZManaged[(A, B), Nothing, B]
Returns an effectful function that extracts out the second element of a tuple.
- def service[A](implicit arg0: zio.Tag[A]): ZManaged[Has[A], Nothing, A]
Accesses the specified service in the environment of the effect.
- def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): ZManaged[Has[A] with Has[B] with Has[C] with Has[D], Nothing, (A, B, C, D)]
Accesses the specified services in the environment of the effect.
- def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): ZManaged[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]
Accesses the specified services in the environment of the effect.
- def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): ZManaged[Has[A] with Has[B], Nothing, (A, B)]
Accesses the specified services in the environment of the effect.
- def some[A](a: => A): UManaged[Option[A]]
Returns an effect with the optional value.
- def succeed[A](r: => A): ZManaged[Any, Nothing, A]
Lifts a lazy, pure value into a Managed.
- def suspend[R, E, A](zManaged: => ZManaged[R, E, A]): ZManaged[R, E, A]
Returns a lazily constructed Managed.
- def swap[A, B]: ZManaged[(A, B), Nothing, (B, A)]
Returns an effectful function that merely swaps the elements in a
Tuple2
. - def switchable[R, E, A]: ZManaged[R, Nothing, (ZManaged[R, E, A]) => ZIO[R, E, A]]
Returns a ZManaged value that represents a managed resource that can be safely swapped within the scope of the ZManaged.
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.foreach_(elements) { element => for { writer <- switchWriter(makeWriter.toManaged(_.close)) _ <- writer.write(element) } yield () } }
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- lazy val unit: ZManaged[Any, Nothing, Unit]
Returns the effect resulting from mapping the success of this effect to unit.
- def unless[R, E](b: => Boolean)(zio: => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
The moral equivalent of
if (!p) exp
- def unlessM[R, E](b: ZManaged[R, E, Boolean])(zio: => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
The moral equivalent of
if (!p) exp
whenp
has side-effects - def unsandbox[R, E, A](v: ZManaged[R, Cause[E], A]): ZManaged[R, E, A]
The inverse operation to
sandbox
.The inverse operation to
sandbox
. Submerges the full cause of failure. - def unwrap[R, E, A](fa: ZIO[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]
Unwraps a
ZManaged
that is inside aZIO
. - final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def when[R, E](b: => Boolean)(zManaged: => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
The moral equivalent of
if (p) exp
- def whenCase[R, E, A](a: => A)(pf: PartialFunction[A, ZManaged[R, E, Any]]): ZManaged[R, E, Unit]
Runs an effect when the supplied
PartialFunction
matches for the given value, otherwise does nothing. - def whenCaseM[R, E, A](a: ZManaged[R, E, A])(pf: PartialFunction[A, ZManaged[R, E, Any]]): ZManaged[R, E, Unit]
Runs an effect when the supplied
PartialFunction
matches for the given effectful value, otherwise does nothing. - def whenM[R, E](b: ZManaged[R, E, Boolean])(zManaged: => ZManaged[R, E, Any]): ZManaged[R, E, Unit]
The moral equivalent of
if (p) exp
whenp
has side-effects - object Finalizer
- object ReleaseMap