Use TupledFunction[F, G] as function tupling instead of application

Also added support for tupled implicit functions
```
TupledFunction[given (Int, Int) => Int, given ((Int, Int)) => Int]
```

Author: nicolasstucki

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

@@ -711,18 +711,22 @@ trait Implicits { self: Typer =>
 
     def synthesizedTupleFunction(formal: Type): Tree = {
       formal match {
-        case AppliedType(_, fun :: args :: ret :: Nil) if defn.isFunctionType(fun) =>
-          val funTypes = fun.dropDependentRefinement.dealias.argInfos
-          if (defn.tupleType(funTypes.init) =:= args && funTypes.last =:= ret) {
+        case AppliedType(_, funArgs @ fun :: tupled :: Nil) if defn.isFunctionType(fun) && defn.isFunctionType(tupled) =>
+          lazy val funTypes = fun.dropDependentRefinement.dealias.argInfos
+          lazy val tupledTypes = tupled.dropDependentRefinement.dealias.argInfos
+          if (
+            defn.isImplicitFunctionType(fun) == defn.isImplicitFunctionType(tupled) &&
+            tupledTypes.size == 2 &&
+            defn.tupleType(funTypes.init) =:= tupledTypes.head &&
+            funTypes.last =:= tupledTypes.last
+          ) {
             val arity = funTypes.size - 1
             if (defn.isErasedFunctionType(fun))
               EmptyTree // TODO support?
-            else if (defn.isImplicitFunctionType(fun))
-              EmptyTree // TODO support
             else if (arity <= Definitions.MaxImplementedFunctionArity)
-              ref(defn.InternalTupleFunctionModule).select(s"tupledFunction$arity".toTermName).appliedToTypes(funTypes)
+              ref(defn.InternalTupleFunctionModule).select(s"tupledFunction$arity".toTermName).appliedToTypes(funArgs)
             else
-              ref(defn.InternalTupleFunctionModule).select("tupledFunctionXXL".toTermName).appliedToTypes(fun :: args :: ret :: Nil)
+              ref(defn.InternalTupleFunctionModule).select("tupledFunctionXXL".toTermName).appliedToTypes(funArgs)
           } else EmptyTree
         case _ =>
           EmptyTree

library/src-3.x/dotty/DottyPredef.scala

@@ -45,8 +45,6 @@ object DottyPredef {
    *  @tparam Args the tuple type with the same types as the function arguments of F
    *  @tparam R the return type of F
    */
-  def (f: F) tupled[F, Args <: Tuple, R] given (tf: TupledFunction[F, Args, R]): Args => R = {
-    x => tf.applyFunctionTo(f, x)
-  }
+  def (f: F) tupled[F, Args <: Tuple, R] given (tupled: TupledFunction[F, Args => R]): Args => R = tupled(f)
 
 }

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

@@ -5,12 +5,11 @@ import scala.annotation.implicitNotFound
 /** Type class relating a `FunctionN[..., R]` with an equvalent tupled function `Function1[TupleN[...], R]`
  *
  *  @tparam F a function type
- *  @tparam Args a tuple type with the same types as the function arguments of F
- *  @tparam R the return type of F
+ *  @tparam G a tupled function type (function of arity 1 receiving a tuple as argument)
  */
-@implicitNotFound("${F} cannot be tupled as ${Args} => ${R}")
-trait TupledFunction[F, Args <: Tuple, R] {
-  def applyFunctionTo(f: F, args: Args): R
+@implicitNotFound("${F} cannot be tupled as ${G}")
+trait TupledFunction[F, G] {
+  def apply(f: F): G
 }
 
 /** Module of TupledFunction containing methods for auto function tupling
@@ -37,8 +36,8 @@ object TupledFunction {
    *  @tparam Args the tuple type with the same types as the function arguments of F
    *  @tparam R the return type of F
    */
-  def (f: F) apply[F, Args <: Tuple, R](args: Args) given (tf: TupledFunction[F, Args, R]): R =
-    tf.applyFunctionTo(f, args)
+  def (f: F) apply[F, Args <: Tuple, R](args: Args) given (tupled: TupledFunction[F, Args => R]): R =
+    tupled(f)(args)
 
   /** Composes two instances of TupledFunctions in a new TupledFunctions, with this function applied last
    *
@@ -48,7 +47,7 @@ object TupledFunction {
    *  @tparam GArgs the tuple type with the same types as the function arguments of G
    *  @tparam R the return type of F
    */
-  def (f: F) compose[F, G, FArgs <: Tuple, GArgs <: Tuple, R](g: G) given TupledFunction[G, GArgs, FArgs], TupledFunction[F, FArgs, R]: GArgs => R = {
+  def (f: F) compose[F, G, FArgs <: Tuple, GArgs <: Tuple, R](g: G) given TupledFunction[G, GArgs => FArgs], TupledFunction[F, FArgs => R]: GArgs => R = {
     x => f(g(x))
   }
 
@@ -60,7 +59,7 @@ object TupledFunction {
    *  @tparam GArgs the tuple type with the same types as the function arguments of G and return type of F
    *  @tparam R the return type of G
    */
-  def (f: F) andThen[F, G, FArgs <: Tuple, GArgs <: Tuple, R](g: G) given TupledFunction[F, FArgs, GArgs], TupledFunction[G, GArgs, R]: FArgs => R = {
+  def (f: F) andThen[F, G, FArgs <: Tuple, GArgs <: Tuple, R](g: G) given TupledFunction[F, FArgs => GArgs], TupledFunction[G, GArgs => R]: FArgs => R = {
     x => g(f(x))
   }