Package arrow.core

Types

data class Const<A, out T>(value: A)

sealed class Either<out A, out B>

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.

Endo

data class Endo<A>(val f: (A) -> A)

The monoid of endomorphisms under composition.

Eval

sealed class Eval<out A>

Eval is a monad which controls evaluation of a value or a computation that produces a value.

Invalid

typealias Invalid<E> = Validated.Invalid<E>

Ior

sealed class Ior<out A, out B>

Port of https://github.com/typelevel/cats/blob/v0.9.0/core/src/main/scala/cats/data/Ior.scala

IorNel

typealias IorNel<A, B> = Ior<Nel<A>, B>

Nel

typealias Nel<A> = NonEmptyList<A>

None

object None : Option<Nothing>

NonEmptyList

class NonEmptyList<out A>(val head: A, val tail: List<A>) : AbstractList<A>

NonEmptyList is a data type used in Λrrow to model ordered lists that guarantee to have at least one value.

Nullable

object Nullable

Option

sealed class Option<out A>

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 ?.

Predicate

typealias Predicate<T> = (T) -> Boolean

Some

data class Some<out T>(val value: T) : Option<T>

Tuple10

data class Tuple10<out A, out B, out C, out D, out E, out F, out G, out H, out I, out J>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: P, val seventeenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: P, val seventeenth: Q, val eighteenth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: P, val seventeenth: Q, val eighteenth: R, val nineteenth: S)

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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: P, val seventeenth: Q, val eighteenth: R, val nineteenth: S, val twentieth: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: P, val seventeenth: Q, val eighteenth: R, val nineteenth: S, val twentieth: T, val twentyFirst: 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>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I, val tenth: J, val eleventh: K, val twelfth: L, val thirteenth: M, val fourteenth: N, val fifteenth: O, val sixteenth: P, val seventeenth: Q, val eighteenth: R, val nineteenth: S, val twentieth: T, val twentyFirst: U, val twentySecond: V)

Tuple4

data class Tuple4<out A, out B, out C, out D>( val first: A, val second: B, val third: C, val fourth: D)

Tuple5

data class Tuple5<out A, out B, out C, out D, out E>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E)

Tuple6

data class Tuple6<out A, out B, out C, out D, out E, out F>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F)

Tuple7

data class Tuple7<out A, out B, out C, out D, out E, out F, out G>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G)

Tuple8

data class Tuple8<out A, out B, out C, out D, out E, out F, out G, out H>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H)

Tuple9

data class Tuple9<out A, out B, out C, out D, out E, out F, out G, out H, out I>( val first: A, val second: B, val third: C, val fourth: D, val fifth: E, val sixth: F, val seventh: G, val eighth: H, val ninth: I)

Valid

typealias Valid<A> = Validated.Valid<A>

Validated

sealed class Validated<out E, out A>

ValidatedNel

typealias ValidatedNel<E, A> = Validated<Nel<E>, A>

Functions

align

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

fun <K, A, B> Map<K, A>.align(b: Map<K, B>): Map<K, Ior<A, B>>

fun <A, B> Sequence<A>.align(b: Sequence): Sequence<Ior<A, B>>

Combines two structures by taking the union of their shapes and using Ior to hold the elements.

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

fun <K, A, B, C> Map<K, A>.align(b: Map<K, B>, fa: (Map.Entry<K, Ior<A, B>>) -> C): Map<K, C>

fun <A, B, C> Sequence<A>.align(b: Sequence, fa: (Ior<A, B>) -> C): Sequence<C>

Combines two structures by taking the union of their shapes and combining the elements with the given function.

andThen

inline fun <E, A, B> Validated<E, A>.andThen(f: (A) -> Validated<E, B>): Validated<E, B>

Apply a function to a Valid value, returning a new Validation that may be valid or invalid

expect infix fun <IP, R> () -> IP.andThen(f: (IP) -> R): () -> R

expect infix fun <P1, IP, R> (P1) -> IP.andThen(f: (IP) -> R): (P1) -> R

