e2e189acfe
jolt-c09 (partial, Steps 0–2d complete). Lazy combinator layer (Step 1): - lazy-cons: build a LazySeq cell from val + rest-thunk (phm.janet) - lazy-from: coerce any seqable to lazy view without forcing (core.janet) - core-seq: check ls-first emptiness, not ls-seq realization (core.janet) Lazy transformers (Steps 2a–2d): Converted in Janet core.janet (lazy branches preserving transducer arities): drop-while, interpose, distinct, partition, partition-all, keep, keep-indexed, map-indexed, take-nth Moved to Clojure overlay (jolt-core): interleave (20-coll.clj) — lazy multi-arity, matches Clojure mapcat (10-seq.clj) — transducer arity + standard (apply concat (apply map f colls)) Safety net (Step 0): test/support/lazy-eval.janet — subprocess worker for Clojure eval test/integration/lazy-infinite-test.janet — deadlined harness (os/spawn + 5s) Multi-input map/mapcat tests (Step 2d): sequences-spec.janet +9 tests, verified against Clojure/CLJS references Gates: lazy-infinite: 18/18 (mapcat on infinite inputs hangs — apply forces, needs Step 4) conformance: 229/229 ×3 (interpret/compile/self-host) specs: 32/32 files, 0 failures
29 lines
1.1 KiB
Clojure
29 lines
1.1 KiB
Clojure
;; clojure.core — seq tier. Pure-Clojure leaf sequence fns on top of the kernel
|
|
;; tier (00-kernel) and the Janet seed. Loaded after the kernel tier; in compile
|
|
;; mode these self-host through the now-built analyzer (interpreted otherwise).
|
|
;;
|
|
;; Migration rule for adding fns here: the fn must (1) NOT be in
|
|
;; compiler/core-renames (that map emits core-X Janet symbols directly), (2) have
|
|
;; no internal Janet callers of its core-X binding, and (3) NOT be used by the
|
|
;; self-hosted compiler (jolt-core/jolt/*.clj). Compiler-facing structural fns go
|
|
;; in the kernel tier (00-kernel) instead — see its header.
|
|
|
|
(defn ffirst [coll] (first (first coll)))
|
|
(defn nfirst [coll] (next (first coll)))
|
|
(defn fnext [coll] (first (next coll)))
|
|
(defn nnext [coll] (next (next coll)))
|
|
|
|
;; Canonical Clojure defs: pure first/next/loop/recur, no Janet realize-for-iteration.
|
|
(defn last [s]
|
|
(if (next s) (recur (next s)) (first s)))
|
|
|
|
(defn butlast [s]
|
|
(loop [ret [] s s]
|
|
(if (next s)
|
|
(recur (conj ret (first s)) (next s))
|
|
(seq ret))))
|
|
|
|
(defn mapcat
|
|
([f] (comp (map f) cat))
|
|
([f & colls]
|
|
(apply concat (apply map f colls))))
|