scala currying by nested functions or by multiple parameter lists

Question

In Scala, I can define a function with two parameter lists.

def myAdd(x :Int)(y :Int) = x + y

This makes it easy to define a partially applied function.

val plusFive = myAdd(5) _

But, I can accomplish something similar by defining and returning a nested function.

  def myOtherAdd(x :Int) = {
    def f(y :Int) = x + y
    f _
  }

Cosmetically, I've moved the underscore, but this still feels like currying.

val otherPlusFive = myOtherAdd(5)

What criteria should I use to prefer one approach over the other?

Answer 1

There are at least four ways to accomplish the same thing:

def myAddA(x: Int, y: Int) = x + y
val plusFiveA: Int => Int = myAddA(5,_)

def myAddB(x: Int)(y : Int) = x + y
val plusFiveB = myAddB(5) _

def myAddC(x: Int) = (y: Int) => x + y
val plusFiveC = myAddC(5)

def myAddD(x: Int) = {
  def innerD(y: Int) = x + y
  innerD _
}
val plusFiveD = myAddD(5)

You might want to know which is most efficient or which is the best style (for some non-performance based measure of best).

As far as efficiency goes, it turns out that all four are essentially equivalent. The first two cases actually emit exactly the same bytecode; the JVM doesn't know anything about multiple parameter lists, so once the compiler figures it out (you need to help it with a type annotation on the case A), it's all the same under the hood. The third case is also extremely close, but since it promises up front to return a function and specifies it on the spot, it can avoid one internal field. The fourth case is pretty much the same as the first two in terms of work done; it just does the conversion to Function1 inside the method instead of outside.

In terms of style, I suggest that B and C are the best ways to go, depending on what you're doing. If your primary use case is to create a function, not to call in-place with both parameter lists, then use C, because it tells you what it's going to do. (This version is also particularly familiar to people coming from Haskell, for instance.) On the other hand, if you are mostly going to call it in place but will only occasionally curry it, then use B. Again, it says more clearly what it's expected to do.