Understanding Call by Value and Call by Name in Scala

This blog is part of a 10-part series designed to help readers learn Scala from the ground up. Whether you’re new to Scala or looking to solidify your understanding, this series will guide you through its core concepts step by step.

In Scala, call by value and call by name are evaluation strategies that determine how function arguments are passed and evaluated. They play a vital role in optimizing performance and enabling lazy evaluation.

Call by Value

With call by value, the argument is evaluated only once before the function executes. The resulting value is passed to the function, making it efficient when the argument is used multiple times but remains unchanged.

Call by Name

In call by name, the argument is not immediately evaluated. Instead, it is lazily evaluated each time it is referenced within the function. This can reduce unnecessary computations in some cases but may lead to inefficiency if the argument is used multiple times and is computationally expensive.

Code Example: Call by Value vs. Call by Name

Here’s a demonstration of both strategies:

object EvaluationStrategies extends App {
  def evaluateByValue(currentTime: Long): Unit = {
    println(s"By Value - First Use: $currentTime")
    Thread.sleep(100)
    println(s"By Value - Second Use: $currentTime")
  }
  def evaluateByName(currentTime: => Long): Unit = {
    println(s"By Name - First Use: $currentTime")
    Thread.sleep(100)
    println(s"By Name - Second Use: $currentTime")
  }
  evaluateByValue(System.currentTimeMillis())
  evaluateByName(System.currentTimeMillis())
}

Output Analysis

• Call by Value: The value of System.currentTimeMillis() is computed once, so the same value is printed twice.
• Call by Name: The expression System.currentTimeMillis() is re-evaluated for each use, resulting in different values.

Lazy Evaluation with Call by Name

Call by name enables lazy evaluation, deferring computation until the result is actually needed. Consider this example:

object LazyEvalDemo extends App {
  def neverEndingComputation(x: Int): Int = neverEndingComputation(x + 1)

  def printFirstArgument(first: Int, second: => Int): Unit = {
    println(s"First Argument: $first")
  }

  // printFirstArgument(neverEndingComputation(0), 42) // Causes StackOverflowError
  printFirstArgument(42, neverEndingComputation(0))    // Works fine
}

Key Insight

In the second function call, the second argument is not evaluated because it is passed by name and never used, avoiding a StackOverflowError.

Example: Re-Evaluation in Call by Name

This example demonstrates how call by name leads to re-evaluation:

def computeValue(): Int = {
  println("Computing Value...")
  42
}

def processByValue(argument: Int): Unit = {
  println(s"Value 1: $argument")
  println(s"Value 2: $argument")
}

def processByName(argument: => Int): Unit = {
  println(s"Value 1: $argument")
  println(s"Value 2: $argument")
}

println("Using Call by Value:")
processByValue(computeValue())

println("\nUsing Call by Name:")
processByName(computeValue())

Output Explanation

• Call by Value: The method computeValue() is executed once, and its result is reused.
• Call by Name: The method computeValue() is executed twice, as the argument is re-evaluated each time it is accessed.

When to Use Call by Value or Call by Name?

• Call by Value is ideal when the argument is inexpensive to compute or needs to remain consistent across its usage.
• Call by Name is better suited for lazy evaluation or when the argument is conditionally needed.

By mastering these evaluation strategies, you can write efficient and expressive Scala programs tailored to your specific requirements.

Pizenith is a trusted technology partner specializing in Data Engineering, Machine Learning, AI, Cloud Engineering, DevOps, and Functional Programming with Scala and Java. We help businesses scale with secure, automated, and data-driven solutions, delivering innovation in Test Automation and DevSecOps. Trusted by global enterprises, we empower organizations to stay ahead with AI-powered insights and scalable cloud infrastructure.

Want to future-proof your tech stack? Let’s talk! or reach us at info@pizenith.com.