An integer that identifies the term in the ZIO sum type to which this instance belongs (e.g. IO.Tags.Succeed).

Returns an effect that executes both this effect and the specified effect, in parallel, specified effect result returned. If either side fails, then the other side will be interrupted, interrupted the result.

Returns an effect that executes both this effect and the specified effect, in parallel, this effect result returned. If either side fails, then the other side will be interrupted, interrupted the result.

Returns an effect that executes both this effect and the specified effect, in parallel, combining their results into a tuple. If either side fails, then the other side will be interrupted, interrupted the result.

Alias for flatMap.

val parsed = readFile("foo.txt") >>= parseFile

Returns an effect that submerges the error case of an Either into the ZIO. The inverse operation of ZIO.either.

Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but it doesn't allocate intermediate zio.ZIO.BracketAcquire_ and zio.ZIO.BracketRelease_ objects.

Recovers from all errors.

openFile("config.json").catchAll(_ => IO.succeed(defaultConfig))

Recovers from some or all of the error cases.

openFile("data.json").catchSome {
  case FileNotFoundException(_) => openFile("backup.json")
}

Returns an effect whose failure and success have been lifted into an Either.The resulting effect cannot fail, because the failure case has been exposed as part of the Either success case.

This method is useful for recovering from ZIO effects that may fail.

The error parameter of the returned ZIO is Nothing, since it is guaranteed the ZIO effect does not model failure.

Returns an effect that, if this effect _starts_ execution, then the specified finalizer is guaranteed to begin execution, whether this effect succeeds, fails, or is interrupted.

Finalizers offer very powerful guarantees, but they are low-level, and should generally not be used for releasing resources. For higher-level logic built on ensuring, see ZIO#bracket.

Returns an effect that models the execution of this effect, followed by the passing of its value to the specified continuation function k, followed by the effect that it returns.

val parsed = readFile("foo.txt").flatMap(file => parseFile(file))

Creates a composite effect that represents this effect followed by another one that may depend on the error produced by this one.

val parsed = readFile("foo.txt").flatMapError(error => logErrorToFile(error))

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.

Returns an effect that swaps the error/success cases. This allows you to use all methods on the error channel, possibly before flipping back.

Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.

This method has better performance than either since no intermediate value is allocated and does not require subsequent calls to flatMap to define the next effect.

The error parameter of the returned IO may be chosen arbitrarily, since it will depend on the IOs returned by the given continuations.

Repeats this effect forever (until the first error). For more sophisticated schedules, see the repeat method.

Returns an effect that forks this effect into its own separate fiber, returning the fiber immediately, without waiting for it to compute its value.

The returned fiber can be used to interrupt the forked fiber, await its result, or join the fiber. See zio.Fiber for more information.

for {
  fiber <- subtask.fork
  // Do stuff...
  a <- fiber.join
} yield a

Switches the interrupt status for this effect. If true is used, then the effect becomes interruptible (the default), while if false is used, then the effect becomes uninterruptible. These changes are compositional, so they only affect regions of the effect.

Performs this effect interruptibly. Because this is the default, this operation only has additional meaning if the effect is located within an uninterruptible section.

Returns an effect whose execution is locked to the specified executor. This is useful when an effect must be executued somewhere, for example: on a UI thread, inside a client library's thread pool, inside a blocking thread pool, inside a low-latency thread pool, or elsewhere.

Use of this method does not alter the execution semantics of other effects composed with this one, making it easy to compositionally reason about where effects are running.

Returns an effect with its error channel mapped using the specified function. This can be used to lift a "smaller" error into a "larger" error.

Runs the specified effect if this effect fails, providing the error to the effect if it exists. The provided effect will not be interrupted.

Provides some of the environment required to run this effect, leaving the remainder R0.

val effect: ZIO[Console with Logging, Nothing, Unit] = ???

effect.provideSome[Console](console =>
  new Console with Logging {
    val console = console
    val logging = new Logging {
      def log(line: String) = console.putStrLn(line)
    }
  }
)

An effectful version of provideSome, useful when the act of partial provision requires an effect.

val effect: ZIO[Console with Logging, Nothing, Unit] = ???

val r0: ZIO[Console, Nothing, Console with Logging] = ???

effect.provideSomeM(r0)

Returns an effect that races this effect with the specified effect, returning the first successful A from the faster side. If one effect succeeds, the other will be interrupted. If neither succeeds, then the effect will fail with some error.

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

Returns an effect that races this effect with the specified effect, yielding the first result to complete, whether by success or failure. If neither effect completes, then the composed effect will not complete.

Returns an effect that races this effect with the specified effect, yielding the first result to succeed. If neither effect succeeds, then the composed effect will fail with some error.

