Package arrow.core.continuations

Types

expect class AtomicRef<V>(initialValue: V)

actual class AtomicRef<V>(initialValue: V)

actual typealias AtomicRef = AtomicReference<V>

actual class AtomicRef<V>(initialValue: V)

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.

EagerEffectScope

interface EagerEffectScope<R>

Context of the EagerEffect DSL.

Effect

interface Effect<R, A>

Effect represents a function of suspend () -> A, that short-circuit with a value of R (and Throwable), or completes with a value of A.

EffectScope

interface EffectScope<R>

Context of the Effect DSL.

either

object either

ior

object ior

IorEagerEffectScope

class IorEagerEffectScope<E>(semigroup: Semigroup<E>, effect: EagerEffectScope<E>) : EagerEffectScope<E> , Semigroup<E>

IorEffectScope

class IorEffectScope<E>(semigroup: Semigroup<E>, effect: EffectScope<E>) : EffectScope<E> , Semigroup<E>

nullable

object nullable

NullableEagerEffectScope

@JvmInline

value class NullableEagerEffectScope(cont: EagerEffectScope<Nothing?>) : EagerEffectScope<Nothing?>

NullableEffectScope

@JvmInline

value class NullableEffectScope(cont: EffectScope<Nothing?>) : EffectScope<Nothing?>

option

object option

OptionEagerEffectScope

@JvmInline

value class OptionEagerEffectScope(cont: EagerEffectScope<None>) : EagerEffectScope<None>

OptionEffectScope

@JvmInline

value class OptionEffectScope(cont: EffectScope<None>) : EffectScope<None>

result

object result

ResultEagerEffectScope

@JvmInline

value class ResultEagerEffectScope(cont: EagerEffectScope<Throwable>) : EagerEffectScope<Throwable>

ResultEffectScope

@JvmInline

value class ResultEffectScope(cont: EffectScope<Throwable>) : EffectScope<Throwable>

ShiftCancellationException

sealed class ShiftCancellationException : CancellationException

AVOID USING THIS TYPE, it's meant for low-level cancellation code When in need in low-level code, you can use this type to differentiate between a foreign CancellationException and the one from Effect.

Functions

eagerEffect

inline fun <R, A> eagerEffect(crossinline f: suspend EagerEffectScope<R>.() -> A): EagerEffect<R, A>

DSL for constructing EagerEffect<R, A> values

effect

inline fun <R, A> effect(crossinline f: suspend EffectScope<R>.() -> A): Effect<R, A>

DSL for constructing Effect values

ensureNotNull

suspend fun <B> NullableEagerEffectScope.ensureNotNull(value: B?): B

suspend fun <B> NullableEffectScope.ensureNotNull(value: B?): B

suspend fun <B> OptionEagerEffectScope.ensureNotNull(value: B?): B

suspend fun <B> OptionEffectScope.ensureNotNull(value: B?): B

suspend fun <R, B : Any> EagerEffectScope<R>.ensureNotNull(value: B?, shift: () -> R): B

suspend fun <R, B : Any> EffectScope<R>.ensureNotNull(value: B?, shift: () -> R): B

Ensure that value is not null. if it's non-null it will be smart-casted and returned if it's false it will shift with the provided value R. Monadic version of kotlin.requireNotNull.

getAndUpdate

inline fun <V> AtomicRef<V>.getAndUpdate(function: (V) -> V): V

Updates variable atomically using the specified function of its value and returns its old value.

loop

inline fun <V> AtomicRef<V>.loop(action: (V) -> Unit): Nothing

Infinite loop that reads this atomic variable and performs the specified action on its value.

toOption

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

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

toResult

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

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

update

inline fun <V> AtomicRef<V>.update(function: (V) -> V)

updateAndGet

inline fun <V> AtomicRef<V>.updateAndGet(function: (V) -> V): V

Updates variable atomically using the specified function of its value and returns its new value.