Adding Clause Interleaving to method definitions

[Sporarum]

This aims to add the ability to declare functions with many clauses of type parameters, instead of at most one, and to allow those clauses to be interleaved with term clauses:

def foo[A](x: A)[B](y: B) = (x, y)

All user-facing details can be found in the Scala 3 new features doc, and in the SIP proposal

The implementation details are described below in the commit messages

The community's opinion of the feature can be found on the scala contributors forum
(note however that the description there is somewhat outdated)

Dependencies

This feature has been accepted by the SIP committee for implementation, it can therefore become part of the language as an experimental feature at any time.

The feature will be available with import scala.language.experimental.clauseInterleaving

How to make non-experimental

git revert the commits named "Make clause interleaving experimental" and "Add import to tests":

git revert 6ace5b816a1845993b0f002067e65d98882667ee
git revert 1e402f3e44310dab4699fcbacbf6afc1eefb261c

Future Work

1. Implement given aliases with clause interweaving: (to have types depends on terms)

given myGiven[T](using x: T)[U](using y: U) = (x, y)

2. Add interleaved clauses to the left-hand side of extension methods:

extension (using Int)[A](using A)(a: A)[B](using B)
  def foo: (A, B) = ???

3. Investigate usefulness/details of clause interweaving for classes and type currying for types:

class Foo[A](a: A)[B](b: B)
new Foo(0)("Hello!") // type: Foo[Int][String] ?

type Bar[A][B] = Map[A, B]
Bar[Char] // should this mean [B] =>> Bar[Char][B] ?

(Started as a semester project with supervision from @smarter, now part of my missions as an intern at the scala center)

[soronpo]

I'm not sure if you thought about the type system when a method application is split to blocks.
Before this SIP type arguments are inferred as Nothing because they all "belong" to the first block.
If this SIP is added, I expect the following to compile:

  class Box[T](x: T)
  def huge[T1, T2](
    t1: T1, t2 : T2, r : Int
  )[T3, T4](t3: T3, r2: Int, t4: T4)[T5](t5 : T5*): Box[(T1, T2, T3, T4, T5)] = ???

  val h1p1 = huge((1, 2), (3, 4), 5)
  val h1p2 = h1p1((6, 7), 8, (9, 10))
  val h1p3 = h1p2(11, 12)
  val h1pTest: Box[((Int, Int), (Int, Int), (Int, Int), (Int, Int), Int)] = h1p3