Packages

object ZIO extends ZIOCompanionPlatformSpecific with Serializable

Linear Supertypes
Serializable, ZIOCompanionPlatformSpecific, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZIO
  2. Serializable
  3. ZIOCompanionPlatformSpecific
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final class AccessPartiallyApplied[R] extends AnyVal
  2. final class AccessZIOPartiallyApplied[R] extends AnyVal
  3. final class Acquire[-R, +E, +A] extends AnyVal
  4. final class AcquireDiscard[-R, +E] extends AnyVal
  5. final class AcquireExit[-R, +E, +A] extends AnyVal
  6. abstract class CanFilter[+E] extends AnyRef
    Annotations
    @implicitNotFound()
  7. final class ForkScopeRestore extends AnyVal
  8. final class GetStateWithPartiallyApplied[S] extends AnyVal
  9. final class Grafter extends AnyVal
  10. final class IfZIO[R, E] extends AnyVal
  11. final class InterruptStatusRestore extends AnyVal
  12. final class LogSpan extends AnyVal
  13. final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal
  14. final class Release[-R, +E, +A] extends AnyRef
  15. final class ReleaseDiscard[-R, +E] extends AnyRef
  16. final class ReleaseExit[-R, +E, E1, +A, B] extends AnyRef
  17. final class ServiceAtPartiallyApplied[Service] extends AnyVal
  18. final class ServiceWithPartiallyApplied[Service] extends AnyVal
  19. final class TimeoutTo[-R, +E, +A, +B] extends AnyRef
  20. final class UnlessZIO[R, E] extends AnyVal
  21. final class UpdateService[-R, +E, +A, M] extends AnyVal
  22. final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal
  23. final class WhenZIO[R, E] extends AnyVal
  24. implicit final class ZIOAutoCloseableOps[R, E, A <: AutoCloseable] extends AnyVal
  25. sealed trait ZIOConstructor[-Environment, +Error, In] extends AnyRef

    A ZIOConstructor[Input] knows how to construct a ZIO value from an input of type Input.

    A ZIOConstructor[Input] knows how to construct a ZIO value from an input of type Input. This allows the type of the ZIO value constructed to depend on Input. The constructed ZIO value is guaranteed not to require any services not included in Environment or to be able to fail in any ways not described by Error.

  26. trait ZIOConstructorLowPriority1 extends ZIOConstructorLowPriority2
  27. trait ZIOConstructorLowPriority2 extends ZIOConstructorLowPriority3
  28. trait ZIOConstructorLowPriority3 extends AnyRef
  29. implicit final class ZIOWithFilterOps[R, E, A] extends AnyVal
  30. implicit final class ZioRefineToOrDieOps[R, E <: Throwable, A] extends AnyVal

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final lazy val Parallelism: FiberRef[Option[Int]]

    The level of parallelism for parallel operators.

  5. def absolve[R, E, A](v: => ZIO[R, E, Either[E, A]])(implicit trace: ZTraceElement): 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.

  6. def access[R]: AccessPartiallyApplied[R]

    Accesses the environment of the effect.

    Accesses the environment of the effect.

    val portNumber = effect.access(_.config.portNumber)
  7. def accessZIO[R]: AccessZIOPartiallyApplied[R]

    Effectfully accesses the environment of the effect.

  8. def acquireReleaseExitWith[R, E, A, B](acquire: => ZIO[R, E, A], release: (A, Exit[E, B]) => URIO[R, Any], use: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): 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.AcquireExit and zio.ZIO.ReleaseExit objects.

  9. def acquireReleaseExitWith[R, E, A](acquire: => ZIO[R, E, A]): AcquireExit[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.

  10. def acquireReleaseWith[R, E, A, B](acquire: => ZIO[R, E, A], release: (A) => URIO[R, Any], use: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): 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.Acquire and zio.ZIO.Release objects.

  11. def acquireReleaseWith[R, E, A](acquire: => ZIO[R, E, A]): Acquire[R, E, A]

    When this effect represents acquisition of a resource (for example, opening a file, launching a thread, etc.), acquireReleaseWith 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.), acquireReleaseWith 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").acquireReleaseWith(closeFile) { file =>
      for {
        header <- readHeader(file)
        ...
      } yield result
    }
  12. def allowInterrupt(implicit trace: ZTraceElement): UIO[Unit]

    Makes an explicit check to see if the fiber has been interrupted, and if so, performs self-interruption

  13. def apply[A](a: => A)(implicit trace: ZTraceElement): Task[A]
  14. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  15. def async[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Any, blockingOn: => FiberId = FiberId.None)(implicit trace: ZTraceElement): 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 asyncMaybe for the more expressive variant of this function that can return a value synchronously.

    The callback function ZIO[R, E, A] => Any must be called at most once.

    The list of fibers, that may complete the async callback, is used to provide better diagnostics.

  16. def asyncInterrupt[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Either[Canceler[R], ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: ZTraceElement): 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] => Any 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.

  17. def asyncMaybe[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Option[ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: ZTraceElement): 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] => Any 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.

  18. def asyncWithCompletionHandler[T](op: (CompletionHandler[T, Any]) => Any)(implicit trace: ZTraceElement): Task[T]
    Definition Classes
    ZIOCompanionPlatformSpecific
  19. def asyncZIO[R, E, A](register: ((ZIO[R, E, A]) => Unit) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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.

  20. def attempt[A](effect: => A)(implicit trace: ZTraceElement): 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 printLine(line: String): Task[Unit] = Task.attempt(println(line))
  21. def attemptBlocking[A](effect: => A)(implicit trace: ZTraceElement): Task[A]

    Imports a synchronous effect that does blocking IO into a pure value.

  22. def attemptBlockingCancelable[R, A](effect: => A)(cancel: => URIO[R, Any])(implicit trace: ZTraceElement): RIO[R, A]

    Imports a synchronous effect that does blocking IO into a pure value, with a custom cancel effect.

    Imports a synchronous effect that does blocking IO into a pure value, with a custom cancel effect.

    If the returned ZIO is interrupted, the blocked thread running the synchronous effect will be interrupted via the cancel effect.

  23. def attemptBlockingIO[A](effect: => A)(implicit trace: ZTraceElement): IO[IOException, A]

    Imports a synchronous effect that does blocking IO into a pure value, refining the error type to java.io.IOException.

  24. def attemptBlockingInterrupt[A](effect: => A)(implicit trace: ZTraceElement): Task[A]

    Imports a synchronous effect that does blocking IO into a pure value.

    Imports a synchronous effect that does blocking IO into a pure value.

    If the returned ZIO is interrupted, the blocked thread running the synchronous effect will be interrupted via Thread.interrupt.

    Note that this adds significant overhead. For performance sensitive applications consider using attemptBlocking or attemptBlockingCancelable.

  25. def blocking[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Locks the specified effect to the blocking thread pool.

  26. def blockingExecutor(implicit trace: ZTraceElement): UIO[Executor]

    Retrieves the executor for all blocking tasks.

  27. def checkInterruptible[R, E, A](f: (zio.InterruptStatus) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Checks the interrupt status, and produces the effect returned by the specified callback.

  28. def checkTraced[R, E, A](f: (zio.TracingStatus) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Checks the ZIO Tracing status, and produces the effect returned by the specified callback.

  29. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  30. def collect[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, Option[E], (Key2, Value2)])(implicit trace: ZTraceElement): ZIO[R, E, Map[Key2, Value2]]

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases. For a parallel version, see collectPar.

  31. def collect[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases. For a parallel version, see collectPar.

  32. def collectAll[R, E, A](in: NonEmptyChunk[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[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.

  33. def collectAll[R, E, A](in: Option[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Option[A]]

    Evaluate effect if present, and return its result as Option[A].

  34. def collectAll[R, E, A](in: Array[ZIO[R, E, A]])(implicit arg0: ClassTag[A], trace: ZTraceElement): ZIO[R, E, Array[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.

  35. def collectAll[R, E, A](in: Set[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Set[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.

  36. def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](in: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[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.

  37. def collectAllDiscard[R, E, A](in: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Evaluate each effect in the structure from left to right, and discard the results.

    Evaluate each effect in the structure from left to right, and discard the results. For a parallel version, see collectAllParDiscard.

  38. def collectAllPar[R, E, A](as: NonEmptyChunk[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[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.

  39. def collectAllPar[R, E, A](as: Array[ZIO[R, E, A]])(implicit arg0: ClassTag[A], trace: ZTraceElement): ZIO[R, E, Array[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.

  40. def collectAllPar[R, E, A](as: Set[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Set[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.

  41. def collectAllPar[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[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.

  42. def collectAllParDiscard[R, E, A](as: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAllDiscard.

  43. def collectAllSuccesses[R, E, A, Collection[+Element] <: Iterable[Element]](in: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): URIO[R, Collection[A]]

    Evaluate and run each effect in the structure and collect discarding failed ones.

  44. def collectAllSuccessesPar[R, E, A, Collection[+Element] <: Iterable[Element]](in: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): URIO[R, Collection[A]]

    Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.

  45. def collectAllWith[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[ZIO[R, E, A]])(f: PartialFunction[A, B])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Evaluate each effect in the structure with collectAll, and collect the results with given partial function.

  46. def collectAllWithPar[R, E, A, U, Collection[+Element] <: Iterable[Element]](in: Collection[ZIO[R, E, A]])(f: PartialFunction[A, U])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], U, Collection[U]], trace: ZTraceElement): ZIO[R, E, Collection[U]]

    Evaluate each effect in the structure with collectAllPar, and collect the results with given partial function.

  47. def collectFirst[R, E, A, B](as: => Iterable[A])(f: (A) => ZIO[R, E, Option[B]])(implicit trace: ZTraceElement): ZIO[R, E, Option[B]]

    Collects the first element of the Iterable[A] for which the effectual function f returns Some.

  48. def collectPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, Option[E], (Key2, Value2)])(implicit trace: ZTraceElement): ZIO[R, E, Map[Key2, Value2]]

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases. For a parallel version, see collectPar.

  49. def collectPar[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.

  50. def cond[E, A](predicate: => Boolean, result: => A, error: => E)(implicit trace: ZTraceElement): IO[E, A]

    Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise

    Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise

    For effectful conditionals, see ZIO.ifZIO

  51. def debug(value: => Any)(implicit trace: ZTraceElement): UIO[Unit]

    Prints the specified message to the console for debugging purposes.

  52. def descriptor(implicit trace: ZTraceElement): UIO[Fiber.Descriptor]

    Returns information about the current fiber, such as its identity.

  53. def descriptorWith[R, E, A](f: (Fiber.Descriptor) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Constructs an effect based on information about the current fiber, such as its identity.

  54. def die(t: => Throwable)(implicit trace: ZTraceElement): 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.

  55. def dieMessage(message: => String)(implicit trace: ZTraceElement): 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.

  56. def done[E, A](r: => Exit[E, A])(implicit trace: ZTraceElement): IO[E, A]

    Returns an effect from a zio.Exit value.

  57. def environment[R](implicit trace: ZTraceElement): URIO[R, R]

    Accesses the whole environment of the effect.

  58. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  59. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  60. def executor(implicit trace: ZTraceElement): UIO[Executor]

    Retrieves the executor for this effect.

  61. def exists[R, E, A](as: => Iterable[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Boolean]

    Determines whether any element of the Iterable[A] satisfies the effectual predicate f.

  62. def fail[E](error: => E)(implicit trace: ZTraceElement): 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.

  63. def failCause[E](cause: => Cause[E])(implicit trace: ZTraceElement): IO[E, Nothing]

    Returns an effect that models failure with the specified Cause.

  64. def failCauseWith[E](function: (() => ZTrace) => Cause[E])(implicit trace: ZTraceElement): 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.

  65. def fiberId(implicit trace: ZTraceElement): UIO[FiberId]

    Returns the FiberId of the fiber executing the effect that calls this method.

  66. def filter[R, E, A](as: Set[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Set[A]]

    Filters the Set[A] using the specified effectual predicate.

  67. def filter[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) => ZIO[R, E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[A]]

    Filters the collection using the specified effectual predicate.

  68. def filterNot[R, E, A](as: Set[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Set[A]]

    Filters the Set[A] using the specified effectual predicate, removing all elements that satisfy the predicate.

  69. def filterNot[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) => ZIO[R, E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[A]]

    Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.

  70. def filterNotPar[R, E, A](as: Set[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Set[A]]

    Filters the Set[A] in parallel using the specified effectual predicate, removing all elements that satisfy the predicate.

    Filters the Set[A] in parallel using the specified effectual predicate, removing all elements that satisfy the predicate.

    See zio.ZIO.filterNot[R,E,A](as:Set* for a sequential version.

  71. def filterNotPar[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) => ZIO[R, E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[A]]

    Filters the collection in parallel using the specified effectual predicate, emoving all elements that satisfy the predicate.

    Filters the collection in parallel using the specified effectual predicate, emoving all elements that satisfy the predicate.

    See zio.ZIO.filterNot[R,E,A,Collection* for a sequential version.

  72. def filterPar[R, E, A](as: Set[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Set[A]]

    Filters the Set[A] in parallel using the specified effectual predicate.

    Filters the Set[A] in parallel using the specified effectual predicate.

    See zio.ZIO.filter[R,E,A,Collection* for a sequential version.

  73. def filterPar[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) => ZIO[R, E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[A]]

    Filters the collection in parallel using the specified effectual predicate.

    Filters the collection in parallel using the specified effectual predicate.

    See zio.ZIO.filter[R,E,A,Collection* for a sequential version.

  74. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  75. def firstSuccessOf[R, R1 <: R, E, A](zio: => ZIO[R, E, A], rest: => Iterable[ZIO[R1, E, A]])(implicit trace: ZTraceElement): ZIO[R1, E, A]

    Returns an effect that runs the first effect and in case of failure, runs each of the specified effects in order until one of them succeeds.

  76. def flatten[R, E, A](zio: => ZIO[R, E, ZIO[R, E, A]])(implicit trace: ZTraceElement): 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.

  77. def foldLeft[R, E, S, A](in: => Iterable[A])(zero: => S)(f: (S, A) => ZIO[R, E, S])(implicit trace: ZTraceElement): ZIO[R, E, S]

    Folds an Iterable[A] using an effectual function f, working sequentially from left to right.

  78. def foldRight[R, E, S, A](in: => Iterable[A])(zero: => S)(f: (A, S) => ZIO[R, E, S])(implicit trace: ZTraceElement): ZIO[R, E, S]

    Folds an Iterable[A] using an effectual function f, working sequentially from right to left.

  79. def forall[R, E, A](as: => Iterable[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Boolean]

    Determines whether all elements of the Iterable[A] satisfy the effectual predicate f.

  80. final def foreach[R, E, A, B](in: NonEmptyChunk[A])(f: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[B]]

    Applies the function f to each element of the NonEmptyChunk[A] and returns the results in a new NonEmptyChunk[B].

    Applies the function f to each element of the NonEmptyChunk[A] and returns the results in a new NonEmptyChunk[B].

    For a parallel version of this method, see foreachPar. If you do not need the results, see foreachDiscard for a more efficient implementation.

  81. final def foreach[R, E, A, B](in: Option[A])(f: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, Option[B]]

    Applies the function f if the argument is non-empty and returns the results in a new Option[B].

  82. def foreach[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, E, (Key2, Value2)])(implicit trace: ZTraceElement): ZIO[R, E, Map[Key2, Value2]]

    Applies the function f to each element of the Map[Key, Value] and returns the results in a new Map[Key2, Value2].

    Applies the function f to each element of the Map[Key, Value] and returns the results in a new Map[Key2, Value2].

    For a parallel version of this method, see foreachPar. If you do not need the results, see foreachDiscard for a more efficient implementation.

  83. final def foreach[R, E, A, B](in: Array[A])(f: (A) => ZIO[R, E, B])(implicit arg0: ClassTag[B], trace: ZTraceElement): ZIO[R, E, Array[B]]

    Applies the function f to each element of the Array[A] and returns the results in a new Array[B].

    Applies the function f to each element of the Array[A] and returns the results in a new Array[B].

    For a parallel version of this method, see foreachPar. If you do not need the results, see foreachDiscard for a more efficient implementation.

  84. final def foreach[R, E, A, B](in: Set[A])(f: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, Set[B]]

    Applies the function f to each element of the Set[A] and returns the results in a new Set[B].

    Applies the function f to each element of the Set[A] and returns the results in a new Set[B].

    For a parallel version of this method, see foreachPar. If you do not need the results, see foreachDiscard for a more efficient implementation.

  85. def foreach[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Applies the function f to each element of the Collection[A] and returns the results in a new Collection[B].

    Applies the function f to each element of the Collection[A] and returns the results in a new Collection[B].

    For a parallel version of this method, see foreachPar. If you do not need the results, see foreach_ for a more efficient implementation.

  86. def foreachDiscard[R, E, A](as: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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.

  87. final def foreachExec[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(exec: => ExecutionStrategy)(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Applies the function f to each element of the Collection[A] and returns the result in a new Collection[B] using the specified execution strategy.

  88. final def foreachPar[R, E, A, B](as: NonEmptyChunk[A])(fn: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[B]]

    Applies the function f to each element of the NonEmptyChunk[A] in parallel, and returns the results in a new NonEmptyChunk[B].

    Applies the function f to each element of the NonEmptyChunk[A] in parallel, and returns the results in a new NonEmptyChunk[B].

    For a sequential version of this method, see foreach.

  89. def foreachPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, E, (Key2, Value2)])(implicit trace: ZTraceElement): ZIO[R, E, Map[Key2, Value2]]

    Applies the function f to each element of the Map[Key, Value] in parallel and returns the results in a new Map[Key2, Value2].

    Applies the function f to each element of the Map[Key, Value] in parallel and returns the results in a new Map[Key2, Value2].

    For a sequential version of this method, see foreach.

  90. final def foreachPar[R, E, A, B](as: Array[A])(f: (A) => ZIO[R, E, B])(implicit arg0: ClassTag[B], trace: ZTraceElement): ZIO[R, E, Array[B]]

    Applies the function f to each element of the Array[A] in parallel, and returns the results in a new Array[B].

    Applies the function f to each element of the Array[A] in parallel, and returns the results in a new Array[B].

    For a sequential version of this method, see foreach.

  91. final def foreachPar[R, E, A, B](as: Set[A])(fn: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, Set[B]]

    Applies the function f to each element of the Set[A] in parallel, and returns the results in a new Set[B].

    Applies the function f to each element of the Set[A] in parallel, and returns the results in a new Set[B].

    For a sequential version of this method, see foreach.

  92. def foreachPar[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    For a sequential version of this method, see foreach.

  93. def foreachParDiscard[R, E, A](as: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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 foreachDiscard.

    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.

  94. def forkAll[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): URIO[R, Fiber[E, Collection[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.

  95. def forkAllDiscard[R, E, A](as: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): 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.

  96. def forkScope(implicit trace: ZTraceElement): UIO[ZScope[Exit[Any, Any]]]

    Retrieves the scope that will be used to supervise forked effects.

  97. def forkScopeMask[R, E, A](newScope: => ZScope[Exit[Any, Any]])(f: (ForkScopeRestore) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Captures the fork scope, before overriding it with the specified new scope, passing a function that allows restoring the fork scope to what it was originally.

  98. def forkScopeWith[R, E, A](f: (ZScope[Exit[Any, Any]]) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Retrieves the scope that will be used to supervise forked effects.

  99. def from[Input](input: => Input)(implicit constructor: ZIOConstructor[Nothing, Any, Input], trace: ZTraceElement): ZIO[OutEnvironment, OutError, OutSuccess]

    Constructs a ZIO value of the appropriate type for the specified input.

  100. def fromCompletableFuture[A](cs: => CompletableFuture[A])(implicit trace: ZTraceElement): Task[A]

    Alias for formCompletionStage for a concrete implementation of CompletionStage

    Alias for formCompletionStage for a concrete implementation of CompletionStage

    Definition Classes
    ZIOCompanionPlatformSpecific
  101. def fromCompletionStage[A](cs: => CompletionStage[A])(implicit trace: ZTraceElement): Task[A]
    Definition Classes
    ZIOCompanionPlatformSpecific
  102. def fromEither[E, A](v: => Either[E, A])(implicit trace: ZTraceElement): IO[E, A]

    Lifts an Either into a ZIO value.

  103. def fromEitherCause[E, A](v: => Either[Cause[E], A])(implicit trace: ZTraceElement): IO[E, A]

    Lifts an Either into a ZIO value.

  104. def fromFiber[E, A](fiber: => Fiber[E, A])(implicit trace: ZTraceElement): IO[E, A]

    Creates a ZIO value that represents the exit value of the specified fiber.

  105. def fromFiberZIO[R, E, A](fiber: => ZIO[R, E, Fiber[E, A]])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Creates a ZIO value that represents the exit value of the specified fiber.

  106. def fromFuture[A](make: (ExecutionContext) => Future[A])(implicit trace: ZTraceElement): Task[A]

    Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a ZIO.

  107. def fromFutureInterrupt[A](make: (ExecutionContext) => Future[A])(implicit trace: ZTraceElement): 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.

  108. def fromFutureJava[A](future: => Future[A])(implicit trace: ZTraceElement): Task[A]

    WARNING: this uses the blocking Future#get, consider using fromCompletionStage

    WARNING: this uses the blocking Future#get, consider using fromCompletionStage

    Definition Classes
    ZIOCompanionPlatformSpecific
  109. def fromOption[A](v: => Option[A])(implicit trace: ZTraceElement): IO[Option[Nothing], A]

    Lifts an Option into a ZIO but preserves the error as an option in the error channel, making it easier to compose in some scenarios.

  110. def fromPromiseScala[A](promise: => scala.concurrent.Promise[A])(implicit trace: ZTraceElement): Task[A]

    Imports a scala.concurrent.Promise we generate a future from promise, and we pass to [fromFuture] to transform into Task[A]

  111. def fromTry[A](value: => Try[A])(implicit trace: ZTraceElement): Task[A]

    Lifts a Try into a ZIO.

  112. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  113. def getFiberRefs(implicit trace: ZTraceElement): UIO[FiberRefs]

    Returns a collection of all FiberRef values for the fiber running this effect.

  114. final def getOrFail[A](v: => Option[A])(implicit trace: ZTraceElement): Task[A]

    Lifts an Option into a ZIO, if the option is not defined it fails with NoSuchElementException.

  115. final def getOrFailUnit[A](v: => Option[A])(implicit trace: ZTraceElement): IO[Unit, A]

    Lifts an Option into a IO, if the option is not defined it fails with Unit.

  116. final def getOrFailWith[E, A](e: => E)(v: => Option[A])(implicit trace: ZTraceElement): IO[E, A]

    Lifts an Option into a ZIO.

    Lifts an Option into a ZIO. If the option is not defined, fail with the e value.

  117. def getState[S](implicit arg0: zio.Tag[S], trace: ZTraceElement): ZIO[Has[ZState[S]], Nothing, S]

    Gets a state from the environment.

  118. def getStateWith[S]: GetStateWithPartiallyApplied[S]

    Gets a state from the environment and uses it to run the specified function.

  119. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  120. def ifZIO[R, E](b: => ZIO[R, E, Boolean]): IfZIO[R, E]

    Runs onTrue if the result of b is true and onFalse otherwise.

  121. val infinity: URIO[Has[Clock], Nothing]

    Like never, but fibers that running this effect won't be garbage collected unless interrupted.

  122. def interrupt(implicit trace: ZTraceElement): UIO[Nothing]

    Returns an effect that is interrupted as if by the fiber calling this method.

  123. def interruptAs(fiberId: => FiberId)(implicit trace: ZTraceElement): UIO[Nothing]

    Returns an effect that is interrupted as if by the specified fiber.

  124. def interruptible[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Prefix form of ZIO#interruptible.

  125. def interruptibleMask[R, E, A](k: (InterruptStatusRestore) => ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

  126. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  127. def iterate[R, E, S](initial: => S)(cont: (S) => Boolean)(body: (S) => ZIO[R, E, S])(implicit trace: ZTraceElement): 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
  128. def left[A](a: => A)(implicit trace: ZTraceElement): UIO[Either[A, Nothing]]

    Returns an effect with the value on the left part.

  129. def log(message: => String)(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified message at the current log level.

  130. def logDebug(message: => String)(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified message at the debug log level.

  131. def logError(message: => String)(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified message at the error log level.

  132. def logErrorCause(cause: => Cause[Any])(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified cause as an error.

  133. def logFatal(message: => String)(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified message at the fatal log level.

  134. def logInfo(message: => String)(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified message at the informational log level.

  135. def logLevel(level: LogLevel): LogLevel
  136. def logSpan(label: => String): LogSpan

    Adjusts the label for the current logging span.

    Adjusts the label for the current logging span.

    ZIO.logSpan("parsing") { parseRequest(req) }
  137. def logWarning(message: => String)(implicit trace: ZTraceElement): UIO[Unit]

    Logs the specified message at the warning log level.

  138. def loop[R, E, A, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZIO[R, E, A])(implicit trace: ZTraceElement): 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
  139. def loopDiscard[R, E, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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)
    }
  140. def memoize[R, E, A, B](f: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): UIO[(A) => ZIO[R, E, B]]

    Returns a memoized version of the specified effectual function.

  141. def mergeAll[R, E, A, B](in: => Iterable[ZIO[R, E, A]])(zero: => B)(f: (B, A) => B)(implicit trace: ZTraceElement): ZIO[R, E, B]

    Merges an Iterable[IO] to a single IO, working sequentially.

  142. def mergeAllPar[R, E, A, B](in: => Iterable[ZIO[R, E, A]])(zero: => B)(f: (B, A) => B)(implicit trace: ZTraceElement): 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.

    Due to the parallel nature of this combinator, f must be both: - commutative: f(a, b) == f(b, a) - associative: f(a, f(b, c)) == f(f(a, b), c)

    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.

  143. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  144. def never(implicit trace: ZTraceElement): 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.

  145. lazy val none: UIO[Option[Nothing]]

    Returns an effect with the empty value.

  146. def noneOrFail[E](o: => Option[E])(implicit trace: ZTraceElement): IO[E, Unit]

    Lifts an Option into a IO.

    Lifts an Option into a IO. If the option is empty it succeeds with Unit. If the option is defined it fails with the content.

  147. def noneOrFailWith[E, O](o: => Option[O])(f: (O) => E)(implicit trace: ZTraceElement): IO[E, Unit]

    Lifts an Option into a IO.

    Lifts an Option into a IO. If the option is empty it succeeds with Unit. If the option is defined it fails with an error adapted with f.

  148. def not[R, E](effect: => ZIO[R, E, Boolean])(implicit trace: ZTraceElement): ZIO[R, E, Boolean]

    Returns a new effect where boolean value of this effect is negated.

  149. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  150. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  151. def onExecutor[R, E, A](executor: => Executor)(zio: ZIO[R, E, A])(implicit trace: ZTraceElement): 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!.onExecutor.

  152. def parallelism(implicit trace: ZTraceElement): UIO[Option[Int]]

    Retrieves the maximum number of fibers for parallel operators or None if it is unbounded.

  153. def parallelismWith[R, E, A](f: (Option[Int]) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Retrieves the current maximum number of fibers for parallel operators and uses it to run the specified effect.

  154. def partition[R, E, A, B](in: => Iterable[A])(f: (A) => ZIO[R, E, B])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, Nothing, (Iterable[E], Iterable[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.

  155. def partitionPar[R, E, A, B](in: => Iterable[A])(f: (A) => ZIO[R, E, B])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, Nothing, (Iterable[E], Iterable[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.

  156. def provide[R, E, A](r: => R)(implicit trace: ZTraceElement): (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.

  157. def raceAll[R, R1 <: R, E, A](zio: => ZIO[R, E, A], ios: => Iterable[ZIO[R1, E, A]])(implicit trace: ZTraceElement): 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.

  158. def reduceAll[R, R1 <: R, E, A](a: => ZIO[R, E, A], as: => Iterable[ZIO[R1, E, A]])(f: (A, A) => A)(implicit trace: ZTraceElement): ZIO[R1, E, A]

    Reduces an Iterable[IO] to a single IO, working sequentially.

  159. def reduceAllPar[R, R1 <: R, E, A](a0: => ZIO[R, E, A], as0: => Iterable[ZIO[R1, E, A]])(f: (A, A) => A)(implicit trace: ZTraceElement): ZIO[R1, E, A]

    Reduces an Iterable[IO] to a single IO, working in parallel.

  160. def replicate[R, E, A](n: Int)(effect: ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

  161. def replicateZIO[R, E, A](n: => Int)(effect: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, Iterable[A]]

    Performs this effect the specified number of times and collects the results.

  162. def replicateZIODiscard[R, E, A](n: => Int)(effect: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Performs this effect the specified number of times, discarding the results.

  163. def reserve[R, E, A, B](reservation: => ZIO[R, E, Reservation[R, E, A]])(use: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): 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 acquireReleaseWith, 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.

  164. def right[B](b: => B)(implicit trace: ZTraceElement): UIO[Either[Nothing, B]]

    Returns an effect with the value on the right part.

  165. def runtime[R](implicit trace: ZTraceElement): 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.

  166. def runtimeConfig(implicit trace: ZTraceElement): UIO[RuntimeConfig]

    Retrieves the runtimeConfig that this effect is running on.

  167. def scopeWith[R, E, A](f: (ZScope[Exit[Any, Any]]) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Passes the fiber's scope to the specified function, which creates an effect that will be returned from this method.

  168. def service[A](implicit arg0: zio.Tag[A], trace: ZTraceElement): URIO[Has[A], A]

    Accesses the specified service in the environment of the effect.

  169. def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

    Accesses the service corresponding to the specified key in the environment.

  170. def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

    Effectfully accesses the specified service in the environment of the effect.

    Effectfully accesses the specified service in the environment of the effect.

    Especially useful for creating "accessor" methods on Services' companion objects.

    def foo(int: Int) = ZIO.serviceWith[Foo](_.foo(int))
  171. def setFiberRefs(fiberRefs: => FiberRefs)(implicit trace: ZTraceElement): UIO[Unit]

    Sets the FiberRef values for the fiber running this effect to the values in the specified collection of FiberRef values.

  172. def setRuntimeConfig(runtimeConfig: => RuntimeConfig)(implicit trace: ZTraceElement): UIO[Unit]

    Sets the runtime configuration to the specified value.

  173. def setState[S](s: => S)(implicit arg0: zio.Tag[S], trace: ZTraceElement): ZIO[Has[ZState[S]], Nothing, Unit]

    Sets a state in the environment to the specified value.

  174. def shift(executor: => Executor)(implicit trace: ZTraceElement): UIO[Unit]

    Returns an effect that shifts execution to the specified executor.

    Returns an effect that shifts execution to the specified executor. This is useful to specify a default executor that effects sequenced after this one will be run on if they are not shifted somewhere else. It can also be used to implement higher level operators to manage where an effect is run such as ZIO!.onExecutor and ZIO!.onExecutionContext.

  175. def sleep(duration: => zio.Duration)(implicit trace: ZTraceElement): URIO[Has[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.

  176. def some[A](a: => A)(implicit trace: ZTraceElement): UIO[Option[A]]

    Returns an effect with the optional value.

  177. def succeed[A](a: => A)(implicit trace: ZTraceElement): UIO[A]

    Returns an effect that models success with the specified value.

  178. def succeedBlocking[A](a: => A)(implicit trace: ZTraceElement): UIO[A]

    Returns a synchronous effect that does blocking and succeeds with the specified value.

  179. def succeedWith[A](f: (RuntimeConfig, FiberId) => A)(implicit trace: ZTraceElement): UIO[A]

    The same as ZIO.succeed, but also provides access to the underlying RuntimeConfig and fiber id.

  180. def suspend[R, A](rio: => RIO[R, A])(implicit trace: ZTraceElement): 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)).

  181. def suspendSucceed[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): 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(succeed(zio)). If you wonder if the effect throws exceptions, do not use this method, use Task.suspend or ZIO.suspend.

  182. def suspendSucceedWith[R, E, A](f: (RuntimeConfig, FiberId) => ZIO[R, E, A])(implicit trace: ZTraceElement): 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(succeed(zio)). If you wonder if the effect throws exceptions, do not use this method, use Task.suspend or ZIO.suspend.

  183. def suspendWith[R, A](f: (RuntimeConfig, FiberId) => RIO[R, A])(implicit trace: ZTraceElement): 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)).

  184. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  185. def toString(): String
    Definition Classes
    AnyRef → Any
  186. def trace(implicit trace: ZTraceElement): UIO[ZTrace]

    Capture ZIO trace at the current point

  187. def traced[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Prefix form of ZIO#traced.

  188. def transplant[R, E, A](f: (Grafter) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Transplants specified effects so that when those effects fork other effects, the forked effects will be governed by the scope of the fiber that executes this effect.

    Transplants specified effects so that when those effects fork other effects, the forked effects will be governed by the scope of the fiber that executes this effect.

    This can be used to "graft" deep grandchildren onto a higher-level scope, effectively extending their lifespans into the parent scope.

  189. def uninterruptible[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Prefix form of ZIO#uninterruptible.

  190. def uninterruptibleMask[R, E, A](k: (InterruptStatusRestore) => ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

  191. lazy val unit: UIO[Unit]

    An effect that succeeds with a unit value.

  192. def unless[R, E, A](p: => Boolean)(zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, Option[A]]

    The moral equivalent of if (!p) exp

  193. def unlessZIO[R, E](p: => ZIO[R, E, Boolean]): UnlessZIO[R, E]

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

  194. def unsandbox[R, E, A](v: => ZIO[R, Cause[E], A])(implicit trace: ZTraceElement): 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]

  195. def unshift(implicit trace: ZTraceElement): UIO[Unit]

    Returns an effect indicating that execution is no longer required to be performed on the current executor.

    Returns an effect indicating that execution is no longer required to be performed on the current executor. The runtime may continue executing on this executor for efficiency but will not automatically shift back to it after completing an effect on another executor.

  196. def untraced[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Prefix form of ZIO#untraced.

  197. def updateState[S](f: (S) => S)(implicit arg0: zio.Tag[S], trace: ZTraceElement): ZIO[Has[ZState[S]], Nothing, Unit]

    Updates a state in the environment with the specified function.

  198. def validate[R, E, A, B](in: NonEmptyChunk[A])(f: (A) => ZIO[R, E, B])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], NonEmptyChunk[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.

  199. def validate[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], Collection[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.

  200. def validateDiscard[R, E, A](in: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], Unit]

    Feeds elements of type A to f and accumulates all errors, discarding the successes.

  201. def validateFirst[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], E, Collection[E]], ev: CanFail[E], trace: ZTraceElement): ZIO[R, Collection[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.

  202. def validateFirstPar[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], E, Collection[E]], ev: CanFail[E], trace: ZTraceElement): ZIO[R, Collection[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.

  203. def validatePar[R, E, A, B](in: NonEmptyChunk[A])(f: (A) => ZIO[R, E, B])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], NonEmptyChunk[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.

  204. def validatePar[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], Collection[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.

  205. def validateParDiscard[R, E, A](in: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], Unit]

    Feeds elements of type A to f in parallel and accumulates all errors, discarding the successes.

  206. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  207. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  208. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  209. def when[R, E, A](p: => Boolean)(zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, Option[A]]

    The moral equivalent of if (p) exp

  210. def whenCase[R, E, A, B](a: => A)(pf: PartialFunction[A, ZIO[R, E, B]])(implicit trace: ZTraceElement): ZIO[R, E, Option[B]]

    Runs an effect when the supplied PartialFunction matches for the given value, otherwise does nothing.

  211. def whenCaseZIO[R, E, A, B](a: => ZIO[R, E, A])(pf: PartialFunction[A, ZIO[R, E, B]])(implicit trace: ZTraceElement): ZIO[R, E, Option[B]]

    Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

  212. def whenZIO[R, E](p: => ZIO[R, E, Boolean]): WhenZIO[R, E]

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

  213. def withChildren[R, E, A](get: (UIO[Chunk[Fiber.Runtime[Any, Any]]]) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Locally installs a supervisor and an effect that succeeds with all the children that have been forked in the returned effect.

  214. def withParallelism[R, E, A](n: => Int)(zio: ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Runs the specified effect with the specified maximum number of fibers for parallel operators.

  215. def withParallelismUnbounded[R, E, A](zio: ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Runs the specified effect with an unbounded maximum number of fibers for parallel operators.

  216. def withRuntimeConfig[R, E, A](runtimeConfig: => RuntimeConfig)(zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Runs the specified effect on the specified runtime configuration, restoring the old runtime configuration when it completes execution.

  217. def yieldNow(implicit trace: ZTraceElement): 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.

  218. object CanFilter
  219. object InterruptStatusRestore
  220. object ZIOConstructor extends ZIOConstructorLowPriority1

Deprecated Value Members

  1. def accessM[R]: AccessZIOPartiallyApplied[R]

    Effectfully accesses the environment of the effect.

    Effectfully accesses the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessZIO

  2. def bracket[R, E, A, B](acquire: => ZIO[R, E, A], release: (A) => URIO[R, Any], use: (A) => ZIO[R, E, B])(implicit trace: ZTraceElement): 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.Acquire and zio.ZIO.Release objects.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseWith

  3. def bracket[R, E, A](acquire: => ZIO[R, E, A]): Acquire[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
    }
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseWith

  4. 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])(implicit trace: ZTraceElement): 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.AcquireExit and zio.ZIO.ReleaseExit objects.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseExitWith

  5. def bracketExit[R, E, A](acquire: => ZIO[R, E, A]): AcquireExit[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseExitWith

  6. def collectAllParN[R, E, A, Collection[+Element] <: Iterable[Element]](n: => Int)(as: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): ZIO[R, E, Collection[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllPar

  7. def collectAllParNDiscard[R, E, A](n: => Int)(as: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAllDiscard.

    Unlike collectAllParDiscard, this method will use at most n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllParDiscard

  8. def collectAllParN_[R, E, A](n: => Int)(as: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAll_.

    Unlike collectAllPar_, this method will use at most n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllParDiscard

  9. def collectAllPar_[R, E, A](as: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAll_.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllParDiscard

  10. def collectAllSuccessesParN[R, E, A, Collection[+Element] <: Iterable[Element]](n: => Int)(in: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]], trace: ZTraceElement): URIO[R, Collection[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllSuccessesPar

  11. def collectAllWithParN[R, E, A, B, Collection[+Element] <: Iterable[Element]](n: => Int)(in: Collection[ZIO[R, E, A]])(f: PartialFunction[A, B])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllWithPar

  12. def collectAll_[R, E, A](in: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Evaluate each effect in the structure from left to right, and discard the results.

    Evaluate each effect in the structure from left to right, and discard the results. For a parallel version, see collectAllPar_.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllDiscard

  13. def collectParN[R, E, A, B, Collection[+Element] <: Iterable[Element]](n: => Int)(in: Collection[A])(f: (A) => ZIO[R, Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.

    Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.

    Unlike collectPar, this method will use at most up to n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectPar

  14. def effect[A](effect: => A)(implicit trace: ZTraceElement): 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 printLine(line: String): Task[Unit] = Task.effect(println(line))
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attempt

  15. def effectAsync[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Any, blockingOn: => FiberId = null)(implicit trace: ZTraceElement): 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] => Any must be called at most once.

    The list of fibers, that may complete the async callback, is used to provide better diagnostics.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use async

  16. def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Either[Canceler[R], ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: ZTraceElement): 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] => Any 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncInterrupt

  17. def effectAsyncM[R, E, A](register: ((ZIO[R, E, A]) => Unit) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncZIO

  18. def effectAsyncMaybe[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Option[ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: ZTraceElement): 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] => Any 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncMaybe

  19. def effectAsyncWithCompletionHandler[T](op: (CompletionHandler[T, Any]) => Any)(implicit trace: ZTraceElement): Task[T]
    Definition Classes
    ZIOCompanionPlatformSpecific
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncWithCompletionHandler

  20. def effectBlocking[A](effect: => A)(implicit trace: ZTraceElement): Task[A]

    Imports a synchronous effect that does blocking IO into a pure value.

    Imports a synchronous effect that does blocking IO into a pure value.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attemptBlocking

  21. def effectBlockingCancelable[R, A](effect: => A)(cancel: => URIO[R, Any])(implicit trace: ZTraceElement): RIO[R, A]

    Imports a synchronous effect that does blocking IO into a pure value, with a custom cancel effect.

    Imports a synchronous effect that does blocking IO into a pure value, with a custom cancel effect.

    If the returned ZIO is interrupted, the blocked thread running the synchronous effect will be interrupted via the cancel effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attemptBlockingCancelable

  22. def effectBlockingIO[A](effect: => A)(implicit trace: ZTraceElement): IO[IOException, A]

    Imports a synchronous effect that does blocking IO into a pure value, refining the error type to java.io.IOException.

    Imports a synchronous effect that does blocking IO into a pure value, refining the error type to java.io.IOException.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attemptBlockingIO

  23. def effectBlockingInterrupt[A](effect: => A)(implicit trace: ZTraceElement): Task[A]

    Imports a synchronous effect that does blocking IO into a pure value.

    Imports a synchronous effect that does blocking IO into a pure value.

    If the returned ZIO is interrupted, the blocked thread running the synchronous effect will be interrupted via Thread.interrupt.

    Note that this adds significant overhead. For performance sensitive applications consider using effectBlocking or effectBlockingCancel.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attemptBlockingInterrupt

  24. def effectSuspend[R, A](rio: => RIO[R, A])(implicit trace: ZTraceElement): 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)).

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use suspend

  25. def effectSuspendTotal[R, E, A](zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use suspendSucceed

  26. def effectSuspendTotalWith[R, E, A](f: (Platform, Id) => ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use suspendSucceedWith

  27. def effectSuspendWith[R, A](f: (Platform, Id) => RIO[R, A])(implicit trace: ZTraceElement): 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)).

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use suspendWith

  28. def effectTotal[A](effect: => A)(implicit trace: ZTraceElement): UIO[A]

    Captures a synchronous computation into a lazy effect, which can be executed later and repeatedly.

    Captures a synchronous computation into a lazy effect, which can be executed later and repeatedly. The synchronous computation must not throw any exceptions. If you are unsure, then don't use this method, use Task.effect, IO.effect, or ZIO.effect.

    val nanoTime: UIO[Long] = IO.succeed(System.nanoTime())
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use succeed

  29. def effectTotalWith[A](effect: (Platform, Id) => A)(implicit trace: ZTraceElement): UIO[A]

    The same as ZIO.effectTotal, but also provides access to the underlying RuntimeConfig and fiber id.

    The same as ZIO.effectTotal, but also provides access to the underlying RuntimeConfig and fiber id.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use succeedWith

  30. def foreachParN[R, E, A, B, Collection[+Element] <: Iterable[Element]](n: => Int)(as: Collection[A])(fn: (A) => ZIO[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZIO[R, E, Collection[B]]

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    Unlike foreachPar, this method will use at most up to n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachPar

  31. def foreachParNDiscard[R, E, A](n: => Int)(as: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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 foreachParDiscard, this method will use at most up to n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachParDiscard

  32. def foreachParN_[R, E, A](n: => Int)(as: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachParDiscard

  33. def foreachPar_[R, E, A](as: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachParDiscard

  34. def foreach_[R, E, A](as: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachDiscard

  35. def forkAll_[R, E, A](as: => Iterable[ZIO[R, E, A]])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use forkAllDiscard

  36. def fromFiberM[E, A](fiber: IO[E, Fiber[E, A]])(implicit trace: ZTraceElement): IO[E, A]

    Creates a ZIO value that represents the exit value of the specified fiber.

    Creates a ZIO value that represents the exit value of the specified fiber.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromFiberZIO

  37. def fromFunction[R, A](f: (R) => A)(implicit trace: ZTraceElement): URIO[R, A]

    Lifts a function R => A into a URIO[R, A].

    Lifts a function R => A into a URIO[R, A].

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use access

  38. def fromFunctionM[R, E, A](f: (R) => IO[E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]

    Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.

    Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessZIO

  39. def halt[E](cause: => Cause[E])(implicit trace: ZTraceElement): IO[E, Nothing]

    Returns an effect that models failure with the specified Cause.

    Returns an effect that models failure with the specified Cause.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use failCause

  40. def haltWith[E](function: (() => ZTrace) => Cause[E])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use failCauseWith

  41. def ifM[R, E](b: => ZIO[R, E, Boolean]): IfZIO[R, E]

    Runs onTrue if the result of b is true and onFalse otherwise.

    Runs onTrue if the result of b is true and onFalse otherwise.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ifZIO

  42. def lock[R, E, A](executor: => Executor)(zio: => ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use onExecutor

  43. def loop_[R, E, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZIO[R, E, Any])(implicit trace: ZTraceElement): 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)
    }
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use loopDiscard

  44. 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)(implicit trace: ZTraceElement): ZIO[R, E, F]

    Sequentially zips the specified effects using the specified combiner function.

    Sequentially zips the specified effects using the specified combiner function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  45. 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)(implicit trace: ZTraceElement): ZIO[R, E, D]

    Sequentially zips the specified effects using the specified combiner function.

    Sequentially zips the specified effects using the specified combiner function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  46. def mapN[R, E, A, B, C](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B])(f: (A, B) => C)(implicit trace: ZTraceElement): ZIO[R, E, C]

    Sequentially zips the specified effects using the specified combiner function.

    Sequentially zips the specified effects using the specified combiner function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  47. 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)(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  48. 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)(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  49. def mapParN[R, E, A, B, C](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B])(f: (A, B) => C)(implicit trace: ZTraceElement): 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  50. def mergeAllParN[R, E, A, B](n: => Int)(in: => Iterable[ZIO[R, E, A]])(zero: => B)(f: (B, A) => B)(implicit trace: ZTraceElement): ZIO[R, E, B]

    Merges an Iterable[IO] to a single IO, working in with up to n fibers in parallel.

    Merges an Iterable[IO] to a single IO, working in with up to n fibers in parallel.

    Due to the parallel nature of this combinator, f must be both: - commutative: f(a, b) == f(b, a) - associative: f(a, f(b, c)) == f(f(a, b), c)

    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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use mergeAllPar

  51. def partitionParN[R, E, A, B](n: => Int)(in: => Iterable[A])(f: (A) => ZIO[R, E, B])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, Nothing, (Iterable[E], Iterable[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use partitionPar

  52. def reduceAllParN[R, R1 <: R, E, A](n: => Int)(a0: => ZIO[R, E, A], as0: => Iterable[ZIO[R1, E, A]])(f: (A, A) => A)(implicit trace: ZTraceElement): ZIO[R1, E, A]

    Reduces an Iterable[IO] to a single IO, working in up to n fibers in parallel.

    Reduces an Iterable[IO] to a single IO, working in up to n fibers in parallel.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use reduceAllPar

  53. def replicateM[R, E, A](n: => Int)(effect: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, Iterable[A]]

    Performs this effect the specified number of times and collects the results.

    Performs this effect the specified number of times and collects the results.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use replicateZIO

  54. def replicateM_[R, E, A](n: => Int)(effect: => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, Unit]

    Performs this effect the specified number of times, discarding the results.

    Performs this effect the specified number of times, discarding the results.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use replicateZIODiscard

  55. def require[R, E, A](error: => E)(implicit trace: ZTraceElement): (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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use someOrFail

  56. def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D], trace: ZTraceElement): URIO[Has[A] with Has[B] with Has[C] with Has[D], (A, B, C, D)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  57. def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], trace: ZTraceElement): URIO[Has[A] with Has[B] with Has[C], (A, B, C)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  58. def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], trace: ZTraceElement): URIO[Has[A] with Has[B], (A, B)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  59. def tupled[R, E, A, B, C, D](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B], zio3: => ZIO[R, E, C], zio4: => ZIO[R, E, D])(implicit trace: ZTraceElement): ZIO[R, E, (A, B, C, D)]

    Sequentially zips the specified effects.

    Sequentially zips the specified effects. Specialized version of mapN.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  60. def tupled[R, E, A, B, C](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B], zio3: => ZIO[R, E, C])(implicit trace: ZTraceElement): ZIO[R, E, (A, B, C)]

    Sequentially zips the specified effects.

    Sequentially zips the specified effects. Specialized version of mapN.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  61. def tupled[R, E, A, B](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, (A, B)]

    Sequentially zips the specified effects.

    Sequentially zips the specified effects. Specialized version of mapN.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  62. def tupledPar[R, E, A, B, C, D](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B], zio3: => ZIO[R, E, C], zio4: => ZIO[R, E, D])(implicit trace: ZTraceElement): ZIO[R, E, (A, B, C, D)]

    Zips the specified effects in parallel.

    Zips the specified effects in parallel. Specialized version of mapParN.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  63. def tupledPar[R, E, A, B, C](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B], zio3: => ZIO[R, E, C])(implicit trace: ZTraceElement): ZIO[R, E, (A, B, C)]

    Zips the specified effects in parallel.

    Zips the specified effects in parallel. Specialized version of mapParN.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  64. def tupledPar[R, E, A, B](zio1: => ZIO[R, E, A], zio2: => ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, (A, B)]

    Zips the specified effects in parallel.

    Zips the specified effects in parallel. Specialized version of mapParN.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  65. def unlessM[R, E](p: => ZIO[R, E, Boolean]): UnlessZIO[R, E]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use unlessZIO

  66. def validatePar_[R, E, A](in: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], Unit]

    Feeds elements of type A to f in parallel and accumulates all errors, discarding the successes.

    Feeds elements of type A to f in parallel and accumulates all errors, discarding the successes.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use validateParDiscard

  67. def validate_[R, E, A](in: => Iterable[A])(f: (A) => ZIO[R, E, Any])(implicit ev: CanFail[E], trace: ZTraceElement): ZIO[R, ::[E], Unit]

    Feeds elements of type A to f and accumulates all errors, discarding the successes.

    Feeds elements of type A to f and accumulates all errors, discarding the successes.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use validateDiscard

  68. def whenCaseM[R, E, A, B](a: => ZIO[R, E, A])(pf: PartialFunction[A, ZIO[R, E, B]])(implicit trace: ZTraceElement): ZIO[R, E, Option[B]]

    Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

    Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenCaseZIO

  69. def whenM[R, E](p: => ZIO[R, E, Boolean]): WhenZIO[R, E]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenZIO

Inherited from Serializable

Inherited from ZIOCompanionPlatformSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped