jolt/stdlib/clojure/sci/host_stubs.clj
Yogthos 33eff7c7d8 Clean up codebase: rename stdlib layer, strip porting residue, fix tooling
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.
2026-06-22 22:18:00 -04:00

49 lines
1.5 KiB
Clojure

;; Forward-declaration stubs for SCI's host-layer modules.
;;
;; sci.impl.{parser,read,load,macroexpand,resolve,proxy,reify} implement SCI's
;; reader, loader, macroexpander and JVM proxy/reify support. On the JVM those
;; lean on tools.reader, java.io and reflection; Jolt has its own native
;; reader/loader, so rather than load SCI's host implementation we provide just
;; the var names that sci.impl.namespaces references when it builds the
;; clojure.core binding map. The map is built at load time but these are only
;; *called* through SCI's own runtime, which Jolt replaces — so no-op
;; placeholders are sufficient. (They must be non-nil so `:refer` re-interns
;; them: interning a nil-valued var drops the binding.)
(ns sci.impl.parser)
(defn parse-next [& _] nil)
(def data-readers {})
(defn default-data-reader-fn [& _] nil)
(defn read-eval [& _] nil)
(defn reader-resolver [& _] nil)
(defn suppress-read [& _] nil)
(ns sci.impl.read)
(defn read [& _] nil)
(defn read-string [& _] nil)
(defn source-logging-reader [& _] nil)
(ns sci.impl.load)
(defn load-string [& _] nil)
(defn load-reader [& _] nil)
(defn add-loaded-lib [& _] nil)
(defn eval-refer [& _] nil)
(defn eval-refer-global [& _] nil)
(defn eval-require [& _] nil)
(defn eval-require-global [& _] nil)
(defn eval-use [& _] nil)
(ns sci.impl.macroexpand)
(defn macroexpand [& _] nil)
(defn macroexpand-1 [& _] nil)
(ns sci.impl.resolve)
(defn resolve-symbol [& _] nil)
(ns sci.impl.proxy)
(defn proxy [& _] nil)
(defn proxy* [& _] nil)
(ns sci.impl.reify)
(defn reify [& _] nil)
(defn reify* [& _] nil)