OutOfMemoryError: Java heap space during LazyList evaluation

Answer

Heap overflow during long-term iteration happens when the head of a LazyList remains reachable while the tail is being evaluated. LazyList is memoized: once a node is evaluated its tail is cached and the node keeps a strong reference to the next node. If a root reference to the head is kept, the entire evaluated prefix stays reachable and the JVM cannot reclaim it.

Confirmed facts

• In Scala 2.13 and Scala 3, scala.collection.immutable.LazyList memoizes each node after first evaluation. A node holds head and an evaluated tail reference.
• Reachability is transitive. Any live reference to the head makes all nodes reachable from that head reachable.
• OutOfMemoryError: Java heap space means the heap is exhausted by live objects, not by lazy evaluation itself.

Likely explanation for your case

Memory grows with the number of evaluated nodes that remain reachable from a retained head. Typical triggers are:

• Storing the list in a val or field and iterating over it, e.g. val xs = LazyList.from(1); xs.foreach(process). xs keeps the head alive for the whole run.
• Operations that force materialization or need the whole structure: length, reverse, toList, toVector, drop with large n, zip, groupBy.
• Capturing the head in a closure, callback or accumulator that lives beyond the current step.

Patterns that allow GC of evaluated nodes

1. Do not retain the head reference. Process with a local, reassignable reference and let the previous node go out of scope. The node chain is forward only, so dropping the previous node allows it to be collected once no other root points to it.
2. Prefer an Iterator for single-pass consumption. source.iterator avoids building a memoized chain. For a true constant-memory source use Iterator.from or a Java stream rather than an infinite memoized LazyList.
3. Avoid whole-structure operations. Use foreach, takeWhile, or manual while loops instead of length, reverse, toList.
4. Generate fresh heads. Define the source as a def, not a val, so each traversal starts from a new root: def infinite = LazyList.iterate(0)(_ + 1).

Example of safe traversal without retaining the head:

def processAll(): Unit = {
  var cur = LazyList.from(1) // local, not captured outside
  while (!cur.isEmpty) {
    val h = cur.head
    // process h
    cur = cur.tail
    // previous node is no longer referenced by cur
  }
}

Even with this pattern, the current node still references all future nodes via the memoized chain, so memory is proportional to the remaining suffix. For true O(1) memory you need a non-memoizing source such as an Iterator.

One missing diagnostic detail that changes the recommendation: are you keeping the LazyList in a val / field or passing it into a closure that outlives the iteration, and are you using any of the materializing operations listed above? Confirming that will determine whether breaking the head reference is sufficient or whether you need to replace the source with an Iterator.