Add generalized tupled functions abstraction

[nicolasstucki]

This introduces the type class

trait TupledFunction[F, G] {
  def tupled(f: F): G
  def untupled(g: G): F
}

which the compiler only instantiates if:

• F is a function type of arity N
• G is a function with a single tuple argument of size N and it's types are equal to the arguments of F
• The return type of F is equal to the return type of G
• F and G are the same kind of function (both are (...) => R or both are given (...) => R)
• If only one of F or G is instantiated the second one is inferred

This abstraction allows to abstract over function arities:

• Adds the ability to write extension methods on functions of any arity
• It trivially introduces the tupled method on functions of arity larger than 22
• Under an import, it allows the application of a function directly to a tuple containing all the arguments (auto function tupling).
• Use andThen and compose directly on functions returning tuples without the need for a call to tupled (auto function tupling).

[julienrf]

Interesting. However, I would say that we miss an example of a problem that is solved by this feature. None of the tests actually abstract over the arity of the functions.

[nicolasstucki]

The first motivation of this is resumed in part in https://github.com/lampepfl/dotty/blob/24a1d00e0dc0aad01711119ac5b46cf9a85b8a66/tests/run/tupled-function-extension-method.scala which captures the essence of the limitation we have in https://github.com/lampepfl/dotty/blob/master/library/src-3.x/scala/quoted/Expr.scala. There we need to implement the extension method for each of the 22 functions and we cannot scale up to any arbitrary function arity.

[milessabin]

LGTM :-)

I think we most likely also want something that goes in the opposite direction (tupled to untupled).

[nicolasstucki]

Yes. I already started looking into it :)

[nicolasstucki]

I think I should add the untupling before merging.

[nicolasstucki]

@milessabin I added untuple and improved type inference in the last two commits