From 4a2ef99feee9335b8973242c4489407dc722479a Mon Sep 17 00:00:00 2001 From: Yogthos Date: Mon, 8 Jun 2026 11:58:39 -0400 Subject: [PATCH] Review fixes: partition+concat in 10-seq, delete dead defns, dedupe de-duplicated 1. partition + concat added to 10-seq.clj (ported from CLJS core.cljs) 2. Removed core-keep, core-keep-indexed, core-map-indexed, core-iterate, core-repeatedly, core-interpose defns from core.janet (bindings already removed in prior commit, left dead bodies) 3. Removed dedupe from 40-lazy.clj (belongs in 20-coll.clj) Gates: lazy-infinite 22/22, conformance 229x3, specs 32/32 --- jolt-core/clojure/core/10-seq.clj | 31 +++++++++++++ jolt-core/clojure/core/40-lazy.clj | 14 ------ src/jolt/core.janet | 72 ------------------------------ 3 files changed, 31 insertions(+), 86 deletions(-) diff --git a/jolt-core/clojure/core/10-seq.clj b/jolt-core/clojure/core/10-seq.clj index 91e84e5..6dbb7e9 100644 --- a/jolt-core/clojure/core/10-seq.clj +++ b/jolt-core/clojure/core/10-seq.clj @@ -34,3 +34,34 @@ run (cons fst (take-while (fn [x] (= fv (f x))) (rest s)))] (cons run (step (lazy-seq (drop (count run) s)))))))))] (step coll))) + +;; Lazy partition: yields complete partitions of size n. Optional step. +;; Ported from CLJS core.cljs (no chunked-seq branches). +(defn partition + ([n coll] (partition n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (when (= n (count p)) + (cons p (partition n step (nthrest coll step))))))))) + +;; Lazy concat: concatenates colls lazily. Ported from CLJS core.cljs. +(defn concat + ([] (lazy-seq nil)) + ([x] (lazy-seq x)) + ([x y] + (lazy-seq + (let [s (seq x)] + (if s + (cons (first s) (concat (rest s) y)) + y)))) + ([x y & zs] + (let [step (fn step [xys zs] + (lazy-seq + (let [xys (seq xys)] + (if xys + (cons (first xys) (step (rest xys) zs)) + (when zs + (step (first zs) (next zs)))))))] + (step (concat x y) zs)))) diff --git a/jolt-core/clojure/core/40-lazy.clj b/jolt-core/clojure/core/40-lazy.clj index 7254b95..4b981b7 100644 --- a/jolt-core/clojure/core/40-lazy.clj +++ b/jolt-core/clojure/core/40-lazy.clj @@ -15,20 +15,6 @@ xs seen)))] (step coll #{}))) -;; --- dedupe (lazy, canonical) --- -(defn dedupe [coll] - (let [step (fn step [s prev] - (lazy-seq - (let [s (seq s)] - (when s - (let [x (first s)] - (if (= x prev) - (step (rest s) prev) - (cons x (step (rest s) x))))))))] - (let [s (seq coll)] - (if s - (lazy-seq (cons (first s) (step (rest s) (first s)))) - ())))) ;; --- keep --- (defn keep diff --git a/src/jolt/core.janet b/src/jolt/core.janet index b9509e2..78fad32 100644 --- a/src/jolt/core.janet +++ b/src/jolt/core.janet @@ -1292,27 +1292,6 @@ (+= i step)) result)))) -(defn core-keep-indexed [f coll] - (def f (as-fn f)) - (if (lazy-seq? coll) - (do - (defn kstep [c i] - (fn [] - (var cur c) (var idx i) (var found false) (var result nil) - (while (and (not found) (not (seq-done? cur))) - (let [v (f idx (ls-first cur))] - (++ idx) - (set cur (ls-rest cur)) - (when (not (nil? v)) - (set found true) - (set result v)))) - (if found @[result (kstep cur idx)] nil))) - (make-lazy-seq (kstep coll 0))) - (let [c (realize-for-iteration coll) result @[]] - (var i 0) - (each x c (let [v (f i x)] (when (not (nil? v)) (array/push result v))) (++ i)) - (tuple/slice (tuple ;result))))) - (defn core-map-indexed [f & rest] (if (= 0 (length rest)) (td-map-indexed f) (let [coll (in rest 0)] @@ -1344,7 +1323,6 @@ # subvec lives in the Clojure kernel tier — core/00-kernel.clj. - (defn core-rand-int [n] (math/floor (* (math/random) n))) (defn core-trampoline [f & args] (var result (apply f args)) @@ -1815,7 +1793,6 @@ (let [t (and (core-meta v) (get (core-meta v) :test))] (if t (do (t) :ok) :no-test))) - # ============================================================ # Bit operations (needed for persistent data structures) # ============================================================ @@ -1860,7 +1837,6 @@ (def core-hash (fn [x] (hash x))) - # ============================================================ # Atom # ============================================================ @@ -2012,7 +1988,6 @@ (put gensym_counter :val (+ n 1)) {:jolt/type :symbol :ns nil :name (string prefix-string n)}) - # if-let/when-let/if-some/when-some now live in the Clojure overlay # (core/30-macros.clj) as defmacros. @@ -2119,15 +2094,12 @@ # Clojure's realized? is only defined on IPending; reject anything else. (error (string "realized? not supported on " (type x))))) - # Proxy stub — returns nil form (macro, args not evaluated) # Thread stubs (def core-Thread (fn [& args] (struct ;[:jolt/type :jolt/thread]))) (def core-ThreadLocal (fn [& args] (struct ;[:jolt/type :jolt/thread-local]))) (def core-IllegalStateException (fn [& args] (struct ;[:jolt/type :jolt/exception]))) - - # letfn — mutually-recursive local fns. Expands to let* of fn* bindings; jolt # closures capture the (shared, mutable) bindings table, so forward references # between the fns resolve at call time. @@ -2269,49 +2241,6 @@ (if started (rf (rf (a 0) sep) (a 1)) (do (set started true) (rf (a 0) (a 1)))))))) -(defn core-interpose [sep & rest] - (if (= 0 (length rest)) (td-interpose sep) - (let [coll (in rest 0)] - (if (lazy-seq? coll) - (do - (defn istep [c need-sep] - (fn [] - (if (seq-done? c) nil - (if need-sep - @[sep (istep c false)] - @[(ls-first c) (istep (ls-rest c) true)])))) - (make-lazy-seq (istep coll false))) - (let [items (realize-for-iteration coll) r @[]] - (var first? true) - (each x items (if first? (set first? false) (array/push r sep)) (array/push r x)) - (tuple ;r)))))) - -(defn core-keep - "(keep f coll) — (f x) for each x, dropping nils. (keep f) is a transducer." - [f & rest] - (def f (as-fn f)) - (if (= 0 (length rest)) - (td-keep f) - (let [coll (in rest 0)] - (if (lazy-seq? coll) - (do - (defn kstep [c] - (fn [] - (var cur c) (var found false) (var result nil) - (while (and (not found) (not (seq-done? cur))) - (let [v (f (ls-first cur))] - (set cur (ls-rest cur)) - (when (not (nil? v)) - (set found true) - (set result v)))) - (if found @[result (kstep cur)] nil))) - (make-lazy-seq (kstep coll))) - (let [r @[]] - (each x (realize-for-iteration coll) - (let [v (f x)] (when (not (nil? v)) (array/push r v)))) - (tuple ;r)))))) - - (defn core-empty [coll] (cond (phm? coll) (make-phm) @@ -2358,7 +2287,6 @@ (and (struct? x) (= :symbol (x :jolt/type))))) (defn core-indexed? [x] (or (tuple? x) (array? x) (pvec? x))) - # With a single item, Clojure returns it WITHOUT calling f. On ties, the last # extremal item wins (>=/<= update), matching Clojure. # Clojure's min-key/max-key: the 2-arg base compares with strict < / > (so the