More generative operations on Tuples: tail, apply, ++

Author: odersky

library/src-scala3/scala/Tuple.scala

@@ -45,6 +45,46 @@ sealed trait Tuple extends Any {
         fromArray[resTpe.Type]($consArray(x, toArray))
     }
   }
+
+  rewrite def ++(that: Tuple): Tuple = {
+    erased val resTpe = Typed(_concat(this, that))
+    rewrite _size(this) match {
+      case 0 =>
+        that
+      case 1 =>
+        if (_size(that) == 0) this
+        else (asInstanceOf[Tuple1[_]]._1 *: that).asInstanceOf[resTpe.Type]
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        rewrite _size(that) match {
+          case 0 => this
+          case 1 =>
+            val u = that.asInstanceOf[Tuple1[_]]
+            Tuple3(t._1, t._2, u._1).asInstanceOf[resTpe.Type]
+          case 2 =>
+            val u = that.asInstanceOf[Tuple2[_, _]]
+            Tuple4(t._1, t._2, u._1, u._2).asInstanceOf[resTpe.Type]
+          case _ =>
+            genericConcat[resTpe.Type](this, that)
+        }
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        rewrite _size(that) match {
+          case 0 => this
+          case 1 =>
+            val u = that.asInstanceOf[Tuple1[_]]
+            Tuple4(t._1, t._2, t._3, u._1).asInstanceOf[resTpe.Type]
+          case _ =>
+            genericConcat[resTpe.Type](this, that)
+        }
+      case _ =>
+        if (_size(that) == 0) this
+        else genericConcat[resTpe.Type](this, that)
+    }
+  }
+
+  rewrite def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
+    fromArray[T](xs.toArray ++ ys.toArray)
 }
 
 object Tuple {
@@ -83,6 +123,20 @@ object Tuple {
     case _: (x *: _) => erasedValue[x]
   }
 
+  private[scala] rewrite def _tail(xs: Tuple): Tuple = rewrite xs match {
+    case _: (_ *: xs1) => erasedValue[xs1]
+  }
+
+  private[scala] rewrite def _index(xs: Tuple, n: Int): Any = rewrite xs match {
+    case _: (x *: _)   if n == 0 => erasedValue[x]
+    case _: (_ *: xs1) if n > 0  => _index(erasedValue[xs1], n - 1)
+  }
+
+  private[scala] rewrite def _concat(xs: Tuple, ys: Tuple): Tuple = rewrite xs match {
+    case _: Unit => ys
+    case _: (x1 *: xs1) => _pair(erasedValue[x1], _concat(erasedValue[xs1], ys))
+  }
+
   rewrite def fromArray[T <: Tuple](xs: Array[Object]): T =
     rewrite _size(erasedValue[T]) match {
       case 0  => ().asInstanceOf[T]
@@ -140,8 +194,63 @@ sealed class *:[+H, +T <: Tuple] extends Tuple {
     resVal.asInstanceOf[resTpe.Type]
   }
 
-  rewrite def tail: T = ???
+  rewrite def tail: Tuple = {
+    erased val resTpe = Typed(_tail(this))
+    rewrite _size(this) match {
+      case 1 =>
+        ()
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        Tuple1(t._2).asInstanceOf[resTpe.Type]
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        Tuple2(t._2, t._3).asInstanceOf[resTpe.Type]
+      case 4 =>
+        val t = asInstanceOf[Tuple4[_, _, _, _]]
+        Tuple3(t._2, t._3, t._4).asInstanceOf[resTpe.Type]
+      case 5 =>
+        val t = asInstanceOf[Tuple5[_, _, _, _, _]]
+        Tuple4(t._2, t._3, t._4, t._5).asInstanceOf[resTpe.Type]
+      case n if n > 5 =>
+        fromArray[resTpe.Type](toArray.tail)
+    }
+  }
 
+  rewrite def apply(n: Int): Any = {
+    erased val resTpe = Typed(_index(this, n))
+    rewrite _size(this) match {
+      case 1 =>
+        val t = asInstanceOf[Tuple1[_]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+        }
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+          case 1 => t._2.asInstanceOf[resTpe.Type]
+        }
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+          case 1 => t._2.asInstanceOf[resTpe.Type]
+          case 2 => t._3.asInstanceOf[resTpe.Type]
+        }
+      case 4 =>
+        val t = asInstanceOf[Tuple4[_, _, _, _]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+          case 1 => t._2.asInstanceOf[resTpe.Type]
+          case 2 => t._3.asInstanceOf[resTpe.Type]
+          case 3 => t._4.asInstanceOf[resTpe.Type]
+        }
+      case s if s > 4 && s <= $MaxSpecialized && n >= 0 && n < s =>
+        asInstanceOf[Product].productElement(n).asInstanceOf[resTpe.Type]
+      case s if s > $MaxSpecialized && n >= 0 && n < s =>
+        asInstanceOf[TupleXXL].elems(n).asInstanceOf[resTpe.Type]
+    }
+  }
 }
 
 object *: {

tests/run/tuples1.check

@@ -11,3 +11,24 @@ h1 = 1
 h2 = A
 h7 = 4
 h8 = D
+t1 = ()
+t2 = (1)
+t7 = (C,3,B,2,A,1)
+t8 = (4,C,3,B,2,A,1)
+a1_0 = 1
+a2_0 = A
+a3_1 = A
+a4_3 = 1
+a6_4 = A
+a8_0 = D
+c0_0 = ()
+c0_1 = (1)
+c1_0 = (1)
+c0_4 = (B,2,A,1)
+c4_0 = (B,2,A,1)
+c1_1 = (1,1)
+c1_8 = (1,D,4,C,3,B,2,A,1)
+c2_1 = (A,1,1)
+c2_2 = (A,1,A,1)
+c2_3 = (A,1,2,A,1)
+c3_3 = (2,A,1,2,A,1)

tests/run/tuples1.scala

@@ -12,7 +12,6 @@ object Test extends App {
   val h2 = x2.head; val h2c: String = h2; println(s"h2 = $h2")
   val h7 = x7.head; val h7c: Int = h7; println(s"h7 = $h7")
   val h8 = x8.head; val h8c: String = h8; println(s"h8 = $h8")
-/*
   val t1 = x1.tail; val t1c: Unit = t1; println(s"t1 = $t1")
   val t2 = x2.tail; val t2c: Int *: Unit = t2; println(s"t2 = $t2")
   val t7 = x7.tail; val t7c: String *: Int *: Unit = t7.tail.tail.tail.tail; println(s"t7 = $t7")
@@ -33,5 +32,5 @@ object Test extends App {
   val c2_1 = x2 ++ x1; val c2_1c: String *: Int *: Int *: Unit = c2_1; println(s"c2_1 = $c2_1")
   val c2_2 = x2 ++ x2; val c2_2c: String *: Int *: String *: Int *: Unit = c2_2; println(s"c2_2 = $c2_2")
   val c2_3 = x2 ++ x3; val c2_3c: String *: Int *: Int *: String *: Int *: Unit = c2_3; println(s"c2_3 = $c2_3")
-  val c3_3 = x3 ++ x3; val c3_3c: Int *: String *: Int *: Int *: String *: Int *: Unit = c3_3; println(s"c3_3 = $c3_3")*/
+  val c3_3 = x3 ++ x3; val c3_3c: Int *: String *: Int *: Int *: String *: Int *: Unit = c3_3; println(s"c3_3 = $c3_3")
 }