d77b4e6420
set was a native shim (apply jolt-hash-set (seq->list coll)). It is a pure composition, so the Clojure version (apply hash-set (seq coll)) lowers to the same code. The compiler uses set, but only off the emit path (the backend's bare-native-names def and type inference), so it can live in the kernel tier: compiling that tier never calls set, and by the time those callers run the tier is already bound. This is distinct from boolean, which the backend calls for every :if node on the emit path. Moving boolean even to the kernel tier deadlocks (compiling the tier that defines boolean needs boolean), so boolean stays native. Added a comment in predicates.ss recording that. Re-mint converges in 3 passes and the benchmark suite is unchanged within noise (collections 43.3 vs 43.1, binary-trees 367 vs 367, the rest flat).
28 lines
1.5 KiB
Scheme
28 lines
1.5 KiB
Scheme
;; Collection constructors + rand — host-coupled natives the overlay assumes as
|
|
;; bare clojure.core vars. The persistent-collection constructors already exist
|
|
;; in collections.ss (jolt-hash-map / jolt-hash-set / jolt-vector); this just
|
|
;; binds the public clojure.core names to them. Loaded after def-var! (rt.ss) +
|
|
;; the collections + seq tiers. hash-map/array-map/hash-set/set/rand semantics.
|
|
|
|
;; array-map: insertion-ordered, any size (Clojure's PersistentArrayMap, via
|
|
;; createAsIfByAssoc). hash-map: hash order (PersistentHashMap). The map LITERAL
|
|
;; ctor (jolt-hash-map, emitted for {...}) is array-ordered up to 8 entries and
|
|
;; hash beyond, matching RT.map.
|
|
(define (jolt-array-map . kvs) (jolt-array-map-build kvs))
|
|
(define (jolt-hash-map-fn . kvs) (jolt-hash-map-build kvs))
|
|
|
|
;; set lives in the kernel overlay tier (clojure/core/00-kernel.clj): it's a pure
|
|
;; composition (apply hash-set (seq coll)) the compiler uses only off the emit path,
|
|
;; so the Clojure version lowers to the same code without a bootstrap cycle.
|
|
|
|
;; rand: a flonum in [0, n) (n defaults to 1.0) — jolt is all-flonum, so the
|
|
;; result is a double like every other number.
|
|
(define (jolt-rand . n)
|
|
(let ((r (random 1.0)))
|
|
(if (null? n) r (* r (exact->inexact (car n))))))
|
|
|
|
(def-var! "clojure.core" "hash-map" jolt-hash-map-fn)
|
|
(def-var! "clojure.core" "hash-set" jolt-hash-set)
|
|
(def-var! "clojure.core" "array-map" jolt-array-map)
|
|
(def-var! "clojure.core" "rand" jolt-rand)
|
|
(def-var! "clojure.core" "map-entry?" jolt-map-entry?)
|