Map on tuples added

Author: anatoliykmetyuk

library/src/scala/Tuple.scala

@@ -35,6 +35,9 @@ sealed trait Tuple extends Any {
 
   inline def zip[This >: this.type <: Tuple, T2 <: Tuple](t2: T2): Zip[This, T2] =
     DynamicTuple.dynamicZip(this, t2)
+
+  inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] =
+    DynamicTuple.dynamicMap(this, f)
 }
 
 object Tuple {

library/src/scala/runtime/DynamicTuple.scala

@@ -1,6 +1,6 @@
 package scala.runtime
 
-import scala.Tuple.{ Concat, Size, Head, Tail, Elem, Zip }
+import scala.Tuple.{ Concat, Size, Head, Tail, Elem, Zip, Map }
 
 object DynamicTuple {
   inline val MaxSpecialized = 22
@@ -257,6 +257,10 @@ object DynamicTuple {
     ).asInstanceOf[Zip[This, T2]]
   }
 
+  def dynamicMap[This <: Tuple, F[_]](self: This, f: [t] => t => F[t]): Map[This, F] =
+    Tuple.fromArray(self.asInstanceOf[Product].productIterator.map(f(_)).toArray)
+      .asInstanceOf[Map[This, F]]
+
   def consIterator(head: Any, tail: Tuple): Iterator[Any] =
     Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator
 

tests/neg/tuple-ops.scala

@@ -0,0 +1,21 @@
+val a: (1, 2, 3) = (1, 2, 3)
+val b: (4, 5, 6) = (4, 5, 6)
+val c: (7, 8) = (7, 8)
+val d: Unit = ()
+val e: (1, "foo", 10.1) = (1, "foo", 10.1)
+
+// Zip
+val r1: ((1, 4), (2, 5), (6, 6)) = a.zip(b)  // error
+val r2: ((1, 7), (1, 8)) = a.zip(c)  // error
+val r3: ((2, 1), (8, 2)) = c.zip(a)  // error
+
+// Map
+case class Foo[X](x: X)
+
+val r6: (Int, Int, String) = a.map[[t] =>> Int]([t] => x: t => x match {  // error
+  case x: Int => x * x
+  case _ => ???
+})
+
+val r7: ((1, Foo[1]), (2), (3, Foo[3])) =
+  a.map[[t] =>> (t, Foo[t])]( [t] => x: t => (x, Foo(x)) )  // error

tests/run/tuple-ops.check

@@ -3,3 +3,5 @@
 ((7,1),(8,2))
 ()
 ()
+(1,4,9)
+((1,Foo(1)),(2,Foo(2)),(3,Foo(3)))

tests/run/tuple-ops.scala

@@ -3,16 +3,23 @@ val b: (4, 5, 6) = (4, 5, 6)
 val c: (7, 8) = (7, 8)
 val d: Unit = ()
 
+// Zip
 val r1: ((1, 4), (2, 5), (3, 6)) = a.zip(b)
 val r2: ((1, 7), (2, 8)) = a.zip(c)
 val r3: ((7, 1), (8, 2)) = c.zip(a)
 val r4: Unit = d.zip(a)
 val r5: Unit = a.zip(d)
 
-@main def Test = List(
-  r1,
-  r2,
-  r3,
-  r4,
-  r5)
-.foreach(println)
+// Map
+case class Foo[X](x: X)
+
+val r6: (Int, Int, Int) = a.map[[t] =>> Int]([t] => x: t => x match {
+  case x: Int => x * x
+  case _ => ???
+})
+
+val r7: ((1, Foo[1]), (2, Foo[2]), (3, Foo[3])) =
+  a.map[[t] =>> (t, Foo[t])]( [t] => x: t => (x, Foo(x)) )
+
+@main def Test =
+  List(r1, r2, r3, r4, r5, r6, r7).foreach(println)