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: Trace): 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 acquireRelease[R, R1, E, A](acquire: => ZIO[R, E, A])(release: (A) => ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R with R1 with Scope, E, A]

   Constructs a scoped resource from an acquire and release effect.

   Constructs a scoped resource from an acquire and release effect. If acquire successfully completes execution then release will be added to the finalizers associated with the scope of this effect and is guaranteed to be run when the scope is closed.

   The acquire and release effects will be run uninterruptibly.

7.  def acquireReleaseExit[R, R1, E, A](acquire: => ZIO[R, E, A])(release: (A, Exit[Any, Any]) => ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R with R1 with Scope, E, A]

   A more powerful variant of acquireRelease that allows the release effect to depend on the Exit value specified when the scope is closed.

8.  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.

9.  def acquireReleaseInterruptible[R, R1, E, A](acquire: => ZIO[R, E, A])(release: ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R with R1 with Scope, E, A]

   A variant of acquireRelease that allows the acquire effect to be interruptible.

   A variant of acquireRelease that allows the acquire effect to be interruptible. Since the acquire effect could be interrupted after partially acquiring resources, the release effect is not allowed to access the resource produced by acquire and must independently determine what finalization, if any, needs to be performed (e.g. by examining in memory state).

10.  def acquireReleaseInterruptibleExit[R, R1, E, A](acquire: => ZIO[R, E, A])(release: (Exit[Any, Any]) => ZIO[R1, Nothing, Any])(implicit trace: Trace): ZIO[R with R1 with Scope, E, A]

    A more powerful variant of acquireReleaseInterruptible that allows the release effect to depend on the Exit value specified when the scope is closed.

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

    Given an effect representing 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.

    Given an effect representing 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 acquire effect 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.

    ZIO.acquireReleaseWith(openFile("data.json"))(closeFile) { file =>
      for {
        header <- readHeader(file)
        ...
      } yield result
    }

12.  def addFinalizer[R](finalizer: => URIO[R, Any])(implicit trace: Trace): ZIO[R with Scope, Nothing, Any]

    Adds a finalizer to the scope of this effect.

    Adds a finalizer to the scope of this effect. The finalizer is guaranteed to be run when the scope is closed.

13.  def addFinalizerExit[R](finalizer: (Exit[Any, Any]) => URIO[R, Any])(implicit trace: Trace): ZIO[R with Scope, Nothing, Any]

    A more powerful variant of addFinalizer that allows the finalizer to depend on the Exit value that the scope is closed with.

14.  def allowInterrupt(implicit trace: Trace): UIO[Unit]

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

15.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

16.  def async[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Unit, blockingOn: => FiberId = FiberId.None)(implicit trace: Trace): ZIO[R, E, A]

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    This method allows you to specify the fiber id that is responsible for invoking callbacks provided to the register function. This is called the "blocking fiber", because it is stopping the fiber executing the async effect from making progress (although it is not "blocking" a thread). Specifying this fiber id in cases where it is known will improve diagnostics, but not affect the behavior of the returned effect.

    Definition Classes

    ZIOCompanionVersionSpecific