expect infix fun <P1, P2, IP, R> (P1, P2) -> IP.andThen(f: (IP) -> R): (P1, P2) -> R

actual infix fun <IP, R> () -> IP.andThen(f: (IP) -> R): () -> R

actual infix fun <P1, IP, R> (P1) -> IP.andThen(f: (IP) -> R): (P1) -> R

actual infix fun <P1, P2, IP, R> (P1, P2) -> IP.andThen(f: (IP) -> R): (P1, P2) -> R

actual infix fun <IP, R> () -> IP.andThen(f: (IP) -> R): () -> R

actual infix fun <P1, IP, R> (P1) -> IP.andThen(f: (IP) -> R): (P1) -> R

actual infix fun <P1, P2, IP, R> (P1, P2) -> IP.andThen(f: (IP) -> R): (P1, P2) -> R

actual infix fun <IP, R> () -> IP.andThen(f: (IP) -> R): () -> R

actual infix fun <P1, IP, R> (P1) -> IP.andThen(f: (IP) -> R): (P1) -> R

actual infix fun <P1, P2, IP, R> (P1, P2) -> IP.andThen(f: (IP) -> R): (P1, P2) -> R

attempt

fun <E, A> Validated<E, A>.attempt(): Validated<Nothing, Either<E, A>>

bisequence

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

fun <A, B> Ior<Iterable<A>, Iterable>.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>>

bisequenceNullable

fun <A, B> Either<A?, B?>.bisequenceNullable(): Either<A, B>?

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

fun <A, B> Validated<A?, B?>.bisequenceNullable(): Validated<A, B>?

bisequenceOption

fun <A, B> Either<Option<A>, Option>.bisequenceOption(): Option<Either<A, B>>

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

fun <A, B> Validated<Option<A>, Option>.bisequenceOption(): Option<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> Pair<A, B>.bothIor(): Ior<A, B>

combine

fun <A, T> Const<A, T>.combine(SG: Semigroup<A>, that: Const<A, T>): Const<A, T>

fun <A> Option<A>.combine(SGA: Semigroup<A>, b: Option<A>): Option<A>

fun <K, A> Map<K, A>.combine(SG: Semigroup<A>, b: Map<K, A>): Map<K, A>

fun <A, B> Either<A, B>.combine( SGA: Semigroup<A>, SGB: Semigroup, b: Either<A, B>): Either<A, B>

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

fun <E, A> Validated<E, A>.combine( SE: Semigroup<E>, SA: Semigroup<A>, y: Validated<E, A>): Validated<E, A>

fun <A, B> Pair<A, B>.combine( SA: Semigroup<A>, SB: Semigroup, b: Pair<A, B>): Pair<A, B>

combineAll

~~fun~~ <A> Option<A>.~~combineAll~~(MA: Monoid<A>): A

~~fun~~ <E, A> Validated<E, A>.~~combineAll~~(MA: Monoid<A>): A

~~fun~~ <A> Iterable<A>.~~combineAll~~(MA: Monoid<A>): A

~~fun~~ <A> Iterable<Option<A>>.~~combineAll~~(MA: Monoid<A>): Option<A>

~~fun~~ <K, A> Iterable<Map<K, A>>.~~combineAll~~(SG: Semigroup<A>): Map<K, A>

~~fun~~ <A> Sequence<A>.~~combineAll~~(MA: Monoid<A>): A

~~fun~~ <A, B> Iterable<Either<A, B>>.~~combineAll~~(MA: Monoid<A>, MB: Monoid): Either<A, B>

combineK

fun <A, B> Either<A, B>.combineK(y: Either<A, B>): Either<A, B>

fun <E, A> Validated<E, A>.combineK(SE: Semigroup<E>, y: Validated<E, A>): Validated<E, A>

compareTo

operator fun <A : Comparable<A>, T> Const<A, T>.compareTo(other: Const<A, T>): Int

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

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

operator fun <A : Comparable<A>> NonEmptyList<A>.compareTo(other: NonEmptyList<A>): Int

