Move the Chez test oracle off Janet
The unit tests in test/chez/_*.janet now drive bin/joltc (the zero-Janet spine) and judge against baked expected values instead of a live build/jolt run. Ten of them captured the oracle from build/jolt per case; their values are now literals (one env-dependent javastatic case became a predicate so it stays portable). The rest already had literal expecteds with a redundant build/jolt sanity check, now dropped. Retire emit-test/emit-parity/reader-parity: they compared the Chez/Clojure path against a live Janet evaluation, emitter, or reader. That migration check is done, and run-corpus-zero-janet (Chez analyzer vs the JVM corpus) plus certify.clj cover correctness now. Rewrite the README for the current zero-Janet gate. jolt-5oci
This commit is contained in:
Yogthos
parent
8d4f83e0f7
commit
9a273e71cd
21 changed files with 205 additions and 1510 deletions
|
|
@ -1,248 +1,60 @@
|
|||
# Chez port — Phase 0 test contract harness
|
||||
# Chez test 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.
|
||||
The correctness gate for jolt on Chez (epic jolt-cf1q). Correctness is judged
|
||||
against the JVM-sourced conformance spec — no Janet decides pass/fail. The spec
|
||||
itself lives in `test/conformance/` (see its `SPEC.md`); this directory holds the
|
||||
Chez runners and unit tests.
|
||||
|
||||
## Files
|
||||
- `extract-corpus.janet` — parses `test/spec/*.janet` `(defspec …)` tables as
|
||||
data and writes `corpus.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)` prints `true`
|
||||
at the CLI, or that a `:throws` case exits non-zero. Pluggable target:
|
||||
- `janet test/chez/run-corpus.janet` # default build/jolt
|
||||
- `JOLT_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 spec corpus
|
||||
|
||||
## The reference baseline (2026-06-17, Janet `build/jolt`, compile mode)
|
||||
2641/2655 pass; 14 known divergences. They split into:
|
||||
- **interpret-vs-compile leniency** — `:throws` cases where interpret mode raises
|
||||
but compile mode returns (`< nil`, `> with nil`, `neg? keyword`, `max`/`min-key`
|
||||
on non-numbers). Several are also non-canonical vs JVM Clojure.
|
||||
- **invoke-collection-as-fn** — the `transient / invokable lookup` suite invokes
|
||||
transients/collections as fns (`((transient {:x 7}) :x)`); compile mode (and
|
||||
JVM Clojure) reject it.
|
||||
- **`xml-seq walks`** — one structural case.
|
||||
- `corpus.edn` — the contract: ~2920 rows `{:suite :label :expected :actual}`,
|
||||
with `:expected` sourced from reference JVM Clojure. Valid as both EDN and Janet
|
||||
data. Generated by `test/conformance/regen-corpus.clj` (the answers) over the
|
||||
case list from `extract-corpus.janet` (the `:actual` strings, pulled from
|
||||
`test/spec/*.janet` and `conformance-test.janet`).
|
||||
- `extract-corpus.janet` — re-derives the case list when spec rows change. Writes
|
||||
only when `JOLT_EXTRACT_CORPUS_OUT` is set, so a gate run never clobbers the
|
||||
JVM-sourced `corpus.edn`. After re-deriving, re-source the answers with
|
||||
`regen-corpus.clj`.
|
||||
|
||||
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.
|
||||
## The standing gate
|
||||
|
||||
## 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.
|
||||
`run-corpus-zero-janet.janet` runs every corpus case through the zero-Janet
|
||||
spine: read → analyze → IR → emit → eval, all on Chez (the analyzer is
|
||||
`jolt.analyzer` cross-compiled to Scheme over `host-contract.ss`). Each result is
|
||||
compared by value-equality against the JVM `:expected`. A `known-fail` allowlist
|
||||
covers cases jolt can't match because Chez has no JVM host (Java classes, arrays,
|
||||
`BigDecimal`, opaque host-object printers, …); the gate fails only on a NEW
|
||||
divergence or if the pass count drops below the floor.
|
||||
|
||||
## 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_ZEROJANET_CORPUS=1 janet test/chez/run-corpus-zero-janet.janet
|
||||
JOLT_CORPUS_LIMIT=200 … # every-Nth stride, fast iteration
|
||||
|
||||
JOLT_CHEZ_CORPUS=1 janet test/chez/run-corpus-chez.janet
|
||||
Floor: 2678 (`JOLT_CHEZ_ZJ_FLOOR` overrides). Raise it as host gaps close.
|
||||
|
||||
Baseline after inc 3g (letfn + declare): **672/672 compiled cases pass**, 0
|
||||
divergences; 1986/2658 out of subset (await clojure.core on Chez). Inc 3e
|
||||
(throw/try + ex-info) was 632/632; inc 3f's quote support + a seq.ss fix (empty
|
||||
`map`/`filter` results are `()` not nil, matching Clojure) reached 664/664; inc 3g
|
||||
(letfn -> Scheme `letrec*`, declare/def-no-init -> a reserved var cell) pulled 8
|
||||
more corpus cases into the subset. `emit-fn` lowers multi-arity fns to a Scheme
|
||||
`case-lambda` and variadic fns to a rest-arg lambda (rest list coerced to a jolt
|
||||
seq, nil when empty).
|
||||
## Unit tests
|
||||
|
||||
## Phase 1 — clojure.core prelude emission (inc 3d, jolt-ocvi)
|
||||
The `-e`-capable jolt-chez path: emit the clojure.core tiers
|
||||
(`jolt-core/clojure/core/NN-*.clj`) through the same analyzer → emit pipeline as a
|
||||
Scheme PRELUDE of `def-var!` forms, so user code's `(var-deref "clojure.core" …)`
|
||||
resolves the fn at runtime. `emit/set-prelude-mode!` flips a switch: in the default
|
||||
(subset) mode a non-native `clojure.core` ref is rejected ("out of subset"); in
|
||||
prelude mode it lowers to a runtime `var-deref` so core fns chain through each
|
||||
other. Host interop (`:host`) and unhandled IR ops still error in both modes —
|
||||
those are the real gaps that need a hand-written RT shim or new emit support.
|
||||
`_*.janet` drive `bin/joltc` (the pure-Chez CLI; `JOLT_BIN` overrides) one
|
||||
subprocess per case and compare the last stdout line against a baked expected
|
||||
value. `:throws` asserts a non-zero exit. Each file targets one area —
|
||||
`_type`/`_class`/`_seqpred` (taxonomy + predicates), `_str`/`_strns`/`_reader`
|
||||
(strings + reader), `_io`/`_ioreader`/`_insttime`/`_javastatic` (host interop),
|
||||
`_dynbind`/`_var_meta`/`_ns` (vars + namespaces), `_atomwatch`/`_walk`/`_dotform`
|
||||
/`_stdlib` (refs, walk, dot-forms, stdlib). Run one with
|
||||
`janet test/chez/_type.janet`.
|
||||
|
||||
`core-prelude-probe.janet` (gated behind `JOLT_CHEZ_PRELUDE=1`) measures reach and
|
||||
catalogs the gaps; macros are skipped (analyze-time only, not a runtime value):
|
||||
## Self-host gates
|
||||
|
||||
JOLT_CHEZ_PRELUDE=1 janet test/chez/core-prelude-probe.janet
|
||||
- `spine-test.janet` — the zero-Janet compile/eval spine end to end.
|
||||
- `cli-test.janet` — `bin/joltc -e` behavior.
|
||||
- `bootstrap-test.janet` — `host/chez/bootstrap.ss` rebuilds the prelude + image
|
||||
from source on Chez and matches the checked-in seed (`host/chez/seed/`).
|
||||
- `fixpoint-test.janet` — the on-Chez compiler reproduces itself (stage2 == stage3,
|
||||
prelude pstage3 == pstage4).
|
||||
|
||||
Baseline after inc 3i (regex): **355/355 non-macro core forms emit** to Scheme —
|
||||
the whole non-macro clojure.core now lowers. inc 3i closed the last gap, the regex
|
||||
literal in `parse-uuid`: a `#"…"` literal lowers to a `:regex` IR node and the Chez
|
||||
emitter emits a `jolt-regex` value over **vendored irregex** (Alex Shinn, BSD,
|
||||
`vendor/irregex` submodule) — a portable Scheme regex with PCRE/Java-style string
|
||||
patterns. `re-pattern`/`re-matches`/`re-find`/`re-seq`/`regex?` are `def-var!`'d
|
||||
into clojure.core (`host/chez/regex.ss`); they stay OUT of the subset native-ops
|
||||
(irregex's Unicode/property-class semantics differ from the seed's byte-PEG
|
||||
approximation), so they resolve in prelude mode — the path the assembled prelude
|
||||
takes — without dragging engine-difference divergences into the subset corpus. The
|
||||
Janet back end punts `:regex` to the interpreter (the seed compiles `#"…"` to a
|
||||
Janet PEG). Prior incs: inc 3h `.method` → `:host-call` (`jolt-host-call` for
|
||||
`.write`/`.isDirectory`/`.listFiles`); `:quote`, `:throw`, `:try`, `ex-info`,
|
||||
`letfn` → `letrec*`, `declare`/def-no-init → reserved var cell. The probe has a
|
||||
regression floor (355) — every non-macro core form must keep emitting.
|
||||
## Bench
|
||||
|
||||
## Phase 1 — the assembled prelude: -e-capable jolt-chez (inc 3j, jolt-9ziu)
|
||||
Once the whole non-macro clojure.core emits (inc 3i), the milestone is to ASSEMBLE
|
||||
it: `driver/emit-core-prelude` emits every non-macro core form across the
|
||||
dependency-ordered tiers as a `def-var!` (prelude mode), concatenated into a
|
||||
Scheme prelude. `bin/jolt-chez -e EXPR` loads `rt.ss` + that prelude + a
|
||||
post-prelude override, emits the user expression in prelude mode, and runs it on
|
||||
Chez — an `-e`-capable jolt-chez (analysis on Janet, execution on Chez). The
|
||||
prelude is cached on disk keyed by a fingerprint of the core sources + the RT.
|
||||
`bench-pipeline.janet` (opt-in via `JOLT_CHEZ_BENCH=1`) times fib + mandelbrot
|
||||
through the real pipeline against the spike ceiling. Skipped in the gate.
|
||||
|
||||
`run-corpus-prelude.janet` is the full parity gate this opens (the prelude-backed
|
||||
sibling of `run-corpus-chez.janet`): it assembles the prelude once, then runs every
|
||||
corpus case with all of core present, bucketing the result —
|
||||
|
||||
JOLT_CHEZ_PRELUDE_CORPUS=1 janet test/chez/run-corpus-prelude.janet
|
||||
JOLT_CORPUS_LIMIT=200 … (every-Nth stride, fast)
|
||||
|
||||
Parity baseline: inc 3j **1220/2497**; 3k (converters, jolt-t6cr) **1326**;
|
||||
3l (transients, jolt-kl2l) **1382**; 3m (numeric-edge emit + variadic assoc!,
|
||||
jolt-q3w8) **1407/2497**, 0 NEW divergences (14 allowlisted:
|
||||
dynamic vars `*ns*`/`*clojure-version*`/`*unchecked-math*`, var/`*ns*` rendering,
|
||||
class names, eval-order, with-open — all deferred Phase-2 / dynamic-var gaps).
|
||||
- inc 3k `host/chez/converters.ss`: `str`/`subs`/`vec`/`keyword`/`symbol`/`compare`/
|
||||
`int`/`double`/`gensym` (seed natives — `str` reuses the printer, `compare` is the
|
||||
3-way port, the symbol no-ns sentinel is `#f` to match emit's quoted-symbol
|
||||
lowering so `(= 'x (symbol "x"))` holds).
|
||||
- inc 3l `host/chez/transients.ss`: `transient`/`persistent!`/`conj!`/`assoc!`/
|
||||
`dissoc!`/`disj!`/`pop!` as copy-on-write over the persistent collections (correct
|
||||
semantics, no in-place perf), plus persistent `disj`. `get`/`count`/`contains?`
|
||||
are redefined to see THROUGH a transient (frequencies/group-by do `(get tm k)` on a
|
||||
transient map); `vector?` on a transient vector is false, which group-by relies on.
|
||||
|
||||
- inc 3m: `##Inf`/`##-Inf`/`##NaN` emitted to bare `inf`/`nan` (unbound in Chez);
|
||||
emit-const now lowers them to `+inf.0`/`-inf.0`/`+nan.0`, the `-e` printer renders
|
||||
`inf`/`-inf`/`nan` and `str` renders `Infinity`/`-Infinity`/`NaN` (Clojure). Plus
|
||||
variadic `assoc!`. (`str` of inf *inside a collection* still wants the long form —
|
||||
the Phase-2 recursive str renderer — so `[inf inside coll]` is allowlisted.)
|
||||
- inc 3n `host/chez/natives-seq.ss` (jolt-y6mv): the dominant prelude-parity crash
|
||||
bucket was `apply non-procedure jolt-nil` — core fns calling seed-native seq fns
|
||||
(`src/jolt/core_coll.janet`) that have no Chez shim, so `var-deref` yields
|
||||
jolt-nil. A static scan of the assembled prelude found 52 referenced-but-undefined
|
||||
`clojure.core` names; this increment shims the safe, high-value seq fns: `mapcat`/
|
||||
`take-while`/`drop-while`/`partition` (collection arities — the 1-arg transducer
|
||||
forms are jolt-kxsr), `sort` (compare default; a comparator may return a 3-way
|
||||
number or a boolean less-than), and `reduced`/`reduced?` — a `jolt-reduced` record
|
||||
in `seq.ss` that `reduce` short-circuits on and `deref` unwraps (so `unreduced`
|
||||
works). `identical?` = `jolt=` (the seed's definition). `list?` was deferred: a
|
||||
Chez lazy seq and a list are both `cseq`, so it can't be told apart without a
|
||||
distinct list type (a real divergence risk).
|
||||
- inc 3o transducer arities (jolt-kxsr): the 1-arg `map`/`filter`/`remove`/`take`/
|
||||
`drop`/`take-while`/`drop-while`/`mapcat` return a transducer `(fn [rf] rf')`, and
|
||||
`into` gets a 3-arg `(into to xform from)`. These were the `cdr () is not a pair` /
|
||||
`incorrect number of arguments` crash bucket: the emitter lowers `(map f)` /
|
||||
`(into to xf from)` at the wrong arity to the bare native procedure (the
|
||||
value-position path), so the fix is RT-side — `case-lambda` the seq procedures and
|
||||
`jolt-into`. The `td-*` factories are ported from the seed (core_coll.janet); a
|
||||
`reduced` step stops the fold via reduce-seq's short-circuit. `transduce`/`comp`/
|
||||
`completing` are overlay and compose over these for free.
|
||||
- inc 3p misc seq/regex gaps (jolt-y1zq): 0-arg `(conj)` -> `[]`, 0-arg `(conj!)` ->
|
||||
a fresh transient vector, `nth` sees through a transient (like get/count/contains?),
|
||||
and irregex `\p{...}`/`\P{...}` property classes translate to the seed's ASCII char
|
||||
classes (regex.ss; `\p{L}`->`[a-zA-Z]`, `\p{N}`->`[0-9]`, `\p{Ps}`->`[([{]`, …) —
|
||||
ASCII-only (the seed counts UTF-8 high bytes as letters, which a Unicode-char Scheme
|
||||
string can't reproduce; the corpus tests ASCII, where they agree) and
|
||||
`clojure.math/PI` (missing ns).
|
||||
|
||||
Two pre-existing bugs surfaced here, since fixed (inc 3x / 3y below).
|
||||
- inc 3q multimethod dispatch + late-bind (jolt-9ls5, Phase 2): `host/chez/
|
||||
multimethods.ss` implements the multimethod runtime — `defmulti`/`defmethod`
|
||||
expand to `defmulti-setup`/`defmethod-setup` calls (+ `get-method`/`methods`/
|
||||
`remove-method`/`prefer-method`/`prefers`). A `jolt-multifn` record carries its
|
||||
dispatch fn and a `jolt=`-keyed method table; `jolt-invoke` dispatches it (exact
|
||||
match, then isa?/hierarchy with `prefer-method`, then `:default`), reusing the
|
||||
overlay's `isa?`/`derive`/`make-hierarchy`. The multifn's ns is set via a runtime
|
||||
`chez-current-ns` (default "user"; the prelude load sets "clojure.core").
|
||||
|
||||
Two emit-side changes made this work:
|
||||
- **late-bind** (`:late-bind-unresolved?` ctx flag, default OFF): `defmulti`
|
||||
expands to a bare-symbol setup *call*, so the analyzer doesn't intern the name
|
||||
and a forward reference (`(area …)` after `(defmulti area …)` in one form) was
|
||||
"Unable to resolve symbol". The strict compiler punts these to the interpreter;
|
||||
the Chez back end has none, so the flag makes an unresolved symbol lower to a
|
||||
`var-ref` against the compile ns — the open-world semantics of `-e`. Set only by
|
||||
the Chez `make-ctx`/`jolt-chez`; the main compiler keeps its strict behavior.
|
||||
- a `:var` call head now routes through `jolt-invoke` (not a direct application),
|
||||
since a late-bound var can hold a multifn (or a keyword/coll IFn), not just a
|
||||
procedure. Transparent for procedures; the hot self-recursive call is a `:local`
|
||||
known-proc, so it stays direct. (Class-based dispatch — `(class x)`/`String` — is
|
||||
deferred; it needs the deftype/class subsystem.)
|
||||
- inc 3r dynamic-var constants (jolt-9ls5): `host/chez/dynamic-vars.ss` binds the seed
|
||||
natives `*clojure-version*` (the `{:major 1 :minor 11 …}` map) and `*unchecked-math*`
|
||||
(false), removing their two parity allowlist entries. `*ns*` is deferred (jolt-b4kl):
|
||||
it needs a namespace value that is not a map (`map?` false) yet answers
|
||||
`(get ns :name)` for the overlay `ns-name`, plus `str`/`find-ns` support.
|
||||
- inc 3x non-ASCII string literals (jolt-x0os): `emit.janet`'s `chez-str-lit` replaces
|
||||
the `%j` string encoder. Janet's `%j` renders a non-ASCII char as raw UTF-8 bytes
|
||||
(`\xC3\xA9`) and a control char / DEL as `\xHH` with NO terminating semicolon — both
|
||||
forms Chez's reader rejects. `chez-str-lit` UTF-8-decodes each char and emits a
|
||||
codepoint hex escape `\x<cp>;` (`é`->`\xe9;`, `日`->`\x65e5;`), keeping `\n`/`\t`/`\r`/
|
||||
`\"`/`\\` and being byte-identical to `%j` for printable ASCII. Applied to every
|
||||
string-content site (string/keyword/symbol/var-name/regex-source). This unblocks the
|
||||
`p{L} utf-8` corpus case (the `\p{L}` translation was already correct). Note: `count`/
|
||||
`subs`/`nth` over a multibyte string index by BYTES in the seed but by codepoints on
|
||||
Chez — a separate semantic gap, not addressed here.
|
||||
- inc 3y seed assoc! odd-args (jolt-ea9k): `core-assoc!` (src/jolt/core_extra.janet) now
|
||||
throws on an odd key/val count, like plain `assoc` and Clojure's `assoc!` — the former
|
||||
lenient nil-fill was non-Clojure and inconsistent with the seed's own `assoc`. The 4
|
||||
`assoc! odd args` spec rows became 3 `:throws` + 1 even-args positive; corpus.edn
|
||||
regenerated. The Chez host already threw, so this only realigns the corpus contract.
|
||||
- Phase 1 close-out (jolt-nkcb): truthy? elision + end-to-end compute bench. `emit.janet`
|
||||
now drops the redundant `jolt-truthy?` wrapper on an `:if` test that provably yields a
|
||||
Scheme boolean (a native comparison/`not`, or a boolean const) — sound because
|
||||
`jolt-truthy?` of `#t`/`#f` is identity; the hot fib/mandelbrot tests are all
|
||||
comparisons, so this is a direct ceiling lever (fib 30 end-to-end 24.0 -> 14.4 ms).
|
||||
`bench-pipeline.janet` (JOLT_CHEZ_BENCH=1, opt-in) times fib(30) + mandelbrot(200)
|
||||
through the real pipeline vs the spike ceiling: mandelbrot 87 ms runs AT the
|
||||
generic-flonum ceiling (98 ms); fib is 2x its hand-flonum ceiling, the residual being
|
||||
jolt's all-double number model (typed fl*/fx* emission = Phase 4). Compile-only is
|
||||
total for the compute subset (every form emits; Chez has no interpreter fallback).
|
||||
|
||||
The remaining buckets are the punch-list the next increments chase: ~361 emit-fail
|
||||
(genuine host interop — qualified Java/Janet refs, runtime `defmacro`/`eval`, out of
|
||||
the analyzer's subset) and the runtime crashes still dominated by `apply jolt-nil`
|
||||
(more host-coupled natives without a shim: `meta`/`with-meta`, `format`, the
|
||||
`clojure.string` natives, bit ops, `var`/`volatile`/`future`/thread-binding ops),
|
||||
plus the small jolt-y1zq tail (0-arg `conj`, `\p{}` regex classes, a few one-offs)
|
||||
and multimethod dispatch (Phase 2 jolt-9ls5).
|
||||
|
||||
Two host shims landed with the prelude. `host/chez/atoms.ss`: atom/deref/swap!/
|
||||
reset! (+ compare-and-set!/swap-vals!/reset-vals!) — host-coupled mutable cells the
|
||||
overlay assumes are native; needed at the prelude's LOAD time
|
||||
(`global-hierarchy = (atom (make-hierarchy))`). `host/chez/predicates.ss`: the type
|
||||
predicates + `name`/`namespace`/`boolean` the overlay assumes are seed natives
|
||||
(`nil?`/`number?`/`string?`/`map?`/`vector?`/`set?`/`seq?`/`coll?`/`fn?`/…), matching
|
||||
the seed's strict semantics. `host/chez/post-prelude.ss` re-asserts `char?`/`atom?`
|
||||
AFTER the prelude — the overlay implements those two by reading a value's
|
||||
`:jolt/type` key (a Janet-host assumption that's false for Chez-native chars/atoms),
|
||||
and its `def-var!` would otherwise clobber the correct native shims.
|
||||
|
||||
The 8 print-method/print-dup `defmulti`/`defmethod` forms (50-io) can't LOAD yet
|
||||
(no multimethod runtime on Chez — Phase 2); a silent load guard in the assembled
|
||||
prelude lets the rest load and turns them into lazy gaps.
|
||||
|
||||
Prior, inc 3b (seq tier + dynamic IFn, jolt-5pso): 595/595 compiled, 0 divergences,
|
||||
2060/2655 out of subset. 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) 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.
|
||||
All Chez runners skip cleanly when `chez` is not on PATH.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue