ZManaged

Type Members

final class AccessMPartiallyApplied[R] extends AnyVal
final class AccessManagedPartiallyApplied[R] extends AnyVal
final class AccessPartiallyApplied[R] extends AnyVal
trait FinalizerRef[R] extends AnyRef

A FinalizerRef describes the finalizers associated with a scope.
final class IfM[R, E] extends AnyVal
trait PreallocationScope extends AnyRef
final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
trait Scope extends AnyRef

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
object FinalizerRef
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.
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](reservation: ZIO[R, E, Reservation[R, E, A]]): ZManaged[R, E, A]

Creates new ZManaged from wrapped Reservation.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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.
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 most n 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 effectTotal[R, A](r: ⇒ A): ZManaged[R, 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: Any): 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.
val fiberId: ZManaged[Any, Nothing, Id]

Returns an effect that succeeds with the Fiber.Id of the caller.
def finalize(): Unit

Attributes
protected[java.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: (Exit[Any, Any]) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, Nothing, FinalizerRef[R]]

Creates an effect that executes a finalizer stored in a FinalizerRef.
Creates an effect that executes a finalizer stored in a FinalizerRef. The FinalizerRef is yielded as the result of the effect, allowing for control flows that require mutating finalizers.
def first[E, A, B]: ZManaged[(A, B), E, 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.
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 new Option[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 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.
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.
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.
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.
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 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_.
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 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.
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.
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 a ZManaged value.
def fromFunction[R, A](f: (R) ⇒ A): ZManaged[R, Nothing, A]

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

Definition Classes
AnyRef → Any
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
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 of b is true and onFalse otherwise.
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] 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 and release actions will be performed uninterruptibly.
def makeEffect[R, A](acquire: ⇒ A)(release: (A) ⇒ Any): ZManaged[R, 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, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, E, A]

Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit.
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.
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 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[IO] to a single IO, 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[IO] to a single IO, working in parallel.
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
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 single IO, 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 single IO, working in parallel.
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
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] into ZManaged[R, E, A]
def sandbox[R, E, A](v: ZManaged[R, E, A]): ZManaged[R, Cause[E], A]
def scope: Managed[Nothing, Scope]

Creates a scope in which resources can be safely allocated into together with a release action.
def second[E, A, B]: ZManaged[(A, B), E, B]

Returns an effectful function that extracts out the second element of a tuple.
def succeed[R, A](r: ⇒ A): ZManaged[R, 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[E, A, B]: ZManaged[(A, B), E, (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
val unit: ZManaged[Any, Nothing, Unit]

Returns the effect resulting from mapping the success of this effect to unit.
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 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( ... )
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 when p has side-effects

Deprecated Value Members

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

Alias for ZManaged.collectAll
Alias for ZManaged.collectAll

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use collectAll
def sequencePar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

Alias for ZManaged.collectAllPar
Alias for ZManaged.collectAllPar

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use collectAllPar
def sequenceParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

Alias for ZManaged.collectAllParN
Alias for ZManaged.collectAllParN

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use collectAllParN
def traverse[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

Alias for ZManaged.foreach[R,E,A1,A2](as:Iterable*
Alias for ZManaged.foreach[R,E,A1,A2](as:Iterable*

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use foreach
def traversePar[R, E, A1, A2](as: Iterable[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

Alias for ZManaged.foreachPar
Alias for ZManaged.foreachPar

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use foreachPar
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
Alias for ZManaged.foreachParN

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use foreachParN
def traverseParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

Alias for ZManaged.foreachParN_
Alias for ZManaged.foreachParN_

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use foreachParN_
def traversePar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

Alias for ZManaged.foreachPar_
Alias for ZManaged.foreachPar_

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use foreachPar_
def traverse_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

Alias for ZManaged.foreach_
Alias for ZManaged.foreach_

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use foreach_

Related Docs: class ZManaged | package zio

object ZManaged extends Serializable

Type Members

final class AccessMPartiallyApplied[R] extends AnyVal

final class AccessManagedPartiallyApplied[R] extends AnyVal

final class AccessPartiallyApplied[R] extends AnyVal

trait FinalizerRef[R] extends AnyRef

final class IfM[R, E] extends AnyVal

trait PreallocationScope extends AnyRef

final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal

trait Scope extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object FinalizerRef

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

def access[R]: AccessPartiallyApplied[R]

def accessM[R]: AccessMPartiallyApplied[R]

def accessManaged[R]: AccessManagedPartiallyApplied[R]

def apply[R, E, A](reservation: ZIO[R, E, Reservation[R, E, A]]): ZManaged[R, E, A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

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

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

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

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

val fiberId: ZManaged[Any, Nothing, Id]

def finalize(): Unit

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

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

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

def first[E, A, B]: ZManaged[(A, B), E, A]

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

final def foreach[R, E, A1, A2](in: Option[A1])(f: (A1) ⇒ ZManaged[R, E, A2]): ZManaged[R, E, Option[A2]]

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

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

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

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

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

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

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

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

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

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

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

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

final def getClass(): Class[_]

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

def hashCode(): Int

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

def ifM[R, E](b: ZManaged[R, E, Boolean]): IfM[R, E]

val interrupt: ZManaged[Any, Nothing, Nothing]

def interruptAs(fiberId: ⇒ Id): ZManaged[Any, Nothing, Nothing]

final def isInstanceOf[T0]: Boolean

def iterate[R, E, S](initial: S)(cont: (S) ⇒ Boolean)(body: (S) ⇒ ZManaged[R, E, S]): ZManaged[R, E, 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]]

def loop_[R, E, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ ZManaged[R, E, Any]): ZManaged[R, E, Unit]

def make[R, R1 <: R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

def makeEffect[R, A](acquire: ⇒ A)(release: (A) ⇒ Any): ZManaged[R, Throwable, A]

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

def makeInterruptible[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, Any]): ZManaged[R, E, A]

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]

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]

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]

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]

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]

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]

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

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

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