Why does Scala provide both multiple parameters lists and multiple parameters per list?
currying, partial-application, scala
Solution
It makes you able to do e.g.:
scala> def foo(as: Int*)(bs: Int*)(cs: Int*) = as.sum * bs.sum * cs.sum
foo: (as: Int*)(bs: Int*)(cs: Int*)Int
scala> foo(1, 2, 3)(4, 5, 6, 7, 9)(10, 11)
res7: Int = 3906
Problem
Multiple parameters lists, e.g. `def foo(a:Int)(b:Int) = {}` and multiple parameters per list, e.g. `def foo(a:Int, b:Int) = {}` are semantically equivalent so far as I can tell, and most functional languages have only one way of declaring multiple parameters, e.g. F#. The only reason I can figure out for supporting both these styles of function definitions is to allow syntax-like language extensions using a parameter list that has only one parameter in it. ``` def withBufferedWriter(file: File)(block: BufferedWriter => Unit) ``` can now be called with the syntax-looking ``` withBufferedWriter(new File("myfile.txt")) { out => out write "whatever" ... } ``` However, there could be other ways of supporting the use of curly braces without having multiple parameter lists. A related question: why is the use of multiple parameter lists in Scala called "currying"? Currying is usually defined as a technique for making an n-ary function unary for the sake of supporting partial application. However, in Scala one can partially apply a function without making a "curried" (multiple parameter lists with one param each) version of the function.