Strict vs Lazy evaluation

November 28, 2023

In the world of functional programming, where the elegance of code and the purity of functions reign supreme, the choice of evaluation strategy becomes a pivotal decision for programmers. At the heart of this decision lies a fundamental dichotomy: strict vs. lazy evaluation.


Understanding evaluation strategies in Functional Programming

Functional programming, with its focus on immutability and mathematical functions, introduces a unique challenge — how to evaluate expressions and handle computation. This leads us to the realm of evaluation strategies, where decisions about when and how computations take place shape the behavior and efficiency of our programs.


The duality: Strict vs. Lazy evaluation

Enter the dichotomy of strict and lazy evaluation. On one side, we have strict evaluation, a strategy that eagerly computes values as soon as expressions are encountered. On the other side, there’s lazy evaluation, a more patient approach that defers computation until the result is absolutely necessary.


Why It matters: Designing functional programs with purpose

The choice between strict and lazy evaluation is not a mere technicality; it’s a design decision that ripples through the architecture of functional programs. The evaluation strategy chosen can influence the performance, readability, and even the expressiveness of your code.

In this exploration of strict and lazy evaluation, we’ll delve into the core principles, benefits, and trade-offs of each strategy. From understanding the fundamentals to dissecting practical examples, we aim to equip you with the knowledge needed to make informed decisions when designing functional programs.


Fundamentals of evaluation in Functional Programming

In the landscape of functional programming, the term “evaluation” refers to the process of determining the value of an expression or a function. Unlike some other programming paradigms, functional programming emphasizes mathematical functions and immutability, shaping the way we approach computation.

In functional programming, expressions are treated as mathematical formulas, and the goal is to compute results based on these formulas. The process of evaluation is fundamental to understanding how a program processes data and produces outcomes.


Distinction between strict and lazy evaluation

At a high level, the distinction between strict and lazy evaluation lies in the timing of computation.


Strict evaluation

Eager computation: In a strictly evaluated system, expressions are computed eagerly, meaning that as soon as an expression is encountered, its value is calculated immediately.

Predictable order: Strict evaluation follows a predictable order of computation, ensuring that values are determined before they are needed.


Lazy evaluation

Deferred computation: Conversely, lazy evaluation takes a more laid-back approach. It defers computation until the value is actually needed in the program.

On-demand processing: This on-demand processing allows for more flexibility, as only the necessary computations are performed.


Understanding this high-level distinction lays the groundwork for comprehending how these evaluation strategies influence the behavior of functional programs. As we delve deeper into strict and lazy evaluation, we’ll uncover the implications, benefits, and trade-offs associated with each, providing a solid foundation for designing functional programs with purpose.


Strict evaluation

In the realm of functional programming, strict evaluation stands as the more eager counterpart to lazy evaluation. It operates on the principle of immediacy — evaluating expressions as soon as they are encountered in the program. This eager approach brings both clarity and potential performance implications to the table.


Immediate computation

In a strictly evaluated system, there’s no room for procrastination. Expressions are computed promptly, and values are determined without delay. This immediate computation aligns with the traditional understanding of program execution, where the order of statements in code mirrors the order of execution.


Impact on program performance

While the immediacy of strict evaluation provides a straightforward and predictable model, it can have implications for program performance, especially in scenarios where resources are constrained. Evaluating expressions eagerly may lead to unnecessary computations if certain values are never utilized in the program’s execution.


Order of evaluation

One crucial aspect of strict evaluation is the fixed order in which expressions are evaluated. This order is determined by the flow of control in the program. Understanding this deterministic pattern is essential for predicting the behavior of a strictly evaluated system.


Lazy evaluation

Lazy evaluation, the more laid-back sibling in the realm of functional programming, introduces a paradigm where computation is deferred until the precise moment the result is genuinely required. This patient approach offers unique advantages, including potential performance improvements and the ability to express infinite data structures.


Deferring computation

Unlike strict evaluation’s eager nature, lazy evaluation takes a more relaxed stance. Expressions are not immediately computed; instead, their computation is deferred until the value is explicitly needed in the program. This on-demand processing aligns with the functional programming principle of only doing what is necessary, contributing to a more flexible and resource-efficient paradigm.


