Higher-Order Functions

If every call to update a UI element must be done on its own thread, we might end up with a naive implementation like this:

  object Ui {
    def updateUiElements() {
      new Thread() {
        override def run(): Unit = updateCustomerBasket(basket)
      }.start()

      new Thread() {
        override def run(): Unit = updateOffersFor(customer)
      }.start()
    }
  }

The Ui object executes the sequence of updates one after another, each on a new thread. The Ui object is managing the threading policy and the update behavior. It would be better if something else was responsible for coordinating threading and the Ui object was left to the update behavior. That way, we could avoid duplication and if the threading policy changes, we wouldn’t have to find all the usages scattered about the place.

The solution is to define a function that can run some other function on a thread. We could create a function called runInThread with the boilerplate threading code.

  def runInThread() {
    new Thread() {
      override def run(): Unit = ???
    }.start()
  }

It will create and start a new thread but it doesn’t do anything interesting. How do we pass in a function? In Java, you’d probably pass in an anonymous instance of a Runnable or Callable or a lambda.

You do the same in Scala but rather than pass in a functional interface as the argument, you pass in a shorthand signature denoting a function argument. You define a variable as usual (function in the following example) but the type that follows the colon represents a function. Our example has no arguments and returns a value of Unit. It’s equivalent to Java’s signature for a lambda: () -> Void.

  def runInThread(function: () => Unit) {
    new Thread() {
      override def run(): Unit = ???
    }.start()
  }

Then we just execute the function in the body of the thread. Remember the brackets denote the shorthand for executing the apply method.

  def runInThread(function: () => Unit) {
    new Thread() {
      override def run(): Unit = function()       // aka function.apply()
    }.start()
  }

Given the new runInThread method, we can rewrite the UI code like this:

  def updateUiElements() {
    runInThread(() => updateCustomerBasket(basket))
    runInThread(() => updateOffersFor(customer))
  }

We’ve eliminated the duplication by passing in functions to runInThread.

Higher-Order Functions with Curly Braces

This doesn’t really live up to the promise of clients being able to pass functions as arguments “in a natural and concise way”. It looks a lot like Java’s lambda syntax, but we can make it look more natural and more like language syntax if we use the curly braces.

If we just replace the parentheses with curly braces, it doesn’t really improve things.

  // yuk!
  def updateUiElements() {
    runInThread { () =>
      updateCustomerBasket(basket)
    }

    runInThread { () =>
      updateOffersFor(customer)
    }
  }

But we can employ another trick to get rid of the empty parentheses and arrows. We can use what’s called a call-by-name parameter.

Call-by-Name

In Java, you can’t do anything about an empty lambda argument list (e.g., () -> Void) but in Scala, you can drop the brackets from a function signature to indicate that the argument is call-by-name . To invoke it, you no longer need to call the apply method. Instead, you simply reference it.

  def runInThread(function: => Unit) {         // call-by-name
    new Thread() {
      override def run(): Unit = function      // not function()
    }.start()
  }

The by-name parameter expression isn’t evaluated until it’s actually used; not when it’s defined. It behaves just like the longhand function did even though it looks like we’re calling the function at the point where we pass it into our runInThread method.

  def updateUiElements() {
    runInThread {
      updateCustomerBasket(basket)
    }

    runInThread {
      updateOffersFor(customer)
    }
  }

This starts to make things look a lot more natural, especially if we want to do more within a running thread. For example, let’s say we want to apply a discount before updating a customer’s basket. The braces and indents make it very clear that this happens in the same thread as the update.

  def updateUiElements() {
    runInThread {
      applyDiscountToBasket(basket)
      updateCustomerBasket(basket)
    }
    runInThread {
      updateOffersFor(customer)
    }
  }

You can think of it as shorthand for creating a parameter-less lambda.

Scala Support for Curried Functions

A regular uncurried function to add two numbers might look like this:

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

Scala supports curried functions out of the box, so we don’t need to do any manual conversion; all we do to turn this into its curried version is to separate out the arguments using parentheses.

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

Scala has created two single-argument parameter lists for us. To evaluate the function, we’d do the following:

  scala> add(1)(2)
  res1: Int = 3

To see it in stages, we could just evaluate the first half like this:

  scala> val f = add(1) _
  f: Int => Int = <function1>

The underscore gives the REPL a hint about what we’re trying to do. The result f is a function from Int to Int. The value 1 has been captured and is available to that function. So, we can now just execute the returned function supplying our second value.

  scala> f(2)
  res2: Int = 3

So, what does this mean for our runInThread method? Well, if we create a curried version of the function, we can get back to using our lovely curly braces.

We start by splitting the argument into two to create the curried form of the original.

  def runInThread(group: String)(function: => Unit) {
    new Thread(new ThreadGroup(group), new Runnable() {
      def run(): Unit = function
    }).start()
  }

Notice there are no other changes to make to the function. Inside runInThread everything is just as it was. However, we can now change the Ui object back to using curly braces for the second argument.

  def updateUiElements() {
    runInThread("basket") {
      applyDiscountToBasket(basket)
      updateCustomerBasket(basket)
    }
    runInThread("customer",
      updateOffersFor(customer)
    )
  }