kotlin-spark-api_3.3.2_2.13/org.jetbrains.kotlinx.spark.api

Package-level declarations

Types

Link copied to clipboard
class Aggregator<IN, BUF, OUT>(    zero: () -> BUF,     reduce: (b: BUF, a: IN) -> BUF,     merge: (b1: BUF, b2: BUF) -> BUF,     finish: (reduction: BUF) -> OUT,     bufferEncoder: Encoder<BUF>,     outputEncoder: Encoder<OUT>) : Aggregator<IN, BUF, OUT> , Serializable
Link copied to clipboard
data class Arity1<T1>(val _1: T1) : Serializable
Link copied to clipboard
data class Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10) : Serializable
Link copied to clipboard
data class Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11) : Serializable
Link copied to clipboard
data class Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12) : Serializable
Link copied to clipboard
data class Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13) : Serializable
Link copied to clipboard
data class Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14) : Serializable
Link copied to clipboard
data class Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15) : Serializable
Link copied to clipboard
data class Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16) : Serializable
Link copied to clipboard
data class Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17) : Serializable
Link copied to clipboard
data class Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18) : Serializable
Link copied to clipboard
data class Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19) : Serializable
Link copied to clipboard
data class Arity2<T1, T2>(val _1: T1, val _2: T2) : Serializable
Link copied to clipboard
data class Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20) : Serializable
Link copied to clipboard
data class Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20,     val _21: T21) : Serializable
Link copied to clipboard
data class Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20,     val _21: T21,     val _22: T22) : Serializable
Link copied to clipboard
data class Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20,     val _21: T21,     val _22: T22,     val _23: T23) : Serializable
Link copied to clipboard
data class Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20,     val _21: T21,     val _22: T22,     val _23: T23,     val _24: T24) : Serializable
Link copied to clipboard
data class Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20,     val _21: T21,     val _22: T22,     val _23: T23,     val _24: T24,     val _25: T25) : Serializable
Link copied to clipboard
data class Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9,     val _10: T10,     val _11: T11,     val _12: T12,     val _13: T13,     val _14: T14,     val _15: T15,     val _16: T16,     val _17: T17,     val _18: T18,     val _19: T19,     val _20: T20,     val _21: T21,     val _22: T22,     val _23: T23,     val _24: T24,     val _25: T25,     val _26: T26) : Serializable
Link copied to clipboard
data class Arity3<T1, T2, T3>(val _1: T1, val _2: T2, val _3: T3) : Serializable
Link copied to clipboard
data class Arity4<T1, T2, T3, T4>(val _1: T1, val _2: T2, val _3: T3, val _4: T4) : Serializable
Link copied to clipboard
data class Arity5<T1, T2, T3, T4, T5>(val _1: T1, val _2: T2, val _3: T3, val _4: T4, val _5: T5) : Serializable
Link copied to clipboard
data class Arity6<T1, T2, T3, T4, T5, T6>(val _1: T1, val _2: T2, val _3: T3, val _4: T4, val _5: T5, val _6: T6) : Serializable
Link copied to clipboard
data class Arity7<T1, T2, T3, T4, T5, T6, T7>(val _1: T1, val _2: T2, val _3: T3, val _4: T4, val _5: T5, val _6: T6, val _7: T7) : Serializable
Link copied to clipboard
data class Arity8<T1, T2, T3, T4, T5, T6, T7, T8>(val _1: T1, val _2: T2, val _3: T3, val _4: T4, val _5: T5, val _6: T6, val _7: T7, val _8: T8) : Serializable
Link copied to clipboard
data class Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(    val _1: T1,     val _2: T2,     val _3: T3,     val _4: T4,     val _5: T5,     val _6: T6,     val _7: T7,     val _8: T8,     val _9: T9) : Serializable
Link copied to clipboard
class FilteringIterator<T>(source: Iterator<T>, predicate: (T) -> Boolean) : AbstractIterator<T>

Filters the values of the iterator lazily using predicate.

Link copied to clipboard
class KSparkSession(val spark: SparkSession)

This wrapper over SparkSession which provides several additional methods to create org.apache.spark.sql.Dataset.

Link copied to clipboard
class KSparkStreamingSession(val ssc: JavaStreamingContext) : Serializable

This wrapper over SparkSession and JavaStreamingContext provides several additional methods to create org.apache.spark.sql.Dataset

Link copied to clipboard
class MappingIterator<T, R>(source: Iterator<T>, func: (T) -> R) : AbstractIterator<R>

Maps the values of the iterator lazily using func.

Link copied to clipboard
interface NamedUserDefinedFunction<Return, This> : UserDefinedFunction<Return, This>

Typed and named wrapper around SparkUserDefinedFunction with defined encoder.

Link copied to clipboard
class NamedUserDefinedFunction0<R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction0<R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction0<R>>

Instance of a UDF with 0 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction1<T1, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction1<T1, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction1<T1, R>>

Instance of a UDF with 1 argument with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>>

Instance of a UDF with 10 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>>

Instance of a UDF with 11 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>>

Instance of a UDF with 12 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>>

Instance of a UDF with 13 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>>

Instance of a UDF with 14 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>>

Instance of a UDF with 15 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>>

Instance of a UDF with 16 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>>

Instance of a UDF with 17 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>>

Instance of a UDF with 18 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>>

Instance of a UDF with 19 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction2<T1, T2, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction2<T1, T2, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction2<T1, T2, R>>

Instance of a UDF with 2 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>>

Instance of a UDF with 20 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>>

Instance of a UDF with 21 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>>

Instance of a UDF with 22 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction3<T1, T2, T3, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction3<T1, T2, T3, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction3<T1, T2, T3, R>>

Instance of a UDF with 3 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction4<T1, T2, T3, T4, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction4<T1, T2, T3, T4, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction4<T1, T2, T3, T4, R>>

Instance of a UDF with 4 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction5<T1, T2, T3, T4, T5, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>>

Instance of a UDF with 5 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction6<T1, T2, T3, T4, T5, T6, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>>

Instance of a UDF with 6 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>>

Instance of a UDF with 7 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>>

Instance of a UDF with 8 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>>

Instance of a UDF with 9 arguments with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class NamedUserDefinedFunctionVararg<T, R>(    val name: String,     udf: UserDefinedFunction,     encoder: Encoder<R>) : UserDefinedFunctionVararg<T, R> , NamedUserDefinedFunction<R, NamedUserDefinedFunctionVararg<T, R>>

Instance of a UDF with vararg arguments of the same type with name. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
class PartitioningIterator<T>(source: Iterator<T>, size: Int, cutIncomplete: Boolean = false) : AbstractIterator<List<T>>

Partitions the values of the iterator lazily in groups of size.

Link copied to clipboard
enum SparkLogLevel : Enum<SparkLogLevel>

Log levels for spark.

Link copied to clipboard
typealias SparkSession = org.apache.spark.sql.SparkSession

The entry point to programming Spark with the Dataset and DataFrame API.

Link copied to clipboard
class TypeOfUDFParameterNotSupportedException(kClass: KClass<*>, parameterName: String) : IllegalArgumentException

An exception thrown when the UDF is generated with illegal types for the parameters

Link copied to clipboard
fun interface UDF0<R> : UDF0<R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF1<T1, R> : UDF1<T1, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> : UDF10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> : UDF11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> : UDF12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> : UDF13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> : UDF14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> : UDF15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> : UDF16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> : UDF17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> : UDF18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> : UDF19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF2<T1, T2, R> : UDF2<T1, T2, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> : UDF20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> : UDF21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> : UDF22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF3<T1, T2, T3, R> : UDF3<T1, T2, T3, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF4<T1, T2, T3, T4, R> : UDF4<T1, T2, T3, T4, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF5<T1, T2, T3, T4, T5, R> : UDF5<T1, T2, T3, T4, T5, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF6<T1, T2, T3, T4, T5, T6, R> : UDF6<T1, T2, T3, T4, T5, T6, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF7<T1, T2, T3, T4, T5, T6, T7, R> : UDF7<T1, T2, T3, T4, T5, T6, T7, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF8<T1, T2, T3, T4, T5, T6, T7, T8, R> : UDF8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
fun interface UDF9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> : UDF9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Kotlin wrapper around UDF interface to ensure nullability in types.

Link copied to clipboard
class UDFWrapper0(udfName: String)

A wrapper for a UDF with 0 arguments.

Link copied to clipboard
class UDFWrapper1(udfName: String)

A wrapper for a UDF with 1 arguments.

Link copied to clipboard
class UDFWrapper10(udfName: String)

A wrapper for a UDF with 10 arguments.

Link copied to clipboard
class UDFWrapper11(udfName: String)

A wrapper for a UDF with 11 arguments.

Link copied to clipboard
class UDFWrapper12(udfName: String)

A wrapper for a UDF with 12 arguments.

Link copied to clipboard
class UDFWrapper13(udfName: String)

A wrapper for a UDF with 13 arguments.

Link copied to clipboard
class UDFWrapper14(udfName: String)

A wrapper for a UDF with 14 arguments.

Link copied to clipboard
class UDFWrapper15(udfName: String)

A wrapper for a UDF with 15 arguments.

Link copied to clipboard
class UDFWrapper16(udfName: String)

A wrapper for a UDF with 16 arguments.

Link copied to clipboard
class UDFWrapper17(udfName: String)

A wrapper for a UDF with 17 arguments.

Link copied to clipboard
class UDFWrapper18(udfName: String)

A wrapper for a UDF with 18 arguments.

Link copied to clipboard
class UDFWrapper19(udfName: String)

A wrapper for a UDF with 19 arguments.

Link copied to clipboard
class UDFWrapper2(udfName: String)

A wrapper for a UDF with 2 arguments.

Link copied to clipboard
class UDFWrapper20(udfName: String)

A wrapper for a UDF with 20 arguments.

Link copied to clipboard
class UDFWrapper21(udfName: String)

A wrapper for a UDF with 21 arguments.

Link copied to clipboard
class UDFWrapper22(udfName: String)

A wrapper for a UDF with 22 arguments.

Link copied to clipboard
class UDFWrapper3(udfName: String)

A wrapper for a UDF with 3 arguments.

Link copied to clipboard
class UDFWrapper4(udfName: String)

A wrapper for a UDF with 4 arguments.

Link copied to clipboard
class UDFWrapper5(udfName: String)

A wrapper for a UDF with 5 arguments.

Link copied to clipboard
class UDFWrapper6(udfName: String)

A wrapper for a UDF with 6 arguments.

Link copied to clipboard
class UDFWrapper7(udfName: String)

A wrapper for a UDF with 7 arguments.

Link copied to clipboard
class UDFWrapper8(udfName: String)

A wrapper for a UDF with 8 arguments.

Link copied to clipboard
class UDFWrapper9(udfName: String)

A wrapper for a UDF with 9 arguments.

Link copied to clipboard
interface UserDefinedFunction<Return, NamedUdf> : Serializable

Typed wrapper around SparkUserDefinedFunction with defined encoder.

Link copied to clipboard
open class UserDefinedFunction0<R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction0<R>>

Instance of a UDF with 0 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction1<T1, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction1<T1, R>>

Instance of a UDF with 1 argument. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>>

Instance of a UDF with 10 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>>

Instance of a UDF with 11 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>>

Instance of a UDF with 12 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>>

Instance of a UDF with 13 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>>

Instance of a UDF with 14 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>>

Instance of a UDF with 15 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>>

Instance of a UDF with 16 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>>

Instance of a UDF with 17 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>>

Instance of a UDF with 18 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>>

Instance of a UDF with 19 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction2<T1, T2, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction2<T1, T2, R>>

Instance of a UDF with 2 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>>

Instance of a UDF with 20 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>>

Instance of a UDF with 21 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>>

Instance of a UDF with 22 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction3<T1, T2, T3, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction3<T1, T2, T3, R>>

Instance of a UDF with 3 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction4<T1, T2, T3, T4, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction4<T1, T2, T3, T4, R>>

Instance of a UDF with 4 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction5<T1, T2, T3, T4, T5, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>>

Instance of a UDF with 5 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>>

Instance of a UDF with 6 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>>

Instance of a UDF with 7 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>>

Instance of a UDF with 8 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>>

Instance of a UDF with 9 arguments. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Link copied to clipboard
open class UserDefinedFunctionVararg<T, R>(    val udf: UserDefinedFunction,     val encoder: Encoder<R>) : UserDefinedFunction<R, NamedUserDefinedFunctionVararg<T, R>>

Instance of a UDF with vararg arguments of the same type. This UDF can be invoked with (typed) columns in a Dataset.select or selectTyped call. Alternatively it can be registered for SQL calls using register.

Properties

Link copied to clipboard
@JvmField
val ENCODERS: Map<KClass<*>, Encoder<*>>
Link copied to clipboard
val SparkSession.sparkContext: SparkContext

Returns the Spark context associated with this Spark session.

Functions

Link copied to clipboard
infix fun Column.&&(other: Any): Column

Boolean AND.

Link copied to clipboard
infix fun Column.=!=(other: Any): Column

Inequality test.

Link copied to clipboard
infix fun Column.==(c: Column): Column
Link copied to clipboard
infix fun Column.===(other: Any): Column

Equality test.

Link copied to clipboard
fun <K, V, U> JavaRDD<Tuple2<K, V>>.aggregateByKey(zeroValue: U, seqFunc: (U, V) -> U, combFunc: (U, U) -> U): JavaRDD<Tuple2<K, U>>
fun <K, V, U> JavaRDD<Tuple2<K, V>>.aggregateByKey(    zeroValue: U,     numPartitions: Int,     seqFunc: (U, V) -> U,     combFunc: (U, U) -> U): JavaRDD<Tuple2<K, U>>
fun <K, V, U> JavaRDD<Tuple2<K, V>>.aggregateByKey(    zeroValue: U,     partitioner: Partitioner,     seqFunc: (U, V) -> U,     combFunc: (U, U) -> U): JavaRDD<Tuple2<K, U>>

Aggregate the values of each key, using given combine functions and a neutral "zero value". This function can return a different result type, U, than the type of the values in this RDD, V. Thus, we need one operation for merging a V into a U and one operation for merging two U's, as in scala.TraversableOnce. The former operation is used for merging values within a partition, and the latter is used for merging values between partitions. To avoid memory allocation, both of these functions are allowed to modify and return their first argument instead of creating a new U.

Link copied to clipboard
inline fun <IN, BUF, OUT> aggregatorOf(    noinline zero: () -> BUF,     noinline reduce: (b: BUF, a: IN) -> BUF,     noinline merge: (b1: BUF, b2: BUF) -> BUF,     noinline finish: (reduction: BUF) -> OUT,     bufferEncoder: Encoder<BUF> = encoder(),     outputEncoder: Encoder<OUT> = encoder()): Aggregator<IN, BUF, OUT>

Creates an Aggregator in functional manner.

Link copied to clipboard
infix fun Column.and(other: Any): Column

Boolean AND.

Link copied to clipboard
inline fun <DsType, U> Column.as(): TypedColumn<DsType, U>
inline fun <DsType, U> TypedColumn<DsType, *>.as(): TypedColumn<DsType, U>

Provides a type hint about the expected return value of this column. This information can be used by operations such as select on a Dataset to automatically convert the results into the correct JVM types.

inline fun <R> Dataset<*>.as(): Dataset<R>

(Kotlin-specific) Returns a new Dataset where each record has been mapped on to the specified type. The method used to map columns depend on the type of R:

