Question

Not sure how to properly formulate the question, there is a problem with currying in the merge sort example from Scala by Example book on page 69. The function is defined as follows:

def msort[A](less: (A, A) => Boolean)(xs: List[A]): List[A] = {
  def merge(xs1: List[A], xs2: List[A]): List[A] =
    if (xs1.isEmpty) xs2
    else if (xs2.isEmpty) xs1
    else if (less(xs1.head, xs2.head)) xs1.head :: merge(xs1.tail, xs2)
    else xs2.head :: merge(xs1, xs2.tail)
  val n = xs.length/2
  if (n == 0) xs
  else merge(msort(less)(xs take n), msort(less)(xs drop n))
}

and then there is an example of how to create other functions from it by currying:

val intSort = msort((x : Int, y : Int) => x < y)
val reverseSort = msort((x:Int, y:Int) => x > y)

however these two lines give me errors about insufficient number of arguments. And if I do like this:

val intSort = msort((x : Int, y : Int) => x < y)(List(1, 2, 4))
val reverseSort = msort((x:Int, y:Int) => x > y)(List(4, 3, 2))

it WILL work. Why? Can someone explain? Looks like the book is really dated since it is not the first case of such an inconsistance in its examples. Could anyone point to something more real to read? (better a free e-book).

Answer 1

My compiler (2.9.1) agrees, there seems to be an error here, but the compiler does tell you what to do:

error: missing arguments for method msort in object $iw;
follow this method with `_' if you want to treat it as a partially applied function

So, this works:

val intSort = msort((x : Int, y : Int) => x < y) _

Since the type of intSort is inferred, the compiler doesn’t otherwise seem to know whether you intended to partially apply, or whether you missed arguments.

The _ can be omitted when the compiler can infer from the expected type that a partially applied function is what is intended. So this works too:

val intSort: List[Int] => List[Int] = msort((x: Int, y: Int) => x < y)

That’s obviously more verbose, but more often you will take advantage of this without any extra boilerplate, for example if msort((x: Int, y: Int) => x < y) were the argument to a function where the parameter type is already known to be List[Int] => List[Int].

---

Edit: Page 181 of the current edition of the Scala Language Specification mentions a tightening of rules for implicit conversions of partially applied methods to functions since Scala 2.0. There is an example of invalid code very similar to the one in Scala by Example, and it is described as “previously legal code”.