tursom/TursomServer
0
0
Fork 0
mirror of https://github.com/tursom/TursomServer.git synced 2025-03-14 03:40:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

update curry

Browse Source
This commit is contained in:
tursom 2021-10-21 09:22:41 +08:00
parent 8c1f8d3d25
commit 0a6cdbbec3
5 changed files with 1145 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ts-core/src/main/kotlin/cn/tursom/core/Tools.kt
View File

@ -622,3 +622,10 @@ fun ByteArray.deflate(): ByteArray {
fun StringBuilder.removeLastChars(count: Int) {
setLength(length - count)
}
inline operator fun <reified T> Array<out T>.plus(other: Array<out T>): Array<T> {
val array = arrayOfNulls<T>(size + other.size)
System.arraycopy(this, 0, array, 0, size)
System.arraycopy(other, 0, array, size, other.size)
return array.uncheckedCast()
}

142
ts-core/ts-curry/src/main/kotlin/cn/tursom/core/curry/VarargCurrying.kt Normal file
View File

@ -0,0 +1,142 @@
@file:Suppress("unused")
package cn.tursom.core.curry
import cn.tursom.core.allMethods
import cn.tursom.core.plus
import cn.tursom.core.uncheckedCast
class VarargCurrying<A, R>(
private val func: (Array<out A>) -> R,
private val args: Array<out Any?>,
private val componentType: Class<A>
) {
companion object {
inline operator fun <reified A, R> invoke(noinline func: (Array<out A>) -> R) =
VarargCurrying(func, A::class.java)
inline operator fun <reified A, R> invoke(noinline func: (Array<out A>) -> R, args: Array<out Any?>) =
VarargCurrying(func, args, A::class.java)
}
constructor(
func: (Array<out A>) -> R, componentType: Class<A> = func.javaClass.allMethods.find {
it.name == "invoke" &&
it.parameterTypes.size == 1 &&
it.parameterTypes[0].isArray
}!!.parameters[0].type.componentType.uncheckedCast()
) : this(func, emptyArray(), componentType)
operator fun invoke(): R = if (componentType == Any::class.java) {
func(args.uncheckedCast())
} else {
val componentArgs = java.lang.reflect.Array.newInstance(componentType, args.size)
System.arraycopy(args, 0, componentArgs, 0, args.size)
func(componentArgs.uncheckedCast())
}
operator fun invoke(vararg args: A) = VarargCurrying(func, this.args + args, componentType)
}
class BooleanVarargCurrying<R>(
private val func: (BooleanArray) -> R,
private val args: BooleanArray
) {
constructor(func: (BooleanArray) -> R) : this(func, booleanArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Boolean) = BooleanVarargCurrying(func, this.args + args)
}
class CharVarargCurrying<R>(
private val func: (CharArray) -> R,
private val args: CharArray
) {
constructor(func: (CharArray) -> R) : this(func, charArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Char) = CharVarargCurrying(func, this.args + args)
}
class ByteVarargCurrying<R>(
private val func: (ByteArray) -> R,
private val args: ByteArray
) {
constructor(func: (ByteArray) -> R) : this(func, byteArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Byte) = ByteVarargCurrying(func, this.args + args)
}
class ShortVarargCurrying<R>(
private val func: (ShortArray) -> R,
private val args: ShortArray
) {
constructor(func: (ShortArray) -> R) : this(func, shortArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Short) = ShortVarargCurrying(func, this.args + args)
}
class IntVarargCurrying<R>(
private val func: (IntArray) -> R,
private val args: IntArray
) {
constructor(func: (IntArray) -> R) : this(func, intArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Int) = IntVarargCurrying(func, this.args + args)
}
class LongVarargCurrying<R>(
private val func: (LongArray) -> R,
private val args: LongArray
) {
constructor(func: (LongArray) -> R) : this(func, longArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Long) = LongVarargCurrying(func, this.args + args)
}
class FloatVarargCurrying<R>(
private val func: (FloatArray) -> R,
private val args: FloatArray
) {
constructor(func: (FloatArray) -> R) : this(func, floatArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Float) = FloatVarargCurrying(func, this.args + args)
}
class DoubleVarargCurrying<R>(
private val func: (DoubleArray) -> R,
private val args: DoubleArray
) {
constructor(func: (DoubleArray) -> R) : this(func, doubleArrayOf())
operator fun invoke() = func(args)
operator fun invoke(vararg args: Double) = DoubleVarargCurrying(func, this.args + args)
}
inline fun <reified T, R> ((Array<out T>) -> R).currying() = VarargCurrying(this)
fun <R> ((BooleanArray) -> R).currying() = BooleanVarargCurrying(this)
fun <R> ((CharArray) -> R).currying() = CharVarargCurrying(this)
fun <R> ((ByteArray) -> R).currying() = ByteVarargCurrying(this)
fun <R> ((ShortArray) -> R).currying() = ShortVarargCurrying(this)
fun <R> ((IntArray) -> R).currying() = IntVarargCurrying(this)
fun <R> ((LongArray) -> R).currying() = LongVarargCurrying(this)
fun <R> ((FloatArray) -> R).currying() = FloatVarargCurrying(this)
fun <R> ((DoubleArray) -> R).currying() = DoubleVarargCurrying(this)
inline fun <reified T, R> ((Array<out T>) -> R).currying(vararg args: T) = VarargCurrying(this, args)
fun <R> ((BooleanArray) -> R).currying(vararg args: Boolean) = BooleanVarargCurrying(this, args)
fun <R> ((CharArray) -> R).currying(vararg args: Char) = CharVarargCurrying(this, args)
fun <R> ((ByteArray) -> R).currying(vararg args: Byte) = ByteVarargCurrying(this, args)
fun <R> ((ShortArray) -> R).currying(vararg args: Short) = ShortVarargCurrying(this, args)
fun <R> ((IntArray) -> R).currying(vararg args: Int) = IntVarargCurrying(this, args)
fun <R> ((LongArray) -> R).currying(vararg args: Long) = LongVarargCurrying(this, args)
fun <R> ((FloatArray) -> R).currying(vararg args: Float) = FloatVarargCurrying(this, args)
fun <R> ((DoubleArray) -> R).currying(vararg args: Double) = DoubleVarargCurrying(this, args)

0
ts-core/ts-curry/src/main/kotlin/cn/tursom/core/curry/MethodInvokeExtension.kt → ts-core/ts-curry/src/main/kotlin/cn/tursom/core/curry/currying.kt
View File

742
ts-core/ts-curry/src/main/kotlin/cn/tursom/core/curry/curyingMethod.kt Normal file
View File

@ -0,0 +1,742 @@
package cn.tursom.core.curry
fun <T1, T2, R> ((T1, T2) -> R).currying() = { a1: T1 -> { a2: T2 -> this(a1, a2) } }
fun <T1, T2, T3, R> ((T1, T2, T3) -> R).currying() = { a1: T1 -> { a2: T2 -> { a3: T3 -> this(a1, a2, a3) } } }
fun <T1, T2, T3, T4, R> ((T1, T2, T3, T4) -> R).currying() =
{ a1: T1 -> { a2: T2 -> { a3: T3 -> { a4: T4 -> this(a1, a2, a3, a4) } } } }
fun <T1, T2, T3, T4, T5, R> ((T1, T2, T3, T4, T5) -> R).currying() =
{ a1: T1 -> { a2: T2 -> { a3: T3 -> { a4: T4 -> { a5: T5 -> this(a1, a2, a3, a4, a5) } } } } }
fun <T1, T2, T3, T4, T5, T6, R> ((T1, T2, T3, T4, T5, T6) -> R).currying() =
{ a1: T1 -> { a2: T2 -> { a3: T3 -> { a4: T4 -> { a5: T5 -> { a6: T6 -> this(a1, a2, a3, a4, a5, a6) } } } } } }
fun <T1, T2, T3, T4, T5, T6, T7, R> ((T1, T2, T3, T4, T5, T6, T7) -> R).currying() = { a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7
)
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, R> ((T1, T2, T3, T4, T5, T6, T7, T8) -> R).currying() = { a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8
)
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R).currying() = { a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9
)
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10
)
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11
)
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12
)
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13
)
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
{ a15: T15 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
{ a15: T15 ->
{ a16: T16 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
{ a15: T15 ->
{ a16: T16 ->
{ a17: T17 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
{ a15: T15 ->
{ a16: T16 ->
{ a17: T17 ->
{ a18: T18 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
{ a15: T15 ->
{ a16: T16 ->
{ a17: T17 ->
{ a18: T18 ->
{ a19: T19 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R).currying() =
{ a1: T1 ->
{ a2: T2 ->
{ a3: T3 ->
{ a4: T4 ->
{ a5: T5 ->
{ a6: T6 ->
{ a7: T7 ->
{ a8: T8 ->
{ a9: T9 ->
{ a10: T10 ->
{ a11: T11 ->
{ a12: T12 ->
{ a13: T13 ->
{ a14: T14 ->
{ a15: T15 ->
{ a16: T16 ->
{ a17: T17 ->
{ a18: T18 ->
{ a19: T19 ->
{ a20: T20 ->
this(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20
)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
@JvmName("curryingVararg")
inline fun <reified T1, T2, R> ((Array<out T1>, T2) -> R).currying(vararg args: T1) =
currying<Array<out T1>, T2, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, R> ((Array<out T1>, T2, T3) -> R).currying(vararg args: T1) =
currying<Array<out T1>, T2, T3, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, R> ((Array<out T1>, T2, T3, T4) -> R).currying(vararg args: T1) =
currying<Array<out T1>, T2, T3, T4, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, R> ((Array<out T1>, T2, T3, T4, T5) -> R).currying(vararg args: T1) =
currying<Array<out T1>, T2, T3, T4, T5, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, R> ((Array<out T1>, T2, T3, T4, T5, T6) -> R).currying(vararg args: T1) =
currying<Array<out T1>, T2, T3, T4, T5, T6, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7) -> R).currying(vararg args: T1) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>().currying(args = args)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>().currying(
args = args
)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>().currying(
args = args
)
@JvmName("curryingVararg")
inline fun <reified T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> ((Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R).currying(
vararg args: T1
) =
currying<Array<out T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>().currying(
args = args
)

254
ts-core/ts-curry/src/main/kotlin/cn/tursom/core/curry/uncurrying.kt Normal file
View File

@ -0,0 +1,254 @@
package cn.tursom.core.curry
operator fun <T1, T2, R> ((T1) -> (T2) -> R).invoke(a1: T1, a2: T2) = this(a1)(a2)
operator fun <T1, T2, T3, R> ((T1) -> (T2) -> (T3) -> R).invoke(a1: T1, a2: T2, a3: T3) = this(a1)(a2)(a3)
operator fun <T1, T2, T3, T4, R> ((T1) -> (T2) -> (T3) -> (T4) -> R).invoke(a1: T1, a2: T2, a3: T3, a4: T4) =
this(a1)(a2)(a3)(a4)
operator fun <T1, T2, T3, T4, T5, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5
) = this(a1)(a2)(a3)(a4)(a5)
operator fun <T1, T2, T3, T4, T5, T6, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6
) = this(a1)(a2)(a3)(a4)(a5)(a6)
operator fun <T1, T2, T3, T4, T5, T6, T7, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> (T15) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14,
a15: T15
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)(a15)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> (T15) -> (T16) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14,
a15: T15,
a16: T16
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)(a15)(a16)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> (T15) -> (T16) -> (T17) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14,
a15: T15,
a16: T16,
a17: T17
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)(a15)(a16)(a17)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> (T15) -> (T16) -> (T17) -> (T18) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14,
a15: T15,
a16: T16,
a17: T17,
a18: T18
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)(a15)(a16)(a17)(a18)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> (T15) -> (T16) -> (T17) -> (T18) -> (T19) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14,
a15: T15,
a16: T16,
a17: T17,
a18: T18,
a19: T19
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)(a15)(a16)(a17)(a18)(a19)
operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> ((T1) -> (T2) -> (T3) -> (T4) -> (T5) -> (T6) -> (T7) -> (T8) -> (T9) -> (T10) -> (T11) -> (T12) -> (T13) -> (T14) -> (T15) -> (T16) -> (T17) -> (T18) -> (T19) -> (T20) -> R).invoke(
a1: T1,
a2: T2,
a3: T3,
a4: T4,
a5: T5,
a6: T6,
a7: T7,
a8: T8,
a9: T9,
a10: T10,
a11: T11,
a12: T12,
a13: T13,
a14: T14,
a15: T15,
a16: T16,
a17: T17,
a18: T18,
a19: T19,
a20: T20
) = this(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(a10)(a11)(a12)(a13)(a14)(a15)(a16)(a17)(a18)(a19)(a20)