Allow generic tuple operations to be dynamic

Rewrite to specialized version if static, fall back to generic
runtime version otherwise.

Author: odersky

compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala

@@ -59,7 +59,6 @@ trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
       defn.FunctionClass(arity, isImplicit, isErased).asClass
     def TupleClass(arity: Int): Symbol = defn.TupleType(arity).classSymbol.asClass
 
-
     def ScalaPrimitiveValueClasses: List[Symbol] =
       UnitClass :: BooleanClass :: ScalaNumericValueClasses
     def ScalaNumericValueClasses: List[Symbol] =

library/src-scala3/scala/Tuple.scala

@@ -25,7 +25,7 @@ sealed trait Tuple extends Any {
     case Some(n) =>
       asInstanceOf[TupleXXL].elems
     case None =>
-      error(".toArray cannot be applied to tuple of unknown size")
+      dynamicToArray(this)
   }
 
   rewrite def *: [H] (x: H): H *: this.type = {
@@ -47,7 +47,7 @@ sealed trait Tuple extends Any {
       case Some(n) =>
         fromArray[Result]($consArray(x, toArray))
       case _ =>
-        error("*: cannot be applied to tuple of unknown size")
+        dynamic_*:[this.type, H](this, x)
     }
   }
 
@@ -86,12 +86,20 @@ sealed trait Tuple extends Any {
         if (constValue[BoundedSize[that.type]] == 0) this.asInstanceOf[Result]
         else genericConcat[Result](this, that).asInstanceOf[Result]
       case None =>
-        error("++ cannot be applied to tuple of unknown size")
+        dynamic_++[this.type, that.type](this, that)
     }
   }
 
   rewrite def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
     fromArray[T](xs.toArray ++ ys.toArray)
+
+  rewrite def size: Size[this.type] = {
+    type Result = Size[this.type]
+    rewrite constValueOpt[BoundedSize[this.type]] match {
+      case Some(n) => n.asInstanceOf[Result]
+      case _ => dynamicSize(this).asInstanceOf[Result]
+    }
+  }
 }
 
 object Tuple {
@@ -183,10 +191,98 @@ object Tuple {
       case 22 => Tuple22(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20), xs(21)).asInstanceOf[T]
       case _ => TupleXXL(xs).asInstanceOf[T]
     }
