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)

Properties

ConstDeprecation

const val ConstDeprecation: String

DeprecatedAmbiguity

const val DeprecatedAmbiguity: String

DeprecatedUnsafeAccess

const val DeprecatedUnsafeAccess: String

NicheAPI

const val NicheAPI: String

RedundantAPI

const val RedundantAPI: String

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

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

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

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

Combines two Sequence by returning Ior.Both when both Sequence have an item, Ior.Left when only the first Sequence has an item, and Ior.Right when only the second Sequence has an item.

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>

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

andThen

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

bisequence

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

bisequenceNullable

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

bisequenceOption

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

bothIor

fun <A, B> Pair<A, B>.bothIor(): Ior<A, B>

catch

inline fun <E, T : Throwable, A> Either<Throwable, A>.catch(catch: Raise<E>.(T) -> A): Either<E, A>

Variant of Either.catchOrThrow constructor that allows for working with Either<Throwable, A> by transforming or recovering from Throwable as T in the Either.Left side. This API is the same as recover. This is useful when working with results of Either.catch since this API offers a reified variant.

combine

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

fun <A> Option<A>.combine(other: Option<A>, combine: (A, A) -> A): Option<A>

fun <A, B> Ior<A, B>.combine(other: Ior<A, B>, combineA: (A, A) -> A, combineB: (B, B) -> B): Ior<A, B>

fun <K, A> Map<K, A>.combine(other: Map<K, A>, combine: (A, A) -> A): Map<K, A>

Combines two maps using combine to combine values for the same key.

fun <A, B> Either<A, B>.combine(other: Either<A, B>, combineLeft: (A, A) -> A, combineRight: (B, B) -> B): Either<A, B>

Combine two Either values. If both are Right then combine both B values using combineRight or if both are Left then combine both A values using combineLeft, otherwise it returns the this or fallbacks to other in case this is Left.

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

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>

@JvmName(name = "crosswalkT")

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

crosswalkMap

fun <A, K, V> Iterable<A>.crosswalkMap(f: (A) -> Map<K, V>): Map<K, List<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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R> suspend (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) -> suspend (P12) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R> suspend (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) -> suspend (P13) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R> suspend (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) -> suspend (P14) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R> suspend (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) -> suspend (P15) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R> suspend (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) -> suspend (P16) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R> suspend (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) -> suspend (P17) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R> suspend (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) -> suspend (P18) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R> suspend (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) -> suspend (P19) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R> suspend (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) -> suspend (P20) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R> suspend (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) -> suspend (P21) -> R

@JvmName(name = "curriedEffect")

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R> suspend (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) -> suspend (P22) -> R

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

@JvmName(name = "curriedEffect")

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

elementAtOrNone

fun <T> Iterable<T>.elementAtOrNone(index: Int): Option<T>

Returns an element as Some at the given index or None if the index is out of bounds of this iterable.

escaped

fun String.escaped(): String

filterIsInstance

inline fun Option<*>.filterIsInstance(): Option

Returns an Option containing all elements that are instances of specified type parameter B.

inline fun <K, R> Map<K, *>.filterIsInstance(): Map<K, R>

Returns a Map containing all elements that are instances of specified type parameter R.

filterOption

fun <T> Iterable<Option<T>>.filterOption(): List<T>

fun <K, A> Map<K, Option<A>>.filterOption(): Map<K, A>

fun <A> Sequence<Option<A>>.filterOption(): Sequence<A>

Filters out all elements that are None, and unwraps the remaining elements Some values.

firstOrNone

fun <T> Iterable<T>.firstOrNone(): Option<T>

Returns the first element as Some, or None if the iterable is empty.

inline fun <T> Iterable<T>.firstOrNone(predicate: (T) -> Boolean): Option<T>

Returns the first element as Some matching the given predicate, or None if element was not found.

flatMap

inline fun <A, B, C> Either<A, B>.flatMap(f: (right: B) -> Either<A, C>): Either<A, C>

Map, or transform, the right value B of this Either into a new Either with a right value of type C. Returns a new Either with either the original left value of type A or the newly transformed right value of type C.

inline fun <A, B> Result<A>.flatMap(transform: (value: A) -> Result): Result

Compose a transform operation on the success value A into B whilst flattening Result.

fun <K, A, B> Map<K, A>.flatMap(f: (Map.Entry<K, A>) -> Map<K, B>): Map<K, B>

Transform every Map.Entry of the original Map using f, only keeping the Map.Entry of the transformed map that match the input Map.Entry.

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

Binds the given function across Ior.Right.

flatten

fun <A, B> Either<A, Either<A, B>>.flatten(): Either<A, B>

fun <A> NonEmptyList<NonEmptyList<A>>.flatten(): NonEmptyList<A>

fun <A> Option<Option<A>>.flatten(): Option<A>

fun <A> Iterable<Iterable<A>>.flatten(): List<A>

fun <A> Sequence<Sequence<A>>.flatten(): Sequence<A>

inline fun <A, B> Ior<A, Ior<A, B>>.flatten(combine: (A, A) -> A): Ior<A, B>

flattenOption

