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

core: migrate 7 lazy seq fns from the Janet seed to the Clojure overlay (40-lazy)

Browse source 
Finishes a port the prior team started and reverted (bb4a3e0): the 40-lazy.clj
tier moved lazy seq fns Janet→Clojure but regressed the suite to 849 because
lazy-seq's expansion leaked as data in compile mode — that was jolt-r81, since
root-fixed (lazy-seq/lazy-cat moved to 00-syntax). With the wall gone, the port
works. This shrinks the Janet seed toward the north star (self-hosted
clojure-in-clojure on a minimal host bootstrap).

Moved to core/40-lazy.clj (wired as a loaded tier after 30-macros):
  distinct keep keep-indexed map-indexed cycle repeat iterate
40-lazy.clj completed to full parity: distinct gains its transducer arity;
keep/keep-indexed/map-indexed already had both arities.

Removed from the Janet seed (core.janet): the 7 core-* fns + their core-bindings
entries, the now-dead td-keep/td-map-indexed transducer helpers (the CLJ versions
carry their own), and the already-dead core-partition-by/core-xml-seq (shadowed by
10-seq/20-coll). Net: core.janet −131 lines.

Deferred (kept in Janet, separate follow-ups): partition-all (a CLJ port via
take/drop realizes a non-minimal element count, tripping the §6.3 laziness
counters + a suite file) and repeatedly (canonical CLJ doesn't validate args, so
the repeatedly.cljc throw cases regress). Both need behavior-matching first.

Gate: conformance 262x3, lazy-infinite 44/44, clojure-test-suite 4004/66 (UP from
3981 — the CLJ versions add coverage, e.g. distinct value-equality), fixpoint,
self-host, sci 422/0, fallback-zero, specs+unit, core-bench all green.
This commit is contained in:
Yogthos 2026-06-08 23:27:41 -04:00
parent 9e6abcd540
commit cd8f11934b
3 changed files with 39 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

50
jolt-core/clojure/core/40-lazy.clj
View file

@ -3,17 +3,26 @@
;;
;; Each fn ported from CLJS core.cljs, stripped of chunked-seq branches.
;; --- distinct ---
(defn distinct [coll]
(let [step (fn step [xs seen]
(lazy-seq
((fn [[f :as xs] seen]
(when-let [s (seq xs)]
(if (contains? seen f)
(recur (rest s) seen)
(cons f (step (rest s) (conj seen f))))))
xs seen)))]
(step coll #{})))
;; --- distinct --- (transducer + lazy collection arity; value-based dedup)
(defn distinct
([]
(fn [rf]
(let [seen (volatile! #{})]
(fn ([] (rf)) ([result] (rf result))
([result input]
(if (contains? @seen input)
result
(do (vswap! seen conj input) (rf result input))))))))
([coll]
(let [step (fn step [xs seen]
(lazy-seq
((fn [[f :as xs] seen]
(when-let [s (seq xs)]
(if (contains? seen f)
(recur (rest s) seen)
(cons f (step (rest s) (conj seen f))))))
xs seen)))]
(step coll #{}))))
;; --- keep ---
@ -76,10 +85,10 @@
(cstep 0)))
()))
;; --- repeatedly ---
(defn repeatedly
([f] (lazy-seq (cons (f) (repeatedly f))))
([n f] (take n (repeatedly f))))
;; repeatedly stays in the Janet seed for now (core-repeatedly): the canonical CLJ
;; version doesn't validate args, so (first (repeatedly non-fn)) / (repeatedly \a +)
;; don't throw like the stricter Janet version (repeatedly.cljc throw cases).
;; Ported separately once the non-fn / non-number-count throws are matched.
;; --- repeat ---
(defn repeat
@ -91,10 +100,7 @@
(lazy-seq (cons x (iterate f (f x)))))
;; --- partition-all ---
(defn partition-all
([n coll] (partition-all n n coll))
([n step coll]
(lazy-seq
(when-let [s (seq coll)]
(cons (take n s) (partition-all n step (nthrest coll step)))))))
;; partition-all stays in the Janet seed for now (core-partition-all): it already
;; has the transducer + collection arities (jolt-cru), and a CLJ port realizes a
;; different (non-minimal) element count via take/drop than the Janet one,
;; tripping the §6.3 laziness counters + a suite file. Ported separately.