+
+  def dynamicFromArray[T <: Tuple](xs: Array[Object]): T = xs.length match {
+    case 0  => ().asInstanceOf[T]
+    case 1  => Tuple1(xs(0)).asInstanceOf[T]
+    case 2  => Tuple2(xs(0), xs(1)).asInstanceOf[T]
+    case 3  => Tuple3(xs(0), xs(1), xs(2)).asInstanceOf[T]
+    case 4  => Tuple4(xs(0), xs(1), xs(2), xs(3)).asInstanceOf[T]
+    case 5  => Tuple5(xs(0), xs(1), xs(2), xs(3), xs(4)).asInstanceOf[T]
+    case 6  => Tuple6(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5)).asInstanceOf[T]
+    case 7  => Tuple7(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6)).asInstanceOf[T]
+    case 8  => Tuple8(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7)).asInstanceOf[T]
+    case 9  => Tuple9(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8)).asInstanceOf[T]
+    case 10 => Tuple10(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9)).asInstanceOf[T]
+    case 11 => Tuple11(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10)).asInstanceOf[T]
+    case 12 => Tuple12(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11)).asInstanceOf[T]
+    case 13 => Tuple13(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12)).asInstanceOf[T]
+    case 14 => Tuple14(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13)).asInstanceOf[T]
+    case 15 => Tuple15(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14)).asInstanceOf[T]
+    case 16 => Tuple16(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15)).asInstanceOf[T]
+    case 17 => Tuple17(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16)).asInstanceOf[T]
+    case 18 => Tuple18(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17)).asInstanceOf[T]
+    case 19 => Tuple19(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18)).asInstanceOf[T]
+    case 20 => Tuple20(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19)).asInstanceOf[T]
+    case 21 => Tuple21(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20)).asInstanceOf[T]
+    case 22 => Tuple22(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20), xs(21)).asInstanceOf[T]
+    case _ => TupleXXL(xs).asInstanceOf[T]
+  }
+
+  def dynamicToArray(self: Tuple): Array[Object] = (self: Any) match {
+    case self: Unit =>
+      $emptyArray
+    case self: Tuple1[_] =>
+      val t = self.asInstanceOf[Tuple1[Object]]
+      Array(t._1)
+    case self: Tuple2[_, _] =>
+      val t = self.asInstanceOf[Tuple2[Object, Object]]
+      Array(t._1, t._2)
+    case self: Tuple3[_, _, _] =>
+      val t = self.asInstanceOf[Tuple3[Object, Object, Object]]
+      Array(t._1, t._2, t._3)
+    case self: Tuple4[_, _, _, _] =>
+      val t = self.asInstanceOf[Tuple4[Object, Object, Object, Object]]
+      Array(t._1, t._2, t._3, t._4)
+    case self: TupleXXL =>
+      asInstanceOf[TupleXXL].elems
+    case self: Product =>
+      val arr = new Array[Object](self.productArity)
+      for (i <- 0 until arr.length) arr(i) = self.productElement(i).asInstanceOf[Object]
+      arr
+  }
+
+  def dynamic_*: [This <: Tuple, H] (self: Tuple, x: H): H *: This = {
+    type Result = H *: This
+    (self: Any) match {
+      case Unit =>
+        Tuple1(x).asInstanceOf[Result]
+      case self: Tuple1[_] =>
+        Tuple2(x, self._1).asInstanceOf[Result]
+      case self: Tuple2[_, _] =>
+        Tuple3(x, self._1, self._2).asInstanceOf[Result]
+      case self: Tuple3[_, _, _] =>
+        Tuple4(x, self._1, self._2, self._3).asInstanceOf[Result]
+      case self: Tuple4[_, _, _, _] =>
+        Tuple5(x, self._1, self._2, self._3, self._4).asInstanceOf[Result]
+      case _ =>
+        dynamicFromArray[Result]($consArray(x, dynamicToArray(self)))
+    }
+  }
+
+  def dynamic_++[This <: Tuple, That <: Tuple](self: This, that: That): Concat[This, That] = {
+    type Result = Concat[This, That]
+    (this: Any) match {
+      case self: Unit => return self.asInstanceOf[Result]
+      case _ =>
+    }
+    (that: Any) match {
+      case that: Unit => return self.asInstanceOf[Result]
+      case _ =>
+    }
+    dynamicFromArray[Result](dynamicToArray(self) ++ dynamicToArray(that))
+  }
+
+  def dynamicSize[This <: Tuple](self: This) = (self: Any) match {
+    case self: Unit => 0
+    case self: TupleXXL => self.elems.length
+    case self: Product => self.productArity
+  }
 }
 
 abstract sealed class NonEmptyTuple extends Tuple {
   import Tuple._
+  import NonEmptyTuple._
 
   rewrite def head: Head[this.type] = {
     type Result = Head[this.type]
@@ -209,7 +305,7 @@ abstract sealed class NonEmptyTuple extends Tuple {
         val t = asInstanceOf[TupleXXL]
         t.elems(0)
       case None =>
-        error(".head cannot be applied to tuple of unknown size")
+        dynamicHead[this.type](this)
     }
     resVal.asInstanceOf[Result]
   }
@@ -234,54 +330,101 @@ abstract sealed class NonEmptyTuple extends Tuple {
       case Some(n) if n > 5 =>
         fromArray[Result](toArray.tail)
       case None =>
-        error(".tail cannot be applied to tuple of unknown size")
+        dynamicTail[this.type](this)
     }
   }
 
-  rewrite def indexOutOfBounds = error("index out of bounds")
+  rewrite def fallbackApply(n: Int) =
+    rewrite constValueOpt[n.type] match {
+      case Some(n: Int) => error("index out of bounds", n)
+      case None => dynamicApply[this.type](this, n)
+    }
 
