Function literals vs function values

Question

Trying to figure out the significance of this section from Programming in Scala, 2nd edition.

A function literal is compiled into a class that when instantiated at run- time is a function value. Thus the distinction between function literals and values is that function literals exist in the source code, whereas function val- ues exist as objects at runtime. The distinction is much like that between classes (source code) and objects (runtime).

I don't really get what they're trying to say here. That function values don't exist in the source code and function literals don't exist at runtime?

// literal
val addOne = (x: Int) => x + 1

// value
def add1(x: Int): Int = x + 1

I can pass either to another function:

def doThing(thing: Int => Int) = thing(5)

doThing(addOne) // 6
doThing(add1)   // 6

It also appears that function literals are placed into a class that inherits from FunctionN (where N is the arity of the function). What distinction are they trying to make here?

Answer 1

I don't really get what they're trying to say here.

Your example of a function literal and value aren't accurate. The book is not comparing methods to functions, it's creating a distinction between two different "modes" of a function. The hint is in the first sentence:

A function literal is compiled into a class that when instantiated at run-time is a function value.

When at compile time you type:

val addOne = (x: Int) => x + 1

This is what the book refers to as a "function literal" (or Anonymous Function). The same way you have a string literal by typing:

val s = "Hello, World"

addOne to the compiler is a Function1[Int, Int], meaning takes an Int and returns an Int result. The function literal syntax ((x: Int) => x + 1) is syntactic sugar over FunctionN, where N is determined by the arity of the function.

At run-time, the compiler takes this "function literal" and "puts life into it" by instantiating an object of type Function1[Int, Int], thus creating a function value which you can invoke, pass around, etc.

What distinction are they trying to make here?

The book is basically trying to create a distinction between the compile time and runtime representation of a function, so when they say "function literal" you'll understand they're talking about the former, and when they say "function value" the latter.