Nested patterns in lambda case

[jiribenes]

Originally reported by @TheDying0fLight -- I thought there already was an issue for this, but I couldn't find it, sorry!

The following nested pattern matching of a tuple in lambda case is not supported:

[(1, 2), (3, 4)].foldLeft(0) { (acc, (x, y)) => acc + x + y }

as it returns a parser error Expected ; on the => token.

What also doesn't work is using case like Scala would (see comment below):

[(1, 2), (3, 4)].foldLeft(0) { case (acc, (x, y)) => acc + x + y }

as that reports Wrong number of value arguments, given 1, but function expects 2.

A workaround that does actually work is, for example:

[(1, 2), (3, 4)].foldLeft(0) { (acc, tup) => 
  val (x, y) = tup;
  acc + x + y
}

(or just using tup.first, tup.second)

This doesn't show up only for tuples, but for anything nested in general:

record Person(name: String, age: Int)
def main() = 
  [Person("Joe", 42), Person("Jolene", 24)].foldLeft(0) { 
    (acc, Person(name, age)) =>
       acc + age
   }

again returns Expected ; on the =>.

This is somewhat related to #707.

[jiribenes]

I think that in Scala 3, one needs the case keyword here:

List((1, 2), (3, 4)).foldLeft(0) { case (acc, (x, y)) => acc + y }

[b-studios]

What about the Coq / Roq style?

foo { case x, y => ... } 

which "clearly" matches on two arguments, not a tuple.