operator fun <A : Comparable<A>> Option<A>.compareTo(other: Option<A>): Int

operator fun <A : Comparable<A>, B : Comparable, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>, H : Comparable<H>, I : Comparable, 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>): Int

operator fun <A : Comparable<A>, B : Comparable, C : Comparable<C>, D : Comparable<D>> Tuple4<A, B, C, D>.compareTo(other: Tuple4<A, B, C, D>): Int

operator fun <A : Comparable<A>, B : Comparable, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>> Tuple5<A, B, C, D, E>.compareTo(other: Tuple5<A, B, C, D, E>): Int

operator fun <A : Comparable<A>, B : Comparable, 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>): Int

operator fun <A : Comparable<A>, B : Comparable, 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>): Int

operator fun <A : Comparable<A>, B : Comparable, 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>): Int

operator fun <A : Comparable<A>, B : Comparable, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>, H : Comparable<H>, I : Comparable> Tuple9<A, B, C, D, E, F, G, H, I>.compareTo(other: Tuple9<A, B, C, D, E, F, G, H, I>): Int

operator fun <E : Comparable<E>, A : Comparable<A>> Validated<E, A>.compareTo(other: Validated<E, A>): Int

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

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

operator fun <A : Comparable<A>> Iterable<A>.compareTo(other: Iterable<A>): Int

compose

expect infix fun <IP, R, P1> (IP) -> R.compose(f: (P1) -> IP): (P1) -> R

actual infix fun <IP, R, P1> (IP) -> R.compose(f: (P1) -> IP): (P1) -> R

const

inline fun <A> A.const(): Const<A, Nothing>

constant

fun <P1, T> constant(t: T): (P1) -> T

contains

fun <A, B> Either<A, B>.contains(elem: B): Boolean

Returns true if this is a Right and its value is equal to elem (as determined by ==), returns false otherwise.

contramap

fun <A, T, U> Const<A, T>.contramap(f: (U) -> T): Const<A, U>

crosswalk

fun <A, B> Iterable<A>.crosswalk(f: (A) -> Iterable): List<List>

fun <A, B> Sequence<A>.crosswalk(f: (A) -> Sequence): Sequence<Sequence>

crosswalkMap

fun <A, K, V> Iterable<A>.crosswalkMap(f: (A) -> Map<K, V>): Map<K, List<V>>

fun <A, K, V> Sequence<A>.crosswalkMap(f: (A) -> Map<K, V>): Map<K, Sequence<V>>

crosswalkNull

fun <A, B> Iterable<A>.crosswalkNull(f: (A) -> B?): List?

fun <A, B> Sequence<A>.crosswalkNull(f: (A) -> B?): Sequence?

curried

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> (P17) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> (P17) -> (P18) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> (P17) -> (P18) -> (P19) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> (P17) -> (P18) -> (P19) -> (P20) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> (P17) -> (P18) -> (P19) -> (P20) -> (P21) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> (P10) -> (P11) -> (P12) -> (P13) -> (P14) -> (P15) -> (P16) -> (P17) -> (P18) -> (P19) -> (P20) -> (P21) -> (P22) -> R

fun <P1, P2, R> (P1, P2) -> R.curried(): (P1) -> (P2) -> R

fun <P1, P2, P3, R> (P1, P2, P3) -> R.curried(): (P1) -> (P2) -> (P3) -> R

fun <P1, P2, P3, P4, R> (P1, P2, P3, P4) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> R

fun <P1, P2, P3, P4, P5, R> (P1, P2, P3, P4, P5) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> R

fun <P1, P2, P3, P4, P5, P6, R> (P1, P2, P3, P4, P5, P6) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> R

fun <P1, P2, P3, P4, P5, P6, P7, R> (P1, P2, P3, P4, P5, P6, P7) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, R> (P1, P2, P3, P4, P5, P6, P7, P8) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> R

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R.curried(): (P1) -> (P2) -> (P3) -> (P4) -> (P5) -> (P6) -> (P7) -> (P8) -> (P9) -> R