arrow-core-data / arrow.core

Package arrow.core

Types

AndThen sealed class AndThen<A, B> : (A) -> B, AndThenOf<A, B>
AndThen wraps a function of shape (A) -> B and can be used to do function composition. It’s similar to arrow.core.andThen and arrow.core.compose and can be used to build stack safe data structures that make use of lambdas. Usage is typically used for signature such as A -> Kind<F, A> where F has a arrow.typeclasses.Monad instance i.e. StateT.flatMap.
Either sealed class Either<out A, out B> : EitherOf<A, B>
Port of https://github.com/scala/scala/blob/v2.12.1/src/library/scala/util/Either.scala
Eval sealed class Eval<out A> : EvalOf<A>
Eval is a monad which controls evaluation of a value or a computation that produces a value.
ForAndThen class ForAndThen
ForEither class ForEither
ForEval class ForEval
ForFunction0 class ForFunction0
ForFunction1 class ForFunction1
ForId class ForId
ForIor class ForIor
ForListK class ForListK
ForMapK class ForMapK
ForNonEmptyList class ForNonEmptyList
ForOption class ForOption
ForSequenceK class ForSequenceK
ForSetK class ForSetK
ForSortedMapK class ForSortedMapK
ForTry class ForTry
ForTuple10 class ForTuple10
ForTuple11 class ForTuple11
ForTuple12 class ForTuple12
ForTuple13 class ForTuple13
ForTuple14 class ForTuple14
ForTuple15 class ForTuple15
ForTuple16 class ForTuple16
ForTuple17 class ForTuple17
ForTuple18 class ForTuple18
ForTuple19 class ForTuple19
ForTuple2 class ForTuple2
ForTuple20 class ForTuple20
ForTuple21 class ForTuple21
ForTuple22 class ForTuple22
ForTuple3 class ForTuple3
ForTuple4 class ForTuple4
ForTuple5 class ForTuple5
ForTuple6 class ForTuple6
ForTuple7 class ForTuple7
ForTuple8 class ForTuple8
ForTuple9 class ForTuple9
ForValidated class ForValidated
Function0 data class Function0<out A> : Function0Of<A>
Function1 class Function1<I, out O> : Function1Of<I, O>
FunctionK interface FunctionK<F, G>
Id data class Id<out A> : IdOf<A>
The identity monad can be seen as the ambient monad that encodes the effect of having no effect. It is ambient in the sense that plain pure values are values of Id.
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
ListExtensions object ListExtensions
ListK data class ListK<out A> : ListKOf<A>, List<A>
A wrapper data type also considered by the @extension mechanisms to forward type class instance methods into both the wrapper and the wrapped data type. Ex. List#foldMap(M: Monoid)
MapInstances object MapInstances
MapK data class MapK<K, out A> : MapKOf<K, A>, Map<K, A>
None object None : Option<Nothing>
NonEmptyList class NonEmptyList<out A> : NonEmptyListOf<A>
A List that can not be empty
Option sealed class Option<out A> : OptionOf<A>
Represents optional values. Instances of Option are either an instance of $some or the object $none.
SequenceK data class SequenceK<out A> : SequenceKOf<A>, Sequence<A>
SetExtensions object SetExtensions
SetK data class SetK<out A> : SetKOf<A>, Set<A>
Some data class Some<out T> : Option<T>
SortedMapInstances object SortedMapInstances
SortedMapK data class SortedMapK<A : Comparable<A>, B> : SortedMapKOf<A, B>, SortedMapKKindedJ<A, B>, SortedMap<A, B>
SortedSetInstances object SortedSetInstances
Try sealed class ~~Try~~<out A> : TryOf<A>
Tuple10 data class Tuple10<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J> : Tuple10Of<A, B, C, D, E, F, G, H, I, J>
Tuple11 data class Tuple11<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K> : Tuple11Of<A, B, C, D, E, F, G, H, I, J, K>
Tuple12 data class Tuple12<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L> : Tuple12Of<A, B, C, D, E, F, G, H, I, J, K, L>
Tuple13 data class Tuple13<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M> : Tuple13Of<A, B, C, D, E, F, G, H, I, J, K, L, M>
Tuple14 data class Tuple14<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N> : Tuple14Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Tuple15 data class Tuple15<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O> : Tuple15Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Tuple16 data class Tuple16<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P> : Tuple16Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
Tuple17 data class Tuple17<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P, out Q> : Tuple17Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>
Tuple18 data class Tuple18<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P, out Q, out R> : Tuple18Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>
Tuple19 data class Tuple19<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P, out Q, out R, out S> : Tuple19Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>
Tuple2 data class Tuple2<out A, out B> : Tuple2Of<A, B>
Tuple20 data class Tuple20<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P, out Q, out R, out S, out T> : Tuple20Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>
Tuple21 data class Tuple21<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P, out Q, out R, out S, out T, out U> : Tuple21Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>
Tuple22 data class Tuple22<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J, out K, out L, out M, out N, out O, out P, out Q, out R, out S, out T, out U, out V> : Tuple22Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>
Tuple3 data class Tuple3<out A, out B, out C> : Tuple3Of<A, B, C>
Tuple4 data class Tuple4<out A, out B, out C, out D> : Tuple4Of<A, B, C, D>
Tuple5 data class Tuple5<out A, out B, out C, out D, out E> : Tuple5Of<A, B, C, D, E>
Tuple6 data class Tuple6<out A, out B, out C, out D, out E, out F> : Tuple6Of<A, B, C, D, E, F>
Tuple7 data class Tuple7<out A, out B, out C, out D, out E, out F, out G> : Tuple7Of<A, B, C, D, E, F, G>
Tuple8 data class Tuple8<out A, out B, out C, out D, out E, out F, out G, out H> : Tuple8Of<A, B, C, D, E, F, G, H>
Tuple9 data class Tuple9<out A, out B, out C, out D, out E, out F, out G, out H, out I> : Tuple9Of<A, B, C, D, E, F, G, H, I>
Validated sealed class Validated<out E, out A> : ValidatedOf<E, A>
Port of https://github.com/typelevel/cats/blob/master/core/src/main/scala/cats/data/Validated.scala

