simon/jolt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clean up codebase: rename stdlib layer, strip porting residue, fix tooling

Browse source 
Rename src/jolt -> stdlib (the runtime-loaded layer; jolt-core stays the
seed-baked layer) and update the loader / emit-image / doc paths. Drop dead
code: the spike/ experiments, the duplicate clojuredocs-export.edn (json moves
to tools/), the Janet-era jolt.http binding, and the orphaned
persistent_vector.clj whose ns/path didn't even match.

Strip porting residue from comments and docstrings across host/chez, jolt-core,
stdlib, tests, and docs: internal issue ids, "Phase N" markers, and the "vs
Janet" historical exposition, leaving present-tense descriptions and the real
JVM-Clojure semantic contrasts. Same pass over the corpus suite labels. The seed
is unchanged (docstrings/comments aren't emitted), so the self-host fixpoint and
corpus are untouched.

Port tools/spec_coverage.py off the dead janet probe to bin/joltc and regenerate
coverage.md; drop the dead :host/janet rule from certify.clj and regenerate the
conformance profile. Add docs/host-interop.md (the JVM shims and how to register
your own host class from a library) and a writing-style note in CLAUDE.md.

Stabilize the four racy concurrency corpus cases (future-cancel and agent
send/send-off): give the future a sleeping body and the agent a slow action, so
cancel reliably catches an in-flight future and deref reliably reads the
pre-update snapshot. They certify deterministically now, so drop their :flaky
allowlist entries and the orphaned legend.
This commit is contained in:
Yogthos 2026-06-22 22:18:00 -04:00
parent c18f8087f0
commit 33eff7c7d8
112 changed files with 970 additions and 1621 deletions
Download patch file Download diff file Expand all files Collapse all files

8
test/chez/bench-chez.ss
View file

@ -1,8 +1,6 @@
;; bench-chez.ss (jolt-cf1q.5) — Phase 4 perf probe for the zero-Janet Chez path.
;;
;; Mirrors test/bench/core-bench.janet's programs and methodology (load the runtime
;; ONCE, then time compile+run of each program, min of N) so the Chez compute path
;; (analyze->Scheme->Chez eval) is comparable to the Janet compile path. Run:
;; bench-chez.ss — perf probe for the Chez compute path. Loads the runtime ONCE,
;; then times compile+run of each program (min of N) over the
;; analyze->Scheme->Chez eval pipeline. Run:
;; chez --script test/chez/bench-chez.ss
(import (chezscheme))
(load "host/chez/rt.ss")

230
test/chez/corpus.edn
View file

