Factor out useful Tuple map type match

Author: nicolasstucki

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -719,7 +719,7 @@ trait Implicits { self: Typer =>
             // TupledFunction[?, (...) => R]
             tupled.dropDependentRefinement.dealias.argInfos match {
               case tupledArgs :: funRet :: Nil =>
-                defn.tupleTypes(tupledArgs) match {
+                defn.tupleTypes(tupledArgs.dealias) match {
                   case Some(funArgs) if functionTypeEqual(tupled, funArgs, funRet, fun) =>
                     // TupledFunction[?, ((...funArgs...)) => funRet]
                     funArgs.size

library/src-3.x/scala/Tuple.scala

@@ -132,6 +132,12 @@ object Tuple {
     case x *: xs => S[Size[xs]]
   }
 
+  /** Converts a tuple `(T1, ..., Tn)` to `(F[T1], ..., F[Tn])` */
+  type Map[Tup <: Tuple, F[_]] <: Tuple = Tup match {
+    case Unit => Unit
+    case h *: t => F[h] *: Map[t, F]
+  }
+
   private[scala] type BoundedSizeRecur[X, L <: Int] <: Int = X match {
     case Unit => 0
     case x *: xs =>

library/src-3.x/scala/quoted/Expr.scala

@@ -21,10 +21,8 @@ package quoted {
       def show(implicit toolbox: Toolbox): String = toolbox.show(expr)
     }
 
-    type TupleOfExpr[Tup <: Tuple] <: Tuple = Tup match {
-      case Unit => Unit
-      case h *: t => Expr[h] *: TupleOfExpr[t]
-    }
+    /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */
+    type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, Expr]
 
     implicit class FunctionBetaReduction[F, Args <: Tuple, R](f: Expr[F]) given (tf: TupledFunction[F, Args => R]) {
       /** Beta-reduces the function appication. Generates the an expression only containing the body of the function */