object ZIO extends ZIOCompanionPlatformSpecific with Serializable
- Alphabetic
- By Inheritance
- ZIO
- Serializable
- Serializable
- ZIOCompanionPlatformSpecific
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- final class AccessMPartiallyApplied[R] extends AnyVal
- final class AccessPartiallyApplied[R] extends AnyVal
- final class BracketAcquire[-R, +E, +A] extends AnyVal
- final class BracketAcquire_[-R, +E] extends AnyVal
- final class BracketExitAcquire[-R, +E, +A] extends AnyVal
- final class BracketExitRelease[-R, +E, E1, +A, B] extends AnyRef
- final class BracketRelease[-R, +E, +A] extends AnyRef
- final class BracketReleaseFn[R, E, A, B] extends ZIOFn2[A, Exit[E, B], URIO[R, Any]]
- final class BracketRelease_[-R, +E] extends AnyRef
-
abstract
class
CanFilter[+E] extends AnyRef
- Annotations
- @implicitNotFound( ... )
- final class ConstFn[A, B] extends ZIOFn1[A, B]
- final class ConstZIOFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]
- final class FoldCauseMFailureFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, A]]
- final class FoldCauseMFailureTraceFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, A]]
- final class ForkScopeRestore extends AnyVal
- final class Grafter extends AnyVal
- final class IfM[R, E] extends AnyVal
- final class InterruptStatusRestore extends AnyVal
- final class MapErrorCauseFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, Nothing]]
- final class MapErrorFn[R, E, E2, A] extends ZIOFn1[Cause[E], ZIO[R, E2, Nothing]]
- final class MapFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]
- final class ProvideSomeLayer[R0 <: Has[_], -R, +E, +A] extends AnyVal
- final class SucceedFn[R, E, A] extends ZIOFn1[A, ZIO[R, E, A]]
- final class TapCauseRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]
- final class TapErrorRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]
- final class TapErrorTraceRefailFn[R, E, E1 >: E, A] extends ZIOFn1[Cause[E], ZIO[R, E1, Nothing]]
- final class TapFn[R, E, A] extends ZIOFn1[A, ZIO[R, E, A]]
- final class TimeoutTo[-R, +E, +A, +B] extends AnyRef
- final class UnlessM[R, E] extends AnyVal
- final class UpdateService[-R, +E, +A, M] extends AnyVal
- final class WhenM[R, E] extends AnyVal
- implicit final class ZIOAutoCloseableOps[R, E, A <: AutoCloseable] extends AnyVal
- implicit final class ZIOWithFilterOps[R, E, A] extends AnyVal
- implicit final class ZioRefineToOrDieOps[R, E <: Throwable, A] extends AnyVal
- final class ZipLeftFn[R, E, A, B] extends ZIOFn1[B, ZIO[R, E, B]]
- final class ZipRightFn[R, E, A, B] extends ZIOFn1[A, ZIO[R, E, B]]
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
absolve[R, E, A](v: ZIO[R, E, Either[E, A]]): ZIO[R, E, A]
Submerges the error case of an
Either
into theZIO
.Submerges the error case of an
Either
into theZIO
. The inverse operation ofIO.either
. -
def
access[R]: AccessPartiallyApplied[R]
Accesses the environment of the effect.
Accesses the environment of the effect.
val portNumber = effect.access(_.config.portNumber)
-
def
accessM[R]: AccessMPartiallyApplied[R]
Effectfully accesses the environment of the effect.
-
def
allowInterrupt: UIO[Unit]
Makes an explicit check to see if the fiber has been interrupted, and if so, performs self-interruption
- def apply[A](a: ⇒ A): Task[A]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bracket[R, E, A, B](acquire: ZIO[R, E, A], release: (A) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]
Uncurried version.
Uncurried version. Doesn't offer curried syntax and have worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketAcquire and zio.ZIO.BracketRelease objects.
-
def
bracket[R, E, A](acquire: ZIO[R, E, A]): BracketAcquire[R, E, A]
When this effect represents acquisition of a resource (for example, opening a file, launching a thread, etc.),
bracket
can be used to ensure the acquisition is not interrupted and the resource is always released.When this effect represents acquisition of a resource (for example, opening a file, launching a thread, etc.),
bracket
can be used to ensure the acquisition is not interrupted and the resource is always released.The function does two things:
1. Ensures this effect, which acquires the resource, will not be interrupted. Of course, acquisition may fail for internal reasons (an uncaught exception). 2. Ensures the
release
effect will not be interrupted, and will be executed so long as this effect successfully acquires the resource.In between acquisition and release of the resource, the
use
effect is executed.If the
release
effect fails, then the entire effect will fail even if theuse
effect succeeds. If this fail-fast behavior is not desired, errors produced by therelease
effect can be caught and ignored.openFile("data.json").bracket(closeFile) { file => for { header <- readHeader(file) ... } yield result }
-
def
bracketExit[R, E, A, B](acquire: ZIO[R, E, A], release: (A, Exit[E, B]) ⇒ URIO[R, Any], use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]
Uncurried version.
Uncurried version. Doesn't offer curried syntax and has worse type-inference characteristics, but guarantees no extra allocations of intermediate zio.ZIO.BracketExitAcquire and zio.ZIO.BracketExitRelease objects.
-
def
bracketExit[R, E, A](acquire: ZIO[R, E, A]): BracketExitAcquire[R, E, A]
Acquires a resource, uses the resource, and then releases the resource.
Acquires a resource, uses the resource, and then releases the resource. Neither the acquisition nor the release will be interrupted, and the resource is guaranteed to be released, so long as the
acquire
effect succeeds. Ifuse
fails, then after release, the returned effect will fail with the same error. -
def
checkInterruptible[R, E, A](f: (zio.InterruptStatus) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Checks the interrupt status, and produces the effect returned by the specified callback.
-
def
checkTraced[R, E, A](f: (zio.TracingStatus) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Checks the ZIO Tracing status, and produces the effect returned by the specified callback.
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
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]]): 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
. -
def
collectAll[R, E, A](in: NonEmptyChunk[ZIO[R, E, A]]): 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
. -
def
collectAll[R, E, A](in: Array[ZIO[R, E, A]])(implicit arg0: ClassTag[A]): 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
. -
def
collectAll[R, E, A](in: Set[ZIO[R, E, A]]): 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
. -
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]]): 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
. -
def
collectAllPar[R, E, A](as: NonEmptyChunk[ZIO[R, E, A]]): 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
. -
def
collectAllPar[R, E, A](as: Array[ZIO[R, E, A]])(implicit arg0: ClassTag[A]): 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
. -
def
collectAllPar[R, E, A](as: Set[ZIO[R, E, A]]): 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
. -
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]]): 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
. -
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]]): 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 mostn
fibers. -
def
collectAllParN_[R, E, A](n: Int)(as: Iterable[ZIO[R, E, A]]): 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 mostn
fibers. -
def
collectAllPar_[R, E, A](as: Iterable[ZIO[R, E, A]]): 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_
. -
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]]): URIO[R, Collection[A]]
Evaluate and run each effect in the structure and collect discarding failed ones.
-
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]]): URIO[R, Collection[A]]
Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
-
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]]): 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 ton
fibers. -
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]]): ZIO[R, E, Collection[B]]
Evaluate each effect in the structure with
collectAll
, and collect the results with given partial function. -
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]]): ZIO[R, E, Collection[U]]
Evaluate each effect in the structure with
collectAllPar
, and collect the results with given partial function. -
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]]): 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 ton
fibers. -
def
collectAll_[R, E, A](in: Iterable[ZIO[R, E, A]]): 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_
. -
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]]): ZIO[R, E, Collection[B]]
Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.
-
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]]): 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 ton
fibers. -
def
cond[E, A](predicate: Boolean, result: ⇒ A, error: ⇒ E): 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.ifM
-
def
descriptor: UIO[Fiber.Descriptor]
Returns information about the current fiber, such as its identity.
-
def
descriptorWith[R, E, A](f: (Fiber.Descriptor) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Constructs an effect based on information about the current fiber, such as its identity.
-
def
die(t: ⇒ Throwable): UIO[Nothing]
Returns an effect that dies with the specified
Throwable
.Returns an effect that dies with the specified
Throwable
. This method can be used for terminating a fiber because a defect has been detected in the code. -
def
dieMessage(message: ⇒ String): UIO[Nothing]
Returns an effect that dies with a java.lang.RuntimeException having the specified text message.
Returns an effect that dies with a java.lang.RuntimeException having the specified text message. This method can be used for terminating a fiber because a defect has been detected in the code.
-
def
done[E, A](r: ⇒ Exit[E, A]): IO[E, A]
Returns an effect from a zio.Exit value.
-
def
effect[A](effect: ⇒ A): Task[A]
Imports a synchronous side-effect into a pure
ZIO
value, translating any thrown exceptions into typed failed effects creating withZIO.fail
.Imports a synchronous side-effect into a pure
ZIO
value, translating any thrown exceptions into typed failed effects creating withZIO.fail
.def putStrLn(line: String): Task[Unit] = Task.effect(println(line))
-
def
effectAsync[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Any, blockingOn: List[Id] = Nil): ZIO[R, E, A]
Imports an asynchronous side-effect into a pure
ZIO
value.Imports an asynchronous side-effect into a pure
ZIO
value. SeeeffectAsyncMaybe
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.
-
def
effectAsyncInterrupt[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Either[Canceler[R], ZIO[R, E, A]], blockingOn: List[Id] = Nil): ZIO[R, E, A]
Imports an asynchronous side-effect into a ZIO effect.
Imports an asynchronous side-effect into a ZIO effect. The side-effect has the option of returning the value synchronously, which is useful in cases where it cannot be determined if the effect is synchronous or asynchronous until the side-effect is actually executed. The effect also has the option of returning a canceler, which will be used by the runtime to cancel the asynchronous effect if the fiber executing the effect is interrupted.
If the register function returns a value synchronously, then the callback function
ZIO[R, E, A] => 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.
-
def
effectAsyncM[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ ZIO[R, E, Any]): ZIO[R, E, A]
Imports an asynchronous effect into a pure
ZIO
value.Imports an asynchronous effect into a pure
ZIO
value. This formulation is necessary when the effect is itself expressed in terms ofZIO
. -
def
effectAsyncMaybe[R, E, A](register: ((ZIO[R, E, A]) ⇒ Unit) ⇒ Option[ZIO[R, E, A]], blockingOn: List[Id] = Nil): ZIO[R, E, A]
Imports an asynchronous effect into a pure
ZIO
value, possibly returning the value synchronously.Imports an asynchronous effect into a pure
ZIO
value, possibly returning the value synchronously.If the register function returns a value synchronously, then the callback function
ZIO[R, E, A] => 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.
-
def
effectSuspend[R, A](rio: ⇒ RIO[R, A]): RIO[R, A]
Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. When no environment is required (i.e., when R == Any) it is conceptually equivalent to
flatten(effect(io))
. -
def
effectSuspendTotal[R, E, A](zio: ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == Any) it is conceptually equivalent to
flatten(effectTotal(zio))
. If you wonder if the effect throws exceptions, do not use this method, use Task.effectSuspend or ZIO.effectSuspend. -
def
effectSuspendTotalWith[R, E, A](f: (Platform, Id) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == Any) it is conceptually equivalent to
flatten(effectTotal(zio))
. If you wonder if the effect throws exceptions, do not use this method, use Task.effectSuspend or ZIO.effectSuspend. -
def
effectSuspendWith[R, A](f: (Platform, Id) ⇒ RIO[R, A]): RIO[R, A]
Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. When no environment is required (i.e., when R == Any) it is conceptually equivalent to
flatten(effect(io))
. -
def
effectTotal[A](effect: ⇒ A): UIO[A]
Imports a total synchronous effect into a pure
ZIO
value.Imports a total synchronous effect into a pure
ZIO
value. The effect must not throw any exceptions. If you wonder if the effect throws exceptions, then do not use this method, use Task.effect, IO.effect, or ZIO.effect.val nanoTime: UIO[Long] = IO.effectTotal(System.nanoTime())
-
def
environment[R]: URIO[R, R]
Accesses the whole environment of the effect.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
executor: UIO[Executor]
Retrieves the executor for this effect.
-
def
fail[E](error: ⇒ E): IO[E, Nothing]
Returns an effect that models failure with the specified error.
Returns an effect that models failure with the specified error. The moral equivalent of
throw
for pure code. -
val
fiberId: UIO[Id]
Returns the
Fiber.Id
of the fiber executing the effect that calls this method. -
def
filter[R, E, A](as: Set[A])(f: (A) ⇒ ZIO[R, E, Boolean]): ZIO[R, E, Set[A]]
Filters the Set[A] using the specified effectual predicate.
-
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]]): ZIO[R, E, Collection[A]]
Filters the collection using the specified effectual predicate.
-
def
filterNot[R, E, A](as: Set[A])(f: (A) ⇒ ZIO[R, E, Boolean]): ZIO[R, E, Set[A]]
Filters the Set[A] using the specified effectual predicate, removing all elements that satisfy the predicate.
-
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]]): ZIO[R, E, Collection[A]]
Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.
-
def
filterNotPar[R, E, A](as: Set[A])(f: (A) ⇒ ZIO[R, E, Boolean]): 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 filterNot[R,E,A](as:Set* for a sequential version of it.
-
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]]): ZIO[R, E, Collection[A]]
Filters the collection in parallel using the specified effectual predicate, removing all elements that satisfy the predicate.
Filters the collection in parallel using the specified effectual predicate, removing all elements that satisfy the predicate. See filterNot[R,E,A,Collection* for a sequential version of it.
-
def
filterPar[R, E, A](as: Set[A])(f: (A) ⇒ ZIO[R, E, Boolean]): 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 filter[R,E,A,Collection* for a sequential version of it.
-
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]]): 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 filter[R,E,A,Collection* for a sequential version of it.
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
first[A]: ZIO[(A, Any), Nothing, A]
Returns an effectful function that extracts out the first element of a tuple.
-
def
firstSuccessOf[R, R1 <: R, E, A](zio: ZIO[R, E, A], rest: Iterable[ZIO[R1, E, A]]): ZIO[R1, E, A]
Returns an effect that runs the first effect and in case of failure, runs each of the specified effects in order until one of them succeeds.
-
def
flatten[R, E, A](zio: ZIO[R, E, ZIO[R, E, A]]): ZIO[R, E, A]
Returns an effect that first executes the outer effect, and then executes the inner effect, returning the value from the inner effect, and effectively flattening a nested effect.
-
def
foldLeft[R, E, S, A](in: Iterable[A])(zero: S)(f: (S, A) ⇒ ZIO[R, E, S]): ZIO[R, E, S]
Folds an Iterable[A] using an effectual function f, working sequentially from left to right.
-
def
foldRight[R, E, S, A](in: Iterable[A])(zero: S)(f: (A, S) ⇒ ZIO[R, E, S]): ZIO[R, E, S]
Folds an Iterable[A] using an effectual function f, working sequentially from right to left.
-
final
def
foreach[R, E, A, B](in: NonEmptyChunk[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, NonEmptyChunk[B]]
Applies the function
f
to each element of theNonEmptyChunk[A]
and returns the results in a newNonEmptyChunk[B]
.Applies the function
f
to each element of theNonEmptyChunk[A]
and returns the results in a newNonEmptyChunk[B]
.For a parallel version of this method, see
foreachPar
. If you do not need the results, seeforeach_
for a more efficient implementation. -
final
def
foreach[R, E, A, B](in: Option[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Option[B]]
Applies the function
f
if the argument is non-empty and returns the results in a newOption[B]
. -
def
foreach[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZIO[R, E, (Key2, Value2)]): ZIO[R, E, Map[Key2, Value2]]
Applies the function
f
to each element of theMap[Key, Value]
and returns the results in a newMap[Key2, Value2]
.Applies the function
f
to each element of theMap[Key, Value]
and returns the results in a newMap[Key2, Value2]
.For a parallel version of this method, see
foreachPar
. If you do not need the results, seeforeach_
for a more efficient implementation. -
final
def
foreach[R, E, A, B](in: Array[A])(f: (A) ⇒ ZIO[R, E, B])(implicit arg0: ClassTag[B]): ZIO[R, E, Array[B]]
Applies the function
f
to each element of theArray[A]
and returns the results in a newArray[B]
.Applies the function
f
to each element of theArray[A]
and returns the results in a newArray[B]
.For a parallel version of this method, see
foreachPar
. If you do not need the results, seeforeach_
for a more efficient implementation. -
final
def
foreach[R, E, A, B](in: Set[A])(f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Set[B]]
Applies the function
f
to each element of theSet[A]
and returns the results in a newSet[B]
.Applies the function
f
to each element of theSet[A]
and returns the results in a newSet[B]
.For a parallel version of this method, see
foreachPar
. If you do not need the results, seeforeach_
for a more efficient implementation. -
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]]): ZIO[R, E, Collection[B]]
Applies the function
f
to each element of theCollection[A]
and returns the results in a newCollection[B]
.Applies the function
f
to each element of theCollection[A]
and returns the results in a newCollection[B]
.For a parallel version of this method, see
foreachPar
. If you do not need the results, seeforeach_
for a more efficient implementation. -
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]]): ZIO[R, E, Collection[B]]
Applies the function
f
to each element of theCollection[A]
and returns the result in a newCollection[B]
using the specified execution strategy. -
final
def
foreachPar[R, E, A, B](as: NonEmptyChunk[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, NonEmptyChunk[B]]
Applies the function
f
to each element of theNonEmptyChunk[A]
in parallel, and returns the results in a newNonEmptyChunk[B]
.Applies the function
f
to each element of theNonEmptyChunk[A]
in parallel, and returns the results in a newNonEmptyChunk[B]
.For a sequential version of this method, see
foreach
. -
def
foreachPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZIO[R, E, (Key2, Value2)]): ZIO[R, E, Map[Key2, Value2]]
Applies the function
f
to each element of theMap[Key, Value]
in parallel and returns the results in a newMap[Key2, Value2]
.Applies the function
f
to each element of theMap[Key, Value]
in parallel and returns the results in a newMap[Key2, Value2]
.For a sequential version of this method, see
foreach
. -
final
def
foreachPar[R, E, A, B](as: Array[A])(f: (A) ⇒ ZIO[R, E, B])(implicit arg0: ClassTag[B]): ZIO[R, E, Array[B]]
Applies the function
f
to each element of theArray[A]
in parallel, and returns the results in a newArray[B]
.Applies the function
f
to each element of theArray[A]
in parallel, and returns the results in a newArray[B]
.For a sequential version of this method, see
foreach
. -
final
def
foreachPar[R, E, A, B](as: Set[A])(fn: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Set[B]]
Applies the function
f
to each element of theSet[A]
in parallel, and returns the results in a newSet[B]
.Applies the function
f
to each element of theSet[A]
in parallel, and returns the results in a newSet[B]
.For a sequential version of this method, see
foreach
. -
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]]): ZIO[R, E, Collection[B]]
Applies the function
f
to each element of theCollection[A]
in parallel, and returns the results in a newCollection[B]
.Applies the function
f
to each element of theCollection[A]
in parallel, and returns the results in a newCollection[B]
.For a sequential version of this method, see
foreach
. -
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]]): ZIO[R, E, Collection[B]]
Applies the function
f
to each element of theCollection[A]
in parallel, and returns the results in a newCollection[B]
.Applies the function
f
to each element of theCollection[A]
in parallel, and returns the results in a newCollection[B]
.Unlike
foreachPar
, this method will use at most up ton
fibers. -
def
foreachParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.Unlike
foreachPar_
, this method will use at most up ton
fibers. -
def
foreachPar_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and runs produced effects in parallel, discarding the results.Applies the function
f
to each element of theIterable[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.
-
def
foreach_[R, E, A](as: Iterable[A])(f: (A) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and runs produced effects sequentially.Applies the function
f
to each element of theIterable[A]
and runs produced effects sequentially.Equivalent to
foreach(as)(f).unit
, but without the cost of building the list of results. -
def
forkAll[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZIO[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZIO[R, E, A]], A, Collection[A]]): 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.
-
def
forkAll_[R, E, A](as: Iterable[ZIO[R, E, A]]): URIO[R, Unit]
Returns an effect that forks all of the specified values, and returns a composite fiber that produces unit.
Returns an effect that forks all of the specified values, and returns a composite fiber that produces unit. This version is faster than forkAll in cases where the results of the forked fibers are not needed.
-
def
forkScope: UIO[ZScope[Exit[Any, Any]]]
Retrieves the scope that will be used to supervise forked effects.
-
def
forkScopeMask[R, E, A](newScope: ZScope[Exit[Any, Any]])(f: (ForkScopeRestore) ⇒ ZIO[R, E, A]): 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.
-
def
forkScopeWith[R, E, A](f: (ZScope[Exit[Any, Any]]) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Retrieves the scope that will be used to supervise forked effects.
-
def
fromEither[E, A](v: ⇒ Either[E, A]): IO[E, A]
Lifts an
Either
into aZIO
value. -
def
fromFiber[E, A](fiber: ⇒ Fiber[E, A]): IO[E, A]
Creates a
ZIO
value that represents the exit value of the specified fiber. -
def
fromFiberM[E, A](fiber: IO[E, Fiber[E, A]]): IO[E, A]
Creates a
ZIO
value that represents the exit value of the specified fiber. -
def
fromFunction[R, A](f: (R) ⇒ A): URIO[R, A]
Lifts a function
R => A
into aURIO[R, A]
. -
def
fromFunctionFuture[R, A](f: (R) ⇒ Future[A]): RIO[R, A]
Lifts a function returning Future into an effect that requires the input to the function.
-
def
fromFunctionM[R, E, A](f: (R) ⇒ IO[E, A]): ZIO[R, E, A]
Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.
-
def
fromFuture[A](make: (ExecutionContext) ⇒ Future[A]): Task[A]
Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a
ZIO
. -
def
fromFutureInterrupt[A](make: (ExecutionContext) ⇒ Future[A]): Task[A]
Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a
ZIO
.Imports a function that creates a scala.concurrent.Future from an scala.concurrent.ExecutionContext into a
ZIO
. The providedExecutionContext
will interrupt theFuture
between asynchronous operations such asmap
andflatMap
if this effect is interrupted. Note that no attempt will be made to interrupt aFuture
blocking on a synchronous operation and that theFuture
must be created using the providedExecutionContext
. -
def
fromOption[A](v: ⇒ Option[A]): IO[Option[Nothing], A]
Lifts an
Option
into aZIO
but preserves the error as an option in the error channel, making it easier to compose in some scenarios. -
def
fromPromiseJS[A](promise: ⇒ scala.scalajs.js.Promise[A]): Task[A]
Imports a Scala.js promise into a
ZIO
.Imports a Scala.js promise into a
ZIO
.- Definition Classes
- ZIOCompanionPlatformSpecific
-
def
fromPromiseScala[A](promise: scala.concurrent.Promise[A]): Task[A]
Imports a scala.concurrent.Promise we generate a future from promise, and we pass to [fromFuture] to transform into Task[A]
-
def
fromTry[A](value: ⇒ Try[A]): Task[A]
Lifts a
Try
into aZIO
. -
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
getOrFail[A](v: ⇒ Option[A]): Task[A]
Lifts an Option into a ZIO, if the option is not defined it fails with NoSuchElementException.
-
final
def
getOrFailUnit[A](v: ⇒ Option[A]): IO[Unit, A]
Lifts an Option into a IO, if the option is not defined it fails with Unit.
-
final
def
getOrFailWith[E, A](e: ⇒ E)(v: ⇒ Option[A]): 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. -
def
halt[E](cause: ⇒ Cause[E]): IO[E, Nothing]
Returns an effect that models failure with the specified
Cause
. -
def
haltWith[E](function: (() ⇒ ZTrace) ⇒ Cause[E]): IO[E, Nothing]
Returns an effect that models failure with the specified
Cause
.Returns an effect that models failure with the specified
Cause
.This version takes in a lazily-evaluated trace that can be attached to the
Cause
viaCause.Traced
. -
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
identity[R]: URIO[R, R]
Returns the identity effectful function, which performs no effects
-
def
ifM[R, E](b: ZIO[R, E, Boolean]): IfM[R, E]
Runs
onTrue
if the result ofb
istrue
andonFalse
otherwise. -
val
infinity: URIO[Clock, Nothing]
Like never, but fibers that running this effect won't be garbage collected unless interrupted.
-
val
interrupt: UIO[Nothing]
Returns an effect that is interrupted as if by the fiber calling this method.
-
def
interruptAs(fiberId: ⇒ Id): UIO[Nothing]
Returns an effect that is interrupted as if by the specified fiber.
-
def
interruptible[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]
Prefix form of
ZIO#interruptible
. -
def
interruptibleMask[R, E, A](k: (InterruptStatusRestore) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Makes the effect interruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
iterate[R, E, S](initial: S)(cont: (S) ⇒ Boolean)(body: (S) ⇒ ZIO[R, E, S]): ZIO[R, E, S]
Iterates with the specified effectual function.
Iterates with the specified effectual function. The moral equivalent of:
var s = initial while (cont(s)) { s = body(s) } s
-
def
left[A](a: ⇒ A): UIO[Either[A, Nothing]]
Returns an effect with the value on the left part.
-
def
lock[R, E, A](executor: ⇒ Executor)(zio: ZIO[R, E, A]): ZIO[R, E, A]
Returns an effect that will execute the specified effect fully on the provided executor, before returning to the default executor.
Returns an effect that will execute the specified effect fully on the provided executor, before returning to the default executor. See ZIO!.lock.
-
def
loop[R, E, A, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ ZIO[R, E, A]): ZIO[R, E, List[A]]
Loops with the specified effectual function, collecting the results into a list.
Loops with the specified effectual function, collecting the results into a list. The moral equivalent of:
var s = initial var as = List.empty[A] while (cont(s)) { as = body(s) :: as s = inc(s) } as.reverse
-
def
loop_[R, E, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]
Loops with the specified effectual function purely for its effects.
Loops with the specified effectual function purely for its effects. The moral equivalent of:
var s = initial while (cont(s)) { body(s) s = inc(s) }
-
def
mapN[R, E, A, B, C, D, F](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C], zio4: ZIO[R, E, D])(f: (A, B, C, D) ⇒ F): ZIO[R, E, F]
Sequentially zips the specified effects using the specified combiner function.
-
def
mapN[R, E, A, B, C, D](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C])(f: (A, B, C) ⇒ D): ZIO[R, E, D]
Sequentially zips the specified effects using the specified combiner function.
-
def
mapN[R, E, A, B, C](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B])(f: (A, B) ⇒ C): ZIO[R, E, C]
Sequentially zips the specified effects using the specified combiner function.
-
def
mapParN[R, E, A, B, C, D, F](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C], zio4: ZIO[R, E, D])(f: (A, B, C, D) ⇒ F): ZIO[R, E, F]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function.Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function. If any effect fails, then the other effects will be interrupted. -
def
mapParN[R, E, A, B, C, D](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C])(f: (A, B, C) ⇒ D): ZIO[R, E, D]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function.Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function. If any effect fails, then the other effects will be interrupted. -
def
mapParN[R, E, A, B, C](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B])(f: (A, B) ⇒ C): ZIO[R, E, C]
Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function.Returns an effect that executes the specified effects in parallel, combining their results with the specified
f
function. If any effect fails, then the other effects will be interrupted. -
def
memoize[R, E, A, B](f: (A) ⇒ ZIO[R, E, B]): UIO[(A) ⇒ ZIO[R, E, B]]
Returns a memoized version of the specified effectual function.
-
def
mergeAll[R, E, A, B](in: Iterable[ZIO[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZIO[R, E, B]
Merges an
Iterable[IO]
to a single IO, working sequentially. -
def
mergeAllPar[R, E, A, B](in: Iterable[ZIO[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZIO[R, E, B]
Merges an
Iterable[IO]
to a single IO, working in parallel.Merges an
Iterable[IO]
to a single IO, working in parallel.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
, asf
may be executed more than once for some ofin
elements during effect execution. -
def
mergeAllParN[R, E, A, B](n: Int)(in: Iterable[ZIO[R, E, A]])(zero: B)(f: (B, A) ⇒ B): ZIO[R, E, B]
Merges an
Iterable[IO]
to a single IO, working in with up ton
fibers in parallel.Merges an
Iterable[IO]
to a single IO, working in with up ton
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
, asf
may be executed more than once for some ofin
elements during effect execution. -
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
val
never: UIO[Nothing]
Returns a effect that will never produce anything.
Returns a effect that will never produce anything. The moral equivalent of
while(true) {}
, only without the wasted CPU cycles. Fibers that suspended running this effect are automatically garbage collected on the JVM, because they cannot be reactivated. -
val
none: UIO[Option[Nothing]]
Returns an effect with the empty value.
-
def
not[R, E](effect: ZIO[R, E, Boolean]): ZIO[R, E, Boolean]
Returns a new effect where boolean value of this effect is negated.
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
partition[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, Nothing, (Iterable[E], Iterable[B])]
Feeds elements of type
A
to a functionf
that returns an effect.Feeds elements of type
A
to a functionf
that returns an effect. Collects all successes and failures in a tupled fashion. -
def
partitionPar[R, E, A, B](in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, Nothing, (Iterable[E], Iterable[B])]
Feeds elements of type
A
to a functionf
that returns an effect.Feeds elements of type
A
to a functionf
that returns an effect. Collects all successes and failures in parallel and returns the result as a tuple. -
def
partitionParN[R, E, A, B](n: Int)(in: Iterable[A])(f: (A) ⇒ ZIO[R, E, B])(implicit ev: CanFail[E]): ZIO[R, Nothing, (Iterable[E], Iterable[B])]
Feeds elements of type
A
to a functionf
that returns an effect.Feeds elements of type
A
to a functionf
that returns an effect. Collects all successes and failures in parallel and returns the result as a tuple.Unlike partitionPar, this method will use at most up to
n
fibers. -
def
provide[R, E, A](r: ⇒ R): (ZIO[R, E, A]) ⇒ IO[E, A]
Given an environment
R
, returns a function that can supply the environment to programs that require it, removing their need for any specific environment.Given an environment
R
, returns a function that can supply the environment to programs that require it, removing their need for any specific environment.This is similar to dependency injection, and the
provide
function can be thought of asinject
. -
def
raceAll[R, R1 <: R, E, A](zio: ZIO[R, E, A], ios: Iterable[ZIO[R1, E, A]]): ZIO[R1, E, A]
Races an
IO[E, A]
against zero or more other effects.Races an
IO[E, A]
against zero or more other effects. Yields either the first success or the last failure. -
def
reduceAll[R, R1 <: R, E, A](a: ZIO[R, E, A], as: Iterable[ZIO[R1, E, A]])(f: (A, A) ⇒ A): ZIO[R1, E, A]
Reduces an
Iterable[IO]
to a singleIO
, working sequentially. -
def
reduceAllPar[R, R1 <: R, E, A](a: ZIO[R, E, A], as: Iterable[ZIO[R1, E, A]])(f: (A, A) ⇒ A): ZIO[R1, E, A]
Reduces an
Iterable[IO]
to a singleIO
, working in parallel. -
def
reduceAllParN[R, R1 <: R, E, A](n: Int)(a: ZIO[R, E, A], as: Iterable[ZIO[R1, E, A]])(f: (A, A) ⇒ A): ZIO[R1, E, A]
Reduces an
Iterable[IO]
to a singleIO
, working in up ton
fibers in parallel. -
def
replicate[R, E, A](n: Int)(effect: ZIO[R, E, A]): Iterable[ZIO[R, E, A]]
Replicates the given effect
n
times.Replicates the given effect
n
times. If 0 or negative numbers are given, an emptyIterable
will be returned. This method is more efficient than usingList.fill
or similar methods, because the returnedIterable
consumes only a small amount of heap regardless ofn
. -
def
replicateM[R, E, A](n: Int)(effect: ZIO[R, E, A]): ZIO[R, E, Iterable[A]]
Performs this effect the specified number of times and collects the results.
-
def
replicateM_[R, E, A](n: Int)(effect: ZIO[R, E, A]): ZIO[R, E, Unit]
Performs this effect the specified number of times, discarding the results.
-
def
require[R, E, A](error: ⇒ E): (ZIO[R, E, Option[A]]) ⇒ ZIO[R, E, A]
Requires that the given
ZIO[R, E, Option[A]]
contain a value.Requires that the given
ZIO[R, E, Option[A]]
contain a value. If there is no value, then the specified error will be raised. -
def
reserve[R, E, A, B](reservation: ZIO[R, E, Reservation[R, E, A]])(use: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, B]
Acquires a resource, uses the resource, and then releases the resource.
Acquires a resource, uses the resource, and then releases the resource. However, unlike
bracket
, the separation of these phases allows the acquisition to be interruptible.Useful for concurrent data structures and other cases where the 'deallocator' can tell if the allocation succeeded or not just by inspecting internal / external state.
-
def
right[B](b: ⇒ B): UIO[Either[Nothing, B]]
Returns an effect with the value on the right part.
-
def
runtime[R]: URIO[R, Runtime[R]]
Returns an effect that accesses the runtime, which can be used to (unsafely) execute tasks.
Returns an effect that accesses the runtime, which can be used to (unsafely) execute tasks. This is useful for integration with legacy code that must call back into ZIO code.
-
def
scopeWith[R, E, A](f: (ZScope[Exit[Any, Any]]) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Passes the fiber's scope to the specified function, which creates an effect that will be returned from this method.
-
def
second[A]: URIO[(Any, A), A]
Returns an effectful function that extracts out the second element of a tuple.
-
def
service[A](implicit arg0: zio.Tag[A]): URIO[Has[A], A]
Accesses the specified service in the environment of the effect.
-
def
services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): 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.
-
def
services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): URIO[Has[A] with Has[B] with Has[C], (A, B, C)]
Accesses the specified services in the environment of the effect.
-
def
services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): URIO[Has[A] with Has[B], (A, B)]
Accesses the specified services in the environment of the effect.
-
def
sleep(duration: ⇒ Duration): URIO[Clock, Unit]
Returns an effect that suspends for the specified duration.
Returns an effect that suspends for the specified duration. This method is asynchronous, and does not actually block the fiber executing the effect.
-
def
some[A](a: ⇒ A): UIO[Option[A]]
Returns an effect with the optional value.
-
def
succeed[A](a: ⇒ A): UIO[A]
Returns an effect that models success with the specified value.
-
def
swap[A, B]: URIO[(A, B), (B, A)]
Returns an effectful function that merely swaps the elements in a
Tuple2
. -
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
trace: UIO[ZTrace]
Capture ZIO trace at the current point
-
def
traced[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]
Prefix form of
ZIO#traced
. -
def
transplant[R, E, A](f: (Grafter) ⇒ ZIO[R, E, A]): 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.
-
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]): ZIO[R, E, (A, B, C, D)]
Sequentially zips the specified effects.
Sequentially zips the specified effects. Specialized version of mapN.
-
def
tupled[R, E, A, B, C](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C]): ZIO[R, E, (A, B, C)]
Sequentially zips the specified effects.
Sequentially zips the specified effects. Specialized version of mapN.
-
def
tupled[R, E, A, B](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B]): ZIO[R, E, (A, B)]
Sequentially zips the specified effects.
Sequentially zips the specified effects. Specialized version of mapN.
-
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]): ZIO[R, E, (A, B, C, D)]
Zips the specified effects in parallel.
Zips the specified effects in parallel. Specialized version of mapParN.
-
def
tupledPar[R, E, A, B, C](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B], zio3: ZIO[R, E, C]): ZIO[R, E, (A, B, C)]
Zips the specified effects in parallel.
Zips the specified effects in parallel. Specialized version of mapParN.
-
def
tupledPar[R, E, A, B](zio1: ZIO[R, E, A], zio2: ZIO[R, E, B]): ZIO[R, E, (A, B)]
Zips the specified effects in parallel.
Zips the specified effects in parallel. Specialized version of mapParN.
-
def
uninterruptible[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]
Prefix form of
ZIO#uninterruptible
. -
def
uninterruptibleMask[R, E, A](k: (InterruptStatusRestore) ⇒ ZIO[R, E, A]): ZIO[R, E, A]
Makes the effect uninterruptible, but passes it a restore function that can be used to restore the inherited interruptibility from whatever region the effect is composed into.
-
val
unit: UIO[Unit]
An effect that succeeds with a unit value.
-
def
unless[R, E](b: ⇒ Boolean)(zio: ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]
The moral equivalent of
if (!p) exp
-
def
unlessM[R, E](b: ZIO[R, E, Boolean]): UnlessM[R, E]
The moral equivalent of
if (!p) exp
whenp
has side-effects -
def
unsandbox[R, E, A](v: ZIO[R, Cause[E], A]): ZIO[R, E, A]
The inverse operation
IO.sandboxed
The inverse operation
IO.sandboxed
Terminates with exceptions on the
Left
side of theEither
error, if it exists. Otherwise extracts the containedIO[E, A]
-
def
untraced[R, E, A](zio: ZIO[R, E, A]): ZIO[R, E, A]
Prefix form of
ZIO#untraced
. -
def
validate[R, E, A, B, 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]): ZIO[R, ::[E], Collection[B]]
Feeds elements of type
A
tof
and accumulates all errors in error channel or successes in success channel.Feeds elements of type
A
tof
and accumulates all errors in error channel or successes in success channel.This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partition.
-
def
validateFirst[R, E, A, B, 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]): ZIO[R, Collection[E], B]
Feeds elements of type
A
tof
until it succeeds.Feeds elements of type
A
tof
until it succeeds. Returns first success or the accumulation of all errors. -
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]): ZIO[R, Collection[E], B]
Feeds elements of type
A
tof
, in parallel, until it succeeds.Feeds elements of type
A
tof
, in parallel, until it succeeds. Returns first success or the accumulation of all errors.In case of success all other running fibers are terminated.
-
def
validatePar[R, E, A, B, 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]): ZIO[R, ::[E], Collection[B]]
Feeds elements of type
A
tof
and accumulates, in parallel, all errors in error channel or successes in success channel.Feeds elements of type
A
tof
and accumulates, in parallel, all errors in error channel or successes in success channel.This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partitionPar.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
when[R, E](b: ⇒ Boolean)(zio: ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]
The moral equivalent of
if (p) exp
-
def
whenCase[R, E, A](a: ⇒ A)(pf: PartialFunction[A, ZIO[R, E, Any]]): ZIO[R, E, Unit]
Runs an effect when the supplied
PartialFunction
matches for the given value, otherwise does nothing. -
def
whenCaseM[R, E, A](a: ZIO[R, E, A])(pf: PartialFunction[A, ZIO[R, E, Any]]): ZIO[R, E, Unit]
Runs an effect when the supplied
PartialFunction
matches for the given effectful value, otherwise does nothing. -
def
whenM[R, E](b: ZIO[R, E, Boolean]): WhenM[R, E]
The moral equivalent of
if (p) exp
whenp
has side-effects -
def
withChildren[R, E, A](get: (UIO[Chunk[Fiber.Runtime[Any, Any]]]) ⇒ ZIO[R, E, A]): 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.
-
val
yieldNow: UIO[Unit]
Returns an effect that yields to the runtime system, starting on a fresh stack.
Returns an effect that yields to the runtime system, starting on a fresh stack. Manual use of this method can improve fairness, at the cost of overhead.
- object CanFilter