Why does Scala provide both multiple parameters lists and multiple parameters per list? [duplicate]

Question

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.

Naima

In general: it's simply more mathematically expressive. Why suffice with one list when you can generalize to a plurality :) – Dogeatdog

Answer 1

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

Aureolin

One limitation of this is that, although you have a variable length for each parameter group, the number of groups must be fixed (in this case, at 3). – Graiae

Since you have accepted this answer, it should be noted that this is just an example and might not be the canonical answer to your "why" question. – Aureolin

This is the first concrete reason I have seen to date for having both types of parameters. All the others are quite ad hoc. That said, I still don't see any of these reasons as worth the syntactic baggage and complication of the language. – Naima

It's quite unavoidable that you have the option of curried functions in a language that supports both function types and tuples. The only question is whether you provide a little extra syntax sugar for declaring them, which is all the "parameter group" syntax is. Without it, you could do essentially the same thing, but you'd have to type a little more: def foo[A, B, C, D, E](a:A, b:B) = (c:C, d:D) => (e:E) => ... – Graiae

It might not be obvious to everyone what your example shows. Maybe 2 setences of explaination would do wonders. – Organic

What's the point? Optional arguments? – Deflexed

Multiple varargs. Until now a pipe dream. So cool. – Eightfold

Answer 2

As well as allowing you to write methods that look like part of the language (which you already spotted), it's worth noting that the type inferencer will work with one block at a time.

So in this:

def foo[T](a: T, b: T)(op: (T,T)=>T) = op(a,b)
foo(1,2){_+_}

T will first be inferred as Int, which will then be used as the type of the two underscores in the closure. This is how the compiler then knows, with complete type safety, that the + operation is valid.

Anesthesiologist

In case anyone is reading this thread post 2021, Scala 3 infers the types correctly even if they are on a single parameter list. – Egon

Answer 3

To answer your "related question," currying is simply a way of turning a function of multiple arguments, for example (A, B, C) => D, into a function which takes one argument and returns a function, e.g. A => (B => (C => D)) (parentheses shown but not necessary).

The tuple-ized form and the curried form are isomorphic, and we may translate freely between them. All of these are equivalent, but have different syntactic implications:

(A, B, C, D, E) => F
((A, B), (C, D, E)) => F
(A, B) => (C, D, E) => F

When you declare separate parameter groups, this is the kind of currying you're doing. The multi-parameter-group method is a method which returns a function... you can see this in the REPL:

scala> def foo(a:Int, b:Int)(c:Int, d:Int, e:Int):Int = 9
foo: (a: Int,b: Int)(c: Int,d: Int,e: Int)Int

scala> foo _                                             
res4: (Int, Int) => (Int, Int, Int) => Int = <function2>

Graiae

Answer 4

Back references in default arguments:

case class Foo(bar: Int)

def test(f: Foo)(i: Int = f.bar) = i*i

test(Foo(3))()

Klaxon

Answer 5

I know one of the motivations was implicit parameter lists. "implicit" is a property of the list, not the parameter. Another was probably case classes: only the first parameter list become case fields.

Bhatt

Interesting. Any chance you can expand on this? – Naima

On case classes with multiple parameter lists, see comments on this bug. That's where I heard about this feature first. – Elasticize