arrow-core/arrow.core.raise.context

Package-level declarations

Types

Raise

typealias Raise<A> = arrow.core.raise.Raise<A>

RaiseAccumulate

typealias RaiseAccumulate<A> = arrow.core.raise.RaiseAccumulate<A>

ResultRaise

typealias ResultRaise = arrow.core.raise.ResultRaise

SingletonRaise

typealias SingletonRaise<A> = arrow.core.raise.SingletonRaise<A>

Functions

accumulate

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A> accumulate(block: context(RaiseAccumulate<Error>) () -> A): A

accumulating

context(raise: RaiseAccumulate<Error>)
inline fun <Error, A> accumulating(block: context(RaiseAccumulate<Error>) () -> A): RaiseAccumulate.Value<A>

bind

context(raise: Raise<Error>)
fun <Error, A> Either<Error, A>.bind(): A

context(raise: Raise<Error>)
suspend fun <Error, A> Effect<Error, A>.bind(): A

context(raise: ResultRaise)
fun <A> Result<A>.bind(): A

context(raise: SingletonRaise<Error>)
fun <Error, A> A?.bind(): A

context(raise: SingletonRaise<Error>)
fun <Error, A> Option<A>.bind(): A

bindAll

@JvmName(name = "bindAllEither")

context(raise: Raise<Error>)
fun <Error, A> NonEmptyList<Either<Error, A>>.bindAll(): NonEmptyList<A>

@JvmName(name = "bindAllEither")

context(raise: Raise<Error>)
fun <Error, A> NonEmptySet<Either<Error, A>>.bindAll(): NonEmptySet<A>

@JvmName(name = "bindAllEither")

context(raise: Raise<Error>)
fun <Error, A> Iterable<Either<Error, A>>.bindAll(): List<A>

@JvmName(name = "bindAllEither")

context(raise: Raise<Error>)
fun <Error, K, A> Map<K, Either<Error, A>>.bindAll(): Map<K, A>

@JvmName(name = "bindAllResult")

context(raise: ResultRaise)
fun <A> NonEmptyList<Result<A>>.bindAll(): NonEmptyList<A>

@JvmName(name = "bindAllResult")

context(raise: ResultRaise)
fun <A> NonEmptySet<Result<A>>.bindAll(): NonEmptySet<A>

@JvmName(name = "bindAllResult")

context(raise: ResultRaise)
fun <A> Iterable<Result<A>>.bindAll(): List<A>

@JvmName(name = "bindAllResult")

context(raise: ResultRaise)
fun <K, A> Map<K, Result<A>>.bindAll(): Map<K, A>

@JvmName(name = "bindAllNullable")

context(raise: SingletonRaise<Error>)
fun <Error, A> NonEmptyList<A?>.bindAll(): NonEmptyList<A>

@JvmName(name = "bindAllOption")

context(raise: SingletonRaise<Error>)
fun <Error, A> NonEmptyList<Option<A>>.bindAll(): NonEmptyList<A>

@JvmName(name = "bindAllNullable")

context(raise: SingletonRaise<Error>)
fun <Error, A> NonEmptySet<A?>.bindAll(): NonEmptySet<A>

@JvmName(name = "bindAllOption")

context(raise: SingletonRaise<Error>)
fun <Error, A> NonEmptySet<Option<A>>.bindAll(): NonEmptySet<A>

@JvmName(name = "bindAllNullable")

context(raise: SingletonRaise<Error>)
fun <Error, A> Iterable<A?>.bindAll(): List<A>

@JvmName(name = "bindAllOption")

context(raise: SingletonRaise<Error>)
fun <Error, A> Iterable<Option<A>>.bindAll(): List<A>

@JvmName(name = "bindAllNullable")

context(raise: SingletonRaise<Error>)
fun <Error, K, A> Map<K, A?>.bindAll(): Map<K, A>

@JvmName(name = "bindAllOption")

context(raise: SingletonRaise<Error>)
fun <Error, K, A> Map<K, Option<A>>.bindAll(): Map<K, A>

bindAllOrAccumulate

context(raise: RaiseAccumulate<Error>)
fun <Error, A> Iterable<Either<Error, A>>.bindAllOrAccumulate(): RaiseAccumulate.Value<List<A>>

bindNel

