Managed

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

See zio.ZManaged.absolve

def apply[E, A](reserve: IO[E, Reservation[Any, E, A]]): Managed[E, A]

See zio.ZManaged

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

See zio.ZManaged.collectAll

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

See zio.ZManaged.collectAllPar

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

See zio.ZManaged.collectAllParN

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

See zio.ZManaged.die

def dieMessage(message: ⇒ String): Managed[Throwable, Nothing]

See zio.ZManaged.dieMessage

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

See zio.ZManaged.done

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

See zio.ZManaged.effectTotal

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

See zio.ZManaged.fail

def finalize(): Unit

def finalizer(f: IO[Nothing, Any]): Managed[Nothing, Unit]

See zio.ZManaged.finalizer

def finalizerRef(initial: (Exit[Any, Any]) ⇒ UIO[Any]): Managed[Nothing, FinalizerRef[Any]]

See zio.ZManaged.finalizerRef

def flatten[E, A](m: Managed[E, Managed[E, A]]): Managed[E, A]

See zio.ZManaged.flatten

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

See zio.ZManaged.foreach[R,E,A1,A2](in:Option*

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

See zio.ZManaged.foreach[R,E,A1,A2](as:Iterable*

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

See zio.ZManaged.foreachPar

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

See zio.ZManaged.foreachParN

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

See zio.ZManaged.foreachParN_

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

See zio.ZManaged.foreachPar_

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

See zio.ZManaged.foreach_

def fromAutoCloseable[E, A <: AutoCloseable](fa: IO[E, A]): Managed[E, A]

See zio.ZManaged.fromAutoCloseable

def fromEffect[E, A](fa: IO[E, A]): Managed[E, A]

See zio.ZManaged.fromEffect

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

See zio.ZManaged.fromEither

final def getClass(): Class[_]

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

See zio.ZManaged.halt

def hashCode(): Int

def ifM[E](b: Managed[E, Boolean]): IfM[Any, E]

See zio.ZManaged.ifM

val interrupt: Managed[Nothing, Nothing]

See zio.ZManaged.interrupt

final def isInstanceOf[T0]: Boolean

def iterate[E, S](initial: S)(cont: (S) ⇒ Boolean)(body: (S) ⇒ Managed[E, S]): Managed[E, S]

See zio.ZManaged.iterate

def loop[E, A, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ Managed[E, A]): Managed[E, List[A]]

See zio.ZManaged.loop

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

See zio.ZManaged.loop_

def make[E, A](acquire: IO[E, A])(release: (A) ⇒ UIO[Any]): Managed[E, A]

See zio.ZManaged.make

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

See zio.ZManaged.makeEffect

def makeExit[E, A](acquire: IO[E, A])(release: (A, Exit[Any, Any]) ⇒ UIO[Any]): Managed[E, A]

See zio.ZManaged.makeExit

def makeInterruptible[R, E, A](acquire: IO[E, A])(release: (A) ⇒ UIO[Any]): Managed[E, A]

See zio.ZManaged.makeInterruptible

def mapN[E, A, B, C, D, F](managed1: Managed[E, A], managed2: Managed[E, B], managed3: Managed[E, C], managed4: Managed[E, D])(f: (A, B, C, D) ⇒ F): Managed[E, F]

def mapN[E, A, B, C, D](managed1: Managed[E, A], managed2: Managed[E, B], managed3: Managed[E, C])(f: (A, B, C) ⇒ D): Managed[E, D]

def mapN[E, A, B, C](managed1: Managed[E, A], managed2: Managed[E, B])(f: (A, B) ⇒ C): Managed[E, C]

def mapParN[E, A, B, C, D, F](managed1: Managed[E, A], managed2: Managed[E, B], managed3: Managed[E, C], managed4: Managed[E, D])(f: (A, B, C, D) ⇒ F): Managed[E, F]

def mapParN[E, A, B, C, D](managed1: Managed[E, A], managed2: Managed[E, B], managed3: Managed[E, C])(f: (A, B, C) ⇒ D): Managed[E, D]

def mapParN[E, A, B, C](managed1: Managed[E, A], managed2: Managed[E, B])(f: (A, B) ⇒ C): Managed[E, C]

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

See zio.ZManaged.mergeAll

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

See zio.ZManaged.mergeAllPar

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

See zio.ZManaged.mergeAllParN

final def ne(arg0: AnyRef): Boolean

val never: Managed[Nothing, Nothing]

See zio.ZManaged.never

final def notify(): Unit

final def notifyAll(): Unit

def reduceAll[E, A](a: Managed[E, A], as: Iterable[Managed[E, A]])(f: (A, A) ⇒ A): Managed[E, A]

See zio.ZManaged.reduceAll

def reduceAllPar[E, A](a: Managed[E, A], as: Iterable[Managed[E, A]])(f: (A, A) ⇒ A): Managed[E, A]

See zio.ZManaged.reduceAllPar

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

See zio.ZManaged.reduceAllParN

def require[E, A](error: ⇒ E): (Managed[E, Option[A]]) ⇒ Managed[E, A]

See zio.ZManaged.require

def reserve[E, A](reservation: Reservation[Any, E, A]): Managed[E, A]

See zio.ZManaged.reserve

def sandbox[E, A](v: Managed[E, A]): Managed[Cause[E], A]

See zio.ZManaged.sandbox

def succeed[A](r: ⇒ A): Managed[Nothing, A]

See zio.ZManaged.succeed

def suspend[E, A](managed: ⇒ Managed[E, A]): Managed[E, A]

See zio.ZManaged.suspend

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

def toString(): String

val unit: Managed[Nothing, Unit]

See zio.ZManaged.unit

def unsandbox[E, A](v: Managed[Cause[E], A]): Managed[E, A]

See zio.ZManaged.unsandbox

def unwrap[E, A](fa: IO[E, Managed[E, A]]): Managed[E, A]

See zio.ZManaged.unwrap

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when[E](b: ⇒ Boolean)(managed: Managed[E, Any]): Managed[E, Unit]

See zio.ZManaged.when

def whenCase[R, E, A](a: ⇒ A)(pf: PartialFunction[A, ZManaged[R, E, Any]]): ZManaged[R, E, Unit]

See zio.ZManaged.whenCase

def whenCaseM[R, E, A](a: ZManaged[R, E, A])(pf: PartialFunction[A, ZManaged[R, E, Any]]): ZManaged[R, E, Unit]

See zio.ZManaged.whenCaseM

def whenM[E](b: Managed[E, Boolean])(managed: Managed[E, Any]): Managed[E, Unit]

See zio.ZManaged.whenM

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

See zio.ZManaged.sequence

def sequencePar[E, A](as: Iterable[Managed[E, A]]): Managed[E, List[A]]

See zio.ZManaged.sequencePar

def sequenceParN[E, A](n: Int)(as: Iterable[Managed[E, A]]): Managed[E, List[A]]

See zio.ZManaged.sequenceParN

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

See zio.ZManaged.traverse

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

See zio.ZManaged.traversePar

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

See zio.ZManaged.traverseParN

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

See zio.ZManaged.traverseParN_

def traversePar_[E, A](as: Iterable[A])(f: (A) ⇒ Managed[E, Any]): Managed[E, Unit]

See zio.ZManaged.traversePar_

def traverse_[E, A](as: Iterable[A])(f: (A) ⇒ Managed[E, Any]): Managed[E, Unit]

See zio.ZManaged.traverse_