Call by Value and Call by Name

Table of contents

Reading Time: 2 minutes

Call by value

In the Call by value method of parameter passing in Scala – a copy is to be passing by the method. This means that the parameters passed to the method have nothing to do with the actual values. These parameters are formal parameters.

The changes that we make in the formal parameters are not visible in the actual parameters (the values pass while calling the method ).

def adder(x: int)=x+x

Example:-

Output:–

Call by Name

Call-by-name evaluation is similar to call-by-value, but its advantage is that a function argument will not evaluate until we use the corresponding value inside the function body.

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

The reduced expression consists of pure functions
Both evaluations terminate

def adder(x: => int)=x+x

Example:-

Output:-

We have defined two functions showtime_Callbyvalue and showtime_Callbyname.

These functions take the System time in Long type and print it two times.

So now we call both functions bypassing the argument System.nanotime that gives current system time in nano-seconds.

showtime_Callbyvalue(System.nanotime())

showtime_Callbyname(System.nanotime())

Call By-Value or Call By-Name

It is 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.

Why not swapping function:-

The most common example demonstrating the use of call by value and call by name is the swapping function.

In Scala, the parameters of the functions are val.

Immutable which means you can’t reinitialize them in the function. This leaves us in a scenario where the easiest way to learn the difference is not applicable.

So, the classical program is created to just give you differences. Now, consider this code, which tries to reinitialize the parameters of Scala.

Example:-

object MyClass {
    def add(a: => Int){
         a = x + 1
        println("sum = "+a)
    };
    def main(args: Array[String]) {
        var a = 34
        add(a)
    }
}

output:-

error: reassignment to val
         a = x + 1
one error found

Conclusion:-

Its function arguments are evaluated once before entering the function, but the call-by-name function arguments are evaluated inside the function only when they are needed.