Restore previous unapply and homogenize staged method names

Author: biboudis

library/src-bootstrapped/scala/StagedTuple.scala

@@ -177,7 +177,7 @@ object StagedTuple {
     }
   }
 
-  def stagedCons[T <: Tuple & Singleton : Type, H : Type](self: Expr[T], x: Expr[H], tailSize: Option[Int]): Expr[H *: T] =
+  def consStaged[T <: Tuple & Singleton : Type, H : Type](self: Expr[T], x: Expr[H], tailSize: Option[Int]): Expr[H *: T] =
   if (!specialize) '{dynamic_*:[T, H]($self, $x)}
   else {
     val res = tailSize match {
@@ -199,7 +199,7 @@ object StagedTuple {
     res.as[H *: T]
   }
 
-  def stagedConcat[Self <: Tuple & Singleton : Type, That <: Tuple & Singleton : Type](self: Expr[Self], selfSize: Option[Int], that: Expr[That], thatSize: Option[Int]): Expr[Concat[Self, That]] = {
+  def concatStaged[Self <: Tuple & Singleton : Type, That <: Tuple & Singleton : Type](self: Expr[Self], selfSize: Option[Int], that: Expr[That], thatSize: Option[Int]): Expr[Concat[Self, That]] = {
     if (!specialize) '{dynamic_++[Self, That]($self, $that)}
     else {
       def genericConcat(xs: Expr[Tuple], ys: Expr[Tuple]): Expr[Tuple] =
@@ -211,7 +211,7 @@ object StagedTuple {
           that
         case Some(1) =>
           if (thatSize.contains(0)) self
-          else stagedCons(that, '{$self.asInstanceOf[Tuple1[_]]._1}, thatSize)
+          else consStaged(that, '{$self.asInstanceOf[Tuple1[_]]._1}, thatSize)
         case Some(2) =>
           val self2 = self.as[Tuple2[_, _]]
           thatSize match {

library/src-bootstrapped/scala/Tuple.scala

@@ -7,7 +7,7 @@ sealed trait Tuple extends Any {
   import Tuple._
 
   inline def toArray: Array[Object] =
-    if (stageIt) stagedToArray
+    if (stageIt) toArrayStaged
     else inline constValueOpt[BoundedSize[this.type]] match {
       case Some(0) =>
         empty$Array
@@ -31,11 +31,11 @@ sealed trait Tuple extends Any {
         dynamicToArray(this)
     }
 
-  inline def stagedToArray: Array[Object] =
+  inline def toArrayStaged: Array[Object] =
     ${ StagedTuple.toArrayStaged('this, constValueOpt[BoundedSize[this.type]]) }
 
   inline def *: [H, This >: this.type <: Tuple] (x: H): H *: This =
-    if (stageIt) stagedCons[H](x)
+    if (stageIt) consStaged[H](x)
     else {
       type Result = H *: This
       inline constValueOpt[BoundedSize[this.type]] match {
@@ -59,11 +59,11 @@ sealed trait Tuple extends Any {
       }
     }
 
-  inline def stagedCons[H] (x: H): H *: this.type =
-    ${ StagedTuple.stagedCons('this, 'x, constValueOpt[BoundedSize[this.type]]) }
+  inline def consStaged[H] (x: H): H *: this.type =
+    ${ StagedTuple.consStaged('this, 'x, constValueOpt[BoundedSize[this.type]]) }
 
   inline def ++ [This >: this.type <: Tuple](that: Tuple): Concat[This, that.type] =
-    if (stageIt) stagedConcat(that).asInstanceOf
+    if (stageIt) concatStaged(that).asInstanceOf
     else {
       type Result = Concat[This, that.type]
       inline constValueOpt[BoundedSize[this.type]] match {
@@ -103,15 +103,15 @@ sealed trait Tuple extends Any {
       }
     }
 
-  inline def stagedConcat(that: Tuple): Concat[this.type, that.type] =
-    ${ StagedTuple.stagedConcat('this, constValueOpt[BoundedSize[this.type]],
+  inline def concatStaged(that: Tuple): Concat[this.type, that.type] =
+    ${ StagedTuple.concatStaged('this, constValueOpt[BoundedSize[this.type]],
                                 'that, constValueOpt[BoundedSize[that.type]]) }
 
   inline def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
     fromArray[T](xs.toArray ++ ys.toArray)
 
   inline def size[This >: this.type <: Tuple]: Size[This] =
-    if (stageIt) stagedSize.asInstanceOf
+    if (stageIt) sizeStaged.asInstanceOf
     else {
       type Result = Size[This]
       inline constValueOpt[BoundedSize[this.type]] match {
@@ -120,15 +120,15 @@ sealed trait Tuple extends Any {
       }
     }
 
-  inline def stagedSize: Size[this.type] =
+  inline def sizeStaged: Size[this.type] =
     ${ StagedTuple.sizeStaged[Size[this.type]]('this, constValueOpt[BoundedSize[this.type]]) }
 }
 
 object Tuple {
   inline val MaxSpecialized = 22
   inline private val XXL = MaxSpecialized + 1
 
-  final val stageIt = false
+  final val stageIt = true
 
   type Head[X <: NonEmptyTuple] = X match {
     case x *: _ => x
@@ -188,7 +188,7 @@ object Tuple {
   }
 
   inline def fromArray[T <: Tuple](xs: Array[Object]): T =
-    if (stageIt) stagedFromArray[T](xs)
+    if (stageIt) fromArrayStaged[T](xs)
     else inline constValue[BoundedSize[T]] match {
       case 0  => ().asInstanceOf[T]
       case 1  => Tuple1(xs(0)).asInstanceOf[T]
@@ -216,7 +216,7 @@ object Tuple {
       case _ => TupleXXL(xs).asInstanceOf[T]
     }
 
-  inline def stagedFromArray[T <: Tuple](xs: Array[Object]): T =
+  inline def fromArrayStaged[T <: Tuple](xs: Array[Object]): T =
     ${ StagedTuple.fromArrayStaged[T]('xs, constValueOpt[BoundedSize[this.type]]) }
 
   def dynamicFromArray[T <: Tuple](xs: Array[Object]): T = xs.length match {
@@ -312,7 +312,7 @@ sealed trait NonEmptyTuple extends Tuple {
   import NonEmptyTuple._
 
   inline def head[This >: this.type <: NonEmptyTuple]: Head[This] =
-    if (stageIt) stagedHead.asInstanceOf
+    if (stageIt) headStaged.asInstanceOf
     else {
       type Result = Head[This]
       val resVal = inline constValueOpt[BoundedSize[this.type]] match {
@@ -339,11 +339,11 @@ sealed trait NonEmptyTuple extends Tuple {
       resVal.asInstanceOf[Result]
     }
 
-  inline def stagedHead: Head[this.type] =
+  inline def headStaged: Head[this.type] =
     ${ StagedTuple.headStaged[this.type]('this, constValueOpt[BoundedSize[this.type]]) }
 
   inline def tail[This >: this.type <: NonEmptyTuple]: Tail[This] =
-    if (stageIt) stagedTail.asInstanceOf
+    if (stageIt) tailStaged.asInstanceOf
     else {
       type Result = Tail[This]
       inline constValueOpt[BoundedSize[this.type]]  match {
@@ -368,7 +368,7 @@ sealed trait NonEmptyTuple extends Tuple {
       }
     }
 
-  inline def stagedTail: Tail[this.type] =
+  inline def tailStaged: Tail[this.type] =
     ${ StagedTuple.tailStaged[this.type]('this, constValueOpt[BoundedSize[this.type]]) }
 
   inline def fallbackApply(n: Int) =
@@ -378,7 +378,7 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] =
-    if (stageIt) stagedApply(n).asInstanceOf
+    if (stageIt) applyStaged(n).asInstanceOf
     else {
       type Result = Elem[This, n.type]
       inline constValueOpt[Size[this.type]] match {
@@ -428,7 +428,7 @@ sealed trait NonEmptyTuple extends Tuple {
       }
     }
 
-  inline def stagedApply(n: Int): Elem[this.type, n.type] =
+  inline def applyStaged(n: Int): Elem[this.type, n.type] =
     ${ StagedTuple.applyStaged[this.type, n.type](
        'this, constValueOpt[Size[this.type]],
        'n, constValueOpt[n.type]) }
@@ -476,5 +476,6 @@ object NonEmptyTuple {
 sealed class *:[+H, +T <: Tuple] extends NonEmptyTuple
 
 object *: {
-  inline def unapply[H, T <: Tuple](x: H *: T) = (x.head, x.tail)
+  inline def unapply[H, T <: Tuple](x: H *: T) =
+    (NonEmptyTuple.dynamicHead(x), NonEmptyTuple.dynamicTail(x))
 }