Anonymous Functions

A function in the general sense is a code fragment designed to perform a specific task or calculation. You can create a function as a Java method or a Scala def. Both by their nature are named. Anonymous functions, on the other hand, do not have a name.

An anonymous function is also called a lambda and when used can be referred to as a function literal .

Java lambda syntax starts by listing the arguments to the function then the arrow token followed by the implementation body. The following example is a lambda taking two string arguments and comparing their values for a sorting algorithm.

  // java
  (String a, String b) -> {
      int comparison = a.compareTo(b);
      return comparison;
  };

If the compiler can infer the types of the argument, you can drop the types and, if the body is a single line expression, you can drop the return.

  (a, b) -> a.compareTo(b);         // abbreviated form

For single argument lambdas, you can even drop the parameter parenthesis but if there are no arguments, you need empty parenthesis.

  value -> value * 2;               // single argument
  () -> 2 + 2;                      // no arguments

In Scala, a lambda looks very similar. As the last statement in an expression is assumed to be the return value, the return keyword is not required.

  // scala
  (a: String, b: String) => {
    val comparison = a.compareTo(b)
 comparison
  }

If Scala can infer the arguments, the types can be dropped as in Java and single line expressions don’t require braces.

  // scala
  (a, b) => a.compareTo(b)          // abbreviated form

Anonymous classes can be used to provide functionality in a similar way to anonymous functions but they can not accurately be called lambdas.

Anonymous Classes

An anonymous class isn’t the same thing as an anonymous function. An anonymous class still needs to be instantiated to an object via the new keyword. It may not have a name but it’s only useful when it’s an instance object.

An anonymous function, on the other hand, has no instance associated with it. Functions are disassociated with the data they act on.

A typical anonymous class in Java might look like this:

  // java
  List<String> list = Arrays.asList("A", "C", "B", "D");
  list.sort(new Comparator<String>() {
      @Override
      public int compare(String a, String b) {
          return a.compareTo(b);
      }
  });

You can still create anonymous classes in Scala but you don’t often need to. In Scala it’s more common to create an anonymous function or lambda. Indeed, since the introduction of lambdas in Java 8, the same is also true of Java.

  // scala
  val list = List("A", "C", "B", "D")
  list.sorted(new Ordering[String] {
    def compare(a: String, b: String): Int = a.compareTo(b)
  })

Just as with Java, to create an anonymous class instance in Scala, you use the new keyword with braces and define the implementation within the body. Notice that you don’t need to add the constructor brackets (new Ordering[String]()).

First-class Functions

As we’ve seen, an anonymous function is called a lambda. It’s a compact way to define a function. Anonymous functions are useful when you want to define calculations or transformations and apply them to different values later. For example, passing functions into other functions or storing function definitions for later use.

This kind of usage is referred to as treating functions as first-class citizens. Specifically, a language supports first-class functions, if it:

1. Supports passing functions as arguments into other functions.

2. Can return functions as values from other functions.

3. Can store them in variables or within data structures.

Lambdas facilitate first-class function support by providing a compact syntax and by the fact that the compiler generates special bytecode for the lambda syntax.¹

A lambda defining the preceding sorting calculations looks like this:

  (String a, String b) -> a.compareTo(b);     // java

  (a: String, b: String) => a.compareTo(b)    // scala

  // java
  List<String> list = Arrays.asList("A", "C", "B", "D");
  list.sort((a, b) -> a.compareTo(b));                     // ascending
  list.sort((a, b) -> b.compareTo(a));                     // descending

  // scala
  val list = List("A", "C", "B", "D")
  list.sorted((a: String, b: String) => a.compareTo(b))    // ascending
  list.sorted((a: String, b: String) => b.compareTo(a))    // descending

  // scala
  def dollarTo(currency: String, dollar: Double) = {
    if (currency == "GBP") dollar * 0.76
    else if (currency == "EUR") dollar * 0.83
    else dollar
  }

  // scala
  def dollarTo(currency: String): Double => Double = {
    if (currency == "GBP") dollar => dollar * 0.76
    else if (currency == "EUR") dollar => dollar * 0.83
    else dollar => dollar
  }

  // scala
  def calculateTicketPrice(targetCurrency: String) = {
    dollarTo(targetCurrency, 199.99)
    // ...
  }

  def calculateTicketPrice(currencyConversion: Double=> Double) = {
    currencyConversion(199.99)
    // ...
  }

  calculateTicketPrice(dollarTo("GBP"))
  calculateTicketPrice(yahooFxRateFor("GBP"))
  calculateTicketPrice(historicalRateFor("GBP"))

  (Integer a, Integer b) -> a + b;        // java

  // java
  BiFunction<Integer, Integer, Integer> plus = (Integer a, Integer b) -> a+b;

  public interface BiFunction<T, U, R> {
      R apply(T t, U u);
  }

  // java
  BiFunction<Integer, Integer, Integer> plus = (a, b) -> a + b;

  // java
  plus.apply(2, 2);                     // 4
  plus.apply(plus.apply(2, 2), 2);      // 6

  (a: Int, b: Int) => a + b             // scala

  val plus: Function2[Int, Int, Int] = (a: Int, b: Int) => a + b   // scala

  val plus: (Int, Int) => Int = (a: Int, b: Int) => a + b          // scala

  val plus: (Int, Int) => Int = (a, b) => a + b                    // scala

  // scala
  plus(2, 2)              // 4
  plus(plus(2, 2), 4)     // 8

