cb3cfaf0c2
Brings up the seq layer on the Chez runtime. host/chez/seq.ss adds one lazy-capable node (cseq) that models Clojure's list, cons, and lazy seq - all print as (...), all sequential-= to each other and to vectors. seq coerces any seqable (vector/map/set/string/list/seq/nil) to a cseq or nil; the empty seq is a distinct value printing () (rest of a 1-elem coll is () not nil, seq of empty is nil). Leaf ops: first/rest/next/seq/cons/list, reverse/last, map/filter/remove/reduce/into, range/take/drop/concat/apply, keys/vals, plus nth/peek/pop extended over seqs. map/filter/reduce apply their fn arg through jolt-invoke, so a procedure, keyword, or collection all work as the fn. Dynamic IFn dispatch: a keyword/vector/coll held in a local (let binding or fn param) and called as a fn now routes through the jolt-invoke fallback (procedure? -> apply; keyword/coll -> lookup). The emitter only routes a :local callee that isn't a known procedure - a named fn's self-recursion name stays a direct call, so the fib hot path is untouched. Closes the 3 ex-known IFn divergences. emit.janet: seq/pred ops added to native-ops with arity gates; value-position clojure.core refs resolve to the RT procedure (native-ops names one for each), with +/-/*// routed to flonum-coercing wrappers so higher-order arithmetic ((reduce + [])) keeps the all-double model. values.ss: cross-type sequential =/hash so a vector and a list of the same elements are jolt= and hash alike. rt.ss: printer learns seqs; top-level nil prints as the empty string (jolt -e str-style). Fixed latent bug: (conj nil ...) now builds a list, not a vector. Gates: emit-test 69/69 (fib/mandelbrot/collections/seq/IFn parity vs the jolt oracle, fib(30) ~24ms unchanged). Subset probe 433/436 -> 595/595 compiled, 0 divergences (was 3 known), 2060/2655 out of subset. Full run-tests green (125 files, conformance + suites included). |
||
|---|---|---|
| .. | ||
| corpus.edn | ||
| emit-test.janet | ||
| extract-corpus.janet | ||
| known-divergences.edn | ||
| README.md | ||
| run-corpus-chez.janet | ||
| run-corpus.janet | ||
| values-test.ss | ||
Chez port — Phase 0 test contract harness
The host-neutral correctness gate for the Chez re-host (epic jolt-cf1q). The spec corpus is data, so the SAME contract validates every host.
Files
extract-corpus.janet— parsestest/spec/*.janet(defspec …)tables as data and writescorpus.edn(2655[label expected actual]cases). The file is valid as BOTH EDN (a future Chez-jolt runner) and Janet data (the runner below). Regenerate:janet test/chez/extract-corpus.janet.corpus.edn— the extracted contract (generated; checked in for convenience).run-corpus.janet— drives a TARGET jolt binary, one fresh subprocess per case (fresh ctx = per-case isolation), checking(= expected actual)printstrueat the CLI, or that a:throwscase exits non-zero. Pluggable target:janet test/chez/run-corpus.janet# default build/joltJOLT_BIN=build/jolt-chez janet test/chez/run-corpus.janet# Phase 1+JOLT_CORPUS_LIMIT=400 …# every-Nth stride, fast
known-divergences.edn— allowlist of cases that diverge at the CLI boundary. The gate fails only on a NEW divergence; known ones are reported but tolerated.values-test.ss/../../host/chez/values.ss— Phase 0a value model + tests.
The reference baseline (2026-06-17, Janet build/jolt, compile mode)
2641/2655 pass; 14 known divergences. They split into:
- interpret-vs-compile leniency —
:throwscases where interpret mode raises but compile mode returns (< nil,> with nil,neg? keyword,max/min-keyon non-numbers). Several are also non-canonical vs JVM Clojure. - invoke-collection-as-fn — the
transient / invokable lookupsuite invokes transients/collections as fns (((transient {:x 7}) :x)); compile mode (and JVM Clojure) reject it. xml-seq walks— one structural case.
The compile-only Chez host (JVM-canonical oracle) should MATCH OR FIX these. The gate's job is to catch regressions the port introduces, not to bless these.
Why the CLI boundary
The runner tests through jolt -e, exactly how the Chez host will be exercised —
not the in-process eval-string the Janet defspec harness uses. The two differ
on a handful of cases (the allowlist), and the CLI boundary is the portable one.
Phase 1 — first parity number (subset probe)
The full run-corpus.janet gate drives an -e-capable jolt binary; the Chez
host can't answer arbitrary -e until all of clojure.core is bootstrapped onto
Chez (Phase 2). Until then, run-corpus-chez.janet reports parity for the subset
the Phase-1 back end (host/chez/emit.janet) can already compile: each case is
run through the live analyzer → Scheme emitter → Chez via host/chez/driver.
Cases that reference unimplemented stdlib/host fns fail to EMIT (a clean
compile-time signal) and are counted "out of subset", not as divergences.
JOLT_CHEZ_CORPUS=1 janet test/chez/run-corpus-chez.janet
Baseline after inc 3b (seq tier + dynamic IFn, jolt-5pso): 595/595 compiled
cases pass, 0 divergences; 2060/2655 out of subset (await clojure.core on Chez).
The seq tier brought up a list/lazy-seq type with first/rest/next/seq/cons/list,
map/filter/reduce/into/remove, range/take/drop/concat/apply, keys/vals, and
nth/peek/pop over seqs; dynamic IFn dispatch (a keyword/vector/coll held in a
local and called as a fn) now routes through the jolt-invoke fallback, closing
the 3 ex-known divergences. The probe exits non-zero on any NEW divergence.
(Prior, inc 3a: 433/436 compiled, 3 known IFn divergences, 2219 out of subset. Inc 2: 182/182 compiled, 0 divergences, 2473 out of subset.)
It's a slow report (a Chez subprocess per case), so it's gated behind
JOLT_CHEZ_CORPUS out of the default suite, like the benches.
test/chez/emit-test.janet is the fast Phase-1 unit gate (real analyzer → Chez
parity for fib/mandelbrot + collections + regressions); both skip cleanly when
chez isn't on PATH.