Attach a wrapping trace pointing to this location in case of error.

Useful when joining fibers to make the resulting trace mention the join point, otherwise only the traces of joined fibers are included.

for {
  badFiber <- UIO(1 / 0).fork
  _ <- badFiber.join.refailWithTrace
} yield ()

Repeats this effect with the specified schedule until the schedule completes, or until the first failure. Repeats are done in addition to the first execution so that io.repeat(Schedule.once) means "execute io and in case of success repeat io once".

Repeats this effect with the specified schedule until the schedule completes, or until the first failure. In the event of failure the progress to date, together with the error, will be passed to the specified handler.

Repeats this effect with the specified schedule until the schedule completes, or until the first failure. In the event of failure the progress to date, together with the error, will be passed to the specified handler.

Retries with the specified retry policy. Retries are done following the failure of the original io (up to a fixed maximum with once or recurs for example), so that that io.retry(Schedule.once) means "execute io and in case of failure, try again once".

Exposes the full cause of failure of this effect.

case class DomainError()

val veryBadIO: IO[DomainError, Unit] =
  IO.effectTotal(5 / 0) *> IO.fail(DomainError())

val caught: UIO[Unit] =
  veryBadIO.sandbox.catchAll {
    case Cause.Die(_: ArithmeticException) =>
      // Caught defect: divided by zero!
      IO.succeed(0)
    case Cause.Fail(e) =>
      // Caught error: DomainError!
      IO.succeed(0)
    case cause =>
      // Caught unknown defects, shouldn't recover!
      IO.halt(cause)
   *
  }

Companion helper to sandbox. Allows recovery, and partial recovery, from errors and defects alike, as in:

case class DomainError()

val veryBadIO: IO[DomainError, Unit] =
  IO.effectTotal(5 / 0) *> IO.fail(DomainError())

val caught: IO[DomainError, Unit] =
  veryBadIO.sandboxWith(_.catchSome {
    case Cause.Die(_: ArithmeticException)=>
      // Caught defect: divided by zero!
      IO.succeed(0)
  })

Using sandboxWith with catchSome is better than using io.sandbox.catchAll with a partial match, because in the latter, if the match fails, the original defects will be lost and replaced by a MatchError

Enables supervision for this effect. This will cause fibers forked by this effect to be tracked and will enable their inspection via ZIO.children.

Returns an effect that effectfully "peeks" at the success of this effect.

readFile("data.json").tap(putStrLn)

Returns an effect that effectfully "peeks" at the failure or success of this effect.

readFile("data.json").tapBoth(logError(_), logData(_))

Returns an effect that effectfully "peeks" at the failure of this effect.

readFile("data.json").tapError(logError(_))

Returns an effect that will timeout this effect, returning None if the timeout elapses before the effect has produced a value; and returning Some of the produced value otherwise.

If the timeout elapses without producing a value, the running effect will be safely interrupted

Returns an effect that will timeout this effect, returning either the default value if the timeout elapses before the effect has produced a value; and or returning the result of applying the function f to the success value of the effect.

If the timeout elapses without producing a value, the running effect will be safely interrupted

IO.succeed(1).timeoutTo(None)(Some(_))(1.second)

Returns an effect that keeps or breaks a promise based on the result of this effect. Synchronizes interruption, so if this effect is interrupted, the specified promise will be interrupted, too.

Enables ZIO tracing for this effect. Because this is the default, this operation only has an additional meaning if the effect is located within an untraced section, or the current fiber has been spawned by a parent inside an untraced section.

Toggles ZIO tracing support for this effect. If true is used, then the effect will accumulate traces, while if false is used, then tracing is disabled. These changes are compositional, so they only affect regions of the effect.

Performs this effect uninterruptibly. This will prevent the effect from being terminated externally, but the effect may fail for internal reasons (e.g. an uncaught error) or terminate due to defect.

Uninterruptible effects may recover from all failure causes (including interruption of an inner effect that has been made interruptible).

The inverse operation to sandbox. Submerges the full cause of failure.

Disables supervision for this effect. This will cause fibers forked by this effect to not be tracked or appear in the list returned by ZIO.children.

Disables ZIO tracing facilities for the duration of the effect.

Note: ZIO tracing is cached, as such after the first iteration it has a negligible effect on performance of hot-spots (Additional hash map lookup per flatMap). As such, using untraced sections is not guaranteed to result in a noticeable performance increase.

Returns an effect that executes both this effect and the specified effect, in parallel, combining their results with the specified f function. If either side fails, then the other side will be interrupted.

Returns the effect resulting from mapping the success of this effect to unit.