knomadic/nz.adjmunro.knomadic.outcome.members

Package-level declarations

Properties

@get:JvmName(name = "flattenNestedFailureAlias")

val <Ok : Any, Err : Any, Oki : Ok, Oko : Ok> Outcome<Oko, Outcome<Oki, Err>>.flatten: Outcome<Ok, Err>

An overloaded alias for Outcome.flattenNestedFailure.

@get:JvmName(name = "flattenNestedBothAlias")

val <Ok : Any, Err : Any, Oks : Ok, Ers : Err, Okf : Ok, Erf : Err> Outcome<Outcome<Oks, Ers>, Outcome<Okf, Erf>>.flatten: Outcome<Ok, Err>

An overloaded alias for Outcome.flattenNestedBoth.

@get:JvmName(name = "flattenNestedSuccessAlias")

val <Ok : Any, Err : Any, Eri : Err, Ero : Err> Outcome<Outcome<Ok, Eri>, Ero>.flatten: Outcome<Ok, Err>

An overloaded alias for Outcome.flattenNestedSuccess.

Functions

aggregate

inline fun <Ok : Any, Error : Any> Iterable<Outcome<Ok, Error>>.aggregate(reduce: (List<Error>) -> Error): Outcome<List<Ok>, Error>

andIf

inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.andIf(predicate: (Ok) -> Boolean, catch: (throwable: Throwable) -> Outcome<Ok, Error> = ::rethrow, success: RaiseScope<Error>.(Ok) -> Ok): Outcome<Ok, Error>

Transforms the encapsulated value if this instance represents success, and the predicate returns true. If predicate is false, the Outcome.Success is left unchanged.

andThen

inline fun <In : Any, Out : Any, Error : Any> Outcome<In, Error>.andThen(catch: (throwable: Throwable) -> Outcome<Out, Error> = ::rethrow, success: RaiseScope<Error>.(In) -> Out): Outcome<Out, Error>

Transforms the encapsulated value if this instance represents success.

coerceToFailure

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.coerceToFailure(falter: (Ok) -> Error): Outcome.Failure<Error>

Returns a new Outcome.Failure, after applying falter to the Outcome.Success value.

coerceToSuccess

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.coerceToSuccess(recover: (Error) -> Ok): Outcome.Success<Ok>

Returns a new Outcome.Success, after applying recover to the Outcome.Failure error.

collapse

fun <Ancestor : Any, Ok : Ancestor, Error : Ancestor> OutcomeFlow<Ok, Error>.collapse(): Flow<Ancestor>

inline fun <Ok : Any, Error : Any, Output> OutcomeFlow<Ok, Error>.collapse(crossinline success: suspend (Ok) -> Output, crossinline failure: suspend (Error) -> Output): Flow<Output>

fun <Ancestor : Any, Ok : Ancestor, Error : Ancestor> Outcome<Ok, Error>.collapse(): Ancestor

Collapse the receiver Outcome into either value or error, using the nearest common Ancestor as the type.

errorOrDefault

infix fun <Ok : Any, Error : Any> Outcome<Ok, Error>.errorOrDefault(default: Error): Error

errorOrElse

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.errorOrElse(faulter: (Ok) -> Error): Error

errorOrNull

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.errorOrNull(): Error?

errorOrThrow

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.errorOrThrow(): Error

falter

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.falter(transform: (Ok) -> Error): Outcome.Failure<Error>

An alias for coerceToFailure.

filterOnlyFailure

fun <Ok : Any, Error : Any> OutcomeFlow<Ok, Error>.filterOnlyFailure(): Flow<Error>

filterOnlySuccess

fun <Ok : Any, Error : Any> OutcomeFlow<Ok, Error>.filterOnlySuccess(): Flow<Ok>

flatMapFailure

infix inline fun <Ok : Any, ErrorIn : Any, ErrorOut : Any> Outcome<Ok, ErrorIn>.flatMapFailure(transform: (ErrorIn) -> Outcome<Ok, ErrorOut>): Outcome<Ok, ErrorOut>

Returns a new Outcome, after applying transform to the Outcome.Failure error.

flatMapSuccess

infix inline fun <In : Any, Out : Any, Error : Any> Outcome<In, Error>.flatMapSuccess(transform: (In) -> Outcome<Out, Error>): Outcome<Out, Error>

Returns a new Outcome, after applying transform to the Outcome.Success value.

flattenNestedBoth

Flatten the nested Outcome inside both Outcome.Success and Outcome.Failure states, into a single Outcome.

flattenNestedFailure

fun <OuterOk : AncestorOk, EmbeddedOk : AncestorOk, Error : Any, AncestorOk : Any> Outcome<OuterOk, Outcome<EmbeddedOk, Error>>.flattenNestedFailure(): Outcome<AncestorOk, Error>