Exceptions

TryException sealed class TryException : Exception

Type Aliases

AndThenKindedJ typealias AndThenKindedJ<A, B> = HkJ2<ForAndThen, A, B>
AndThenOf typealias AndThenOf<A, B> = Kind2<ForAndThen, A, B>
AndThenPartialOf typealias AndThenPartialOf<A> = Kind<ForAndThen, A>
EitherOf typealias EitherOf<A, B> = Kind2<ForEither, A, B>
EitherPartialOf typealias EitherPartialOf<A> = Kind<ForEither, A>
EvalOf typealias EvalOf<A> = Kind<ForEval, A>
Failure typealias Failure = Try.Failure
Function0Of typealias Function0Of<A> = Kind<ForFunction0, A>
Function1Of typealias Function1Of<I, O> = Kind2<ForFunction1, I, O>
Function1PartialOf typealias Function1PartialOf<I> = Kind<ForFunction1, I>
IdOf typealias IdOf<A> = Kind<ForId, A>
Invalid typealias Invalid<E> = Validated.Invalid<E>
IorNel typealias IorNel<A, B> = Ior<Nel<A>, B>
IorOf typealias IorOf<A, B> = Kind2<ForIor, A, B>
IorPartialOf typealias IorPartialOf<A> = Kind<ForIor, A>
ListKOf typealias ListKOf<A> = Kind<ForListK, A>
MapKOf typealias MapKOf<K, A> = Kind2<ForMapK, K, A>
MapKPartialOf typealias MapKPartialOf<K> = Kind<ForMapK, K>
Nel typealias Nel<A> = NonEmptyList<A>
NonEmptyListOf typealias NonEmptyListOf<A> = Kind<ForNonEmptyList, A>
OptionOf typealias OptionOf<A> = Kind<ForOption, A>
Predicate typealias Predicate<T> = (T) -> Boolean
SequenceKOf typealias SequenceKOf<A> = Kind<ForSequenceK, A>
SetKOf typealias SetKOf<A> = Kind<ForSetK, A>
SortedMap typealias SortedMap<K, V> = SortedMap<K, V>
SortedMapKKindedJ typealias SortedMapKKindedJ<A, B> = HkJ2<ForSortedMapK, A, B>
SortedMapKOf typealias SortedMapKOf<A, B> = Kind2<ForSortedMapK, A, B>
SortedMapKPartialOf typealias SortedMapKPartialOf<A> = Kind<ForSortedMapK, A>
Success typealias Success<A> = Try.Success<A>
TryOf typealias TryOf<A> = Kind<ForTry, A>
Tuple10Of typealias Tuple10Of<A, B, C, D, E, F, G, H, I, J> = Kind10<ForTuple10, A, B, C, D, E, F, G, H, I, J>
Tuple10PartialOf typealias Tuple10PartialOf<A, B, C, D, E, F, G, H, I> = Kind9<ForTuple10, A, B, C, D, E, F, G, H, I>
Tuple11Of typealias Tuple11Of<A, B, C, D, E, F, G, H, I, J, K> = Kind11<ForTuple11, A, B, C, D, E, F, G, H, I, J, K>
Tuple11PartialOf typealias Tuple11PartialOf<A, B, C, D, E, F, G, H, I, J> = Kind10<ForTuple11, A, B, C, D, E, F, G, H, I, J>
Tuple12Of typealias Tuple12Of<A, B, C, D, E, F, G, H, I, J, K, L> = Kind12<ForTuple12, A, B, C, D, E, F, G, H, I, J, K, L>
Tuple12PartialOf typealias Tuple12PartialOf<A, B, C, D, E, F, G, H, I, J, K> = Kind11<ForTuple12, A, B, C, D, E, F, G, H, I, J, K>
Tuple13Of typealias Tuple13Of<A, B, C, D, E, F, G, H, I, J, K, L, M> = Kind13<ForTuple13, A, B, C, D, E, F, G, H, I, J, K, L, M>
Tuple13PartialOf typealias Tuple13PartialOf<A, B, C, D, E, F, G, H, I, J, K, L> = Kind12<ForTuple13, A, B, C, D, E, F, G, H, I, J, K, L>
Tuple14Of typealias Tuple14Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N> = Kind14<ForTuple14, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Tuple14PartialOf typealias Tuple14PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M> = Kind13<ForTuple14, A, B, C, D, E, F, G, H, I, J, K, L, M>
Tuple15Of typealias Tuple15Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> = Kind15<ForTuple15, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Tuple15PartialOf typealias Tuple15PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N> = Kind14<ForTuple15, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Tuple16Of typealias Tuple16Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> = Kind16<ForTuple16, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
Tuple16PartialOf typealias Tuple16PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> = Kind15<ForTuple16, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Tuple17Of typealias Tuple17Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> = Kind17<ForTuple17, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>
Tuple17PartialOf typealias Tuple17PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> = Kind16<ForTuple17, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
Tuple18Of typealias Tuple18Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> = Kind18<ForTuple18, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>
Tuple18PartialOf typealias Tuple18PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> = Kind17<ForTuple18, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>
Tuple19Of typealias Tuple19Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> = Kind19<ForTuple19, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>
Tuple19PartialOf typealias Tuple19PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> = Kind18<ForTuple19, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>
Tuple20Of typealias Tuple20Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> = Kind20<ForTuple20, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>
Tuple20PartialOf typealias Tuple20PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> = Kind19<ForTuple20, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>
Tuple21Of typealias Tuple21Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> = Kind21<ForTuple21, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>
Tuple21PartialOf typealias Tuple21PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> = Kind20<ForTuple21, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>
Tuple22Of typealias Tuple22Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> = Kind22<ForTuple22, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>
Tuple22PartialOf typealias Tuple22PartialOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> = Kind21<ForTuple22, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>
Tuple2Of typealias Tuple2Of<A, B> = Kind2<ForTuple2, A, B>
Tuple2PartialOf typealias Tuple2PartialOf<A> = Kind<ForTuple2, A>
Tuple3Of typealias Tuple3Of<A, B, C> = Kind3<ForTuple3, A, B, C>
Tuple3PartialOf typealias Tuple3PartialOf<A, B> = Kind2<ForTuple3, A, B>
Tuple4Of typealias Tuple4Of<A, B, C, D> = Kind4<ForTuple4, A, B, C, D>
Tuple4PartialOf typealias Tuple4PartialOf<A, B, C> = Kind3<ForTuple4, A, B, C>
Tuple5Of typealias Tuple5Of<A, B, C, D, E> = Kind5<ForTuple5, A, B, C, D, E>
Tuple5PartialOf typealias Tuple5PartialOf<A, B, C, D> = Kind4<ForTuple5, A, B, C, D>
Tuple6Of typealias Tuple6Of<A, B, C, D, E, F> = Kind6<ForTuple6, A, B, C, D, E, F>
Tuple6PartialOf typealias Tuple6PartialOf<A, B, C, D, E> = Kind5<ForTuple6, A, B, C, D, E>
Tuple7Of typealias Tuple7Of<A, B, C, D, E, F, G> = Kind7<ForTuple7, A, B, C, D, E, F, G>
Tuple7PartialOf typealias Tuple7PartialOf<A, B, C, D, E, F> = Kind6<ForTuple7, A, B, C, D, E, F>
Tuple8Of typealias Tuple8Of<A, B, C, D, E, F, G, H> = Kind8<ForTuple8, A, B, C, D, E, F, G, H>
Tuple8PartialOf typealias Tuple8PartialOf<A, B, C, D, E, F, G> = Kind7<ForTuple8, A, B, C, D, E, F, G>
Tuple9Of typealias Tuple9Of<A, B, C, D, E, F, G, H, I> = Kind9<ForTuple9, A, B, C, D, E, F, G, H, I>
Tuple9PartialOf typealias Tuple9PartialOf<A, B, C, D, E, F, G, H> = Kind8<ForTuple9, A, B, C, D, E, F, G, H>
Valid typealias Valid<A> = Validated.Valid<A>
ValidatedNel typealias ValidatedNel<E, A> = Validated<Nel<E>, A>
ValidatedOf typealias ValidatedOf<E, A> = Kind2<ForValidated, E, A>
ValidatedPartialOf typealias ValidatedPartialOf<E> = Kind<ForValidated, E>

