bfa2cbf49d
jolt maps were HAMTs with hash iteration order; Clojure keeps small maps as
PersistentArrayMap (insertion order), converting to PersistentHashMap past a
threshold. Map literals, array-map, assoc, into/transient, merge, zipmap,
select-keys, update-keys/vals, frequencies and group-by now iterate in insertion
order for <=8 entries, matching the JVM. hash-map and >8-entry maps stay hash
order; sets stay hash order.
The pmap record gains an order field (the insertion-order key list, or #f once
hashed); the HAMT still backs the values so equality/hash/lookup are unchanged.
pmap-fold visits an array-mode map last-to-first so the runtime's cons-accumulate
idiom reconstructs insertion order without touching its many call sites, and
hash-mode output stays byte-identical; pmap-fold-fwd visits in order for the few
sites that build a value directly. Transient maps track insertion order and
promote to hash past max(8, source-count), matching TransientArrayMap.
The hash-map native-op retargets to a hash-order builder so (hash-map ...) stays
hash-ordered while {...} literals are ordered; syntax-quote builds maps via the
hash builder (Clojure expands `{...} to apply hash-map). The core overlay map
builders seed from {} instead of (hash-map) to keep order.
Threshold is 8 for any key (the keyword exception in newer Clojure isn't in
1.12.5). honeysql now passes 832/0/0; 19 JVM-certified corpus rows added.
29 lines
1.5 KiB
Scheme
29 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: realize any seqable to a list, then dedup through the set ctor. nil -> #{}.
|
|
(define (jolt-set coll)
|
|
(if (jolt-nil? coll) (jolt-hash-set) (apply jolt-hash-set (seq->list coll))))
|
|
|
|
;; 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" "set" jolt-set)
|
|
(def-var! "clojure.core" "rand" jolt-rand)
|
|
(def-var! "clojure.core" "map-entry?" jolt-map-entry?)
|