object AsyncZio extends AsyncZio[Any]
- Alphabetic
- By Inheritance
- AsyncZio
- AsyncZio
- Async2
- IO2
- Panic2
- PanicSyntax
- Bracket2
- Error2
- ErrorAccumulatingOps2
- Monad2
- ApplicativeError2
- Bifunctor2
- Guarantee2
- Applicative2
- Functor2
- Concurrent2
- Parallel2
- RootBifunctor
- Root
- PredefinedHelper
- DivergenceHelper
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final type Canceler = ZIO[Any, Nothing, Unit]
- Definition Classes
- Async2
- type Divergence = Nondivergent
- Definition Classes
- DivergenceHelper
- type IsPredefined = NotPredefined
- Definition Classes
- PredefinedHelper
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def *>[E, A, B](f: ZIO[Any, E, A], next: => ZIO[Any, E, B]): ZIO[Any, E, B]
execute two operations in order, return result of second operation
execute two operations in order, return result of second operation
- Definition Classes
- AsyncZio → Monad2 → Applicative2
- Annotations
- @inline()
- final def <*[E, A, B](f: ZIO[Any, E, A], next: => ZIO[Any, E, B]): ZIO[Any, E, A]
execute two operations in order, same as
*>, but return result of first operationexecute two operations in order, same as
*>, but return result of first operation- Definition Classes
- AsyncZio → Monad2 → Applicative2
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def InnerF: AsyncZio.this.type
- Definition Classes
- AsyncZio → Async2 → ApplicativeError2 → Bifunctor2 → Concurrent2 → Parallel2
- Annotations
- @inline()
- def accumulateErrorsImpl[ColL[_], ColR[x] <: IterableOnce[x], E, E1, A, B, B1, AC](col: ColR[A])(effect: (A) => ZIO[Any, E, B], onLeft: (E) => IterableOnce[E1], init: AC, onRight: (AC, B) => AC, end: (AC) => B1)(implicit buildL: Factory[E1, ColL[E1]]): ZIO[Any, ColL[E1], B1]
- Attributes
- protected[this]
- Definition Classes
- IO2 → ErrorAccumulatingOps2
- final def apply[A](effect: => A): ZIO[Any, Throwable, A]
- Definition Classes
- IO2
- Annotations
- @inline()
- final def as[E, A, B](r: ZIO[Any, E, A])(v: => B): ZIO[Any, E, B]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- final def async[E, A](register: ((Either[E, A]) => Unit) => Unit): ZIO[Any, E, A]
- final def asyncCancelable[E, A](register: ((Either[E, A]) => Unit) => Canceler): ZIO[Any, E, A]
- final def asyncF[E, A](register: ((Either[E, A]) => Unit) => ZIO[Any, E, Unit]): ZIO[Any, E, A]
- final def attempt[E, A](r: ZIO[Any, E, A]): ZIO[Any, Nothing, Either[E, A]]
- final def bimap[E, A, E2, B](r: ZIO[Any, E, A])(f: (E) => E2, g: (A) => B): ZIO[Any, E2, B]
- Definition Classes
- AsyncZio → Error2 → Bifunctor2
- Annotations
- @inline()
- final def bracket[E, A, B](acquire: ZIO[Any, E, A])(release: (A) => ZIO[Any, Nothing, Unit])(use: (A) => ZIO[Any, E, B]): ZIO[Any, E, B]
- final def bracketCase[E, A, B](acquire: ZIO[Any, E, A])(release: (A, Exit[E, B]) => ZIO[Any, Nothing, Unit])(use: (A) => ZIO[Any, E, B]): ZIO[Any, E, B]
- final def bracketExcept[E, A, B](acquire: (RestoreInterruption2[[+β$8$, +γ$9$]ZIO[Any, β$8$, γ$9$]]) => ZIO[Any, E, A])(release: (A, Exit[E, B]) => ZIO[Any, Nothing, Unit])(use: (A) => ZIO[Any, E, B]): ZIO[Any, E, B]
Like bracketCase, but
acquirecan contain marked interruptible regions as in uninterruptibleExceptLike bracketCase, but
acquirecan contain marked interruptible regions as in uninterruptibleExcept - final def bracketOnFailure[E, A, B](acquire: ZIO[Any, E, A])(cleanupOnFailure: (A, Failure[E]) => ZIO[Any, Nothing, Unit])(use: (A) => ZIO[Any, E, B]): ZIO[Any, E, B]
Run release action only on a failure – _any failure_, INCLUDING interruption.
Run release action only on a failure – _any failure_, INCLUDING interruption. Do not run release action if
usefinished successfully.- Definition Classes
- Bracket2
- final def catchAll[E, A, E2](r: ZIO[Any, E, A])(f: (E) => ZIO[Any, E2, A]): ZIO[Any, E2, A]
- final def catchSome[E, A, E1 >: E](r: ZIO[Any, E, A])(f: PartialFunction[E, ZIO[Any, E1, A]]): ZIO[Any, E1, A]
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collect[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, Option[B]]): ZIO[Any, E, List[B]]
- Definition Classes
- Applicative2
- final def collectFirst[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, Option[B]]): ZIO[Any, E, Option[B]]
- final def currentEC: ZIO[Any, Nothing, ExecutionContext]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def fail[E](v: => E): ZIO[Any, E, Nothing]
- Definition Classes
- AsyncZio → ApplicativeError2
- Annotations
- @inline()
- final def filter[E, A](l: Iterable[A])(f: (A) => ZIO[Any, E, Boolean]): ZIO[Any, E, List[A]]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def find[E, A](l: Iterable[A])(f: (A) => ZIO[Any, E, Boolean]): ZIO[Any, E, Option[A]]
- final def flatMap[E, A, B](r: ZIO[Any, E, A])(f0: (A) => ZIO[Any, E, B]): ZIO[Any, E, B]
- def flatSequence[E, A](l: Iterable[ZIO[Any, E, Iterable[A]]]): ZIO[Any, E, List[A]]
- Definition Classes
- Applicative2
- def flatSequenceAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[ZIO[Any, ColL[E], ColIn[A]]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): ZIO[Any, ColL[E], ColR[A]]
flatSequencewith error accumulationflatSequencewith error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def flatTraverse[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, Iterable[B]]): ZIO[Any, E, List[B]]
- Definition Classes
- Applicative2
- def flatTraverseAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], E, A, B](col: ColR[A])(f: (A) => ZIO[Any, ColL[E], ColIn[B]])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): ZIO[Any, ColL[E], ColR[B]]
flatTraversewith error accumulationflatTraversewith error accumulation- Definition Classes
- ErrorAccumulatingOps2
- final def flatten[E, A](r: ZIO[Any, E, ZIO[Any, E, A]]): ZIO[Any, E, A]
- final def flip[E, A](r: ZIO[Any, E, A]): ZIO[Any, A, E]
- final def foldLeft[E, A, AC](l: Iterable[A])(z: AC)(f: (AC, A) => ZIO[Any, E, AC]): ZIO[Any, E, AC]
- final def forever[E, A](r: ZIO[Any, E, A]): ZIO[Any, E, Nothing]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- final def fromEither[E, A](effect: => Either[E, A]): ZIO[Any, E, A]
- Definition Classes
- AsyncZio → IO2 → ApplicativeError2
- Annotations
- @inline()
- final def fromFuture[A](mkFuture: (ExecutionContext) => Future[A]): ZIO[Any, Throwable, A]
- final def fromFuture[A](mkFuture: => Future[A]): ZIO[Any, Throwable, A]
- Definition Classes
- Async2
- Annotations
- @inline()
- final def fromFutureJava[A](javaFuture: => CompletionStage[A]): ZIO[Any, Throwable, A]
- final def fromOption[E, A](errorOnNone: => E)(effect: => Option[A]): ZIO[Any, E, A]
- Definition Classes
- AsyncZio → IO2 → ApplicativeError2
- Annotations
- @inline()
- def fromOption[E, A](errorOnNone: => E, r: ZIO[Any, E, Option[A]]): ZIO[Any, E, A]
Extracts the optional value or fails with the
errorOnNoneerrorExtracts the optional value or fails with the
errorOnNoneerror- Definition Classes
- Error2
- final def fromOptionF[E, A](fallbackOnNone: => ZIO[Any, E, A], r: ZIO[Any, E, Option[A]]): ZIO[Any, E, A]
Extracts the optional value, or executes the
fallbackOnNoneeffect - final def fromOptionOr[E, A](valueOnNone: => A, r: ZIO[Any, E, Option[A]]): ZIO[Any, E, A]
Extracts the optional value, or returns the given
valueOnNonevalue - final def fromTry[A](effect: => Try[A]): ZIO[Any, Throwable, A]
- Definition Classes
- AsyncZio → IO2 → ApplicativeError2
- Annotations
- @inline()
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def guarantee[E, A](f: ZIO[Any, E, A], cleanup: ZIO[Any, Nothing, Unit]): ZIO[Any, E, A]
- Definition Classes
- AsyncZio → Bracket2 → Guarantee2
- Annotations
- @inline()
- final def guaranteeCase[E, A](f: ZIO[Any, E, A], cleanup: (Exit[E, A]) => ZIO[Any, Nothing, Unit]): ZIO[Any, E, A]
- final def guaranteeExceptOnInterrupt[E, A](f: ZIO[Any, E, A], cleanupOnNonInterruption: (Uninterrupted[E, A]) => ZIO[Any, Nothing, Unit]): ZIO[Any, E, A]
Run cleanup on both _success_ and _failure_, if the failure IS NOT an interruption.
Run cleanup on both _success_ and _failure_, if the failure IS NOT an interruption.
- Definition Classes
- Bracket2
- final def guaranteeOnFailure[E, A](f: ZIO[Any, E, A], cleanupOnFailure: (Failure[E]) => ZIO[Any, Nothing, Unit]): ZIO[Any, E, A]
Run cleanup only on a failure – _any failure_, INCLUDING interruption.
Run cleanup only on a failure – _any failure_, INCLUDING interruption. Do not run cleanup if
usefinished successfully.- Definition Classes
- Bracket2
- final def guaranteeOnInterrupt[E, A](f: ZIO[Any, E, A], cleanupOnInterruption: (Interruption) => ZIO[Any, Nothing, Unit]): ZIO[Any, E, A]
Run cleanup only on interruption.
Run cleanup only on interruption. Do not run cleanup if
usefinished successfully.- Definition Classes
- Bracket2
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def ifThenElse[E, E1, A](cond: ZIO[Any, E, Boolean])(ifTrue: => ZIO[Any, E1, A], ifFalse: => ZIO[Any, E1, A])(implicit ev: <:<[E, E1]): ZIO[Any, E1, A]
- Definition Classes
- Monad2
- Annotations
- @inline()
- final def ifThenElse[E, A](cond: Boolean)(ifTrue: => ZIO[Any, E, A], ifFalse: => ZIO[Any, E, A]): ZIO[Any, E, A]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def iterateUntil[E, A](r: ZIO[Any, E, A])(p: (A) => Boolean): ZIO[Any, E, A]
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
- def iterateUntilF[E, A](init: A)(f: (A) => ZIO[Any, E, A])(p: (A) => Boolean): ZIO[Any, E, A]
Apply an effectful function iteratively until its result satisfies the given predicate and return that result.
Apply an effectful function iteratively until its result satisfies the given predicate and return that result.
- Definition Classes
- Monad2
- final def iterateWhile[E, A](r: ZIO[Any, E, A])(p: (A) => Boolean): ZIO[Any, E, A]
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
- def iterateWhileF[E, A](init: A)(f: (A) => ZIO[Any, E, A])(p: (A) => Boolean): ZIO[Any, E, A]
Apply an effectful function iteratively until its result fails to satisfy the given predicate and return that result.
Apply an effectful function iteratively until its result fails to satisfy the given predicate and return that result.
- Definition Classes
- Monad2
- final def leftFlatMap[E, A, E2](r: ZIO[Any, E, A])(f: (E) => ZIO[Any, Nothing, E2]): ZIO[Any, E2, A]
- final def leftMap[E, A, E2](r: ZIO[Any, E, A])(f: (E) => E2): ZIO[Any, E2, A]
- Definition Classes
- AsyncZio → Bifunctor2
- Annotations
- @inline()
- final def leftMap2[E, A, E2, E3](firstOp: ZIO[Any, E, A], secondOp: => ZIO[Any, E2, A])(f: (E, E2) => E3): ZIO[Any, E3, A]
map errors from two operations into a new error if both fail
map errors from two operations into a new error if both fail
- Definition Classes
- AsyncZio → Error2 → ApplicativeError2
- Annotations
- @inline()
- final def map[E, A, B](r: ZIO[Any, E, A])(f: (A) => B): ZIO[Any, E, B]
- final def map2[E, A, B, C](r1: ZIO[Any, E, A], r2: => ZIO[Any, E, B])(f: (A, B) => C): ZIO[Any, E, C]
execute two operations in order, map their results
execute two operations in order, map their results
- Definition Classes
- AsyncZio → Monad2 → Applicative2
- Annotations
- @inline()
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def never: ZIO[Any, Nothing, Nothing]
- Definition Classes
- AsyncZio → Async2 → Concurrent2
- Annotations
- @inline()
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def onEC[E, A](ec: ExecutionContext)(f: ZIO[Any, E, A]): ZIO[Any, E, A]
- final def orElse[E, A, E2](r: ZIO[Any, E, A], f: => ZIO[Any, E2, A]): ZIO[Any, E2, A]
execute second operation only if the first one fails
execute second operation only if the first one fails
- Definition Classes
- AsyncZio → Error2 → ApplicativeError2
- Annotations
- @inline()
- final def orTerminate[A](r: ZIO[Any, Throwable, A]): ZIO[Any, Nothing, A]
- Definition Classes
- Panic2
- Annotations
- @inline()
- final def parTraverse[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, List[B]]
- final def parTraverseN[E, A, B](maxConcurrent: Int)(l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, List[B]]
- final def parTraverseNCore[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, List[B]]
parTraverseN with
maxConcurrentset to the number of cores, or 2 when on single-core processorparTraverseN with
maxConcurrentset to the number of cores, or 2 when on single-core processor - final def parTraverseNCore_[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, Unit]
- final def parTraverseN_[E, A, B](maxConcurrent: Int)(l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, Unit]
- final def parTraverse_[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, Unit]
- def partition[E, A](l: Iterable[ZIO[Any, E, A]]): ZIO[Any, Nothing, (List[E], List[A])]
- Definition Classes
- Error2
- Annotations
- @nowarn()
- final def pure[A](a: A): ZIO[Any, Nothing, A]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- final def race[E, A](r1: ZIO[Any, E, A], r2: ZIO[Any, E, A]): ZIO[Any, E, A]
Race two actions, the winner is the first action to TERMINATE, whether by success or failure
Race two actions, the winner is the first action to TERMINATE, whether by success or failure
- Definition Classes
- AsyncZio → Concurrent2
- Annotations
- @inline()
- final def racePairUnsafe[E, A, B](r1: ZIO[Any, E, A], r2: ZIO[Any, E, B]): ZIO[Any, E, Either[(Exit[E, A], Fiber2[[+β$2$, +γ$3$]ZIO[Any, β$2$, γ$3$], E, B]), (Fiber2[[+β$4$, +γ$5$]ZIO[Any, β$4$, γ$5$], E, A], Exit[E, B])]]
Race two actions, the winner is the first action to TERMINATE, whether by success or failure
Race two actions, the winner is the first action to TERMINATE, whether by success or failure
Unlike race, the loser is not interrupted after the winner has terminated - whether by success or failure.
- Definition Classes
- AsyncZio → Concurrent2
- Annotations
- @inline()
- final def redeem[E, A, E2, B](r: ZIO[Any, E, A])(err: (E) => ZIO[Any, E2, B], succ: (A) => ZIO[Any, E2, B]): ZIO[Any, E2, B]
- final def redeemPure[E, A, B](r: ZIO[Any, E, A])(err: (E) => B, succ: (A) => B): ZIO[Any, Nothing, B]
- final def retryUntil[E, A](r: ZIO[Any, E, A])(f: (E) => Boolean): ZIO[Any, E, A]
Retries this effect until its error satisfies the specified predicate.
- final def retryUntilF[E, A](r: ZIO[Any, E, A])(f: (E) => ZIO[Any, Nothing, Boolean]): ZIO[Any, E, A]
Retries this effect until its error satisfies the specified effectful predicate.
- final def retryWhile[E, A](r: ZIO[Any, E, A])(f: (E) => Boolean): ZIO[Any, E, A]
Retries this effect while its error satisfies the specified predicate.
- final def retryWhileF[E, A](r: ZIO[Any, E, A])(f: (E) => ZIO[Any, Nothing, Boolean]): ZIO[Any, E, A]
Retries this effect while its error satisfies the specified effectful predicate.
- final def sandbox[E, A](r: ZIO[Any, E, A]): ZIO[Any, FailureUninterrupted[E], A]
- Definition Classes
- AsyncZio → Panic2
- Annotations
- @inline()
- Note
Will return either Exit.Success, Exit.Error or Exit.Termination. Exit.Interruption cannot be sandboxed. Use guaranteeOnInterrupt for cleanups on interruptions.
- final def sandboxExit[E, A](r: ZIO[Any, E, A]): ZIO[Any, Nothing, Uninterrupted[E, A]]
- Definition Classes
- Panic2
- Annotations
- @inline()
- Note
Will return either Exit.Success, Exit.Error or Exit.Termination. Exit.Interruption cannot be sandboxed. Use guaranteeOnInterrupt for cleanups on interruptions.
- final def sendInterruptToSelf: ZIO[Any, Nothing, Unit]
Signal interruption to this fiber.
Signal interruption to this fiber.
This is _NOT_ the same as
F.halt(Exit.Interrupted(Trace.forUnknownError))
The code above exits with
Exit.Interruptedfailure *unconditionally*, whereas sendInterruptToSelf will not exit when in an uninterruptible region. Example:F.uninterruptible { F.halt(Exit.Interrupted(Trace.forUnknownError)) *> F.sync(println("Hello!")) // interrupted above. Hello _not_ printed }But with
sendInterruptToSelf:F.uninterruptible { F.sendInterruptToSelf *> F.sync(println("Hello!")) // Hello IS printed. } *> F.sync(println("Impossible")) // interrupted immediately after `uninterruptible` block ends. Impossible _not_ printed- Definition Classes
- AsyncZio → Panic2
- Annotations
- @inline()
- See also
- https://github.com/zio/interop-cats/issues/503 - History of supporting this method in ZIO
- https://github.com/zio/zio/issues/6911 - related issue
- final def sequence[E, A](l: Iterable[ZIO[Any, E, A]]): ZIO[Any, E, List[A]]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- def sequenceAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[ZIO[Any, ColL[E], A]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): ZIO[Any, ColL[E], ColR[A]]
sequencewith error accumulationsequencewith error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def sequenceAccumErrorsNEList[ColR[x] <: IterableOnce[x], E, A](col: ColR[ZIO[Any, E, A]])(implicit buildR: Factory[A, ColR[A]]): ZIO[Any, NEList[E], ColR[A]]
sequencewith error accumulationsequencewith error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def sequenceAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[ZIO[Any, ColL[E], A]])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): ZIO[Any, ColL[E], Unit]
sequence_with error accumulationsequence_with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- final def sequence_[E](l: Iterable[ZIO[Any, E, Unit]]): ZIO[Any, E, Unit]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- final def suspend[A](effect: => ZIO[Any, Throwable, A]): ZIO[Any, Throwable, A]
Capture a side-effectful block of code that can throw exceptions and returns another effect
- final def suspendSafe[E, A](effect: => ZIO[Any, E, A]): ZIO[Any, E, A]
Capture an _exception-safe_ side-effect that returns another effect
- final def sync[A](effect: => A): ZIO[Any, Nothing, A]
Capture an _exception-safe_ side-effect such as memory mutation or randomness
Capture an _exception-safe_ side-effect such as memory mutation or randomness
- Definition Classes
- AsyncZio → IO2
- Annotations
- @inline()
import izumi.functional.bio.F val exceptionSafeArrayAllocation: F[Nothing, Array[Byte]] = { F.sync(new Array(256)) }
- Note
If you're not completely sure that a captured block can't throw, use syncThrowable
,syncmeanssynchronous, that is, a blocking CPU effect, as opposed to a non-blocking asynchronous effect or a long blocking I/O effect (izumi.functional.bio.BlockingIO2#syncBlocking)
Example: - final def syncThrowable[A](effect: => A): ZIO[Any, Throwable, A]
Capture a side-effectful block of code that can throw exceptions
Capture a side-effectful block of code that can throw exceptions
- Definition Classes
- AsyncZio → IO2
- Annotations
- @inline()
- Note
syncmeanssynchronous, that is, a blocking CPU effect, as opposed to a non-blocking asynchronous effect or a long blocking I/O effect (izumi.functional.bio.BlockingIO2#syncBlocking)
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tailRecM[E, A, B](a: A)(f: (A) => ZIO[Any, E, Either[A, B]]): ZIO[Any, E, B]
- Definition Classes
- Monad2
- final def tap[E, A](r: ZIO[Any, E, A], f: (A) => ZIO[Any, E, Unit]): ZIO[Any, E, A]
- final def tapBoth[E, A, E1 >: E](r: ZIO[Any, E, A])(err: (E) => ZIO[Any, E1, Unit], succ: (A) => ZIO[Any, E1, Unit]): ZIO[Any, E1, A]
- final def tapError[E, A, E1 >: E](r: ZIO[Any, E, A])(f: (E) => ZIO[Any, E1, Unit]): ZIO[Any, E1, A]
- final def terminate(v: => Throwable): ZIO[Any, Nothing, Nothing]
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def traverse[E, A, B](l: Iterable[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, List[B]]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- final def traverse[E, A, B](o: Option[A])(f: (A) => ZIO[Any, E, B]): ZIO[Any, E, Option[B]]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- def traverseAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], E, A, B](col: ColR[A])(f: (A) => ZIO[Any, ColL[E], B])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): ZIO[Any, ColL[E], ColR[B]]
traversewith error accumulationtraversewith error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def traverseAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[A])(f: (A) => ZIO[Any, ColL[E], Unit])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): ZIO[Any, ColL[E], Unit]
traverse_with error accumulationtraverse_with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- final def traverse_[E, A](l: Iterable[A])(f: (A) => ZIO[Any, E, Unit]): ZIO[Any, E, Unit]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- final def uninterruptible[E, A](r: ZIO[Any, E, A]): ZIO[Any, E, A]
- final def uninterruptibleExcept[E, A](r: (RestoreInterruption2[[+β$6$, +γ$7$]ZIO[Any, β$6$, γ$7$]]) => ZIO[Any, E, A]): ZIO[Any, E, A]
Designate the effect uninterruptible, with exception of regions in it that are specifically marked to restore previous interruptibility status using the provided
RestoreInterruptionfunctionDesignate the effect uninterruptible, with exception of regions in it that are specifically marked to restore previous interruptibility status using the provided
RestoreInterruptionfunction- Definition Classes
- AsyncZio → Panic2
- Annotations
- @inline()
F.uninterruptibleExcept { restoreInterruption => val workLoop = { importantWorkThatMustNotBeInterrupted() *> log.info("Taking a break for a second, you can interrupt me while I wait!") *> restoreInterruption.apply { F.sleep(1.second) .guaranteeOnInterrupt(_ => log.info("Got interrupted!")) } *> log.info("No interruptions, going back to work!") *> workLoop } workLoop }- Note
Interruptibility status will be restored to what it was in the outer region, so if the outer region was also uninterruptible, the provided
RestoreInterruptionwill have no effect. e.g. the expressionF.uninterruptible { F.uninterruptibleExcept { restore => restore(F.sleep(1.second)) }is fully uninterruptible throughout
Example: - final def unit: ZIO[Any, Nothing, Unit]
- Definition Classes
- AsyncZio → Applicative2
- Annotations
- @inline()
- final def unless[E, E1](cond: ZIO[Any, E, Boolean])(ifFalse: => ZIO[Any, E1, Unit])(implicit ev: <:<[E, E1]): ZIO[Any, E1, Unit]
- Definition Classes
- Monad2
- Annotations
- @inline()
- final def unless[E](cond: Boolean)(ifFalse: => ZIO[Any, E, Unit]): ZIO[Any, E, Unit]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- final def void[E, A](r: ZIO[Any, E, A]): ZIO[Any, E, Unit]
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def when[E, E1](cond: ZIO[Any, E, Boolean])(ifTrue: => ZIO[Any, E1, Unit])(implicit ev: <:<[E, E1]): ZIO[Any, E1, Unit]
- Definition Classes
- Monad2
- Annotations
- @inline()
- final def when[E](cond: Boolean)(ifTrue: => ZIO[Any, E, Unit]): ZIO[Any, E, Unit]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- final def widen[E, A, A1](r: ZIO[Any, E, A])(implicit ev: <:<[A, A1]): ZIO[Any, E, A1]
- Definition Classes
- Functor2
- Annotations
- @inline()
- final def widenBoth[E, A, E1, A1](r: ZIO[Any, E, A])(implicit ev: <:<[E, E1], ev2: <:<[A, A1]): ZIO[Any, E1, A1]
- Definition Classes
- Bifunctor2
- Annotations
- @inline()
- final def widenError[E, A, E1](r: ZIO[Any, E, A])(implicit ev: <:<[E, E1]): ZIO[Any, E1, A]
- Definition Classes
- Bifunctor2
- Annotations
- @inline()
- final def withFilter[E, A](r: ZIO[Any, E, A])(predicate: (A) => Boolean)(implicit filter: WithFilter[E], pos: SourceFilePositionMaterializer): ZIO[Any, E, A]
for-comprehensions sugar:
for-comprehensions sugar:
for { (1, 2) <- F.pure((2, 1)) } yield ()
Use widenError to for pattern matching with non-Throwable errors:
val f = for { (1, 2) <- F.pure((2, 1)).widenError[Option[Unit]] } yield () // f: F[Option[Unit], Unit] = F.fail(Some(())
- Definition Classes
- Error2
- Annotations
- @inline()
- final def yieldNow: ZIO[Any, Nothing, Unit]
- Definition Classes
- AsyncZio → Concurrent2
- Annotations
- @inline()
- final def zipPar[E, A, B](fa: ZIO[Any, E, A], fb: ZIO[Any, E, B]): ZIO[Any, E, (A, B)]
Returns an effect that executes both effects, in parallel, combining their results into a tuple.
- final def zipParLeft[E, A, B](fa: ZIO[Any, E, A], fb: ZIO[Any, E, B]): ZIO[Any, E, A]
Returns an effect that executes both effects, in parallel, the left effect result is returned.
- final def zipParRight[E, A, B](fa: ZIO[Any, E, A], fb: ZIO[Any, E, B]): ZIO[Any, E, B]
Returns an effect that executes both effects, in parallel, the right effect result is returned.
- final def zipWithPar[E, A, B, C](fa: ZIO[Any, E, A], fb: ZIO[Any, E, B])(f: (A, B) => C): ZIO[Any, E, C]
Returns an effect that executes both effects, in parallel, combining their results with the specified
ffunction.