Question

I’m trying to understand when clojure’s lazy sequences are lazy, and when the work happens, and how I can influence those things.

user=> (def lz-seq (map #(do (println "fn call!") (identity %)) (range 4)))
#'user/lz-seq
user=> (let [[a b] lz-seq])
fn call!
fn call!
fn call!
fn call!
nil

I was hoping to see only two “fn call!”s here. Is there a way to manage that?
Anyway, moving on to something which indisputably only requires one evaluation:

user=> (def lz-seq (map #(do (println "fn call!") (identity %)) (range 4)))
#'user/lz-seq
user=> (first lz-seq)
fn call!
fn call!
fn call!
fn call!
0

Is first not suitable for lazy sequences?

user=> (def lz-seq (map #(do (println "fn call!") (identity %)) (range 4)))
#'user/lz-seq
user=> (take 1 lz-seq)
(fn call!
fn call!
fn call!
fn call!
0)

At this point, I’m completely at a loss as to how to access the beginning of my toy lz-seq without having to realize the entire thing. What’s going on?

Answer 1

Clojure’s sequences are lazy, but for efficiency are also chunked, realizing blocks of 32 results at a time.

=>(def lz-seq (map #(do (println (str "fn call " %)) (identity %)) (range 100)))
=>(first lz-seq)

fn call 0
fn call 1
...
fn call 31
0

The same thing happens once you cross the 32 boundary first

=>(nth lz-seq 33)
fn call 0
fn call 1
...
fn call 63
33

For code where considerable work needs to be done per realisation, Fogus gives a way to work around chunking, and gives a hint an official way to control chunking might be underway.