Scala currying vs partially applied functions

by

The semantic difference has been explained fairly well in the answer linked to by Plasty Grove.

In terms of functionality, there doesn’t seem much of a difference, though. Let’s look at some examples to verify that. First, a normal function:

scala> def modN(n: Int, x: Int): Boolean = ((x % n) == 0)
scala> modN(5, _ : Int)
res0: Int => Boolean = <function1>

So we get a partially applied <function1> that takes an Int, because we’ve already given it the first integer. So far so good. Now to currying:

scala> def modNCurried(n: Int)(x: Int): Boolean = ((x % n) == 0)

With this notation, you’d naively expect the following to work:

scala> modNCurried(5)
<console>:9: error: missing arguments for method modN;
follow this method with `_' if you want to treat it as a partially applied function
          modNCurried(5)

So the multiple parameter list notation doesn’t really seem to create a curried function right away (assumingly to avoid unnecessary overhead) but waits for you to explicitly state that you want it curried (the notation has some other advantages as well):

scala> modNCurried(5) _
res24: Int => Boolean = <function1>

Which is exactly the same thing we got before, so no difference here, except for notation. Another example:

scala> modN _
res35: (Int, Int) => Boolean = <function2>

scala> modNCurried _
res36: Int => (Int => Boolean) = <function1>

This demonstrates how partially applying a “normal” function results in a function that takes all parameters, whereas partially applying a function with multiple parameter lists creates a chain of functions, one per parameter list which, all return a new function:

scala> def foo(a:Int, b:Int)(x:Int)(y:Int): Int = a * b + x - y
scala> foo _
res42: (Int, Int) => Int => (Int => Int) = <function2>

scala> res42(5)
<console>:10: error: not enough arguments for method apply: (v1: Int, v2: Int)Int => (Int => Int) in trait Function2.
Unspecified value parameter v2.

As you can see, because the first parameter list of foo has two parameters, the first function in the curried chain has two parameters.

In summary, partially applied functions aren’t really different form curried functions in terms of functionality. This is easily verified given that you can convert any function to a curried one:

scala> (modN _).curried
res45: Int => (Int => Boolean) = <function1

scala> modNCurried _
res46: Int => (Int => Boolean) = <function1>

Post Scriptum

Note: The reason that your example println(filter(nums, modN(2)) works without the underscore after modN(2) seems to be that the Scala compiler simply assumes that underscore as a convenience for the programmer.

Addition: As @asflierl has correctly pointed out, Scala doesn’t seem to be able to infer the type when partially applying “normal” functions:

scala> modN(5, _)
<console>:9: error: missing parameter type for expanded function ((x$1) => modN(5, x$1))

Whereas that information is available for functions written using multiple parameter list notation:

scala> modNCurried(5) _
res3: Int => Boolean = <function1>

This answers shows how this can be very useful.

More Related Contents:

  1. What is Scala’s yield?
  2. What is the difference between Scala’s case class and class?
  3. What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?
  4. Difference between reduce and foldLeft/fold in functional programming (particularly Scala and Scala APIs)?
  5. Abort early in a fold
  6. What is the difference between def foo = {} and def foo() = {} in Scala?
  7. What’s the difference between multiple parameters lists and multiple parameters per list in Scala?
  8. val-mutable versus var-immutable in Scala
  9. Two ways of currying in Scala; what’s the use-case for each?
  10. Using Either to process failures in Scala code
  11. When to use parenthesis in Scala infix notation
  12. When and why should one use Applicative Functors in Scala
  13. Function returns an empty List in Spark
  14. Functional programming, Scala map and fold left [closed]
  15. Usefulness (as in practical applications) of Currying v.s. Partial Application in Scala
  16. What is a function literal in Scala?
  17. Why does Scala provide both multiple parameters lists and multiple parameters per list? [duplicate]
  18. How to sort a list in Scala by two fields?
  19. Can I zip more than two lists together in Scala?
  20. Cross product in Scala
  21. Applying an argument list to curried function using foldLeft in Scala
  22. Functional Reactive Programming in Scala [closed]
  23. Using partial functions in Scala – how does it work?
  24. Functions vs methods in Scala
  25. What does setMaster `local[*]` mean in spark?
  26. Encode an ADT / sealed trait hierarchy into Spark DataSet column
  27. Difference between MutableList and ListBuffer
  28. Spark RDD default number of partitions
  29. Why does Spark RDD partition has 2GB limit for HDFS?
  30. How to use IntelliJ with Play Framework and Scala

Leave a Comment