simon/jolt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Match Clojure's lazy seq realization model

Browse source 
jolt's seq layer realized one element ahead of Clojure, so a side-effecting
lazy seq ran its producer too eagerly. Four changes bring it in line:

- rest is Clojure's more(): it returns the tail without realizing it. An
  unforced tail (vector / string / lazy-seq cell) comes back as a deferred
  seq, so (rest (iterate f x)) does not call f. next still realizes one.
- iterate applies f lazily, inside the tail thunk, so (first (iterate f x))
  is x with no call to f (clojure.lang.Iterate parity).
- take realizes exactly n: the last element terminates without touching the
  rest, instead of forcing one more element of the source.
- an empty realized lazy seq is still a sequence value, printing "()" not
  "nil" (a JVM LazySeq is never nil).

Also: the map transducer's step fn now takes multiple inputs
([result input & inputs]) so a multi-collection transduce applies f across
all of them. Fixes medley's join/window/sequence-padded laziness and
multi-input transducer tests (now 293/293). The rest change also fixed a
latent overrun in distinct/dedupe over a map's empty tail.

iterate is a seed source, re-minted.
This commit is contained in:
Yogthos 2026-06-26 19:41:02 -04:00
parent 331a41ee26
commit 448611a5df
6 changed files with 57 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

2
host/chez/seed/prelude.ss
View file

@ -933,7 +933,7 @@
(guard (e (#t #f))
(def-var! "clojure.core" "repeat" (letrec ((repeat (case-lambda ((x) (let fnrec2319 ((x x)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2320 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (repeat x)))))))) ((n x) (let fnrec2321 ((n n) (x x)) (jolt-take n (repeat x))))))) repeat)))
(guard (e (#t #f))
(def-var! "clojure.core" "iterate" (letrec ((iterate (lambda (f x) (let fnrec2322 ((f f) (x x)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2323 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (iterate f (jolt-invoke f x))))))))))) iterate)))
(def-var! "clojure.core" "iterate" (letrec ((iterate (lambda (f x) (let fnrec2322 ((f f) (x x)) (jolt-cons x (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2323 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (iterate f (jolt-invoke f x))))))))))) iterate)))
(guard (e (#t #f))
(def-var! "clojure.core" "partition-all" (letrec ((partition-all (case-lambda ((n) (let fnrec2324 ((n n)) (lambda (rf) (let fnrec2325 ((rf rf)) (let* ((a (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector)))) (case-lambda (() (let fnrec2326 () (jolt-invoke rf))) ((result) (let fnrec2327 ((result result)) (let* ((result (if (jolt-zero? (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") a))) result (let* ((v (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") a (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result v))))))) (jolt-invoke rf result)))) ((result input) (let fnrec2328 ((result result) (input input)) (begin (jolt-invoke (var-deref "clojure.core" "vswap!") a jolt-conj input) (if (jolt= n (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((v (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") a (jolt-vector)) (jolt-invoke rf result v))) result)))))))))) ((n coll) (let fnrec2329 ((n n) (coll coll)) (letrec* ((go (letrec ((go (lambda (s) (let fnrec2330 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2331 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (if (jolt-truthy? (jolt-seq s)) (let* ((i 0) (acc (jolt-list )) (cur s)) (let loop2332 ((i i) (acc acc) (cur cur)) (if (jolt-truthy? (let* ((and__25__auto (< i n))) (if (jolt-truthy? and__25__auto) (jolt-seq cur) and__25__auto))) (let* ((_a$2333 (jolt-inc i)) (_a$2334 (jolt-cons (jolt-first cur) acc)) (_a$2335 (jolt-rest cur))) (loop2332 _a$2333 _a$2334 _a$2335)) (let* ((_a$2336 (jolt-reverse acc)) (_a$2337 (go cur))) (jolt-cons _a$2336 _a$2337))))) jolt-nil))))))))) go))) (jolt-invoke go coll)))) ((n step coll) (let fnrec2338 ((n n) (step step) (coll coll)) (letrec* ((go (letrec ((go (lambda (s) (let fnrec2339 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2340 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (if (jolt-truthy? (jolt-seq s)) (let* ((_a$2341 (jolt-take n s)) (_a$2342 (go (jolt-invoke (var-deref "clojure.core" "nthrest") s step)))) (jolt-cons _a$2341 _a$2342)) jolt-nil))))))))) go))) (jolt-invoke go coll))))))) partition-all)))
(guard (e (#t #f))