One of Scala's benefits is that it allows a developer to create control structures that, while not part of the language, feel as though they were. Such control structures make programs more natural to read.

One way Scala supports such natural-looking constructs is its implementation of currying, a technique that allows the transformation of a multi-argument method into a method with a single argument. The new single-argument method returns another method, with one argument, which is the next argument in the original method's argument list.

In a recent article, Function Currying in Scala, Daniel Spiewak explains how function currying works, and illustrates its benefits:

The currying process transforms a function of two parameters into a function of one parameter which returns a function of one parameter which itself returns the result. In Scala, we can accomplish this like so:

def add(x:Int, y:Int) = x + y
 
add(1, 2)   // 3
add(7, 3)   // 10

And after currying:

def add(x:Int) = (y:Int) => x + y
 
add(1)(2)   // 3
add(7)(3)   // 10

Spiewak also shows Scala's idiomatic syntax for curried functions:

We can shorten our curried definition to something more like this:

def add(x:Int)(y:Int) = x + y
 
add(1)(2)   // 3
add(7)(3)   // 10

While at first such transformations may seem merely syntactic sugar, Spiewak points out several uses of function currying in the article

Of course, it’s not very apparent as to why this is a good idea. All we’ve really accomplished is eliminate the second parameter and move it into another function. This is a big deal in languages like Haskell which only allow a single parameter, but Scala doesn’t have this restriction...

It turns out that the best rationale for using currying has to do with general and specialized functions. It would be nice to define a function for the general case, but allow users to specialize the function and then used the specialized version on different data sets.

In the article, Spiewak illustrates the use of currying in the case of partially applied functions. What do you think of function currying in Scala?

public interface IRSable<T> {
 
   public T fromResultSet(ResultSet rs, Object extra) throws SQLException ;
}

def limiter = { x, y -> Math.min(x, y) }
def limitTo100 = limiter.curry(100)
println "limit(110): " + limitTo100(110)
println "limit(90): " + limitTo100(90)

def limitTo100 = { x, y -> Math.min(x, y) }.curry(100)
println "limit(110): " + limitTo100(110)
println "limit(90): " + limitTo100(90)

class MyFunction extends Function {
   public static SomeType apply(firstParam, secondParam) {
      // some code
   }
}

class MyCurriedFunction extends MyFunction {
    public static SomeType apply(secondParam) {
          apply( FIX_VALUE, secondParam ) 
    }
}


result = MyCurriedFunction.apply( aValue )

class MyFunction extends Function {
   protected firstParam
   protected secondParam

   MyFunction(first, second) {
        firstParam = first
        secondParam = second
   }

   public Object apply() {
      // some code working with firstParam, secondParam
   }
}

myFunc = new MyFunction( valueOne, valueTwo )
result = myFunc.apply()

class MyCurriedFunction extends MyFunction {

   MyCurriedFunction(second) {
        super(FIX_VALUE, second)
   }

}

myFunc = new MyCurriedFunction( valueTwo )
result = myFunc.apply()