Right

data class Right<out B>(val value: B) : Either<Nothing, B>

The right side of the disjoint union, as opposed to the Left side.

Constructors

Right

fun <out B> Right(value: B)

Types

Companion

object Companion

Functions

all

~~inline~~ ~~fun~~ ~~all~~(predicate: (B) -> 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, Nothing) -> C, g: (C, B) -> C): C

bifoldMap

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

bimap

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

Map over Left and Right of this Either

bitraverse

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

bitraverseNullable

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

bitraverseOption

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

bitraverseValidated

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

exists

~~inline~~ ~~fun~~ ~~exists~~(predicate: (B) -> 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: (B) -> Boolean): B?

fold

inline fun <C> fold(ifLeft: (left: Nothing) -> C, ifRight: (B) -> 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, B) -> C): C

foldMap

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

getOrNone

fun getOrNone(): Option<B>

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(): B?

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: (B) -> C): Either<Nothing, C>

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

mapLeft

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

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

onLeft

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

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

onRight

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

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

orNone

fun orNone(): Option<B>

orNull

~~fun~~ ~~orNull~~(): B?

replicate

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

swap

fun swap(): Either<B, Nothing>

Swap the generic parameters A and B of this Either.

tap

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

tapLeft

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

toString

open override fun toString(): String

toValidated

fun toValidated(): Validated<Nothing, B>

toValidatedNel

fun toValidatedNel(): ValidatedNel<Nothing, B>

traverse

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

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

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

traverseNullable

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

traverseOption

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

traverseValidated

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

void

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

Properties

value

val value: B