Quiver Library/app.cash.quiver

Package-level declarations

Custom types (e.g. Outcome)

Types

Absent

data object Absent : Outcome<Nothing, Nothing>

Failure

data class Failure<E>(val error: E) : Outcome<E, Nothing>

Outcome

sealed class Outcome<out E, out A>

Outcome is a type that represents three possible states a result can be in: Present, Absent or Failure. Under the hood it wraps the type Either<E, Option<A>> and supports the common functions that Eithers and Options support such as map, flatMap and zip.

Present

data class Present<A>(val value: A) : Outcome<Nothing, A>

A data class representing the Presence of a value A.

Functions

asEither

inline fun <E, A> Outcome<E, A>.asEither(onAbsent: () -> E): Either<E, A>

asOption

fun <E, A> Outcome<E, A>.asOption(): Option<A>

Converts an Outcome to an option treating Failure as Absent

asOutcome

fun <E, A> Either<E, A>.asOutcome(): Outcome<E, A>

asResult

fun <A> OutcomeOf<A>.asResult(): Result<Option<A>>

Converts an OutcomeOf to a Result>. This reflects the inner structure of the Outcome.

inline fun <A> OutcomeOf<A>.asResult(onAbsent: () -> Throwable): Result<A>

Converts an OutcomeOf to a Result , converting Absent to a Failure.

failure

fun <E> E.failure(): Outcome<E, Nothing>

filter

inline fun <A, E> Outcome<E, A>.filter(p: (A) -> Boolean): Outcome<E, A>

flatMap

inline fun <A, E, B> Outcome<E, A>.flatMap(f: (A) -> Outcome<E, B>): Outcome<E, B>

FlatMap allows multiple Outcomes to be safely chained together, passing the value from the previous as input into the next function that produces an Outcome

flatTap

inline fun <A, E, B> Outcome<E, A>.flatTap(f: (A) -> Outcome<E, B>): Outcome<E, A>

Performs a flatMap across the supplied function, propagating failures or absence but preserving the original present value.

flatten

fun <A, E> Outcome<E, Outcome<E, A>>.flatten(): Outcome<E, A>

fold

inline fun <E, A, B> Outcome<E, A>.fold(onFailure: (E) -> B, onAbsent: () -> B, onPresent: (A) -> B): B

foldOption

inline fun <E, A, B> Outcome<E, A>.foldOption(onAbsent: () -> B, onPresent: (A) -> B): Either<E, B>

getOrElse

inline fun <E, A> Outcome<E, A>.getOrElse(onAbsentOrFailure: () -> A): A

mapFailure

inline fun <E, A, EE> Outcome<E, A>.mapFailure(f: (E) -> EE): Outcome<EE, A>

onAbsentHandle

inline fun <E, A> Outcome<E, A>.onAbsentHandle(onAbsent: () -> Outcome<E, A>): Outcome<E, A>

onFailureHandle

inline fun <E, A> Outcome<E, A>.onFailureHandle(onFailure: (E) -> Outcome<E, A>): Outcome<E, A>

optionOrThrow

fun <A> Outcome<Throwable, A>.optionOrThrow(): Option<A>

orThrow

inline fun <A> Outcome<Throwable, A>.orThrow(onAbsent: () -> Throwable): A

present

fun <A> A.present(): Outcome<Nothing, A>

recover

inline fun <E, A, EE> Outcome<E, A>.recover(block: OutcomeRaise<EE>.(E) -> A): Outcome<EE, A>

sequence

fun <E, EE, A> Outcome<E, Either<EE, A>>.sequence(): Either<EE, Outcome<E, A>>

fun <E, A> Outcome<E, Option<A>>.sequence(): Option<Outcome<E, A>>

fun <E, A> Outcome<E, Iterable<A>>.sequence(): List<Outcome<E, A>>

fun <E, A> Iterable<Outcome<E, A>>.sequence(): Outcome<E, List<A>>

tapAbsent

inline fun <A, B, E> Outcome<E, A>.tapAbsent(f: () -> B): Outcome<E, A>

tapFailure

inline fun <A, B, E> Outcome<E, A>.tapFailure(f: (E) -> B): Outcome<E, A>

toOutcome

fun <E, A> Either<E, Option<A>>.toOutcome(): Outcome<E, A>

An extension method on Either> that converts it to an Outcome.

fun <A> Option<A>.toOutcome(): Outcome<Nothing, A>

fun <A> Result<A>.toOutcome(): Outcome<Throwable, A>

traverse

inline fun <E, EE, A, B> Outcome<E, A>.traverse(f: (A) -> Either<EE, B>): Either<EE, Outcome<E, B>>

inline fun <E, A, B> Outcome<E, A>.traverse(f: (A) -> Option<B>): Option<Outcome<E, B>>

inline fun <E, A, B> Outcome<E, A>.traverse(f: (A) -> List<B>): List<Outcome<E, B>>

zip

inline fun <E, A, B, C> Outcome<E, A>.zip(other: Outcome<E, B>, f: (A, B) -> C): Outcome<E, C>

Zip allows you to combine two or more Outcomes easily with a supplied function.

inline fun <E, A, B, C, D> Outcome<E, A>.zip(o1: Outcome<E, B>, o2: Outcome<E, C>, crossinline f: (A, B, C) -> D): Outcome<E, D>

inline fun <E, A, B, C, D, EE> Outcome<E, A>.zip(o1: Outcome<E, B>, o2: Outcome<E, C>, o3: Outcome<E, D>, crossinline f: (A, B, C, D) -> EE): Outcome<E, EE>

inline fun <E, A, B, C, D, EE, F> Outcome<E, A>.zip(o1: Outcome<E, B>, o2: Outcome<E, C>, o3: Outcome<E, D>, o4: Outcome<E, EE>, crossinline f: (A, B, C, D, EE) -> F): Outcome<E, F>