Left

data class Left<out A>(val value: A) : Either<A, Nothing>

The left side of the disjoint union, as opposed to the Right side.

Constructors

Left

fun <out A> Left(value: A)

Types

Companion

object Companion

Functions

all

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

Returns true if Left or returns the result of the application of the given predicate to the Right value.

bifoldLeft

~~inline~~ ~~fun~~ <C> ~~bifoldLeft~~( c: C, f: (C, A) -> C, g: (C, Nothing) -> C): C

bifoldMap

~~inline~~ ~~fun~~ <C> ~~bifoldMap~~( MN: Monoid<C>, f: (A) -> C, g: (Nothing) -> C): C

bimap

~~inline~~ ~~fun~~ <C, D> ~~bimap~~(leftOperation: (A) -> C, rightOperation: (right: Nothing) -> D): Either<C, D>

Map over Left and Right of this Either

bitraverse

~~inline~~ ~~fun~~ <AA, C> ~~bitraverse~~(fe: (A) -> Iterable<AA>, fa: (Nothing) -> Iterable<C>): List<Either<AA, C>>

bitraverseNullable

~~inline~~ ~~fun~~ <AA, C> ~~bitraverseNullable~~(fl: (A) -> AA?, fr: (Nothing) -> C?): Either<AA, C>?

bitraverseOption

~~inline~~ ~~fun~~ <AA, C> ~~bitraverseOption~~(fl: (A) -> Option<AA>, fr: (Nothing) -> Option<C>): Option<Either<AA, C>>

bitraverseValidated

~~inline~~ ~~fun~~ <AA, C, D> ~~bitraverseValidated~~(fe: (A) -> Validated<AA, C>, fa: (Nothing) -> Validated<AA, D>): Validated<AA, Either<C, D>>

exists

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

Returns false if Left or returns the result of the application of the given predicate to the Right value.

findOrNull

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

fold

inline fun <C> fold(ifLeft: (A) -> C, ifRight: (right: Nothing) -> C): C

Transform an Either into a value of C. Alternative to using when to fold an Either into a value C.

foldLeft

~~inline~~ ~~fun~~ <C> ~~foldLeft~~(initial: C, rightOperation: (C, Nothing) -> C): C

foldMap

~~fun~~ <C> ~~foldMap~~(MN: Monoid<C>, f: (Nothing) -> C): C

getOrNone

fun getOrNone(): Option<Nothing>

Transforms Either into Option, where the encapsulated value B is wrapped in Some when this instance represents Either.Right, or None if it is Either.Left.

getOrNull

fun getOrNull(): Nothing?

Returns the encapsulated value B if this instance represents Either.Right or null if it is Either.Left.

isEmpty

~~fun~~ ~~isEmpty~~(): Boolean

Returns true if Left

isLeft

fun isLeft(): Boolean

isNotEmpty

~~fun~~ ~~isNotEmpty~~(): Boolean

Returns true if Right

isRight

fun isRight(): Boolean

map

inline fun <C> map(f: (right: Nothing) -> C): Either<A, C>

Map, or transform, the right value B of this Either to a new value C.

mapLeft

inline fun <C> mapLeft(f: (A) -> C): Either<C, Nothing>

Map, or transform, the left value A of this Either to a new value C.

onLeft

inline fun onLeft(action: (A) -> Unit): Either<A, Nothing>

Performs the given action on the encapsulated A if this instance represents Either.Left. Returns the original Either unchanged.

onRight

inline fun onRight(action: (right: Nothing) -> Unit): Either<A, Nothing>

Performs the given action on the encapsulated B value if this instance represents Either.Right. Returns the original Either unchanged.

orNone

fun orNone(): Option<Nothing>

orNull

~~fun~~ ~~orNull~~(): Nothing?

replicate

~~fun~~ ~~replicate~~(n: Int): Either<A, List<Nothing>>

swap

fun swap(): Either<Nothing, A>

Swap the generic parameters A and B of this Either.

tap

~~inline~~ ~~fun~~ ~~tap~~(f: (right: Nothing) -> Unit): Either<A, Nothing>

tapLeft

~~inline~~ ~~fun~~ ~~tapLeft~~(f: (A) -> Unit): Either<A, Nothing>

toString

open override fun toString(): String

toValidated

fun toValidated(): Validated<A, Nothing>

toValidatedNel

fun toValidatedNel(): ValidatedNel<A, Nothing>

traverse

~~inline~~ ~~fun~~ <C> ~~traverse~~(fa: (Nothing) -> Option<C>): Option<Either<A, C>>

inline fun <AA, C> traverse(fa: (Nothing) -> Validated<AA, C>): Validated<AA, Either<A, C>>

~~inline~~ ~~fun~~ <C> ~~traverse~~(fa: (Nothing) -> Iterable<C>): List<Either<A, C>>

traverseNullable

~~inline~~ ~~fun~~ <C> ~~traverseNullable~~(fa: (Nothing) -> C?): Either<A, C>?

traverseOption

~~inline~~ ~~fun~~ <C> ~~traverseOption~~(fa: (Nothing) -> Option<C>): Option<Either<A, C>>

traverseValidated

~~inline~~ ~~fun~~ <AA, C> ~~traverseValidated~~(fa: (Nothing) -> Validated<AA, C>): Validated<AA, Either<A, C>>

void

~~fun~~ ~~void~~(): Either<A, Unit>

Properties

value

val value: A