ZManaged

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
final def _1[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, A]

Returns an effectful function that extracts out the first element of a tuple.
final def _2[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, B]

Returns an effectful function that extracts out the second element of a tuple.
final def absolve[R, E, A](v: ZManaged[R, E, Either[E, A]]): ZManaged[R, E, A]

Submerges the error case of an Either into the ZManaged.
Submerges the error case of an Either into the ZManaged. The inverse operation of ZManaged.either.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def collectAll[R, E, A1, A2](ms: Iterable[ZManaged[R, E, A2]]): ZManaged[R, E, List[A2]]

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.
final 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.
final 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 most n fibers.
final 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.
final 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.
final def done[E, A](r: Exit[E, A]): ZManaged[Any, E, A]

Returns an effect from a zio.Exit value.
final def effectTotal[R, A](r: ⇒ A): ZManaged[R, Nothing, A]

Lifts a by-name, pure value into a Managed.
final 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: Any): Boolean

Definition Classes
AnyRef → Any
final 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.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def finalizer[R](f: ZIO[R, Nothing, _]): ZManaged[R, Nothing, Unit]

Creates an effect that only executes the provided finalizer as its release action.
final def finalizerExit[R](f: (Exit[_, _]) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, Nothing, Unit]

Creates an effect that only executes the provided function as its release action.
final def finalizerRef[R](initial: (Exit[_, _]) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, Nothing, Ref[(Exit[_, _]) ⇒ ZIO[R, Nothing, Any]]]

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.
final 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.
final 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 the Iterable[A] and returns the results in a new List[B].
Applies the function f to each element of the Iterable[A] and returns the results in a new List[B].
For a parallel version of this method, see foreachPar.
final 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 the Iterable[A] in parallel, and returns the results in a new List[B].
Applies the function f to each element of the Iterable[A] in parallel, and returns the results in a new List[B].
For a sequential version of this method, see foreach.
final 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 the Iterable[A] in parallel, and returns the results in a new List[B].
Applies the function f to each element of the Iterable[A] in parallel, and returns the results in a new List[B].
Unlike foreachPar, this method will use at most up to n fibers.
final 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 the Iterable[A] and runs produced effects in parallel, discarding the results.
Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.
Unlike foreachPar_, this method will use at most up to n fibers.
final def foreachPar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.
Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.
For a sequential version of this method, see foreach_.
final def foreach_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

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).void, but without the cost of building the list of results.
final 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's close method will be used as the release action.
final 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. Use with care.
final def fromEither[E, A](v: ⇒ Either[E, A]): ZManaged[Any, E, A]

Lifts an Either into a ZManaged value.
final def fromFunction[R, A](f: (R) ⇒ A): ZManaged[R, Nothing, A]

Lifts a function R => A into a ZManaged[R, Nothing, A].
final 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[_]

Definition Classes
AnyRef → Any
final 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
final def identity[R]: ZManaged[R, Nothing, R]

Returns the identity effectful function, which performs no effects
final val interrupt: ZManaged[Any, Nothing, Nothing]

Returns an effect that is interrupted.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def make[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, _]): ZManaged[R, E, A]

Lifts a ZIO[R, E, R] into ZManaged[R, E, R] with a release action.
final def makeEffect[R, A](acquire: ⇒ A)(release: Function1[A, _]): ZManaged[R, Throwable, A]

Lifts a synchronous effect into ZManaged[R, Throwable, R] with a release action.
final def makeExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[_, _]) ⇒ ZIO[R, Nothing, _]): ZManaged[R, E, A]

Lifts a ZIO[R, E, R] into ZManaged[R, E, R] with a release action that handles Exit.
final 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[IO] to a single IO, working sequentially.
final 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[IO] to a single IO, working in parallel.
final 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[IO] to a single IO, working in parallel.
Merges 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
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val never: ZManaged[Any, Nothing, Nothing]

Returns a ZManaged that never acquires a resource.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final 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 single IO, working sequentially.
final 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 single IO, working in parallel.
final def reduceAllParN[R, E, A](n: Long)(a1: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) ⇒ A): ZManaged[R, E, A]

Reduces an Iterable[IO] to a single IO, working in parallel.
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
final 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.
final def reserve[R, E, A](reservation: Reservation[R, E, A]): ZManaged[R, E, A]

Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A]
final def sandbox[R, E, A](v: ZManaged[R, E, A]): ZManaged[R, Cause[E], A]
final def sequence[R, E, A1, A2](ms: Iterable[ZManaged[R, E, A2]]): ZManaged[R, E, List[A2]]

Alias for ZManaged.collectAll
final def sequencePar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

Alias for ZManaged.collectAllPar
final def sequenceParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

Alias for ZManaged.collectAllParN
final def succeed[R, A](r: A): ZManaged[R, Nothing, A]

Lifts a strict, pure value into a Managed.
final def suspend[R, E, A](zManaged: ⇒ ZManaged[R, E, A]): ZManaged[R, E, A]

Returns a lazily constructed Managed.
final def swap[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, (B, A)]

