Higher-Order Functions

This chapter is from the book

Functional and Concurrent Programming: Core Concepts and Features

Learn More Buy

This chapter is from the book

This chapter is from the book 

Functional and Concurrent Programming: Core Concepts and Features

Learn More Buy

9.5 Single-Abstract-Method Interfaces

In hybrid languages, functions are objects, and lambda expressions are used as a convenient way to create such objects. Indeed, the lambda expression syntax is so handy that many languages let you use it to create instances of types other than functions.

A single-abstract-method (SAM) interface is an interface that contains exactly one abstract method. In Scala, for instance, the type Function[A,B] (or, equivalently, A => B) is a SAM interface with a single abstract method apply. We have used lambda expressions in code illustrations to create instances of Function[A,B], but it turns out that all SAM types can be instantiated using lambda expressions, even types that are not related to Function:

Scala

abstract class Formatter:
   def format(str: String): String
   def println(any: Any): Unit = Predef.println(format(any.toString))

Class Formatter defines only one abstract method format and is therefore a SAM interface. It can be implemented using lambda expressions:

Scala

val f: Formatter = str => str.toUpperCase
f.println(someValue)

Note how method println is called on object f, which was defined as a lambda expression. This is possible only because f was declared with type Formatter; the expression (str => str.toUpperCase).println("foo") would make no sense.

Many Java interfaces can be implemented as lambdas, even though they predate Java’s syntax for lambda expressions and have little to do with functional programming:

Scala

val absComp: Comparator[Int] = (x, y) => x.abs.compareTo(y.abs)

val stream: IntStream = ...
val loggingStream: IntStream = stream.onClose(() => logger.info("closing stream"))

Comparator is a Java 2 SAM interface with an abstract method compare. Stream method onClose uses a single argument of type Runnable, a Java 1 SAM interface with an abstract method run. Both Comparator and Runnable can be implemented as lambda expressions.