Currying, That’s Why

Daniel did a great job at explaining why parameterless methods are necessary. I’ll explain why they are regarded distinctly from zero-parameter methods.

Many people view the distinction between parameterless and zero-parameter functions as some vague form of syntactic sugar. In truth it is purely an artifact of how Scala supports currying (for completeness, see below for a more thorough explanation of what currying is, and why we all like it so much).

Formally, a function may have zero or more parameter lists, with zero or more parameters each.
This means the following are valid: def a, def b(), but also the contrived def c()() and def d(x: Int)()()(y: Int) etc…

A function def foo = ??? has zero parameter lists. A function def bar() = ??? has precisely one parameter list, with zero parameters. Introducing additional rules that conflate the two forms would have undermined currying as a consistent language feature: def a would be equivalent in form to def b() and def c()() both; def d(x: Int)()()(y: Int) would be equivalent to def e()(x: Int)(y: Int)()().

One case where currying is irrelevant is when dealing with Java interop. Java does not support currying, so there’s no problem with introducing syntactic sugar for zero-parameter methods like "test".length() (which directly invokes java.lang.String#length()) to also be invoked as "test".length.

A quick explanation of currying

Scala supports a language feature called ‘currying’, named after mathematician Haskell Curry.
Currying allows you to define functions with several parameter lists, e.g.:

def add(a: Int)(b: Int): Int = a + b
add(2)(3) // 5

This is useful, because you can now define inc in terms of a partial application of add:

def inc: Int => Int = add(1)
inc(2) // 3

Currying is most often seen as a way of introducing control structures via libraries, e.g.:

def repeat(n: Int)(thunk: => Any): Unit = (1 to n) foreach { _ => thunk }

repeat(2) {
  println("Hello, world")
}

// Hello, world
// Hello, world

As a recap, see how repeat opens up another opportunity to use currying:

def twice: (=> Any) => Unit = repeat(2)

twice {
  println("Hello, world")
}

// ... you get the picture :-)