Function Types

Both Java and Scala support functions as first-class citizens as they support all the preceding points. However, an academically interesting difference is that Java doesn’t support function types whereas Scala does.

Although you can define a lambda’s type using Function2 in Scala as follows:

  val f: Function2[String, String, Int] = (a, b) => a.compareTo(b)

…you can also define it using a function type.

  val f: (String, String) => Int = (a, b) => a.compareTo(b)

The type declaration to the left of the assignment is known as a function type. (String, String) => Int is a full type in Scala, it declares a function from two string arguments returning an integer. It can be used anywhere an ordinary type declaration can be used; to describe the type of a value, as we’ve done here, an argument to a function, or a return type.

Functions vs. Methods

In Scala, a def can be used as a function or a method. Scala developers often talk about functions and shy away from talking about methods, so what’s the difference?

A method def will be defined within a Scala class, it will usually refer to instance data within the class. Its nomenclature is firmly in the object-oriented world; methods define behaviors for instance objects.

Function defs are defined in Scala singleton objects (but, if defined in a class, can be converted into functions under certain conditions). Functions are firmly from the mathematical world, they take inputs and produce outputs. In the functional programming world, they don’t define behaviors for instance objects but instead implement independent, repeatable transformations or apply calculations.

The difference between a function and a method then is partly about describing the context of their use; you talk about methods when you’re building object-oriented systems and functions when talking about transformations or functional programming. Methods will also be associated with instance objects and functions will not.

There are several ways to create functions in Scala.

1. A def in a singleton object is inherently a function.

2. Create a lambda.

3. Create a def in a class which Scala will convert to a function when passed to a higher-order function.

There are only two ways to create functions in Java.

1. Create static class method.

2. Create a lambda.

There is special type of lambda called a closure. In both Java and Scala, these are created differently under the hood. They are closer to anonymous classes than functions as a new instance is created when they are defined. You can therefore argue that they are not “functions” in the sense I’m describing here.

Lambdas vs. Closures

A closure is a special type of lambda . It’s an anonymous function but it also captures something from its environment when created.

Every closure is a lambda but not all lambdas are closures! To make it more confusing, an anonymous class can also be called a closure when in captures some data.

Let’s take a look at an example. Given the following interface Condition:

  // java
  interface Condition {
      Boolean isSatisfied();
  }

…an anonymous class might implement Condition to check if some server has shutdown (it calls waitFor to poll continuously until the isRunning method returns false).

  // java
  void anonymousClass() {
      final Server server = new HttpServer();
      waitFor(new Condition() {
          @Override
          public Boolean isSatisfied() {
              return !server.isRunning();
          }
      });
  }

The functionally equivalent closure would look like this:

  // java
  void closure() {
      Server server = new HttpServer();
      waitFor(() -> !server.isRunning());
  }

In the interest of completeness, the waitFor method might naively be implemented like this:

  // java
  class WaitFor {
      static void waitFor(Condition condition) throws InterruptedException {
          while (!condition.isSatisfied())
              Thread.sleep(250);
      }
  }

Both implementations are closures; the former is an anonymous class and a closure, the latter is a lambda and a closure. As we’ve said, a closure captures its "environment" at runtime. In the anonymous class version, this means copying the value of server into an anonymous instance of Condition. In the lambda, the server variable would also need to be copied into the function at runtime.

As it’s a copy, it has to be declared final to ensure that it can not be changed between when it’s captured and when it’s used. The value at these two points in time could be very different as closures are often used to defer execution until some later point.

Java uses a neat trick whereby, if it can reason that a variable is never updated, it might as well be final, so it treats it as effectively final and you don’t need to declare it using the final keyword explicitly.

A lambda, on the other hand, doesn’t need to copy its environment or capture any terms. This means it can be treated as a genuine function and not an instance of a class.

The same example expressed as a lambda and not a closure would look like this:

  // java
  void lambda() {
      Server httpServer = new HttpServer();
      waitFor(server -> !server.isRunning(), httpServer);
  }

  void waitFor(ServerCondition condition, Server server) {
      while (!condition.isSatisfied(server))
          Thread.sleep(250);
  }

  interface ServerCondition {
      Boolean isSatisfied(Server server);
  }

The trick here is that the lambda takes the httpServer instance as an argument and so doesn’t need to capture it on construction. It doesn’t reference anything outside of its scope so nothing is copied in. The same lambda instance can be reused with different instances of a server.

It’s an important distinction to make as a lambda doesn’t need to be instantiated many times. A closure has to be instantiated and memory allocated for each value it closes over. Memory need only be allocated once for non-closure lambdas and then the lambda can be reused. This makes it more efficient, at least in theory.

(x) -> x * 2;     // lambda
() -> x * 2;      // closure