@ -56,13 +56,13 @@
{:suite "control / conditional-binding scope" :label "if-let in fn param" :expected "9" :actual "((fn [xs] (if-let [xs nil] :then xs)) 9)"}
{:suite "control / conditional-binding scope" :label "when-some binds zero" :expected "1" :actual "(when-some [x 0] (inc x))"}
{:suite "control / conditional-binding scope" :label "if-let evals test once" :expected "1" :actual "(let [c (atom 0)] (if-let [v (do (swap! c inc) :v)] @c :none))"}
{:suite "control / loop lowering (jolt-v28u)" :label "closure captures per-iter binding" :expected "[0 1 2]" :actual "(mapv (fn [g] (g)) (loop [i 0 fs []] (if (< i 3) (recur (inc i) (conj fs (fn [] i))) fs)))"}
{:suite "control / loop lowering (jolt-v28u)" :label "fib via loop" :expected "55" :actual "(loop [a 0 b 1 i 0] (if (= i 10) a (recur b (+ a b) (inc i))))"}
{:suite "control / loop lowering (jolt-v28u)" :label "recur args no clobber" :expected "[2 1]" :actual "(loop [a 1 b 2 n 0] (if (= n 1) [a b] (recur b a (inc n))))"}
{:suite "control / loop lowering (jolt-v28u)" :label "nested loops" :expected "9" :actual "(loop [i 0 s 0] (if (= i 3) s (recur (inc i) (loop [j 0 t s] (if (= j 3) t (recur (inc j) (inc t)))))))"}
{:suite "control / loop lowering (jolt-v28u)" :label "loop sequential init" :expected "12" :actual "(loop [a 1 b (+ a 10)] (+ a b))"}
{:suite "control / loop lowering (jolt-v28u)" :label "recur through let" :expected "6" :actual "(loop [i 0 acc 0] (let [x (* i 2)] (if (< i 3) (recur (inc i) (+ acc x)) acc)))"}
{:suite "control / loop lowering (jolt-v28u)" :label "fn-arity recur intact" :expected "15" :actual "((fn f [n acc] (if (zero? n) acc (recur (dec n) (+ acc n)))) 5 0)"}
{:suite "control / loop lowering" :label "closure captures per-iter binding" :expected "[0 1 2]" :actual "(mapv (fn [g] (g)) (loop [i 0 fs []] (if (< i 3) (recur (inc i) (conj fs (fn [] i))) fs)))"}
{:suite "control / loop lowering" :label "fib via loop" :expected "55" :actual "(loop [a 0 b 1 i 0] (if (= i 10) a (recur b (+ a b) (inc i))))"}
{:suite "control / loop lowering" :label "recur args no clobber" :expected "[2 1]" :actual "(loop [a 1 b 2 n 0] (if (= n 1) [a b] (recur b a (inc n))))"}
{:suite "control / loop lowering" :label "nested loops" :expected "9" :actual "(loop [i 0 s 0] (if (= i 3) s (recur (inc i) (loop [j 0 t s] (if (= j 3) t (recur (inc j) (inc t)))))))"}
{:suite "control / loop lowering" :label "loop sequential init" :expected "12" :actual "(loop [a 1 b (+ a 10)] (+ a b))"}
{:suite "control / loop lowering" :label "recur through let" :expected "6" :actual "(loop [i 0 acc 0] (let [x (* i 2)] (if (< i 3) (recur (inc i) (+ acc x)) acc)))"}
{:suite "control / loop lowering" :label "fn-arity recur intact" :expected "15" :actual "((fn f [n acc] (if (zero? n) acc (recur (dec n) (+ acc n)))) 5 0)"}
{:suite "control / iteration" :label "dotimes side-effect" :expected "5" :actual "(let [a (atom 0)] (dotimes [i 5] (swap! a inc)) @a)"}
{:suite "control / iteration" :label "while" :expected "5" :actual "(let [a (atom 0)] (while (< @a 5) (swap! a inc)) @a)"}
{:suite "control / iteration" :label "for" :expected "[0 1 2]" :actual "(for [x (range 3)] x)"}
@ -136,12 +136,12 @@
{:suite "destructure / fn params & loop" :label "loop vector binding" :expected "[4 2]" :actual "(loop [[a b] [1 2] n 0] (if (< n 3) (recur [(inc a) b] (inc n)) [a b]))"}
{:suite "destructure / fn params & loop" :label "loop map binding" :expected "4" :actual "(loop [{:keys [v]} {:v 1} n 0] (if (< n 2) (recur {:v (* v 2)} (inc n)) v))"}
{:suite "destructure / fn params & loop" :label "loop init sees destr" :expected "[1 2 3]" :actual "(loop [[a b] [1 2] c (+ a b)] [a b c])"}
{:suite "destructure / primitives reject patterns (jolt-f79)" :label "fn* fixed pattern" :expected :throws :actual "((fn* [[a b]] a) [1 2])"}
{:suite "destructure / primitives reject patterns (jolt-f79)" :label "fn* rest pattern" :expected :throws :actual "((fn* [a & [b]] b) 1 2 3)"}
{:suite "destructure / primitives reject patterns (jolt-f79)" :label "let* pattern" :expected :throws :actual "(let* [[a b] [1 2]] a)"}
{:suite "destructure / primitives reject patterns (jolt-f79)" :label "loop* pattern" :expected :throws :actual "(loop* [[a b] [1 2]] a)"}
{:suite "destructure / primitives reject patterns (jolt-f79)" :label "fn desugars" :expected "[1 2]" :actual "((fn [[a b]] [a b]) [1 2])"}
{:suite "destructure / primitives reject patterns (jolt-f79)" :label "let desugars" :expected "[1 2]" :actual "(let [[a b] [1 2]] [a b])"}
{:suite "destructure / primitives reject patterns" :label "fn* fixed pattern" :expected :throws :actual "((fn* [[a b]] a) [1 2])"}
{:suite "destructure / primitives reject patterns" :label "fn* rest pattern" :expected :throws :actual "((fn* [a & [b]] b) 1 2 3)"}
{:suite "destructure / primitives reject patterns" :label "let* pattern" :expected :throws :actual "(let* [[a b] [1 2]] a)"}
{:suite "destructure / primitives reject patterns" :label "loop* pattern" :expected :throws :actual "(loop* [[a b] [1 2]] a)"}
{:suite "destructure / primitives reject patterns" :label "fn desugars" :expected "[1 2]" :actual "((fn [[a b]] [a b]) [1 2])"}
{:suite "destructure / primitives reject patterns" :label "let desugars" :expected "[1 2]" :actual "(let [[a b] [1 2]] [a b])"}
{:suite "destructure / macro params" :label "macro & [a & more :as all]" :expected "[1 [2 3] [1 2 3]]" :actual "(do (defmacro m [& [a & more :as all]] (list (quote quote) [a (vec more) (vec all)])) (m 1 2 3))"}
{:suite "destructure / macro params" :label "macro fixed destructure" :expected "[2 1]" :actual "(do (defmacro mm [[a b]] (list (quote quote) [b a])) (mm [1 2]))"}
{:suite "destructure / macro params" :label "macro & {:keys}" :expected "5" :actual "(do (defmacro mk [& {:keys [x]}] (list (quote quote) x)) (mk :x 5))"}
@ -414,8 +414,8 @@
{:suite "clojure.core / futures — predicates" :label "future? false" :expected "false" :actual "(future? 42)"}
{:suite "clojure.core / futures — predicates" :label "future-done? after deref" :expected "true" :actual "(let [f (future 1)] (deref f) (future-done? f))"}
{:suite "clojure.core / futures — predicates" :label "realized? after deref" :expected "true" :actual "(let [f (future 1)] (deref f) (realized? f))"}
{:suite "clojure.core / futures — predicates" :label "cancel an in-flight future returns true" :expected "true" :actual "(let [f (future 1)] (future-cancel f))"}
{:suite "clojure.core / futures — predicates" :label "future-cancelled? after cancel" :expected "true" :actual "(let [f (future 1)] (future-cancel f) (future-cancelled? f))"}
{:suite "clojure.core / futures — predicates" :label "cancel an in-flight future returns true" :expected "true" :actual "(let [f (future (do (Thread/sleep 100) 1))] (future-cancel f))"}
{:suite "clojure.core / futures — predicates" :label "future-cancelled? after cancel" :expected "true" :actual "(let [f (future (do (Thread/sleep 100) 1))] (future-cancel f) (future-cancelled? f))"}
{:suite "clojure.core / futures — predicates" :label "future-done? after cancel" :expected "true" :actual "(let [f (future 1)] (future-cancel f) (future-done? f))"}
{:suite "clojure.core / futures — predicates" :label "cancel an already-completed future returns false" :expected "false" :actual "(let [f (future 1)] (deref f) (future-cancel f))"}
{:suite "clojure.core / futures — predicates" :label "future-cancelled? fresh is false" :expected "false" :actual "(future-cancelled? (future 1))"}
@ -670,15 +670,15 @@
{:suite "io / cold tagged types via print-method" :label "transient map" :expected "\"#object[clojure.lang.PersistentArrayMap$TransientArrayMap 0x79939c8 \\\"clojure.lang.PersistentArrayMap$TransientArrayMap@79939c8\\\"]\"" :actual "(pr-str (transient {:a 1}))"}
{:suite "io / cold tagged types via print-method" :label "atom override fires nested" :expected "\"{:a #object[clojure.lang.Atom 0x2bb39d6c {:status :ready, :val 7}]}\"" :actual "(do (defmethod print-method :jolt/atom [a w] (.write w (str \"#atom[\" (deref a) \"]\"))) (pr-str {:a (atom 7)}))"}
{:suite "io / cold tagged types via print-method" :label "uuid through str unchanged" :expected "\"b6883c0a-0342-4007-9966-bc2dfa6b109e\"" :actual "(str (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"}
{:suite "ISeq call forms (jolt-2rx)" :label "eval a cons'd call" :expected "3" :actual "(eval (cons (quote +) (quote (1 2))))"}
{:suite "ISeq call forms (jolt-2rx)" :label "eval a list-built call" :expected "6" :actual "(eval (list (quote +) 1 2 3))"}
{:suite "ISeq call forms (jolt-2rx)" :label "eval a concat'd call" :expected "10" :actual "(eval (concat (list (quote +)) (list 1 2 3 4)))"}
{:suite "ISeq call forms (jolt-2rx)" :label "nested cons'd subform" :expected "7" :actual "(eval (list (quote +) 3 (cons (quote +) (quote (1 3)))))"}
{:suite "ISeq call forms (jolt-2rx)" :label "empty list self-evals" :expected "[]" :actual "(eval (list))"}
{:suite "ISeq call forms (jolt-2rx)" :label "macro output via cons" :expected "3" :actual "(do (defmacro mc [] (cons (quote +) (quote (1 2)))) (mc))"}
{:suite "ISeq call forms (jolt-2rx)" :label "macro output via concat" :expected "6" :actual "(do (defmacro mk [] (concat (list (quote +)) (list 1 2 3))) (mk))"}
{:suite "ISeq call forms (jolt-2rx)" :label "vector value self-evals" :expected "[1 2 3]" :actual "(eval (vec [1 2 3]))"}
{:suite "ISeq call forms (jolt-2rx)" :label "quoted list of data" :expected "[1 2 3]" :actual "(quote (1 2 3))"}
{:suite "ISeq call forms" :label "eval a cons'd call" :expected "3" :actual "(eval (cons (quote +) (quote (1 2))))"}
{:suite "ISeq call forms" :label "eval a list-built call" :expected "6" :actual "(eval (list (quote +) 1 2 3))"}
{:suite "ISeq call forms" :label "eval a concat'd call" :expected "10" :actual "(eval (concat (list (quote +)) (list 1 2 3 4)))"}
{:suite "ISeq call forms" :label "nested cons'd subform" :expected "7" :actual "(eval (list (quote +) 3 (cons (quote +) (quote (1 3)))))"}
{:suite "ISeq call forms" :label "empty list self-evals" :expected "[]" :actual "(eval (list))"}
{:suite "ISeq call forms" :label "macro output via cons" :expected "3" :actual "(do (defmacro mc [] (cons (quote +) (quote (1 2)))) (mc))"}
{:suite "ISeq call forms" :label "macro output via concat" :expected "6" :actual "(do (defmacro mk [] (concat (list (quote +)) (list 1 2 3))) (mk))"}
{:suite "ISeq call forms" :label "vector value self-evals" :expected "[1 2 3]" :actual "(eval (vec [1 2 3]))"}
{:suite "ISeq call forms" :label "quoted list of data" :expected "[1 2 3]" :actual "(quote (1 2 3))"}
{:suite "lazy / construction & laziness" :label "lazy-seq value" :expected "[1 2 3]" :actual "(take 3 (lazy-seq (cons 1 (lazy-seq (cons 2 (lazy-seq (cons 3 nil)))))))"}
{:suite "lazy / construction & laziness" :label "not eagerly evaluated" :expected "0" :actual "(let [c (atom 0)] (lazy-seq (swap! c inc) nil) @c)"}
{:suite "lazy / construction & laziness" :label "realized on demand" :expected "1" :actual "(let [c (atom 0) s (lazy-seq (swap! c inc) [1])] (first s) @c)"}
@ -832,22 +832,22 @@
{:suite "maps / literal construction" :label "equality with phm" :expected "true" :actual "(= {:a 1 :b 2} (assoc {:a 1} :b 2))"}
{:suite "maps / literal construction" :label "keys work after assoc" :expected "2" :actual "(:b (assoc {:a 1 :b 2} :c 3))"}
{:suite "maps / literal construction" :label "literal in fn body" :expected "12" :actual "(do (defn mfp-mk [x] {:v (* x 2)}) (:v (mfp-mk 6)))"}
{:suite "clojure.math (jolt-h79)" :label "sqrt" :expected "true" :actual "(< 1.4142 (clojure.math/sqrt 2) 1.4143)"}
{:suite "clojure.math (jolt-h79)" :label "pow" :expected "1024" :actual "(long (clojure.math/pow 2 10))"}
{:suite "clojure.math (jolt-h79)" :label "tan of 0" :expected "0" :actual "(long (clojure.math/tan 0))"}
{:suite "clojure.math (jolt-h79)" :label "round" :expected "3" :actual "(clojure.math/round 2.6)"}
{:suite "clojure.math (jolt-h79)" :label "floor" :expected "2.0" :actual "(clojure.math/floor 2.9)"}
{:suite "clojure.math (jolt-h79)" :label "signum" :expected "-1.0" :actual "(clojure.math/signum -7.2)"}
{:suite "clojure.math (jolt-h79)" :label "to-radians" :expected "true" :actual "(< 3.14 (clojure.math/to-radians 180) 3.15)"}
{:suite "clojure.math (jolt-h79)" :label "PI" :expected "true" :actual "(< 3.14 clojure.math/PI 3.15)"}
{:suite "clojure.math (jolt-h79)" :label "require + alias" :expected "5" :actual "(do (require '[clojure.math :as m]) (long (m/hypot 3 4)))"}
{:suite "clojure.math (jolt-h79)" :label "as a value" :expected "[1 2]" :actual "(mapv (comp long clojure.math/sqrt) [1 4])"}
{:suite "calls / locals named like janet macros" :label "local fn named repeat" :expected "[1 1]" :actual "(let [repeat (fn [x] [x x])] (repeat 1))"}
{:suite "calls / locals named like janet macros" :label "local fn named seq" :expected ":end" :actual "((fn seq [n] (if (pos? n) (seq (dec n)) :end)) 2)"}
{:suite "calls / locals named like janet macros" :label "local fn named loop2" :expected "[2 1]" :actual "(let [with (fn [a b] [b a])] (with 1 2))"}
{:suite "calls / locals named like janet macros" :label "overlay repeat self-call (regression)" :expected "[0 0 0]" :actual "(take 3 (repeat 0))"}
{:suite "calls / locals named like janet macros" :label "closure param called" :expected "42" :actual "((fn [f] (f 41)) inc)"}
{:suite "calls / locals named like janet macros" :label "param holding a keyword (IFn leftover)" :expected "1" :actual "((fn [f] (f {:a 1})) :a)"}
{:suite "clojure.math" :label "sqrt" :expected "true" :actual "(< 1.4142 (clojure.math/sqrt 2) 1.4143)"}
{:suite "clojure.math" :label "pow" :expected "1024" :actual "(long (clojure.math/pow 2 10))"}
{:suite "clojure.math" :label "tan of 0" :expected "0" :actual "(long (clojure.math/tan 0))"}
{:suite "clojure.math" :label "round" :expected "3" :actual "(clojure.math/round 2.6)"}
{:suite "clojure.math" :label "floor" :expected "2.0" :actual "(clojure.math/floor 2.9)"}
{:suite "clojure.math" :label "signum" :expected "-1.0" :actual "(clojure.math/signum -7.2)"}
{:suite "clojure.math" :label "to-radians" :expected "true" :actual "(< 3.14 (clojure.math/to-radians 180) 3.15)"}
{:suite "clojure.math" :label "PI" :expected "true" :actual "(< 3.14 clojure.math/PI 3.15)"}
{:suite "clojure.math" :label "require + alias" :expected "5" :actual "(do (require '[clojure.math :as m]) (long (m/hypot 3 4)))"}
{:suite "clojure.math" :label "as a value" :expected "[1 2]" :actual "(mapv (comp long clojure.math/sqrt) [1 4])"}
{:suite "calls / locals named like core macros" :label "local fn named repeat" :expected "[1 1]" :actual "(let [repeat (fn [x] [x x])] (repeat 1))"}
{:suite "calls / locals named like core macros" :label "local fn named seq" :expected ":end" :actual "((fn seq [n] (if (pos? n) (seq (dec n)) :end)) 2)"}
{:suite "calls / locals named like core macros" :label "local fn named loop2" :expected "[2 1]" :actual "(let [with (fn [a b] [b a])] (with 1 2))"}
{:suite "calls / locals named like core macros" :label "overlay repeat self-call (regression)" :expected "[0 0 0]" :actual "(take 3 (repeat 0))"}
{:suite "calls / locals named like core macros" :label "closure param called" :expected "42" :actual "((fn [f] (f 41)) inc)"}
{:suite "calls / locals named like core macros" :label "param holding a keyword (IFn leftover)" :expected "1" :actual "((fn [f] (f {:a 1})) :a)"}
{:suite "map / construct & predicate" :label "literal" :expected "{:a 1}" :actual "{:a 1}"}
{:suite "map / construct & predicate" :label "hash-map" :expected "{:b 2, :a 1}" :actual "(hash-map :a 1 :b 2)"}
{:suite "map / construct & predicate" :label "empty" :expected "{}" :actual "{}"}
@ -909,15 +909,15 @@
{:suite "map / collection keys (by value)" :label "key across repr" :expected ":v" :actual "(get (assoc {} (vec [1 2]) :v) [1 2])"}
{:suite "map / collection keys (by value)" :label "frequencies of maps" :expected "2" :actual "(get (frequencies [{:a 1} (hash-map :a 1)]) {:a 1})"}
{:suite "map / collection keys (by value)" :label "group-by collection key" :expected "1" :actual "(count (group-by identity [{:a 1} (hash-map :a 1)]))"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "set key w/ nil distinct" :expected "2" :actual "(count {#{nil 1} :a, #{1} :b})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "set key w/ nil neg lookup" :expected "nil" :actual "(get {#{nil 1} :a} #{1})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "set key w/ nil pos lookup" :expected ":a" :actual "(get {#{nil 1} :a} #{nil 1})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "set key just nil distinct" :expected "false" :actual "(= {#{nil} :x} {#{} :x})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "map nil-value key distinct" :expected "2" :actual "(count {{:a nil} 1, {} 2})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "map nil-value key neg" :expected "nil" :actual "(get {{:a nil} 1} {})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "map nil-value key pos" :expected "1" :actual "(get {{:a nil} 1} {:a nil})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "map nil-key key distinct" :expected "2" :actual "(count {{nil :a} 1, {} 2})"}
{:suite "map / nil inside a collection key (jolt-zcm9)" :label "map nil-key key pos" :expected "1" :actual "(get {{nil :a} 1} {nil :a})"}
{:suite "map / nil inside a collection key" :label "set key w/ nil distinct" :expected "2" :actual "(count {#{nil 1} :a, #{1} :b})"}
{:suite "map / nil inside a collection key" :label "set key w/ nil neg lookup" :expected "nil" :actual "(get {#{nil 1} :a} #{1})"}
{:suite "map / nil inside a collection key" :label "set key w/ nil pos lookup" :expected ":a" :actual "(get {#{nil 1} :a} #{nil 1})"}
{:suite "map / nil inside a collection key" :label "set key just nil distinct" :expected "false" :actual "(= {#{nil} :x} {#{} :x})"}
{:suite "map / nil inside a collection key" :label "map nil-value key distinct" :expected "2" :actual "(count {{:a nil} 1, {} 2})"}
{:suite "map / nil inside a collection key" :label "map nil-value key neg" :expected "nil" :actual "(get {{:a nil} 1} {})"}
{:suite "map / nil inside a collection key" :label "map nil-value key pos" :expected "1" :actual "(get {{:a nil} 1} {:a nil})"}
{:suite "map / nil inside a collection key" :label "map nil-key key distinct" :expected "2" :actual "(count {{nil :a} 1, {} 2})"}
{:suite "map / nil inside a collection key" :label "map nil-key key pos" :expected "1" :actual "(get {{nil :a} 1} {nil :a})"}
{:suite "map / strictness (throws like Clojure)" :label "assoc vec out of bounds" :expected :throws :actual "(assoc [0 1 2] 4 4)"}
{:suite "map / strictness (throws like Clojure)" :label "assoc vec negative" :expected :throws :actual "(assoc [] -1 0)"}
{:suite "map / strictness (throws like Clojure)" :label "assoc vec at count ok" :expected "[1 2 3]" :actual "(assoc [1 2] 2 3)"}
@ -1438,17 +1438,17 @@
{:suite "predicates / map? & coll? strictness" :label "coll? list" :expected "true" :actual "(coll? (list 1))"}
{:suite "predicates / map? & coll? strictness" :label "coll? set" :expected "true" :actual "(coll? #{1})"}
{:suite "predicates / map? & coll? strictness" :label "coll? lazy seq" :expected "true" :actual "(coll? (map inc [1]))"}
{:suite "predicates / tagged-value (Phase 4)" :label "atom? yes" :expected "true" :actual "(atom? (atom 1))"}
{:suite "predicates / tagged-value (Phase 4)" :label "atom? no" :expected "false" :actual "(atom? 1)"}
{:suite "predicates / tagged-value (Phase 4)" :label "volatile? yes" :expected "true" :actual "(volatile? (volatile! 1))"}
{:suite "predicates / tagged-value (Phase 4)" :label "volatile? no" :expected "false" :actual "(volatile? (atom 1))"}
{:suite "predicates / tagged-value (Phase 4)" :label "record? yes" :expected "true" :actual "(do (defrecord Rp [a]) (record? (->Rp 1)))"}
{:suite "predicates / tagged-value (Phase 4)" :label "record? no map" :expected "false" :actual "(record? {:a 1})"}
{:suite "predicates / tagged-value (Phase 4)" :label "record? no nil" :expected "false" :actual "(record? nil)"}
{:suite "predicates / tagged-value (Phase 4)" :label "tagged-literal? yes" :expected "true" :actual "(tagged-literal? (tagged-literal (quote inst) \"2020\"))"}
{:suite "predicates / tagged-value (Phase 4)" :label "tagged-literal? no" :expected "false" :actual "(tagged-literal? 1)"}
{:suite "predicates / tagged-value (Phase 4)" :label "reader-conditional? no" :expected "false" :actual "(reader-conditional? 1)"}
{:suite "predicates / tagged-value (Phase 4)" :label "chunked-seq? always false" :expected "true" :actual "(chunked-seq? (seq [1 2 3]))"}
{:suite "predicates / tagged-value" :label "atom? yes" :expected "true" :actual "(atom? (atom 1))"}
{:suite "predicates / tagged-value" :label "atom? no" :expected "false" :actual "(atom? 1)"}
{:suite "predicates / tagged-value" :label "volatile? yes" :expected "true" :actual "(volatile? (volatile! 1))"}
{:suite "predicates / tagged-value" :label "volatile? no" :expected "false" :actual "(volatile? (atom 1))"}
{:suite "predicates / tagged-value" :label "record? yes" :expected "true" :actual "(do (defrecord Rp [a]) (record? (->Rp 1)))"}
{:suite "predicates / tagged-value" :label "record? no map" :expected "false" :actual "(record? {:a 1})"}
{:suite "predicates / tagged-value" :label "record? no nil" :expected "false" :actual "(record? nil)"}
{:suite "predicates / tagged-value" :label "tagged-literal? yes" :expected "true" :actual "(tagged-literal? (tagged-literal (quote inst) \"2020\"))"}
{:suite "predicates / tagged-value" :label "tagged-literal? no" :expected "false" :actual "(tagged-literal? 1)"}
{:suite "predicates / tagged-value" :label "reader-conditional? no" :expected "false" :actual "(reader-conditional? 1)"}
{:suite "predicates / tagged-value" :label "chunked-seq? always false" :expected "true" :actual "(chunked-seq? (seq [1 2 3]))"}
{:suite "predicates / equality & identity" :label "= same" :expected "true" :actual "(= 1 1)"}
{:suite "predicates / equality & identity" :label "= vectors" :expected "true" :actual "(= [1 2] [1 2])"}
{:suite "predicates / equality & identity" :label "= vector & list" :expected "true" :actual "(= [1 2] (list 1 2))"}
@ -1701,18 +1701,18 @@
{:suite "regex / Pattern statics & String regex methods" :label ".matches partial -> false" :expected "false" :actual "(.matches \"abcd\" \"a.c\")"}
{:suite "regex / Pattern statics & String regex methods" :label ".replaceAll regex" :expected "\"a-b-c\"" :actual "(.replaceAll \"a_b_c\" \"_\" \"-\")"}
{:suite "regex / Pattern statics & String regex methods" :label ".replaceFirst regex" :expected "\"a-b_c\"" :actual "(.replaceFirst \"a_b_c\" \"_\" \"-\")"}
{:suite "regex / bounded quantifiers (jolt-3xur)" :label "exact {n}" :expected "\"aaa\"" :actual "(re-matches #\"a{3}\" \"aaa\")"}
{:suite "regex / bounded quantifiers (jolt-3xur)" :label "range {n,m} max" :expected "\"aaaa\"" :actual "(re-find #\"a{2,4}\" \"aaaaa\")"}
{:suite "regex / bounded quantifiers (jolt-3xur)" :label "zero lower {0,n}" :expected "\"aa\"" :actual "(re-find #\"a{0,3}\" \"aa\")"}
{:suite "regex / bounded quantifiers (jolt-3xur)" :label "{n,} unbounded" :expected "\"aaaa\"" :actual "(re-find #\"a{2,}\" \"aaaa\")"}
{:suite "regex / bounded quantifiers (jolt-3xur)" :label "nested bounds compile" :expected "true" :actual "(boolean (re-matches #\"[a-z](?:[a-z]{0,61}[a-z])?(?:-[a-z]{0,61}[a-z])*\" \"abc-def\"))"}
{:suite "regex / backreferences (jolt-xtss)" :label "repeated char" :expected "true" :actual "(boolean (re-find #\"(.)\\1\" \"abba\"))"}
{:suite "regex / backreferences (jolt-xtss)" :label "no repeat = nil" :expected "nil" :actual "(re-find #\"(.)\\1\" \"abc\")"}
{:suite "regex / backreferences (jolt-xtss)" :label "thematic-break run" :expected "true" :actual "(boolean (re-matches #\"([-*_])\\1\\1\" \"---\"))"}
{:suite "regex / backreferences (jolt-xtss)" :label "mismatched run" :expected "nil" :actual "(re-matches #\"([-*_])\\1\\1\" \"-*_\")"}
{:suite "regex / backreferences (jolt-xtss)" :label "repeated word" :expected "[\"the the\" \"the\"]" :actual "(re-find #\"(\\w+) \\1\" \"say the the word\")"}
{:suite "regex / backreferences (jolt-xtss)" :label "group still captures" :expected "[\"x=x\" \"x\"]" :actual "(re-matches #\"(\\w+)=\\1\" \"x=x\")"}
{:suite "regex / backreferences (jolt-xtss)" :label "html tag pair" :expected "true" :actual "(boolean (re-matches #\"<(\\w+)>.*</\\1>\" \"<b>hi</b>\"))"}
{:suite "regex / bounded quantifiers" :label "exact {n}" :expected "\"aaa\"" :actual "(re-matches #\"a{3}\" \"aaa\")"}
{:suite "regex / bounded quantifiers" :label "range {n,m} max" :expected "\"aaaa\"" :actual "(re-find #\"a{2,4}\" \"aaaaa\")"}
{:suite "regex / bounded quantifiers" :label "zero lower {0,n}" :expected "\"aa\"" :actual "(re-find #\"a{0,3}\" \"aa\")"}
{:suite "regex / bounded quantifiers" :label "{n,} unbounded" :expected "\"aaaa\"" :actual "(re-find #\"a{2,}\" \"aaaa\")"}
{:suite "regex / bounded quantifiers" :label "nested bounds compile" :expected "true" :actual "(boolean (re-matches #\"[a-z](?:[a-z]{0,61}[a-z])?(?:-[a-z]{0,61}[a-z])*\" \"abc-def\"))"}
{:suite "regex / backreferences" :label "repeated char" :expected "true" :actual "(boolean (re-find #\"(.)\\1\" \"abba\"))"}
{:suite "regex / backreferences" :label "no repeat = nil" :expected "nil" :actual "(re-find #\"(.)\\1\" \"abc\")"}
{:suite "regex / backreferences" :label "thematic-break run" :expected "true" :actual "(boolean (re-matches #\"([-*_])\\1\\1\" \"---\"))"}
{:suite "regex / backreferences" :label "mismatched run" :expected "nil" :actual "(re-matches #\"([-*_])\\1\\1\" \"-*_\")"}
{:suite "regex / backreferences" :label "repeated word" :expected "[\"the the\" \"the\"]" :actual "(re-find #\"(\\w+) \\1\" \"say the the word\")"}
{:suite "regex / backreferences" :label "group still captures" :expected "[\"x=x\" \"x\"]" :actual "(re-matches #\"(\\w+)=\\1\" \"x=x\")"}
{:suite "regex / backreferences" :label "html tag pair" :expected "true" :actual "(boolean (re-matches #\"<(\\w+)>.*</\\1>\" \"<b>hi</b>\"))"}
{:suite "seq / access" :label "first of vector" :expected "1" :actual "(first [1 2 3])"}
{:suite "seq / access" :label "first of list" :expected "1" :actual "(first (list 1 2 3))"}
{:suite "seq / access" :label "first of empty is nil" :expected "nil" :actual "(first [])"}
@ -1988,22 +1988,22 @@
{:suite "set / literals & value elements" :label "contains? map by value" :expected "true" :actual "(contains? #{(hash-map :x 1)} {:x 1})"}
{:suite "set / literals & value elements" :label "dedup equal maps" :expected "1" :actual "(count (set [{:a 1} (hash-map :a 1)]))"}
{:suite "set / literals & value elements" :label "vector elements" :expected "true" :actual "(contains? #{[1 2]} (vec [1 2]))"}
{:suite "set / nil element (jolt-bn2p)" :label "set keeps nil" :expected "2" :actual "(count (set [nil 1 nil]))"}
{:suite "set / nil element (jolt-bn2p)" :label "contains? nil true" :expected "true" :actual "(contains? (set [nil 1]) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "contains? nil false" :expected "false" :actual "(contains? #{1} nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "seq includes nil" :expected "true" :actual "(some nil? (seq (set [nil 1])))"}
{:suite "set / nil element (jolt-bn2p)" :label "disj nil" :expected "#{1}" :actual "(disj (set [nil 1]) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "disj nil count" :expected "1" :actual "(count (disj (set [nil 1]) nil))"}
{:suite "set / nil element (jolt-bn2p)" :label "conj nil count" :expected "2" :actual "(count (conj #{1} nil))"}
{:suite "set / nil element (jolt-bn2p)" :label "conj nil contains?" :expected "true" :actual "(contains? (conj #{1} nil) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "into #{} keeps nil" :expected "2" :actual "(count (into #{} [nil 1]))"}
{:suite "set / nil element (jolt-bn2p)" :label "into #{} contains? nil" :expected "true" :actual "(contains? (into #{} [nil 1]) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "into keeps existing nil" :expected "true" :actual "(contains? (into #{nil} [1]) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "transient conj! nil" :expected "2" :actual "(count (persistent! (conj! (transient #{}) nil 1)))"}
{:suite "set / nil element (jolt-bn2p)" :label "transient contains? nil" :expected "true" :actual "(contains? (persistent! (conj! (transient #{}) nil 1)) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "transient disj! nil cnt" :expected "1" :actual "(count (persistent! (disj! (conj! (transient #{}) nil 1) nil)))"}
{:suite "set / nil element (jolt-bn2p)" :label "transient disj! removes" :expected "false" :actual "(contains? (persistent! (disj! (conj! (transient #{}) nil 1) nil)) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "transient of set w/ nil" :expected "true" :actual "(contains? (persistent! (transient (set [nil 1]))) nil)"}
{:suite "set / nil element" :label "set keeps nil" :expected "2" :actual "(count (set [nil 1 nil]))"}
{:suite "set / nil element" :label "contains? nil true" :expected "true" :actual "(contains? (set [nil 1]) nil)"}
{:suite "set / nil element" :label "contains? nil false" :expected "false" :actual "(contains? #{1} nil)"}
{:suite "set / nil element" :label "seq includes nil" :expected "true" :actual "(some nil? (seq (set [nil 1])))"}
{:suite "set / nil element" :label "disj nil" :expected "#{1}" :actual "(disj (set [nil 1]) nil)"}
{:suite "set / nil element" :label "disj nil count" :expected "1" :actual "(count (disj (set [nil 1]) nil))"}
{:suite "set / nil element" :label "conj nil count" :expected "2" :actual "(count (conj #{1} nil))"}
{:suite "set / nil element" :label "conj nil contains?" :expected "true" :actual "(contains? (conj #{1} nil) nil)"}
{:suite "set / nil element" :label "into #{} keeps nil" :expected "2" :actual "(count (into #{} [nil 1]))"}
{:suite "set / nil element" :label "into #{} contains? nil" :expected "true" :actual "(contains? (into #{} [nil 1]) nil)"}
{:suite "set / nil element" :label "into keeps existing nil" :expected "true" :actual "(contains? (into #{nil} [1]) nil)"}
{:suite "set / nil element" :label "transient conj! nil" :expected "2" :actual "(count (persistent! (conj! (transient #{}) nil 1)))"}
{:suite "set / nil element" :label "transient contains? nil" :expected "true" :actual "(contains? (persistent! (conj! (transient #{}) nil 1)) nil)"}
{:suite "set / nil element" :label "transient disj! nil cnt" :expected "1" :actual "(count (persistent! (disj! (conj! (transient #{}) nil 1) nil)))"}
{:suite "set / nil element" :label "transient disj! removes" :expected "false" :actual "(contains? (persistent! (disj! (conj! (transient #{}) nil 1) nil)) nil)"}
{:suite "set / nil element" :label "transient of set w/ nil" :expected "true" :actual "(contains? (persistent! (transient (set [nil 1]))) nil)"}
{:suite "clojure.set" :label "union" :expected "#{1 4 3 2}" :actual "(do (require (quote [clojure.set :as s])) (s/union #{1 2} #{3 4}))"}
{:suite "clojure.set" :label "intersection" :expected "#{2}" :actual "(do (require (quote [clojure.set :as s])) (s/intersection #{1 2} #{2 3}))"}
{:suite "clojure.set" :label "difference" :expected "#{1}" :actual "(do (require (quote [clojure.set :as s])) (s/difference #{1 2} #{2 3}))"}
@ -2179,8 +2179,8 @@
{:suite "state / promises" :label "promise undelivered" :expected "nil" :actual "(let [p (promise)] @p)"}
{:suite "state / agents (synchronous shim)" :label "agent deref" :expected "0" :actual "(deref (agent 0))"}
{:suite "state / agents (synchronous shim)" :label "agent with opts" :expected "0" :actual "(deref (agent 0 :error-mode :continue))"}
{:suite "state / agents (synchronous shim)" :label "send-off applies" :expected "0" :actual "(let [a (agent 0)] (send-off a + 5) (deref a))"}
{:suite "state / agents (synchronous shim)" :label "send applies" :expected "1" :actual "(let [a (agent 1)] (send a + 6) (deref a))"}
{:suite "state / agents (synchronous shim)" :label "send-off applies" :expected "0" :actual "(let [a (agent 0)] (send-off a (fn [x] (Thread/sleep 100) (+ x 5))) (deref a))"}
{:suite "state / agents (synchronous shim)" :label "send applies" :expected "1" :actual "(let [a (agent 1)] (send a (fn [x] (Thread/sleep 100) (+ x 6))) (deref a))"}
{:suite "state / agents (synchronous shim)" :label "agent-error nil" :expected "nil" :actual "(agent-error (agent 0))"}
{:suite "string / str & basics" :label "str concat" :expected "\"abc\"" :actual "(str \"a\" \"b\" \"c\")"}
{:suite "string / str & basics" :label "str of numbers" :expected "\"12\"" :actual "(str 1 2)"}
@ -2197,18 +2197,18 @@
{:suite "string / str & basics" :label "str of a var" :expected "\"#'user/ww\"" :actual "(str (def ww 2))"}
{:suite "string / str & basics" :label "pr-str of a defn" :expected "\"#'user/gg\"" :actual "(pr-str (defn gg [x] x))"}
{:suite "string / str & basics" :label "seq of string" :expected "[\\a \\b]" :actual "(seq \"ab\")"}
{:suite "string as a seqable of chars (jolt-dl4s)" :label "vec of string" :expected "[\\a \\b]" :actual "(vec \"ab\")"}
{:suite "string as a seqable of chars (jolt-dl4s)" :label "into [] of string" :expected "[\\a \\b]" :actual "(into [] \"ab\")"}
{:suite "string as a seqable of chars (jolt-dl4s)" :label "set of string" :expected "true" :actual "(= #{\\a \\b} (set \"ab\"))"}
{:suite "string as a seqable of chars (jolt-dl4s)" :label "into #{} of string" :expected "true" :actual "(= #{\\a \\b} (into #{} \"ab\"))"}
{:suite "string as a seqable of chars (jolt-dl4s)" :label "set dedups chars" :expected "2" :actual "(count (set \"aab\"))"}
{:suite "string as a seqable of chars (jolt-dl4s)" :label "mapv over string" :expected "[\\a \\b]" :actual "(mapv identity \"ab\")"}
{:suite "clojure.string / split limit (jolt-ik3a)" :label "neg keeps trailing" :expected "[\"a\" \"\" \"\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,\" #\",\" -1))"}
{:suite "clojure.string / split limit (jolt-ik3a)" :label "zero trims trailing" :expected "[\"a\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,\" #\",\" 0))"}
{:suite "clojure.string / split limit (jolt-ik3a)" :label "omitted trims" :expected "[\"a\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,\" #\",\"))"}
{:suite "clojure.string / split limit (jolt-ik3a)" :label "positive caps parts" :expected "[\"a\" \"b,c\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,b,c\" #\",\" 2))"}
{:suite "clojure.string / split limit (jolt-ik3a)" :label "empty string" :expected "[\"\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"\" #\",\"))"}
{:suite "clojure.string / split limit (jolt-ik3a)" :label "interior empties kept" :expected "[\"a\" \"\" \"b\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,b\" #\",\"))"}
{:suite "string as a seqable of chars" :label "vec of string" :expected "[\\a \\b]" :actual "(vec \"ab\")"}
{:suite "string as a seqable of chars" :label "into [] of string" :expected "[\\a \\b]" :actual "(into [] \"ab\")"}
{:suite "string as a seqable of chars" :label "set of string" :expected "true" :actual "(= #{\\a \\b} (set \"ab\"))"}
{:suite "string as a seqable of chars" :label "into #{} of string" :expected "true" :actual "(= #{\\a \\b} (into #{} \"ab\"))"}
{:suite "string as a seqable of chars" :label "set dedups chars" :expected "2" :actual "(count (set \"aab\"))"}
{:suite "string as a seqable of chars" :label "mapv over string" :expected "[\\a \\b]" :actual "(mapv identity \"ab\")"}
{:suite "clojure.string / split limit" :label "neg keeps trailing" :expected "[\"a\" \"\" \"\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,\" #\",\" -1))"}
{:suite "clojure.string / split limit" :label "zero trims trailing" :expected "[\"a\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,\" #\",\" 0))"}
{:suite "clojure.string / split limit" :label "omitted trims" :expected "[\"a\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,\" #\",\"))"}
{:suite "clojure.string / split limit" :label "positive caps parts" :expected "[\"a\" \"b,c\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,b,c\" #\",\" 2))"}
{:suite "clojure.string / split limit" :label "empty string" :expected "[\"\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"\" #\",\"))"}
{:suite "clojure.string / split limit" :label "interior empties kept" :expected "[\"a\" \"\" \"b\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,,b\" #\",\"))"}
{:suite "clojure.string" :label "join" :expected "\"a,b,c\"" :actual "(do (require (quote [clojure.string :as s])) (s/join \",\" [\"a\" \"b\" \"c\"]))"}
{:suite "clojure.string" :label "join no sep" :expected "\"abc\"" :actual "(do (require (quote [clojure.string :as s])) (s/join [\"a\" \"b\" \"c\"]))"}
{:suite "clojure.string" :label "split" :expected "[\"a\" \"b\"]" :actual "(do (require (quote [clojure.string :as s])) (s/split \"a,b\" #\",\"))"}
@ -2692,14 +2692,14 @@
{:suite "conformance / HIGH: destructuring" :label "destr let map key" :expected "1" :actual "(let [{a :a} {:a 1}] a)"}
{:suite "conformance / HIGH: update / assoc-in on map literals" :label "update extra args" :expected "{:a 111}" :actual "(update {:a 1} :a + 10 100)"}
{:suite "conformance / HIGH: update / assoc-in on map literals" :label "get-in" :expected "1" :actual "(get-in {:a {:b {:c 1}}} [:a :b :c])"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native mod floored" :expected "2" :actual "(mod -7 3)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native rem truncated" :expected "-1" :actual "(rem -7 3)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native unary div" :expected "1/2" :actual "(/ 2)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native chained div" :expected "1" :actual "(/ 6 3 2)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native bit-and" :expected "8" :actual "(bit-and 12 10)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native bit-xor" :expected "6" :actual "(bit-xor 12 10)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native shifts" :expected "[16 2]" :actual "[(bit-shift-left 4 2) (bit-shift-right 8 2)]"}
{:suite "conformance / multimethod preferences (jolt-heo)" :label "prefer-method breaks tie" :expected ":rect" :actual "(do (derive :cm/sq :cm/rect) (derive :cm/sq :cm/shape) (defmulti cmf identity) (defmethod cmf :cm/rect [x] :rect) (defmethod cmf :cm/shape [x] :shape) (prefer-method cmf :cm/rect :cm/shape) (cmf :cm/sq))"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native mod floored" :expected "2" :actual "(mod -7 3)"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native rem truncated" :expected "-1" :actual "(rem -7 3)"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native unary div" :expected "1/2" :actual "(/ 2)"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native chained div" :expected "1" :actual "(/ 6 3 2)"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native bit-and" :expected "8" :actual "(bit-and 12 10)"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native bit-xor" :expected "6" :actual "(bit-xor 12 10)"}
{:suite "conformance / native-op parity (native ops at guarded arities)" :label "native shifts" :expected "[16 2]" :actual "[(bit-shift-left 4 2) (bit-shift-right 8 2)]"}
{:suite "conformance / multimethod preferences" :label "prefer-method breaks tie" :expected ":rect" :actual "(do (derive :cm/sq :cm/rect) (derive :cm/sq :cm/shape) (defmulti cmf identity) (defmethod cmf :cm/rect [x] :rect) (defmethod cmf :cm/shape [x] :shape) (prefer-method cmf :cm/rect :cm/shape) (cmf :cm/sq))"}
{:suite "conformance / HIGH: str semantics" :label "str concat nil" :expected "\"a1\"" :actual "(str \"a\" 1 nil)"}
{:suite "conformance / HIGH: str semantics" :label "str keyword" :expected "\":b\"" :actual "(str :b)"}
{:suite "conformance / HIGH: str semantics" :label "str symbol" :expected "\"foo\"" :actual "(str (quote foo))"}
@ -2734,7 +2734,7 @@
{:suite "conformance / dispatch-table ops + misc as macros/fns (Stage 2 tier 6c)" :label "locking evals monitor" :expected "[3 1]" :actual "(let [a (atom 0)] [(locking (swap! a inc) 3) @a])"}
{:suite "conformance / dispatch-table ops + misc as macros/fns (Stage 2 tier 6c)" :label "defonce keeps first" :expected "5" :actual "(do (defonce d6o 5) (defonce d6o 9) d6o)"}
{:suite "conformance / dispatch-table ops + misc as macros/fns (Stage 2 tier 6c)" :label "read-string + eval" :expected "3" :actual "(eval (read-string \"(+ 1 2)\"))"}
{:suite "conformance / uuid (jolt-6s2)" :label "uuid as map key" :expected ":v" :actual "(get {(parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\") :v} (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"}
{:suite "conformance / uuid" :label "uuid as map key" :expected ":v" :actual "(get {(parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\") :v} (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"}
{:suite "conformance / 1.11 additions + ns fns (spec 35-var batch A)" :label "parse-long bad" :expected "nil" :actual "(parse-long \"4.2\")"}
{:suite "conformance / 1.11 additions + ns fns (spec 35-var batch A)" :label "update-keys" :expected "{\"a\" 1}" :actual "(update-keys {:a 1} name)"}
{:suite "conformance / 1.11 additions + ns fns (spec 35-var batch A)" :label "update-vals" :expected "{:a 2}" :actual "(update-vals {:a 1} inc)"}
@ -2745,9 +2745,9 @@
{:suite "conformance / 1.11 additions + ns fns (spec 35-var batch A)" :label "ns-publics lookup" :expected "true" :actual "(do (def cnp 7) (some? (get (ns-publics (quote user)) (quote cnp))))"}
{:suite "conformance / #inst + syntax-quote literal collapse (spec 2.4/2.3)" :label "inst partial = full" :expected "true" :actual "(= #inst \"2020\" #inst \"2020-01-01T00:00:00Z\")"}
{:suite "conformance / #inst + syntax-quote literal collapse (spec 2.4/2.3)" :label "sq number collapse" :expected "42" :actual "``42"}
{:suite "conformance / stage 3: proper vars replace the Janet root-env leak" :label "compare total order" :expected "[-1 0 1]" :actual "[(compare nil 1) (compare :a :a) (compare \"b\" \"a\")]"}
{:suite "conformance / stage 3: proper vars replace the Janet root-env leak" :label "any? anything" :expected "true" :actual "(and (any? nil) (any? 1) (any? :k))"}
{:suite "conformance / stage 3: proper vars replace the Janet root-env leak" :label "macroexpand-1 when" :expected "2" :actual "(count (rest (macroexpand-1 (quote (when true 1)))))"}
{:suite "conformance / vars replace the root-env leak" :label "compare total order" :expected "[-1 0 1]" :actual "[(compare nil 1) (compare :a :a) (compare \"b\" \"a\")]"}
{:suite "conformance / vars replace the root-env leak" :label "any? anything" :expected "true" :actual "(and (any? nil) (any? 1) (any? :k))"}
{:suite "conformance / vars replace the root-env leak" :label "macroexpand-1 when" :expected "2" :actual "(count (rest (macroexpand-1 (quote (when true 1)))))"}
{:suite "conformance / HIGH: aliased namespace calls" :label "require :as alias" :expected "\"1,2,3\"" :actual "(do (require (quote [clojure.string :as s])) (s/join \",\" [1 2 3]))"}
{:suite "conformance / HIGH: aliased namespace calls" :label "ns form + alias" :expected "\"HI\"" :actual "(do (ns my.a (:require [clojure.string :as s])) (s/upper-case \"hi\"))"}
{:suite "conformance / HIGH: aliased namespace calls" :label "ns :use refers" :expected "42" :actual "(do (ns src.u) (def helper 42) (ns dst.u (:use [src.u])) helper)"}
@ -2822,7 +2822,7 @@
{:suite "conformance / sequences" :label "split-with" :expected "[[1 2] [3 4 1]]" :actual "(split-with (fn [x] (< x 3)) [1 2 3 4 1])"}
{:suite "conformance / sequences" :label "partition step" :expected "[[1 2] [3 4]]" :actual "(partition 2 2 [1 2 3 4 5])"}
{:suite "conformance / sequences" :label "not-every?" :expected "true" :actual "(not-every? pos? [1 -2 3])"}
{:suite "conformance / overlay migration (jolt-1j0): run in all 3 modes" :label "not-any?" :expected "true" :actual "(not-any? neg? [1 2 3])"}
{:suite "conformance / overlay migration: run in all 3 modes" :label "not-any?" :expected "true" :actual "(not-any? neg? [1 2 3])"}
{:suite "conformance / sequences" :label "take-nth" :expected "[0 2 4]" :actual "(take-nth 2 [0 1 2 3 4])"}
{:suite "conformance / sequences" :label "butlast" :expected "[1 2]" :actual "(butlast [1 2 3])"}
{:suite "conformance / sequences" :label "empty" :expected "[]" :actual "(empty [1 2 3])"}

9
test/chez/transient-test.ss
View file

@ -1,8 +1,9 @@
;; Transient regression: mutable backing + snapshot-on-persist (jolt-kl2l). Run:
;; Transient regression: mutable backing + snapshot-on-persist. Run:
;; chez --script test/chez/transient-test.ss
;; Semantics are covered broadly by the corpus; this pins the invariants the
;; mutable port must keep AND that large builds stay linear (a copy-on-write
;; regression would make the 200k builds quadratic and time the gate out).
;; mutable implementation must keep AND that large builds stay linear (a
;; copy-on-write regression would make the 200k builds quadratic and time the
;; gate out).
(import (chezscheme))
(load "host/chez/rt.ss")
@ -31,7 +32,7 @@
(is "source map unchanged" "(let [m {:a 1} _ (persistent! (assoc! (transient m) :b 2))] (= m {:a 1}))" "true")
(is "source vector unchanged" "(let [v [1 2] _ (persistent! (conj! (transient v) 3))] (= v [1 2]))" "true")
;; --- edges the port must keep -----------------------------------------------
;; --- edges the implementation must keep -------------------------------------
(is "nil key" "(get (persistent! (assoc! (transient {}) nil :v)) nil)" ":v")
(is "collection key" "(get (persistent! (assoc! (transient {}) [1 2] :v)) [1 2])" ":v")
(is "dangling key pads" "(= {:a 1 :b nil} (persistent! (assoc! (transient {}) :a 1 :b)))" "true")

3
test/chez/values-test.ss
View file

@ -1,4 +1,5 @@
;; Phase 0a tests — Jolt value model on Chez. Run from repo root:
;; Tests for the Jolt value model on Chez (nil/truthiness, interned keywords,
;; symbols, exactness-aware =, hashing). Run from repo root:
;; chez --script test/chez/values-test.ss
(import (chezscheme))
(load "host/chez/values.ss")

8
test/conformance/README.md
View file

@ -50,10 +50,10 @@ clojure -M test/conformance/certify.clj test/chez/corpus.edn --edn /tmp/report.e
## Current state
Of ~2487 vanilla-certifiable rows, **>2410 match reference Clojure exactly**; the
~70 divergences are all classified (deliberate deltas + 4 tracked bugs). The corpus
is trustworthy as a spec, with the host-specific deltas made explicit rather than
hidden.
Of ~2740 vanilla-certifiable rows, **>2730 match reference Clojure exactly**; the
handful of divergences are all classified (deliberate deltas plus a few tracked
bugs). The corpus is trustworthy as a spec, with the host-specific deltas made
explicit rather than hidden.
## Adding / changing cases

4
test/conformance/SPEC.md
View file

@ -42,7 +42,7 @@ the canonical, frozen contract**: it is what every runtime consumes, what
Historically every `:expected` was hand-written. `certify.clj` removes that
weakness: it evaluates every `:actual` (and `:expected`) on **JVM Clojure** in a
fresh `user` namespace and checks jolt's `:expected` against what real Clojure
produces. Of ~2740 vanilla-certifiable rows, **>2660 match reference Clojure
produces. Of ~2740 vanilla-certifiable rows, **>2730 match reference Clojure
exactly**. The rest are classified (see below) — none are silently wrong.
```sh
@ -62,7 +62,7 @@ each **non-portable** case by the feature it requires. Cases *not* in the profil
are **portable** — they must pass on any faithful Clojure.
A runtime's **conformance level** = portable cases + the feature families it
implements. Current profile (≈2670 portable, ≈249 non-portable):
implements. Current profile (≈2735 portable, ≈167 non-portable):
| Feature | Meaning |
|---------|---------|

3
test/conformance/certify.clj
View file

@ -1,4 +1,4 @@
;; certify.clj (jolt-xsfe) — certify the jolt corpus against reference JVM Clojure.
;; certify.clj — certify the jolt corpus against reference JVM Clojure.
;;
;; The corpus (test/chez/corpus.edn) carries hand-written :expected values. This
;; script runs each row's :actual and :expected through REAL JVM Clojure and checks
@ -154,7 +154,6 @@
(defn jvm-error-feature [actual]
(let [a (str/lower-case actual)]
(cond
(re-find #"janet" a) :host/janet
(re-find #"chan|>!|<!|go-loop|\(go |alts!|core\.async" a) :async/core-async
(re-find #"load-string|\beval\b|read-string.*eval" a) :runtime/eval
(re-find #"-array|into-array|to-array|aget|aset|aclone|alength" a) :host/arrays

16
test/conformance/known-divergences.edn
View file

@ -1,10 +1,8 @@
{:doc
"Rows of test/chez/corpus.edn whose :expected differs from reference JVM Clojure. The corpus is JVM-sourced (regen-corpus.clj), so this list is only the rows whose JVM value is an opaque host object that cannot round-trip to readable source — Java arrays, transients, atoms, beans, proxies, and chunks print as #object[..@addr] with a per-run identity — plus the (fn* foo) strictness case and a few racy concurrency cases (:flaky). For those the corpus keeps jolt's value. certify.clj gates on NEW (unlisted) divergences and STALE entries. Keyed by [suite label].",
"Rows of test/chez/corpus.edn whose :expected differs from reference JVM Clojure. The corpus is JVM-sourced (regen-corpus.clj), so this list is only the rows whose JVM value is an opaque host object that cannot round-trip to readable source — Java arrays, transients, atoms, beans, proxies, and chunks print as #object[..@addr] with a per-run identity — plus the (fn* foo) strictness case. For that the corpus keeps jolt's value. certify.clj gates on NEW (unlisted) divergences and STALE entries. Keyed by [suite label].",
:legend
{:numeric-model
"jolt has a numeric tower (exact integer / Ratio / double); no BigDecimal",
:concurrency-model
"Janet isolated-heap snapshot futures/agents/pmap; atoms snapshot, not shared",
:host-model
"no JVM host: classes->name strings, type->symbol, *in* is a map, inline-impl extenders, duck-typed with-open close",
:reader-model
@ -19,18 +17,6 @@
[{:suite "forms / fn",
:label "no param vector",
:category :strictness}
;; racy: agent send / future-cancel observe state that the action thread may or
;; may not have reached yet, so the JVM value is nondeterministic run-to-run.
{:suite "state / agents (synchronous shim)", :label "send applies",
:category :concurrency-model, :flaky true}
{:suite "state / agents (synchronous shim)", :label "send-off applies",
:category :concurrency-model, :flaky true}
{:suite "clojure.core / futures — predicates",
:label "cancel an in-flight future returns true",
:category :concurrency-model, :flaky true}
{:suite "clojure.core / futures — predicates",
:label "future-cancelled? after cancel",
:category :concurrency-model, :flaky true}
{:suite "io / cold tagged types via print-method",
:label "atom override fires nested",
:category :reader-model}

367
test/conformance/profile.edn
View file

@ -1,73 +1,53 @@
{:doc
"Conformance profile for test/chez/corpus.edn, generated by certify.clj. Each entry is a NON-portable case (keyed by [suite label]) and the host feature(s) it requires. Cases NOT listed are portable — they pass on any faithful Clojure. A runtime's conformance LEVEL = portable + the feature families it implements. See SPEC.md.",
:clojure-version "1.12.5",
:portable-count 2674,
:non-portable-count 246,
:portable-count 2735,
:non-portable-count 167,
:feature-counts
{:concurrency/snapshot 5,
:host/arrays 12,
:host/janet 16,
:host/jvm-interop 174,
:impl/representation 1,
:numerics/double-only 17,
{:host/arrays 10,
:host/jvm-interop 149,
:perf/unbounded 1,
:printer/jolt 4,
:reader/jolt 13,
:strictness/jolt 3},
:printer/jolt 2,
:reader/jolt 4,
:strictness/jolt 1},
:entries
[{:suite "*ns* / identity & printing",
:label "tracks in-ns",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.core / futures — predicates",
:label "cancel an in-flight future returns true",
:bucket :divergent,
:features [:concurrency/snapshot]}
{:suite "clojure.core / futures — snapshot (copy) semantics",
:label "captured atom is snapshotted, not shared",
:bucket :divergent,
:features [:concurrency/snapshot]}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)",
:label "bigdec",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)",
:label "supers empty set",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.core / pmap family",
:label "snapshot semantics",
:bucket :divergent,
:features [:concurrency/snapshot]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "PI",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "floor",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "pow",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "round",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "signum",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "sqrt",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "tan of 0",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "clojure.math (jolt-h79)",
{:suite "clojure.math",
:label "to-radians",
:bucket :jvm-error,
:features [:host/jvm-interop]}
@ -91,11 +71,6 @@
:label "try multi-body last",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite
"conformance / native-op parity (compile emits janet ops at guarded arities)",
:label "native unary div",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "conformance / try / catch",
:label "ex-data",
:bucket :jvm-error,
@ -108,14 +83,6 @@
:label "try catch",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "core / extenders",
:label "lists extended type",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "core / extenders",
:label "seq of tags",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "core / with-open",
:label "binding visible",
:bucket :jvm-error,
@ -124,10 +91,6 @@
:label "body result",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "core / with-open",
:label "close on throw",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "core / with-open",
:label "close runs",
:bucket :jvm-error,
@ -220,22 +183,6 @@
:label "global underive",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "host-interop / bake env scrub",
:label "full snapshot filtered to the allowlist",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "host-interop / bake env scrub",
:label "listed name still reads",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "host-interop / bake env scrub",
:label "unlisted name reads nil under the allowlist",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "host-interop / class tokens & readers",
:label "class name evaluates to canonical string",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "host-interop / class tokens & readers",
:label "dispatch-only class name",
:bucket :jvm-error,
@ -256,10 +203,6 @@
:label "HashMap put + size",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "host-interop / exception + HashMap shims",
:label "getMessage on a thrown string",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "host-interop / migratus class shims",
:label "Timestamp is millis",
:bucket :jvm-error,
@ -332,10 +275,6 @@
:label "String/valueOf nil",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "interop / StringReader & StringBuilder",
:label "line-seq over file reader",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / StringReader & StringBuilder",
:label "mark/reset",
:bucket :jvm-error,
@ -360,30 +299,6 @@
:label "method with args",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "interop / janet bridge",
:label "janet.os/clock is a number",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / janet bridge",
:label "janet.string module fn",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / janet bridge",
:label "jolt vector crosses as a janet table",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / janet bridge",
:label "module fn janet.<mod>/<name>",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / janet bridge",
:label "root builtin janet/<name>",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / janet bridge",
:label "root builtin janet/type",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / java.time shims",
:label "Instant instance",
:bucket :jvm-error,
@ -424,30 +339,6 @@
:label "withLocale chain",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "interop / jolt.interop",
:label "janet-type keyword",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / jolt.interop",
:label "janet-type list",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / jolt.interop",
:label "janet-type number",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / jolt.interop",
:label "janet-type quoted list",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "interop / jolt.interop",
:label "janet-type string",
:bucket :jvm-error,
:features [:host/janet]}
{:suite "io / *in* + with-in-str + read-line",
:label "*in* is bound",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "io / cold tagged types via print-method",
:label "atom override fires nested",
:bucket :divergent,
@ -480,18 +371,6 @@
:label "StringWriter accumulates",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "io / print-method multimethod",
:label "defmethod fires nested in a map",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "io / print-method multimethod",
:label "defmethod fires through prn",
:bucket :divergent,
:features [:printer/jolt]}
{:suite "io / print-method multimethod",
:label "defmethod overrides a record, top level",
:bucket :divergent,
:features [:printer/jolt]}
{:suite "io / print-method multimethod",
:label "direct builtin override",
:bucket :jvm-error,
@ -507,7 +386,7 @@
{:suite "io / slurp, spit, printf, flush (host-classified)",
:label "file-seq finds files",
:bucket :jvm-error,
:features [:host/janet]}
:features [:host/jvm-interop]}
{:suite "macros / core-overlay",
:label "assert message",
:bucket :jvm-error,
@ -520,22 +399,10 @@
:label "condp no match",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "macros / defmacro",
:label "macroexpand-1",
:bucket :divergent,
:features [:impl/representation]}
{:suite "macros / time, with-redefs, macroexpand",
:label "with-redefs restores on throw",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "maps / literal construction",
:label "source order through syntax-quote",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "metadata / def metadata",
:label "^Type tag on var",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "metadata / type hints",
:label "symbol hint -> :tag",
:bucket :divergent,
@ -568,42 +435,6 @@
:label "require :as registers the alias",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "numbers / arithmetic",
:label "divide to fraction",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / literal syntax",
:label "bigdec int M",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / literal syntax",
:label "bigdec suffix M",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / literal syntax",
:label "neg ratio",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / literal syntax",
:label "ratio -> double",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / literal syntax",
:label "ratio 3/4",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / printing of inf & nan",
:label "inf inside coll",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "numbers / printing of inf & nan",
:label "pr-str Infinity",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "predicates / compare, type, any? (stage 3)",
:label "type of record",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "predicates / overlay-migrated",
:label "keyword-identical?",
:bucket :jvm-error,
@ -620,54 +451,14 @@
:label "undefined?",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "predicates / tagged-value (Phase 4)",
{:suite "predicates / tagged-value",
:label "atom? no",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "predicates / tagged-value (Phase 4)",
{:suite "predicates / tagged-value",
:label "atom? yes",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "predicates / tagged-value (Phase 4)",
:label "chunked-seq? always false",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "reader / dispatch & sugar",
:label "reader cond :jolt",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "reader / dispatch & sugar",
:label "reader cond no match",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "reader / dispatch & sugar",
:label "reader cond splice",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "reader / dispatch & sugar",
:label "reader cond splice no match",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "reader / dispatch & sugar",
:label "reader conditional",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "reader / scalar literals",
:label "bigdec suffix M",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "reader / scalar literals",
:label "ratio -> double",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)",
:label "bool nested",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)",
:label "nil nested",
:bucket :divergent,
:features [:reader/jolt]}
{:suite "regex / Pattern statics & String regex methods",
:label "Pattern/MULTILINE ^",
:bucket :jvm-error,
@ -708,19 +499,19 @@
:label "re-pattern is regex?",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "set / nil element (jolt-bn2p)",
{:suite "set / nil element",
:label "transient conj! nil",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "set / nil element (jolt-bn2p)",
{:suite "set / nil element",
:label "transient contains? nil",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "set / nil element (jolt-bn2p)",
{:suite "set / nil element",
:label "transient disj! nil cnt",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "set / nil element (jolt-bn2p)",
{:suite "set / nil element",
:label "transient disj! removes",
:bucket :jvm-error,
:features [:host/jvm-interop]}
@ -744,14 +535,6 @@
:label "sorted-set? true",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "state / agents (synchronous shim)",
:label "send applies",
:bucket :divergent,
:features [:concurrency/snapshot]}
{:suite "state / agents (synchronous shim)",
:label "send-off applies",
:bucket :divergent,
:features [:concurrency/snapshot]}
{:suite "state / atoms",
:label "atom? on non-atom",
:bucket :jvm-error,
@ -764,14 +547,6 @@
:label "promise undelivered",
:bucket :timeout,
:features [:perf/unbounded]}
{:suite "transient / assoc! odd args throw",
:label "map dangling key",
:bucket :throws-mismatch,
:features [:strictness/jolt]}
{:suite "transient / assoc! odd args throw",
:label "vector dangling",
:bucket :throws-mismatch,
:features [:strictness/jolt]}
{:suite "transient / set",
:label "conj! dedups",
:bucket :jvm-error,
@ -804,22 +579,6 @@
:label "bean is the map",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "class keyword",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "class number",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "class string",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "definterface defines",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "enumeration-seq",
:bucket :jvm-error,
@ -848,10 +607,6 @@
:label "update-proxy",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "aclone vec",
:bucket :jvm-error,
:features [:host/arrays]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "aset-boolean",
:bucket :jvm-error,
@ -884,58 +639,10 @@
:label "aset-short",
:bucket :jvm-error,
:features [:host/arrays]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "boolean-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "double-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "float-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "int-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "into-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "long-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "make-array",
:bucket :jvm-error,
:features [:host/arrays]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "short-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / array stubs (vectors + host buffers)",
:label "to-array",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / chunk family (eager equivalents) + cat",
:label "chunk round-trip",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / ns + REPL machinery",
:label "*in* bound",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / ns + REPL machinery",
:label "ns-imports empty user",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / primed + division + bit ops",
:label "/ ratio-as-double",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "untested / protocols: extend + extends?",
:label "extend registers",
:bucket :jvm-error,
@ -964,22 +671,6 @@
:label "chars first",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "untested / typed coercion views",
:label "double",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "untested / typed coercion views",
:label "doubles",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "untested / typed coercion views",
:label "float",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "untested / typed coercion views",
:label "floats",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "untested / typed coercion views",
:label "ints",
:bucket :jvm-error,
@ -991,16 +682,4 @@
{:suite "untested / typed coercion views",
:label "shorts",
:bucket :jvm-error,
:features [:host/jvm-interop]}
{:suite "untested / unchecked-* are plain ops",
:label "unchecked-char",
:bucket :divergent,
:features [:host/jvm-interop]}
{:suite "untested / unchecked-* are plain ops",
:label "unchecked-double",
:bucket :divergent,
:features [:numerics/double-only]}
{:suite "untested / unchecked-* are plain ops",
:label "unchecked-float",
:bucket :divergent,
:features [:numerics/double-only]}]}
:features [:host/jvm-interop]}]}

2
test/conformance/regen-corpus.clj
View file

@ -43,7 +43,7 @@
(clojure.core/refer-clojure)
;; make the stdlib namespaces a corpus case may reference by qualified name
;; resolvable (clojure.math/floor etc.) so they evaluate to the real JVM
;; value instead of throwing Unable-to-resolve (-> kept Janet value).
;; value instead of throwing Unable-to-resolve (-> existing :expected kept).
(doseq [n '[clojure.string clojure.set clojure.walk clojure.edn
clojure.math clojure.pprint]]
(try (require n) (catch Throwable _ nil)))