17.  def asyncInterrupt[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Either[URIO[R, Any], ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: Trace): ZIO[R, E, A]

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    With this variant, you can specify either a way to cancel the asynchrounous action, or you can return the result right away if no asynchronous operation is required.

    This method allows you to specify the fiber id that is responsible for invoking callbacks provided to the register function. This is called the "blocking fiber", because it is stopping the fiber executing the async effect from making progress (although it is not "blocking" a thread). Specifying this fiber id in cases where it is known will improve diagnostics, but not affect the behavior of the returned effect.

    Definition Classes

    ZIOCompanionVersionSpecific

18.  def asyncInterruptUnsafe[R, E, A](register: (Unsafe) => ((ZIO[R, E, A]) => Unit) => Either[URIO[R, Any], ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: Trace): ZIO[R, E, A]
19.  def asyncMaybe[R, E, A](register: ((ZIO[R, E, A]) => Unit) => Option[ZIO[R, E, A]], blockingOn: => FiberId = FiberId.None)(implicit trace: Trace): ZIO[R, E, A]

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    With this variant, the registration function may return the result right away, if it turns out that no asynchronous operation is required to complete the operation.

    This method allows you to specify the fiber id that is responsible for invoking callbacks provided to the register function. This is called the "blocking fiber", because it is stopping the fiber executing the async effect from making progress (although it is not "blocking" a thread). Specifying this fiber id in cases where it is known will improve diagnostics, but not affect the behavior of the returned effect.

    Definition Classes

    ZIOCompanionVersionSpecific

20.  def asyncWithCompletionHandler[T](op: (CompletionHandler[T, Any]) => Any)(implicit trace: Trace): Task[T]

    Definition Classes

    ZIOCompanionPlatformSpecific

21.  def asyncZIO[R, E, A](register: ((ZIO[R, E, A]) => Unit) => ZIO[R, E, Any])(implicit trace: Trace): ZIO[R, E, A]

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    Converts an asynchronous, callback-style API into a ZIO effect, which will be executed asynchronously.

    With this variant, the registration function may return a ZIO effect.

22.  def attempt[A](code: => A)(implicit trace: Trace): Task[A]

    Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.

    Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.

    This method should be used whenever you want to take arbitrary code, which may throw exceptions or not be type safe, and convert it into a ZIO effect, which can safely execute that code whenever the effect is executed.

    def printLine(line: String): Task[Unit] = ZIO.attempt(println(line))

    Definition Classes

    ZIOCompanionVersionSpecific

23.  def attemptBlocking[A](effect: => A)(implicit trace: Trace): Task[A]

    Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.

    Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.

    This method should be used whenever you want to take arbitrary code, which may throw exceptions or not be type safe, and convert it into a ZIO effect, which can safely execute that code whenever the effect is executed.

    This variant expects that the provided code will engage in blocking I/O, and therefore, pro-actively executes the code on a dedicated blocking thread pool, so it won't interfere with the main thread pool that ZIO uses.

    Definition Classes

    ZIOCompanionVersionSpecific

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

    Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.

    Returns an effect that, when executed, will cautiously run the provided code, catching any exception and translated it into a failed ZIO effect.

    This method should be used whenever you want to take arbitrary code, which may throw exceptions or not be type safe, and convert it into a ZIO effect, which can safely execute that code whenever the effect is executed.

    This variant expects that the provided code will engage in blocking I/O, and therefore, pro-actively executes the code on a dedicated blocking thread pool, so it won't interfere with the main thread pool that ZIO uses.

    Additionally, this variant allows you to specify an effect that will cancel the blocking operation. This effect will be executed if the fiber that is executing the blocking effect is interrupted for any reason.

    Definition Classes

    ZIOCompanionVersionSpecific

25.  def attemptBlockingIO[A](effect: => A)(implicit trace: Trace): IO[IOException, A]

    This function is the same as attempt, except that it only exposes IOException, treating any other exception as fatal.

    This function is the same as attempt, except that it only exposes IOException, treating any other exception as fatal.

    Definition Classes

    ZIOCompanionVersionSpecific

26.  def attemptBlockingIOUnsafe[A](effect: (Unsafe) => A)(implicit trace: Trace): IO[IOException, A]
27.  def attemptBlockingInterrupt[A](effect: => A)(implicit trace: Trace): 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.

    Definition Classes

    ZIOCompanionPlatformSpecific

28.  def attemptUnsafe[A](a: (Unsafe) => A)(implicit trace: Trace): Task[A]
29.  def blocking[R, E, A](zio: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Returns a new effect that, when executed, will execute the original effect on the blocking thread pool.

30.  def blockingExecutor(implicit trace: Trace): UIO[Executor]

    Retrieves the executor for all blocking tasks.

31.  def checkInterruptible[R, E, A](f: (InterruptStatus) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

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

32.  def clock(implicit trace: Trace): UIO[Clock]

    Retrieves the Clock service for this workflow.

33.  def clockWith[R, E, A](f: (Clock) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the Clock service for this workflow and uses it to run the specified workflow.

34.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()

35.  def collect[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, Option[E], (Key2, Value2)])(implicit trace: Trace): 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.

36.  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: Trace): 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.

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

38.  def collectAll[R, E, A](in: Option[ZIO[R, E, A]])(implicit trace: Trace): ZIO[R, E, Option[A]]

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

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

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

41.  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: Trace): 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.

42.  def collectAllDiscard[R, E, A](in: => Iterable[ZIO[R, E, A]])(implicit trace: Trace): 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.

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

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

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

46.  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: Trace): 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.

47.  def collectAllParDiscard[R, E, A](as: => Iterable[ZIO[R, E, A]])(implicit trace: Trace): 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.

48.  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: Trace): URIO[R, Collection[A]]

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

49.  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: Trace): URIO[R, Collection[A]]

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

50.  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: Trace): ZIO[R, E, Collection[B]]

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

51.  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: Trace): ZIO[R, E, Collection[U]]

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

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

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

53.  def collectPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, Option[E], (Key2, Value2)])(implicit trace: Trace): 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.

54.  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: Trace): ZIO[R, E, Collection[B]]

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

55.  def cond[E, A](predicate: => Boolean, result: => A, error: => E)(implicit trace: Trace): 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

56.  def config[A](config: Config[A])(implicit trace: Trace): ZIO[Any, Error, A]

    Uses the current config provider to load the specified config, or fail with an error of type Config.Error.

