Work in Progress

Scala 3 has not been released, yet. We are still in the process of writing the documentation for Scala 3. You can help us to improve the documentation.

Are you searching for the Scala 2 documentation?

Scala 3 — Book

Function Variables

Language

Going back to this example from the previous section:

val doubledInts = ints.map((i: Int) => i * 2)

We noted that this part of the expression is an anonymous function:

(i: Int) => i * 2

The reason it’s called anonymous is because it’s not assigned to a variable, and therefore doesn’t have a name.

However, an anonymous function—also known as a function literal—can be assigned to a variable to create a function variable:

val double = (i: Int) => i * 2

This creates a function variable named double. In this expression, the original function literal is on the right side of the = symbol:

val double = (i: Int) => i * 2
             -----------------

the new variable name is on the left side:

val double = (i: Int) => i * 2
    ------

and the function’s parameter list is underlined here:

val double = (i: Int) => i * 2
             --------

Like the parameter list for a method, this means that the double function takes one parameter, an Int named i. You can see in the REPL that double has the type Int => Int, meaning that it takes a single Int parameter and returns an Int:

scala> val double = (i: Int) => i * 2
val double: Int => Int = ...

Invoking the function

Now you can call the double function like this:

val x = double(2)   // 4

You can also pass double into a map call:

List(1, 2, 3).map(double)   // List(2, 4, 6)

Furthermore, when you have other functions of the Int => Int type:

val triple = (i: Int) => i * 3

you can store them in a List or Map:

val functionList = List(double, triple)

val functionMap = Map(
  "2x" -> double,
  "3x" -> triple
)

If you paste those expressions into the REPL, you’ll see that they have these types:

// a List that contains functions of the type `Int => Int`
functionList: List[Int => Int]

// a Map whose keys have the type `String`, and whose
// values have the type `Int => Int`
functionMap: Map[String, Int => Int]

Key points

The important parts here are:

  • To create a function variable, just assign a variable name to a function literal
  • Once you have a function, you can treat it like any other variable, i.e., like a String or Int variable

And thanks to the improved Eta Expansion functionality in Scala 3, you can treat methods in the same way.

Contributors to this page: