Add take and drop methods on Tuples

Author: Antoine Brunner

library/src/scala/Tuple.scala

@@ -43,14 +43,31 @@ sealed trait Tuple extends Any {
   inline def zip[This >: this.type <: Tuple, T2 <: Tuple](t2: T2): Zip[This, T2] =
     DynamicTuple.dynamicZip(this, t2)
 
- /** Called on a tuple `(a1, ..., an)`, returns a new tuple `(f(a1), ..., f(an))`.
-  *  The result is typed as `(F[A1], ..., F[An])` if the tuple type is fully known.
-  *  If the tuple is of the form `a1 *: ... *: Tuple` (that is, the tail is not known
-  *  to be the cons type.
-  */
+  /** Called on a tuple `(a1, ..., an)`, returns a new tuple `(f(a1), ..., f(an))`.
+   *  The result is typed as `(F[A1], ..., F[An])` if the tuple type is fully known.
+   *  If the tuple is of the form `a1 *: ... *: Tuple` (that is, the tail is not known
+   *  to be the cons type.
+   */
   inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] =
     DynamicTuple.dynamicMap(this, f)
 
+  /** Given a tuple `(a1, ..., am)`, returns the tuple `(a1, ..., an)` consisting
+   *  of its first n elements.
+   */
+  inline def take[This >: this.type <: Tuple](n: Int): Take[This, n.type] =
+    DynamicTuple.dynamicTake[This, n.type](this, n)
+
+
+  /** Given a tuple `(a1, ..., am)`, returns the tuple `(an+1, ..., am)` consisting
+   *  all its elements except the first n ones.
+   */
+  inline def drop[This >: this.type <: Tuple](n: Int): Drop[This, n.type] =
+    DynamicTuple.dynamicDrop[This, n.type](this, n)
+
+  /** Given a tuple `(a1, ..., am)`, returns a pair of the tuple `(a1, ..., an)`
+   *  consisting of the first n elements, and the tuple `(an+1, ..., am)` consisting
+   *  of the remaining elements.
+   */
   inline def splitAt[This >: this.type <: Tuple](n: Int): Split[This, n.type] =
     DynamicTuple.dynamicSplitAt[This, n.type](this, n)
 }

library/src/scala/runtime/DynamicTuple.scala

@@ -1,6 +1,6 @@
 package scala.runtime
 
-import scala.Tuple.{ Concat, Size, Head, Tail, Elem, Zip, Map, Split }
+import scala.Tuple.{ Concat, Size, Head, Tail, Elem, Zip, Map, Take, Drop, Split }
 
 object DynamicTuple {
   inline val MaxSpecialized = 22
@@ -264,6 +264,33 @@ object DynamicTuple {
         .asInstanceOf[Map[This, F]]
   }
 
+  def dynamicTake[This <: Tuple, N <: Int](self: This, n: N): Take[This, N] = {
+    type Result = Take[This, N]
+    val arr = (self: Any) match {
+      case xxl: TupleXXL =>
+        xxl.elems.asInstanceOf[Array[Object]].take(n)
+      case _ =>
+        val arr = new Array[Object](n)
+        itToArray(self.asInstanceOf[Product].productIterator, n, arr, 0)
+        arr
+    }
+    dynamicFromIArray(arr.asInstanceOf[IArray[Object]]).asInstanceOf[Result]
+  }
+
+  def dynamicDrop[This <: Tuple, N <: Int](self: This, n: N): Drop[This, N] = {
+    type Result = Drop[This, N]
+    val arr = (self: Any) match {
+      case xxl: TupleXXL =>
+        xxl.elems.asInstanceOf[Array[Object]].drop(n)
+      case _ =>
+        val size = self.asInstanceOf[Product].productArity - n
+        val arr = new Array[Object](size)
+        itToArray(self.asInstanceOf[Product].productIterator.drop(n), size, arr, 0)
+        arr
+    }
+    dynamicFromIArray(arr.asInstanceOf[IArray[Object]]).asInstanceOf[Result]
+  }
+
   def dynamicSplitAt[This <: Tuple, N <: Int](self: This, n: N): Split[This, N] = {
     type Result = Split[This, N]
     val (arr1, arr2) = (self: Any) match {