Change fewerbraces to always use a colon, even before lambdas

[odersky]

So it's

   xs.map: x =>
       x + 1
     .foldLeft: (x, y) =>
       x + y

But the following will still not work (it is however supported by #15258):

   xs.map: x => x + 1
     .foldLeft: (x, y) => x + y

[tgodzik]

I feel like this proposal looks much cleaner that the previous approach. I left a few comments, but I would say the only blocking one is the issue with no whitespace allowed before :

[tgodzik]

So instead of single : we need to explicitely call apply in case of curried functions? I think that is sensible

[julienrf]

I think the proximity with type ascriptions is too close:

def f(x: Int)(y: Int): Int
def g(x: Int): Int => Int

// type ascription
f(42): Int => Int
// lambda argument
g(42): (x: Int) =>
  x + 1
// inline lambda argument
g(42): (x: Int) => x + 1

// puzzle…
trait X:
  type Y
  def Y: Y

val k: (x: X) => x.Y // type ascription or lambda argument?
// even worse
def z(n: Int): (x: X) => x.Y
z(42): (x: X) => x.Y // type ascription or lambda argument?

[julienrf]

In Scala 2, we could not write:

xs.foldLeft(0)((x, y) =>
  val z = x + y
  z + 1
)

This is one of the reasons why it was convenient to use braces instead of the usual application with parens:

xs.foldLeft(0) { (x, y) =>
  val z = x + y
  z + 1
}

But now, even without fewerBraces, it is possible in Scala 3 to write the first form.

I don’t think we should get rid of the parens, which are anyway required for “non-lambda” arguments.

[odersky]

@julienrf Note that lambda arguments in the version must be multi-line with a => at the end of the first line. Furthermore the function type in ascriptions must be in parentheses unless the whole expression appears in parentheses. That means many of the examples are neither type ascription nor lambda argument. I agree we have a problem if we allow single-line lambdas, though.

[odersky]

Fixes #15082

[odersky]

I think this is a clear win over what we had before. If there are no objections I am going to merge this tomorrow.