Flatten a nested Outcome inside the Outcome.Failure state, into a single Outcome.

flattenNestedSuccess

fun <Ok : Any, EmbeddedError : AncestorError, OuterError : AncestorError, AncestorError : Any> Outcome<Outcome<Ok, EmbeddedError>, OuterError>.flattenNestedSuccess(): Outcome<Ok, AncestorError>

Flatten a nested Outcome inside the Outcome.Success state, into a single Outcome.

fold

inline fun <Ok : Any, Error : Any, Output> Outcome<Ok, Error>.fold(success: (Ok) -> Output, failure: (Error) -> Output): Output

Fold the caller into some Output.

getOrDefault

infix fun <Ok : Any, Error : Any> Outcome<Ok, Error>.getOrDefault(default: Ok): Ok

getOrElse

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.getOrElse(recover: (Error) -> Ok): Ok

getOrNull

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.getOrNull(): Ok?

getOrThrow

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.getOrThrow(): Ok

invert

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.invert(): Outcome<Error, Ok>

Inverts the Outcome so that the Outcome.Success value becomes the Outcome.Failure error and vice versa.

isFailure

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.isFailure(): Boolean

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.isFailure(predicate: (Error) -> Boolean): Boolean

isSuccess

fun <Ok : Any, Error : Any> Outcome<Ok, Error>.isSuccess(): Boolean

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.isSuccess(predicate: (Ok) -> Boolean): Boolean

map

inline fun <In : Any, Out : Any, ErrorIn : Any, ErrorOut : Any> Outcome<In, ErrorIn>.map(success: (In) -> Out, failure: (ErrorIn) -> ErrorOut): Outcome<Out, ErrorOut>

Transform an Outcome with either success or failure.

mapEachFailure

inline fun <Ok : Any, ErrorIn : Any, ErrorOut : Any> OutcomeFlow<Ok, ErrorIn>.mapEachFailure(crossinline transform: suspend (ErrorIn) -> ErrorOut): OutcomeFlow<Ok, ErrorOut>

mapEachSuccess

inline fun <In : Any, Out : Any, Error : Any> OutcomeFlow<In, Error>.mapEachSuccess(crossinline transform: suspend (In) -> Out): OutcomeFlow<Out, Error>

mapFailure

infix inline fun <Ok : Any, ErrorIn : Any, ErrorOut : Any> Outcome<Ok, ErrorIn>.mapFailure(transform: (ErrorIn) -> ErrorOut): Outcome<Ok, ErrorOut>

Returns a new Outcome, after applying transform to the Outcome.Failure error.

mapSuccess

infix inline fun <In : Any, Out : Any, Error : Any> Outcome<In, Error>.mapSuccess(transform: (In) -> Out): Outcome<Out, Error>

Returns a new Outcome, after applying transform to the Outcome.Success value.

onEachFailure

inline fun <Ok : Any, Error : Any> OutcomeFlow<Ok, Error>.onEachFailure(crossinline block: suspend (Error) -> Unit): OutcomeFlow<Ok, Error>

onEachSuccess

inline fun <Ok : Any, Error : Any> OutcomeFlow<Ok, Error>.onEachSuccess(crossinline block: suspend (Ok) -> Unit): OutcomeFlow<Ok, Error>

onFailure

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.onFailure(block: (Error) -> Unit): Outcome<Ok, Error>

onSuccess

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.onSuccess(block: (Ok) -> Unit): Outcome<Ok, Error>

recover

infix inline fun <Ok : Any, Error : Any> Outcome<Ok, Error>.recover(transform: (Error) -> Ok): Outcome.Success<Ok>

An alias for coerceToSuccess.

rfold

inline fun <Ok : Any, Error : Any, Output> Outcome<Ok, Error>.rfold(failure: (Error) -> Output, success: (Ok) -> Output): Output

Reverse fold is syntax-sugar that swaps the lambda argument order.

tryRecover

inline fun <Ok : Any, ErrorIn : Any, ErrorOut : Any> Outcome<Ok, ErrorIn>.tryRecover(catch: (throwable: Throwable) -> Outcome<Ok, ErrorOut> = ::rethrow, failure: RaiseScope<ErrorOut>.(ErrorIn) -> Ok): Outcome<Ok, ErrorOut>

Transform failure into success.

unwrap

infix inline fun <Ok, Error : Any> Outcome<Ok & Any, Error>.unwrap(recover: (Error) -> Ok = { error("Outcome::unwrap threw! Got: $this") }): Ok

Attempt to unwrap Outcome into an Ok value.

unwrapError

infix inline fun <Ok : Any, Error> Outcome<Ok, Error & Any>.unwrapError(faulter: (Ok) -> Error = { error("Outcome::unwrapError threw! Got: $this") }): Error

Attempt to unwrap Outcome into an Ok value.