Benefits of lazy evaluation

Resource efficiency: Lazy evaluation can enhance resource efficiency by avoiding unnecessary computations. In scenarios where certain values might not be needed during the program’s execution, lazy evaluation prevents unnecessary work, leading to potential performance improvements.

Infinite data structures: One distinctive feature of lazy evaluation is its compatibility with infinite data structures. Since values are only computed when needed, it becomes feasible to represent and work with structures that extend infinitely. This capability is a powerful tool in functional programming.


Use cases and considerations

The choice between strict and lazy evaluation in functional programming is not a one-size-fits-all decision; it hinges on the specific requirements and characteristics of your program. Let’s explore scenarios where each evaluation strategy shines and the considerations that should guide your decision-making process.


Strict evaluation

Predictable computation: In scenarios where the order of computation is crucial and a predictable, sequential execution is desired, strict evaluation can be the preferred choice. This is particularly relevant in scenarios where certain computations must be completed before progressing further in the program.

Resource constraint sensitivity: In resource-sensitive environments where managing memory or computational resources is paramount, strict evaluation might be preferred. It avoids the overhead of keeping unevaluated thunks, potentially leading to more efficient resource utilization.


Trade-offs and considerations

Potential overhead: While strict evaluation offers predictability, it may come at the cost of potential overhead, especially if certain computations are never utilized during program execution. This can lead to unnecessary work and impact performance.

Limited expressiveness: Strict evaluation might limit the expressiveness of your programs, especially when dealing with infinite data structures or scenarios where not all values are needed immediately.


Lazy evaluation

Efficiency in resource utilization: In scenarios where resource efficiency is critical, lazy evaluation shines. By deferring computations until their results are needed, lazy evaluation can avoid unnecessary work and contribute to more efficient resource utilization.

Infinite data structures: Lazy evaluation is particularly beneficial when working with infinite data structures. It allows the representation and manipulation of structures that would be impractical or impossible in strictly evaluated systems.


Trade-offs and considerations

Potential for thunks: Lazy evaluation introduces the concept of thunks—unevaluated expressions. While this can lead to resource efficiency, it also introduces the potential for memory overhead if thunks are not handled appropriately.

Complexity in understanding execution order: The on-demand nature of lazy evaluation can make it challenging to predict the order of execution, which might introduce complexity in understanding and debugging programs.


Balancing act: Choosing the right tool for the job

The decision between strict and lazy evaluation is ultimately a balancing act. Consider the nature of your program, the expected patterns of computation, and the resource constraints. Striking the right balance involves weighing the advantages and trade-offs of each strategy, keeping in mind that the best tool for the job depends on the specific characteristics and goals of your functional program. As we navigate this decision-making process, the next section will delve into how popular functional programming languages approach and implement these evaluation strategies.


Functional programming languages and their approach

Functional programming languages are diverse, each with its own take on evaluation strategies. Let’s delve into how some of the popular languages, such as Haskell, Scala, and Lisp, handle the dichotomy between strict and lazy evaluation.



Lazy by default

Haskell is renowned for its commitment to lazy evaluation. In Haskell, expressions are lazy by default, and computations are deferred until their results are actually needed. This design choice aligns with Haskell’s emphasis on creating expressive and efficient programs by allowing developers to work with potentially infinite data structures without fear of unnecessary computations.


Control over strictness

While Haskell is predominantly lazy, it provides mechanisms for introducing strictness where necessary. Annotations such as seq and $! allow programmers to exert control over the evaluation strategy, making it possible to enforce strictness in specific parts of the code when desired.



Mixed evaluation strategies

Scala takes a different approach by incorporating both strict and lazy evaluation. By default, Scala employs strict evaluation, where expressions are evaluated eagerly. However, Scala introduces the `lazy` keyword, allowing developers to create lazy values explicitly. This flexibility enables Scala programmers to choose the most appropriate evaluation strategy based on the specific needs of their code.


Example in Scala

