Laziness & Streams — Interview Q&A¶

Roadmap: Functional Programming → Laziness & Streams

Laziness is computing on demand: an expression is described now and evaluated only when its result is actually needed — sometimes never. Streams are the lazy sequence: a recipe for elements that materializes one at a time, so you can pipeline transformations, model infinite data, and decouple producing from consuming. The power is real but the costs are sneaky: thunks accumulate, effects fire at surprising times, and a generator you consume twice silently yields nothing the second time.

A bank of 50+ interview questions and answers spanning eager-vs-lazy intuition, lazy pipelines, streaming API design, space leaks, and the runtime machinery (thunks, WHNF, fusion). Each answer models the reasoning a strong candidate gives — including the trade-offs. Use the <details> toggles to self-quiz: read the question, answer out loud, then expand.

Table of Contents¶

1. Fundamentals / Junior
2. Intermediate / Middle
3. Senior — Streaming API Design, Backpressure, Effects
4. Professional / Deep — Thunks, WHNF, Fusion, Runtime Cost
5. Code-Reading — Lazy or Eager? When Does It Run?
6. Curveballs
7. Rapid-Fire / One-Liners
8. How to Talk About Laziness in Interviews
9. Summary
10. Related Topics

Fundamentals / Junior¶

Eager vs lazy, generators/iterators, infinite sequences.

Q1. What is the difference between eager and lazy evaluation?

Q2. What is a stream in the functional sense?

Q3. What is a generator, and how does it relate to laziness?

Q4. How can a lazy sequence be infinite without running out of memory?

def naturals():
    n = 0
    while True:
        yield n      # suspends here; only `n` is live
        n += 1

from itertools import islice
print(list(islice(naturals(), 5)))  # [0, 1, 2, 3, 4] — forces only 5

Q5. What's the difference between an iterable and an iterator in Python?

Q6. Can you iterate a Python generator twice?

g = (x * 2 for x in range(3))
print(list(g))   # [0, 2, 4]
print(list(g))   # [] — already exhausted, silently empty

Q7. Give a concrete benefit of laziness in everyday code.

Q8. What does range(1_000_000) cost in Python 3 versus building a list of a million numbers?

Q9. What is "demand" or "forcing" a value?

Q10. Why are comprehensions in Python sometimes lazy and sometimes eager?

Q11. Is a Python for loop over a generator lazy?

Intermediate / Middle¶

Lazy pipelines, short-circuiting, memoized lazy values, processing unbounded data.

Q12. How does a lazy pipeline avoid building intermediate collections?

Q13. What is short-circuiting in a lazy pipeline, and why does it matter?

Q14. How do you sum an infinite stream's first N elements?

# Python
from itertools import islice
def naturals():
    n = 0
    while True: yield n; n += 1
total = sum(islice(naturals(), 100))   # 4950 — forces exactly 100

// Java
int total = Stream.iterate(0, n -> n + 1)   // infinite
                  .limit(100)                 // bound it
                  .mapToInt(Integer::intValue)
                  .sum();

Q15. What is a memoized lazy value (a "lazy val"), and why use one?

Q16. Distinguish "lazy" from "memoized." Are they the same?

Q17. How do you process an unbounded data source — e.g. a network feed or a file you can't fit in memory?

Q18. In a lazy pipeline, when do map's side effects run?

Q19. What's the bug here, and how do you fix it?

def get_records():
    rows = (parse(line) for line in open("data.csv"))
    return rows

records = get_records()
print(sum(1 for _ in records))   # count
print(max(r.value for r in records))   # max — BUG

count, mx = 0, float("-inf")
for r in get_records():
    count += 1; mx = max(mx, r.value)

Q20. How does itertools.tee let you iterate a generator twice, and what's the catch?

Q21. Why prefer a generator expression over a list comprehension when feeding any() or sum()?

Q22. What's the difference between Stream.iterate and Stream.generate in Java?

Q23. You need only the first matching element from an expensive computation over a large list. Eager filter().get(0) vs lazy — what's the difference in work done?

Senior — Streaming API Design, Backpressure, Effects¶

Designing streaming APIs, backpressure, space leaks, late effects/exceptions.

