Define TupleXXL using IArray

Author: nicolasstucki

library/src/scala/Tuple.scala

@@ -13,6 +13,10 @@ sealed trait Tuple extends Any {
   inline def toArray: Array[Object] =
     DynamicTuple.dynamicToArray(this)
 
+  /** Create a copy this tuple as an IArray */
+  inline def toIArray: IArray[Object] =
+    DynamicTuple.dynamicToIArray(this)
+
   /** Return a new tuple by prepending the element to `this` tuple.
    *  This opteration is O(this.size)
    */
@@ -79,6 +83,17 @@ object Tuple {
     DynamicTuple.dynamicFromArray[Tuple](xs2)
   }
 
+  /** Convert an immutable array into a tuple of unknown arity and types */
+  def fromIArray[T](xs: IArray[T]): Tuple = {
+    val xs2: IArray[Object] = xs match {
+      case xs: IArray[Object] => xs
+      case xs =>
+        // TODO suport IArray.map
+        xs.asInstanceOf[Array[T]].map(_.asInstanceOf[Object]).asInstanceOf[IArray[Object]]
+    }
+    DynamicTuple.dynamicFromIArray[Tuple](xs2)
+  }
+
   /** Convert a Product into a tuple of unknown arity and types */
   def fromProduct(product: Product): Tuple =
     runtime.DynamicTuple.dynamicFromProduct[Tuple](product)

library/src/scala/TupleXXL.scala

@@ -1,35 +1,36 @@
 package scala
 import java.util.Arrays.{deepEquals, deepHashCode}
 
-final class TupleXXL private (es: Array[Object]) extends Product {
+final class TupleXXL private (es: IArray[Object]) extends Product {
   assert(es.length > 22)
 
   def productElement(n: Int): Any = es(n)
   def productArity: Int = es.length
 
-  override def toString = elems.mkString("(", ",", ")")
-  override def hashCode = getClass.hashCode * 41 + deepHashCode(elems)
+  override def toString = elems.asInstanceOf[Array[Object]].mkString("(", ",", ")")
+  override def hashCode = getClass.hashCode * 41 + deepHashCode(elems.asInstanceOf[Array[Object]])
   override def canEqual(that: Any): Boolean = that match {
     case that: TupleXXL => that.productArity == this.productArity
     case _ => false
   }
 
   override def equals(that: Any) = that match {
-    case that: TupleXXL => deepEquals(this.elems, that.elems)
+    case that: TupleXXL => deepEquals(this.elems.asInstanceOf[Array[Object]], that.elems.asInstanceOf[Array[Object]])
     case _ => false
   }
-  def elems: Array[Object] = es
+  def elems: IArray[Object] = es
 
   def tailXXL: TupleXXL = {
     assert(es.length > 23)
-    new TupleXXL(es.tail)
+    new TupleXXL(es.asInstanceOf[Array[Object]].tail.asInstanceOf[IArray[Object]])
   }
 
-  def toArray: Array[Object] = es.clone
+  def toArray: Array[Object] = es.asInstanceOf[Array[Object]].clone
 }
 object TupleXXL {
-  def fromIterator(elems: Iterator[Any]) = new TupleXXL(elems.map(_.asInstanceOf[Object]).toArray)
-  def apply(elems: Array[Object]) = new TupleXXL(elems.clone)
-  def apply(elems: Any*) = new TupleXXL(elems.asInstanceOf[Seq[Object]].toArray)
-  def unapplySeq(x: TupleXXL): Option[Seq[Any]] = Some(x.elems.toSeq)
+  def fromIterator(elems: Iterator[Any]) = new TupleXXL(elems.map(_.asInstanceOf[Object]).toArray.asInstanceOf[IArray[Object]])
+  def fromIArray(elems: IArray[Object]) = new TupleXXL(elems)
+  def apply(elems: Array[Object]) = new TupleXXL(elems.clone.asInstanceOf[IArray[Object]])
+  def apply(elems: Any*) = new TupleXXL(elems.asInstanceOf[Seq[Object]].toArray.asInstanceOf[IArray[Object]])
+  def unapplySeq(x: TupleXXL): Option[Seq[Any]] = Some(x.elems.asInstanceOf[Array[Object]].toSeq)
 }

library/src/scala/TupledFunction.scala

@@ -167,7 +167,7 @@ package internal {
     }
 
     def tupledFunctionXXL[F, G]: TupledFunction[F, G] = new TupledFunction {
-      def tupled(f: F): G = ((args: TupleXXL) => f.asInstanceOf[FunctionXXL].apply(args.elems)).asInstanceOf[G]
+      def tupled(f: F): G = ((args: TupleXXL) => f.asInstanceOf[FunctionXXL].apply(args.elems.asInstanceOf[Array[Object]])).asInstanceOf[G]
       def untupled(g: G): F = new FunctionXXL {
         override def apply(xs: Array[Object]): AnyRef = g.asInstanceOf[TupleXXL => AnyRef].apply(TupleXXL(xs))
       }.asInstanceOf[F]

library/src/scala/runtime/DynamicTuple.scala

@@ -55,6 +55,10 @@ object DynamicTuple {
     case _ => TupleXXL(xs).asInstanceOf[T]
   }
 
+  def dynamicFromIArray[T <: Tuple](xs: IArray[Object]): T =
+    if (xs.length <= 22) dynamicFromArray(xs.asInstanceOf[Array[Object]])
+    else TupleXXL.fromIArray(xs).asInstanceOf[T]
+
   def dynamicFromProduct[T <: Tuple](xs: Product): T = (xs.productArity match {
     case 1 =>
       xs match {
@@ -180,6 +184,12 @@ object DynamicTuple {
     case self: Product => productToArray(self)
   }
 
+  def dynamicToIArray(self: Tuple): IArray[Object] = (self: Any) match {
+    case self: Unit => Array.emptyObjectArray.asInstanceOf[IArray[Object]]
+    case self: TupleXXL => self.elems
+    case self: Product => productToArray(self).asInstanceOf[IArray[Object]]
+  }
+
   def productToArray(self: Product): Array[Object] = {
     val arr = new Array[Object](self.productArity)
     for (i <- 0 until arr.length) arr(i) = self.productElement(i).asInstanceOf[Object]

tests/run-with-compiler/staged-tuples/StagedTuple.scala

@@ -28,7 +28,7 @@ object StagedTuple {
       case Some(n) if n <= MaxSpecialized =>
         '{to$Array($tup, ${ n.toExpr })}
       case Some(n) =>
-        '{${ tup.as[TupleXXL] }.elems}
+        '{ ${tup.as[TupleXXL]}.toArray }
       case None =>
         '{dynamicToArray($tup)}
     }