final case class ZManaged[-R, +E, +A](reserve: ZIO[R, E, Reservation[R, E, A]]) extends Product with Serializable
A ZManaged[R, E, A]
is a managed resource of type A
, which may be used by
invoking the use
method of the resource. The resource will be automatically
acquired before the resource is used, and automatically released after the
resource is used.
Resources do not survive the scope of use
, meaning that if you attempt to
capture the resource, leak it from use
, and then use it after the resource
has been consumed, the resource will not be valid anymore and may fail with
some checked error, as per the type of the functions provided by the resource.
- Self Type
- ZManaged[R, E, A]
- Alphabetic
- By Inheritance
- ZManaged
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new ZManaged(reserve: ZIO[R, E, Reservation[R, E, A]])
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
&&&[R1 <: R, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R1, E1, (A, B)]
Symbolic alias for zip.
-
final
def
&>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]
Symbolic alias for zipParRight
-
final
def
*>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]
Symbolic alias for zipRight
- final def +++[R1, B, E1 >: E](that: ZManaged[R1, E1, B]): ZManaged[Either[R, R1], E1, Either[A, B]]
-
final
def
<&[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]
Symbolic alias for zipParLeft
-
final
def
<&>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]
Symbolic alias for zipPar
-
final
def
<*[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]
Symbolic alias for zipLeft
-
final
def
<*>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]
Symbolic alias for zip.
-
final
def
<<<[R1, E1 >: E](that: ZManaged[R1, E1, R]): ZManaged[R1, E1, A]
Symbolic alias for compose
-
final
def
<>[R1 <: R, E2, A1 >: A](that: ⇒ ZManaged[R1, E2, A1]): ZManaged[R1, E2, A1]
Operator alias for
orElse
. -
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
>>=[R1 <: R, E1 >: E, B](k: (A) ⇒ ZManaged[R1, E1, B]): ZManaged[R1, E1, B]
Symbolic alias for flatMap
-
final
def
>>>[R1 >: A, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R, E1, B]
Symbolic alias for andThen
-
final
def
absolve[R1 <: R, E1, B](implicit ev: <:<[ZManaged[R, E, A], ZManaged[R1, E1, Either[E1, B]]]): ZManaged[R1, E1, B]
Submerges the error case of an
Either
into theZManaged
.Submerges the error case of an
Either
into theZManaged
. The inverse operation ofZManaged.either
. -
final
def
andThen[R1 >: A, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R, E1, B]
Executes the this effect and then provides its output as an environment to the second effect
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
final
def
bimap[E1, A1](f: (E) ⇒ E1, g: (A) ⇒ A1): ZManaged[R, E1, A1]
Returns an effect whose failure and success channels have been mapped by the specified pair of functions,
f
andg
. -
final
def
catchAll[R1 <: R, E2, A1 >: A](h: (E) ⇒ ZManaged[R1, E2, A1]): ZManaged[R1, E2, A1]
Recovers from all errors.
-
final
def
catchSome[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[E, ZManaged[R1, E1, A1]]): ZManaged[R1, E1, A1]
Recovers from some or all of the error cases.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
compose[R1, E1 >: E](that: ZManaged[R1, E1, R]): ZManaged[R1, E1, A]
Executes the second effect and then provides its output as an environment to this effect
-
final
def
const[B](b: ⇒ B): ZManaged[R, E, B]
Maps this effect to the specified constant while preserving the effects of this effect.
-
final
def
either: ZManaged[R, Nothing, Either[E, A]]
Returns an effect whose failure and success have been lifted into an
Either
.The resulting effect cannot fail -
final
def
ensuring[R1 <: R](f: ZIO[R1, Nothing, _]): ZManaged[R1, E, A]
Ensures that
f
is executed when this ZManaged is finalized, after the existing finalizer. -
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
first[R1 <: R, A1 >: A]: ZManaged[R1, E, (A1, R1)]
Zips this effect with its environment
-
final
def
flatMap[R1 <: R, E1 >: E, B](f0: (A) ⇒ ZManaged[R1, E1, B]): ZManaged[R1, E1, B]
Returns an effect that models the execution of this effect, followed by the passing of its value to the specified continuation function
k
, followed by the effect that it returns. -
final
def
flatMapError[R1 <: R, E2](f: (E) ⇒ ZManaged[R1, Nothing, E2]): ZManaged[R1, E2, A]
Effectfully map the error channel
-
final
def
flatten[R1 <: R, E1 >: E, B](implicit ev: <:<[A, ZManaged[R1, E1, B]]): ZManaged[R1, E1, B]
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.
This method can be used to "flatten" nested effects.
-
final
def
flip: ZManaged[R, A, E]
Flip the error and result
-
final
def
flipWith[R1, A1, E1](f: (ZManaged[R, A, E]) ⇒ ZManaged[R1, A1, E1]): ZManaged[R1, E1, A1]
Flip the error and result, then apply an effectful function to the effect
-
final
def
fold[B](failure: (E) ⇒ B, success: (A) ⇒ B): ZManaged[R, Nothing, B]
Folds over the failure value or the success value to yield an effect that does not fail, but succeeds with the value returned by the left or right function passed to
fold
. -
final
def
foldCauseM[R1 <: R, E1, A1](failure: (Cause[E]) ⇒ ZManaged[R1, E1, A1], success: (A) ⇒ ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]
A more powerful version of
foldM
that allows recovering from any kind of failure except interruptions. -
final
def
foldM[R1 <: R, E2, B](failure: (E) ⇒ ZManaged[R1, E2, B], success: (A) ⇒ ZManaged[R1, E2, B]): ZManaged[R1, E2, B]
Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.
-
final
def
fork: ZManaged[R, Nothing, Fiber[E, A]]
Creates a
ZManaged
value that acquires the original resource in a fiber, and provides that fiber.Creates a
ZManaged
value that acquires the original resource in a fiber, and provides that fiber. The finalizer for this value will interrupt the fiber and run the original finalizer. -
final
def
get[E1 >: E, B](implicit ev1: =:=[E1, Nothing], ev2: <:<[A, Option[B]]): ZManaged[R, Unit, B]
Unwraps the optional success of this effect, but can fail with unit value.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
join[R1, E1 >: E, A1 >: A](that: ZManaged[R1, E1, A1]): ZManaged[Either[R, R1], E1, A1]
Depending on the environment execute this or the other effect
- final def left[R1 <: R, C]: ZManaged[Either[R1, C], E, Either[A, C]]
-
final
def
map[B](f0: (A) ⇒ B): ZManaged[R, E, B]
Returns an effect whose success is mapped by the specified
f
function. -
final
def
mapError[E1](f: (E) ⇒ E1): ZManaged[R, E1, A]
Returns an effect whose failure is mapped by the specified
f
function. -
final
def
mapM[R1 <: R, E1 >: E, B](f: (A) ⇒ ZIO[R1, E1, B]): ZManaged[R1, E1, B]
Effectfully maps the resource acquired by this value.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
option: ZManaged[R, Nothing, Option[A]]
Executes this effect, skipping the error but returning optionally the success.
-
final
def
orDie(implicit ev: <:<[E, Throwable]): ZManaged[R, Nothing, A]
Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.
-
final
def
orDieWith(f: (E) ⇒ Throwable): ZManaged[R, Nothing, A]
Keeps none of the errors, and terminates the fiber with them, using the specified function to convert the
E
into aThrowable
. -
final
def
orElse[R1 <: R, E2, A1 >: A](that: ⇒ ZManaged[R1, E2, A1]): ZManaged[R1, E2, A1]
Executes this effect and returns its value, if it succeeds, but otherwise executes the specified effect.
-
final
def
orElseEither[R1 <: R, E2, B](that: ⇒ ZManaged[R1, E2, B]): ZManaged[R1, E2, Either[A, B]]
Returns an effect that will produce the value of this effect, unless it fails, in which case, it will produce the value of the specified effect.
-
final
def
provide(r: R): ZManaged[Any, E, A]
Provides the
ZManaged
effect with its required environment, which eliminates its dependency onR
. -
final
def
provideSome[R0](f: (R0) ⇒ R): ZManaged[R0, E, A]
Provides some of the environment required to run this effect, leaving the remainder
R0
. -
final
def
refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev: <:<[E, Throwable]): ZManaged[R, E1, A]
Keeps some of the errors, and terminates the fiber with the rest.
-
final
def
refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) ⇒ Throwable): ZManaged[R, E1, A]
Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the
E
into aThrowable
. -
final
def
refineToOrDie[E1](implicit arg0: ClassTag[E1], ev: <:<[E, Throwable]): ZManaged[R, E1, A]
Keeps some of the errors, and terminates the fiber with the rest.
- val reserve: ZIO[R, E, Reservation[R, E, A]]
-
final
def
retry[R1 <: R, E1 >: E, S](policy: ZSchedule[R1, E1, S]): ZManaged[R1 with Clock, E1, A]
Retries with the specified retry policy.
Retries with the specified retry policy. Retries are done following the failure of the original
io
(up to a fixed maximum withonce
orrecurs
for example), so that thatio.retry(Schedule.once)
means "executeio
and in case of failure, try again once". - final def right[R1 <: R, C]: ZManaged[Either[C, R1], E, Either[C, A]]
-
final
def
sandbox: ZManaged[R, Cause[E], A]
Exposes the full cause of failure of this effect.
-
final
def
second[R1 <: R, A1 >: A]: ZManaged[R1, E, (R1, A1)]
Zips this effect with its environment
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
final
def
timed: ZManaged[R with Clock, E, (Duration, A)]
Returns a new effect that executes this one and times the acquisition of the resource.
-
final
def
timeout(d: Duration): ZManaged[R with Clock, E, Option[A]]
Returns an effect that will timeout this resource, returning
None
if the timeout elapses before the resource was reserved and acquired.Returns an effect that will timeout this resource, returning
None
if the timeout elapses before the resource was reserved and acquired. If the reservation completes successfully (even after the timeout) the release action will be run on a new fiber.Some
will be returned if acquisition and reservation complete in time -
final
lazy val
unit: ZManaged[R, E, Unit]
Return unit while running the effect
-
final
def
unsandbox[E1](implicit ev: <:<[E, Cause[E1]]): ZManaged[R, E1, A]
The inverse operation
ZManaged.sandboxed
-
final
def
use[R1 <: R, E1 >: E, B](f: (A) ⇒ ZIO[R1, E1, B]): ZIO[R1, E1, B]
Run an effect while acquiring the resource before and releasing it after
-
final
val
useForever: ZIO[R, E, Nothing]
Use the resource until interruption.
Use the resource until interruption. Useful for resources that you want to acquire and use as long as the application is running, like a HTTP server.
-
final
def
use_[R1 <: R, E1 >: E, B](f: ZIO[R1, E1, B]): ZIO[R1, E1, B]
Run an effect while acquiring the resource before and releasing it after.
Run an effect while acquiring the resource before and releasing it after. This does not provide the resource to the function
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
when(b: Boolean): ZManaged[R, E, Unit]
The moral equivalent of
if (p) exp
-
final
def
whenM[R1 <: R, E1 >: E](b: ZManaged[R1, E1, Boolean]): ZManaged[R1, E1, Unit]
The moral equivalent of
if (p) exp
whenp
has side-effects -
final
def
zip[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]
Named alias for
<*>
. -
final
def
zipLeft[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]
Named alias for
<*
. -
final
def
zipPar[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]
Named alias for
<&>
. -
final
def
zipParLeft[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]
Named alias for
<&
. -
final
def
zipParRight[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]
Named alias for
&>
. -
final
def
zipRight[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]
Named alias for
*>
. -
final
def
zipWith[R1 <: R, E1 >: E, A1, A2](that: ZManaged[R1, E1, A1])(f: (A, A1) ⇒ A2): ZManaged[R1, E1, A2]
Returns an effect that executes both this effect and the specified effect, in sequence, combining their results with the specified
f
function. -
final
def
zipWithPar[R1 <: R, E1 >: E, A1, A2](that: ZManaged[R1, E1, A1])(f0: (A, A1) ⇒ A2): ZManaged[R1, E1, A2]
Returns an effect that executes both this effect and the specified effect, in parallel, combining their results with the specified
f
function.Returns an effect that executes both this effect and the specified effect, in parallel, combining their results with the specified
f
function. If either side fails, then the other side will be interrupted. -
final
def
|||[R1, E1 >: E, A1 >: A](that: ZManaged[R1, E1, A1]): ZManaged[Either[R, R1], E1, A1]
Symbolic alias for join