Q24. What principles guide designing a good streaming API?

Q25. What is backpressure, and why do lazy/pull-based streams handle it naturally?

Q26. What is a space leak in the context of laziness, and how does it differ from a normal memory leak?

Q27. Why does a lazy foldl leak space, and how does foldl' fix it? (Haskell aside)

Q28. With laziness, when do exceptions and effects actually fire — and why is that dangerous?

Q29. Show how lazy file reading can leak a file handle, and how to avoid it.

def lines(path):
    with open(path) as f:
        for line in f:
            yield line        # control returns to caller WHILE file is open

g = lines("big.txt")
first = next(g)               # opens file, reads one line
# ... if we never exhaust g, the `with` never finishes → handle stays open

Q30. When should an API return an eager collection versus a lazy stream?

Q31. How do you reconcile laziness with deterministic resource cleanup (RAII / try-with-resources)?

Q32. Why can putting side effects inside map / intermediate operations be a design smell in a streaming API?

Q33. How would you design a lazy stream that's safe to consume multiple times?

Q34. A teammate wants to log progress by adding a println inside a .map() of a Java Stream. What do you tell them?

Professional / Deep — Thunks, WHNF, Fusion, Runtime Cost¶

Thunks, graph reduction, foldl space leak & foldl', generator runtime cost, fusion.

Q35. What is a thunk?

Q36. What is WHNF (Weak Head Normal Form), and why does it matter for forcing? (Haskell aside)

Q37. What is graph reduction, the evaluation model behind lazy languages?

Q38. What is the runtime cost of generators / lazy iteration versus a plain loop?

Q39. What is stream/loop fusion, and why does it matter?

Q40. How does Java's Stream pipeline actually execute — what happens at collect/terminal time?

Q41. Is Go lazy? How do you express lazy sequences in Go?

Q42. Why might forcing to WHNF not fix a space leak, and what does that teach about "adding strictness"?

Q43. What's the memory difference between Stream.iterate(...).limit(n) and an equivalent eager loop?

Code-Reading — Lazy or Eager? When Does It Run?¶

You're shown a snippet; say whether it's lazy or eager, when it actually runs, or spot the bug.

Q44. Lazy or eager? When does expensive() run?

xs = [expensive(i) for i in range(3)]   # A
ys = (expensive(i) for i in range(3))   # B

Q45. When does anything happen here? (Java)

Stream<String> s = Files.lines(Path.of("big.txt"))
    .map(String::trim)
    .filter(line -> !line.isEmpty());
System.out.println("built the stream");

Q46. Spot the bug. (Python)

def evens(nums):
    return (n for n in nums if n % 2 == 0)

data = [1, 2, 3, 4]
e = evens(data)
if any(x > 2 for x in e):
    result = list(e)        # expecting [4]

Q47. Lazy or eager — and is there a bug? (Go, channels)

func gen() <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; ; i++ { ch <- i }   // infinite
    }()
    return ch
}

func main() {
    ch := gen()
    fmt.Println(<-ch, <-ch)   // 0 1
}                              // returns

Q48. Does this log 5 times or 1000 times? (Java)

IntStream.rangeClosed(1, 1000)
    .peek(n -> System.out.println("seen " + n))
    .filter(n -> n % 2 == 0)
    .limit(5)
    .forEach(n -> {});

Q49. Eager or lazy? What's printed and why? (Python)

def f(x):
    print("f", x)
    return x * 10

m = map(f, [1, 2, 3])     # Python 3: map() is lazy
print("before")
print(next(m))

before
f 1
10

Q50. What does this print, and what's the subtle laziness trap? (Python closures + generator)

funcs = (lambda: i for i in range(3))
print([fn() for fn in funcs])

Curveballs¶

The questions designed to catch glib answers.

Q51. Is a Java Stream lazy?

Q52. Why does lazy foldl leak space?

Q53. What's a thunk, in one breath, with an everyday non-Haskell example?

Q54. Can you iterate a Python generator twice?

Q55. How do you sum an infinite stream's first N elements?

Q56. "Laziness is always more efficient because it does less work." True?

