None

Functions

infix fun align(b: Option): Option<Ior<Nothing, B>>

Align two options (this on the left and b on the right) as one Option of Ior.

inline fun <B, C> align(b: Option, f: (Ior<Nothing, B>) -> C): Option<C>

Align two options (this on the left and b on the right) as one Option of Ior, and then, if it's not None, map it using f.

all

inline fun all(predicate: (Nothing) -> Boolean): Boolean

Returns true if this option is empty '''or''' the predicate $predicate returns true when applied to this $option's value.

and

infix fun <X> and(value: Option<X>): Option<X>

crosswalk

inline fun crosswalk(f: (Nothing) -> Option): Option<Option>

crosswalkMap

inline fun <K, V> crosswalkMap(f: (Nothing) -> Map<K, V>): Map<K, Option<V>>

crosswalkNull

inline fun crosswalkNull(f: (Nothing) -> B?): Option?

exists

inline fun exists(predicate: (Nothing) -> Boolean): Boolean

Returns true if this option is nonempty '''and''' the predicate $p returns true when applied to this $option's value. Otherwise, returns false.

filter

inline fun filter(predicate: (Nothing) -> Boolean): Option<Nothing>

Returns this $option if it is nonempty '''and''' applying the predicate $p to this $option's value returns true. Otherwise, return $none.

filterNot

inline fun filterNot(predicate: (Nothing) -> Boolean): Option<Nothing>

Returns this $option if it is nonempty '''and''' applying the predicate $p to this $option's value returns false. Otherwise, return $none.

findOrNull

inline fun findOrNull(predicate: (Nothing) -> Boolean): Nothing?