-  rewrite def apply(transparent n: Int): Elem[this.type, n.type] = {
+  rewrite def apply(n: Int): Elem[this.type, n.type] = {
     type Result = Elem[this.type, n.type]
     rewrite constValueOpt[BoundedSize[this.type]] match {
       case Some(1) =>
         val t = asInstanceOf[Tuple1[_]]
-        rewrite n match {
-          case 0 => t._1.asInstanceOf[Result]
-          case _ => indexOutOfBounds
+        rewrite constValueOpt[n.type] match {
+          case Some(0) => t._1.asInstanceOf[Result]
+          case _ => fallbackApply(n).asInstanceOf[Result]
         }
       case Some(2) =>
         val t = asInstanceOf[Tuple2[_, _]]
-        rewrite n match {
-          case 0 => t._1.asInstanceOf[Result]
-          case 1 => t._2.asInstanceOf[Result]
-          case _ => indexOutOfBounds
+        rewrite constValueOpt[n.type] match {
+          case Some(0) => t._1.asInstanceOf[Result]
+          case Some(1) => t._2.asInstanceOf[Result]
+          case _ => fallbackApply(n).asInstanceOf[Result]
         }
       case Some(3) =>
         val t = asInstanceOf[Tuple3[_, _, _]]
-        rewrite n match {
-          case 0 => t._1.asInstanceOf[Result]
-          case 1 => t._2.asInstanceOf[Result]
-          case 2 => t._3.asInstanceOf[Result]
-          case _ => indexOutOfBounds
+        rewrite constValueOpt[n.type] match {
+          case Some(0) => t._1.asInstanceOf[Result]
+          case Some(1) => t._2.asInstanceOf[Result]
+          case Some(2) => t._3.asInstanceOf[Result]
+          case _ => fallbackApply(n).asInstanceOf[Result]
         }
       case Some(4) =>
         val t = asInstanceOf[Tuple4[_, _, _, _]]
-        rewrite n match {
-          case 0 => t._1.asInstanceOf[Result]
-          case 1 => t._2.asInstanceOf[Result]
-          case 2 => t._3.asInstanceOf[Result]
-          case 3 => t._4.asInstanceOf[Result]
-          case _ => indexOutOfBounds
+        rewrite constValueOpt[n.type] match {
+          case Some(0) => t._1.asInstanceOf[Result]
+          case Some(1) => t._2.asInstanceOf[Result]
+          case Some(2) => t._3.asInstanceOf[Result]
+          case Some(3) => t._4.asInstanceOf[Result]
+          case _ => fallbackApply(n).asInstanceOf[Result]
         }
-      case Some(s) if s > 4 && s <= $MaxSpecialized && n >= 0 && n < s =>
-        asInstanceOf[Product].productElement(n).asInstanceOf[Result]
-      case Some(s) if s > $MaxSpecialized && n >= 0 && n < s =>
-        asInstanceOf[TupleXXL].elems(n).asInstanceOf[Result]
-      case Some(s) =>
-        indexOutOfBounds
-      case None =>
-        error("selection (...) cannot be applied to tuple of unknown size")
+      case Some(s) if s > 4 && s <= $MaxSpecialized =>
+        val t = asInstanceOf[Product]
+        rewrite constValueOpt[n.type] match {
+          case Some(n) if n >= 0 && n < s => t.productElement(n).asInstanceOf[Result]
+          case _ => fallbackApply(n).asInstanceOf[Result]
+        }
+      case Some(s) if s > $MaxSpecialized =>
+        val t = asInstanceOf[TupleXXL]
+        rewrite constValueOpt[n.type] match {
+          case Some(n) if n >= 0 && n < s => t.elems(n).asInstanceOf[Result]
+          case _ => fallbackApply(n).asInstanceOf[Result]
+        }
+      case _ => fallbackApply(n).asInstanceOf[Result]
+    }
+  }
+}
+
+object NonEmptyTuple {
+  import Tuple._
+
+  def dynamicHead[This <: NonEmptyTuple] (self: This): Head[This] = {
+    type Result = Head[This]
+    val res = (self: Any) match {
+      case self: Tuple1[_] => self._1
+      case self: Tuple2[_, _] => self._1
+      case self: Tuple3[_, _, _] => self._1
+      case self: Tuple4[_, _, _, _] => self._1
+      case self: TupleXXL => self.elems(0)
+      case self: Product => self.productElement(0)
+    }
+    res.asInstanceOf[Result]
+  }
+
+  def dynamicTail[This <: NonEmptyTuple] (self: This): Tail[This] = {
+    type Result = Tail[This]
+    val res = (self: Any) match {
+      case self: Tuple1[_] => self._1
+      case self: Tuple2[_, _] => Tuple1(self._2)
+      case self: Tuple3[_, _, _] => Tuple2(self._2, self._3)
+      case self: Tuple4[_, _, _, _] => Tuple3(self._2, self._3, self._4)
+      case _ => dynamicFromArray[Result](self.toArray.tail)
+    }
+    res.asInstanceOf[Result]
+  }
+
+  def dynamicApply[This <: NonEmptyTuple] (self: This, n: Int): Elem[This, n.type] = {
+    type Result = Elem[This, n.type]
+    val res = (self: Any) match {
+      case self: TupleXXL => self.elems(n)
+      case self: Product => self.productElement(n)
     }
+    res.asInstanceOf[Result]
   }
 }
 

library/src/scala/TupleXXL.scala

@@ -2,6 +2,7 @@ package scala
 import java.util.Arrays.{deepEquals, deepHashCode}
 
 final class TupleXXL private (es: Array[Object]) {
+  assert(es.length > 22)
   override def toString = elems.mkString("(", ",", ")")
   override def hashCode = getClass.hashCode * 41 + deepHashCode(elems)
   override def equals(that: Any) = that match {

tests/neg/tuple-nonconstant.scala

@@ -72,4 +72,47 @@ object Test extends App {
     val xsc: Unit = xs
     println(s"$x23 -> $x, $y, $xs")
   }
+
+  val x3s: 3 = x3.size
+  val us: 0 = ().size
+  val x23s: 23 = x23.size
+
+// dynamic operations
+
+  def head1(x: NonEmptyTuple): Tuple.Head[x.type] = x.head
+  def head2[X <: NonEmptyTuple](x: X): Tuple.Head[X] = x.head
+
+  val hd1: Int = head1(x3)
+  val hd2: Int = head2(x3)
+
+  def tail1(x: NonEmptyTuple): Tuple.Tail[x.type] = x.tail
+  def tail2[X <: NonEmptyTuple](x: X): Tuple.Tail[X] = x.tail
+
+  val tl1: (String, Int) = tail1(x3)
+  val tl2: (String, Int) = tail2(x3)
+
+  def elem[X <: NonEmptyTuple](x: X, n: Int): Tuple.Elem[X, n.type] = x(n)
+  val elem1: String = x3(1)
+
+  def toArray[X <: Tuple](x: X): Array[Object] = x.toArray
+  val toArray1 = x3.toArray
+
+  def cons[X, Y <: Tuple](x: X, y: Y): X *: Y = x *: y
+  val cons1: Boolean *: Int *: (String, Int) = cons(true, x3)
+
+  def concat[X <: Tuple, Y <: Tuple](x: X, y: Y): Tuple.Concat[X, Y] = x ++ y
+  def concat0(x: Tuple, y: Tuple): Tuple.Concat[x.type, y.type] = x ++ y
+  val conc1: String *: Int *: Unit = concat((), tl1)
+  val conc2: String *: Int *: Unit = concat(tl1, ())
+  val conc3: String *: Int *: String *: Int *: Unit = concat(tl1, tl1)
+  val conc4: String *: Int *: Unit = concat0((), tl1)
+  val conc5: String *: Int *: Unit = concat0(tl1, ())
+  val conc6: String *: Int *: String *: Int *: Unit = concat0(tl1, tl1)
+
+  def size[X <: Tuple](x: X): Tuple.Size[X] = x.size
+  def size0(x: Tuple): Tuple.Size[x.type] = x.size
+  val x3s0: 3 = size(x3)
+  val us0: 0 = size(())
+  val x3s1: 3 = size0(x3)
+  val us1: 0 = size0(())
 }