Currying in Scala

Currying is a technique in functional programming where a function that takes multiple arguments is transformed into a sequence of functions, each taking a single argument. This technique has been named after Haskell Curry, who was an American mathematician and logician. The technique is widely used in many functional programming languages, including Scala.

Basics of Currying

In Scala, a function can be curried by declaring multiple parameter lists. For example, consider the following curried function that takes two integers and returns their sum.

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

Here, the add function has two parameter lists. When the function is called, it will have to be called as shown below:

val result = add(10)(20)

In this example, the first parameter list takes the value 10 and returns a second function that takes the value 20.

Advantages of Currying

Currying provides several benefits. The most significant advantage of currying is that it enables partial function application. Partial function application is the process of fixing some of the arguments of a function and creating a new function that requires fewer arguments. For example, consider a curried function that multiplies two integers.

def multiply(x: Int)(y: Int): Int = x * y

The curried function can be partially applied by fixing one parameter, as shown below:

val double: Int => Int = multiply(2) _

Here, the underscore _ is used to transform the curried function into a partial function that takes a single argument. This partial function can be used to double the value of an integer by calling it with the value of the integer as shown below:

val result = double(10)

Conclusion

Currying is a powerful technique that has many benefits. It enables partial function application, enhances composability, and enables the creation of higher-order functions. In Scala, currying is a natural part of the language and its standard library, and it is used extensively in both application-level and library-level code.