updating docs and readme

Author: Jolanrensen

README.md

@@ -245,7 +245,7 @@ The concept of `EmptyTuple` from Scala 3 is also already present:
 tupleOf(1).dropLast() == tupleOf() == emptyTuple()
 ```
 
-Finally, all these helper functions are also baked in:
+Finally, all these tuple helper functions are also baked in:
 
 - `componentX()` for destructuring: `val (a, b) = tuple`
 - `dropLast() / dropFirst()`
@@ -257,10 +257,15 @@ Finally, all these helper functions are also baked in:
 - `getOrNull(n) / getOrNull(i..j)`
 - `getAs<T>(n) / getAs<T>(i..j)`
 - `getAsOrNull<T>(n) / getAsOrNull<T>(i..j)`
-- `zip`
 - `copy(_1 = ..., _5 = ...)`
 - `first() / last()`
 - `_1`, `_6` etc. (instead of `_1()`, `_6()`)
+- `zip`
+- `dropN() / dropLastN()`
+- `takeN() / takeLastN()`
+- `splitAtN()`
+- `map`
+- `cast`
 
 ## Examples
 

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/DestructuredTupleBuilders.kt

@@ -45,6 +45,9 @@ import scala.Tuple22
 
 /**
  * This file provides a descriptive way to create Tuples using [X].
+ * Only use [X] to create new Tuples.
+ * To create Tuples of Tuples, it's recommended to use [t] or [tupleOf] instead as using [X] can lead
+ * to unexpected results.
  *
  * For instance:
  * ```val yourTuple = 1 X "test" X a```

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/DropFunctions.kt

@@ -47,7 +47,9 @@ import scala.Tuple22
  * This can be done using [dropFirst] and [dropLast].
  *
  * For example:
- * ```val yourTuple: Tuple2<Int, String> = tupleOf(1, "test", a).dropLast()```
+ * ```kotlin
+ * val yourTuple: Tuple2<Int, String> = tupleOf(1, "test", a).dropLast()
+ * ```
  *
  */
 

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/MapTuples.kt

@@ -2,6 +2,25 @@ package org.jetbrains.kotlinx.spark.api.tuples
 
 import scala.*
 
+/**
+ * This file provides map-functions to all Tuple variants.
+ * Given a tuple `t(a1, ..., an)`, returns a new tuple `t(func(a1), ..., func(an))`.
+ * Compared to Scala 3, no type mapping can occur in Kotlin, so to create a `TupleX<T1, T2, ...>`
+ * the user will need to explicitly [cast] the result.
+ *
+ * For example:
+ * ```kotlin
+ * val myTuple: Tuple4<Int, String, Int, String> = t(1, "3", 2, "4")
+ * val myStringTuple: Tuple4<String, Int, String, Int> = myTuple.map {
+ *     when (it) {
+ *         is Int -> it.toString()
+ *         is String -> it.toInt()
+ *         else -> error("")
+ *     }
+ * }.cast<String, Int, String, Int>()
+ * ```
+ */
+
 fun <T, R, T1: T> Tuple1<T1>.map(func: (T) -> R): Tuple1<R> = Tuple1<R>(func(this._1()))
 fun <T, R, T1: T, T2: T> Tuple2<T1, T2>.map(func: (T) -> R): Tuple2<R, R> = Tuple2<R, R>(func(this._1()), func(this._2()))
 fun <T, R, T1: T, T2: T, T3: T> Tuple3<T1, T2, T3>.map(func: (T) -> R): Tuple3<R, R, R> = Tuple3<R, R, R>(func(this._1()), func(this._2()), func(this._3()))
@@ -24,3 +43,26 @@ fun <T, R, T1: T, T2: T, T3: T, T4: T, T5: T, T6: T, T7: T, T8: T, T9: T, T10: T
 fun <T, R, T1: T, T2: T, T3: T, T4: T, T5: T, T6: T, T7: T, T8: T, T9: T, T10: T, T11: T, T12: T, T13: T, T14: T, T15: T, T16: T, T17: T, T18: T, T19: T, T20: T> Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>.map(func: (T) -> R): Tuple20<R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R> = Tuple20<R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R>(func(this._1()), func(this._2()), func(this._3()), func(this._4()), func(this._5()), func(this._6()), func(this._7()), func(this._8()), func(this._9()), func(this._10()), func(this._11()), func(this._12()), func(this._13()), func(this._14()), func(this._15()), func(this._16()), func(this._17()), func(this._18()), func(this._19()), func(this._20()))
 fun <T, R, T1: T, T2: T, T3: T, T4: T, T5: T, T6: T, T7: T, T8: T, T9: T, T10: T, T11: T, T12: T, T13: T, T14: T, T15: T, T16: T, T17: T, T18: T, T19: T, T20: T, T21: T> Tuple21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>.map(func: (T) -> R): Tuple21<R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R> = Tuple21<R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R>(func(this._1()), func(this._2()), func(this._3()), func(this._4()), func(this._5()), func(this._6()), func(this._7()), func(this._8()), func(this._9()), func(this._10()), func(this._11()), func(this._12()), func(this._13()), func(this._14()), func(this._15()), func(this._16()), func(this._17()), func(this._18()), func(this._19()), func(this._20()), func(this._21()))
 fun <T, R, T1: T, T2: T, T3: T, T4: T, T5: T, T6: T, T7: T, T8: T, T9: T, T10: T, T11: T, T12: T, T13: T, T14: T, T15: T, T16: T, T17: T, T18: T, T19: T, T20: T, T21: T, T22: T> Tuple22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>.map(func: (T) -> R): Tuple22<R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R> = Tuple22<R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R>(func(this._1()), func(this._2()), func(this._3()), func(this._4()), func(this._5()), func(this._6()), func(this._7()), func(this._8()), func(this._9()), func(this._10()), func(this._11()), func(this._12()), func(this._13()), func(this._14()), func(this._15()), func(this._16()), func(this._17()), func(this._18()), func(this._19()), func(this._20()), func(this._21()), func(this._22()))
+
+inline fun <reified T1> Tuple1<*>.cast(): Tuple1<T1> = Tuple1<T1>(this._1() as T1)
+inline fun <reified T1, reified T2> Tuple2<*, *>.cast(): Tuple2<T1, T2> = Tuple2<T1, T2>(this._1() as T1, this._2() as T2)
+inline fun <reified T1, reified T2, reified T3> Tuple3<*, *, *>.cast(): Tuple3<T1, T2, T3> = Tuple3<T1, T2, T3>(this._1() as T1, this._2() as T2, this._3() as T3)
+inline fun <reified T1, reified T2, reified T3, reified T4> Tuple4<*, *, *, *>.cast(): Tuple4<T1, T2, T3, T4> = Tuple4<T1, T2, T3, T4>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5> Tuple5<*, *, *, *, *>.cast(): Tuple5<T1, T2, T3, T4, T5> = Tuple5<T1, T2, T3, T4, T5>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Tuple6<*, *, *, *, *, *>.cast(): Tuple6<T1, T2, T3, T4, T5, T6> = Tuple6<T1, T2, T3, T4, T5, T6>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Tuple7<*, *, *, *, *, *, *>.cast(): Tuple7<T1, T2, T3, T4, T5, T6, T7> = Tuple7<T1, T2, T3, T4, T5, T6, T7>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Tuple8<*, *, *, *, *, *, *, *>.cast(): Tuple8<T1, T2, T3, T4, T5, T6, T7, T8> = Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Tuple9<*, *, *, *, *, *, *, *, *>.cast(): Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9> = Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Tuple10<*, *, *, *, *, *, *, *, *, *>.cast(): Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> = Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Tuple11<*, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> = Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Tuple12<*, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple12<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Tuple13<*, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple13<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Tuple14<*, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple14<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Tuple15<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple15<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Tuple16<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple16<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Tuple17<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple17<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16, this._17() as T17)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Tuple18<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple18<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16, this._17() as T17, this._18() as T18)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Tuple19<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple19<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16, this._17() as T17, this._18() as T18, this._19() as T19)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Tuple20<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple20<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16, this._17() as T17, this._18() as T18, this._19() as T19, this._20() as T20)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Tuple21<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple21<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16, this._17() as T17, this._18() as T18, this._19() as T19, this._20() as T20, this._21() as T21)
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Tuple22<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *>.cast(): Tuple22<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>(this._1() as T1, this._2() as T2, this._3() as T3, this._4() as T4, this._5() as T5, this._6() as T6, this._7() as T7, this._8() as T8, this._9() as T9, this._10() as T10, this._11() as T11, this._12() as T12, this._13() as T13, this._14() as T14, this._15() as T15, this._16() as T16, this._17() as T17, this._18() as T18, this._19() as T19, this._20() as T20, this._21() as T21, this._22() as T22)

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/TupleDrop.kt

@@ -2,6 +2,17 @@ package org.jetbrains.kotlinx.spark.api.tuples
 
 import scala.*
 
+/**
+ * This file contains all functions to drop N items from the beginning or end of a Tuple.
+ * If all items are dropped, the result will be [EmptyTuple].
+ *
+ * For example:
+ * ```kotlin
+ * tupleOf(1, 2, 3, 4).drop2() == tupleOf(3, 4)
+ * tupleOf(1, 2, 3, 4).dropLast2() == tupleOf(1, 2)
+ * ```
+ */
+
 fun <T1> Tuple1<T1>.drop0(): Tuple1<T1> = Tuple1<T1>(this._1())
 fun Tuple1<*>.drop1(): EmptyTuple = EmptyTuple
 fun <T1, T2> Tuple2<T1, T2>.drop0(): Tuple2<T1, T2> = Tuple2<T1, T2>(this._1(), this._2())

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/TupleSplit.kt

@@ -2,6 +2,18 @@ package org.jetbrains.kotlinx.spark.api.tuples
 
 import scala.*
 
+/**
+ * Given a tuple `t(a1, ..., am)`, returns a [Tuple2] of the tuple `t(a1, ..., an)`
+ *  consisting of the first n elements, and the tuple `t(an+1, ..., am)` consisting
+ *  of the remaining elements.
+ *  Splitting at 0 or at n results in `t(t(), myTuple)` or `t(myTuple, t())` respectively.
+ *
+ *  For example:
+ *  ```kotlin
+ *  t(1, 2, 3, 4, 5).splitAt2() == t(t(1, 2), t(3, 4, 5))
+ *  ```
+ */
+
 fun <T1> Tuple1<T1>.splitAt0(): Tuple2<EmptyTuple, Tuple1<T1>> = Tuple2<EmptyTuple, Tuple1<T1>>(EmptyTuple, Tuple1<T1>(this._1()))
 fun <T1> Tuple1<T1>.splitAt1(): Tuple2<Tuple1<T1>, EmptyTuple> = Tuple2<Tuple1<T1>, EmptyTuple>(Tuple1<T1>(this._1()), EmptyTuple)
 fun <T1, T2> Tuple2<T1, T2>.splitAt0(): Tuple2<EmptyTuple, Tuple2<T1, T2>> = Tuple2<EmptyTuple, Tuple2<T1, T2>>(EmptyTuple, Tuple2<T1, T2>(this._1(), this._2()))

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/TupleTake.kt

@@ -1,6 +1,18 @@
 package org.jetbrains.kotlinx.spark.api.tuples
 
 import scala.*
+
+/**
+ * This file contains all functions to take N items from the beginning or end of a Tuple.
+ * If 0 items are taken, the result will be [EmptyTuple].
+ *
+ * For example:
+ * ```kotlin
+ * tupleOf(1, 2, 3, 4).take2() == tupleOf(1, 2)
+ * tupleOf(1, 2, 3, 4).takeLast2() == tupleOf(3, 4)
+ * ```
+ */
+
 fun Tuple1<*>.take0(): EmptyTuple = EmptyTuple
 fun <T1> Tuple1<T1>.take1(): Tuple1<T1> = Tuple1<T1>(this._1())
 fun Tuple2<*, *>.take0(): EmptyTuple = EmptyTuple

kotlin-spark-api/3.2/src/main/kotlin/org/jetbrains/kotlinx/spark/api/tuples/TupleZip.kt

@@ -4,11 +4,10 @@ import scala.*
 
 /**
  * This file provides zip-functions to all Tuple variants.
- * Given two tuples, `t(a1, ..., an)` and `t(a1, ..., an)`, returns a tuple
+ * Given two tuples, `t(a1, ..., an) zip t(a1, ..., an)`, returns a tuple
  *  `t(t(a1, b1), ..., t(an, bn))`. If the two tuples have different sizes,
  *  the extra elements of the larger tuple will be disregarded.
  *  The result is typed as `TupleX<Tuple2<TA1, TB1>, ..., Tuple2<TAn, TBn>>`.
- *
  */
 
 infix fun Tuple1<*>.zip(other: EmptyTuple): EmptyTuple = EmptyTuple

kotlin-spark-api/3.2/src/test/kotlin/org/jetbrains/kotlinx/spark/api/TuplesTest.kt

@@ -186,9 +186,15 @@ class TuplesTest : ShouldSpec({
         }
 
         should("Map tuples") {
-            t(1, 2.toShort(), 3L, 4.0, 5).map {
-                it.toString()
-            } shouldBe t("1", "2", "3", "4.0", "5")
+            t(1, 2.toShort(), 3L, 4.0, 5)
+                .map { it.toString() }
+                .shouldBe(
+                    t("1", "2", "3", "4.0", "5")
+                )
+
+            shouldThrow<ClassCastException> {
+                t(1, "2", 3L).cast<String, Int, Double>()
+            }
         }
 
         should("Take n from tuples") {