57.  def configProviderWith[R, E, A](f: (ConfigProvider) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the current config provider, and passes it to the specified function, which may return an effect that uses the provider to perform some work or compute some value.

58.  def console(implicit trace: Trace): UIO[Console]

    Retrieves the Console service for this workflow.

59.  def consoleWith[R, E, A](f: (Console) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the Console service for this workflow and uses it to run the specified workflow.

60.  def debug(value: => Any)(implicit trace: Trace): UIO[Unit]

    Prints the specified message to the console for debugging purposes.

61.  def descriptor(implicit trace: Trace): UIO[Descriptor]

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

62.  def descriptorWith[R, E, A](f: (Descriptor) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

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

63.  def die(t: => Throwable)(implicit trace: Trace): 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.

64.  def dieMessage(message: => String)(implicit trace: Trace): 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.

65.  def done[E, A](r: => Exit[E, A])(implicit trace: Trace): IO[E, A]

    Returns an effect from a zio.Exit value.

66.  def environment[R](implicit trace: Trace): URIO[R, ZEnvironment[R]]

    Accesses the whole environment of the effect.

67.  def environmentWith[R]: EnvironmentWithPartiallyApplied[R]

    Accesses the environment of the effect.

68.  def environmentWithZIO[R]: EnvironmentWithZIOPartiallyApplied[R]

    Effectually accesses the environment of the effect.

69.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

70.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

71.  def executor(implicit trace: Trace): UIO[Executor]

    Retrieves the executor for this effect.

72.  def executorWith[R, E, A](f: (Executor) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Constructs an effect based on the current executor.

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

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

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

75.  def failCause[E](cause: => Cause[E])(implicit trace0: Trace): IO[E, Nothing]

    Returns an effect that models failure with the specified Cause.

76.  def fiberId(implicit trace: Trace): UIO[FiberId.Runtime]

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

77.  def fiberIdWith[R, E, A](f: (FiberId.Runtime) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Constructs an effect based on the FiberId of the fiber executing the effect that calls this method.

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

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

79.  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: Trace): ZIO[R, E, Collection[A]]

    Filters the collection using the specified effectual predicate.

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

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

81.  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: Trace): ZIO[R, E, Collection[A]]

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

82.  def filterNotPar[R, E, A](as: Set[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: Trace): 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.

83.  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: Trace): 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.

84.  def filterPar[R, E, A](as: Set[A])(f: (A) => ZIO[R, E, Boolean])(implicit trace: Trace): 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.

85.  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: Trace): 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.

86.  def firstSuccessOf[R, R1 <: R, E, A](zio: => ZIO[R, E, A], rest: => Iterable[ZIO[R1, E, A]])(implicit trace: Trace): 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.

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

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

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

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

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

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

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

91.  final def foreach[R, E, A, B](in: NonEmptyChunk[A])(f: (A) => ZIO[R, E, B])(implicit trace: Trace): 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.

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

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

93.  def foreach[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, E, (Key2, Value2)])(implicit trace: Trace): 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.

94.  final def foreach[R, E, A, B](in: Array[A])(f: (A) => ZIO[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): 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.

95.  final def foreach[R, E, A, B](in: Set[A])(f: (A) => ZIO[R, E, B])(implicit trace: Trace): 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.

96.  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: Trace): 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 foreachDiscard for a more efficient implementation.

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

98.  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: Trace): 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.

99.  final def foreachPar[R, E, A, B](as: NonEmptyChunk[A])(fn: (A) => ZIO[R, E, B])(implicit trace: Trace): 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.

100.  def foreachPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) => ZIO[R, E, (Key2, Value2)])(implicit trace: Trace): 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.

101.  final def foreachPar[R, E, A, B](as: Array[A])(f: (A) => ZIO[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): 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.

102.  final def foreachPar[R, E, A, B](as: Set[A])(fn: (A) => ZIO[R, E, B])(implicit trace: Trace): 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.

103.  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: Trace): 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.

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

105.  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: Trace): 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.

