Package arrow.core
Types
| AndThen | 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.sealed class ~~AndThen~~<A, B> : (A) -> B, AndThenOf<A, B> |
| 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> |
| Const | data class Const<A, out T> : ConstOf<A, T> |
| ConstOf | typealias ~~ConstOf~~<A, T> = Kind2<ForConst, A, T> |
| ConstPartialOf | typealias ~~ConstPartialOf~~<A> = Kind<ForConst, A> |
| EagerBind | interface EagerBind<F> : BindSyntax<F> |
| Either | In day-to-day programming, it is fairly common to find ourselves writing functions that can fail. For instance, querying a service may result in a connection issue, or some unexpected JSON response.sealed class Either<out A, out B> : EitherOf<A, B> |
| EitherOf | typealias ~~EitherOf~~<A, B> = Kind2<ForEither, A, B> |
| EitherPartialOf | typealias ~~EitherPartialOf~~<A> = Kind<ForEither, A> |
| Endo | The monoid of endomorphisms under composition.data class Endo<A> |
| EQ | object EQ : Ordering |
| Eval | Eval is a monad which controls evaluation of a value or a computation that produces a value.sealed class Eval<out A> : EvalOf<A> |
| EvalOf | typealias ~~EvalOf~~<A> = Kind<ForEval, A> |
| ForAndThen | class ~~ForAndThen~~ |
| ForConst | class ~~ForConst~~ |
| ForEither | class ~~ForEither~~ |
| ForEval | class ~~ForEval~~ |
| ForHashed | class ~~ForHashed~~ |
| ForIor | class ~~ForIor~~ |
| ForListK | class ~~ForListK~~ |
| ForMapK | class ~~ForMapK~~ |
| ForNonEmptyList | class ~~ForNonEmptyList~~ |
| ForOption | class ~~ForOption~~ |
| ForSequenceK | class ~~ForSequenceK~~ |
| ForSetK | class ~~ForSetK~~ |
| ForSortedMapK | class ~~ForSortedMapK~~ |
| 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~~ |
| FunctionK | interface ~~FunctionK~~<F, G> |
| GT | object GT : Ordering |
| Hashed | Wrapper type that caches a values precomputed hash with the valuedata class ~~Hashed~~<A> : HashedOf<A> |
| HashedKindedJ | typealias ~~HashedKindedJ~~<A> = Hk<ForHashed, A> |
| HashedOf | typealias ~~HashedOf~~<A> = Kind<ForHashed, A> |
| Invalid | typealias Invalid<E> = Invalid<E> |
| Ior | Port of https://github.com/typelevel/cats/blob/v0.9.0/core/src/main/scala/cats/data/Ior.scalasealed class Ior<out A, out B> : IorOf<A, B> |
| 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> |
| ListExtensions | object ~~ListExtensions~~ |
| ListK | ListK wraps over the platform List type to make it a type constructor(/docs/0.12/patterns/glossary/#type-constructors).data class ~~ListK~~<out A> : ListKOf<A>, List<A> |
| ListKOf | typealias ~~ListKOf~~<A> = Kind<ForListK, A> |
| LT | object LT : Ordering |
| MapInstances | object ~~MapInstances~~ |
| MapK | data class ~~MapK~~<K, out A> : MapKOf<K, A>, Map<K, A> |
| MapKOf | typealias ~~MapKOf~~<K, A> = Kind2<ForMapK, K, A> |
| MapKPartialOf | typealias ~~MapKPartialOf~~<K> = Kind<ForMapK, K> |
| Nel | typealias Nel<A> = NonEmptyList<A> |
| None | object None : Option<Nothing> |
| NonEmptyList | NonEmptyList is a data type used in Λrrow to model ordered lists that guarantee to have at least one value. NonEmptyList is available in the arrow-core-data module under the import arrow.core.NonEmptyListclass NonEmptyList<out A> : NonEmptyListOf<A>, AbstractList<A> |
| NonEmptyListOf | typealias ~~NonEmptyListOf~~<A> = Kind<ForNonEmptyList, A> |
| Nullable | object Nullable |
| Option | If you have worked with Java at all in the past, it is very likely that you have come across a NullPointerException at some time (other languages will throw similarly named errors in such a case). Usually this happens because some method returns null when you weren’t expecting it and, thus, isn’t dealing with that possibility in your client code. A value of null is often abused to represent an absent optional value. Kotlin tries to solve the problem by getting rid of null values altogether, and providing its own special syntax Null-safety machinery based on ?.sealed class Option<out A> : OptionOf<A> |
| OptionOf | typealias ~~OptionOf~~<A> = Kind<ForOption, A> |
| Ordering | sealed class ~~Ordering~~ |
| Predicate | typealias Predicate<T> = (T) -> Boolean |
| SequenceK | data class ~~SequenceK~~<out A> : SequenceKOf<A>, Sequence<A> |
| SequenceKOf | typealias ~~SequenceKOf~~<A> = Kind<ForSequenceK, A> |
| SetExtensions | object ~~SetExtensions~~ |
| SetK | data class ~~SetK~~<out A> : SetKOf<A>, Set<A> |
| SetKOf | typealias ~~SetKOf~~<A> = Kind<ForSetK, A> |
| Some | data class Some<out T> : Option<T> |
| SortedMap | typealias ~~SortedMap~~<K, V> = SortedMap<K, V> |
| SortedMapInstances | object ~~SortedMapInstances~~ |
| SortedMapK | data class ~~SortedMapK~~<A : Comparable<A>, B> : SortedMapKOf<A, B>, SortedMapKKindedJ<A, B>, SortedMap<A, B> |
| 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> |
| SortedSetInstances | object ~~SortedSetInstances~~ |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| Tuple3 | data class ~~Tuple3~~<out A, out B, out C> : Tuple3Of<A, B, C> |
| Tuple3Of | typealias ~~Tuple3Of~~<A, B, C> = Kind3<ForTuple3, A, B, C> |
| Tuple3PartialOf | typealias ~~Tuple3PartialOf~~<A, B> = Kind2<ForTuple3, A, B> |
| Tuple4 | data class Tuple4<out A, out B, out C, out D> : Tuple4Of<A, B, C, D> |
| Tuple4Of | typealias ~~Tuple4Of~~<A, B, C, D> = Kind4<ForTuple4, A, B, C, D> |
| Tuple4PartialOf | typealias ~~Tuple4PartialOf~~<A, B, C> = Kind3<ForTuple4, A, B, C> |
| Tuple5 | data class Tuple5<out A, out B, out C, out D, out E> : Tuple5Of<A, B, C, D, E> |
| 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> |
| Tuple6 | data class Tuple6<out A, out B, out C, out D, out E, out F> : Tuple6Of<A, B, C, D, E, F> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> = Valid<A> |
| Validated | Imagine you are filling out a web form to sign up for an account. You input your username and password, then submit. A response comes back saying your username can’t have dashes in it, so you make some changes, then resubmit. You can’t have special characters either. Change, resubmit. Password needs to have at least one capital letter. Change, resubmit. Password needs to have at least one number.sealed class Validated<out E, out A> : ValidatedOf<E, 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> |
Exceptions
| ShortCircuit | class ShortCircuit : RuntimeException |
Extensions for External Classes
Properties
| AndThenDeprecation | const val AndThenDeprecation: String |
| DeprecatedAmbiguity | const val DeprecatedAmbiguity: String |
| DeprecatedUnsafeAccess | const val DeprecatedUnsafeAccess: String |
| FoldRightDeprecation | const val FoldRightDeprecation: String |
| ListKDeprecation | const val ListKDeprecation: String |
| MapKDeprecation | const val MapKDeprecation: String |
| OrderingDeprecation | const val OrderingDeprecation: String |
| SequenceKDeprecation | const val SequenceKDeprecation: String |
| SetKDeprecation | const val SetKDeprecation: String |
| SortedMapKDeprecation | const val SortedMapKDeprecation: String |
| TailRecMDeprecation | const val TailRecMDeprecation: String |
Functions
| ap | fun <A, T, U> ConstOf<A, T>.~~ap~~(SG: Semigroup<A>, ff: ConstOf<A, (T) -> U>): Const<A, U>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> |
| attempt | fun <E, A> Validated<E, A>.attempt(): Validated<Nothing, Either<E, A>> |
| bisequence | fun <A, B> Either<Iterable<A>, Iterable<B>>.bisequence(): List<Either<A, B>>fun <A, B> Ior<Iterable<A>, Iterable<B>>.bisequence(): List<Ior<A, B>>fun <E, A> Validated<Iterable<E>, Iterable<A>>.bisequence(): List<Validated<E, A>> |
| bisequenceEither | fun <A, B, C> Ior<Either<A, B>, Either<A, C>>.bisequenceEither(): Either<A, Ior<B, C>>fun <E, A, B> Validated<Either<E, A>, Either<E, B>>.bisequenceEither(): Either<E, Validated<A, B>> |
| bisequenceValidated | fun <A, B, C> Either<Validated<A, B>, Validated<A, C>>.bisequenceValidated(): Validated<A, Either<B, C>>fun <A, B, C> Ior<Validated<A, B>, Validated<A, C>>.bisequenceValidated(SA: Semigroup<A>): Validated<A, Ior<B, C>> |
| bothIor | fun <A, B> Tuple2<A, B>.~~bothIor~~(): Ior<A, B> |
| combine | fun <A, T> ConstOf<A, T>.~~combine~~(SG: Semigroup<A>, that: ConstOf<A, T>): Const<A, T>fun <A, T> Const<A, T>.combine(SG: Semigroup<A>, that: Const<A, T>): Const<A, T>fun <A, B> Either<A, B>.combine(SGA: Semigroup<A>, SGB: Semigroup<B>, b: Either<A, B>): Either<A, B>fun <A, B> Ior<A, B>.combine(SA: Semigroup<A>, SB: Semigroup<B>, other: Ior<A, B>): Ior<A, B>fun <A> Option<A>.combine(SGA: Semigroup<A>, b: Option<A>): Option<A>fun <E, A> ValidatedOf<E, A>.combine(SE: Semigroup<E>, SA: Semigroup<A>, y: ValidatedOf<E, A>): Validated<E, A> |
| combineAll | fun <A> Option<A>.combineAll(MA: Monoid<A>): Afun <E, A> Validated<E, A>.combineAll(MA: Monoid<A>): 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> |
| compareTo | operator fun <A : Comparable<A>, T> Const<A, T>.compareTo(other: Const<A, T>): Intoperator fun <A : Comparable<A>, B : Comparable<B>> Either<A, B>.compareTo(other: Either<A, B>): Intoperator fun <A : Comparable<A>, B : Comparable<B>> Ior<A, B>.compareTo(other: Ior<A, B>): Intoperator fun <A : Comparable<A>> NonEmptyList<A>.compareTo(other: NonEmptyList<A>): Intoperator fun <A : Comparable<A>> Option<A>.compareTo(other: Option<A>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>, H : Comparable<H>, I : Comparable<I>, J : Comparable<J>> Tuple10<A, B, C, D, E, F, G, H, I, J>.compareTo(other: Tuple10<A, B, C, D, E, F, G, H, I, J>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>> Tuple4<A, B, C, D>.compareTo(other: Tuple4<A, B, C, D>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>> Tuple5<A, B, C, D, E>.compareTo(other: Tuple5<A, B, C, D, E>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>> Tuple6<A, B, C, D, E, F>.compareTo(other: Tuple6<A, B, C, D, E, F>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>> Tuple7<A, B, C, D, E, F, G>.compareTo(other: Tuple7<A, B, C, D, E, F, G>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>, H : Comparable<H>> Tuple8<A, B, C, D, E, F, G, H>.compareTo(other: Tuple8<A, B, C, D, E, F, G, H>): Intoperator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>, H : Comparable<H>, I : Comparable<I>> Tuple9<A, B, C, D, E, F, G, H, I>.compareTo(other: Tuple9<A, B, C, D, E, F, G, H, I>): Intoperator fun <E : Comparable<E>, A : Comparable<A>> Validated<E, A>.compareTo(other: Validated<E, A>): Int |
| const | fun <A> A.const(): Const<A, Nothing> |
| constant | fun <P1, T> constant(t: T): (P1) -> T |
| contains | Returns true if this is a Either.Right and its value is equal to elem (as determined by ==), returns false otherwise.fun <A, B> EitherOf<A, B>.contains(elem: B): Boolean |
| contramap | fun <A, T, U> Const<A, T>.contramap(f: (U) -> T): Const<A, U> |
| ensure | fun <A, B> Either<A, B>.ensure(error: () -> A, predicate: (B) -> Boolean): Either<A, B>fun <A> Option<A>.ensure(error: () -> Unit, predicate: (A) -> Boolean): Option<A> |
| filterIsInstance | Returns an Option containing all elements that are instances of specified type parameter R.fun <B> Option<*>.filterIsInstance(): Option<B> |
| filterOrElse | 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.fun <A, B> EitherOf<A, B>.filterOrElse(predicate: (B) -> Boolean, default: () -> A): Either<A, B> |
| filterOrOther | 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.fun <A, B> EitherOf<A, B>.filterOrOther(predicate: (B) -> Boolean, default: (B) -> A): Either<A, B> |
| findValid | 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.fun <E, A> ValidatedOf<E, A>.findValid(SE: Semigroup<E>, that: () -> Validated<E, A>): Validated<E, A> |
| fix | fun <A, B> AndThenOf<A, B>.~~fix~~(): AndThen<A, B>fun <A, T> ConstOf<A, T>.~~fix~~(): Const<A, T>fun <A, B> EitherOf<A, B>.~~fix~~(): Either<A, B>fun <A> EvalOf<A>.~~fix~~(): Eval<A>fun <A> HashedOf<A>.~~fix~~(): Hashed<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, 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> Tuple2Of<A, B>.~~fix~~(): Tuple2<A, B>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 <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, 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 <E, A> ValidatedOf<E, A>.~~fix~~(): Validated<E, A> |
| flatMap | Binds the given function across Either.Right.fun <A, B, C> EitherOf<A, B>.flatMap(f: (B) -> Either<A, C>): Either<A, C>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> Either<A, Either<A, B>>.flatten(): Either<A, B>fun <A, B> Ior<A, Ior<A, B>>.flatten(SA: Semigroup<A>): Ior<A, B>fun <A> NonEmptyList<NonEmptyList<A>>.flatten(): NonEmptyList<A>fun <A> Option<Option<A>>.flatten(): Option<A> |
| fold | fun <E, A> Validated<E, A>.fold(MA: Monoid<A>): A |
| getOrElse | Returns the value from this Either.Right or the given argument if this is a Either.Left.fun <B> EitherOf<*, B>.getOrElse(default: () -> B): Bfun <A, B> Ior<A, B>.getOrElse(default: () -> B): BReturns the option’s value if the option is nonempty, otherwise return the result of evaluating default.fun <T> Option<T>.getOrElse(default: () -> T): TReturn the Valid value, or the default if Invalid fun <E, A> ValidatedOf<E, A>.getOrElse(default: () -> A): A |
| getOrHandle | 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.fun <A, B> EitherOf<A, B>.getOrHandle(default: (A) -> B): B |
| handleError | fun <A, B> Either<A, B>.handleError(f: (A) -> B): Either<A, B>fun <A> Option<A>.handleError(f: (Unit) -> A): Option<A>fun <E, A> ValidatedOf<E, A>.handleError(f: (E) -> A): Validated<Nothing, A> |
| handleErrorWith | 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 <A, B, C> EitherOf<A, B>.handleErrorWith(f: (A) -> EitherOf<C, B>): Either<C, B>fun <A> Option<A>.handleErrorWith(f: (Unit) -> Option<A>): Option<A>fun <E, A> ValidatedOf<E, A>.handleErrorWith(f: (E) -> ValidatedOf<E, A>): Validated<E, A> |
| 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 |
| 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 | 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.fun <A, B> EitherOf<A, B?>.leftIfNull(default: () -> A): Either<A, B> |
| leftIor | fun <A> A.leftIor(): Ior<A, Nothing> |
| leftWiden | fun <AA, A : AA, B> Either<A, B>.leftWiden(): Either<AA, B>fun <AA, A : AA, B> Ior<A, B>.leftWiden(): Ior<AA, B>fun <EE, E : EE, A> Validated<E, A>.leftWiden(): Validated<EE, A> |
| listKOf | fun <A> ~~listKOf~~(vararg elements: A): ListK<A> |
| mapN | fun <A, R> ~~mapN~~(a: A?, fn: (A) -> R): R?fun <A, B, R> ~~mapN~~(a: A?, b: B?, fn: (A, B) -> R): R?fun <A, B, C, R> ~~mapN~~(a: A?, b: B?, c: C?, fn: (A, B, C) -> R): R?fun <A, B, C, D, R> ~~mapN~~(a: A?, b: B?, c: C?, d: D?, fn: (A, B, C, D) -> R): R?fun <A, B, C, D, E, R> ~~mapN~~(a: A?, b: B?, c: C?, d: D?, e: E?, fn: (A, B, C, D, E) -> R): R?fun <A, B, C, D, E, F, R> ~~mapN~~(a: A?, b: B?, c: C?, d: D?, e: E?, f: F?, fn: (A, B, C, D, E, F) -> R): R?fun <A, B, C, D, E, F, G, R> ~~mapN~~(a: A?, b: B?, c: C?, d: D?, e: E?, f: F?, g: G?, fn: (A, B, C, D, E, F, G) -> R): R?fun <A, B, C, D, E, F, G, H, R> ~~mapN~~(a: A?, b: B?, c: C?, d: D?, e: E?, f: F?, g: G?, h: H?, fn: (A, B, C, D, E, F, G, H) -> R): R?fun <A, B, C, D, E, F, G, H, I, R> ~~mapN~~(a: A?, b: B?, c: C?, d: D?, e: E?, f: F?, g: G?, h: H?, i: I?, fn: (A, B, C, D, E, F, G, H, I) -> R): R? |
| mapOf | fun <K, V> ~~mapOf~~(vararg tuple: Tuple2<K, V>): MapK<K, V>fun <K, V> ~~mapOf~~(pair: Tuple2<K, V>): Map<K, V> |
| merge | Returns the value from this Either.Right or Either.Left.fun <A> EitherOf<A, A>.merge(): A |
| nel | fun <A> A.nel(): NonEmptyList<A> |
| none | fun <A> none(): Option<A> |
| nonEmptyListOf | fun <A> nonEmptyListOf(head: A, vararg t: A): NonEmptyList<A> |
| NonFatal | Extractor of non-fatal Throwable. Will not match fatal errors like VirtualMachineError (for example, OutOfMemoryError and StackOverflowError, subclasses of VirtualMachineError), ThreadDeath, LinkageError, InterruptedException. This will also not match CancellationException since that’s a fatal exception in Kotlin for cancellation purposes.fun NonFatal(t: Throwable): Boolean |
| or | infix fun <T> OptionOf<T>.or(value: Option<T>): Option<T> |
| orElse | Returns this option’s if the option is nonempty, otherwise returns another option provided lazily by default.fun <A> OptionOf<A>.orElse(alternative: () -> Option<A>): Option<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. fun <E, A> ValidatedOf<E, A>.orElse(default: () -> Validated<E, A>): Validated<E, A> |
| orNull | Returns the value from this Either.Right or null if this is a Either.Left.fun <B> EitherOf<*, B>.orNull(): B?Return the Valid value, or null if Invalid fun <E, A> ValidatedOf<E, A>.orNull(): A? |
| redeem | fun <A, B, C> Either<A, B>.redeem(fe: (A) -> C, fa: (B) -> C): Either<A, C>fun <A, B> Option<A>.redeem(fe: (Unit) -> B, fb: (A) -> B): Option<B>fun <E, A, B> Validated<E, A>.redeem(fe: (E) -> B, fa: (A) -> B): Validated<E, B> |
| redeemWith | fun <A, B, C, D> Either<A, B>.redeemWith(fa: (A) -> Either<C, D>, fb: (B) -> Either<C, D>): Either<C, D>fun <A, B> Option<A>.redeemWith(fe: (Unit) -> Option<B>, fb: (A) -> Option<B>): Option<B> |
| replicate | fun <A, B> Either<A, B>.replicate(n: Int, MB: Monoid<B>): Either<A, B>fun <A> Eval<A>.replicate(n: Int): Eval<List<A>>fun <A> Eval<A>.replicate(n: Int, MA: Monoid<A>): Eval<A>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>fun <A> Option<A>.replicate(n: Int, MA: Monoid<A>): Option<A>fun <E, A> Validated<E, A>.replicate(SE: Semigroup<E>, n: Int): Validated<E, List<A>>fun <E, A> Validated<E, A>.replicate(SE: Semigroup<E>, n: Int, MA: Monoid<A>): Validated<E, A> |
| rethrow | fun <A> Option<Either<Unit, A>>.rethrow(): Option<A> |
| Right | fun <R> ~~Right~~(right: R): Either<Nothing, R> |
| right | fun <A> A.right(): Either<Nothing, A> |
| rightIfNotNull | Returns Either.Right if the value of type B is not null, otherwise the specified A value wrapped into an Either.Left.fun <A, B> B?.rightIfNotNull(default: () -> A): Either<A, B> |
| rightIor | fun <A> A.rightIor(): Ior<Nothing, A> |
| salign | fun <A> Option<A>.salign(SA: Semigroup<A>, b: Option<A>): Option<A> |
| select | fun <A, B> Option<Either<A, B>>.~~select~~(f: OptionOf<(A) -> B>): Option<B> |
| separateEither | Separate the inner Either value into the Either.Left and Either.Right.fun <A, B> Option<Either<A, B>>.separateEither(): Pair<Option<A>, Option<B>> |
| separateValidated | Separate the inner Validated value into the Validated.Invalid and Validated.Valid.fun <A, B> Option<Validated<A, B>>.separateValidated(): Pair<Option<A>, Option<B>> |
| sequence | fun <T, A, G> ConstOf<A, Kind<G, T>>.~~sequence~~(GA: Applicative<G>): Kind<G, Const<A, T>>fun <A, B> Either<A, Iterable<B>>.sequence(): List<Either<A, B>>fun <A, B, G> IorOf<A, Kind<G, B>>.~~sequence~~(GA: Applicative<G>): Kind<G, Ior<A, B>>fun <A, B> Ior<A, Iterable<B>>.sequence(): List<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> Option<Iterable<A>>.sequence(): List<Option<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 <E, A> Validated<E, Iterable<A>>.sequence(): List<Validated<E, A>>fun <G, E, A> ValidatedOf<E, Kind<G, A>>.~~sequence~~(GA: Applicative<G>): Kind<G, Validated<E, A>> |
| sequenceEither | fun <A, B, C> Ior<A, Either<B, C>>.sequenceEither(): Either<B, Ior<A, C>>fun <E, A> NonEmptyList<Either<E, A>>.sequenceEither(): Either<E, NonEmptyList<A>>fun <A, B> Option<Either<A, B>>.sequenceEither(): Either<A, Option<B>>fun <E, A, B> Validated<A, Either<E, B>>.sequenceEither(): Either<E, Validated<A, B>> |
| sequenceValidated | fun <A, B, C> Either<A, Validated<B, C>>.sequenceValidated(): Validated<B, Either<A, C>>fun <A, B, C> Ior<A, Validated<B, C>>.sequenceValidated(): Validated<B, Ior<A, C>>fun <E, A> NonEmptyList<Validated<E, A>>.sequenceValidated(semigroup: Semigroup<E>): Validated<E, NonEmptyList<A>>fun <A, B> Option<Validated<A, B>>.sequenceValidated(): Validated<A, Option<B>> |
| some | fun <A> A.some(): Option<A> |
| sort | fun <A : Comparable<A>> sort(a: A, b: A): Pair<A, A>fun <A : Comparable<A>> sort(a: A, b: A, c: A): Triple<A, A, A>fun <A : Comparable<A>> sort(a: A, vararg aas: A): List<A>fun <A> sort(a: A, b: A, comparator: Comparator<A>): Pair<A, A>fun <A> sort(a: A, b: A, c: A, comparator: Comparator<A>): Triple<A, A, A>fun <A> sort(a: A, vararg aas: A, comparator: Comparator<A>): List<A>fun sort(a: Byte, b: Byte): Pair<Byte, Byte>fun sort(a: Byte, b: Byte, c: Byte): Triple<Byte, Byte, Byte>fun sort(a: Byte, vararg aas: Byte): List<Byte>fun sort(a: Short, b: Short): Pair<Short, Short>fun sort(a: Short, b: Short, c: Short): Triple<Short, Short, Short>fun sort(a: Short, vararg aas: Short): List<Short>fun sort(a: Int, b: Int): Pair<Int, Int>fun sort(a: Int, b: Int, c: Int): Triple<Int, Int, Int>fun sort(a: Int, vararg aas: Int): List<Int>fun sort(a: Long, b: Long): Pair<Long, Long>fun sort(a: Long, b: Long, c: Long): Triple<Long, Long, Long>fun sort(a: Long, vararg aas: Long): List<Long>fun sort(a: Float, b: Float): Pair<Float, Float>fun sort(a: Float, b: Float, c: Float): Triple<Float, Float, Float>fun sort(a: Float, vararg aas: Float): List<Float>fun sort(a: Double, b: Double): Pair<Double, Double>fun sort(a: Double, b: Double, c: Double): Triple<Double, Double, Double>fun sort(a: Double, vararg aas: Double): List<Double> |
| toIor | Converts the value to an Ior<E, A>fun <E, A> ValidatedOf<E, A>.toIor(): 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>> |
| traverseEither | fun <E, A, B> NonEmptyList<A>.traverseEither(f: (A) -> Either<E, B>): Either<E, NonEmptyList<B>> |
| traverseValidated | fun <E, A, B> NonEmptyList<A>.traverseValidated(semigroup: Semigroup<E>, f: (A) -> Validated<E, B>): Validated<E, NonEmptyList<B>> |
| unalign | fun <A, B> Option<Ior<A, B>>.unalign(): Pair<Option<A>, Option<B>>fun <A, B, C> Option<C>.unalign(f: (C) -> Ior<A, B>): Pair<Option<A>, Option<B>> |
| unite | fun <A> Option<Iterable<A>>.unite(MA: Monoid<A>): Option<A> |
| uniteEither | fun <A, B> Option<Either<A, B>>.uniteEither(): Option<B> |
| uniteValidated | fun <A, B> Option<Validated<A, B>>.uniteValidated(): Option<B> |
| unzip | fun <A, B> NonEmptyList<Pair<A, B>>.unzip(): Pair<NonEmptyList<A>, NonEmptyList<B>>fun <A, B, C> NonEmptyList<C>.unzip(f: (C) -> Pair<A, B>): Pair<NonEmptyList<A>, NonEmptyList<B>>fun <A, B> Option<Pair<A, B>>.unzip(): Pair<Option<A>, Option<B>>fun <A, B, C> Option<C>.unzip(f: (C) -> Pair<A, B>): Pair<Option<A>, Option<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, T> ConstOf<A, T>.~~value~~(): Afun <A> EvalOf<A>.~~value~~(): A |
| valueOr | Return the Valid value, or the result of f if Invalidfun <E, A> ValidatedOf<E, A>.valueOr(f: (E) -> A): A |
| widen | Given B is a sub type of C, re-type this value from Either<A, B> to Either<A, B>fun <A, C, B : C> Either<A, B>.widen(): Either<A, C>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>Given A is a sub type of B, re-type this value from Option to Option fun <B, A : B> Option<A>.widen(): Option<B>Given A is a sub type of B, re-type this value from Validated<E, A> to Validated<E, B> fun <E, B, A : B> Validated<E, A>.widen(): Validated<E, B> |
| zip | fun <A, B, C, D> Either<A, B>.zip(fb: Either<A, C>, f: (B, C) -> D): Either<A, D>fun <A, B, C> Either<A, B>.zip(fb: Either<A, C>): Either<A, Pair<B, C>>fun <A, B, C, D, E> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, map: (B, C, D) -> E): Either<A, E>fun <A, B, C, D, E, F> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, map: (B, C, D, E) -> F): Either<A, F>fun <A, B, C, D, E, F, G> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, f: Either<A, F>, map: (B, C, D, E, F) -> G): Either<A, G>fun <A, B, C, D, E, F, G, H> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, f: Either<A, F>, g: Either<A, G>, map: (B, C, D, E, F, G) -> H): Either<A, H>fun <A, B, C, D, E, F, G, H, I> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, f: Either<A, F>, g: Either<A, G>, h: Either<A, H>, map: (B, C, D, E, F, G, H) -> I): Either<A, I>fun <A, B, C, D, E, F, G, H, I, J> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, f: Either<A, F>, g: Either<A, G>, h: Either<A, H>, i: Either<A, I>, map: (B, C, D, E, F, G, H, I) -> J): Either<A, J>fun <A, B, C, D, E, F, G, H, I, J, K> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, f: Either<A, F>, g: Either<A, G>, h: Either<A, H>, i: Either<A, I>, j: Either<A, J>, map: (B, C, D, E, F, G, H, I, J) -> K): Either<A, K>fun <A, B, C, D, E, F, G, H, I, J, K, L> Either<A, B>.zip(c: Either<A, C>, d: Either<A, D>, e: Either<A, E>, f: Either<A, F>, g: Either<A, G>, h: Either<A, H>, i: Either<A, I>, j: Either<A, J>, k: Either<A, K>, map: (B, C, D, E, F, G, H, I, J, K) -> L): Either<A, L>fun <A, B, Z> Eval<A>.zip(b: Eval<B>, map: (A, B) -> Z): Eval<Z>fun <A, B> Eval<A>.zip(b: Eval<B>): Eval<Pair<A, B>>fun <A, B, C, D> Eval<A>.zip(b: Eval<B>, c: Eval<C>, map: (A, B, C) -> D): Eval<D>fun <A, B, C, D, E> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, map: (A, B, C, D) -> E): Eval<E>fun <A, B, C, D, E, F> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, map: (A, B, C, D, E) -> F): Eval<F>fun <A, B, C, D, E, F, G> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, map: (A, B, C, D, E, F) -> G): Eval<G>fun <A, B, C, D, E, F, G, H> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, map: (A, B, C, D, E, F, G) -> H): Eval<H>fun <A, B, C, D, E, F, G, H, I> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, h: Eval<H>, map: (A, B, C, D, E, F, G, H) -> I): Eval<I>fun <A, B, C, D, E, F, G, H, I, J> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, h: Eval<H>, i: Eval<I>, map: (A, B, C, D, E, F, G, H, I) -> J): Eval<J>fun <A, B, C, D, E, F, G, H, I, J, K> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, h: Eval<H>, i: Eval<I>, j: Eval<J>, map: (A, B, C, D, E, F, G, H, I, J) -> K): Eval<K>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>fun <E, A, B> Validated<E, A>.zip(SE: Semigroup<E>, fb: Validated<E, B>): Validated<E, Pair<A, B>>fun <E, A, B, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, f: (A, B) -> Z): Validated<E, Z>fun <E, A, B, C, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, f: (A, B, C) -> Z): Validated<E, Z>fun <E, A, B, C, D, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, f: (A, B, C, D) -> Z): Validated<E, Z>fun <E, A, B, C, D, EE, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, f: (A, B, C, D, EE) -> Z): Validated<E, Z>fun <E, A, B, C, D, EE, FF, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, FF>, f: (A, B, C, D, EE, FF) -> Z): Validated<E, Z>fun <E, A, B, C, D, EE, F, G, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, f: (A, B, C, D, EE, F, G) -> Z): Validated<E, Z>fun <E, A, B, C, D, EE, F, G, H, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, h: Validated<E, H>, f: (A, B, C, D, EE, F, G, H) -> Z): Validated<E, Z>fun <E, A, B, C, D, EE, F, G, H, I, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, h: Validated<E, H>, i: Validated<E, I>, f: (A, B, C, D, EE, F, G, H, I) -> Z): Validated<E, Z>fun <E, A, B, C, D, EE, F, G, H, I, J, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, h: Validated<E, H>, i: Validated<E, I>, j: Validated<E, J>, f: (A, B, C, D, EE, F, G, H, I, J) -> Z): Validated<E, Z>fun <E, A, B, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, f: (A, B) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, f: (A, B, C) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, f: (A, B, C, D) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, EE, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, f: (A, B, C, D, EE) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, EE, FF, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, FF>, f: (A, B, C, D, EE, FF) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, EE, F, G, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, f: (A, B, C, D, EE, F, G) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, EE, F, G, H, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, h: ValidatedNel<E, H>, f: (A, B, C, D, EE, F, G, H) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, EE, F, G, H, I, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, h: ValidatedNel<E, H>, i: ValidatedNel<E, I>, f: (A, B, C, D, EE, F, G, H, I) -> Z): ValidatedNel<E, Z>fun <E, A, B, C, D, EE, F, G, H, I, J, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, h: ValidatedNel<E, H>, i: ValidatedNel<E, I>, j: ValidatedNel<E, J>, f: (A, B, C, D, EE, F, G, H, I, J) -> Z): ValidatedNel<E, Z> |