👀 Views: 89 💬 Answers: 1 📅 Created: 2025-06-16

scala lazy-evaluation case-classes performance Scala

This might be a silly question, but I'm refactoring my project and I'm working on a personal project and I'm encountering an unexpected behavior when using lazy evaluation in my custom data structure in Scala 2.13.6. I have a case class that defines a tree-like structure, and I'm trying to implement a method that lazily computes the sum of all values in the tree. However, when I test the lazy `sum` method, it seems to evaluate the entire structure immediately instead of on-demand. Here’s a snippet of what I have: ```scala case class TreeNode(value: Int, left: Option[TreeNode] = None, right: Option[TreeNode] = None) { lazy val sum: Int = value + left.map(_.sum).getOrElse(0) + right.map(_.sum).getOrElse(0) } val tree = TreeNode(1, Some(TreeNode(2)), Some(TreeNode(3))) println(tree.sum) // Expected: 6 ``` When I run this code, it seems like it's correctly returning the sum, but I noticed that if I add a print statement inside the `sum` method, like this: ```scala lazy val sum: Int = { println(s"Calculating sum for node with value $value") value + left.map(_.sum).getOrElse(0) + right.map(_.sum).getOrElse(0) } ``` Then the print statement gets executed even before I call `println(tree.sum)`. This leads me to believe that `sum` is being evaluated immediately when the `TreeNode` is instantiated, rather than being lazily evaluated only when I access it. I also tried wrapping the `sum` in a `def` instead of `lazy val`, and while that worked as expected (no evaluation until called), I intended to use lazy evaluation to prevent unnecessary computation when the sum might not be needed. Is there a way to ensure that `sum` behaves lazily without evaluating until explicitly called? Am I misinterpreting how `lazy val` works in this context? Am I missing something obvious? The stack includes Scala and several other technologies. I've been using Scala for about a year now.