arrow-core/arrow.core.continuations/EagerEffect

EagerEffect

interface EagerEffect<out R, out A>

RestrictsSuspension version of Effect. This version runs eagerly, and can be used in non-suspending code. An effect computation interoperates with an EagerEffect via bind.

Functions

attempt

open fun attempt(): EagerEffect<R, Result<A>>

flatMap

open fun ~~flatMap~~(f: (A) -> EagerEffect<@UnsafeVariance R, B>): EagerEffect<R, B>

fold

abstract fun fold(recover: (R) -> B, transform: (A) -> B): B

Runs the non-suspending computation by creating a Continuation with an EmptyCoroutineContext, and running the fold function over the computation.

open fun fold(error: (error: Throwable) -> B, recover: (shifted: R) -> B, transform: (value: A) -> B): B

Like fold but also allows folding over any unexpected Throwable that might have occurred.

handleError

open fun handleError(f: (R) -> @UnsafeVariance A): EagerEffect<Nothing, A>

handleErrorWith

open fun <R2> handleErrorWith(f: (R) -> EagerEffect<R2, @UnsafeVariance A>): EagerEffect<R2, A>

map

open fun ~~map~~(f: (A) -> B): EagerEffect<R, B>

orNull

open fun orNull(): A?

fold the EagerEffect into an A?. Where the shifted value R is mapped to null, and result value A.

redeem

open fun redeem(f: (R) -> B, g: (A) -> B): EagerEffect<Nothing, B>

redeemWith

open fun <R2, B> redeemWith(f: (R) -> EagerEffect<R2, B>, g: (A) -> EagerEffect<R2, B>): EagerEffect<R2, B>

toEither

open fun toEither(): Either<R, A>

fold the EagerEffect into an Either. Where the shifted value R is mapped to Either.Left, and result value A is mapped to Either.Right.

toIor

open fun toIor(): Ior<R, A>

fold the EagerEffect into an Ior. Where the shifted value R is mapped to Ior.Left, and result value A is mapped to Ior.Right.

toOption

open fun toOption(orElse: (R) -> Option<@UnsafeVariance A>): Option<A>

fold the EagerEffect into an Option. Where the shifted value R is mapped to Option by the provided function orElse, and result value A is mapped to Some.

toValidated

open fun toValidated(): Validated<R, A>

fold the EagerEffect into an Validated. Where the shifted value R is mapped to Validated.Invalid, and result value A is mapped to Validated.Valid.

Extensions

merge

fun <A> EagerEffect<A, A>.merge(): A

toOption

fun <A> EagerEffect<None, A>.toOption(): Option<A>

toResult

fun <A> EagerEffect<Throwable, A>.toResult(): Result<A>

EagerEffect

See also

Functions

Extensions