Question

I’m trying to understand the point of this language feature of multiple parameter clauses and why you would use it.
Eg, what’s the difference between these two functions really?

class WTF {
    def TwoParamClauses(x : Int)(y: Int) = x + y
    def OneParamClause(x: Int, y : Int) = x + y
}

>> val underTest = new WTF
>> underTest.TwoParamClauses(1)(1) // result is '2'
>> underTest.OneParamClause(1,1) // result is '2' 

There’s something on this in the Scala specification at point 4.6. See if that makes any sense to you.

NB: the spec calls these ‘parameter clauses’, but I think some people may also call them ‘parameter lists’.

Answer 1

Here are three practical uses of multiple parameter lists,

1. To aid type inference. This is especially useful when using higher order methods. Below, the type parameter A of g2 is inferred from the first parameter x, so the function arguments in the second parameter f can be elided,

   def g1[A](x: A, f: A => A) = f(x)
   g1(2, x => x) // error: missing parameter type for argument x
   
   def g2[A](x: A)(f: A => A) = f(x)
   g2(2) {x => x} // type is inferred; also, a nice syntax
   

2. For implicit parameters. Only the last parameter list can be marked implicit, and a single parameter list cannot mix implicit and non-implicit parameters. The definition of g3 below requires two parameter lists,

   // analogous to a context bound: g3[A : Ordering](x: A)
   def g3[A](x: A)(implicit ev: Ordering[A]) {}
   

3. To set default values based on previous parameters,

   def g4(x: Int, y: Int = 2*x) {} // error: not found value x
   def g5(x: Int)(y: Int = 2*x) {} // OK