Extensions for External Classes

java.util.SortedMap  
kotlin.Any  
kotlin.Array  
kotlin.Boolean  
kotlin.collections.Iterable  
kotlin.collections.Iterator  
kotlin.collections.List  
kotlin.collections.Map  
kotlin.collections.Map.Entry  
kotlin.collections.Set  
kotlin.Function0  
kotlin.Function1  
kotlin.Function2  
kotlin.Pair  
kotlin.sequences.Sequence  
kotlin.Throwable  
kotlin.Triple  

Properties

DeprecatedAmbiguity const val DeprecatedAmbiguity: String
DeprecatedUnsafeAccess const val DeprecatedUnsafeAccess: String

Functions

ap fun <A, B, C> EitherOf<A, B>.ap(ff: EitherOf<A, (B) -> C>): Either<A, C>
fun <A, B, D> Ior<A, B>.ap(SG: Semigroup<A>, ff: IorOf<A, (B) -> D>): Ior<A, D>fun <E, A, B> ValidatedOf<E, A>.ap(SE: Semigroup<E>, f: Validated<E, (A) -> B>): Validated<E, B>
From Apply: if both the function and this value are Valid, apply the function
bothIor fun <A, B> Tuple2<A, B>.bothIor(): Ior<A, B>
combine fun <E, A> ValidatedOf<E, A>.combine(SE: Semigroup<E>, SA: Semigroup<A>, y: ValidatedOf<E, A>): Validated<E, A>
combineK fun <A, B> EitherOf<A, B>.combineK(y: EitherOf<A, B>): Either<A, B>
fun <A> ListKOf<A>.combineK(y: ListKOf<A>): ListK<A>
fun <A> NonEmptyListOf<A>.combineK(y: NonEmptyListOf<A>): NonEmptyList<A>
fun <A> SequenceKOf<A>.combineK(y: SequenceKOf<A>): SequenceK<A>
fun <A> SetKOf<A>.combineK(y: SetKOf<A>): SetK<A>
fun <E, A> ValidatedOf<E, A>.combineK(SE: Semigroup<E>, y: ValidatedOf<E, A>): Validated<E, A>
constant fun <P1, T> constant(t: T): (P1) -> T
contains fun <A, B> EitherOf<A, B>.contains(elem: B): Boolean
Returns true if this is a Either.Right and its value is equal to elem (as determined by ==), returns false otherwise.
filterOrElse fun <A, B> EitherOf<A, B>.filterOrElse(predicate: (B) -> Boolean, default: () -> A): Either<A, B>
Returns Either.Right with the existing value of Either.Right if this is a Either.Right and the given predicate holds for the right value.
filterOrOther fun <A, B> EitherOf<A, B>.filterOrOther(predicate: (B) -> Boolean, default: (B) -> A): Either<A, B>
Returns Either.Right with the existing value of Either.Right if this is a Either.Right and the given predicate holds for the right value.
findValid fun <E, A> ValidatedOf<E, A>.findValid(SE: Semigroup<E>, that: () -> Validated<E, A>): Validated<E, A>
If this is valid return this, otherwise if that is valid return that, otherwise combine the failures. This is similar to orElse except that here failures are accumulated.
fix fun <A, B> AndThenOf<A, B>.fix(): AndThen<A, B>
fun <A, B> EitherOf<A, B>.fix(): Either<A, B>
fun <A> EvalOf<A>.fix(): Eval<A>
fun <A> Function0Of<A>.fix(): () -> A
fun <I, O> Function1Of<I, O>.fix(): (I) -> O
fun <A> IdOf<A>.fix(): Id<A>
fun <A, B> IorOf<A, B>.fix(): Ior<A, B>
fun <A> ListKOf<A>.fix(): ListK<A>
fun <K, A> MapKOf<K, A>.fix(): MapK<K, A>
fun <A> NonEmptyListOf<A>.fix(): NonEmptyList<A>
fun <A> OptionOf<A>.fix(): Option<A>
fun <A> SequenceKOf<A>.fix(): SequenceK<A>
fun <A> SetKOf<A>.fix(): SetK<A>
fun <A : Comparable<A>, B> SortedMapKOf<A, B>.fix(): SortedMapK<A, B>
fun <A> TryOf<A>.fix(): Try<A>
fun <A, B, C, D, E, F, G, H, I, J> Tuple10Of<A, B, C, D, E, F, G, H, I, J>.fix(): Tuple10<A, B, C, D, E, F, G, H, I, J>
fun <A, B, C, D, E, F, G, H, I, J, K> Tuple11Of<A, B, C, D, E, F, G, H, I, J, K>.fix(): Tuple11<A, B, C, D, E, F, G, H, I, J, K>
fun <A, B, C, D, E, F, G, H, I, J, K, L> Tuple12Of<A, B, C, D, E, F, G, H, I, J, K, L>.fix(): Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Tuple13Of<A, B, C, D, E, F, G, H, I, J, K, L, M>.fix(): Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Tuple14Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N>.fix(): Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Tuple15Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>.fix(): Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Tuple16Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>.fix(): Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Tuple17Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>.fix(): Tuple17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Tuple18Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>.fix(): Tuple18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Tuple19Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>.fix(): Tuple19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>
fun <A, B> Tuple2Of<A, B>.fix(): Tuple2<A, B>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Tuple20Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>.fix(): Tuple20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Tuple21Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>.fix(): Tuple21<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>
fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Tuple22Of<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>.fix(): Tuple22<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>
fun <A, B, C> Tuple3Of<A, B, C>.fix(): Tuple3<A, B, C>
fun <A, B, C, D> Tuple4Of<A, B, C, D>.fix(): Tuple4<A, B, C, D>
fun <A, B, C, D, E> Tuple5Of<A, B, C, D, E>.fix(): Tuple5<A, B, C, D, E>
fun <A, B, C, D, E, F> Tuple6Of<A, B, C, D, E, F>.fix(): Tuple6<A, B, C, D, E, F>
fun <A, B, C, D, E, F, G> Tuple7Of<A, B, C, D, E, F, G>.fix(): Tuple7<A, B, C, D, E, F, G>
fun <A, B, C, D, E, F, G, H> Tuple8Of<A, B, C, D, E, F, G, H>.fix(): Tuple8<A, B, C, D, E, F, G, H>
fun <A, B, C, D, E, F, G, H, I> Tuple9Of<A, B, C, D, E, F, G, H, I>.fix(): Tuple9<A, B, C, D, E, F, G, H, I>
fun <E, A> ValidatedOf<E, A>.fix(): Validated<E, A>
flatMap fun <A, B, C> EitherOf<A, B>.flatMap(f: (B) -> Either<A, C>): Either<A, C>
Binds the given function across Either.Right.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 fun <T> TryOf<TryOf<T>>.flatten(): Try<T>
getOrDefault fun <B> TryOf<B>.~~getOrDefault~~(default: () -> B): B
getOrElse fun <B> EitherOf<*, B>.getOrElse(default: () -> B): B
Returns the value from this Either.Right or the given argument if this is a Either.Left.fun <A, B> Ior<A, B>.getOrElse(default: () -> B): B
fun <B> TryOf<B>.~~getOrElse~~(default: (Throwable) -> B): Bfun <T> Option<T>.getOrElse(default: () -> T): T
Returns the option’s value if the option is nonempty, otherwise return the result of evaluating default.fun <E, B> ValidatedOf<E, B>.getOrElse(default: () -> B): B
Return the Valid value, or the default if Invalid
getOrHandle fun <A, B> EitherOf<A, B>.getOrHandle(default: (A) -> B): B
Returns the value from this Either.Right or allows clients to transform Either.Left to Either.Right while providing access to the value of Either.Left.
handleError fun <B> TryOf<B>.~~handleError~~(f: (Throwable) -> B): Try<B>
handleErrorWith fun <A, B> EitherOf<A, B>.handleErrorWith(f: (A) -> EitherOf<A, B>): Either<A, B>
Applies the given function f if this is a Left, otherwise returns this if this is a Right. This is like flatMap for the exception.fun <B> TryOf<B>.~~handleErrorWith~~(f: (Throwable) -> TryOf<B>): Try<B>
handleLeftWith fun <E, A> ValidatedOf<E, A>.handleLeftWith(f: (E) -> ValidatedOf<E, A>): Validated<E, A>
identity fun <A> identity(a: A): A
invalid fun <E> E.invalid(): Validated<E, Nothing>
invalidNel fun <E> E.invalidNel(): ValidatedNel<E, Nothing>
invoke operator fun <A, B> AndThenOf<A, B>.invoke(a: A): B
operator fun <A> Function0Of<A>.invoke(): A
operator fun <I, O> Function1Of<I, O>.invoke(i: I): O
k fun <K, A> Option<Tuple2<K, A>>.k(): MapK<K, A>
fun <A : Comparable<A>, B> Option<Tuple2<A, B>>.k(): SortedMapK<A, B>
Left fun <L> Left(left: L): Either<L, Nothing>
left fun <A> A.left(): Either<A, Nothing>
leftIfNull fun <A, B> EitherOf<A, B?>.leftIfNull(default: () -> A): Either<A, B>
Returns Either.Right with the existing value of Either.Right if this is an Either.Right with a non-null value. The returned Either.Right type is not nullable.
leftIor fun <A> A.leftIor(): Ior<A, Nothing>
mapOf fun <K, V> mapOf(vararg tuple: Tuple2<K, V>): MapK<K, V>
fun <K, V> mapOf(pair: Tuple2<K, V>): Map<K, V>
nel fun <A> A.nel(): NonEmptyList<A>
none fun <A> none(): Option<A>
NonFatal fun NonFatal(t: Throwable): Boolean
Extractor of non-fatal Throwables. Will not match fatal errors like VirtualMachineError (for example, OutOfMemoryError and StackOverflowError, subclasses of VirtualMachineError), ThreadDeath, LinkageError, InterruptedException.
or infix fun <T> OptionOf<T>.or(value: Option<T>): Option<T>
orElse fun <A> OptionOf<A>.orElse(alternative: () -> Option<A>): Option<A>
Returns this option’s if the option is nonempty, otherwise returns another option provided lazily by default.fun <B, A : B> TryOf<A>.~~orElse~~(f: () -> TryOf<B>): Try<B>fun <E, A> ValidatedOf<E, A>.orElse(default: () -> Validated<E, A>): Validated<E, A>
Return this if it is Valid, or else fall back to the given default. The functionality is similar to that of findValid except for failure accumulation, where here only the error on the right is preserved and the error on the left is ignored.
orNull fun <B> EitherOf<*, B>.orNull(): B?
Returns the value from this Either.Right or null if this is a Either.Left.fun <B> TryOf<B>.~~orNull~~(): B?fun <E, B> ValidatedOf<E, B>.orNull(): B?
Return the Valid value, or null if Invalid
Right fun <R> Right(right: R): Either<Nothing, R>
right fun <A> A.right(): Either<Nothing, A>
rightIfNotNull fun <A, B> B?.rightIfNotNull(default: () -> A): Either<A, B>
Returns Either.Right if the value of type B is not null, otherwise the specified A value wrapped into an Either.Left.
rightIor fun <A> A.rightIor(): Ior<Nothing, A>
select fun <A, B> (() -> Either<A, B>).select(f: Function0Of<(A) -> B>): () -> B
fun <A, B> Id<Either<A, B>>.select(f: IdOf<(A) -> B>): Id<B>
fun <A, B> Option<Either<A, B>>.select(f: OptionOf<(A) -> B>): Option<B>
sequence fun <A, B, G> IorOf<A, Kind<G, B>>.sequence(GA: Applicative<G>): Kind<G, Ior<A, B>>
fun <K, V, G> MapKOf<K, Kind<G, V>>.sequence(GA: Applicative<G>): Kind<G, MapK<K, V>>
fun <A, G> NonEmptyListOf<Kind<G, A>>.sequence(GA: Applicative<G>): Kind<G, NonEmptyList<A>>
fun <A, G> SequenceKOf<Kind<G, A>>.sequence(GA: Applicative<G>): Kind<G, SequenceK<A>>
fun <K : Comparable<K>, V, G> SortedMapKOf<K, Kind<G, V>>.sequence(GA: Applicative<G>): Kind<G, SortedMapK<K, V>>
fun <G, E, A> ValidatedOf<E, Kind<G, A>>.sequence(GA: Applicative<G>): Kind<G, Validated<E, A>>
some fun <A> A.some(): Option<A>
success fun <A> A.~~success~~(): Try<A>
toIor fun <E, A> ValidatedOf<E, A>.toIor(): Ior<E, A>
Converts the value to an Ior<E, A>
toOption fun <T> T?.toOption(): Option<T>
toPair fun <A, B> Tuple2<A, B>.toPair(): Pair<A, B>
toT infix fun <A, B> A.toT(b: B): Tuple2<A, B>
toTriple fun <A, B, C> Tuple3<A, B, C>.toTriple(): Triple<A, B, C>
traverse fun <G, E, A, B> ValidatedOf<E, A>.traverse(GA: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, Validated<E, B>>
updated fun <K, A> MapK<K, A>.updated(k: K, value: A): MapK<K, A>
fun <A : Comparable<A>, B> SortedMapK<A, B>.updated(k: A, value: B): SortedMapK<A, B>
valid fun <A> A.valid(): Validated<Nothing, A>
validNel fun <A> A.validNel(): ValidatedNel<Nothing, A>
value fun <A> EvalOf<A>.value(): A
fun <A> IdOf<A>.value(): A
valueOr fun <E, B> ValidatedOf<E, B>.valueOr(f: (E) -> B): B
Return the Valid value, or the result of f if Invalid