## 1. Overview

In this tutorial, we’ll learn about the features and evaluation strategies of call by-value and call by-name in Scala and how we can use them in practice.

## 2. Call By-Value

Function arguments are considered call by-value by default in Scala. Let’s define a function, test, which takes an argument as call by-value:

``````def test(a: Int) = a * a
``````

In general, applications of parameterized functions are evaluated similarly as operators. First, it evaluates all the function arguments, from left to right. Then it replaces the function application by the function’s right-hand side, and, at the same time, it replaces the formal parameters of the function by the actual arguments. The call by-value strategy has the advantage that it evaluates every function argument only once.

## 3. Call By-Name

To make an argument called by-name, we simply prepend => (rocket symbol) to its type.

Let’s define a function, test, which takes an argument as call by-name:

``````def test(a: => Int) = a * a
``````

Call by-name evaluation is similar to call by-value, but it has the advantage that a function argument won’t be evaluated until the corresponding value is used inside the function body.

Both strategies are reduced to the final value as long as:

• The reduced expression consists of pure functions
• Both evaluations terminate

## 4. Examples

Let’s define a function, addFirst, which takes an argument x of type Int as a call by-value and an argument y of type Int as a call by-name:

``def addFirst(x: Int, y: => Int) = x + x``

Now, let’s understand the evaluation of the function addFirst as a call by-value:

``assert(addFirst(3+5, 7) == 16)``

In this case, the call by-value strategy will first evaluate the expression 3+5 and then pass the value 8 to the function’s body where x parameter is added to itself to evaluate the final value of 16.

Now, let’s look at the same example as a call by-name.

``assert(addFirst(7, 3+5) == 14)``

In case, the call by-name strategy will ignore expression 3+5 because parameter y is not used inside the function’s body. Therefore, the parameter x will be added to itself producing the final value of 14.

In this example, the call by-name strategy is one step faster than the call by-value strategy.

Now, let’s take one more example. Let’s define an infinitely recursive function infinite():

``def infinite(): Int = 1 + infinite()``

If we apply this function as the x parameter in addFirst, the call by-value argument will produce a StackOverflowError:

``````assertThrows[StackOverflowError] {
}
``````

In the above example, simply calling the function produced a StackOverflowError because infinite() is evaluated before the function body is evaluated.

Now, if we use infinite() as the call by-name argument:

``assert(addFirst(4, infinite()) == 8)``

The infinite() function is never evaluated in the function body. Therefore, the function call runs successfully.

## 5. Call By-Value or Call By-Name

Using call by-name may seem like a more efficient solution since it’s possible that the argument is not evaluated.

However, call by-value is often more efficient than call by-name because it avoids the repeated re-computation of argument expressions that call by-name entails. Additionally, it can avoid other side effects because we know when the expressions will be evaluated.

## 6. Conclusion

In this tutorial, we introduced call by-value and call by-name in Scala. We’ve seen some of their features, usage, and evaluation strategies. As usual, the full source code can be found over on GitHub.