Link copied to clipboard
fun <A> Iterable<A>.asKotlinCollection(): Collection<A>
Link copied to clipboard
fun <A, B> Map<A, B>.asKotlinConcurrentMap(): ConcurrentMap<A, B>
Link copied to clipboard
fun <A, B> Map<A, B>.asKotlinDictionary(): Dictionary<A, B>
Link copied to clipboard
fun <A> Iterator<A>.asKotlinEnumeration(): Enumeration<A>
Link copied to clipboard
fun <A> Iterable<A>.asKotlinIterable(): Iterable<A>
Link copied to clipboard
fun <A> Iterator<A>.asKotlinIterator(): Iterator<A>
Link copied to clipboard
fun <A> Seq<A>.asKotlinList(): List<A>
Link copied to clipboard
fun <A, B> Map<A, B>.asKotlinMap(): Map<A, B>
Link copied to clipboard
Link copied to clipboard
fun <A, B> Map<A, B>.asKotlinMutableMap(): MutableMap<A, B>
Link copied to clipboard
fun <A> Set<A>.asKotlinMutableSet(): MutableSet<A>
Link copied to clipboard
fun <A> Set<A>.asKotlinSet(): Set<A>
Link copied to clipboard
fun <A, B> ConcurrentMap<A, B>.asScalaConcurrentMap(): Map<A, B>
Link copied to clipboard
fun <A> Collection<A>.asScalaIterable(): Iterable<A>
fun <A> Iterable<A>.asScalaIterable(): Iterable<A>
Link copied to clipboard
fun <A> Enumeration<A>.asScalaIterator(): Iterator<A>
fun <A> Iterator<A>.asScalaIterator(): Iterator<A>
Link copied to clipboard
fun <A, B> Dictionary<A, B>.asScalaMap(): Map<A, B>
fun Properties.asScalaMap(): Map<String, String>
fun <A, B> Map<A, B>.asScalaMap(): Map<A, B>
Link copied to clipboard
fun <A> MutableList<A>.asScalaMutableBuffer(): Buffer<A>
Link copied to clipboard
fun <A, B> MutableMap<A, B>.asScalaMutableMap(): Map<A, B>
Link copied to clipboard
fun <A> MutableSet<A>.asScalaMutableSet(): Set<A>
Link copied to clipboard
@JvmName(name = "iterableColumnAsSeq")
fun <DsType, T, I : Iterable<T>> TypedColumn<DsType, I>.asSeq(): TypedColumn<DsType, Seq<T>>
@JvmName(name = "arrayColumnAsSeq")
fun <DsType, T> TypedColumn<DsType, Array<T>>.asSeq(): TypedColumn<DsType, Seq<T>>
@JvmName(name = "booleanArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, BooleanArray>.asSeq(): TypedColumn<DsType, Seq<Boolean>>
@JvmName(name = "byteArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, ByteArray>.asSeq(): TypedColumn<DsType, Seq<Byte>>
@JvmName(name = "charArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, CharArray>.asSeq(): TypedColumn<DsType, Seq<Char>>
@JvmName(name = "doubleArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, DoubleArray>.asSeq(): TypedColumn<DsType, Seq<Double>>
@JvmName(name = "floatArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, FloatArray>.asSeq(): TypedColumn<DsType, Seq<Float>>
@JvmName(name = "intArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, IntArray>.asSeq(): TypedColumn<DsType, Seq<Int>>
@JvmName(name = "longArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, LongArray>.asSeq(): TypedColumn<DsType, Seq<Long>>
@JvmName(name = "shortArrayColumnAsSeq")
fun <DsType> TypedColumn<DsType, ShortArray>.asSeq(): TypedColumn<DsType, Seq<Short>>
Link copied to clipboard
inline fun <T> SparkContext.broadcast(value: T): Broadcast<T>
inline fun <T> SparkSession.broadcast(value: T): Broadcast<T>

Broadcast a read-only variable to the cluster, returning a org.apache.spark.broadcast.Broadcast object for reading it in distributed functions. The variable will be sent to each cluster only once.

Link copied to clipboard
fun <T1> c(_1: T1): Arity1<T1>
fun <T1, T2> c(_1: T1, _2: T2): Arity2<T1, T2>
fun <T1, T2, T3> c(_1: T1, _2: T2, _3: T3): Arity3<T1, T2, T3>
fun <T1, T2, T3, T4> c(_1: T1, _2: T2, _3: T3, _4: T4): Arity4<T1, T2, T3, T4>
fun <T1, T2, T3, T4, T5> c(_1: T1, _2: T2, _3: T3, _4: T4, _5: T5): Arity5<T1, T2, T3, T4, T5>
fun <T1, T2, T3, T4, T5, T6> c(_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6): Arity6<T1, T2, T3, T4, T5, T6>
fun <T1, T2, T3, T4, T5, T6, T7> c(_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7): Arity7<T1, T2, T3, T4, T5, T6, T7>
fun <T1, T2, T3, T4, T5, T6, T7, T8> c(_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> c(_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20,     _21: T21): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20,     _21: T21,     _22: T22): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20,     _21: T21,     _22: T22,     _23: T23): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20,     _21: T21,     _22: T22,     _23: T23,     _24: T24): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20,     _21: T21,     _22: T22,     _23: T23,     _24: T24,     _25: T25): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> c(    _1: T1,     _2: T2,     _3: T3,     _4: T4,     _5: T5,     _6: T6,     _7: T7,     _8: T8,     _9: T9,     _10: T10,     _11: T11,     _12: T12,     _13: T13,     _14: T14,     _15: T15,     _16: T16,     _17: T17,     _18: T18,     _19: T19,     _20: T20,     _21: T21,     _22: T22,     _23: T23,     _24: T24,     _25: T25,     _26: T26): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.cogroup(other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, Tuple2<Iterable<V>, Iterable<W>>>>
fun <K, V, W> JavaRDD<Tuple2<K, V>>.cogroup(    other: JavaRDD<Tuple2<K, W>>,     numPartitions: Int): JavaRDD<Tuple2<K, Tuple2<Iterable<V>, Iterable<W>>>>
fun <K, V, W> JavaRDD<Tuple2<K, V>>.cogroup(    other: JavaRDD<Tuple2<K, W>>,     partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple2<Iterable<V>, Iterable<W>>>>

For each key k in this or other, return a resulting RDD that contains a tuple with the list of values for that key in this as well as other.

fun <K, V, W1, W2> JavaRDD<Tuple2<K, V>>.cogroup(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>): JavaRDD<Tuple2<K, Tuple3<Iterable<V>, Iterable<W1>, Iterable<W2>>>>
fun <K, V, W1, W2> JavaRDD<Tuple2<K, V>>.cogroup(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>,     numPartitions: Int): JavaRDD<Tuple2<K, Tuple3<Iterable<V>, Iterable<W1>, Iterable<W2>>>>
fun <K, V, W1, W2> JavaRDD<Tuple2<K, V>>.cogroup(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>,     partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple3<Iterable<V>, Iterable<W1>, Iterable<W2>>>>

For each key k in this or other1 or other2, return a resulting RDD that contains a tuple with the list of values for that key in this, other1 and other2.

inline fun <K, V, U, R> KeyValueGroupedDataset<K, V>.cogroup(    other: KeyValueGroupedDataset<K, U>,     noinline func: (key: K, left: Iterator<V>, right: Iterator<U>) -> Iterator<R>): Dataset<R>

(Kotlin-specific) Applies the given function to each cogrouped data. For each unique group, the function will be passed the grouping key and 2 iterators containing all elements in the group from Dataset and other. The function can return an iterator containing elements of an arbitrary type which will be returned as a new Dataset.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.cogroup(    other: JavaDStream<Tuple2<K, W>>,     numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Tuple2<Iterable<V>, Iterable<W>>>>

Return a new DStream by applying 'cogroup' between RDDs of this DStream and other DStream. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.cogroup(    other: JavaDStream<Tuple2<K, W>>,     partitioner: Partitioner): JavaDStream<Tuple2<K, Tuple2<Iterable<V>, Iterable<W>>>>

Return a new DStream by applying 'cogroup' between RDDs of this DStream and other DStream. The supplied org.apache.spark.Partitioner is used to partition the generated RDDs.

fun <K, V, W1, W2, W3> JavaRDD<Tuple2<K, V>>.cogroup(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>,     other3: JavaRDD<Tuple2<K, W3>>): JavaRDD<Tuple2<K, Tuple4<Iterable<V>, Iterable<W1>, Iterable<W2>, Iterable<W3>>>>
fun <K, V, W1, W2, W3> JavaRDD<Tuple2<K, V>>.cogroup(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>,     other3: JavaRDD<Tuple2<K, W3>>,     numPartitions: Int): JavaRDD<Tuple2<K, Tuple4<Iterable<V>, Iterable<W1>, Iterable<W2>, Iterable<W3>>>>
fun <K, V, W1, W2, W3> JavaRDD<Tuple2<K, V>>.cogroup(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>,     other3: JavaRDD<Tuple2<K, W3>>,     partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple4<Iterable<V>, Iterable<W1>, Iterable<W2>, Iterable<W3>>>>

For each key k in this or other1 or other2 or other3, return a resulting RDD that contains a tuple with the list of values for that key in this, other1, other2 and other3.

Link copied to clipboard
inline fun <DsType, U> col(colName: String): TypedColumn<DsType, U>

Returns a TypedColumn based on the given column name and type DsType.

fun col(colName: String): Column

Returns a Column based on the given column name.

inline fun <DsType, U> col(column: KProperty1<DsType, U>): TypedColumn<DsType, U>

Returns a Column based on the given class attribute, not connected to a dataset.

Link copied to clipboard
inline fun <T, R> Dataset<T>.col(colName: String): TypedColumn<T, R>

Selects column based on the column name and returns it as a TypedColumn.

inline fun <T, U> Dataset<T>.col(column: KProperty1<T, U>): TypedColumn<T, U>

Helper function to quickly get a TypedColumn (or Column) from a dataset in a refactor-safe manner.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.collectAsMap(): Map<K, V>

Return the key-value pairs in this RDD to the master as a Map.

Link copied to clipboard
fun <K, V, C> JavaRDD<Tuple2<K, V>>.combineByKey(    createCombiner: (V) -> C,     mergeValue: (C, V) -> C,     mergeCombiners: (C, C) -> C): JavaRDD<Tuple2<K, C>>

Simplified version of combineByKeyWithClassTag that hash-partitions the resulting RDD using the existing partitioner/parallelism level. This method is here for backward compatibility. It does not provide combiner classtag information to the shuffle.

fun <K, V, C> JavaRDD<Tuple2<K, V>>.combineByKey(    createCombiner: (V) -> C,     mergeValue: (C, V) -> C,     mergeCombiners: (C, C) -> C,     numPartitions: Int): JavaRDD<Tuple2<K, C>>

Simplified version of combineByKeyWithClassTag that hash-partitions the output RDD. This method is here for backward compatibility. It does not provide combiner classtag information to the shuffle.

fun <K, V, C> JavaDStream<Tuple2<K, V>>.combineByKey(    createCombiner: (V) -> C,     mergeValue: (C, V) -> C,     mergeCombiner: (C, C) -> C,     numPartitions: Int = dstream().ssc().sc().defaultParallelism(),     mapSideCombine: Boolean = true): JavaDStream<Tuple2<K, C>>
fun <K, V, C> JavaDStream<Tuple2<K, V>>.combineByKey(    createCombiner: (V) -> C,     mergeValue: (C, V) -> C,     mergeCombiner: (C, C) -> C,     partitioner: Partitioner,     mapSideCombine: Boolean = true): JavaDStream<Tuple2<K, C>>

Combine elements of each key in DStream's RDDs using custom functions. This is similar to the combineByKey for RDDs. Please refer to combineByKey in org.apache.spark.rdd.PairRDDFunctions in the Spark core documentation for more information.

fun <K, V, C> JavaRDD<Tuple2<K, V>>.combineByKey(    createCombiner: (V) -> C,     mergeValue: (C, V) -> C,     mergeCombiners: (C, C) -> C,     partitioner: Partitioner,     mapSideCombine: Boolean = true,     serializer: Serializer? = null): JavaRDD<Tuple2<K, C>>

Generic function to combine the elements for each key using a custom set of aggregation functions. This method is here for backward compatibility. It does not provide combiner classtag information to the shuffle.

Link copied to clipboard
inline fun <R, T : NamedUserDefinedFunction<R, *>> T.copy(    name: String = this.name,     udf: UserDefinedFunction = this.udf,     encoder: Encoder<R> = this.encoder): T

Copy method for all NamedUserDefinedFunction functions.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.countApproxDistinctByKey(relativeSD: Double): JavaRDD<Tuple2<K, Long>>
fun <K, V> JavaRDD<Tuple2<K, V>>.countApproxDistinctByKey(relativeSD: Double, numPartitions: Int): JavaRDD<Tuple2<K, Long>>
fun <K, V> JavaRDD<Tuple2<K, V>>.countApproxDistinctByKey(relativeSD: Double, partitioner: Partitioner): JavaRDD<Tuple2<K, Long>>

Return approximate number of distinct values for each key in this RDD.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.countByKey(): Map<K, Long>

Count the number of elements for each key, collecting the results to a local Map.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.countByKeyApprox(timeout: Long, confidence: Double = 0.95): PartialResult<Map<K, BoundedDouble>>

Approximate version of countByKey that can return a partial result if it does not finish within a timeout.

Link copied to clipboard
fun <T> Dataset<T>.debug(): Dataset<T>

It's hard to call Dataset.debug from kotlin, so here is utility for that

Link copied to clipboard
fun <T> Dataset<T>.debugCodegen(): Dataset<T>

It's hard to call Dataset.debugCodegen from kotlin, so here is utility for that

Link copied to clipboard
inline fun <T> SparkSession.dfOf(vararg t: T): Dataset<Row>

Utility method to create dataframe from *array or vararg arguments

inline fun <T> SparkSession.dfOf(colNames: Array<String>, vararg t: T): Dataset<Row>

Utility method to create dataframe from *array or vararg arguments with given column names

Link copied to clipboard
operator fun Column.div(other: Any): Column

Division this expression by another expression.

Link copied to clipboard
inline fun <T, R> Dataset<T>.downcast(): Dataset<R>

DEPRECATED: Use as or to for this.

Link copied to clipboard
inline fun <T> SparkSession.dsOf(vararg t: T): Dataset<T>

Utility method to create dataset from *array or vararg arguments

Link copied to clipboard
fun <T> emptyMutableSeq(): Seq<T>

Returns a new mutable Seq with the given elements.

Link copied to clipboard
fun <T> emptySeq(): Seq<T>

Returns a new empty immutable Seq.

Link copied to clipboard
inline fun <T> encoder(): Encoder<T>

Main method of API, which gives you seamless integration with Spark: It creates encoder for any given supported type T

Link copied to clipboard
infix fun Column.eq(other: Any): Column

Equality test.

Link copied to clipboard
fun <T> Iterator<T>.filter(predicate: (T) -> Boolean): Iterator<T>

Filters the values of the iterator lazily using predicate.

Link copied to clipboard
fun <K : Comparable<K>, V> JavaRDD<Tuple2<K, V>>.filterByRange(range: ClosedRange<K>): JavaRDD<Tuple2<K, V>>

Return a RDD containing only the elements in the range range. If the RDD has been partitioned using a RangePartitioner, then this operation can be performed efficiently by only scanning the partitions that might contain matching elements. Otherwise, a standard filter is applied to all partitions.

fun <K, V> JavaRDD<Tuple2<K, V>>.filterByRange(lower: K, upper: K): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.filterByRange(comp: Comparator<K>, lower: K, upper: K): JavaRDD<Tuple2<K, V>>

Return a RDD containing only the elements in the inclusive range lower to upper. If the RDD has been partitioned using a RangePartitioner, then this operation can be performed efficiently by only scanning the partitions that might contain matching elements. Otherwise, a standard filter is applied to all partitions.

fun <K : Comparable<K>, V> JavaRDD<Tuple2<K, V>>.filterByRange(comp: Comparator<K>, range: ClosedRange<K>): JavaRDD<Tuple2<K, V>>

Return a RDD containing only the elements in the inclusive range range. If the RDD has been partitioned using a RangePartitioner, then this operation can be performed efficiently by only scanning the partitions that might contain matching elements. Otherwise, a standard filter is applied to all partitions.

Link copied to clipboard
fun <T : Any> Dataset<T?>.filterNotNull(): Dataset<T>

(Kotlin-specific) Filters rows to eliminate null values.

Link copied to clipboard
inline fun <T, R> Dataset<T>.flatMap(noinline func: (T) -> Iterator<R>): Dataset<R>

(Kotlin-specific) Returns a new Dataset by first applying a function to all elements of this Dataset, and then flattening the results.

Link copied to clipboard
inline fun <K, V, U> KeyValueGroupedDataset<K, V>.flatMapGroups(noinline func: (key: K, values: Iterator<V>) -> Iterator<U>): Dataset<U>

(Kotlin-specific) Applies the given function to each group of data. For each unique group, the function will be passed the group key and an iterator that contains all the elements in the group. The function can return an iterator containing elements of an arbitrary type which will be returned as a new Dataset.

Link copied to clipboard
inline fun <K, V, S, U> KeyValueGroupedDataset<K, V>.flatMapGroupsWithState(    outputMode: OutputMode,     timeoutConf: GroupStateTimeout,     noinline func: (key: K, values: Iterator<V>, state: GroupState<S>) -> Iterator<U>): Dataset<U>

(Kotlin-specific) Applies the given function to each group of data, while maintaining a user-defined per-group state. The result Dataset will represent the objects returned by the function. For a static batch Dataset, the function will be invoked once per group. For a streaming Dataset, the function will be invoked for each group repeatedly in every trigger, and updates to each group's state will be saved across invocations. See GroupState for more details.

Link copied to clipboard
fun <K, V, U> JavaRDD<Tuple2<K, V>>.flatMapValues(f: (V) -> Iterator<U>): JavaRDD<Tuple2<K, U>>

Pass each value in the key-value pair RDD through a flatMap function without changing the keys; this also retains the original RDD's partitioning.

fun <K, V, U> JavaDStream<Tuple2<K, V>>.flatMapValues(flatMapValuesFunc: (V) -> Iterator<U>): JavaDStream<Tuple2<K, U>>

Return a new DStream by applying a flatmap function to the value of each key-value pairs in 'this' DStream without changing the key.

Link copied to clipboard
fun <T> Iterator<Iterator<T>>.flatten(): Iterator<T>

Flattens iterator.

inline fun <T, I : Iterable<T>> Dataset<I>.flatten(): Dataset<T>

(Kotlin-specific) Returns a new Dataset by flattening. This means that a Dataset of an iterable such as listOf(listOf(1, 2, 3), listOf(4, 5, 6)) will be flattened to a Dataset of listOf(1, 2, 3, 4, 5, 6).

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.foldByKey(zeroValue: V, func: (V, V) -> V): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.foldByKey(zeroValue: V, numPartitions: Int, func: (V, V) -> V): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.foldByKey(zeroValue: V, partitioner: Partitioner, func: (V, V) -> V): JavaRDD<Tuple2<K, V>>

Merge the values for each key using an associative function and a neutral "zero value" which may be added to the result an arbitrary number of times, and must not change the result (e.g., emptyList for list concatenation, 0 for addition, or 1 for multiplication.).

Link copied to clipboard
inline fun <T> Dataset<T>.forEach(noinline func: (T) -> Unit)

(Kotlin-specific) Applies a function func to all rows.

Link copied to clipboard
fun <T> DataStreamWriter<T>.forEachBatch(func: (batch: Dataset<T>, batchId: Long) -> Unit): DataStreamWriter<T>

:: Experimental ::

Link copied to clipboard
inline fun <T> Dataset<T>.forEachPartition(noinline func: (Iterator<T>) -> Unit)

(Kotlin-specific) Runs func on each partition of this Dataset.

Link copied to clipboard
inline fun <L, R> Dataset<L>.fullJoin(right: Dataset<R>, col: Column): Dataset<Tuple2<L?, R?>>

Alias for Dataset.joinWith which passes "full" argument and respects the fact that in result of join any element of resulting tuple is nullable

Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.fullOuterJoin(    other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, Tuple2<Optional<V>, Optional<W>>>>

Perform a full outer join of this and other. For each element (k, v) in this, the resulting RDD will either contain all pairs (k, (Some(v), Some(w))) for w in other, or the pair (k, (Some(v), None)) if no elements in other have key k. Similarly, for each element (k, w) in other, the resulting RDD will either contain all pairs (k, (Some(v), Some(w))) for v in this, or the pair (k, (None, Some(w))) if no elements in this have key k. Hash-partitions the resulting RDD using the existing partitioner/ parallelism level.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.fullOuterJoin(    other: JavaRDD<Tuple2<K, W>>,     numPartitions: Int): JavaRDD<Tuple2<K, Tuple2<Optional<V>, Optional<W>>>>

Perform a full outer join of this and other. For each element (k, v) in this, the resulting RDD will either contain all pairs (k, (Some(v), Some(w))) for w in other, or the pair (k, (Some(v), None)) if no elements in other have key k. Similarly, for each element (k, w) in other, the resulting RDD will either contain all pairs (k, (Some(v), Some(w))) for v in this, or the pair (k, (None, Some(w))) if no elements in this have key k. Hash-partitions the resulting RDD into the given number of partitions.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.fullOuterJoin(    other: JavaRDD<Tuple2<K, W>>,     partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple2<Optional<V>, Optional<W>>>>

Perform a full outer join of this and other. For each element (k, v) in this, the resulting RDD will either contain all pairs (k, (Some(v), Some(w))) for w in other, or the pair (k, (Some(v), None)) if no elements in other have key k. Similarly, for each element (k, w) in other, the resulting RDD will either contain all pairs (k, (Some(v), Some(w))) for v in this, or the pair (k, (None, Some(w))) if no elements in this have key k. Uses the given Partitioner to partition the output RDD.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.fullOuterJoin(    other: JavaDStream<Tuple2<K, W>>,     numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Tuple2<Optional<V>, Optional<W>>>>

Return a new DStream by applying 'full outer join' between RDDs of this DStream and other DStream. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.fullOuterJoin(    other: JavaDStream<Tuple2<K, W>>,     partitioner: Partitioner): JavaDStream<Tuple2<K, Tuple2<Optional<V>, Optional<W>>>>

Return a new DStream by applying 'full outer join' between RDDs of this DStream and other DStream. The supplied org.apache.spark.Partitioner is used to control the partitioning of each RDD.

Link copied to clipboard
fun <T> generateEncoder(type: KType, cls: KClass<*>): Encoder<T>
Link copied to clipboard
infix fun Column.geq(other: Any): Column

Greater than or equal to an expression.

Link copied to clipboard
operator fun Column.get(key: Any): Column

An expression that gets an item at position ordinal out of an array, or gets a value by key key in a MapType.

Link copied to clipboard
fun <T> Optional<T>.getOrElse(other: T): T
fun <T> Option<T>.getOrElse(other: T): T

Get if available else other.

fun <T> State<T>.getOrElse(other: T): T

Returns state value if it exists, else other.

Link copied to clipboard
fun <T> Optional<T>.getOrNull(): T?

Converts Optional to Kotlin nullable.

fun <S> GroupState<S>.getOrNull(): S?

(Kotlin-specific) Returns the group state value if it exists, else null. This is comparable to GroupState.getOption, but instead utilises Kotlin's nullability features to get the same result.

fun <T> State<T>.getOrNull(): T?

Returns state value if it exists, else null.

fun <T> Option<T>.getOrNull(): T?

Converts Scala Option to Kotlin nullable.

Link copied to clipboard
operator fun <S> GroupState<S>.getValue(thisRef: Any?, property: KProperty<*>): S?

(Kotlin-specific) Allows the group state object to be used as a delegate. Will be null if it does not exist.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.groupByKey(): JavaRDD<Tuple2<K, Iterable<V>>>

Group the values for each key in the RDD into a single sequence. Hash-partitions the resulting RDD with the existing partitioner/parallelism level. The ordering of elements within each group is not guaranteed, and may even differ each time the resulting RDD is evaluated.

fun <K, V> JavaRDD<Tuple2<K, V>>.groupByKey(numPartitions: Int): JavaRDD<Tuple2<K, Iterable<V>>>

Group the values for each key in the RDD into a single sequence. Hash-partitions the resulting RDD with into numPartitions partitions. The ordering of elements within each group is not guaranteed, and may even differ each time the resulting RDD is evaluated.

fun <K, V> JavaRDD<Tuple2<K, V>>.groupByKey(partitioner: Partitioner): JavaRDD<Tuple2<K, Iterable<V>>>

Group the values for each key in the RDD into a single sequence. Allows controlling the partitioning of the resulting key-value pair RDD by passing a Partitioner. The ordering of elements within each group is not guaranteed, and may even differ each time the resulting RDD is evaluated.

inline fun <T, R> Dataset<T>.groupByKey(noinline func: (T) -> R): KeyValueGroupedDataset<R, T>

(Kotlin-specific) Returns a KeyValueGroupedDataset where the data is grouped by the given key func.

fun <K, V> JavaDStream<Tuple2<K, V>>.groupByKey(    numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Iterable<V>>>

Return a new DStream by applying groupByKey to each RDD. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V> JavaDStream<Tuple2<K, V>>.groupByKey(partitioner: Partitioner): JavaDStream<Tuple2<K, Iterable<V>>>

Return a new DStream by applying groupByKey on each RDD. The supplied org.apache.spark.Partitioner is used to control the partitioning of each RDD.

Link copied to clipboard
fun <K, V> JavaDStream<Tuple2<K, V>>.groupByKeyAndWindow(    windowDuration: Duration,     slideDuration: Duration = dstream().slideDuration(),     numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Iterable<V>>>

Return a new DStream by applying groupByKey over a sliding window on this DStream. Similar to DStream.groupByKey(), but applies it over a sliding window. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V> JavaDStream<Tuple2<K, V>>.groupByKeyAndWindow(    windowDuration: Duration,     slideDuration: Duration = dstream().slideDuration(),     partitioner: Partitioner): JavaDStream<Tuple2<K, Iterable<V>>>

Create a new DStream by applying groupByKey over a sliding window on this DStream. Similar to DStream.groupByKey(), but applies it over a sliding window.

Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.groupWith(other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, Tuple2<Iterable<V>, Iterable<W>>>>
fun <K, V, W1, W2> JavaRDD<Tuple2<K, V>>.groupWith(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>): JavaRDD<Tuple2<K, Tuple3<Iterable<V>, Iterable<W1>, Iterable<W2>>>>
fun <K, V, W1, W2, W3> JavaRDD<Tuple2<K, V>>.groupWith(    other1: JavaRDD<Tuple2<K, W1>>,     other2: JavaRDD<Tuple2<K, W2>>,     other3: JavaRDD<Tuple2<K, W3>>): JavaRDD<Tuple2<K, Tuple4<Iterable<V>, Iterable<W1>, Iterable<W2>, Iterable<W3>>>>

Alias for cogroup.

Link copied to clipboard
infix fun Column.gt(other: Any): Column

Greater than.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.histogram(bucketCount: Int): Tuple2<DoubleArray, LongArray>

Compute a histogram of the data using bucketCount number of buckets evenly spaced between the minimum and maximum of the RDD. For example if the min value is 0 and the max is 100 and there are two buckets the resulting buckets will be [0, 50) [50, 100]. bucketCount must be at least 1 If the RDD contains infinity, NaN throws an exception If the elements in RDD do not vary (max == min) always returns a single bucket.

inline fun <T : Number> JavaRDD<T>.histogram(buckets: DoubleArray, evenBuckets: Boolean = false): LongArray

Compute a histogram using the provided buckets. The buckets are all open to the right except for the last which is closed. e.g. for the array [1, 10, 20, 50] the buckets are [1, 10) [10, 20) [20, 50] e.g. <=x<10, 10<=x<20, 20<=x<=50 And on the input of 1 and 50 we would have a histogram of 1, 0, 1

Link copied to clipboard
inline fun <L, R> Dataset<L>.innerJoin(right: Dataset<R>, col: Column): Dataset<Tuple2<L, R>>

Alias for Dataset.joinWith which passes "inner" argument

Link copied to clipboard
infix fun Column.inRangeOf(range: ClosedRange<*>): Column

True if the current column is in the given range.

Link copied to clipboard
operator fun Dataset<*>.invoke(colName: String): Column

Selects column based on the column name and returns it as a Column.

inline operator fun <T, R> Dataset<T>.invoke(colName: String): TypedColumn<T, R>

Selects column based on the column name and returns it as a TypedColumn.

inline operator fun <T, U> Dataset<T>.invoke(column: KProperty1<T, U>): TypedColumn<T, U>

Helper function to quickly get a TypedColumn (or Column) from a dataset in a refactor-safe manner.

Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.join(other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, Tuple2<V, W>>>
fun <K, V, W> JavaRDD<Tuple2<K, V>>.join(other: JavaRDD<Tuple2<K, W>>, numPartitions: Int): JavaRDD<Tuple2<K, Tuple2<V, W>>>

Return an RDD containing all pairs of elements with matching keys in this and other. Each pair of elements will be returned as a (k, (v1, v2)) tuple, where (k, v1) is in this and (k, v2) is in other. Performs a hash join across the cluster.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.join(other: JavaRDD<Tuple2<K, W>>, partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple2<V, W>>>

Return an RDD containing all pairs of elements with matching keys in this and other. Each pair of elements will be returned as a (k, (v1, v2)) tuple, where (k, v1) is in this and (k, v2) is in other. Uses the given Partitioner to partition the output RDD.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.join(    other: JavaDStream<Tuple2<K, W>>,     numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Tuple2<V, W>>>

Return a new DStream by applying 'join' between RDDs of this DStream and other DStream. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.join(    other: JavaDStream<Tuple2<K, W>>,     partitioner: Partitioner): JavaDStream<Tuple2<K, Tuple2<V, W>>>

Return a new DStream by applying 'join' between RDDs of this DStream and other DStream. The supplied org.apache.spark.Partitioner is used to control the partitioning of each RDD.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.keys(): JavaRDD<K>

Return an RDD with the keys of each tuple.

Link copied to clipboard
inline fun <L, R> Dataset<L>.leftJoin(right: Dataset<R>, col: Column): Dataset<Tuple2<L, R?>>

Alias for Dataset.joinWith which passes "left" argument and respects the fact that in result of left join right relation is nullable

Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.leftOuterJoin(other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, Tuple2<V, Optional<W>>>>

Perform a left outer join of this and other. For each element (k, v) in this, the resulting RDD will either contain all pairs (k, (v, Some(w))) for w in other, or the pair (k, (v, None)) if no elements in other have key k. Hash-partitions the output using the existing partitioner/parallelism level.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.leftOuterJoin(    other: JavaRDD<Tuple2<K, W>>,     numPartitions: Int): JavaRDD<Tuple2<K, Tuple2<V, Optional<W>>>>

Perform a left outer join of this and other. For each element (k, v) in this, the resulting RDD will either contain all pairs (k, (v, Some(w))) for w in other, or the pair (k, (v, None)) if no elements in other have key k. Hash-partitions the output into numPartitions partitions.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.leftOuterJoin(    other: JavaRDD<Tuple2<K, W>>,     partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple2<V, Optional<W>>>>

Perform a left outer join of this and other. For each element (k, v) in this, the resulting RDD will either contain all pairs (k, (v, Some(w))) for w in other, or the pair (k, (v, None)) if no elements in other have key k. Uses the given Partitioner to partition the output RDD.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.leftOuterJoin(    other: JavaDStream<Tuple2<K, W>>,     numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Tuple2<V, Optional<W>>>>

Return a new DStream by applying 'left outer join' between RDDs of this DStream and other DStream. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.leftOuterJoin(    other: JavaDStream<Tuple2<K, W>>,     partitioner: Partitioner): JavaDStream<Tuple2<K, Tuple2<V, Optional<W>>>>

Return a new DStream by applying 'left outer join' between RDDs of this DStream and other DStream. The supplied org.apache.spark.Partitioner is used to control the partitioning of each RDD.

Link copied to clipboard
infix fun Column.leq(other: Any): Column

Less than or equal to.

Link copied to clipboard
fun lit(a: Any): Column

Creates a Column of literal value.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.lookup(key: K): List<V>

Return the list of values in the RDD for key key. This operation is done efficiently if the RDD has a known partitioner by only searching the partition that the key maps to.

Link copied to clipboard
infix fun Column.lt(other: Any): Column

Less than.

Link copied to clipboard
fun <T, R> Iterator<T>.map(func: (T) -> R): Iterator<R>

Maps the values of the iterator lazily using func.

inline fun <T, R> Dataset<T>.map(noinline func: (T) -> R): Dataset<R>

(Kotlin-specific) Returns a new Dataset that contains the result of applying func to each element.

Link copied to clipboard
inline fun <KEY, VALUE, R> KeyValueGroupedDataset<KEY, VALUE>.mapGroups(noinline func: (KEY, Iterator<VALUE>) -> R): Dataset<R>

(Kotlin-specific) Applies the given function to each group of data. For each unique group, the function will be passed the group key and an iterator that contains all the elements in the group. The function can return an element of arbitrary type which will be returned as a new Dataset.

Link copied to clipboard
inline fun <K, V, S, U> KeyValueGroupedDataset<K, V>.mapGroupsWithState(    noinline func: (key: K, values: Iterator<V>, state: GroupState<S>) -> U): Dataset<U>
inline fun <K, V, S, U> KeyValueGroupedDataset<K, V>.mapGroupsWithState(    timeoutConf: GroupStateTimeout,     noinline func: (key: K, values: Iterator<V>, state: GroupState<S>) -> U): Dataset<U>

(Kotlin-specific) Applies the given function to each group of data, while maintaining a user-defined per-group state. The result Dataset will represent the objects returned by the function. For a static batch Dataset, the function will be invoked once per group. For a streaming Dataset, the function will be invoked for each group repeatedly in every trigger, and updates to each group's state will be saved across invocations. See org.apache.spark.sql.streaming.GroupState for more details.

Link copied to clipboard
fun <K, V, U> JavaRDD<Tuple2<K, V>>.mapKeys(f: (K) -> U): JavaRDD<Tuple2<U, V>>

Pass each key in the key-value pair RDD through a map function without changing the values; this also retains the original RDD's partitioning.

Link copied to clipboard
inline fun <T, R> Dataset<T>.mapPartitions(noinline func: (Iterator<T>) -> Iterator<R>): Dataset<R>

(Kotlin-specific) Returns a new Dataset that contains the result of applying func to each partition.

Link copied to clipboard
fun <K, V, U> JavaRDD<Tuple2<K, V>>.mapValues(f: (V) -> U): JavaRDD<Tuple2<K, U>>

Pass each value in the key-value pair RDD through a map function without changing the keys; this also retains the original RDD's partitioning.

inline fun <KEY, VALUE, R> KeyValueGroupedDataset<KEY, VALUE>.mapValues(noinline func: (VALUE) -> R): KeyValueGroupedDataset<KEY, R>

Returns a new KeyValueGroupedDataset where the given function func has been applied to the data. The grouping key is unchanged by this.

fun <K, V, U> JavaDStream<Tuple2<K, V>>.mapValues(mapValuesFunc: (V) -> U): JavaDStream<Tuple2<K, U>>

Return a new DStream by applying a map function to the value of each key-value pairs in 'this' DStream without changing the key.

Link copied to clipboard
fun <K, V, StateType, MappedType> JavaDStream<Tuple2<K, V>>.mapWithState(    spec: StateSpec<K, V, StateType, MappedType>): JavaMapWithStateDStream<K, V, StateType, MappedType>

Return a JavaMapWithStateDStream by applying a function to every key-value element of this stream, while maintaining some state data for each unique key. The mapping function and other specification (e.g. partitioners, timeouts, initial state data, etc.) of this transformation can be specified using StateSpec class. The state data is accessible in as a parameter of type State in the mapping function.

Link copied to clipboard
fun <T : Comparable<T>> JavaRDD<T>.max(): T

Returns the maximum element from this RDD as defined by the specified Comparator.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.mean(): Double

Compute the mean of this RDD's elements.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.meanApprox(timeout: Long, confidence: Double = 0.95): PartialResult<BoundedDouble>

Approximate operation to return the mean within a timeout.

Link copied to clipboard
fun <T : Comparable<T>> JavaRDD<T>.min(): T

Returns the minimum element from this RDD as defined by the specified Comparator.

Link copied to clipboard
fun <T> mutableSeqOf(vararg elements: T): Seq<T>

Returns a new mutable Seq with the given elements.

Link copied to clipboard
infix fun Column.neq(other: Any): Column

Inequality test.

Link copied to clipboard
operator fun Column.not(): Column

Inversion of boolean expression, i.e. NOT.

Link copied to clipboard
infix fun Column.or(other: Any): Column

Boolean OR.

Link copied to clipboard
fun <T> Iterator<T>.partition(size: Int, cutIncomplete: Boolean = false): Iterator<List<T>>

Partitions the values of the iterator lazily in groups of size.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.partitionBy(partitioner: Partitioner): JavaRDD<Tuple2<K, V>>

Return a copy of the RDD partitioned using the specified partitioner.

Link copied to clipboard
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity10<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity11<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity12<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity13<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity14<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity15<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity16<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity1<T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity2<T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity3<T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity4<T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity5<T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity6<T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity7<T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity8<T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.plus(    that: Arity9<T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity10<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity11<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity12<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity13<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity14<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity15<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity1<T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity2<T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity3<T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity4<T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity5<T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity6<T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity7<T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity8<T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.plus(    that: Arity9<T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity10<T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity11<T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity12<T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity13<T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity14<T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity1<T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity2<T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity3<T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity4<T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity5<T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity6<T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity7<T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity8<T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.plus(    that: Arity9<T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity10<T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity11<T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity12<T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity13<T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity1<T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity2<T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity3<T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity4<T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity5<T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity6<T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity7<T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity8<T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.plus(    that: Arity9<T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity10<T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity11<T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity12<T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity1<T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity2<T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity3<T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity4<T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity5<T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity6<T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity7<T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity8<T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.plus(    that: Arity9<T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity10<T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity11<T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity1<T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity2<T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity3<T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity4<T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity5<T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity6<T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity7<T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity8<T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.plus(    that: Arity9<T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity10<T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity1<T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity2<T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity3<T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity4<T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity5<T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity6<T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity7<T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity8<T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.plus(    that: Arity9<T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity1<T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity2<T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity3<T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity4<T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity5<T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity6<T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity7<T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity8<T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.plus(    that: Arity9<T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity1<T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity2<T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity3<T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity4<T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity5<T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity6<T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity7<T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.plus(    that: Arity8<T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity1<T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity2<T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity3<T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity4<T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity5<T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity6<T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.plus(    that: Arity7<T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity1<T1>.plus(    that: Arity10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity1<T1>.plus(    that: Arity11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity1<T1>.plus(    that: Arity12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity1<T1>.plus(    that: Arity13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity1<T1>.plus(    that: Arity14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity1<T1>.plus(    that: Arity15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity1<T1>.plus(    that: Arity16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity1<T1>.plus(    that: Arity17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity1<T1>.plus(    that: Arity18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity1<T1>.plus(    that: Arity19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2> Arity1<T1>.plus(that: Arity1<T2>): Arity2<T1, T2>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity1<T1>.plus(    that: Arity20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity1<T1>.plus(    that: Arity21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity1<T1>.plus(    that: Arity22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity1<T1>.plus(    that: Arity23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity1<T1>.plus(    that: Arity24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity1<T1>.plus(    that: Arity25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3> Arity1<T1>.plus(that: Arity2<T2, T3>): Arity3<T1, T2, T3>
infix operator fun <T1, T2, T3, T4> Arity1<T1>.plus(that: Arity3<T2, T3, T4>): Arity4<T1, T2, T3, T4>
infix operator fun <T1, T2, T3, T4, T5> Arity1<T1>.plus(that: Arity4<T2, T3, T4, T5>): Arity5<T1, T2, T3, T4, T5>
infix operator fun <T1, T2, T3, T4, T5, T6> Arity1<T1>.plus(that: Arity5<T2, T3, T4, T5, T6>): Arity6<T1, T2, T3, T4, T5, T6>
infix operator fun <T1, T2, T3, T4, T5, T6, T7> Arity1<T1>.plus(that: Arity6<T2, T3, T4, T5, T6, T7>): Arity7<T1, T2, T3, T4, T5, T6, T7>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity1<T1>.plus(that: Arity7<T2, T3, T4, T5, T6, T7, T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity1<T1>.plus(    that: Arity8<T2, T3, T4, T5, T6, T7, T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity1<T1>.plus(    that: Arity9<T2, T3, T4, T5, T6, T7, T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.plus(    that: Arity1<T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.plus(    that: Arity2<T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.plus(    that: Arity3<T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.plus(    that: Arity4<T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.plus(    that: Arity5<T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.plus(    that: Arity6<T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.plus(    that: Arity1<T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.plus(    that: Arity2<T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.plus(    that: Arity3<T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.plus(    that: Arity4<T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.plus(    that: Arity5<T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.plus(    that: Arity1<T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.plus(    that: Arity2<T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.plus(    that: Arity3<T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.plus(    that: Arity4<T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>.plus(    that: Arity1<T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>.plus(    that: Arity2<T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>.plus(    that: Arity3<T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>.plus(    that: Arity1<T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>.plus(    that: Arity2<T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>.plus(    that: Arity1<T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity2<T1, T2>.plus(    that: Arity10<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity2<T1, T2>.plus(    that: Arity11<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity2<T1, T2>.plus(    that: Arity12<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity2<T1, T2>.plus(    that: Arity13<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity2<T1, T2>.plus(    that: Arity14<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity2<T1, T2>.plus(    that: Arity15<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity2<T1, T2>.plus(    that: Arity16<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity2<T1, T2>.plus(    that: Arity17<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity2<T1, T2>.plus(    that: Arity18<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity2<T1, T2>.plus(    that: Arity19<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3> Arity2<T1, T2>.plus(that: Arity1<T3>): Arity3<T1, T2, T3>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity2<T1, T2>.plus(    that: Arity20<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity2<T1, T2>.plus(    that: Arity21<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity2<T1, T2>.plus(    that: Arity22<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity2<T1, T2>.plus(    that: Arity23<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity2<T1, T2>.plus(    that: Arity24<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4> Arity2<T1, T2>.plus(that: Arity2<T3, T4>): Arity4<T1, T2, T3, T4>
infix operator fun <T1, T2, T3, T4, T5> Arity2<T1, T2>.plus(that: Arity3<T3, T4, T5>): Arity5<T1, T2, T3, T4, T5>
infix operator fun <T1, T2, T3, T4, T5, T6> Arity2<T1, T2>.plus(that: Arity4<T3, T4, T5, T6>): Arity6<T1, T2, T3, T4, T5, T6>
infix operator fun <T1, T2, T3, T4, T5, T6, T7> Arity2<T1, T2>.plus(that: Arity5<T3, T4, T5, T6, T7>): Arity7<T1, T2, T3, T4, T5, T6, T7>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity2<T1, T2>.plus(that: Arity6<T3, T4, T5, T6, T7, T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity2<T1, T2>.plus(    that: Arity7<T3, T4, T5, T6, T7, T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity2<T1, T2>.plus(    that: Arity8<T3, T4, T5, T6, T7, T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity2<T1, T2>.plus(    that: Arity9<T3, T4, T5, T6, T7, T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity3<T1, T2, T3>.plus(    that: Arity10<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity3<T1, T2, T3>.plus(    that: Arity11<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity3<T1, T2, T3>.plus(    that: Arity12<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity3<T1, T2, T3>.plus(    that: Arity13<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity3<T1, T2, T3>.plus(    that: Arity14<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity3<T1, T2, T3>.plus(    that: Arity15<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity3<T1, T2, T3>.plus(    that: Arity16<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity3<T1, T2, T3>.plus(    that: Arity17<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity3<T1, T2, T3>.plus(    that: Arity18<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity3<T1, T2, T3>.plus(    that: Arity19<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4> Arity3<T1, T2, T3>.plus(that: Arity1<T4>): Arity4<T1, T2, T3, T4>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity3<T1, T2, T3>.plus(    that: Arity20<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity3<T1, T2, T3>.plus(    that: Arity21<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity3<T1, T2, T3>.plus(    that: Arity22<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity3<T1, T2, T3>.plus(    that: Arity23<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5> Arity3<T1, T2, T3>.plus(that: Arity2<T4, T5>): Arity5<T1, T2, T3, T4, T5>
infix operator fun <T1, T2, T3, T4, T5, T6> Arity3<T1, T2, T3>.plus(that: Arity3<T4, T5, T6>): Arity6<T1, T2, T3, T4, T5, T6>
infix operator fun <T1, T2, T3, T4, T5, T6, T7> Arity3<T1, T2, T3>.plus(that: Arity4<T4, T5, T6, T7>): Arity7<T1, T2, T3, T4, T5, T6, T7>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity3<T1, T2, T3>.plus(that: Arity5<T4, T5, T6, T7, T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity3<T1, T2, T3>.plus(    that: Arity6<T4, T5, T6, T7, T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity3<T1, T2, T3>.plus(    that: Arity7<T4, T5, T6, T7, T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity3<T1, T2, T3>.plus(    that: Arity8<T4, T5, T6, T7, T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity3<T1, T2, T3>.plus(    that: Arity9<T4, T5, T6, T7, T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity4<T1, T2, T3, T4>.plus(    that: Arity10<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity4<T1, T2, T3, T4>.plus(    that: Arity11<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity4<T1, T2, T3, T4>.plus(    that: Arity12<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity4<T1, T2, T3, T4>.plus(    that: Arity13<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity4<T1, T2, T3, T4>.plus(    that: Arity14<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity4<T1, T2, T3, T4>.plus(    that: Arity15<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity4<T1, T2, T3, T4>.plus(    that: Arity16<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity4<T1, T2, T3, T4>.plus(    that: Arity17<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity4<T1, T2, T3, T4>.plus(    that: Arity18<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity4<T1, T2, T3, T4>.plus(    that: Arity19<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5> Arity4<T1, T2, T3, T4>.plus(that: Arity1<T5>): Arity5<T1, T2, T3, T4, T5>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity4<T1, T2, T3, T4>.plus(    that: Arity20<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity4<T1, T2, T3, T4>.plus(    that: Arity21<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity4<T1, T2, T3, T4>.plus(    that: Arity22<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6> Arity4<T1, T2, T3, T4>.plus(that: Arity2<T5, T6>): Arity6<T1, T2, T3, T4, T5, T6>
infix operator fun <T1, T2, T3, T4, T5, T6, T7> Arity4<T1, T2, T3, T4>.plus(that: Arity3<T5, T6, T7>): Arity7<T1, T2, T3, T4, T5, T6, T7>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity4<T1, T2, T3, T4>.plus(that: Arity4<T5, T6, T7, T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity4<T1, T2, T3, T4>.plus(    that: Arity5<T5, T6, T7, T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity4<T1, T2, T3, T4>.plus(    that: Arity6<T5, T6, T7, T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity4<T1, T2, T3, T4>.plus(    that: Arity7<T5, T6, T7, T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity4<T1, T2, T3, T4>.plus(    that: Arity8<T5, T6, T7, T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity4<T1, T2, T3, T4>.plus(    that: Arity9<T5, T6, T7, T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity10<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity11<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity12<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity13<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity14<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity15<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity16<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity17<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity18<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity19<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6> Arity5<T1, T2, T3, T4, T5>.plus(that: Arity1<T6>): Arity6<T1, T2, T3, T4, T5, T6>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity20<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity21<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7> Arity5<T1, T2, T3, T4, T5>.plus(that: Arity2<T6, T7>): Arity7<T1, T2, T3, T4, T5, T6, T7>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity5<T1, T2, T3, T4, T5>.plus(that: Arity3<T6, T7, T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity4<T6, T7, T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity5<T6, T7, T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity6<T6, T7, T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity7<T6, T7, T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity8<T6, T7, T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity5<T1, T2, T3, T4, T5>.plus(    that: Arity9<T6, T7, T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity10<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity11<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity12<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity13<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity14<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity15<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity16<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity17<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity18<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity19<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7> Arity6<T1, T2, T3, T4, T5, T6>.plus(that: Arity1<T7>): Arity7<T1, T2, T3, T4, T5, T6, T7>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity20<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity6<T1, T2, T3, T4, T5, T6>.plus(that: Arity2<T7, T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity3<T7, T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity4<T7, T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity5<T7, T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity6<T7, T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity7<T7, T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity8<T7, T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity6<T1, T2, T3, T4, T5, T6>.plus(    that: Arity9<T7, T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity10<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity11<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity12<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity13<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity14<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity15<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity16<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity17<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity18<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity19<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(that: Arity1<T8>): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity2<T8, T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity3<T8, T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity4<T8, T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity5<T8, T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity6<T8, T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity7<T8, T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity8<T8, T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity7<T1, T2, T3, T4, T5, T6, T7>.plus(    that: Arity9<T8, T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity10<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity11<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity12<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity13<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity14<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity15<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity16<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity17<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity18<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity1<T9>): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity2<T9, T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity3<T9, T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity4<T9, T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity5<T9, T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity6<T9, T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity7<T9, T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity8<T9, T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.plus(    that: Arity9<T9, T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity10<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity11<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity12<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity13<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity14<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>): Arity23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity15<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>): Arity24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity16<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>): Arity25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity17<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>): Arity26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity1<T10>): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity2<T10, T11>): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity3<T10, T11, T12>): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity4<T10, T11, T12, T13>): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity5<T10, T11, T12, T13, T14>): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity6<T10, T11, T12, T13, T14, T15>): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity7<T10, T11, T12, T13, T14, T15, T16>): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity8<T10, T11, T12, T13, T14, T15, T16, T17>): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
infix operator fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.plus(    that: Arity9<T10, T11, T12, T13, T14, T15, T16, T17, T18>): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.popStdev(): Double

Compute the population standard deviation of this RDD's elements.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.popVariance(): Double

Compute the population variance of this RDD's elements.

Link copied to clipboard
fun <T> JavaSparkContext.rddOf(vararg elements: T, numSlices: Int = defaultParallelism()): JavaRDD<T>

Utility method to create an RDD from a list. NOTE: T must be Serializable.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.reduceByKey(func: (V, V) -> V): JavaRDD<Tuple2<K, V>>

Merge the values for each key using an associative and commutative reduce function. This will also perform the merging locally on each mapper before sending results to a reducer, similarly to a "combiner" in MapReduce. Output will be hash-partitioned with the existing partitioner/ parallelism level.

fun <K, V> JavaRDD<Tuple2<K, V>>.reduceByKey(numPartitions: Int, func: (V, V) -> V): JavaRDD<Tuple2<K, V>>

Merge the values for each key using an associative and commutative reduce function. This will also perform the merging locally on each mapper before sending results to a reducer, similarly to a "combiner" in MapReduce. Output will be hash-partitioned with numPartitions partitions.

fun <K, V> JavaRDD<Tuple2<K, V>>.reduceByKey(partitioner: Partitioner, func: (V, V) -> V): JavaRDD<Tuple2<K, V>>

Merge the values for each key using an associative and commutative reduce function. This will also perform the merging locally on each mapper before sending results to a reducer, similarly to a "combiner" in MapReduce.

fun <K, V> JavaDStream<Tuple2<K, V>>.reduceByKey(    numPartitions: Int = dstream().ssc().sc().defaultParallelism(),     reduceFunc: (V, V) -> V): JavaDStream<Tuple2<K, V>>

Return a new DStream by applying reduceByKey to each RDD. The values for each key are merged using the supplied reduce function. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V> JavaDStream<Tuple2<K, V>>.reduceByKey(partitioner: Partitioner, reduceFunc: (V, V) -> V): JavaDStream<Tuple2<K, V>>

Return a new DStream by applying reduceByKey to each RDD. The values for each key are merged using the supplied reduce function. org.apache.spark.Partitioner is used to control the partitioning of each RDD.

Link copied to clipboard
fun <K, V> JavaDStream<Tuple2<K, V>>.reduceByKeyAndWindow(    windowDuration: Duration,     slideDuration: Duration = dstream().slideDuration(),     numPartitions: Int = dstream().ssc().sc().defaultParallelism(),     reduceFunc: (V, V) -> V): JavaDStream<Tuple2<K, V>>

Return a new DStream by applying reduceByKey over a sliding window. This is similar to DStream.reduceByKey() but applies it over a sliding window. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V> JavaDStream<Tuple2<K, V>>.reduceByKeyAndWindow(    windowDuration: Duration,     slideDuration: Duration = dstream().slideDuration(),     partitioner: Partitioner,     reduceFunc: (V, V) -> V): JavaDStream<Tuple2<K, V>>

Return a new DStream by applying reduceByKey over a sliding window. Similar to DStream.reduceByKey(), but applies it over a sliding window.

fun <K, V> JavaDStream<Tuple2<K, V>>.reduceByKeyAndWindow(    invReduceFunc: (V, V) -> V,     windowDuration: Duration,     slideDuration: Duration = dstream().slideDuration(),     numPartitions: Int = dstream().ssc().sc().defaultParallelism(),     filterFunc: (Tuple2<K, V>) -> Boolean? = null,     reduceFunc: (V, V) -> V): JavaDStream<Tuple2<K, V>>
fun <K, V> JavaDStream<Tuple2<K, V>>.reduceByKeyAndWindow(    invReduceFunc: (V, V) -> V,     windowDuration: Duration,     slideDuration: Duration = dstream().slideDuration(),     partitioner: Partitioner,     filterFunc: (Tuple2<K, V>) -> Boolean? = null,     reduceFunc: (V, V) -> V): JavaDStream<Tuple2<K, V>>

Return a new DStream by applying incremental reduceByKey over a sliding window. The reduced value of over a new window is calculated using the old window's reduced value :

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.reduceByKeyLocally(func: (V, V) -> V): Map<K, V>

Merge the values for each key using an associative and commutative reduce function, but return the results immediately to the master as a Map. This will also perform the merging locally on each mapper before sending results to a reducer, similarly to a "combiner" in MapReduce.

Link copied to clipboard
inline fun <KEY, VALUE> KeyValueGroupedDataset<KEY, VALUE>.reduceGroupsK(    noinline func: (VALUE, VALUE) -> VALUE): Dataset<Tuple2<KEY, VALUE>>

(Kotlin-specific) Reduces the elements of each group of data using the specified binary function. The given function must be commutative and associative or the result may be non-deterministic.

Link copied to clipboard
inline fun <T> Dataset<T>.reduceK(noinline func: (T, T) -> T): T

(Kotlin-specific) Reduces the elements of this Dataset using the specified binary function. The given func must be commutative and associative or the result may be non-deterministic.

Link copied to clipboard
inline fun <Return, NamedUdf : NamedUserDefinedFunction<Return, *>> UDFRegistration.register(namedUdf: NamedUdf): NamedUdf

Registers a user-defined function (UDF) with name, for a UDF that's already defined using the Dataset API (i.e. of type NamedUserDefinedFunction).

inline fun <Return, NamedUdf : NamedUserDefinedFunction<Return, *>> UDFRegistration.register(    name: String,     udf: UserDefinedFunction<Return, NamedUdf>): NamedUdf

inline fun <R> UDFRegistration.register(func: () -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>
inline fun <R> UDFRegistration.register(func: KProperty0<() -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>

Creates and registers a UDF (NamedUserDefinedFunction0) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Creates and registers a UDF (NamedUserDefinedFunction10) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Creates and registers a UDF (NamedUserDefinedFunction11) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Creates and registers a UDF (NamedUserDefinedFunction12) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Creates and registers a UDF (NamedUserDefinedFunction13) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Creates and registers a UDF (NamedUserDefinedFunction14) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Creates and registers a UDF (NamedUserDefinedFunction15) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Creates and registers a UDF (NamedUserDefinedFunction16) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Creates and registers a UDF (NamedUserDefinedFunction17) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Creates and registers a UDF (NamedUserDefinedFunction18) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Creates and registers a UDF (NamedUserDefinedFunction19) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, R> UDFRegistration.register(func: (T1) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>
inline fun <T1, R> UDFRegistration.register(func: KProperty0<(T1) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>

Creates and registers a UDF (NamedUserDefinedFunction1) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

@JvmName(name = "registerVarargT")
inline fun <T, R> UDFRegistration.register(varargFunc: (Array<T>) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "registerVarargBoolean")
inline fun <R> UDFRegistration.register(    varargFunc: (BooleanArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "registerVarargByte")
inline fun <R> UDFRegistration.register(    varargFunc: (ByteArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "registerVarargDouble")
inline fun <R> UDFRegistration.register(    varargFunc: (DoubleArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "registerVarargFloat")
inline fun <R> UDFRegistration.register(    varargFunc: (FloatArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "registerVarargInt")
inline fun <R> UDFRegistration.register(varargFunc: (IntArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "registerVarargLong")
inline fun <R> UDFRegistration.register(    varargFunc: (LongArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "registerVarargShort")
inline fun <R> UDFRegistration.register(    varargFunc: (ShortArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>
@JvmName(name = "registerVarargT")
inline fun <T, R> UDFRegistration.register(    varargFunc: KProperty0<(Array<T>) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "registerVarargBoolean")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(BooleanArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "registerVarargByte")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(ByteArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "registerVarargDouble")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(DoubleArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "registerVarargFloat")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(FloatArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "registerVarargInt")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(IntArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "registerVarargLong")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(LongArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "registerVarargShort")
inline fun <R> UDFRegistration.register(    varargFunc: KProperty0<(ShortArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>

Creates and registers a vararg UDF (NamedUserDefinedFunctionVararg) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Creates and registers a UDF (NamedUserDefinedFunction20) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Creates and registers a UDF (NamedUserDefinedFunction21) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Creates and registers a UDF (NamedUserDefinedFunction22) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, R> UDFRegistration.register(func: (T1, T2) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>
inline fun <T1, T2, R> UDFRegistration.register(    func: KProperty0<(T1, T2) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>

Creates and registers a UDF (NamedUserDefinedFunction2) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, R> UDFRegistration.register(    func: (T1, T2, T3) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>
inline fun <T1, T2, T3, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>

Creates and registers a UDF (NamedUserDefinedFunction3) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, R> UDFRegistration.register(    func: (T1, T2, T3, T4) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>
inline fun <T1, T2, T3, T4, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>

Creates and registers a UDF (NamedUserDefinedFunction4) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>
inline fun <T1, T2, T3, T4, T5, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>

Creates and registers a UDF (NamedUserDefinedFunction5) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>
inline fun <T1, T2, T3, T4, T5, T6, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Creates and registers a UDF (NamedUserDefinedFunction6) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Creates and registers a UDF (NamedUserDefinedFunction7) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Creates and registers a UDF (NamedUserDefinedFunction8) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> UDFRegistration.register(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> UDFRegistration.register(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Creates and registers a UDF (NamedUserDefinedFunction9) from a function reference adapting its name by reflection. For example: val myUdf = udf.register(::myFunction)

inline fun <T1, R> UDFRegistration.register(agg: Aggregator<T1, *, R>, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>
inline fun <T1, R> UDFRegistration.register(    name: String,     agg: Aggregator<T1, *, R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>

Registers agg as a UDAF for SQL. Returns the UDAF as NamedUserDefinedFunction. Obtains a NamedUserDefinedFunction1 that wraps the given agg so that it may be used with Data Frames.

inline fun <R> UDFRegistration.register(name: String, nondeterministic: Boolean = false, func: UDF0<R>): NamedUserDefinedFunction0<R>

Defines and registers a named UDF (NamedUserDefinedFunction0) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Defines and registers a named UDF (NamedUserDefinedFunction10) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Defines and registers a named UDF (NamedUserDefinedFunction11) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Defines and registers a named UDF (NamedUserDefinedFunction12) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Defines and registers a named UDF (NamedUserDefinedFunction13) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Defines and registers a named UDF (NamedUserDefinedFunction14) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Defines and registers a named UDF (NamedUserDefinedFunction15) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Defines and registers a named UDF (NamedUserDefinedFunction16) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Defines and registers a named UDF (NamedUserDefinedFunction17) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Defines and registers a named UDF (NamedUserDefinedFunction18) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Defines and registers a named UDF (NamedUserDefinedFunction19) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19 -> ... }

inline fun <T1, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF1<T1, R>): NamedUserDefinedFunction1<T1, R>

Defines and registers a named UDF (NamedUserDefinedFunction1) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1 -> ... }

@JvmName(name = "registerVarargT")
inline fun <T, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<Array<T>, R>): NamedUserDefinedFunctionVararg<T, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: Array<T> -> ... }

@JvmName(name = "registerVarargBoolean")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<BooleanArray, R>): NamedUserDefinedFunctionVararg<Boolean, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: BooleanArray -> ... }

@JvmName(name = "registerVarargByte")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<ByteArray, R>): NamedUserDefinedFunctionVararg<Byte, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: ByteArray -> ... }

@JvmName(name = "registerVarargDouble")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<DoubleArray, R>): NamedUserDefinedFunctionVararg<Double, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: DoubleArray -> ... }

@JvmName(name = "registerVarargFloat")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<FloatArray, R>): NamedUserDefinedFunctionVararg<Float, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: FloatArray -> ... }

@JvmName(name = "registerVarargInt")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<IntArray, R>): NamedUserDefinedFunctionVararg<Int, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: IntArray -> ... }

@JvmName(name = "registerVarargLong")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<LongArray, R>): NamedUserDefinedFunctionVararg<Long, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: LongArray -> ... }

@JvmName(name = "registerVarargShort")
inline fun <R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<ShortArray, R>): NamedUserDefinedFunctionVararg<Short, R>

Defines and registers a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf.register("myUdf") { t1: ShortArray -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Defines and registers a named UDF (NamedUserDefinedFunction20) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Defines and registers a named UDF (NamedUserDefinedFunction21) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Defines and registers a named UDF (NamedUserDefinedFunction22) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21, t22: T22 -> ... }

inline fun <T1, T2, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF2<T1, T2, R>): NamedUserDefinedFunction2<T1, T2, R>

Defines and registers a named UDF (NamedUserDefinedFunction2) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2 -> ... }

inline fun <T1, T2, T3, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF3<T1, T2, T3, R>): NamedUserDefinedFunction3<T1, T2, T3, R>

Defines and registers a named UDF (NamedUserDefinedFunction3) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3 -> ... }

inline fun <T1, T2, T3, T4, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF4<T1, T2, T3, T4, R>): NamedUserDefinedFunction4<T1, T2, T3, T4, R>

Defines and registers a named UDF (NamedUserDefinedFunction4) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4 -> ... }

inline fun <T1, T2, T3, T4, T5, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF5<T1, T2, T3, T4, T5, R>): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>

Defines and registers a named UDF (NamedUserDefinedFunction5) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF6<T1, T2, T3, T4, T5, T6, R>): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Defines and registers a named UDF (NamedUserDefinedFunction6) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF7<T1, T2, T3, T4, T5, T6, T7, R>): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Defines and registers a named UDF (NamedUserDefinedFunction7) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF8<T1, T2, T3, T4, T5, T6, T7, T8, R>): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Defines and registers a named UDF (NamedUserDefinedFunction8) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> UDFRegistration.register(    name: String,     nondeterministic: Boolean = false,     func: UDF9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Defines and registers a named UDF (NamedUserDefinedFunction9) instance based on the (lambda) function func. For example: val myUdf = udf.register("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9 -> ... }

inline fun <R> UDFRegistration.register(name: String, func: () -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>
inline fun <R> UDFRegistration.register(    name: String,     func: KProperty0<() -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>

Creates and registers a UDF (NamedUserDefinedFunction0) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Creates and registers a UDF (NamedUserDefinedFunction10) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Creates and registers a UDF (NamedUserDefinedFunction11) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Creates and registers a UDF (NamedUserDefinedFunction12) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Creates and registers a UDF (NamedUserDefinedFunction13) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Creates and registers a UDF (NamedUserDefinedFunction14) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Creates and registers a UDF (NamedUserDefinedFunction15) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Creates and registers a UDF (NamedUserDefinedFunction16) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Creates and registers a UDF (NamedUserDefinedFunction17) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Creates and registers a UDF (NamedUserDefinedFunction18) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Creates and registers a UDF (NamedUserDefinedFunction19) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, R> UDFRegistration.register(name: String, func: (T1) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>
inline fun <T1, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>

Creates and registers a UDF (NamedUserDefinedFunction1) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

@JvmName(name = "registerVarargT")
inline fun <T, R> UDFRegistration.register(    name: String,     varargFunc: (Array<T>) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "registerVarargBoolean")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (BooleanArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "registerVarargByte")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (ByteArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "registerVarargDouble")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (DoubleArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "registerVarargFloat")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (FloatArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "registerVarargInt")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (IntArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "registerVarargLong")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (LongArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "registerVarargShort")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: (ShortArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>
@JvmName(name = "registerVarargT")
inline fun <T, R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(Array<T>) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "registerVarargBoolean")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(BooleanArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "registerVarargByte")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(ByteArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "registerVarargDouble")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(DoubleArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "registerVarargFloat")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(FloatArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "registerVarargInt")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(IntArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "registerVarargLong")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(LongArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "registerVarargShort")
inline fun <R> UDFRegistration.register(    name: String,     varargFunc: KProperty0<(ShortArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>

Creates and registers a vararg UDF (NamedUserDefinedFunctionVararg) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Creates and registers a UDF (NamedUserDefinedFunction20) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Creates and registers a UDF (NamedUserDefinedFunction21) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Creates and registers a UDF (NamedUserDefinedFunction22) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, R> UDFRegistration.register(    name: String,     func: (T1, T2) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>
inline fun <T1, T2, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>

Creates and registers a UDF (NamedUserDefinedFunction2) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>
inline fun <T1, T2, T3, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>

Creates and registers a UDF (NamedUserDefinedFunction3) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>
inline fun <T1, T2, T3, T4, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>

Creates and registers a UDF (NamedUserDefinedFunction4) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>
inline fun <T1, T2, T3, T4, T5, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>

Creates and registers a UDF (NamedUserDefinedFunction5) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>
inline fun <T1, T2, T3, T4, T5, T6, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Creates and registers a UDF (NamedUserDefinedFunction6) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Creates and registers a UDF (NamedUserDefinedFunction7) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Creates and registers a UDF (NamedUserDefinedFunction8) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> UDFRegistration.register(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> UDFRegistration.register(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Creates and registers a UDF (NamedUserDefinedFunction9) from a function reference. For example: val myUdf = udf.register("myFunction", ::myFunction)

inline fun <IN, BUF, OUT> UDFRegistration.register(    name: String,     noinline zero: () -> BUF,     noinline reduce: (b: BUF, a: IN) -> BUF,     noinline merge: (b1: BUF, b2: BUF) -> BUF,     noinline finish: (reduction: BUF) -> OUT,     bufferEncoder: Encoder<BUF> = encoder(),     outputEncoder: Encoder<OUT> = encoder(),     nondeterministic: Boolean = false): NamedUserDefinedFunction1<IN, OUT>

Registers a UDAF for SQL based on the given arguments. Returns the UDAF as NamedUserDefinedFunction. Obtains a NamedUserDefinedFunction1 that wraps the given agg so that it may be used with Data Frames.

Link copied to clipboard
operator fun Column.rem(other: Any): Column

Modulo (a.k.a. remainder) expression.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.repartitionAndSortWithinPartitions(partitioner: Partitioner): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.repartitionAndSortWithinPartitions(partitioner: Partitioner, comp: Comparator<K>): JavaRDD<Tuple2<K, V>>

Repartition the RDD according to the given partitioner and, within each resulting partition, sort records by their keys.

Link copied to clipboard
inline fun <L, R> Dataset<L>.rightJoin(right: Dataset<R>, col: Column): Dataset<Tuple2<L?, R>>

Alias for Dataset.joinWith which passes "right" argument and respects the fact that in result of right join left relation is nullable

Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.rightOuterJoin(other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, Tuple2<Optional<V>, W>>>

Perform a right outer join of this and other. For each element (k, w) in other, the resulting RDD will either contain all pairs (k, (Some(v), w)) for v in this, or the pair (k, (None, w)) if no elements in this have key k. Hash-partitions the resulting RDD using the existing partitioner/parallelism level.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.rightOuterJoin(    other: JavaRDD<Tuple2<K, W>>,     numPartitions: Int): JavaRDD<Tuple2<K, Tuple2<Optional<V>, W>>>

Perform a right outer join of this and other. For each element (k, w) in other, the resulting RDD will either contain all pairs (k, (Some(v), w)) for v in this, or the pair (k, (None, w)) if no elements in this have key k. Hash-partitions the resulting RDD into the given number of partitions.

fun <K, V, W> JavaRDD<Tuple2<K, V>>.rightOuterJoin(    other: JavaRDD<Tuple2<K, W>>,     partitioner: Partitioner): JavaRDD<Tuple2<K, Tuple2<Optional<V>, W>>>

Perform a right outer join of this and other. For each element (k, w) in other, the resulting RDD will either contain all pairs (k, (Some(v), w)) for v in this, or the pair (k, (None, w)) if no elements in this have key k. Uses the given Partitioner to partition the output RDD.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.rightOuterJoin(    other: JavaDStream<Tuple2<K, W>>,     numPartitions: Int = dstream().ssc().sc().defaultParallelism()): JavaDStream<Tuple2<K, Tuple2<Optional<V>, W>>>

Return a new DStream by applying 'right outer join' between RDDs of this DStream and other DStream. Hash partitioning is used to generate the RDDs with numPartitions partitions.

fun <K, V, W> JavaDStream<Tuple2<K, V>>.rightOuterJoin(    other: JavaDStream<Tuple2<K, W>>,     partitioner: Partitioner): JavaDStream<Tuple2<K, Tuple2<Optional<V>, W>>>

Return a new DStream by applying 'right outer join' between RDDs of this DStream and other DStream. The supplied org.apache.spark.Partitioner is used to control the partitioning of each RDD.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.sampleByKey(    withReplacement: Boolean,     fractions: Map<K, Double>,     seed: Long = Random.nextLong()): JavaRDD<Tuple2<K, V>>

Return a subset of this RDD sampled by key (via stratified sampling).

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.sampleByKeyExact(    withReplacement: Boolean,     fractions: Map<K, Double>,     seed: Long = Random.nextLong()): JavaRDD<Tuple2<K, V>>

Return a subset of this RDD sampled by key (via stratified sampling) containing exactly math.ceil(numItems * samplingRate) for each stratum (group of pairs with the same key).

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.sampleStdev(): Double

Compute the sample standard deviation of this RDD's elements (which corrects for bias in estimating the standard deviation by dividing by N-1 instead of N).

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.sampleVariance(): Double

Compute the sample variance of this RDD's elements (which corrects for bias in estimating the variance by dividing by N-1 instead of N).

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.saveAsHadoopDataset(conf: JobConf)

Output the RDD to any Hadoop-supported storage system, using a Hadoop JobConf object for that storage system. The JobConf should set an OutputFormat and any output paths required (e.g. a table name to write to) in the same way as it would be configured for a Hadoop MapReduce job.

Link copied to clipboard
fun <K, V, F : OutputFormat<*, *>> JavaRDD<Tuple2<K, V>>.saveAsHadoopFile(    path: String,     keyClass: Class<*>,     valueClass: Class<*>,     outputFormatClass: Class<F>)
fun <K, V, F : OutputFormat<*, *>> JavaRDD<Tuple2<K, V>>.saveAsHadoopFile(    path: String,     keyClass: Class<*>,     valueClass: Class<*>,     outputFormatClass: Class<F>,     conf: JobConf)

Output the RDD to any Hadoop-supported file system.

fun <K, V, F : OutputFormat<*, *>> JavaRDD<Tuple2<K, V>>.saveAsHadoopFile(    path: String,     keyClass: Class<*>,     valueClass: Class<*>,     outputFormatClass: Class<F>,     codec: Class<CompressionCodec>)

Output the RDD to any Hadoop-supported file system, compressing with the supplied codec.

Link copied to clipboard
fun <K, V> JavaDStream<Tuple2<K, V>>.saveAsHadoopFiles(prefix: String, suffix: String)

Save each RDD in this DStream as a Hadoop file. The file name at each batch interval is generated based on prefix and suffix: "prefix-TIME_IN_MS.suffix".

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.saveAsNewAPIHadoopDataset(conf: Configuration)

Output the RDD to any Hadoop-supported storage system, using a Configuration object for that storage system.

Link copied to clipboard
fun <K, V, F : OutputFormat<*, *>> JavaRDD<Tuple2<K, V>>.saveAsNewAPIHadoopFile(    path: String,     keyClass: Class<*>,     valueClass: Class<*>,     outputFormatClass: Class<F>)
fun <K, V, F : OutputFormat<*, *>> JavaRDD<Tuple2<K, V>>.saveAsNewAPIHadoopFile(    path: String,     keyClass: Class<*>,     valueClass: Class<*>,     outputFormatClass: Class<F>,     conf: Configuration)

Output the RDD to any Hadoop-supported file system.

Link copied to clipboard
fun <K, V> JavaDStream<Tuple2<K, V>>.saveAsNewAPIHadoopFiles(prefix: String, suffix: String)

Save each RDD in this DStream as a Hadoop file. The file name at each batch interval is generated based on prefix and suffix: "prefix-TIME_IN_MS.suffix".

Link copied to clipboard
fun schema(type: KType, map: Map<String, KType> = mapOf()): DataType

Not meant to be used by the user explicitly.

Link copied to clipboard
inline fun <T, U1> Dataset<T>.selectTyped(c1: TypedColumn<out Any, U1>): Dataset<U1>
inline fun <T, U1, U2> Dataset<T>.selectTyped(c1: TypedColumn<out Any, U1>, c2: TypedColumn<out Any, U2>): Dataset<Tuple2<U1, U2>>
inline fun <T, U1, U2, U3> Dataset<T>.selectTyped(    c1: TypedColumn<out Any, U1>,     c2: TypedColumn<out Any, U2>,     c3: TypedColumn<out Any, U3>): Dataset<Tuple3<U1, U2, U3>>
inline fun <T, U1, U2, U3, U4> Dataset<T>.selectTyped(    c1: TypedColumn<out Any, U1>,     c2: TypedColumn<out Any, U2>,     c3: TypedColumn<out Any, U3>,     c4: TypedColumn<out Any, U4>): Dataset<Tuple4<U1, U2, U3, U4>>
inline fun <T, U1, U2, U3, U4, U5> Dataset<T>.selectTyped(    c1: TypedColumn<out Any, U1>,     c2: TypedColumn<out Any, U2>,     c3: TypedColumn<out Any, U3>,     c4: TypedColumn<out Any, U4>,     c5: TypedColumn<out Any, U5>): Dataset<Tuple5<U1, U2, U3, U4, U5>>

Returns a new Dataset by computing the given Column expressions for each element.

Link copied to clipboard
fun <T> seqOf(vararg elements: T): Seq<T>

Returns a new immutable Seq with the given elements.

Link copied to clipboard
fun SparkContext.setLogLevel(level: SparkLogLevel)

Control our logLevel. This overrides any user-defined log settings.

Link copied to clipboard
operator fun <S> GroupState<S>.setValue(thisRef: Any?, property: KProperty<*>, value: S?)

(Kotlin-specific) Allows the group state object to be used as a delegate. Will be null if it does not exist.

Link copied to clipboard
fun <T> Dataset<T>.showDS(numRows: Int = 20, truncate: Boolean = true): Dataset<T>

Alternative to Dataset.show which returns source dataset. Useful for debug purposes when you need to view content of a dataset as an intermediate operation

Link copied to clipboard
inline fun <DsType> singleCol(colName: String = "value"): TypedColumn<DsType, DsType>

Can be used to create a TypedColumn for a simple Dataset with just one single column called "value".

Link copied to clipboard
inline fun <T> Dataset<T>.singleCol(colName: String = "value"): TypedColumn<T, T>

Can be used to create a TypedColumn for a simple Dataset with just one single column called "value".

Link copied to clipboard
inline fun <T> Dataset<T>.sort(columns: (Dataset<T>) -> Array<Column>): Dataset<T>

Alias for Dataset.sort which forces user to provide sorted columns from the source dataset

fun <T> Dataset<T>.sort(col: KProperty1<T, *>, vararg cols: KProperty1<T, *>): Dataset<T>

Allows to sort data class dataset on one or more of the properties of the data class.

Link copied to clipboard
@JvmName(name = "sortByPairKey")
fun <T1, T2> Dataset<Pair<T1, T2>>.sortByKey(): Dataset<Pair<T1, T2>>

Returns a dataset sorted by the first (first) value of each Pair inside.

@JvmName(name = "sortByArity2Key")
fun <T1, T2> Dataset<Arity2<T1, T2>>.sortByKey(): Dataset<Arity2<T1, T2>>

Returns a dataset sorted by the first (_1) value of each Arity2 inside.

@JvmName(name = "sortByTuple2Key")
fun <T1, T2> Dataset<Tuple2<T1, T2>>.sortByKey(): Dataset<Tuple2<T1, T2>>

Returns a dataset sorted by the first (_1) value of each Tuple2 inside.

fun <K, V> JavaRDD<Tuple2<K, V>>.sortByKey(ascending: Boolean = true): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.sortByKey(comp: Comparator<K>, ascending: Boolean = true): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.sortByKey(ascending: Boolean, numPartitions: Int): JavaRDD<Tuple2<K, V>>
fun <K, V> JavaRDD<Tuple2<K, V>>.sortByKey(comp: Comparator<K>, ascending: Boolean, numPartitions: Int): JavaRDD<Tuple2<K, V>>

Sort the RDD by key, so that each partition contains a sorted range of the elements. Calling JavaRDD.collect or save on the resulting RDD will return or output an ordered list of records (in the save case, they will be written to multiple part-X files in the filesystem, in order of the keys).

Link copied to clipboard
@JvmName(name = "sortByPairValue")
fun <T1, T2> Dataset<Pair<T1, T2>>.sortByValue(): Dataset<Pair<T1, T2>>

Returns a dataset sorted by the second (second) value of each Pair inside.

@JvmName(name = "sortByArity2Value")
fun <T1, T2> Dataset<Arity2<T1, T2>>.sortByValue(): Dataset<Arity2<T1, T2>>

Returns a dataset sorted by the second (_2) value of each Arity2 inside.

@JvmName(name = "sortByTuple2Value")
fun <T1, T2> Dataset<Tuple2<T1, T2>>.sortByValue(): Dataset<Tuple2<T1, T2>>

Returns a dataset sorted by the second (_2) value of each Tuple2 inside.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.stats(): StatCounter

Return a org.apache.spark.util.StatCounter object that captures the mean, variance and count of the RDD's elements in one operation.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.stdev(): Double

Compute the population standard deviation of this RDD's elements.

Link copied to clipboard
fun <K, V, W> JavaRDD<Tuple2<K, V>>.subtractByKey(other: JavaRDD<Tuple2<K, W>>): JavaRDD<Tuple2<K, V>>
fun <K, V, W> JavaRDD<Tuple2<K, V>>.subtractByKey(other: JavaRDD<Tuple2<K, W>>, numPartitions: Int): JavaRDD<Tuple2<K, V>>
fun <K, V, W> JavaRDD<Tuple2<K, V>>.subtractByKey(other: JavaRDD<Tuple2<K, W>>, p: Partitioner): JavaRDD<Tuple2<K, V>>

Return an RDD with the pairs from this whose keys are not in other.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.sum(): Double

Add up the elements in this RDD.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.sumApprox(timeout: Long, confidence: Double = 0.95): PartialResult<BoundedDouble>

Approximate operation to return the sum within a timeout.

Link copied to clipboard
inline fun <T1, T2> Dataset<Pair<T1, T2>>.takeKeys(): Dataset<T1>

(Kotlin-specific) Maps the Dataset to only retain the "keys" or Pair.first values.

@JvmName(name = "takeKeysArity2")
inline fun <T1, T2> Dataset<Arity2<T1, T2>>.takeKeys(): Dataset<T1>

(Kotlin-specific) Maps the Dataset to only retain the "keys" or Arity2._1 values.

@JvmName(name = "takeKeysTuple2")
inline fun <T1, T2> Dataset<Tuple2<T1, T2>>.takeKeys(): Dataset<T1>

(Kotlin-specific) Maps the Dataset to only retain the "keys" or Tuple2._1 values.

Link copied to clipboard
inline fun <T1, T2> Dataset<Pair<T1, T2>>.takeValues(): Dataset<T2>

(Kotlin-specific) Maps the Dataset to only retain the "values" or Pair.second values.

@JvmName(name = "takeValuesArity2")
inline fun <T1, T2> Dataset<Arity2<T1, T2>>.takeValues(): Dataset<T2>

(Kotlin-specific) Maps the Dataset to only retain the "values" or Arity2._2 values.

@JvmName(name = "takeValuesTuple2")
inline fun <T1, T2> Dataset<Tuple2<T1, T2>>.takeValues(): Dataset<T2>

(Kotlin-specific) Maps the Dataset to only retain the "values" or Tuple2._2 values.

Link copied to clipboard
operator fun Column.times(other: Any): Column

Multiplication of this expression and another expression.

Link copied to clipboard
inline fun <R> Dataset<*>.to(): Dataset<R>

(Kotlin-specific) Returns a new Dataset where each record has been mapped on to the specified type. The method used to map columns depend on the type of R:

Link copied to clipboard
fun <T1, T2> Pair<T1, T2>.toArity(): Arity2<T1, T2>

Returns a new Arity2 based on the arguments in the current Pair.

fun <T1, T2, T3> Triple<T1, T2, T3>.toArity(): Arity3<T1, T2, T3>

Returns a new Arity3 based on the arguments in the current Triple.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.toArity(): Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>

Returns a new Arity10 based on this Tuple10.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.toArity(): Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>

Returns a new Arity11 based on this Tuple11.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.toArity(): Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>

Returns a new Arity12 based on this Tuple12.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.toArity(): Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

Returns a new Arity13 based on this Tuple13.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.toArity(): Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

Returns a new Arity14 based on this Tuple14.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.toArity(): Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>

Returns a new Arity15 based on this Tuple15.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.toArity(): Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>

Returns a new Arity16 based on this Tuple16.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.toArity(): Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>

Returns a new Arity17 based on this Tuple17.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.toArity(): Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>

Returns a new Arity18 based on this Tuple18.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.toArity(): Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>

Returns a new Arity19 based on this Tuple19.

fun <T1> Tuple1<T1>.toArity(): Arity1<T1>

Returns a new Arity1 based on this Tuple1.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.toArity(): Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>

Returns a new Arity20 based on this Tuple20.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Tuple21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.toArity(): Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>

Returns a new Arity21 based on this Tuple21.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Tuple22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.toArity(): Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>

Returns a new Arity22 based on this Tuple22.

fun <T1, T2> Tuple2<T1, T2>.toArity(): Arity2<T1, T2>

Returns a new Arity2 based on this Tuple2.

fun <T1, T2, T3> Tuple3<T1, T2, T3>.toArity(): Arity3<T1, T2, T3>

Returns a new Arity3 based on this Tuple3.

fun <T1, T2, T3, T4> Tuple4<T1, T2, T3, T4>.toArity(): Arity4<T1, T2, T3, T4>

Returns a new Arity4 based on this Tuple4.

fun <T1, T2, T3, T4, T5> Tuple5<T1, T2, T3, T4, T5>.toArity(): Arity5<T1, T2, T3, T4, T5>

Returns a new Arity5 based on this Tuple5.

fun <T1, T2, T3, T4, T5, T6> Tuple6<T1, T2, T3, T4, T5, T6>.toArity(): Arity6<T1, T2, T3, T4, T5, T6>

Returns a new Arity6 based on this Tuple6.

fun <T1, T2, T3, T4, T5, T6, T7> Tuple7<T1, T2, T3, T4, T5, T6, T7>.toArity(): Arity7<T1, T2, T3, T4, T5, T6, T7>

Returns a new Arity7 based on this Tuple7.

fun <T1, T2, T3, T4, T5, T6, T7, T8> Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>.toArity(): Arity8<T1, T2, T3, T4, T5, T6, T7, T8>

Returns a new Arity8 based on this Tuple8.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.toArity(): Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>

Returns a new Arity9 based on this Tuple9.

Link copied to clipboard
inline fun <T> Dataset<*>.toArray(): Array<T>

Collects the dataset as Array where each item has been mapped to type T.

Link copied to clipboard
inline fun <T> Array<T>.toDF(spark: SparkSession, vararg colNames: String): Dataset<Row>
inline fun <T> List<T>.toDF(spark: SparkSession, vararg colNames: String): Dataset<Row>
inline fun <T> SparkSession.toDF(list: List<T>, vararg colNames: String): Dataset<Row>

Utility method to create dataframe from list

inline fun <T> JavaRDDLike<T, *>.toDF(spark: SparkSession, vararg colNames: String): Dataset<Row>

Utility method to create Dataset (Dataframe) from JavaRDD. NOTE: T must be Serializable.

inline fun <T> RDD<T>.toDF(spark: SparkSession, vararg colNames: String): Dataset<Row>

Utility method to create Dataset (Dataframe) from RDD. NOTE: T must be Serializable.

Link copied to clipboard
fun JavaDoubleRDD.toDoubleRDD(): JavaRDD<Double>

Utility method to convert JavaDoubleRDD to JavaRDD<Double>.

Link copied to clipboard
inline fun <T> Array<T>.toDS(spark: SparkSession): Dataset<T>
inline fun <T> List<T>.toDS(spark: SparkSession): Dataset<T>
inline fun <T> SparkSession.toDS(list: List<T>): Dataset<T>

Utility method to create dataset from list

inline fun <T> JavaRDDLike<T, *>.toDS(spark: SparkSession): Dataset<T>

Utility method to create dataset from JavaRDD

inline fun <T> RDD<T>.toDS(spark: SparkSession): Dataset<T>

Utility method to create dataset from RDD

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.toJavaDoubleRDD(): JavaDoubleRDD

Utility method to convert JavaRDD<Number> to JavaDoubleRDD.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.toJavaPairRDD(): JavaPairRDD<K, V>

Utility method to convert JavaRDD<Tuple2> to JavaPairRDD.

Link copied to clipboard
inline fun <T> Dataset<*>.toList(): List<T>

Collects the dataset as list where each item has been mapped to type T.

Link copied to clipboard
fun <T> T?.toOption(): Option<T>

Converts nullable value to Scala Option.

fun <T> Optional<T>.toOption(): Option<T>

Converts Java Optional to Scala Option.

Link copied to clipboard
fun <T> T?.toOptional(): Optional<T>

Converts nullable value to Optional.

fun <T> Option<T>.toOptional(): Optional<T>

Converts Scala Option to Java Optional.

Link copied to clipboard
fun <T1, T2> Arity2<T1, T2>.toPair(): Pair<T1, T2>

Returns a new Pair based on the arguments in the current Arity2.

Link copied to clipboard
fun <K, V> JavaDStream<Tuple2<K, V>>.toPairDStream(): JavaPairDStream<K, V>
Link copied to clipboard
fun <T> JavaSparkContext.toRDD(elements: List<T>, numSlices: Int = defaultParallelism()): JavaRDD<T>

Utility method to create an RDD from a list. NOTE: T must be Serializable.

Link copied to clipboard
fun <T1, T2, T3> Arity3<T1, T2, T3>.toTriple(): Triple<T1, T2, T3>

Returns a new Triple based on the arguments in the current Arity3.

Link copied to clipboard
fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Arity10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.toTuple(): Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>

Returns a new Tuple10 based on this Arity10.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Arity11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.toTuple(): Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>

Returns a new Tuple11 based on this Arity11.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Arity12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.toTuple(): Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>

Returns a new Tuple12 based on this Arity12.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Arity13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.toTuple(): Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

Returns a new Tuple13 based on this Arity13.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Arity14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.toTuple(): Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

Returns a new Tuple14 based on this Arity14.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Arity15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.toTuple(): Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>

Returns a new Tuple15 based on this Arity15.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Arity16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>.toTuple(): Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>

Returns a new Tuple16 based on this Arity16.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Arity17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>.toTuple(): Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>

Returns a new Tuple17 based on this Arity17.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Arity18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>.toTuple(): Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>

Returns a new Tuple18 based on this Arity18.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Arity19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>.toTuple(): Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>

Returns a new Tuple19 based on this Arity19.

fun <T1> Arity1<T1>.toTuple(): Tuple1<T1>

Returns a new Tuple1 based on this Arity1.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Arity20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.toTuple(): Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>

Returns a new Tuple20 based on this Arity20.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Arity21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.toTuple(): Tuple21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>

Returns a new Tuple21 based on this Arity21.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Arity22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.toTuple(): Tuple22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>

Returns a new Tuple22 based on this Arity22.

fun <T1, T2> Arity2<T1, T2>.toTuple(): Tuple2<T1, T2>

Returns a new Tuple2 based on this Arity2.

fun <T1, T2, T3> Arity3<T1, T2, T3>.toTuple(): Tuple3<T1, T2, T3>

Returns a new Tuple3 based on this Arity3.

fun <T1, T2, T3, T4> Arity4<T1, T2, T3, T4>.toTuple(): Tuple4<T1, T2, T3, T4>

Returns a new Tuple4 based on this Arity4.

fun <T1, T2, T3, T4, T5> Arity5<T1, T2, T3, T4, T5>.toTuple(): Tuple5<T1, T2, T3, T4, T5>

Returns a new Tuple5 based on this Arity5.

fun <T1, T2, T3, T4, T5, T6> Arity6<T1, T2, T3, T4, T5, T6>.toTuple(): Tuple6<T1, T2, T3, T4, T5, T6>

Returns a new Tuple6 based on this Arity6.

fun <T1, T2, T3, T4, T5, T6, T7> Arity7<T1, T2, T3, T4, T5, T6, T7>.toTuple(): Tuple7<T1, T2, T3, T4, T5, T6, T7>

Returns a new Tuple7 based on this Arity7.

fun <T1, T2, T3, T4, T5, T6, T7, T8> Arity8<T1, T2, T3, T4, T5, T6, T7, T8>.toTuple(): Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>

Returns a new Tuple8 based on this Arity8.

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9> Arity9<T1, T2, T3, T4, T5, T6, T7, T8, T9>.toTuple(): Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>

Returns a new Tuple9 based on this Arity9.

Link copied to clipboard
fun <K, V> JavaPairDStream<K, V>.toTupleDStream(): JavaDStream<Tuple2<K, V>>
Link copied to clipboard
fun <K, V> JavaPairRDD<K, V>.toTupleRDD(): JavaRDD<Tuple2<K, V>>

Utility method to convert JavaPairRDD to JavaRDD<Tuple2>.

Link copied to clipboard
fun <T, R> Iterator<T>.transformAsSequence(func: Sequence<T>.() -> Sequence<R>): Iterator<R>

Allows to transform an Iterator using the Sequence functions.

Link copied to clipboard
inline fun <DsType, T> Column.typed(): TypedColumn<DsType, T>
inline fun <DsType, T> TypedColumn<DsType, *>.typed(): TypedColumn<DsType, T>

Provides a type hint about the expected return value of this column. This information can be used by operations such as select on a Dataset to automatically convert the results into the correct JVM types.

Link copied to clipboard
inline fun <DsType, U> typedLit(literal: U): TypedColumn<DsType, U>

Creates a Column of literal value.

Link copied to clipboard
inline fun <IN, OUT, AGG : Aggregator<IN, *, OUT>> udaf(agg: AGG, nondeterministic: Boolean = false): NamedUserDefinedFunction1<IN, OUT>
inline fun <IN, OUT, AGG : Aggregator<IN, *, OUT>> udaf(    name: String,     agg: AGG,     nondeterministic: Boolean = false): NamedUserDefinedFunction1<IN, OUT>

Obtains a NamedUserDefinedFunction1 that wraps the given agg so that it may be used with Data Frames.

inline fun <IN, BUF, OUT> udaf(    noinline zero: () -> BUF,     noinline reduce: (b: BUF, a: IN) -> BUF,     noinline merge: (b1: BUF, b2: BUF) -> BUF,     noinline finish: (reduction: BUF) -> OUT,     bufferEncoder: Encoder<BUF> = encoder(),     outputEncoder: Encoder<OUT> = encoder(),     nondeterministic: Boolean = false): UserDefinedFunction1<IN, OUT>

Obtains a UserDefinedFunction1 created from an Aggregator created by the given arguments so that it may be used with Data Frames.

inline fun <IN, BUF, OUT> udaf(    name: String,     noinline zero: () -> BUF,     noinline reduce: (b: BUF, a: IN) -> BUF,     noinline merge: (b1: BUF, b2: BUF) -> BUF,     noinline finish: (reduction: BUF) -> OUT,     bufferEncoder: Encoder<BUF> = encoder(),     outputEncoder: Encoder<OUT> = encoder(),     nondeterministic: Boolean = false): NamedUserDefinedFunction1<IN, OUT>

Obtains a NamedUserDefinedFunction1 that wraps the given agg so that it may be used with Data Frames. so that it may be used with Data Frames.

Link copied to clipboard
inline fun <IN, OUT, AGG : Aggregator<IN, *, OUT>> udafUnnamed(agg: AGG, nondeterministic: Boolean = false): UserDefinedFunction1<IN, OUT>

Obtains a UserDefinedFunction1 that wraps the given agg so that it may be used with Data Frames.

Link copied to clipboard
inline fun <R> udf(nondeterministic: Boolean = false, func: UDF0<R>): UserDefinedFunction0<R>

Defines a UDF (UserDefinedFunction0) instance based on the (lambda) function func. For example: val myUdf = udf { -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> udf(    nondeterministic: Boolean = false,     func: UDF10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>): UserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Defines a UDF (UserDefinedFunction10) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> udf(    nondeterministic: Boolean = false,     func: UDF11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>): UserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Defines a UDF (UserDefinedFunction11) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> udf(    nondeterministic: Boolean = false,     func: UDF12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>): UserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Defines a UDF (UserDefinedFunction12) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> udf(    nondeterministic: Boolean = false,     func: UDF13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>): UserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Defines a UDF (UserDefinedFunction13) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> udf(    nondeterministic: Boolean = false,     func: UDF14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>): UserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Defines a UDF (UserDefinedFunction14) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> udf(    nondeterministic: Boolean = false,     func: UDF15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>): UserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Defines a UDF (UserDefinedFunction15) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> udf(    nondeterministic: Boolean = false,     func: UDF16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>): UserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Defines a UDF (UserDefinedFunction16) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> udf(    nondeterministic: Boolean = false,     func: UDF17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>): UserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Defines a UDF (UserDefinedFunction17) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> udf(    nondeterministic: Boolean = false,     func: UDF18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>): UserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Defines a UDF (UserDefinedFunction18) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> udf(    nondeterministic: Boolean = false,     func: UDF19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>): UserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Defines a UDF (UserDefinedFunction19) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19 -> ... }

inline fun <T1, R> udf(nondeterministic: Boolean = false, func: UDF1<T1, R>): UserDefinedFunction1<T1, R>

Defines a UDF (UserDefinedFunction1) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1 -> ... }

@JvmName(name = "udfVarargT")
inline fun <T, R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<Array<T>, R>): UserDefinedFunctionVararg<T, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: Array<T> -> ... }

@JvmName(name = "udfVarargBoolean")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<BooleanArray, R>): UserDefinedFunctionVararg<Boolean, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: BooleanArray -> ... }

@JvmName(name = "udfVarargByte")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<ByteArray, R>): UserDefinedFunctionVararg<Byte, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: ByteArray -> ... }

@JvmName(name = "udfVarargDouble")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<DoubleArray, R>): UserDefinedFunctionVararg<Double, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: DoubleArray -> ... }

@JvmName(name = "udfVarargFloat")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<FloatArray, R>): UserDefinedFunctionVararg<Float, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: FloatArray -> ... }

@JvmName(name = "udfVarargInt")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<IntArray, R>): UserDefinedFunctionVararg<Int, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: IntArray -> ... }

@JvmName(name = "udfVarargLong")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<LongArray, R>): UserDefinedFunctionVararg<Long, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: LongArray -> ... }

@JvmName(name = "udfVarargShort")
inline fun <R> udf(nondeterministic: Boolean = false, varargFunc: UDF1<ShortArray, R>): UserDefinedFunctionVararg<Short, R>

Defines a vararg UDF (UserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf { t1: ShortArray -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> udf(    nondeterministic: Boolean = false,     func: UDF20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>): UserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Defines a UDF (UserDefinedFunction20) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> udf(    nondeterministic: Boolean = false,     func: UDF21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>): UserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Defines a UDF (UserDefinedFunction21) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> udf(    nondeterministic: Boolean = false,     func: UDF22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>): UserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Defines a UDF (UserDefinedFunction22) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21, t22: T22 -> ... }

inline fun <T1, T2, R> udf(nondeterministic: Boolean = false, func: UDF2<T1, T2, R>): UserDefinedFunction2<T1, T2, R>

Defines a UDF (UserDefinedFunction2) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2 -> ... }

inline fun <T1, T2, T3, R> udf(nondeterministic: Boolean = false, func: UDF3<T1, T2, T3, R>): UserDefinedFunction3<T1, T2, T3, R>

Defines a UDF (UserDefinedFunction3) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3 -> ... }

inline fun <T1, T2, T3, T4, R> udf(nondeterministic: Boolean = false, func: UDF4<T1, T2, T3, T4, R>): UserDefinedFunction4<T1, T2, T3, T4, R>

Defines a UDF (UserDefinedFunction4) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4 -> ... }

inline fun <T1, T2, T3, T4, T5, R> udf(    nondeterministic: Boolean = false,     func: UDF5<T1, T2, T3, T4, T5, R>): UserDefinedFunction5<T1, T2, T3, T4, T5, R>

Defines a UDF (UserDefinedFunction5) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, R> udf(    nondeterministic: Boolean = false,     func: UDF6<T1, T2, T3, T4, T5, T6, R>): UserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Defines a UDF (UserDefinedFunction6) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, R> udf(    nondeterministic: Boolean = false,     func: UDF7<T1, T2, T3, T4, T5, T6, T7, R>): UserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Defines a UDF (UserDefinedFunction7) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> udf(    nondeterministic: Boolean = false,     func: UDF8<T1, T2, T3, T4, T5, T6, T7, T8, R>): UserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Defines a UDF (UserDefinedFunction8) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> udf(    nondeterministic: Boolean = false,     func: UDF9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>): UserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Defines a UDF (UserDefinedFunction9) instance based on the (lambda) function func. For example: val myUdf = udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9 -> ... }

inline fun <R> udf(func: () -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>
inline fun <R> udf(func: KProperty0<() -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>

Creates a UDF (NamedUserDefinedFunction0) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Creates a UDF (NamedUserDefinedFunction10) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Creates a UDF (NamedUserDefinedFunction11) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Creates a UDF (NamedUserDefinedFunction12) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Creates a UDF (NamedUserDefinedFunction13) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Creates a UDF (NamedUserDefinedFunction14) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Creates a UDF (NamedUserDefinedFunction15) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Creates a UDF (NamedUserDefinedFunction16) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Creates a UDF (NamedUserDefinedFunction17) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Creates a UDF (NamedUserDefinedFunction18) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Creates a UDF (NamedUserDefinedFunction19) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, R> udf(func: (T1) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>
inline fun <T1, R> udf(func: KProperty0<(T1) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>

Creates a UDF (NamedUserDefinedFunction1) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

@JvmName(name = "udfVarargT")
inline fun <T, R> udf(varargFunc: (Array<T>) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "udfVarargBoolean")
inline fun <R> udf(varargFunc: (BooleanArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "udfVarargByte")
inline fun <R> udf(varargFunc: (ByteArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "udfVarargDouble")
inline fun <R> udf(varargFunc: (DoubleArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "udfVarargFloat")
inline fun <R> udf(varargFunc: (FloatArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "udfVarargInt")
inline fun <R> udf(varargFunc: (IntArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "udfVarargLong")
inline fun <R> udf(varargFunc: (LongArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "udfVarargShort")
inline fun <R> udf(varargFunc: (ShortArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>
@JvmName(name = "udfVarargT")
inline fun <T, R> udf(varargFunc: KProperty0<(Array<T>) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "udfVarargBoolean")
inline fun <R> udf(    varargFunc: KProperty0<(BooleanArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "udfVarargByte")
inline fun <R> udf(varargFunc: KProperty0<(ByteArray) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "udfVarargDouble")
inline fun <R> udf(varargFunc: KProperty0<(DoubleArray) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "udfVarargFloat")
inline fun <R> udf(varargFunc: KProperty0<(FloatArray) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "udfVarargInt")
inline fun <R> udf(varargFunc: KProperty0<(IntArray) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "udfVarargLong")
inline fun <R> udf(varargFunc: KProperty0<(LongArray) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "udfVarargShort")
inline fun <R> udf(varargFunc: KProperty0<(ShortArray) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>

Creates a vararg UDF (NamedUserDefinedFunctionVararg) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Creates a UDF (NamedUserDefinedFunction20) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Creates a UDF (NamedUserDefinedFunction21) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Creates a UDF (NamedUserDefinedFunction22) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, R> udf(func: (T1, T2) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>
inline fun <T1, T2, R> udf(func: KProperty0<(T1, T2) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>

Creates a UDF (NamedUserDefinedFunction2) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, R> udf(func: (T1, T2, T3) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>
inline fun <T1, T2, T3, R> udf(func: KProperty0<(T1, T2, T3) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>

Creates a UDF (NamedUserDefinedFunction3) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, R> udf(func: (T1, T2, T3, T4) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>
inline fun <T1, T2, T3, T4, R> udf(    func: KProperty0<(T1, T2, T3, T4) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>

Creates a UDF (NamedUserDefinedFunction4) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, R> udf(    func: (T1, T2, T3, T4, T5) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>
inline fun <T1, T2, T3, T4, T5, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>

Creates a UDF (NamedUserDefinedFunction5) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, R> udf(    func: (T1, T2, T3, T4, T5, T6) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>
inline fun <T1, T2, T3, T4, T5, T6, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Creates a UDF (NamedUserDefinedFunction6) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Creates a UDF (NamedUserDefinedFunction7) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Creates a UDF (NamedUserDefinedFunction8) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> udf(    func: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> udf(    func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Creates a UDF (NamedUserDefinedFunction9) from a function reference adapting its name by reflection. For example: val myUdf = udf(::myFunction)

inline fun <R> udf(name: String, nondeterministic: Boolean = false, func: UDF0<R>): NamedUserDefinedFunction0<R>

Defines a named UDF (NamedUserDefinedFunction0) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { -> ... } Name can also be supplied using delegate: val myUdf by udf { -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Defines a named UDF (NamedUserDefinedFunction10) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Defines a named UDF (NamedUserDefinedFunction11) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Defines a named UDF (NamedUserDefinedFunction12) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Defines a named UDF (NamedUserDefinedFunction13) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Defines a named UDF (NamedUserDefinedFunction14) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Defines a named UDF (NamedUserDefinedFunction15) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Defines a named UDF (NamedUserDefinedFunction16) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Defines a named UDF (NamedUserDefinedFunction17) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Defines a named UDF (NamedUserDefinedFunction18) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Defines a named UDF (NamedUserDefinedFunction19) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19 -> ... }

inline fun <T1, R> udf(name: String, nondeterministic: Boolean = false, func: UDF1<T1, R>): NamedUserDefinedFunction1<T1, R>

Defines a named UDF (NamedUserDefinedFunction1) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1 -> ... }

@JvmName(name = "udfVarargT")
inline fun <T, R> udf(name: String, nondeterministic: Boolean = false, varargFunc: UDF1<Array<T>, R>): NamedUserDefinedFunctionVararg<T, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: Array<T> -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: Array<T> -> ... }

@JvmName(name = "udfVarargBoolean")
inline fun <R> udf(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<BooleanArray, R>): NamedUserDefinedFunctionVararg<Boolean, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: BooleanArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: BooleanArray -> ... }

@JvmName(name = "udfVarargByte")
inline fun <R> udf(name: String, nondeterministic: Boolean = false, varargFunc: UDF1<ByteArray, R>): NamedUserDefinedFunctionVararg<Byte, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: ByteArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: ByteArray -> ... }

@JvmName(name = "udfVarargDouble")
inline fun <R> udf(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<DoubleArray, R>): NamedUserDefinedFunctionVararg<Double, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: DoubleArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: DoubleArray -> ... }

@JvmName(name = "udfVarargFloat")
inline fun <R> udf(name: String, nondeterministic: Boolean = false, varargFunc: UDF1<FloatArray, R>): NamedUserDefinedFunctionVararg<Float, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: FloatArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: FloatArray -> ... }

@JvmName(name = "udfVarargInt")
inline fun <R> udf(name: String, nondeterministic: Boolean = false, varargFunc: UDF1<IntArray, R>): NamedUserDefinedFunctionVararg<Int, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: IntArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: IntArray -> ... }

@JvmName(name = "udfVarargLong")
inline fun <R> udf(name: String, nondeterministic: Boolean = false, varargFunc: UDF1<LongArray, R>): NamedUserDefinedFunctionVararg<Long, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: LongArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: LongArray -> ... }

@JvmName(name = "udfVarargShort")
inline fun <R> udf(    name: String,     nondeterministic: Boolean = false,     varargFunc: UDF1<ShortArray, R>): NamedUserDefinedFunctionVararg<Short, R>

Defines a named vararg UDF (NamedUserDefinedFunctionVararg) instance based on the (lambda) function varargFunc. For example: val myUdf = udf("myUdf") { t1: ShortArray -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: ShortArray -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Defines a named UDF (NamedUserDefinedFunction20) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Defines a named UDF (NamedUserDefinedFunction21) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Defines a named UDF (NamedUserDefinedFunction22) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21, t22: T22 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19, t20: T20, t21: T21, t22: T22 -> ... }

inline fun <T1, T2, R> udf(name: String, nondeterministic: Boolean = false, func: UDF2<T1, T2, R>): NamedUserDefinedFunction2<T1, T2, R>

Defines a named UDF (NamedUserDefinedFunction2) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2 -> ... }

inline fun <T1, T2, T3, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF3<T1, T2, T3, R>): NamedUserDefinedFunction3<T1, T2, T3, R>

Defines a named UDF (NamedUserDefinedFunction3) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3 -> ... }

inline fun <T1, T2, T3, T4, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF4<T1, T2, T3, T4, R>): NamedUserDefinedFunction4<T1, T2, T3, T4, R>

Defines a named UDF (NamedUserDefinedFunction4) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4 -> ... }

inline fun <T1, T2, T3, T4, T5, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF5<T1, T2, T3, T4, T5, R>): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>

Defines a named UDF (NamedUserDefinedFunction5) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF6<T1, T2, T3, T4, T5, T6, R>): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Defines a named UDF (NamedUserDefinedFunction6) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF7<T1, T2, T3, T4, T5, T6, T7, R>): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Defines a named UDF (NamedUserDefinedFunction7) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF8<T1, T2, T3, T4, T5, T6, T7, T8, R>): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Defines a named UDF (NamedUserDefinedFunction8) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8 -> ... }

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> udf(    name: String,     nondeterministic: Boolean = false,     func: UDF9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Defines a named UDF (NamedUserDefinedFunction9) instance based on the (lambda) function func. For example: val myUdf = udf("myUdf") { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9 -> ... } Name can also be supplied using delegate: val myUdf by udf { t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9 -> ... }

inline fun <R> udf(name: String, func: () -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>
inline fun <R> udf(name: String, func: KProperty0<() -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction0<R>

Creates a UDF (NamedUserDefinedFunction0) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>

Creates a UDF (NamedUserDefinedFunction10) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>

Creates a UDF (NamedUserDefinedFunction11) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>

Creates a UDF (NamedUserDefinedFunction12) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>

Creates a UDF (NamedUserDefinedFunction13) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>

Creates a UDF (NamedUserDefinedFunction14) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>

Creates a UDF (NamedUserDefinedFunction15) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R>

Creates a UDF (NamedUserDefinedFunction16) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R>

Creates a UDF (NamedUserDefinedFunction17) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R>

Creates a UDF (NamedUserDefinedFunction18) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R>

Creates a UDF (NamedUserDefinedFunction19) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, R> udf(name: String, func: (T1) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>
inline fun <T1, R> udf(name: String, func: KProperty0<(T1) -> R>, nondeterministic: Boolean = false): NamedUserDefinedFunction1<T1, R>

Creates a UDF (NamedUserDefinedFunction1) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

@JvmName(name = "udfVarargT")
inline fun <T, R> udf(name: String, varargFunc: (Array<T>) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "udfVarargBoolean")
inline fun <R> udf(    name: String,     varargFunc: (BooleanArray) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "udfVarargByte")
inline fun <R> udf(name: String, varargFunc: (ByteArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "udfVarargDouble")
inline fun <R> udf(name: String, varargFunc: (DoubleArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "udfVarargFloat")
inline fun <R> udf(name: String, varargFunc: (FloatArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "udfVarargInt")
inline fun <R> udf(name: String, varargFunc: (IntArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "udfVarargLong")
inline fun <R> udf(name: String, varargFunc: (LongArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "udfVarargShort")
inline fun <R> udf(name: String, varargFunc: (ShortArray) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>
@JvmName(name = "udfVarargT")
inline fun <T, R> udf(    name: String,     varargFunc: KProperty0<(Array<T>) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<T, R>
@JvmName(name = "udfVarargBoolean")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(BooleanArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Boolean, R>
@JvmName(name = "udfVarargByte")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(ByteArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Byte, R>
@JvmName(name = "udfVarargDouble")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(DoubleArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Double, R>
@JvmName(name = "udfVarargFloat")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(FloatArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Float, R>
@JvmName(name = "udfVarargInt")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(IntArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Int, R>
@JvmName(name = "udfVarargLong")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(LongArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Long, R>
@JvmName(name = "udfVarargShort")
inline fun <R> udf(    name: String,     varargFunc: KProperty0<(ShortArray) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunctionVararg<Short, R>

Creates a vararg UDF (NamedUserDefinedFunctionVararg) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R>

Creates a UDF (NamedUserDefinedFunction20) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R>

Creates a UDF (NamedUserDefinedFunction21) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R>

Creates a UDF (NamedUserDefinedFunction22) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, R> udf(name: String, func: (T1, T2) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>
inline fun <T1, T2, R> udf(    name: String,     func: KProperty0<(T1, T2) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction2<T1, T2, R>

Creates a UDF (NamedUserDefinedFunction2) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, R> udf(name: String, func: (T1, T2, T3) -> R, nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>
inline fun <T1, T2, T3, R> udf(    name: String,     func: KProperty0<(T1, T2, T3) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction3<T1, T2, T3, R>

Creates a UDF (NamedUserDefinedFunction3) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, R> udf(    name: String,     func: (T1, T2, T3, T4) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>
inline fun <T1, T2, T3, T4, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction4<T1, T2, T3, T4, R>

Creates a UDF (NamedUserDefinedFunction4) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, R> udf(    name: String,     func: (T1, T2, T3, T4, T5) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>
inline fun <T1, T2, T3, T4, T5, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction5<T1, T2, T3, T4, T5, R>

Creates a UDF (NamedUserDefinedFunction5) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>
inline fun <T1, T2, T3, T4, T5, T6, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction6<T1, T2, T3, T4, T5, T6, R>

Creates a UDF (NamedUserDefinedFunction6) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction7<T1, T2, T3, T4, T5, T6, T7, R>

Creates a UDF (NamedUserDefinedFunction7) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R>

Creates a UDF (NamedUserDefinedFunction8) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> udf(    name: String,     func: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>
inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> udf(    name: String,     func: KProperty0<(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>,     nondeterministic: Boolean = false): NamedUserDefinedFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>

Creates a UDF (NamedUserDefinedFunction9) from a function reference. For example: val myUdf = udf("myFunction", ::myFunction)

Link copied to clipboard
operator fun Column.unaryMinus(): Column

Unary minus, i.e. negate the expression.

Link copied to clipboard
fun DataType.unWrap(): DataType

Unwraps DataTypeWithClass.

Link copied to clipboard
@JvmName(name = "updateStateByKeyNullable")
fun <K, V, S> JavaDStream<Tuple2<K, V>>.updateStateByKey(    numPartitions: Int = dstream().ssc().sc().defaultParallelism(),     updateFunc: (List<V>, S?) -> S?): JavaDStream<Tuple2<K, S>>
@JvmName(name = "updateStateByKey")
fun <K, V, S> JavaDStream<Tuple2<K, V>>.updateStateByKey(    numPartitions: Int = dstream().ssc().sc().defaultParallelism(),     updateFunc: (List<V>, Optional<S>) -> Optional<S>): JavaDStream<Tuple2<K, S>>

Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. In every batch the updateFunc will be called for each state even if there are no new values. Hash partitioning is used to generate the RDDs with Spark's default number of partitions. Note: Needs checkpoint directory to be set.

@JvmName(name = "updateStateByKeyNullable")
fun <K, V, S> JavaDStream<Tuple2<K, V>>.updateStateByKey(    partitioner: Partitioner,     updateFunc: (List<V>, S?) -> S?): JavaDStream<Tuple2<K, S>>
fun <K, V, S> JavaDStream<Tuple2<K, V>>.updateStateByKey(    partitioner: Partitioner,     updateFunc: (List<V>, Optional<S>) -> Optional<S>): JavaDStream<Tuple2<K, S>>

Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. In every batch the updateFunc will be called for each state even if there are no new values. [org.apache.spark.Partitioner] is used to control the partitioning of each RDD. Note: Needs checkpoint directory to be set.

@JvmName(name = "updateStateByKeyNullable")
fun <K, V, S> JavaDStream<Tuple2<K, V>>.updateStateByKey(    partitioner: Partitioner,     initialRDD: JavaRDD<Tuple2<K, S>>,     updateFunc: (List<V>, S?) -> S?): JavaDStream<Tuple2<K, S>>
fun <K, V, S> JavaDStream<Tuple2<K, V>>.updateStateByKey(    partitioner: Partitioner,     initialRDD: JavaRDD<Tuple2<K, S>>,     updateFunc: (List<V>, Optional<S>) -> Optional<S>): JavaDStream<Tuple2<K, S>>

Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of the key. org.apache.spark.Partitioner is used to control the partitioning of each RDD. Note: Needs checkpoint directory to be set.

Link copied to clipboard
fun <K, V> JavaRDD<Tuple2<K, V>>.values(): JavaRDD<V>

Return an RDD with the values of each tuple.

Link copied to clipboard
inline fun <T : Number> JavaRDD<T>.variance(): Double

Compute the population variance of this RDD's elements.

Link copied to clipboard
inline fun <T, R> Dataset<T>.withCached(blockingUnpersist: Boolean = false, executeOnCached: Dataset<T>.() -> R): R

This function creates block, where one can call any further computations on already cached dataset Data will be unpersisted automatically at the end of computation

Link copied to clipboard
@JvmOverloads
inline fun withSpark(sparkConf: SparkConf, logLevel: SparkLogLevel = ERROR, func: KSparkSession.() -> Unit)

Wrapper for spark creation which copies params from sparkConf.

@JvmOverloads
inline fun withSpark(builder: SparkSession.Builder, logLevel: SparkLogLevel = ERROR, func: KSparkSession.() -> Unit)
@JvmOverloads
inline fun withSpark(    props: Map<String, Any> = emptyMap(),     master: String = SparkConf().get("spark.master", "local[*]"),     appName: String = "Kotlin Spark Sample",     logLevel: SparkLogLevel = ERROR,     func: KSparkSession.() -> Unit)

Wrapper for spark creation which allows setting different spark params.

Link copied to clipboard
@JvmOverloads
fun withSparkStreaming(    batchDuration: Duration = Durations.seconds(1L),     checkpointPath: String? = null,     hadoopConf: Configuration = SparkHadoopUtil.get().conf(),     createOnError: Boolean = false,     props: Map<String, Any> = emptyMap(),     master: String = SparkConf().get("spark.master", "local[*]"),     appName: String = "Kotlin Spark Sample",     timeout: Long = -1L,     startStreamingContext: Boolean = true,     func: KSparkStreamingSession.() -> Unit)

Wrapper for spark streaming creation. spark: SparkSession and ssc: JavaStreamingContext are provided, started, awaited, and stopped automatically. The use of a checkpoint directory is optional. If checkpoint data exists in the provided checkpointPath, then StreamingContext will be recreated from the checkpoint data. If the data does not exist, then the provided factory will be used to create a JavaStreamingContext.