Cont

interface Cont<R, A>

Cont represents a suspending computation that runs will either

So Cont is defined by fold, to map both values of R and A to a value of B.

Functions

attempt

Runs the Cont and captures any NonFatal exception into Result.

fold

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

Runs the suspending computation by creating a Continuation, and running the fold function over the computation.

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

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

handleError

open fun handleError(recover: suspend (R) -> A): Cont<Nothing, A>

handleErrorWith

open fun <R2> handleErrorWith(recover: suspend (R) -> Cont<R2, A>): Cont<R2, A>

redeem

open fun <B> redeem(recover: suspend (R) -> B, transform: suspend (A) -> B): Cont<Nothing, B>

redeemWith

open fun <R2, B> redeemWith(recover: suspend (R) -> Cont<R2, B>, transform: suspend (A) -> Cont<R2, B>): Cont<R2, B>

toEither

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

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

toIor

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

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

toOption

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

fold the Cont 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 suspend fun toValidated(): Validated<R, A>

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

toOption

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

common source