28ef15ea4b
First fractal turn of the multi-stage bootstrap (jolt-tzo). The Clojure part of clojure.core is now loaded in ordered tiers under jolt-core/clojure/core/. The kernel tier (00-kernel: second/peek/subvec/mapv/update) holds the structural fns the self-hosted compiler itself uses; in compile mode it is bootstrap-compiled into clojure.core BEFORE the analyzer is built, so the analyzer binds those names to the Clojure definitions instead of a not-yet-defined forward ref. That removes the circularity that previously forced these to stay in Janet — the five core-* primitives and their init-core! entries are gone. Mechanism: backend/bootstrap-load-source (generalized from compile-load) builds a source string into a target ns via the bootstrap; rebuild-compiler! recompiles the self-hosted compiler against the current core (the rail for future turns, exercised by the new fixpoint test). api/load-core-overlay! walks the ordered tiers, bootstrap-loading kernel tiers and self-hosting the rest. Also fixes a latent evaluator bug surfaced by the move: a fn rebinds current-ns to its defining ns while it runs and restores on normal return, but a fn that THREW unwound past its own restore, leaking the ns. try now restores the try-entry ns on the catch/finally path, so referred-symbol resolution survives a caught error (this was breaking is/testing in the suite harness after any thrown assertion). Net battery +3 (3913 -> 3916); conformance 218/218 in all three modes; binary builds and runs the embedded tiers.
46 lines
2 KiB
Clojure
46 lines
2 KiB
Clojure
;; clojure.core — kernel tier (stage just above the Janet seed).
|
|
;;
|
|
;; These are the structural fns the self-hosted compiler itself uses
|
|
;; (jolt.analyzer): second/peek/subvec/mapv/update. Because the compiler must be
|
|
;; able to compile the *rest* of clojure.core, anything it calls has to exist
|
|
;; before it is built. So this tier is loaded FIRST and, in compile mode, is
|
|
;; bootstrap-compiled directly into clojure.core (not routed through the
|
|
;; self-hosted pipeline, which would need these to already exist — the
|
|
;; circularity that previously forced `second` to stay in Janet). With this tier
|
|
;; in place the analyzer is built against the Clojure definitions and the Janet
|
|
;; primitives are gone.
|
|
;;
|
|
;; Constraint: depend only on core-renames primitives (first/next/nth/count/conj/
|
|
;; vec/map/apply/assoc/get/…, all hardwired to the Janet seed) and on each other.
|
|
|
|
(defn second [coll] (first (next coll)))
|
|
|
|
(defn peek [coll]
|
|
(cond
|
|
(nil? coll) nil
|
|
;; vectors (incl. jolt's eager seq results): last element; lists/seqs: first.
|
|
(vector? coll) (if (zero? (count coll)) nil (nth coll (dec (count coll))))
|
|
(seq? coll) (first coll)
|
|
:else (throw (str "peek not supported on: " coll))))
|
|
|
|
(defn subvec
|
|
([v start] (subvec v start (count v)))
|
|
([v start end]
|
|
(when (not (vector? v)) (throw (str "subvec requires a vector")))
|
|
;; Clojure coerces indices with (int ...): NaN -> 0, floats/ratios truncate
|
|
;; toward zero ((quot x 1)); non-numbers throw. Only then range-check.
|
|
(let [coerce (fn [x]
|
|
(cond
|
|
(not (number? x)) (throw (str "subvec index must be a number"))
|
|
(not= x x) 0
|
|
:else (quot x 1)))
|
|
s (coerce start)
|
|
e (coerce end)]
|
|
(when (or (< s 0) (< e s) (< (count v) e))
|
|
(throw (str "subvec index out of range: " s " " e)))
|
|
(loop [i s acc []]
|
|
(if (< i e) (recur (inc i) (conj acc (nth v i))) acc)))))
|
|
|
|
(defn mapv [f & colls] (vec (apply map f colls)))
|
|
|
|
(defn update [m k f & args] (assoc m k (apply f (get m k) args)))
|