Returns the $option's value if this option is nonempty '''and''' the predicate $p returns true when applied to this $option's value. Otherwise, returns null.

flatMap

inline fun flatMap(f: (Nothing) -> Option): Option

Returns the result of applying $f to this $option's value if this $option is nonempty. Returns $none if this $option is empty. Slightly different from map in that $f is expected to return an $option (which could be $none).

fold

inline fun <R> fold(ifEmpty: () -> R, ifSome: (Nothing) -> R): R

foldLeft

inline fun foldLeft(initial: B, operation: (B, Nothing) -> B): B

foldMap

inline fun foldMap(MB: Monoid, f: (Nothing) -> B): B

isDefined

fun isDefined(): Boolean

Returns true if the option is an instance of Some, false otherwise.

isEmpty

open override fun isEmpty(): Boolean

Returns true if the option is None, false otherwise.

isNotEmpty

fun isNotEmpty(): Boolean

map

inline fun map(f: (Nothing) -> B): Option

Returns a Some<$B> containing the result of applying $f to this $option's value if this $option is nonempty. Otherwise return $none.

mapNotNull

inline fun mapNotNull(f: (Nothing) -> B?): Option

Returns $none if the result of applying $f to this $option's value is null. Otherwise returns the result.

nonEmpty

fun nonEmpty(): Boolean

alias for isDefined

orNull

fun orNull(): Nothing?

padZip

fun padZip(other: Option): Option<Pair<Nothing?, B?>>

inline fun <B, C> padZip(other: Option, f: (Nothing?, B?) -> C): Option<C>

pairLeft

fun <L> pairLeft(left: L): Option<Pair<L, Nothing>>

pairRight

fun <R> pairRight(right: R): Option<Pair<Nothing, R>>

reduceOrNull

inline fun reduceOrNull(initial: (Nothing) -> B, operation: (acc: B, Nothing) -> B): B?

reduceRightEvalOrNull

inline fun reduceRightEvalOrNull(initial: (Nothing) -> B, operation: (Nothing, acc: Eval) -> Eval): Eval<B?>

replicate

fun replicate(n: Int): Option<List<Nothing>>

tap

inline fun tap(f: (Nothing) -> Unit): Option<Nothing>

The given function is applied as a fire and forget effect if this is a some. When applied the result is ignored and the original Some value is returned

tapNone

inline fun tapNone(f: () -> Unit): Option<Nothing>

The given function is applied as a fire and forget effect if this is a None. When applied the result is ignored and the original None value is returned

toEither

inline fun <L> toEither(ifEmpty: () -> L): Either<L, Nothing>

toList

fun toList(): List<Nothing>

toString

open override fun toString(): String

traverse

inline fun <AA, B> traverse(fa: (Nothing) -> Either<AA, B>): Either<AA, Option>

inline fun <AA, B> traverse(fa: (Nothing) -> Validated<AA, B>): Validated<AA, Option>

inline fun traverse(fa: (Nothing) -> Iterable): List<Option>

void

fun void(): Option<Unit>

zip

fun zip(other: Option): Option<Pair<Nothing, B>>

inline fun <B, C> zip(b: Option, map: (Nothing, B) -> C): Option<C>

inline fun <B, C, D> zip(b: Option, c: Option<C>, map: (Nothing, B, C) -> D): Option<D>

inline fun <B, C, D, E> zip(b: Option, c: Option<C>, d: Option<D>, map: (Nothing, B, C, D) -> E): Option<E>

inline fun <B, C, D, E, F> zip(b: Option, c: Option<C>, d: Option<D>, e: Option<E>, map: (Nothing, B, C, D, E) -> F): Option<F>

inline fun <B, C, D, E, F, G> zip(b: Option, c: Option<C>, d: Option<D>, e: Option<E>, f: Option<F>, map: (Nothing, B, C, D, E, F) -> G): Option<G>

inline fun <B, C, D, E, F, G, H> zip(b: Option, c: Option<C>, d: Option<D>, e: Option<E>, f: Option<F>, g: Option<G>, map: (Nothing, B, C, D, E, F, G) -> H): Option<H>

inline fun <B, C, D, E, F, G, H, I> zip(b: Option, c: Option<C>, d: Option<D>, e: Option<E>, f: Option<F>, g: Option<G>, h: Option<H>, map: (Nothing, B, C, D, E, F, G, H) -> I): Option

inline fun <B, C, D, E, F, G, H, I, J> zip(b: Option, c: Option<C>, d: Option<D>, e: Option<E>, f: Option<F>, g: Option<G>, h: Option<H>, i: Option, map: (Nothing, B, C, D, E, F, G, H, I) -> J): Option<J>

inline fun <B, C, D, E, F, G, H, I, J, K> zip(b: Option, c: Option<C>, d: Option<D>, e: Option<E>, f: Option<F>, g: Option<G>, h: Option<H>, i: Option, j: Option<J>, map: (Nothing, B, C, D, E, F, G, H, I, J) -> K): Option<K>

Extensions

combine

fun <A> Option<A>.combine(SGA: Semigroup<A>, b: Option<A>): Option<A>

compareTo

operator fun <A : Comparable<A>> Option<A>.compareTo(other: Option<A>): Int

ensure

inline fun <A> Option<A>.ensure(error: () -> Unit, predicate: (A) -> Boolean): Option<A>

filterIsInstance

inline fun Option<*>.filterIsInstance(): Option

Returns an Option containing all elements that are instances of specified type parameter B.

flatten

fun <A> Option<Option<A>>.flatten(): Option<A>

getOrElse

inline fun <T> Option<T>.getOrElse(default: () -> T): T

Returns the option's value if the option is nonempty, otherwise return the result of evaluating default.

handleError

inline fun <A> Option<A>.handleError(f: (Unit) -> A): Option<A>

handleErrorWith

inline fun <A> Option<A>.handleErrorWith(f: (Unit) -> Option<A>): Option<A>

infix fun <T> Option<T>.or(value: Option<T>): Option<T>

orElse

inline fun <A> Option<A>.orElse(alternative: () -> Option<A>): Option<A>

Returns this option's if the option is nonempty, otherwise returns another option provided lazily by default.

redeem

inline fun <A, B> Option<A>.redeem(fe: (Unit) -> B, fb: (A) -> B): Option

redeemWith

inline fun <A, B> Option<A>.redeemWith(fe: (Unit) -> Option, fb: (A) -> Option): Option

replicate

fun <A> Option<A>.replicate(n: Int, MA: Monoid<A>): Option<A>

rethrow

fun <A> Option<Either<Unit, A>>.rethrow(): Option<A>

salign

fun <A> Option<A>.salign(SA: Semigroup<A>, b: Option<A>): Option<A>

separateEither

fun <A, B> Option<Either<A, B>>.separateEither(): Pair<Option<A>, Option>

Separate the inner Either value into the Either.Left and Either.Right.

separateValidated

fun <A, B> Option<Validated<A, B>>.separateValidated(): Pair<Option<A>, Option>

Separate the inner Validated value into the Validated.Invalid and Validated.Valid.

sequence

fun <A> Option<Iterable<A>>.sequence(): List<Option<A>>

fun <A, B> Option<Either<A, B>>.sequence(): Either<A, Option>

fun <A, B> Option<Validated<A, B>>.sequence(): Validated<A, Option>

toMap

fun <K, V> Option<Pair<K, V>>.toMap(): Map<K, V>

unalign

fun <A, B> Option<Ior<A, B>>.unalign(): Pair<Option<A>, Option>

inline fun <A, B, C> Option<C>.unalign(f: (C) -> Ior<A, B>): Pair<Option<A>, Option>

unite

fun <A> Option<Iterable<A>>.unite(MA: Monoid<A>): Option<A>

uniteEither

fun <A, B> Option<Either<A, B>>.uniteEither(): Option

uniteValidated

fun <A, B> Option<Validated<A, B>>.uniteValidated(): Option

unzip

fun <A, B> Option<Pair<A, B>>.unzip(): Pair<Option<A>, Option>

inline fun <A, B, C> Option<C>.unzip(f: (C) -> Pair<A, B>): Pair<Option<A>, Option>

widen

fun <B, A : B> Option<A>.widen(): Option

Given A is a sub type of B, re-type this value from Option to Option