106.  def forkAllDiscard[R, E, A](as: => Iterable[ZIO[R, E, A]])(implicit trace: Trace): URIO[R, Fiber[E, 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.

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

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

108.  def fromAutoCloseable[R, E, A <: AutoCloseable](fa: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R with Scope, E, A]
109.  def fromCompletableFuture[A](cs: => CompletableFuture[A])(implicit trace: Trace): Task[A]

     Alias for formCompletionStage for a concrete implementation of CompletionStage

     Alias for formCompletionStage for a concrete implementation of CompletionStage

     Definition Classes

     ZIOCompanionPlatformSpecific

110.  def fromCompletionStage[A](cs: => CompletionStage[A])(implicit trace: Trace): Task[A]

     Definition Classes

     ZIOCompanionPlatformSpecific

111.  def fromEither[E, A](v: => Either[E, A])(implicit trace: Trace): IO[E, A]

     Lifts an Either into a ZIO value.

112.  def fromEitherCause[E, A](v: => Either[Cause[E], A])(implicit trace: Trace): IO[E, A]

     Lifts an Either into a ZIO value.

113.  def fromFiber[E, A](fiber: => Fiber[E, A])(implicit trace: Trace): IO[E, A]

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

114.  def fromFiberZIO[R, E, A](fiber: => ZIO[R, E, Fiber[E, A]])(implicit trace: Trace): ZIO[R, E, A]

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

115.  def fromFuture[A](make: (ExecutionContext) => Future[A])(implicit trace: Trace): Task[A]

     Returns an effect that, when executed, will both create and launch a scala.concurrent.Future, feeding it an scala.concurrent.ExecutionContext that is backed by ZIO's own executor.

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

117.  def fromFutureJava[A](future: => Future[A])(implicit trace: Trace): 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

118.  def fromOption[A](v: => Option[A])(implicit trace: Trace): 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.

119.  def fromPromiseScala[A](promise: => scala.concurrent.Promise[A])(implicit trace: Trace): Task[A]

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

120.  def fromTry[A](value: => Try[A])(implicit trace: Trace): Task[A]

     Lifts a Try into a ZIO.

121.  final def getClass(): Class[_ <: AnyRef]

     Definition Classes

     AnyRef → Any

     Annotations

     @IntrinsicCandidate() @native()

122.  def getFiberRefs(implicit trace: Trace): UIO[FiberRefs]

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

123.  final def getOrFail[A](v: => Option[A])(implicit trace: Trace): Task[A]

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

124.  final def getOrFailUnit[A](v: => Option[A])(implicit trace: Trace): IO[Unit, A]

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

125.  final def getOrFailWith[E, A](e: => E)(v: => Option[A])(implicit trace: Trace): 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.

126.  def getState[S](implicit arg0: zio.EnvironmentTag[S], trace: Trace): ZIO[ZState[S], Nothing, S]

     Gets a state from the environment.

127.  def getStateWith[S]: GetStateWithPartiallyApplied[S]

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

128.  def hashCode(): Int

     Definition Classes

     AnyRef → Any

     Annotations

     @IntrinsicCandidate() @native()

129.  def ifZIO[R, E](b: => ZIO[R, E, Boolean]): IfZIO[R, E]

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

130.  def ignore(code: => Any)(implicit trace: Trace): UIO[Unit]

     Returns an effect that, when executed, will cautiously run the provided code, ignoring it success or failure.

     Returns an effect that, when executed, will cautiously run the provided code, ignoring it success or failure.

     Definition Classes

     ZIOCompanionVersionSpecific

131.  def infinity(implicit trace: Trace): UIO[Nothing]

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

132.  def inheritFiberRefs(childFiberRefs: FiberRefs)(implicit trace: Trace): UIO[Unit]

     Inherits values from all FiberRef instances into current fiber.

133.  def interrupt(implicit trace: Trace): UIO[Nothing]

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

134.  def interruptAs(fiberId: => FiberId)(implicit trace: Trace): UIO[Nothing]

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

135.  def interruptible[R, E, A](zio: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Prefix form of ZIO#interruptible.

136.  def interruptibleMask[R, E, A](k: (InterruptibilityRestorer) => ZIO[R, E, A])(implicit trace: Trace): 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.

137.  def isFatal(implicit trace: Trace): UIO[(Throwable) => Boolean]

     Retrieves the definition of a fatal error.

138.  def isFatalWith[R, E, A](f: ((Throwable) => Boolean) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Constructs an effect based on the definition of a fatal error.

139.  final def isInstanceOf[T0]: Boolean

     Definition Classes

     Any

140.  def iterate[R, E, S](initial: => S)(cont: (S) => Boolean)(body: (S) => ZIO[R, E, S])(implicit trace: Trace): 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

141.  def left[A](a: => A)(implicit trace: Trace): UIO[Either[A, Nothing]]

     Returns an effect with the value on the left part.

142.  def log(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the current log level.

143.  def logAnnotate(logAnnotations: => Set[LogAnnotation]): LogAnnotate

     Annotates each log in this effect with the specified log annotation.

144.  def logAnnotate(logAnnotation: => LogAnnotation, logAnnotations: LogAnnotation*): LogAnnotate

     Annotates each log in this effect with the specified log annotation.

145.  def logAnnotate(key: => String, value: => String): LogAnnotate

     Annotates each log in this effect with the specified log annotation.

146.  def logAnnotateScoped(logAnnotations: => Set[LogAnnotation])(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
147.  def logAnnotateScoped(logAnnotation: => LogAnnotation, logAnnotations: LogAnnotation*)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
148.  def logAnnotateScoped(key: => String, value: => String)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
149.  def logAnnotations(implicit trace: Trace): UIO[Map[String, String]]

     Retrieves the log annotations associated with the current scope.

150.  def logCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified message and cause at the current log level.

151.  def logCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the current log level.

152.  def logDebug(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the debug log level.

153.  def logDebugCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the debug log level..

154.  def logDebugCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the debug log level.

155.  def logError(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the error log level.

156.  def logErrorCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause as an error.

157.  def logErrorCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause as an error.

158.  def logFatal(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the fatal log level.

159.  def logFatalCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the fatal log level.

160.  def logFatalCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the fatal log level.

161.  def logInfo(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the informational log level.

162.  def logInfoCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the informational log level..

163.  def logInfoCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the informational log level.

164.  def logLevel(level: LogLevel): LogLevel

     Sets the log level for this effect.

     Sets the log level for this effect.

     ZIO.logLevel(LogLevel.Warning) {
       ZIO.log("The response time exceeded its threshold!")
     }

165.  def logLevelScoped(level: LogLevel)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
166.  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) }

167.  def logSpanScoped(label: => String)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
168.  def logSpans(implicit trace: Trace): UIO[List[zio.LogSpan]]

     Retrieves the log spans associated with the current scope.

169.  def logTrace(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the trace log level.

170.  def logTraceCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the trace log level..

171.  def logTraceCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the trace log level.

172.  def logWarning(message: => String)(implicit trace: Trace): UIO[Unit]

     Logs the specified message at the warning log level.

173.  def logWarningCause(cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the warning log level..

174.  def logWarningCause(message: => String, cause: => Cause[Any])(implicit trace: Trace): UIO[Unit]

     Logs the specified cause at the warning log level.

175.  def loggers(implicit trace: Trace): UIO[Set[ZLogger[String, Any]]]

     Retrieves the current loggers for this effect.

176.  def loggersWith[R, E, A](f: (Set[ZLogger[String, Any]]) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Constructs an effect based on the current loggers.

177.  def loop[R, E, A, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZIO[R, E, A])(implicit trace: Trace): 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

178.  def loopDiscard[R, E, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZIO[R, E, Any])(implicit trace: Trace): 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)
     }

179.  def memoize[R, E, A, B](f: (A) => ZIO[R, E, B])(implicit trace: Trace): UIO[(A) => ZIO[R, E, B]]

     Returns a memoized version of the specified effectual function.

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

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

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

182.  def metrics(implicit trace: Trace): UIO[Metrics]

     Gets current metrics snapshot.

183.  final def ne(arg0: AnyRef): Boolean

     Definition Classes

     AnyRef

184.  def never(implicit trace: Trace): 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 execute this effect will be automatically garbage collected on the JVM when no explicit references to them are held, because they cannot be reactivated.

185.  val none: UIO[Option[Nothing]]

     Returns an effect that succeeds with the None value.

186.  def noneOrFail[E](o: => Option[E])(implicit trace: Trace): IO[E, Unit]

     Lifts an Option into a ZIO.

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

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

     Lifts an Option into a ZIO.

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

188.  def not[R, E](effect: => ZIO[R, E, Boolean])(implicit trace: Trace): ZIO[R, E, Boolean]

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

189.  final def notify(): Unit

     Definition Classes

     AnyRef

     Annotations

     @IntrinsicCandidate() @native()

190.  final def notifyAll(): Unit

     Definition Classes

     AnyRef

     Annotations

     @IntrinsicCandidate() @native()

191.  def onExecutor[R, E, A](executor: => Executor)(zio: ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Returns an effect that will execute the specified effect fully on the provided executor, before potentially returning to the previous executor.

     Returns an effect that will execute the specified effect fully on the provided executor, before potentially returning to the previous executor. See ZIO!.onExecutor.

192.  def onExecutorScoped(executor: => Executor)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]

     Shifts execution to the specified executor and shifts it back to the previous executor, if any, when the scope is closed.

193.  def parallelFinalizers[R, E, A](zio: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Returns a new scoped workflow that runs finalizers added to the scope of this workflow in parallel.

194.  def parallelFinalizersMask[R, E, A](f: (FinalizersRestorer) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
195.  def parallelism(implicit trace: Trace): UIO[Option[Int]]

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

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

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

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

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

199.  def patchFiberRefs(patch: Patch)(implicit trace: Trace): ZIO[Any, Nothing, Unit]

     Applies the specified changes to the FiberRef values for the fiber running this workflow.

200.  def provideEnvironment[R, E, A](r: => ZEnvironment[R])(implicit trace: Trace): (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.

201.  def provideLayer[RIn, E, ROut, RIn2, ROut2](layer: ZLayer[RIn, E, ROut])(zio: ZIO[ROut with RIn2, E, ROut2])(implicit ev: zio.EnvironmentTag[RIn2], tag: zio.EnvironmentTag[ROut], trace: Trace): ZIO[RIn with RIn2, E, ROut2]
202.  def raceAll[R, R1 <: R, E, A](zio: => ZIO[R, E, A], ios: => Iterable[ZIO[R1, E, A]])(implicit trace: Trace): 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.

203.  def raceFirst[R, R1 <: R, E, A](zio: ZIO[R, E, A], ios: Iterable[ZIO[R1, E, A]])(implicit trace: Trace): ZIO[R1, E, A]

     Returns an effect that races this effect with all the specified effects, yielding the first result to complete, whether by success or failure.

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

     WARNING: The raced effect will safely interrupt the "losers", but will not resume until the losers have been cleanly terminated. If early return is desired, then instead of performing ZIO.raceFirst(l, rs), perform ZIO.raceFirst(l.disconnect, rs.map(_.disconnect)), which disconnects left and rights interrupt signal, allowing a fast return, with interruption performed in the background.

204.  def random(implicit trace: Trace): UIO[Random]

     Retreives the Random service for this workflow.

205.  def randomWith[R, E, A](f: (Random) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Retrieves the Random service for this workflow and uses it to run the specified workflow.

206.  def readFile(name: => String)(implicit trace: Trace): ZIO[Any, IOException, String]

     Definition Classes

     ZIOCompanionPlatformSpecific

207.  def readFile(path: => Path)(implicit trace: Trace, d: DummyImplicit): ZIO[Any, IOException, String]

     Definition Classes

     ZIOCompanionPlatformSpecific

208.  def readFileInputStream(name: => String)(implicit trace: Trace): ZIO[Scope, IOException, ZInputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

209.  def readFileInputStream(path: => Path)(implicit trace: Trace, d: DummyImplicit): ZIO[Scope, IOException, ZInputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

210.  def readURIInputStream(uri: => URI)(implicit trace: Trace): ZIO[Scope, IOException, ZInputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

211.  def readURLInputStream(url: => String)(implicit trace: Trace): ZIO[Scope, IOException, ZInputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

212.  def readURLInputStream(url: => URL)(implicit trace: Trace, d: DummyImplicit): ZIO[Scope, IOException, ZInputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

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

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

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

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

215.  def refailCause[E](cause: Cause[E])(implicit trace: Trace): ZIO[Any, E, Nothing]
216.  def replicate[R, E, A](n: Int)(effect: ZIO[R, E, A])(implicit trace: Trace): 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.

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

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

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

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

219.  def right[B](b: => B)(implicit trace: Trace): UIO[Either[Nothing, B]]

     Returns an effect with the value on the right part.

220.  def runtime[R](implicit trace: Trace): 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.

221.  def runtimeFlags(implicit trace: Trace): ZIO[Any, Nothing, RuntimeFlags]

     Retrieves an effect that succeeds with the current runtime flags, which govern behavior and features of the runtime system.

222.  def scope(implicit trace: Trace): ZIO[Scope, Nothing, Scope]

     Returns the current scope.

223.  def scopeWith[R, E, A](f: (Scope) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R with Scope, E, A]

     Accesses the current scope and uses it to perform the specified effect.

224.  def scoped[R]: ScopedPartiallyApplied[R]

     Scopes all resources used in this effect to the lifetime of the effect, ensuring that their finalizers are run as soon as this effect completes execution, whether by success, failure, or interruption.

     Scopes all resources used in this effect to the lifetime of the effect, ensuring that their finalizers are run as soon as this effect completes execution, whether by success, failure, or interruption.

     ZIO.scoped {
       openFile(name).flatMap(useFile)
     }

225.  def scopedWith[R, E, A](f: (Scope) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Creates a scope, uses it to perform the specified effect, and closes the scope as soon as the effect completes, whether by success, failure, or interruption.

226.  def sequentialFinalizers[R, E, A](zio: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Returns a new scoped workflow that runs finalizers added to the scope of this workflow sequentially in the reverse of the order in which they were added.

     Returns a new scoped workflow that runs finalizers added to the scope of this workflow sequentially in the reverse of the order in which they were added. Note that finalizers are run sequentially by default so this only has meaning if used within a scope where finalizers are being run in parallel.

227.  def service[A](implicit arg0: Tag[A], trace: Trace): URIO[A, A]

     Accesses the specified service in the environment of the effect.

228.  def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

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

229.  def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

     Accesses the specified service in the environment of the effect.

     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))

230.  def serviceWithZIO[Service]: ServiceWithZIOPartiallyApplied[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.serviceWithZIO[Foo](_.foo(int))

231.  def setFiberRefs(fiberRefs: => FiberRefs)(implicit trace: Trace): UIO[Unit]

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

232.  def setState[S](s: => S)(implicit arg0: zio.EnvironmentTag[S], trace: Trace): ZIO[ZState[S], Nothing, Unit]

     Sets a state in the environment to the specified value.

233.  def shift(executor: => Executor)(implicit trace: Trace): 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.

234.  def sleep(duration: => zio.Duration)(implicit trace: Trace): UIO[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.

235.  def some[A](a: => A)(implicit trace: Trace): UIO[Option[A]]

     Returns an effect with the optional value.

236.  def stackTrace(implicit trace: Trace): UIO[StackTrace]

     Capture ZIO stack trace at the current point.

237.  def stateful[R]: StatefulPartiallyApplied[R]

     Provides a stateful ZIO workflow with its initial state, resulting in a workflow that is ready to be run.

     Provides a stateful ZIO workflow with its initial state, resulting in a workflow that is ready to be run.

     ZIO.stateful(0) {
       for {
           _     <- ZIO.updateState[Int](_ + 1)
           state <- ZIO.getState[Int]
         } yield assertTrue(state == 1)
       }

238.  def statefulPatch[R]: StatefulPatchPartiallyApplied[R]

     Provides a stateful ZIO workflow with its initial state, using the specified patch type to combine updates to the state by different fibers in a compositional way.

239.  def succeed[A](a: => A)(implicit trace: Trace): ZIO[Any, Nothing, A]

     Returns an effect that models success with the specified value.

     Returns an effect that models success with the specified value.

     Definition Classes

     ZIOCompanionVersionSpecific

240.  def succeedBlocking[A](a: => A)(implicit trace: Trace): UIO[A]

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

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

     Definition Classes

     ZIOCompanionVersionSpecific

241.  def succeedBlockingUnsafe[A](a: (Unsafe) => A)(implicit trace: Trace): UIO[A]
242.  def succeedUnsafe[A](a: (Unsafe) => A)(implicit trace: Trace): UIO[A]
243.  def suspend[R, A](rio: => RIO[R, A])(implicit trace: Trace): 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)).

244.  def suspendSucceed[R, E, A](zio: => ZIO[R, E, A])(implicit trace: Trace): 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 ZIO.suspend.

245.  def suspendSucceedUnsafe[R, E, A](zio: (Unsafe) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
246.  final def synchronized[T0](arg0: => T0): T0

     Definition Classes

     AnyRef

247.  def system(implicit trace: Trace): UIO[System]

     Retrieves the System service for this workflow.

248.  def systemWith[R, E, A](f: (System) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Retrieves the System service for this workflow and uses it to run the specified workflow.

249.  def tagged(tags: => Set[MetricLabel]): Tagged

     Tags each metric in this effect with the specific tag.

250.  def tagged(tag: => MetricLabel, tags: MetricLabel*): Tagged

     Tags each metric in this effect with the specific tag.

251.  def tagged(key: => String, value: => String): Tagged

     Tags each metric in this effect with the specific tag.

252.  def taggedScoped(tags: => Set[MetricLabel])(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
253.  def taggedScoped(tag: => MetricLabel, tags: MetricLabel*)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
254.  def taggedScoped(key: => String, value: => String)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
255.  def tags(implicit trace: Trace): ZIO[Any, Nothing, Set[MetricLabel]]

     Retrieves the metric tags associated with the current scope.

256.  def toString(): String

     Definition Classes

     AnyRef → Any

257.  def transplant[R, E, A](f: (Grafter) => ZIO[R, E, A])(implicit trace: Trace): 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.

258.  def uninterruptible[R, E, A](zio: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Prefix form of ZIO#uninterruptible.

259.  def uninterruptibleMask[R, E, A](f: (InterruptibilityRestorer) => ZIO[R, E, A])(implicit trace: Trace): 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.

260.  val unit: UIO[Unit]

     An effect that succeeds with a unit value.

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

     The moral equivalent of if (!p) exp

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

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

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

264.  def unshift(implicit trace: Trace): 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.

265.  def updateFiberRefs(f: (FiberId.Runtime, FiberRefs) => FiberRefs)(implicit trace: Trace): UIO[Unit]

     Updates the FiberRef values for the fiber running this effect using the specified function.

266.  def updateRuntimeFlags(patch: Patch)(implicit trace: Trace): ZIO[Any, Nothing, Unit]

     Updates the runtime flags.

     Updates the runtime flags. This may have a performance impact. For a higher-performance variant, see ZIO#withRuntimeFlags.

267.  def updateState[S](f: (S) => S)(implicit arg0: zio.EnvironmentTag[S], trace: Trace): ZIO[ZState[S], Nothing, Unit]

     Updates a state in the environment with the specified function.

268.  def using[R]: UsingPartiallyApplied[R]

     Scopes all resources acquired by resource to the lifetime of use without effecting the scope of any resources acquired by use.

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

270.  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: Trace): 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.

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

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

272.  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: Trace): 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.

273.  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: Trace): 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.

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

275.  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: Trace): 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.

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

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

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

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

278.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException]) @native()

279.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

280.  def when[R, E, A](p: => Boolean)(zio: => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, Option[A]]

     The moral equivalent of if (p) exp

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

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

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

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

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

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

284.  def whileLoop[R, E, A](check: => Boolean)(body: => ZIO[R, E, A])(process: (A) => Any)(implicit trace: Trace): ZIO[R, E, Unit]

     A low-level while-loop with direct support in the ZIO runtime.

     A low-level while-loop with direct support in the ZIO runtime. The only reason to use this constructor is performance.

     See ZIO.iterate for a user-friendly version of this operator that is compatible with purely functional code.

285.  def withChildren[R, E, A](get: (UIO[Chunk[Fiber.Runtime[Any, Any]]]) => ZIO[R, E, A])(implicit trace: Trace): 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.

286.  def withClock[R, E, A <: Clock, B](clock: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

     Executes the specified workflow with the specified implementation of the clock service.

287.  def withClockScoped[A <: Clock](clock: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

     Sets the implementation of the clock service to the specified value and restores it to its original value when the scope is closed.

288.  def withConfigProvider[R, E, A <: ConfigProvider, B](configProvider: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

     Executes the specified workflow with the specified configuration provider.

289.  def withConfigProviderScoped[A <: ConfigProvider](configProvider: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

     Sets the configuration provider to the specified value and restores it to its original value when the scope is closed.

290.  def withConsole[R, E, A <: Console, B](console: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

     Executes the specified workflow with the specified implementation of the console service.

291.  def withConsoleScoped[A <: Console](console: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

     Sets the implementation of the console service to the specified value and restores it to its original value when the scope is closed.

292.  def withLogger[R, E, A <: ZLogger[String, Any], B](logger: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

     Executed this workflow with the specified logger added.

293.  def withLoggerScoped[A <: ZLogger[String, Any]](logger: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

     Adds the specified logger and removes it when the scope is closed.

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

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

295.  def withParallelismMask[R, E, A](n: => Int)(f: (ParallelismRestorer) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Runs the specified effect with the specified maximum number of fibers for parallel operators, but passes it a restore function that can be used to restore the inherited parallelism from whatever region the effect is composed into.

296.  def withParallelismUnbounded[R, E, A](zio: ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

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

297.  def withParallelismUnboundedMask[R, E, A](f: (ParallelismRestorer) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

     Runs the specified effect with an unbounded maximum number of fibers for parallel operators, but passes it a restore function that can be used to restore the inherited parallelism from whatever region the effect is composed into.

298.  def withRandom[R, E, A <: Random, B](random: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

     Executes the specified workflow with the specified implementation of the random service.

299.  def withRandomScoped[A <: Random](random: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

     Sets the implementation of the random service to the specified value and restores it to its original value when the scope is closed.

300.  def withRuntimeFlagsScoped(update: Patch)(implicit trace: Trace): ZIO[Scope, Nothing, Unit]
301.  def withSystem[R, E, A <: System, B](system: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

     Executes the specified workflow with the specified implementation of the system service.

302.  def withSystemScoped[A <: System](system: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

     Sets the implementation of the system service to the specified value and restores it to its original value when the scope is closed.

303.  def writeFile(path: => Path, content: => String)(implicit trace: Trace, d: DummyImplicit): ZIO[Any, IOException, Unit]

     Definition Classes

     ZIOCompanionPlatformSpecific

304.  def writeFile(path: => String, content: => String)(implicit trace: Trace): ZIO[Any, IOException, Unit]

     Definition Classes

     ZIOCompanionPlatformSpecific

305.  def writeFileOutputStream(path: => Path)(implicit trace: Trace, d: DummyImplicit): ZIO[Scope, IOException, ZOutputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

306.  def writeFileOutputStream(path: => String)(implicit trace: Trace): ZIO[Scope, IOException, ZOutputStream]

     Definition Classes

     ZIOCompanionPlatformSpecific

307.  def yieldNow(implicit trace: Trace): 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.

308.  object CanFilter
309.  object Continuation
310.  object FinalizersRestorer
311.  object InterruptibilityRestorer
312.  object ParallelismRestorer
313.  object ZIOConstructor extends ZIOConstructorLowPriority1