ZIO

Type Members

final class AccessMPartiallyApplied[R] extends AnyVal
final class AccessPartiallyApplied[R] extends AnyVal
final class BracketAcquire[-R, +E, +A] extends AnyVal
final class BracketAcquire_[-R, +E] extends AnyVal
final class BracketExitAcquire[-R, +E, +A] extends AnyVal
final class BracketExitRelease[-R, +E, E1, +A, B] extends AnyRef
final class BracketForkAcquire[-R, +E, +A] extends AnyVal
final class BracketForkAcquire_[-R, +E] extends AnyVal
final class BracketForkExitAcquire[-R, +E, +A] extends AnyVal
final class BracketForkExitRelease[-R, +E, E1, +A, B] extends AnyRef
final class BracketForkRelease[-R, +E, +A] extends AnyRef
final class BracketForkRelease_[-R, +E] extends AnyRef
final class BracketRelease[-R, +E, +A] extends AnyRef
final class BracketReleaseFn[R, E, A, B] extends ZIOFn2[A, Exit[E, B], URIO[R, Any]]
final class BracketRelease_[-R, +E] extends AnyRef
final class ConstFn[A, B] extends ZIOFn1[A, B]
final class ConstZIOFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]
final class FoldCauseMFailureFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, A]]
final class IfM[R, E] extends AnyVal
final class InterruptStatusRestore extends AnyVal
final class MapErrorCauseFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, Nothing]]
final class MapErrorFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, Nothing]]
final class MapFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]
final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
final class SucceedFn[R, E, A] extends ZIOFn1[A, ZIO[R, E, A]]
final class TapCauseRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]
final class TapErrorRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]
final class TapFn[R, E, A] extends ZIOFn1[A, ZIO[R, E, A]]
final class TimeoutTo[R, E, A, B] extends AnyRef
implicit final class ZIOAutocloseableOps[R, E, A <: AutoCloseable] extends AnyVal
implicit final class ZIOWithFilterOps[R, E, A] extends AnyVal
implicit final class ZioRefineToOrDieOps[R, E <: Throwable, A] extends AnyVal
final class ZipLeftFn[R, E, A, B] extends ZIOFn1[B, ZIO[R, E, B]]
final class ZipRightFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]

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: ZIO[R, E, Either[E, A]]): ZIO[R, E, A]

Submerges the error case of an Either into the ZIO.
Submerges the error case of an Either into the ZIO. The inverse operation of IO.either.
def access[R]: AccessPartiallyApplied[R]

Accesses the environment of the effect.
Accesses the environment of the effect.
```
val portNumber = effect.access(_.config.portNumber)
```
def accessM[R]: AccessMPartiallyApplied[R]

Effectfully accesses the environment of the effect.
def allowInterrupt: UIO[Unit]

Makes an explicit check to see if the fiber has been interrupted, and if so, performs self-interruption
def apply[A](a: ⇒ A): Task[A]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def awaitAllChildren: UIO[Unit]

Awaits all child fibers of the fiber executing the effect.
def bracket[R, E, A, B](acquire: ZIO[R, E, A], release: (A) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

Uncurried version.
Uncurried version. Doesn't offer curried syntax and have worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketAcquire and zio.ZIO.BracketRelease objects.
def bracket[R, E, A](acquire: ZIO[R, E, A]): BracketAcquire[R, E, A]

When this effect represents acquisition of a resource (for example, opening a file, launching a thread, etc.), bracket can be used to ensure the acquisition is not interrupted and the resource is always released.
When this effect represents acquisition of a resource (for example, opening a file, launching a thread, etc.), bracket can be used to ensure the acquisition is not interrupted and the resource is always released.
The function does two things:
1. Ensures this effect, which acquires the resource, will not be interrupted. Of course, acquisition may fail for internal reasons (an uncaught exception). 2. Ensures the release effect will not be interrupted, and will be executed so long as this effect successfully acquires the resource.
In between acquisition and release of the resource, the use effect is executed.
If the release effect fails, then the entire effect will fail even if the use effect succeeds. If this fail-fast behavior is not desired, errors produced by the release effect can be caught and ignored.
```
openFile("data.json").bracket(closeFile) { file =>
  for {
    header <- readHeader(file)
    ...
  } yield result
}
```
def bracketExit[R, E, A, B](acquire: ZIO[R, E, A], release: (A, Exit[E, B]) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

Uncurried version.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketExitAcquire and zio.ZIO.BracketExitRelease objects.
def bracketExit[R, E, A](acquire: ZIO[R, E, A]): BracketExitAcquire[R, E, A]

Acquires a resource, uses the resource, and then releases the resource.
Acquires a resource, uses the resource, and then releases the resource. Neither the acquisition nor the release will be interrupted, and the resource is guaranteed to be released, so long as the acquire effect succeeds. If use fails, then after release, the returned effect will fail with the same error.
def checkInterruptible[R, E, A](f: (zio.InterruptStatus) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Checks the interrupt status, and produces the effect returned by the specified callback.
def checkTraced[R, E, A](f: (zio.TracingStatus) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Checks the ZIO Tracing status, and produces the effect returned by the specified callback.
def children: UIO[Iterable[Fiber[Any, Any]]]

Provides access to the list of child fibers supervised by this fiber.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collectAll[R, E, A](in: Iterable[ZIO[R, E, A]]): ZIO[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[ZIO[R, E, A]]): ZIO[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[ZIO[R, E, A]]): ZIO[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 collectAllSuccesses[R, E, A](in: Iterable[ZIO[R, E, A]]): URIO[R, List[A]]

Evaluate and run each effect in the structure and collect discarding failed ones.
def collectAllSuccessesPar[R, E, A](in: Iterable[ZIO[R, E, A]]): URIO[R, List[A]]

Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
def collectAllSuccessesParN[R, E, A](n: Int)(in: Iterable[ZIO[R, E, A]]): URIO[R, List[A]]

Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
Unlike collectAllSuccessesPar, this method will use at most up to n fibers.
def collectAllWith[R, E, A, U](in: Iterable[ZIO[R, E, A]])(f: PartialFunction[A, U]): ZIO[R, E, List[U]]

Evaluate each effect in the structure with collectAll, and collect the results with given partial function.
def collectAllWithPar[R, E, A, U](in: Iterable[ZIO[R, E, A]])(f: PartialFunction[A, U]): ZIO[R, E, List[U]]

Evaluate each effect in the structure with collectAllPar, and collect the results with given partial function.
def collectAllWithParN[R, E, A, U](n: Int)(in: Iterable[ZIO[R, E, A]])(f: PartialFunction[A, U]): ZIO[R, E, List[U]]

Evaluate each effect in the structure with collectAllPar, and collect the results with given partial function.
Evaluate each effect in the structure with collectAllPar, and collect the results with given partial function.
Unlike collectAllWithPar, this method will use at most up to n fibers.
def descriptor: UIO[Fiber.Descriptor]

Returns information about the current fiber, such as its identity.
def descriptorWith[R, E, A](f: (Fiber.Descriptor) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Constructs an effect based on information about the current fiber, such as its identity.
def die(t: ⇒ Throwable): UIO[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): UIO[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 disown(fiber: Fiber[Any, Any]): UIO[Boolean]

Disowns the specified fiber, which means that when this fiber exits, the specified fiber will not be interrupted.
Disowns the specified fiber, which means that when this fiber exits, the specified fiber will not be interrupted. Disowned fibers become new root fibers, and are not terminated automatically when any other fibers ends.
val disownChildren: UIO[Boolean]

Disowns all children.
def done[E, A](r: ⇒ Exit[E, A]): IO[E, A]

Returns an effect from a zio.Exit value.
def effect[A](effect: ⇒ A): Task[A]

Imports a synchronous side-effect into a pure ZIO value, translating any thrown exceptions into typed failed effects creating with ZIO.fail.
Imports a synchronous side-effect into a pure ZIO value, translating any thrown exceptions into typed failed effects creating with ZIO.fail.
```
def putStrLn(line: String): Task[Unit] = Task.effect(println(line))
```
def effectAsync[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Unit, blockingOn: List[Id] = Nil): ZIO[R, E, A]

Imports an asynchronous side-effect into a pure ZIO value.
Imports an asynchronous side-effect into a pure ZIO value. See effectAsyncMaybe for the more expressive variant of this function that can return a value synchronously.
The callback function ZIO[R, E, A] => Unit must be called at most once.
The list of fibers, that may complete the async callback, is used to provide better diagnostics.
def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Either[Canceler[R], ZIO[R, E, A]], blockingOn: List[Id] = Nil): ZIO[R, E, A]

Imports an asynchronous side-effect into a ZIO effect.
Imports an asynchronous side-effect into a ZIO effect. The side-effect has the option of returning the value synchronously, which is useful in cases where it cannot be determined if the effect is synchronous or asynchronous until the side-effect is actually executed. The effect also has the option of returning a canceler, which will be used by the runtime to cancel the asynchronous effect if the fiber executing the effect is interrupted.
If the register function returns a value synchronously, then the callback function ZIO[R, E, A] => Unit must not be called. Otherwise the callback function must be called at most once.
The list of fibers, that may complete the async callback, is used to provide better diagnostics.
def effectAsyncM[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ ZIO[R, E, Any]): ZIO[R, E, A]

Imports an asynchronous effect into a pure ZIO value.
Imports an asynchronous effect into a pure ZIO value. This formulation is necessary when the effect is itself expressed in terms of ZIO.
def effectAsyncMaybe[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Option[ZIO[R, E, A]], blockingOn: List[Id] = Nil): ZIO[R, E, A]

Imports an asynchronous effect into a pure ZIO value, possibly returning the value synchronously.
Imports an asynchronous effect into a pure ZIO value, possibly returning the value synchronously.
If the register function returns a value synchronously, then the callback function ZIO[R, E, A] => Unit must not be called. Otherwise the callback function must be called at most once.
The list of fibers, that may complete the async callback, is used to provide better diagnostics.
def effectSuspend[R, A](rio: ⇒ RIO[R, A]): RIO[R, A]

Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. When no environment is required (i.e., when R == Any) it is conceptually equivalent to flatten(effect(io)).
def effectSuspendTotal[R, E, A](zio: ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == Any) it is conceptually equivalent to flatten(effectTotal(zio)). If you wonder if the effect throws exceptions, do not use this method, use Task.effectSuspend or ZIO.effectSuspend.
def effectSuspendTotalWith[R, E, A](f: (Platform, Id) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == Any) it is conceptually equivalent to flatten(effectTotal(zio)). If you wonder if the effect throws exceptions, do not use this method, use Task.effectSuspend or ZIO.effectSuspend.
def effectSuspendWith[R, A](f: (Platform, Id) ⇒ RIO[R, A]): RIO[R, A]

Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. When no environment is required (i.e., when R == Any) it is conceptually equivalent to flatten(effect(io)).
def effectTotal[A](effect: ⇒ A): UIO[A]

Imports a total synchronous effect into a pure ZIO value.
Imports a total synchronous effect into a pure ZIO value. The effect must not throw any exceptions. If you wonder if the effect throws exceptions, then do not use this method, use Task.effect, IO.effect, or ZIO.effect.
```
val nanoTime: UIO[Long] = IO.effectTotal(System.nanoTime())
```
def environment[R]: URIO[R, 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): IO[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: UIO[Id]

Returns the Fiber.Id of the fiber executing the effect that calls this method.
def filter[R, E, A](as: Iterable[A])(f: (A) ⇒ ZIO[R, E, Boolean]): ZIO[R, E, List[A]]

Filters the collection using the specified effectual predicate.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def first[E, A, B]: ZIO[(A, B), E, A]

Returns an effectful function that extracts out the first element of a tuple.
def firstSuccessOf[R, R1 <: R, E, A](zio: ZIO[R, E, A], rest: Iterable[ZIO[R1, E, A]]): ZIO[R1, E, A]

Returns an effect that races this effect with all the specified effects, yielding the value of the first effect to succeed with a value.
Returns an effect that races this effect with all the specified effects, yielding the value of the first effect to succeed with a value. Losers of the race will be interrupted immediately
def flatten[R, E, A](zio: ZIO[R, E, ZIO[R, E, A]]): ZIO[R, E, A]

Returns an effect that first executes the outer effect, and then executes the inner effect, returning the value from the inner effect, and effectively flattening a nested effect.
def foldLeft[R, E, S, A](in: Iterable[A])(zero: S)(f: (S, A) ⇒ ZIO[R, E, S]): ZIO[R, E, S]

Folds an Iterable[A] using an effectual function f, working sequentially from left to right.
def foldRight[R, E, S, A](in: Iterable[A])(zero: S)(f: (A, S) ⇒ ZIO[R, E, S]): ZIO[R, E, S]

Folds an Iterable[A] using an effectual function f, working sequentially from right to left.
final def foreach[R, E, A, B](in: Chunk[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Chunk[B]]

Applies the function f to each element of the Chunk[A] and returns the results in a new Chunk[B].
Applies the function f to each element of the Chunk[A] and returns the results in a new Chunk[B].
For a parallel version of this method, see foreachPar.
final def foreach[R, E, A, B](in: Option[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Option[B]]

Applies the function f if the argument is non-empty and returns the results in a new Option[B].
def foreach[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, List[B]]

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, A, B](as: Chunk[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Chunk[B]]

Applies the function f to each element of the Chunk[A] in parallel, and returns the results in a new Chunk[B].
Applies the function f to each element of the Chunk[A] in parallel, and returns the results in a new Chunk[B].
For a sequential version of this method, see foreach.
def foreachPar[R, E, A, B](as: Iterable[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, List[B]]

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, A, B](n: Int)(as: Iterable[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, List[B]]

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) ⇒ ZIO[R, E, Any]): ZIO[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: Chunk[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[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 foreachPar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[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_.
Optimized to avoid keeping full tree of effects, so that method could be able to handle large input sequences. Behaves almost like this code:
```
as.foldLeft(ZIO.unit) { (acc, a) => acc.zipParLeft(f(a)) }
```
Additionally, interrupts all effects on any failure.
final def foreach_[R, E, A](as: Chunk[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]

Applies the function f to each element of the Chunk[A] and returns the results in a new Chunk[B].
Applies the function f to each element of the Chunk[A] and returns the results in a new Chunk[B].
For a parallel version of this method, see foreachPar.
def foreach_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[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 forkAll[R, E, A](as: Iterable[ZIO[R, E, A]]): URIO[R, Fiber[E, List[A]]]

Returns an effect that forks all of the specified values, and returns a composite fiber that produces a list of their results, in order.
def forkAll_[R, E, A](as: Iterable[ZIO[R, E, A]]): URIO[R, Unit]

Returns an effect that forks all of the specified values, and returns a composite fiber that produces unit.
Returns an effect that forks all of the specified values, and returns a composite fiber that produces unit. This version is faster than forkAll in cases where the results of the forked fibers are not needed.
def fromEither[E, A](v: ⇒ Either[E, A]): IO[E, A]

Lifts an Either into a ZIO value.
def fromFiber[E, A](fiber: ⇒ Fiber[E, A]): IO[E, A]

Creates a ZIO value that represents the exit value of the specified fiber.
def fromFiberM[E, A](fiber: IO[E, Fiber[E, A]]): IO[E, A]

Creates a ZIO value that represents the exit value of the specified fiber.
def fromFunction[R, A](f: (R) ⇒ A): URIO[R, A]

Lifts a function R => A into a URIO[R, A].
def fromFunctionFuture[R, A](f: (R) ⇒ Future[A]): RIO[R, A]

Lifts a function returning Future into an effect that requires the input to the function.
def fromFunctionM[R, E, A](f: (R) ⇒ IO[E, A]): ZIO[R, E, A]

Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.
def fromFuture[A](make: (ExecutionContext) ⇒ Future[A]): Task[A]

Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a ZIO.
def fromFutureInterrupt[A](make: (ExecutionContext) ⇒ Future[A]): Task[A]

Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a ZIO.
Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a ZIO. The provided ExecutionContext will interrupt the Future between asynchronous operations such as map and flatMap if this effect is interrupted. Note that no attempt will be made to interrupt a Future blocking on a synchronous operation and that the Future must be created using the provided ExecutionContext.
def fromOption[A](v: ⇒ Option[A]): IO[Unit, A]

Lifts an Option into a ZIO.
def fromTry[A](value: ⇒ Try[A]): Task[A]

Lifts a Try into a ZIO.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def getOrFail[A](v: ⇒ Option[A]): Task[A]

Lifts an Option into a ZIO, if the option is not defined it fails with NoSuchElementException.
def halt[E](cause: ⇒ Cause[E]): IO[E, Nothing]

Returns an effect that models failure with the specified Cause.
def haltWith[E](function: (() ⇒ ZTrace) ⇒ Cause[E]): IO[E, Nothing]

Returns an effect that models failure with the specified Cause.
Returns an effect that models failure with the specified Cause.
This version takes in a lazily-evaluated trace that can be attached to the Cause via Cause.Traced.
def hashCode(): Int

Definition Classes
AnyRef → Any
def identity[R]: URIO[R, R]

Returns the identity effectful function, which performs no effects
def ifM[R, E](b: ZIO[R, E, Boolean]): IfM[R, E]

Runs onTrue if the result of b is true and onFalse otherwise.
val infinity: URIO[Clock, Nothing]

Like never, but fibers that running this effect won't be garbage collected unless interrupted.
val interrupt: UIO[Nothing]

Returns an effect that is interrupted as if by the fiber calling this method.
def interruptAllChildren: UIO[Unit]

Interrupts all child fibers of the fiber executing the effect.
def interruptAs(fiberId: ⇒ Id): UIO[Nothing]

Returns an effect that is interrupted as if by the specified fiber.
def interruptible[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]

Prefix form of ZIO#interruptible.
def interruptibleMask[R, E, A](k: (InterruptStatusRestore) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Makes the effect interruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterate[R, E, S](initial: S)(cont: (S) ⇒ Boolean)(body: (S) ⇒ ZIO[R, E, S]): ZIO[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 left[A](a: ⇒ A): UIO[Either[A, Nothing]]

Returns an effect with the value on the left part.
def lock[R, E, A](executor: ⇒ Executor)(zio: ZIO[R, E, A]): ZIO[R, E, A]

Returns an effect that will execute the specified effect fully on the provided executor, before returning to the default executor.
Returns an effect that will execute the specified effect fully on the provided executor, before returning to the default executor. See ZIO!.lock.
def loop[R, E, A, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ ZIO[R, E, A]): ZIO[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) ⇒ ZIO[R, E, Any]): ZIO[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 mapN[R, E, A, B, C, D, F](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C], zio4: ZIO[R, E, D])(f: (A, B, C, D) ⇒ F): ZIO[R, E, F]

Sequentially zips the specified effects using the specified combiner function.
def mapN[R, E, A, B, C, D](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C])(f: (A, B, C) ⇒ D): ZIO[R, E, D]

Sequentially zips the specified effects using the specified combiner function.
def mapN[R, E, A, B, C](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B])(f: (A, B) ⇒ C): ZIO[R, E, C]

Sequentially zips the specified effects using the specified combiner function.
def mapParN[R, E, A, B, C, D, F](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C], zio4: ZIO[R, E, D])(f: (A, B, C, D) ⇒ F): ZIO[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](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C])(f: (A, B, C) ⇒ D): ZIO[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](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B])(f: (A, B) ⇒ C): ZIO[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[ZIO[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZIO[R, E, B]

Merges an Iterable[IO] to a single IO, working sequentially.
def mergeAllPar[R, E, A, B](in: Iterable[ZIO[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZIO[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.
It's unsafe to execute side effects inside f, as f may be executed more than once for some of in elements during effect execution.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val never: UIO[Nothing]

Returns a effect that will never produce anything.
Returns a effect that will never produce anything. The moral equivalent of while(true) {}, only without the wasted CPU cycles. Fibers that suspended running this effect are automatically garbage collected on the JVM, because they cannot be reactivated.
val none: UIO[Option[Nothing]]

Returns an effect with the empty value.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def partition[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, Nothing, (List[E], List[B])]

Feeds elements of type A to a function f that returns an effect.
Feeds elements of type A to a function f that returns an effect. Collects all successes and failures in a tupled fashion.
def partitionPar[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, Nothing, (List[E], List[B])]

Feeds elements of type A to a function f that returns an effect.
Feeds elements of type A to a function f that returns an effect. Collects all successes and failures in parallel and returns the result as a tuple.
def partitionParN[R, E, A, B](n: Int)(in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, Nothing, (List[E], List[B])]

Feeds elements of type A to a function f that returns an effect.
Feeds elements of type A to a function f that returns an effect. Collects all successes and failures in parallel and returns the result as a tuple.
Unlike partitionPar, this method will use at most up to n fibers.
def provide[R, E, A](r: ⇒ R): (ZIO[R, E, A]) ⇒ IO[E, A]

Given an environment R, returns a function that can supply the environment to programs that require it, removing their need for any specific environment.
Given an environment R, returns a function that can supply the environment to programs that require it, removing their need for any specific environment.
This is similar to dependency injection, and the provide function can be thought of as inject.
def raceAll[R, R1 <: R, E, A](zio: ZIO[R, E, A], ios: Iterable[ZIO[R1, E, A]]): ZIO[R1, E, A]

Races an IO[E, A] against zero or more other effects.
Races an IO[E, A] against zero or more other effects. Yields either the first success or the last failure.
def reduceAll[R, R1 <: R, E, A](a: ZIO[R, E, A], as: Iterable[ZIO[R1, E, A]])(f: (A, A) ⇒ A): ZIO[R1, E, A]

Reduces an Iterable[IO] to a single IO, working sequentially.
def reduceAllPar[R, R1 <: R, E, A](a: ZIO[R, E, A], as: Iterable[ZIO[R1, E, A]])(f: (A, A) ⇒ A): ZIO[R1, E, A]

Reduces an Iterable[IO] to a single IO, working in parallel.
def replicate[R, E, A](n: Int)(effect: ZIO[R, E, A]): Iterable[ZIO[R, E, A]]

Replicates the given effect n times.
Replicates the given effect n times. If 0 or negative numbers are given, an empty Iterable will be returned. This method is more efficient than using List.fill or similar methods, because the returned Iterable consumes only a small amount of heap regardless of n.
def require[R, E, A](error: ⇒ E): (ZIO[R, E, Option[A]]) ⇒ ZIO[R, E, A]

Requires that the given ZIO[R, E, Option[A]] contain a value.
Requires that the given ZIO[R, E, Option[A]] contain a value. If there is no value, then the specified error will be raised.
def reserve[R, E, A, B](reservation: ZIO[R, E, Reservation[R, E, A]])(use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

Acquires a resource, uses the resource, and then releases the resource.
Acquires a resource, uses the resource, and then releases the resource. However, unlike bracket, the separation of these phases allows the acquisition to be interruptible.
Useful for concurrent data structures and other cases where the 'deallocator' can tell if the allocation succeeded or not just by inspecting internal / external state.
def right[B](b: ⇒ B): UIO[Either[Nothing, B]]

Returns an effect with the value on the right part.
def runtime[R]: URIO[R, Runtime[R]]

Returns an effect that accesses the runtime, which can be used to (unsafely) execute tasks.
Returns an effect that accesses the runtime, which can be used to (unsafely) execute tasks. This is useful for integration with legacy code that must call back into ZIO code.
def second[E, A, B]: ZIO[(A, B), E, B]

Returns an effectful function that extracts out the second element of a tuple.
def sleep(duration: ⇒ Duration): URIO[Clock, Unit]

Returns an effect that suspends for the specified duration.
Returns an effect that suspends for the specified duration. This method is asynchronous, and does not actually block the fiber executing the effect.
def some[A](a: ⇒ A): UIO[Option[A]]

Returns an effect with the optional value.
def succeed[A](a: ⇒ A): UIO[A]

Returns an effect that models success with the specified value.
def swap[E, A, B]: ZIO[(A, B), 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
def trace: UIO[ZTrace]

Capture ZIO trace at the current point
def traced[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]

Prefix form of ZIO#traced.
def uninterruptible[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]

Prefix form of ZIO#uninterruptible.
def uninterruptibleMask[R, E, A](k: (InterruptStatusRestore) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

Makes the effect uninterruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
val unit: UIO[Unit]

An effect that succeeds with a unit value.
def unsandbox[R, E, A](v: ZIO[R, Cause[E], A]): ZIO[R, E, A]

The inverse operation IO.sandboxed
The inverse operation IO.sandboxed
Terminates with exceptions on the Left side of the Either error, if it exists. Otherwise extracts the contained IO[E, A]
def untraced[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]

Prefix form of ZIO#untraced.
def validate[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, ::[E], List[B]]

Feeds elements of type A to f and accumulates all errors in error channel or successes in success channel.
Feeds elements of type A to f and accumulates all errors in error channel or successes in success channel.
This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partition.
def validateFirst[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, List[E], B]

Feeds elements of type A to f until it succeeds.
Feeds elements of type A to f until it succeeds. Returns first success or the accumulation of all errors.
def validateFirstPar[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, List[E], B]

Feeds elements of type A to f, in parallel, until it succeeds.
Feeds elements of type A to f, in parallel, until it succeeds. Returns first success or the accumulation of all errors.
In case of success all other running fibers are terminated.
def validatePar[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, ::[E], List[B]]

Feeds elements of type A to f and accumulates, in parallel, all errors in error channel or successes in success channel.
Feeds elements of type A to f and accumulates, in parallel, all errors in error channel or successes in success channel.
This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partitionPar.
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)(zio: ZIO[R, E, Any]): ZIO[R, E, Unit]

The moral equivalent of if (p) exp
def whenCase[R, E, A](a: ⇒ A)(pf: PartialFunction[A, ZIO[R, E, Any]]): ZIO[R, E, Unit]

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

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

The moral equivalent of if (p) exp when p has side-effects
val yieldNow: UIO[Unit]

Returns an effect that yields to the runtime system, starting on a fresh stack.
Returns an effect that yields to the runtime system, starting on a fresh stack. Manual use of this method can improve fairness, at the cost of overhead.

Deprecated Value Members

def bracketFork[R, E, A, B](acquire: ZIO[R, E, A], release: (A) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

Uncurried version of bracketFork.
Uncurried version of bracketFork. Doesn't offer curried syntax and has worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketForkAcquire and zio.ZIO.BracketForkRelease objects.

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO#disconnect on an ordinary bracket
def bracketFork[R, E, A](acquire: ZIO[R, E, A]): BracketForkAcquire[R, E, A]

A variant of bracket which returns immediately on interruption.
A variant of bracket which returns immediately on interruption. however, it does not actually interrupt the underlying acquisition, but rather, in a separate fiber, awaits the acquisition and then gracefully and immediately releases the resource after acquisition. Thus the fiber executing bracketFork is able to be interrupted right away even if in the middle of a lengthy acquisition operation.

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO#disconnect on an ordinary bracket
def bracketForkExit[R, E, A, B](acquire: ZIO[R, E, A], release: (A, Exit[E, B]) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

Uncurried version of bracketForkExit.
Uncurried version of bracketForkExit. Doesn't offer curried syntax and has worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketForkExitAcquire and zio.ZIO.BracketForkExitRelease objects.

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO#disconnect on an ordinary bracket
def bracketForkExit[R, E, A](acquire: ZIO[R, E, A]): BracketForkExitAcquire[R, E, A]

A variant of bracketExit which returns immediately on interruption.
A variant of bracketExit which returns immediately on interruption. However, it does not actually interrupt the underlying acquisition, but rather, in a separate fiber, awaits the acquisition and then gracefully and immediately releases the resource after acquisition.

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO#disconnect on an ordinary bracket
def sequence[R, E, A](in: Iterable[ZIO[R, E, A]]): ZIO[R, E, List[A]]

Alias for ZIO.collectAll
Alias for ZIO.collectAll

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

Alias for ZIO.collectAllPar
Alias for ZIO.collectAllPar

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

Alias for ZIO.collectAllParN
Alias for ZIO.collectAllParN

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO.collectAllParN
def traverse[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, List[B]]

Alias for ZIO.foreach[R,E,A,B](in:Iterable*
Alias for ZIO.foreach[R,E,A,B](in:Iterable*

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO.foreach
def traversePar[R, E, A, B](as: Iterable[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, List[B]]

Alias for ZIO.foreachPar[R,E,A,B](as:Iterable*
Alias for ZIO.foreachPar[R,E,A,B](as:Iterable*

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO.foreachPar
def traverseParN[R, E, A, B](n: Int)(as: Iterable[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, List[B]]

Alias for ZIO.foreachParN
Alias for ZIO.foreachParN

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

Alias for ZIO.foreachParN_
Alias for ZIO.foreachParN_

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

Alias for ZIO.foreachPar_[R,E,A](as:Iterable*
Alias for ZIO.foreachPar_[R,E,A](as:Iterable*

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

Alias for ZIO.foreach_[R,E,A](as:Iterable*
Alias for ZIO.foreach_[R,E,A](as:Iterable*

Annotations
@deprecated
Deprecated
(Since version 1.0.0) Use ZIO.foreach_

Related Docs: trait ZIO | package zio

object ZIO extends ZIOCompanionPlatformSpecific with Serializable

Type Members

final class AccessMPartiallyApplied[R] extends AnyVal

final class AccessPartiallyApplied[R] extends AnyVal

final class BracketAcquire[-R, +E, +A] extends AnyVal

final class BracketAcquire_[-R, +E] extends AnyVal

final class BracketExitAcquire[-R, +E, +A] extends AnyVal

final class BracketExitRelease[-R, +E, E1, +A, B] extends AnyRef

final class BracketForkAcquire[-R, +E, +A] extends AnyVal

final class BracketForkAcquire_[-R, +E] extends AnyVal

final class BracketForkExitAcquire[-R, +E, +A] extends AnyVal

final class BracketForkExitRelease[-R, +E, E1, +A, B] extends AnyRef

final class BracketForkRelease[-R, +E, +A] extends AnyRef

final class BracketForkRelease_[-R, +E] extends AnyRef

final class BracketRelease[-R, +E, +A] extends AnyRef

final class BracketReleaseFn[R, E, A, B] extends ZIOFn2[A, Exit[E, B], URIO[R, Any]]

final class BracketRelease_[-R, +E] extends AnyRef

final class ConstFn[A, B] extends ZIOFn1[A, B]

final class ConstZIOFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]

final class FoldCauseMFailureFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, A]]

final class IfM[R, E] extends AnyVal

final class InterruptStatusRestore extends AnyVal

final class MapErrorCauseFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, Nothing]]

final class MapErrorFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, Nothing]]

final class MapFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]

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

final class SucceedFn[R, E, A] extends ZIOFn1[A, ZIO[R, E, A]]

final class TapCauseRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]

final class TapErrorRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]

final class TapFn[R, E, A] extends ZIOFn1[A, ZIO[R, E, A]]

final class TimeoutTo[R, E, A, B] extends AnyRef

implicit final class ZIOAutocloseableOps[R, E, A <: AutoCloseable] extends AnyVal

implicit final class ZIOWithFilterOps[R, E, A] extends AnyVal

implicit final class ZioRefineToOrDieOps[R, E <: Throwable, A] extends AnyVal

final class ZipLeftFn[R, E, A, B] extends ZIOFn1[B, ZIO[R, E, B]]

final class ZipRightFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

def access[R]: AccessPartiallyApplied[R]

def accessM[R]: AccessMPartiallyApplied[R]

def allowInterrupt: UIO[Unit]

def apply[A](a: ⇒ A): Task[A]

final def asInstanceOf[T0]: T0

def awaitAllChildren: UIO[Unit]

def bracket[R, E, A, B](acquire: ZIO[R, E, A], release: (A) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

def bracket[R, E, A](acquire: ZIO[R, E, A]): BracketAcquire[R, E, A]

def bracketExit[R, E, A, B](acquire: ZIO[R, E, A], release: (A, Exit[E, B]) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]

def bracketExit[R, E, A](acquire: ZIO[R, E, A]): BracketExitAcquire[R, E, A]

def checkInterruptible[R, E, A](f: (zio.InterruptStatus) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

def checkTraced[R, E, A](f: (zio.TracingStatus) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

def children: UIO[Iterable[Fiber[Any, Any]]]

def clone(): AnyRef

def collectAll[R, E, A](in: Iterable[ZIO[R, E, A]]): ZIO[R, E, List[A]]

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

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

def collectAllSuccesses[R, E, A](in: Iterable[ZIO[R, E, A]]): URIO[R, List[A]]

def collectAllSuccessesPar[R, E, A](in: Iterable[ZIO[R, E, A]]): URIO[R, List[A]]

def collectAllSuccessesParN[R, E, A](n: Int)(in: Iterable[ZIO[R, E, A]]): URIO[R, List[A]]

def collectAllWith[R, E, A, U](in: Iterable[ZIO[R, E, A]])(f: PartialFunction[A, U]): ZIO[R, E, List[U]]

def collectAllWithPar[R, E, A, U](in: Iterable[ZIO[R, E, A]])(f: PartialFunction[A, U]): ZIO[R, E, List[U]]

def collectAllWithParN[R, E, A, U](n: Int)(in: Iterable[ZIO[R, E, A]])(f: PartialFunction[A, U]): ZIO[R, E, List[U]]

def descriptor: UIO[Fiber.Descriptor]

def descriptorWith[R, E, A](f: (Fiber.Descriptor) ⇒ ZIO[R, E, A]): ZIO[R, E, A]

def die(t: ⇒ Throwable): UIO[Nothing]

def dieMessage(message: ⇒ String): UIO[Nothing]

def disown(fiber: Fiber[Any, Any]): UIO[Boolean]

val disownChildren: UIO[Boolean]

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

def effect[A](effect: ⇒ A): Task[A]

def effectAsync[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Unit, blockingOn: List[Id] = Nil): ZIO[R, E, A]

def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Either[Canceler[R], ZIO[R, E, A]], blockingOn: List[Id] = Nil): ZIO[R, E, A]

def effectAsyncM[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ ZIO[R, E, Any]): ZIO[R, E, A]

def effectAsyncMaybe[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Option[ZIO[R, E, A]], blockingOn: List[Id] = Nil): ZIO[R, E, A]

def effectSuspend[R, A](rio: ⇒ RIO[R, A]): RIO[R, A]

def effectSuspendTotal[R, E, A](zio: ⇒ ZIO[R, E, A]): ZIO[R, E, A]