Q57. If a lazy value is never forced, does its side effect happen?

Q58. Does map in Python run eagerly or lazily — and was that always true?

Rapid-Fire / One-Liners¶

Crisp answers; what an interviewer wants in one or two sentences.

Q59. Eager vs lazy in one line each?

Q60. What forces a lazy value?

Q61. Generator: container or iterator?

Q62. [x for x in xs] vs (x for x in xs)?

Q63. One-line cure for a lazy foldl space leak?

Q64. Where do intermediate-op side effects fire in a Java Stream?

Q65. What makes pull-based streams handle backpressure for free?

Q66. WHNF in one sentence?

Q67. When does laziness lose to an eager loop?

Q68. The classic stream/loop fusion rewrite?

Q69. One-liner: how to make a stream re-iterable?

How to Talk About Laziness in Interviews¶

A few habits separate a strong answer from a textbook recital:

• Always answer "lazy or eager?" with "lazy until what forces it." The interesting part is never the label — it's when (and whether) evaluation happens. Name the forcing event: the terminal op, the next(), the pattern match.
• Name the trade-off, not just the win. Laziness buys skipped work, intermediate-free pipelines, and infinite sequences — and costs per-element overhead, less predictable effect timing, escaping exceptions, and space leaks. "It depends on whether you skip enough work to pay for the overhead" is a senior answer.
• Separate describing from running. The composable, testable design keeps intermediate operations pure and concentrates effects in the terminal stage. Mentioning this unprompted signals you've designed streaming APIs, not just used them.
• Know the single-use gotcha cold. Generators/streams are exhausted after one pass; the bug is silent. Being able to spot the consumed-twice pattern and reach for materialize / tee / re-create instantly is a reliable separator.
• Tie infinite sources to short-circuiting. "Laziness makes the infinite source constructible; a take/limit makes a reduction over it terminate" shows you understand why it works, not just the incantation.
• Go to the machinery when asked to go deep. Thunks, WHNF, graph reduction with sharing, the foldl/foldl' space leak, and fusion are the depth markers. Use them to explain why space leaks happen and why fusion lets functional pipelines hit loop-like speed.
• Reason about resources. Lazy + RAII is a real tension: a stream backed by a file handle must have an owner who closes it regardless of how consumption ends. Mentioning try-with-resources / GeneratorExit / bracket shows production experience.

Summary¶

• Laziness is on-demand computation: describe now, evaluate only when the result is forced — sometimes never. Most mainstream languages are eager by default; laziness shows up as generators, streams, and lazy iterators.
• The junior bar is eager vs lazy, generators/iterators (single-use!), and infinite sequences in O(1) space. The middle bar is lazy pipelines, short-circuiting, memoized lazy values, and bounding infinite sources before reducing. The senior bar is streaming API design, backpressure, space leaks, and late effects/exceptions. The professional bar is the machinery — thunks, WHNF, graph reduction, the foldl/foldl' leak, generator runtime cost, and fusion.
• The recurring traps: a consumed-twice generator (silent empty result), effects inside intermediate ops (consumer-dependent timing), a reduction over an unbounded source (never terminates), a space leak from unforced thunks or a retained head, and a leaked resource/goroutine from a lazy producer outliving its consumer.
• The strongest answers lead with when evaluation actually happens, name the trade-off (skipped work vs overhead and unpredictability), separate describing from running, and reach for the runtime machinery (thunks/WHNF/fusion) to explain why — not just that — laziness behaves as it does.

Related Topics¶

• junior.md — eager vs lazy, generators, and infinite sequences from scratch.
• middle.md — lazy pipelines, short-circuiting, and processing unbounded data.
• senior.md — streaming API design, backpressure, space leaks, and late effects.
• professional.md — thunks, WHNF, graph reduction, the foldl' fix, and fusion.
• Map / Filter / Reduce — the core transformations that lazy pipelines fuse.
• Recursion & Tail Calls — accumulator strictness and the cousin of the foldl space leak.
• Effect Tracking — pure core / imperative shell, the discipline that keeps effects out of lazy intermediate ops.
• Pure Functions & Referential Transparency — why pure transformations are safe to defer, reorder, and re-run.