fun <T> Iterable<Option<T>>.flattenOption(): List<T>

flattenOrAccumulate

fun <Error, A> Iterable<Either<Error, A>>.flattenOrAccumulate(): Either<NonEmptyList<Error>, List<A>>

Flatten an Iterable of Either. Alias for mapOrAccumulate over an Iterable of computed Either. Either returns a List containing all Either.Right values, or a NonEmptyList of all Either.Left values.

@JvmName(name = "flattenNelOrAccumulate")

fun <Error, A> Iterable<EitherNel<Error, A>>.flattenOrAccumulate(): Either<NonEmptyList<Error>, List<A>>

Flatten an Iterable of Either. Alias for mapOrAccumulate over an Iterable of computed Either. Either returns a List containing all Either.Right values, or a NonEmptyList of all EitherNel values.

inline fun <Error, A> Iterable<Either<Error, A>>.flattenOrAccumulate(combine: (Error, Error) -> Error): Either<Error, List<A>>

Flatten an Iterable of Either. Alias for mapOrAccumulate over an Iterable of computed Either. Either returns a List containing all Either.Right values, or Either.Left values accumulated using combine.

@JvmName(name = "flattenNelOrAccumulate")

fun <Error, A> Iterable<EitherNel<Error, A>>.flattenOrAccumulate(combine: (Error, Error) -> Error): Either<Error, List<A>>

Flatten an Iterable of Either. Alias for mapOrAccumulate over an Iterable of computed Either. Either returns a List containing all Either.Right values, or EitherNel values accumulated using combine.

fold

inline fun <K, A, B> Map<K, A>.fold(initial: B, operation: (acc: B, Map.Entry<K, A>) -> B): B

foldLeft

fun <A, B, C> SortedMap<A, B>.foldLeft(b: SortedMap<A, C>, f: (SortedMap<A, C>, Map.Entry<A, B>) -> SortedMap<A, C>): SortedMap<A, C>

getOrElse

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

Get the right value B of this Either, or compute a default value with the left value A.

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

inline fun <T> Option<T>.getOrElse(default: () -> T): T

Returns the option's value if the option is nonempty, otherwise return the result of evaluating default.

getOrNone

fun <K, V> Map<K, V>.getOrNone(key: K): Option<V>

identity

inline fun <A> identity(a: A): A

interleave

fun <A> Iterable<A>.interleave(other: Iterable<A>): List<A>

Interleaves the elements of this Iterable with those of other. Elements of this and other are taken in turn, and the resulting list is the concatenation of the interleaved elements. If one Iterable is longer than the other, the remaining elements are appended to the end.

fun <A> Sequence<A>.interleave(other: Sequence<A>): Sequence<A>

Interleaves the elements of this Sequence with those of other. Elements of this and other are taken in turn, and the resulting list is the concatenation of the interleaved elements. If one Sequence is longer than the other, the remaining elements are appended to the end.

iterateRight

fun <A, B> Iterator<A>.iterateRight(lb: Eval, f: (A, Eval) -> Eval): Eval

lastOrNone

fun <T> Iterable<T>.lastOrNone(): Option<T>

Returns the last element as Some, or None if the iterable is empty.

inline fun <T> Iterable<T>.lastOrNone(predicate: (T) -> Boolean): Option<T>

Returns the last element as Some matching the given predicate, or None if no such element was found.

left

fun <A> A.left(): Either<A, Nothing>

leftIor

fun <A> A.leftIor(): Ior<A, Nothing>

leftNel

fun <E> E.leftNel(): EitherNel<E, Nothing>

leftPadZip

fun <A, B> Iterable<A>.leftPadZip(other: Iterable): List<Pair<A?, B>>

Returns a List containing the zipped values of the two lists with null for padding on the left.

fun <A, B> Sequence<A>.leftPadZip(other: Sequence): Sequence<Pair<A?, B>>

Returns a Sequence> containing the zipped values of the two sequences with null for padding on the left.

inline fun <A, B, C> Iterable<A>.leftPadZip(other: Iterable, fab: (A?, B) -> C): List<C>

Returns a List containing the result of applying some transformation (A?, B) -> C on a zip, excluding all cases where the right value is null.

fun <A, B, C> Sequence<A>.leftPadZip(other: Sequence, fab: (A?, B) -> C): Sequence<C>

Returns a Sequence containing the result of applying some transformation (A?, B) -> C on a zip, excluding all cases where the right value is null.

leftWiden

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

many

fun <A> Sequence<A>.many(): Sequence<Sequence<A>>

mapNotNull

fun <K, A, B> Map<K, A>.mapNotNull(transform: (Map.Entry<K, A>) -> B?): Map<K, B>

mapNullable

fun <T : Any> Predicate<T>.mapNullable(): (T?) -> Boolean

mapOrAccumulate

inline fun <E, A, B> NonEmptyList<A>.mapOrAccumulate(transform: RaiseAccumulate<E>.(A) -> B): Either<NonEmptyList<E>, NonEmptyList>

inline fun <K, E, A, B> Map<K, A>.mapOrAccumulate(transform: RaiseAccumulate<E>.(Map.Entry<K, A>) -> B): Either<NonEmptyList<E>, Map<K, B>>

fun <Error, A, B> Sequence<A>.mapOrAccumulate(transform: RaiseAccumulate<Error>.(A) -> B): Either<NonEmptyList<Error>, List>

inline fun <E, A, B> NonEmptyList<A>.mapOrAccumulate(combine: (E, E) -> E, transform: RaiseAccumulate<E>.(A) -> B): Either<E, NonEmptyList>

inline fun <K, E, A, B> Map<K, A>.mapOrAccumulate(combine: (E, E) -> E, transform: RaiseAccumulate<E>.(Map.Entry<K, A>) -> B): Either<E, Map<K, B>>

fun <Error, A, B> Sequence<A>.mapOrAccumulate(combine: (Error, Error) -> Error, transform: RaiseAccumulate<Error>.(A) -> B): Either<Error, List>

inline fun <Error, A, B> Iterable<A>.mapOrAccumulate(transform: RaiseAccumulate<Error>.(A) -> B): Either<NonEmptyList<Error>, List>

Returns Either a List containing the results of applying the given transform function to each element in the original collection, or accumulate all the logical errors into a NonEmptyList that were raised while applying the transform function.

inline fun <Error, A, B> Iterable<A>.mapOrAccumulate(combine: (Error, Error) -> Error, transform: RaiseAccumulate<Error>.(A) -> B): Either<Error, List>

Returns Either a List containing the results of applying the given transform function to each element in the original collection, or accumulate all the logical errors that were raised while transforming the collection using the combine function is used to accumulate all the logical errors.

max

inline fun <T : Comparable<T>> NonEmptyList<T>.max(): T

maxBy

inline fun <A, B : Comparable> NonEmptyList<A>.maxBy(selector: (A) -> B): A

memoize

fun <R> () -> R.memoize(): () -> R

Memoizes the given pure function so that invocations with the same arguments will only execute the function once.

fun <P1, R> (P1) -> R.memoize(): (P1) -> R

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

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

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

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

MemoizedDeepRecursiveFunction

fun <T, R> MemoizedDeepRecursiveFunction(block: suspend DeepRecursiveScope<T, R>.(T) -> R): DeepRecursiveFunction<T, R>

Defines a recursive pure function that:

merge

inline fun <A> Either<A, A>.merge(): A

Returns the value from this Right or Left.

min

inline fun <T : Comparable<T>> NonEmptyList<T>.min(): T

minBy

inline fun <A, B : Comparable> NonEmptyList<A>.minBy(selector: (A) -> B): A

nel

inline fun <A> A.nel(): NonEmptyList<A>

none

fun <A> none(): Option<A>

nonEmptyListOf

fun <A> nonEmptyListOf(head: A, vararg t: A): NonEmptyList<A>

nonEmptySetOf

fun <A> nonEmptySetOf(first: A, vararg rest: A): NonEmptySet<A>

NonFatal

expect fun NonFatal(t: Throwable): Boolean

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.

actual fun NonFatal(t: Throwable): Boolean

nonFatalOrThrow

fun Throwable.nonFatalOrThrow(): Throwable

Returns the Throwable if NonFatal and throws it otherwise.

once

fun <A> Sequence<A>.once(): Sequence<A>

padZip

fun <A, B> Iterable<A>.padZip(other: Iterable): List<Pair<A?, B?>>

Returns a List containing the zipped values of the two lists with null for padding.

fun <K, A, B> Map<K, A>.padZip(other: Map<K, B>): Map<K, Pair<A?, B?>>

Align two structures as in zip, but filling in blanks with null.

fun <A, B> Sequence<A>.padZip(other: Sequence): Sequence<Pair<A?, B?>>

Returns a Sequence> containing the zipped values of the two sequences with null for padding.

inline fun <A, B, C> Iterable<A>.padZip(other: Iterable, fa: (A?, B?) -> C): List<C>

Returns a List containing the result of applying some transformation (A?, B?) -> C on a zip.

fun <K, A, B, C> Map<K, A>.padZip(other: Map<K, B>, fa: (K, A?, B?) -> C): Map<K, C>

inline fun <A, B, C> Iterable<A>.padZip(other: Iterable, left: (A) -> C, right: (B) -> C, both: (A, B) -> C): List<C>

inline fun <K, A, B, C> Map<K, A>.padZip(other: Map<K, B>, left: (K, A) -> C, right: (K, B) -> C, both: (K, A, B) -> C): Map<K, C>

fun <A, B, C> Sequence<A>.padZip(other: Sequence, fa: (A?, B?) -> C): Sequence<C>

Returns a Sequence containing the result of applying some transformation (A?, B?) -> C on a zip.

partially1

fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: P1): (P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R

fun <P1, R> (P1) -> R.partially1(p1: P1): () -> 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: 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.partially1(p1: P1): (P2) -> R

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

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

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

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

fun <P1, P2, P3, P4, P5, P6, P7, R> (P1, P2, P3, P4, P5, P6, P7) -> R.partially1(p1: 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.partially1(p1: 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.partially1(p1: P1): (P2, P3, P4, P5, P6, P7, P8, P9) -> R