Call another and retrieve the result. If the result is success, continue (the result of calling another is discarded). If the result is an error, propagate it to this. Effectively, requires for another ApiResult to succeed before proceeding with this one.

component1

inline operator fun component1(): T?

Get the Success component of this result or null

component2

inline operator fun component2(): Exception?

Get the Error component of this result or null

errorIf

inline fun <T> ApiResult<T>.errorIf(exception: () -> Exception = { ConditionNotSatisfiedException() }, predicate: (T) -> Boolean): ApiResult<T>

Makes this an Error if predicate returns true

errorIfEmpty

inline fun <T, R : Iterable<T>> ApiResult<R>.errorIfEmpty(exception: () -> Exception = { ConditionNotSatisfiedException("Collection was empty") }): ApiResult<R>

@JvmName(name = "sequenceErrorIfEmpty")

inline fun <T, R : Sequence<T>> ApiResult<R>.errorIfEmpty(exception: () -> Exception = { ConditionNotSatisfiedException("Sequence was empty") }): ApiResult<R>

Makes this an error if the collection is empty.

errorOnLoading

inline fun <T> ApiResult<T>.errorOnLoading(exception: () -> Exception = { NotFinishedException() }): ApiResult<T>

Makes this result an Error if this result is Loading

errorOnNull

inline fun <T : Any> ApiResult<T?>?.errorOnNull(exception: () -> Exception = { ConditionNotSatisfiedException("Value was null") }): ApiResult<T>

Make this result an Error if Success value was null.

errorUnless

inline fun <T> ApiResult<T>.errorUnless(exception: () -> Exception = { ConditionNotSatisfiedException() }, predicate: (T) -> Boolean): ApiResult<T>

Makes this an Error if predicate returns false

exceptionOrNull

inline fun <T> ApiResult<T>?.exceptionOrNull(): Exception?

filter

infix inline fun <T : Iterable<R>, R> ApiResult<T>.filter(block: (R) -> Boolean): ApiResult<List<R>>

Filter the underlying collection.

@JvmName(name = "filterSequence")

infix inline fun <T : Sequence<R>, R> ApiResult<T>.filter(noinline block: (R) -> Boolean): ApiResult<Sequence<R>>

Filter the underlying sequence.

flatMap

infix inline fun <T, R> ApiResult<T>.flatMap(another: (T) -> ApiResult<R>): ApiResult<R>

Call another and if it succeeds, continue with another's result. If it fails, propagate the error. An alias for then.

fold

inline fun <T, R> ApiResult<T>.fold(onSuccess: (result: T) -> R, onError: (e: Exception) -> R, noinline onLoading: () -> R? = null): R

Fold this returning the result of onSuccess or onError By default, maps Loading to Error with NotFinishedException

ifEmpty

infix inline fun <T : Iterable<R>, R> ApiResult<T>.ifEmpty(block: () -> Unit): ApiResult<T>

Execute block if this's collection is empty.

map

infix inline fun <T, R> ApiResult<T>.map(block: (T) -> R): ApiResult<R>

Change the type of the Success to R without affecting Error/Loading results

mapEither

inline fun <T, R> ApiResult<T>.mapEither(success: (T) -> R, error: (Exception) -> Exception): ApiResult<R>

Map both Error and Success. Does not affect Loading

mapError

@JvmName(name = "mapErrorTyped")

infix inline fun <R : Exception, T> ApiResult<T>.mapError(block: (R) -> Exception): ApiResult<T>

Map the exception of the Error state, but only if this exception is of type R. Loading and Success are unaffected

infix inline fun <T> ApiResult<T>.mapError(block: (Exception) -> Exception): ApiResult<T>

Change the exception of the Error response without affecting loading/success results

mapErrorToCause

inline fun <T> ApiResult<T>.mapErrorToCause(): ApiResult<T>

Maps the error of the result, if present, to its cause, or self if cause is not available

mapLoading

infix inline fun <T, R : T> ApiResult<T>.mapLoading(block: () -> R): ApiResult<T>

Maps Loading to a Success, not affecting other states.

mapOrDefault

inline fun <T, R> ApiResult<T>.mapOrDefault(default: (e: Exception) -> R, transform: (T) -> R): R

Map the Success result using transform, and if the result is not a success, return default

mapValues

infix inline fun <T, R> ApiResult<Iterable<T>>.mapValues(transform: (T) -> R): ApiResult<List<R>>

Executes ApiResult.map on each value of the collection

@JvmName(name = "sequenceMapValues")

infix inline fun <T, R> ApiResult<Sequence<T>>.mapValues(noinline transform: (T) -> R): ApiResult<Sequence<R>>

Executes ApiResult.map on each value of the sequence

merge

inline fun <T> ApiResult<T>.merge(results: Iterable<ApiResult<T>>): ApiResult<List<T>>

Merges this results and all other results into a single result of type T.

not

inline operator fun not(): T

Bang operator returns the result or throws if it is an Error or Loading This is equivalent to calling orThrow

nullOnError

inline fun <T> ApiResult<T>.nullOnError(): ApiResult<T?>

Maps Error values to nulls

onEmpty

infix inline fun <T : Iterable<R>, R> ApiResult<T>.onEmpty(block: () -> Unit): ApiResult<T>

Execute block if this's collection is empty.