Returns an effectful function that merely swaps the elements in a Tuple2.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def traverse[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

Alias for ZManaged.foreach
final def traversePar[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

Alias for ZManaged.foreachPar
final def traverseParN[R, E, A1, A2](n: Int)(as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

Alias for ZManaged.foreachParN
final def traverseParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

Alias for ZManaged.foreachParN_
final def traversePar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

Alias for ZManaged.foreachPar_
final def traverse_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

Alias for ZManaged.foreach_
final val unit: ZManaged[Any, Nothing, Unit]

Returns the effect resulting from mapping the success of this effect to unit.
final 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.
final def unwrap[R, E, A](fa: ZIO[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]

Unwraps a ZManaged that is inside a ZIO.
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
@throws( ... )
final def when[R, E](b: Boolean)(zManaged: ZManaged[R, E, _]): ZManaged[R, E, Unit]

The moral equivalent of if (p) exp
final def whenCase[R, E, A](a: A)(pf: PartialFunction[A, ZManaged[R, E, _]]): ZManaged[R, E, Unit]

Runs an effect when the supplied PartialFunction matches for the given value, otherwise does nothing.
final def whenCaseM[R, E, A](a: ZManaged[R, E, A])(pf: PartialFunction[A, ZManaged[R, E, _]]): ZManaged[R, E, Unit]

Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.
final def whenM[R, E](b: ZManaged[R, E, Boolean])(zManaged: ZManaged[R, E, _]): ZManaged[R, E, Unit]

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

Deprecated Value Members

final def succeedLazy[R, A](r: ⇒ A): ZManaged[R, Nothing, A]

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use effectTotal

Related Docs: class ZManaged | package zio

object ZManaged extends Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def _1[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, A]

final def _2[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, B]

final def absolve[R, E, A](v: ZManaged[R, E, Either[E, A]]): ZManaged[R, E, A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collectAll[R, E, A1, A2](ms: Iterable[ZManaged[R, E, A2]]): ZManaged[R, E, List[A2]]

final def collectAllPar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

final def collectAllParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

final def die(t: Throwable): ZManaged[Any, Nothing, Nothing]

final def dieMessage(message: String): ZManaged[Any, Nothing, Nothing]

final def done[E, A](r: Exit[E, A]): ZManaged[Any, E, A]

final def effectTotal[R, A](r: ⇒ A): ZManaged[R, Nothing, A]

final def environment[R]: ZManaged[R, Nothing, R]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fail[E](error: E): ZManaged[Any, E, Nothing]

def finalize(): Unit

final def finalizer[R](f: ZIO[R, Nothing, _]): ZManaged[R, Nothing, Unit]

final def finalizerExit[R](f: (Exit[_, _]) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, Nothing, Unit]

final def finalizerRef[R](initial: (Exit[_, _]) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, Nothing, Ref[(Exit[_, _]) ⇒ ZIO[R, Nothing, Any]]]

final def flatten[R, E, A](zManaged: ZManaged[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]

final def foreach[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

final def foreachPar[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

final def foreachParN[R, E, A1, A2](n: Int)(as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

final def foreachParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

final def foreachPar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

final def foreach_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

final def fromAutoCloseable[R, E, A <: AutoCloseable](fa: ZIO[R, E, A]): ZManaged[R, E, A]

final def fromEffect[R, E, A](fa: ZIO[R, E, A]): ZManaged[R, E, A]

final def fromEither[E, A](v: ⇒ Either[E, A]): ZManaged[Any, E, A]

final def fromFunction[R, A](f: (R) ⇒ A): ZManaged[R, Nothing, A]

final def fromFunctionM[R, E, A](f: (R) ⇒ ZManaged[Any, E, A]): ZManaged[R, E, A]

final def getClass(): Class[_]

final def halt[E](cause: Cause[E]): ZManaged[Any, E, Nothing]

def hashCode(): Int

final def identity[R]: ZManaged[R, Nothing, R]

final val interrupt: ZManaged[Any, Nothing, Nothing]

final def isInstanceOf[T0]: Boolean

final def make[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, _]): ZManaged[R, E, A]

final def makeEffect[R, A](acquire: ⇒ A)(release: Function1[A, _]): ZManaged[R, Throwable, A]

final def makeExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[_, _]) ⇒ ZIO[R, Nothing, _]): ZManaged[R, E, A]

final def mergeAll[R, E, A, B](in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZManaged[R, E, B]

final def mergeAllPar[R, E, A, B](in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZManaged[R, E, B]

final def mergeAllParN[R, E, A, B](n: Int)(in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZManaged[R, E, B]

final def ne(arg0: AnyRef): Boolean

val never: ZManaged[Any, Nothing, Nothing]

final def notify(): Unit

final def notifyAll(): Unit

final def reduceAll[R, E, A](a: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) ⇒ A): ZManaged[R, E, A]

final def reduceAllPar[R, E, A](a: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) ⇒ A): ZManaged[R, E, A]

final def reduceAllParN[R, E, A](n: Long)(a1: ZManaged[R, E, A], as: Iterable[ZManaged[R, E, A]])(f: (A, A) ⇒ A): ZManaged[R, E, A]

final def require[R, E, A](error: E): (ZManaged[R, E, Option[A]]) ⇒ ZManaged[R, E, A]

final def reserve[R, E, A](reservation: Reservation[R, E, A]): ZManaged[R, E, A]

final def sandbox[R, E, A](v: ZManaged[R, E, A]): ZManaged[R, Cause[E], A]

final def sequence[R, E, A1, A2](ms: Iterable[ZManaged[R, E, A2]]): ZManaged[R, E, List[A2]]

final def sequencePar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

final def sequenceParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

final def succeed[R, A](r: A): ZManaged[R, Nothing, A]

final def suspend[R, E, A](zManaged: ⇒ ZManaged[R, E, A]): ZManaged[R, E, A]

final def swap[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, (B, A)]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def traverse[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

final def traversePar[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

final def traverseParN[R, E, A1, A2](n: Int)(as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

final def traverseParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

final def traversePar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

final def traverse_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, _]): ZManaged[R, E, Unit]

final val unit: ZManaged[Any, Nothing, Unit]

final def unsandbox[R, E, A](v: ZManaged[R, Cause[E], A]): ZManaged[R, E, A]

final def unwrap[R, E, A](fa: ZIO[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit