Both

data class Both<out A, out B>(val leftValue: A, val rightValue: B) : Ior<A, B>

Constructors

Both

fun <out A, out B> Both(leftValue: A, rightValue: B)

Functions

all

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

bicrosswalk

inline fun <C, D> bicrosswalk(fa: (A) -> Iterable<C>, fb: (B) -> Iterable<D>): List<Ior<C, D>>

bicrosswalkMap

inline fun <C, D, K> bicrosswalkMap(fa: (A) -> Map<K, C>, fb: (B) -> Map<K, D>): Map<K, Ior<C, D>>

bicrosswalkNull

inline fun <C, D> bicrosswalkNull(fa: (A) -> C?, fb: (B) -> D?): Ior<C, D>?

bifoldLeft

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

bifoldMap

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

bimap

inline fun <C, D> bimap(fa: (A) -> C, fb: (B) -> D): Ior<C, D>

Apply fa if this is a Left or Both to A and apply fb if this is Right or Both to B

bitraverse

inline fun <AA, C> bitraverse(fa: (A) -> Iterable<AA>, fb: (B) -> Iterable<C>): List<Ior<AA, C>>

bitraverseEither

inline fun <AA, C, D> bitraverseEither(fa: (A) -> Either<AA, C>, fb: (B) -> Either<AA, D>): Either<AA, Ior<C, D>>

bitraverseNullable

inline fun <C, D> bitraverseNullable(fa: (A) -> C?, fb: (B) -> D?): Ior<C, D>?

bitraverseOption

inline fun <C, D> bitraverseOption(fa: (A) -> Option<C>, fb: (B) -> Option<D>): Option<Ior<C, D>>

bitraverseValidated

inline fun <AA, C, D> bitraverseValidated( SA: Semigroup<AA>, fa: (A) -> Validated<AA, C>, fb: (B) -> Validated<AA, D>): Validated<AA, Ior<C, D>>

crosswalk

inline fun <C> crosswalk(fa: (B) -> Iterable<C>): List<Ior<A, C>>

crosswalkMap

inline fun <K, V> crosswalkMap(fa: (B) -> Map<K, V>): Map<K, Ior<A, V>>

crosswalkNull

inline fun <A, B, C> crosswalkNull(ior: Ior<A, B>, fa: (B) -> C?): Ior<A, C>?

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( fa: (A) -> C, fb: (B) -> C, fab: (A, B) -> C): C

Applies fa if this is a Left, fb if this is a Right or fab if this is a Both

foldLeft

inline fun <C> foldLeft(c: C, f: (C, B) -> C): C

foldMap

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

isEmpty

fun isEmpty(): Boolean

isNotEmpty

fun isNotEmpty(): Boolean

leftOrNull

fun leftOrNull(): A?

Returns the Left value or A if this is Left or Both and null if this is a Right.

map

inline fun <D> map(f: (B) -> D): Ior<A, D>

The given function is applied if this is a Right or Both to B.

mapLeft

inline fun <C> mapLeft(fa: (A) -> C): Ior<C, B>

The given function is applied if this is a Left or Both to A.

orNull

fun orNull(): B?

Returns the Right value or B if this is Right or Both and null if this is a Left.

padNull

fun padNull(): Pair<A?, B?>

Return this Ior as Pair of nullables]

swap

fun swap(): Ior<B, A>

If this is a Left, then return the left value in Right or vice versa, when this is Both , left and right values are swap

toEither

fun toEither(): Either<A, B>

Returns a Either.Right containing the Right value or B if this is Right or Both and Either.Left if this is a Left.

toString

open override fun toString(): String

toValidated

fun toValidated(): Validated<A, B>

Returns a Validated.Valid containing the Right value or B if this is Right or Both and Validated.Invalid if this is a Left.

traverse

inline fun <AA, C> traverse(fa: (B) -> Either<AA, C>): Either<AA, Ior<A, C>>

inline fun <C> traverse(fa: (B) -> Option<C>): Option<Ior<A, C>>

inline fun <AA, C> traverse(fa: (B) -> Validated<AA, C>): Validated<AA, Ior<A, C>>

inline fun <C> traverse(fa: (B) -> Iterable<C>): List<Ior<A, C>>

traverseEither

~~inline~~ ~~fun~~ <AA, C> ~~traverseEither~~(fa: (B) -> Either<AA, C>): Either<AA, Ior<A, C>>

traverseNullable

inline fun <C> traverseNullable(fa: (B) -> C?): Ior<A, C>?

traverseOption

~~inline~~ ~~fun~~ <C> ~~traverseOption~~(fa: (B) -> Option<C>): Option<Ior<A, C>>

traverseValidated

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

unwrap

fun unwrap(): Either<Either<A, B>, Pair<A, B>>

Return the isomorphic Either of this Ior

void

fun void(): Ior<A, Unit>

Properties

isBoth

open override val isBoth: Boolean

Returns true if this is a Both, false otherwise.

isLeft

open override val isLeft: Boolean

Returns true if this is a Left, false otherwise.

isRight

open override val isRight: Boolean

Returns true if this is a Right, false otherwise.

leftValue

val leftValue: A

rightValue

val rightValue: B