onError

@JvmName(name = "onErrorTyped")

infix inline fun <E : Exception, T> ApiResult<T>.onError(block: (E) -> Unit): ApiResult<T>

Invoke a given block if this is Error and it's Error.e is of type E.

infix inline fun <T> ApiResult<T>.onError(block: (Exception) -> Unit): ApiResult<T>

Invoke a given block if this is Error

onLoading

infix inline fun <T> ApiResult<T>.onLoading(block: () -> Unit): ApiResult<T>

Invoke given block if this is Loading

onSuccess

infix inline fun <T> ApiResult<T>.onSuccess(block: (T) -> Unit): ApiResult<T>

Invoke a given block if this is Success

infix inline fun <T, R : T> ApiResult<T>.or(defaultValue: R): T

If this is Error or Loading, returns defaultValue.

orElse

infix inline fun <T, R : T> ApiResult<T>.orElse(block: (e: Exception) -> R): T

Executes block if this is an ApiResult.Error, otherwise returns ApiResult.value will result in NotFinishedException

orEmpty

inline fun <T> ApiResult<Collection<T>>.orEmpty(): Collection<T>

inline fun <T> ApiResult<Set<T>>.orEmpty(): Set<T>

inline fun <T> ApiResult<Sequence<T>>.orEmpty(): Sequence<T>

Returns emptyList if this's collection is empty

inline fun <T> ApiResult<List<T>>.orEmpty(): List<T>

Returns emptyList if this's list is empty

inline fun <K, V> ApiResult<Map<K, V>>.orEmpty(): Map<K, V>

Returns emptyMap if this's map is empty

orNull

inline fun <T> ApiResult<T>?.orNull(): T?

orThrow

inline fun <T> ApiResult<T>.orThrow(): T

Throws ApiResult.Error.e, or NotFinishedException if the request has not been completed yet.

recover

@JvmName(name = "recoverTyped")

infix inline fun <T : Exception, R> ApiResult<R>.recover(another: (e: T) -> ApiResult<R>): ApiResult<R>

Recover from an exception of type R, else no-op. Does not affect Loading.

infix inline fun <T> ApiResult<T>.recover(another: (e: Exception) -> ApiResult<T>): ApiResult<T>

Recover from an exception. Does not affect Loading See also the typed version of this function to recover from a specific exception type

recoverIf

inline fun <T> ApiResult<T>.recoverIf(condition: (Exception) -> Boolean, block: (Exception) -> ApiResult<T>): ApiResult<T>

Recover from an Error only if the condition is true, else no-op. Does not affect Loading

require

inline fun <T> ApiResult<T>.require(): T

Alias for orThrow

inline fun <T> ApiResult<T>.require(message: () -> String? = { null }, predicate: (T) -> Boolean): ApiResult<T>

Makes this an error with ConditionNotSatisfiedException using specified message if the predicate returns false.

requireIs

inline fun <R, T> ApiResult<T>.requireIs(exception: (T) -> Exception = { value -> "Result value is of type ${value?.let { it::class.simpleName }} but expected ${R::class.simpleName}" .let(::ConditionNotSatisfiedException) }): ApiResult<R>

requireNotNull

inline fun <T> ApiResult<T?>?.requireNotNull(): ApiResult<T & Any>

Alias for errorOnNull

rethrow

inline fun <T : Exception, R> ApiResult<R>.rethrow(): ApiResult<R>

Throws if this result is an Error and Error.e is of type T. Ignores all other exceptions.

rethrowCancellation

inline fun <T> ApiResult<T>.rethrowCancellation(): ApiResult<T>

Throws CancellationExceptions if this is an Error.

then

infix inline fun <T, R> ApiResult<T>.then(another: (T) -> ApiResult<R>): ApiResult<R>

Call another and if it succeeds, continue with another's result. If it fails, propagate the error. Effectively, flatMap to another result.

toString

open override fun toString(): String

tryChain

infix inline fun <T> ApiResult<T>.tryChain(block: (T) -> Unit): ApiResult<T>

Call block, wrapping it in an ApiResult, and then discard the Success value, but propagate Errors.

tryMap

infix inline fun <T, R> ApiResult<T>.tryMap(block: (T) -> R): ApiResult<R>

Change the type of successful result to R, also wrapping block in another result then folding it (handling exceptions)

tryRecover

@JvmName(name = "tryRecoverTyped")

infix inline fun <T : Exception, R> ApiResult<R>.tryRecover(block: (T) -> R): ApiResult<R>

calls recover catching and wrapping any exceptions thrown inside block.

infix inline fun <T> ApiResult<T>.tryRecover(block: (e: Exception) -> T): ApiResult<T>

Calls recover catching and wrapping any exceptions thrown inside block. See also the typed version of this function to recover from a specific exception type

tryRecoverIf

inline fun <T> ApiResult<T>.tryRecoverIf(condition: (Exception) -> Boolean, block: (Exception) -> T): ApiResult<T>

Recover from an Error only if the condition is true, else no-op. Does not affect Loading

unit

inline fun ApiResult<*>.unit(): ApiResult<Unit>

Map this result to Unit, discarding the value

unwrap

inline fun <T> ApiResult<ApiResult<T>>.unwrap(): ApiResult<T>

Unwrap an ApiResult> to be ApiResult