arrow-core-data / arrow.core / Ior
sealed class Ior<out A, out B> :
IorOf
<A, B>
Port of https://github.com/typelevel/cats/blob/v0.9.0/core/src/main/scala/cats/data/Ior.scala
Represents a right-biased disjunction that is either an A
, or a B
, or both an A
and a B
.
An instance of Ior<A
,B
> is one of:
Ior<A
,B
> is similar to Either<A
,B
>, except that it can represent the simultaneous presence of
an A
and a B
. It is right-biased so methods such as map
and flatMap
operate on the
B
value. Some methods, like flatMap
, handle the presence of two Ior.Both values using a
[Semigroup]<
A>, while other methods, like [toEither], ignore the
A` value in a Ior.Both Both.
Ior<A
,B
> is isomorphic to Either<Either<A
,B
>, Pair<A
,B
>>, but provides methods biased toward B
values, regardless of whether the B
values appear in a Ior.Right or a Ior.Both.
The isomorphic Either form can be accessed via the unwrap method.
Both | data class Both<out A, out B> : Ior <A, B> |
Left | data class Left<out A> : Ior <A, Nothing > |
Right | data class Right<out B> : Ior < Nothing , B> |
isBoth | Returns true if this is a Both, false otherwise.abstract val isBoth: Boolean |
isLeft | Returns true if this is a Left, false otherwise.abstract val isLeft: Boolean |
isRight | Returns true if this is a Right, false otherwise.abstract val isRight: Boolean |
all | fun all(predicate: (B) -> Boolean ): Boolean |
bicrosswalk | fun <C, D> bicrosswalk(fa: (A) -> Iterable <C>, fb: (B) -> Iterable <D>): List < Ior <C, D>> |
bicrosswalkMap | fun <C, D, K> bicrosswalkMap(fa: (A) -> Map <K, C>, fb: (B) -> Map <K, D>): Map <K, Ior <C, D>> |
bicrosswalkNull | fun <C, D> bicrosswalkNull(fa: (A) -> C?, fb: (B) -> D?): Ior <C, D>? |
bifoldLeft | fun <C> bifoldLeft(c: C, f: (C, A) -> C, g: (C, B) -> C): C |
bifoldMap | fun <C> bifoldMap(MN: Monoid <C>, f: (A) -> C, g: (B) -> C): C |
bifoldRight | fun <C> ~~bifoldRight~~(c: Eval <C>, f: (A, Eval <C>) -> Eval <C>, g: (B, Eval <C>) -> Eval <C>): Eval <C> |
bimap | Apply fa if this is a Left or Both to A and apply fb if this is Right or Both to B fun <C, D> bimap(fa: (A) -> C, fb: (B) -> D): Ior <C, D> |
bitraverse | fun <AA, C> bitraverse(fa: (A) -> Iterable <AA>, fb: (B) -> Iterable <C>): List < Ior <AA, C>> |
bitraverseEither | fun <AA, C, D> bitraverseEither(fa: (A) -> Either <AA, C>, fb: (B) -> Either <AA, D>): Either <AA, Ior <C, D>> |
bitraverseValidated | fun <AA, C, D> bitraverseValidated(SA: Semigroup <AA>, fa: (A) -> Validated <AA, C>, fb: (B) -> Validated <AA, D>): Validated <AA, Ior <C, D>> |
crosswalk | fun <C> crosswalk(fa: (B) -> Iterable <C>): List < Ior <A, C>> |
crosswalkMap | fun <K, V> crosswalkMap(fa: (B) -> Map <K, V>): Map <K, Ior <A, V>> |
crosswalkNull | fun <A, B, C> crosswalkNull(ior: Ior <A, B>, fa: (B) -> C?): Ior <A, C>? |
exists | Returns false if Left or returns the result of the application of the given predicate to the Right value.fun exists(predicate: (B) -> Boolean ): Boolean |
findOrNull | fun findOrNull(predicate: (B) -> Boolean ): B? |
fold | Applies fa if this is a Left, fb if this is a Right or fab if this is a Bothfun <C> fold(fa: (A) -> C, fb: (B) -> C, fab: (A, B) -> C): C |
foldLeft | fun <C> foldLeft(c: C, f: (C, B) -> C): C |
foldMap | fun <C> foldMap(MN: Monoid <C>, f: (B) -> C): C |
foldRight | fun <C> ~~foldRight~~(lc: Eval <C>, f: (B, Eval <C>) -> Eval <C>): Eval <C> |
isEmpty | fun isEmpty(): Boolean |
isNotEmpty | fun isNotEmpty(): Boolean |
leftOrNull | Returns the Left value or A if this is Left or Both and null if this is a Right.fun leftOrNull(): A? |
map | The given function is applied if this is a Right or Both to B .fun <D> map(f: (B) -> D): Ior <A, D> |
mapLeft | The given function is applied if this is a Left or Both to A .fun <C> mapLeft(fa: (A) -> C): Ior <C, B> |
orNull | Returns the Right value or B if this is Right or Both and null if this is a Left.fun orNull(): B? |
pad | Return this Ior as Pair of Optionfun ~~pad~~(): Pair < Option <A>, Option <B>> |
padNull | Return this Ior as Pair of nullables]fun padNull(): Pair <A?, B?> |
show | fun ~~show~~(SL: Show <A>, SR: Show <B>): String |
swap | If this is a Left, then return the left value in Right or vice versa, when this is Both , left and right values are swapfun swap(): Ior <B, A> |
toEither | Returns a Either.Right containing the Right value or B if this is Right or Both and Either.Left if this is a Left.fun toEither(): Either <A, B> |
toLeftOption | Returns a Some containing the Left value or A if this is Left or Both and None if this is a Right.fun ~~toLeftOption~~(): Option <A> |
toOption | Returns a Some containing the Right value or B if this is Right or Both and None if this is a Left.fun ~~toOption~~(): Option <B> |
toString | open fun toString(): String |
toValidated | Returns a Validated.Valid containing the Right value or B if this is Right or Both and Validated.Invalid if this is a Left.fun toValidated(): Validated <A, B> |
traverse | fun <G, C> ~~traverse~~(GA: Applicative <G>, f: (B) -> Kind<G, C>): Kind<G, Ior <A, C>> fun <C> traverse(fa: (B) -> Iterable <C>): List < Ior <A, C>> |
traverseEither | fun <AA, C> traverseEither(fa: (B) -> Either <AA, C>): Either <AA, Ior <A, C>> |
traverseValidated | fun <AA, C> traverseValidated(fa: (B) -> Validated <AA, C>): Validated <AA, Ior <A, C>> |
unwrap | Return the isomorphic Either of this Iorfun unwrap(): Either < Either <A, B>, Pair <A, B>> |
void | fun void(): Ior <A, Unit > |
bothNel | fun <A, B> bothNel(a: A, b: B): IorNel <A, B> |
fromNullables | Create an Ior from two nullables if at least one of them is defined.fun <A, B> fromNullables(a: A?, b: B?): Ior <A, B>? |
fromOptions | Create an Ior from two Options if at least one of them is defined.fun <A, B> ~~fromOptions~~(oa: Option <A>, ob: Option <B>): Option < Ior <A, B>> |
leftNel | fun <A, B> leftNel(a: A): IorNel <A, B> |
lift | Lifts a function (B) -> C to the Ior structure returning a polymorphic function that can be applied over all Ior values in the shape of Ior<A, B>fun <A, B, C> lift(f: (B) -> C): ( Ior <A, B>) -> Ior <A, C> fun <A, B, C, D> lift(fa: (A) -> C, fb: (B) -> D): ( Ior <A, B>) -> Ior <C, D> |
tailRecM | fun <L, A, B> ~~tailRecM~~(a: A, f: (A) -> IorOf <L, Either <A, B>>, SL: Semigroup <L>): Ior <L, B> |
altFold | fun <T, F, A> Kind<T, A>.altFold(AF: Alternative <F>, FT: Foldable <T>): Kind<F, A> |
altSum | fun <T, F, A> Kind<T, Kind<F, A>>.altSum(AF: Alternative <F>, FT: Foldable <T>): Kind<F, A> |
ap | fun <A, B, D> Ior <A, B>.~~ap~~(SG: Semigroup <A>, ff: IorOf <A, (B) -> D>): Ior <A, D> |
bisequence | fun <A, B> Ior < Iterable <A>, Iterable <B>>.bisequence(): List < Ior <A, B>> |
bisequenceEither | fun <A, B, C> Ior < Either <A, B>, Either <A, C>>.bisequenceEither(): Either <A, 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 <B>, other: Ior <A, B>): Ior <A, B> |
compareTo | operator fun <A : Comparable <A>, B : Comparable <B>> Ior <A, B>.compareTo(other: Ior <A, B>): Int |
conest | fun <F, A, B> CounnestedType <F, A, B>.conest(): ConestedType <F, A, B> |
fix | fun <A, B> IorOf <A, B>.~~fix~~(): Ior <A, B> |
flatMap | Binds the given function across Ior.Right.fun <A, B, D> Ior <A, B>.flatMap(SG: Semigroup <A>, f: (B) -> Ior <A, D>): Ior <A, D> |
flatten | fun <A, B> Ior <A, Ior <A, B>>.flatten(SA: Semigroup <A>): Ior <A, B> |
getOrElse | 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 <B>> fun <A, B> Ior <A, B>.replicate(SA: Semigroup <A>, n: Int , MB: Monoid <B>): Ior <A, B> |
sequence | fun <A, B> Ior <A, Iterable <B>>.sequence(): List < Ior <A, B>> fun <A, B, G> IorOf <A, Kind<G, B>>.~~sequence~~(GA: Applicative <G>): Kind<G, Ior <A, B>> |
sequenceEither | fun <A, B, C> Ior <A, Either <B, C>>.sequenceEither(): Either <B, Ior <A, C>> |
sequenceValidated | fun <A, B, C> Ior <A, Validated <B, C>>.sequenceValidated(): Validated <B, Ior <A, C>> |
widen | Given B is a sub type of C, re-type this value from Ior<A, B> to Ior<A, B>fun <A, C, B : C> Ior <A, B>.widen(): Ior <A, C> |
zip | fun <A, B, C> Ior <A, B>.zip(SA: Semigroup <A>, fb: Ior <A, C>): Ior <A, Pair <B, C>> fun <A, B, C, D> Ior <A, B>.zip(SA: Semigroup <A>, c: Ior <A, C>, map: (B, C) -> D): Ior <A, D> 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> 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> 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> 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> 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> 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> 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> 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> |
Do you like Arrow?
✖