Every computation in
Scala is treated like a mathematical function, and the evaluation of these functions is made following the
Substitution Model which has many strategies, two of them are:
This is the strategy by default, the arguments of the function are evaluated before the function itself, like this example:
def test(x:Int, y:Int) = x+x
test(7,2*4) test(7,8) 7+7 14
In this case, the arguments aren’t evaluated before the function is called, they are evaluated whenever they appear in the function, like this:
def test(x:=>Int, y:=>Int) = x+x
test(7,2*4) 7+7 14
And…what is this for?
Saving time. In the previous examples, the
call-by-name strategy is faster because it has fewer evaluations than the
This strategies also apply to values?
Yes, they do.
def form uses
call-by-name strategy and the right part of the assignation is evaluated with each use of the value.
val form uses
call-by-value strategy and the right part of the assignation is evaluated in the definition itself.
For example, if we define this function:
def loop: Boolean = loop
And then we make this assignation:
def x = loop
We cause an infinity loop only if x is used in the rest of the code.
On the other hand, if we make this assignation:
val x = loop
This definition already causes an infinity loop.