arrow-core/arrow.core/Ior/Right

Right

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

Constructors

Right

fun <out B> Right(value: B)

Types

Companion

object Companion

Functions

all

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

bicrosswalk

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

bicrosswalkMap

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

bicrosswalkNull

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

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(fa: (Nothing) -> 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: (Nothing) -> Iterable<AA>, fb: (B) -> Iterable<C>): List<Ior<AA, C>>

bitraverseEither

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

bitraverseNullable

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

bitraverseOption

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

bitraverseValidated

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

crosswalk

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

crosswalkMap

inline fun <K, V> crosswalkMap(fa: (B) -> Map<K, V>): Map<K, Ior<Nothing, 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: (Nothing) -> C, fb: (B) -> C, fab: (Nothing, 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(): Nothing?

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<Nothing, D>

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

mapLeft

inline fun <C> mapLeft(fa: (Nothing) -> 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<Nothing?, B?>

Return this Ior as Pair of nullables]

swap

fun swap(): Ior<B, Nothing>

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<Nothing, 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<Nothing, 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<Nothing, C>>

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

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

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

traverseNullable

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

unwrap

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

Return the isomorphic Either of this Ior

void

fun void(): Ior<Nothing, 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.

value

val value: B

Extensions

bisequence

fun <A, B> Ior<Iterable<A>, Iterable>.bisequence(): List<Ior<A, B>>

bisequenceEither

fun <A, B, C> Ior<Either<A, B>, Either<A, C>>.bisequenceEither(): Either<A, Ior<B, C>>

bisequenceNullable

fun <B, C> Ior<B?, C?>.bisequenceNullable(): Ior<B, C>?

bisequenceOption

fun <B, C> Ior<Option, Option<C>>.bisequenceOption(): Option<Ior<B, C>>

bisequenceValidated

fun <A, B, C> Ior<Validated<A, B>, Validated<A, C>>.bisequenceValidated(SA: Semigroup<A>): Validated<A, Ior<B, C>>

combine

fun <A, B> Ior<A, B>.combine(SA: Semigroup<A>, SB: Semigroup, other: Ior<A, B>): Ior<A, B>

compareTo

operator fun <A : Comparable<A>, B : Comparable> Ior<A, B>.compareTo(other: Ior<A, B>): Int

flatMap

inline fun <A, B, D> Ior<A, B>.flatMap(SG: Semigroup<A>, f: (B) -> Ior<A, D>): Ior<A, D>

Binds the given function across Ior.Right.

flatten

inline fun <A, B> Ior<A, Ior<A, B>>.flatten(SA: Semigroup<A>): Ior<A, B>

getOrElse

inline fun <A, B> Ior<A, B>.getOrElse(default: () -> B): B

leftWiden

fun <AA, A : AA, B> Ior<A, B>.leftWiden(): Ior<AA, B>

replicate

fun <A, B> Ior<A, B>.replicate(SA: Semigroup<A>, n: Int): Ior<A, List>

fun <A, B> Ior<A, B>.replicate(SA: Semigroup<A>, n: Int, MB: Monoid): Ior<A, B>

sequence

fun <A, B> Ior<A, Iterable>.sequence(): List<Ior<A, B>>

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

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

fun <A, B> Ior<A, B?>.sequence(): Ior<A, B>?

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

widen

fun <A, C, B : C> Ior<A, B>.widen(): Ior<A, C>

Given B is a sub type of C, re-type this value from Ior to Ior

zip

fun <A, B, C> Ior<A, B>.zip(SA: Semigroup<A>, fb: Ior<A, C>): Ior<A, Pair<B, C>>

inline fun <A, B, C, D> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, map: (B, C) -> D): Ior<A, D>

inline fun <A, B, C, D, E> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, map: (B, C, D) -> E): Ior<A, E>

inline fun <A, B, C, D, E, F> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, map: (B, C, D, E) -> F): Ior<A, F>

inline fun <A, B, C, D, E, F, G> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, f: Ior<A, F>, map: (B, C, D, E, F) -> G): Ior<A, G>

inline fun <A, B, C, D, E, F, G, H> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, f: Ior<A, F>, g: Ior<A, G>, map: (B, C, D, E, F, G) -> H): Ior<A, H>

inline fun <A, B, C, D, E, F, G, H, I> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, f: Ior<A, F>, g: Ior<A, G>, h: Ior<A, H>, map: (B, C, D, E, F, G, H) -> I): Ior<A, I>

inline fun <A, B, C, D, E, F, G, H, I, J> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, f: Ior<A, F>, g: Ior<A, G>, h: Ior<A, H>, i: Ior<A, I>, map: (B, C, D, E, F, G, H, I) -> J): Ior<A, J>

inline fun <A, B, C, D, E, F, G, H, I, J, K> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, f: Ior<A, F>, g: Ior<A, G>, h: Ior<A, H>, i: Ior<A, I>, j: Ior<A, J>, map: (B, C, D, E, F, G, H, I, J) -> K): Ior<A, K>

inline fun <A, B, C, D, E, F, G, H, I, J, K, L> Ior<A, B>.zip(SA: Semigroup<A>, c: Ior<A, C>, d: Ior<A, D>, e: Ior<A, E>, f: Ior<A, F>, g: Ior<A, G>, h: Ior<A, H>, i: Ior<A, I>, j: Ior<A, J>, k: Ior<A, K>, map: (B, C, D, E, F, G, H, I, J, K) -> L): Ior<A, L>