Scala collections: why do we need a case statement to extract values tuples in higher order functions?

Question

Related to Tuple Unpacking in Map Operations, I don't understand why do we need a case (that looks like a partial function to me) to extract values from tuple, like that:

arrayOfTuples map {case (e1, e2) => e1.toString + e2}

Instead of extracting in the same way it works in foldLeft, for example

def sum(list: List[Int]): Int = list.foldLeft(0)((r,c) => r+c)

Anyway we don't specify the type of parameters in the first case, so why do we need the case statement?

Answer 1

Because in Scala function argument lists and tuples are not a unified concept as they are in Haskell and other functional languages. So a function:

(t: (Int, Int)) => ...

is not the same thing as a function:

(e1: Int, e2: Int) => ...

In the first case you can use pattern matching to extract the tuple elements, and that's always done using case syntax. Actually, the expression:

{case (e1, e2) => ...}

is shorthand for:

t => t match {case (e1, e2) => ...}

There has been some discussions about unifying tuples and function argument lists, but there are complications regarding Java overloading rules, and also default/named arguments. So, I think it's unlikely the concepts will ever be unified in Scala.