val x: Int = {
   println("Computing x")

lazy val y: Int = {
   println("Computing y lazily")

val result = x + y
println(s"Result: $result")


In this example, x is computed eagerly, while y is computed lazily, demonstrating Scala’s mixed evaluation strategies.


Lisp (Common Lisp)

Traditionally strict

Common Lisp traditionally follows strict evaluation. Expressions are evaluated eagerly, adhering to a predictable order of execution. This strictness simplifies reasoning about the flow of the program and aligns with Lisp’s design philosophy of simplicity and efficiency.


Dynamic extensibility

Lisp’s dynamic nature allows for the extension and modification of the language, and developers can introduce lazy evaluation features if needed. However, Common Lisp’s standard behavior is primarily strict.


Language-specific nuances

Each language’s approach to evaluation brings its own set of nuances and features. Haskell’s commitment to laziness allows for expressive, concise code. Scala’s mix of strict and lazy evaluation provides flexibility. Lisp’s tradition of strictness contributes to simplicity and predictability.

Understanding the nuances of evaluation strategies in these languages empowers developers to make informed decisions when designing functional programs. As we conclude this exploration, the final section of our journey will present practical examples that showcase the impact of choosing between strict and lazy evaluation in real-world scenarios.


Practical examples

To truly understand the implications of choosing between strict and lazy evaluation, let’s explore practical examples that showcase how these strategies can impact the behavior and performance of real-world functional programs. These examples aim to provide insights into the decision-making process for programmers facing specific use cases.


Lazy evaluation for improved resource efficiency

Consider a scenario where you need to process a large dataset, but only a subset of the data is required for a particular computation. Lazy evaluation can be a boon in such situations. By deferring the processing of the entire dataset until the specific subset is needed, you can significantly improve resource efficiency.


Example in Haskell

-- A lazy list representing an infinite sequence of numbers
infiniteList :: [Int]
infiniteList = [1..]

-- Take the first five elements only when needed
firstFive :: [Int]
firstFive = take 5 infiniteList

main :: IO ()
main = print firstFive


In this example, the infinite list is defined lazily, and only the first five elements are computed when needed. This showcases how lazy evaluation enables the creation and manipulation of potentially infinite data structures without incurring unnecessary computation.


Strict evaluation for predictable control flow

Now, let’s consider a scenario where the order of computation is crucial for maintaining predictable control flow. Strict evaluation ensures that expressions are computed immediately, allowing for a straightforward and predictable execution sequence.


Example in Scala

// Strictly evaluated function
def calculateTotalCost(price: Double, quantity: Int): Double = {
   println(s"Calculating total cost")
   price * quantity

// Main program
val totalCost = calculateTotalCost(10.99, 5)
println(s"Total cost: $totalCost")

In this Scala example, the `calculateTotalCost` function is strictly evaluated, ensuring that the total cost is computed immediately. This predictability in control flow can be advantageous in scenarios where the order of computations matters.


Guiding programmers in decision-making

These examples highlight the practical implications of choosing between strict and lazy evaluation. As a programmer, your decision should be guided by the specific needs and characteristics of your program. Consider factors such as resource efficiency, control flow predictability, and the nature of your data structures.


By understanding the impact of these evaluation strategies through real-world examples, programmers can make informed decisions that align with the goals and requirements of their functional programs. As we conclude our exploration, remember that the art of choosing between strict and lazy evaluation is about finding the delicate balance that optimizes both performance and expressiveness for your unique use cases.




In our exploration of strict and lazy evaluation in the realm of functional programming, we’ve uncovered a spectrum of approaches that fundamentally shape how programs compute and process data. Let’s recap the key differences and highlight the importance of choosing the right evaluation strategy for your programming endeavors.


Key differences

Strict evaluation: Eager and immediate, strictly evaluated expressions are computed as soon as they are encountered, following a predictable order of execution. This approach offers clarity but may lead to unnecessary computations.

Lazy evaluation: Patient and on-demand, lazy evaluation defers computations until the results are actually needed. This flexibility enhances resource efficiency and enables the representation of potentially infinite data structures.


Additional resources

Check out the Ada Beat Functional Programming blog for more topics, including functional programming principles, summaries of MeetUps, language specific articles, and much more. Whether you’re interested in functional programming theory or practical application, we have something for everyone.