context(raise: RaiseAccumulate<Error>)
fun <A> EitherNel<Error, A>.bindNel(): A

bindNelOrAccumulate

context(raise: RaiseAccumulate<Error>)
fun <Error, A> EitherNel<Error, A>.bindNelOrAccumulate(): RaiseAccumulate.Value<A>

bindOrAccumulate

context(raise: RaiseAccumulate<Error>)
fun <Error, A> Either<Error, A>.bindOrAccumulate(): RaiseAccumulate.Value<A>

either

inline fun <Error, A> either(block: context(Raise<Error>) () -> A): Either<Error, A>

ensure

context(raise: Raise<Error>)
inline fun <Error> ensure(condition: Boolean, otherwise: () -> Error)

ensureNotNull

context(raise: Raise<Error>)
inline fun <Error, B : Any> ensureNotNull(value: B?, otherwise: () -> Error): B

ensureNotNullOrAccumulate

context(raise: RaiseAccumulate<Error>)
inline fun <Error, B : Any> ensureNotNullOrAccumulate(value: B?, error: () -> Error): RaiseAccumulate.Value<B>

ensureOrAccumulate

context(raise: RaiseAccumulate<Error>)
inline fun <Error> ensureOrAccumulate(condition: Boolean, error: () -> Error)

impure

inline fun impure(block: context(SingletonRaise<Unit>) () -> Unit)

ior

inline fun <Error, A> ior(noinline combineError: (Error, Error) -> Error, block: context(IorRaise<Error>) () -> A): Ior<Error, A>

iorNel

inline fun <Error, A> iorNel(noinline combineError: (NonEmptyList<Error>, NonEmptyList<Error>) -> NonEmptyList<Error> = { a, b -> a + b }, block: context(IorRaise<NonEmptyList<Error>>) () -> A): IorNel<Error, A>

mapOrAccumulate

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A, B> NonEmptyList<A>.mapOrAccumulate(transform: context(RaiseAccumulate<Error>) (A) -> B): NonEmptyList<B>

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A, B> Iterable<A>.mapOrAccumulate(transform: context(RaiseAccumulate<Error>) (A) -> B): List<B>

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A, B> Sequence<A>.mapOrAccumulate(transform: context(RaiseAccumulate<Error>) (A) -> B): List<B>

mapValuesOrAccumulate

context(raise: Raise<NonEmptyList<Error>>)
inline fun <K, Error, A, B> Map<K, A>.mapValuesOrAccumulate(transform: context(RaiseAccumulate<Error>) (Map.Entry<K, A>) -> B): Map<K, B>

nullable

inline fun <A> nullable(block: context(SingletonRaise<Nothing?>) () -> A): A?

option

inline fun <A> option(block: context(SingletonRaise<None>) () -> A): Option<A>

raise

context(raise: Raise<Error>)
fun <Error> raise(e: Error): Nothing

result

inline fun <A> result(block: context(ResultRaise) () -> A): Result<A>

singleton

inline fun <A> singleton(raise: () -> A, block: context(SingletonRaise<A>) () -> A): A

withError

context(raise: Raise<Error>)
inline fun <Error, OtherError, A> withError(transform: (OtherError) -> Error, block: context(Raise<OtherError>) () -> A): A

withNel

context(raise: RaiseAccumulate<Error>)
inline fun <A> withNel(block: context(Raise<NonEmptyList<Error>>) () -> A): A

zipOrAccumulate

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A, B, C> zipOrAccumulate(action1: context(RaiseAccumulate<Error>) () -> A, action2: context(RaiseAccumulate<Error>) () -> B, block: (A, B) -> C): C

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A, B, C, D> zipOrAccumulate(action1: context(RaiseAccumulate<Error>) () -> A, action2: context(RaiseAccumulate<Error>) () -> B, action3: context(RaiseAccumulate<Error>) () -> C, block: (A, B, C) -> D): D

context(raise: Raise<NonEmptyList<Error>>)
inline fun <Error, A, B, C, D, E> zipOrAccumulate(action1: context(RaiseAccumulate<Error>) () -> A, action2: context(RaiseAccumulate<Error>) () -> B, action3: context(RaiseAccumulate<Error>) () -> C, action4: context(RaiseAccumulate<Error>) () -> D, block: (A, B, C, D) -> E): E