refactor: registry pattern for jolt-pr-str/pr-readable + remaining arms (jolt-lmot)

The printer's two entry points (jolt-pr-str in rt.ss, jolt-pr-readable in printing.ss)
get register-pr-str-arm! / register-pr-readable-arm!, plus register-pr-arm! for the
types whose str and readable forms match (bigdec/inst/uuid/tagged/record/ns/var). The
normalize arms (sorted, lazy-seq, queue) and the uri readable arm register per-printer.
Also folds in the hash (dyn-binding var-cell), class (io uri/uuid/file), and get
(transients) arms missed earlier.

natives-array's get stays a case-lambda wrapper on purpose: its 2-arg path errors on
an out-of-bounds index while the 3-arg path returns the default, an arity distinction
the (coll k d) registry collapses — left as-is to preserve behaviour.

Completes jolt-lmot: all six dispatchers (hash/class/get/=/pr-str/pr-readable) off the
set!-rebind chains. make test green, 0 new corpus divergences; pr-str/str of inst,
uuid, bigdec, sorted-map, record-with-lazyseq, queue all verified.

host/chez/bigdec.ss

@@ -66,10 +66,7 @@
 
 ;; str drops the M; pr/pr-str keep it.
 (register-str-render! jbigdec? jbigdec->string)
-(define %bd-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (jbigdec? x) (string-append (jbigdec->string x) "M") (%bd-pr-str x))))
-(define %bd-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jbigdec? x) (string-append (jbigdec->string x) "M") (%bd-pr-readable x))))
+(register-pr-arm! jbigdec? (lambda (x) (string-append (jbigdec->string x) "M")))
 
 ;; class / decimal?
 (register-class-arm! jbigdec? (lambda (x) "java.math.BigDecimal"))

host/chez/dyn-binding.ss

@@ -132,12 +132,7 @@
 ;; var-cell keys hash/compare by ns/name (jolt=2 in vars.ss already compares
 ;; ns/name) — stable under root mutation, so a var works as a map key (with-redefs
 ;; builds (hash-map (var f) v); get-thread-bindings returns a var-keyed map).
-(define %dyn-hash jolt-hash)
-(set! jolt-hash
-  (lambda (x)
-    (if (var-cell? x)
-        (equal-hash (cons (var-cell-ns x) (var-cell-name x)))
-        (%dyn-hash x))))
+(register-hash-arm! var-cell? (lambda (x) (equal-hash (cons (var-cell-ns x) (var-cell-name x)))))
 
 ;; --- bind the host seams the overlay references -----------------------------
 (def-var! "clojure.core" "push-thread-bindings" jolt-push-thread-bindings)

host/chez/host-table.ss

@@ -153,10 +153,9 @@
 (define (sorted-render x render)
   (if (htable-sorted-map? x) (sorted-map-render x render) (sorted-set-render x render)))
 
-(define %h-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (htable-sorted? x) (sorted-render x jolt-pr-readable) (%h-pr-readable x))))
-(define %h-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (htable-sorted? x) (sorted-render x jolt-pr-str) (%h-pr-str x))))
+;; sorted colls render in :seq order via the calling printer (str vs readable).
+(register-pr-readable-arm! htable-sorted? (lambda (x) (sorted-render x jolt-pr-readable)))
+(register-pr-str-arm! htable-sorted? (lambda (x) (sorted-render x jolt-pr-str)))
 (register-str-render! htable-sorted? (lambda (x) (sorted-render x jolt-str-render-one)))
 
 ;; --- protocol dispatch over builtins (extend-protocol Map/Set on sorted) ------

host/chez/inst-time.ss

@@ -244,10 +244,7 @@
 (register-hash-arm! jinst? (lambda (x) (jolt-hash (jinst-ms x))))
 
 (define (inst-pr i) (string-append "#inst \"" (inst-rfc3339 i) "\""))
-(define %it-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (jinst? x) (inst-pr x) (%it-pr-str x))))
-(define %it-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jinst? x) (inst-pr x) (%it-pr-readable x))))
+(register-pr-arm! jinst? inst-pr)
 (register-str-render! jinst? inst-rfc3339)
 
 (define %it-type jolt-type)

host/chez/io.ss

@@ -487,17 +487,9 @@
 ;; str / pr-str of a uri -> its string form.
 (register-str-render! (lambda (x) (and (jhost? x) (string=? (jhost-tag x) "uri")))
                       (lambda (x) (uri-field x 'string)))
-(define %uri-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable
-  (lambda (x) (if (and (jhost? x) (string=? (jhost-tag x) "uri"))
-                  (string-append "#object[java.net.URI \"" (uri-field x 'string) "\"]")
-                  (%uri-pr-readable x))))
+(register-pr-readable-arm! (lambda (x) (and (jhost? x) (string=? (jhost-tag x) "uri")))
+                           (lambda (x) (string-append "#object[java.net.URI \"" (uri-field x 'string) "\"]")))
 ;; class of the host value types defined by now (uri/uuid/file).
-(define %uri-class jolt-class)
-(set! jolt-class
-  (lambda (x)
-    (cond ((and (jhost? x) (string=? (jhost-tag x) "uri")) "java.net.URI")
-          ((juuid? x) "java.util.UUID")
-          ((jfile? x) "java.io.File")
-          (else (%uri-class x)))))
-(def-var! "clojure.core" "class" jolt-class)
+(register-class-arm! (lambda (x) (and (jhost? x) (string=? (jhost-tag x) "uri"))) (lambda (x) "java.net.URI"))
+(register-class-arm! juuid? (lambda (x) "java.util.UUID"))
+(register-class-arm! jfile? (lambda (x) "java.io.File"))

host/chez/lazy-bridge.ss

@@ -65,10 +65,9 @@
 (set! jolt-nth (case-lambda
   ((coll i)   (if (jolt-lazyseq? coll) (%ls-nth (jolt-seq coll) i)   (%ls-nth coll i)))
   ((coll i d) (if (jolt-lazyseq? coll) (%ls-nth (jolt-seq coll) i d) (%ls-nth coll i d)))))
-(define %ls-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (jolt-lazyseq? x) (%ls-pr-str (jolt-seq x)) (%ls-pr-str x))))
-(define %ls-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jolt-lazyseq? x) (%ls-pr-readable (jolt-seq x)) (%ls-pr-readable x))))
+;; a lazy seq prints as its realized seq — force, then re-dispatch through the printer.
+(register-pr-str-arm! jolt-lazyseq? (lambda (x) (jolt-pr-str (jolt-seq x))))
+(register-pr-readable-arm! jolt-lazyseq? (lambda (x) (jolt-pr-readable (jolt-seq x))))
 (register-str-render! jolt-lazyseq? (lambda (x) (jolt-str-render-one (jolt-seq x))))
 
 ;; seq? — a lazy seq IS a seq (predicates.ss's jolt-seq? predates the lazyseq

host/chez/natives-misc.ss

@@ -53,10 +53,7 @@
 ;; str of a uuid -> the bare 36-char string; pr-str -> #uuid "…".
 (register-str-render! juuid? juuid-s)
 (define (juuid-pr u) (string-append "#uuid \"" (juuid-s u) "\""))
-(define %m-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (juuid? x) (juuid-pr x) (%m-pr-str x))))
-(define %m-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (juuid? x) (juuid-pr x) (%m-pr-readable x))))
+(register-pr-arm! juuid? juuid-pr)
 ;; two uuids are = iff same string.
 (register-eq-arm! (lambda (a b) (or (juuid? a) (juuid? b)))
                   (lambda (a b) (and (juuid? a) (juuid? b) (string=? (juuid-s a) (juuid-s b)))))
@@ -83,10 +80,7 @@
           ((jolt=2 k kw-tl-form) (jtagged-form coll))
           (else d))))
 (define (jtagged-pr t) (string-append "#" (jolt-pr-str (jtagged-tag t)) " " (jolt-pr-readable (jtagged-form t))))
-(define %m2-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (jtagged? x) (jtagged-pr x) (%m2-pr-str x))))
-(define %m2-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jtagged? x) (jtagged-pr x) (%m2-pr-readable x))))
+(register-pr-arm! jtagged? jtagged-pr)
 (def-var! "clojure.core" "tagged-literal" jolt-tagged-literal)
 ;; tagged-literal? is OVERLAY (reads :jolt/type) — asserted in post-prelude.ss.
 

host/chez/natives-queue.ss

@@ -44,8 +44,7 @@
 
 ;; printing: render the elements as a parenthesized list (delegate to the seq path).
 (define (jolt-seq-or-empty x) (let ((s (jolt-seq x))) (if (jolt-nil? s) jolt-empty-list s)))
-(define %q-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jolt-queue? x) (%q-pr-readable (jolt-seq-or-empty x)) (%q-pr-readable x))))
+(register-pr-readable-arm! jolt-queue? (lambda (x) (jolt-pr-readable (jolt-seq-or-empty x))))
 (register-str-render! jolt-queue? (lambda (x) (jolt-str-render-one (jolt-seq-or-empty x))))
 
 ;; class / type / instance? recognize a queue.

host/chez/ns.ss

@@ -344,8 +344,5 @@
 (def-var! "clojure.core" "*ns*" (intern-ns! "user"))
 
 ;; --- printer patches: a namespace renders as its name (str / pr-str / -e) ----
-(define %ns-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (jns? x) (jns-name x) (%ns-pr-str x))))
-(define %ns-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jns? x) (jns-name x) (%ns-pr-readable x))))
+(register-pr-arm! jns? jns-name)
 (register-str-render! jns? jns-name)

host/chez/printing.ss

@@ -24,7 +24,16 @@
                   ((#\return) (cons #\r (cons #\\ acc)))
                   (else (cons c acc))))))))
 
-(define (jolt-pr-readable x)
+;; A host shim registers a type's readable rendering via register-pr-readable-arm!,
+;; or register-pr-arm! for types whose str and readable forms match (most host types:
+;; inst, uuid, record, var, …). Disjoint types, checked before the base cases.
+(define jolt-pr-readable-arms '())
+(define (register-pr-readable-arm! pred render)
+  (set! jolt-pr-readable-arms (cons (cons pred render) jolt-pr-readable-arms)))
+(define (register-pr-arm! pred render)
+  (register-pr-str-arm! pred render)
+  (register-pr-readable-arm! pred render))
+(define (jolt-pr-readable-base x)
   (cond
     ((string? x) (string-append "\"" (jolt-str-escape x) "\""))
     ;; pr renders the infinities / NaN in READABLE form (##Inf reads back), unlike
@@ -58,6 +67,11 @@
          (if (jolt-nil? s) (reverse acc)
              (loop (jolt-seq (seq-more s)) (cons (jolt-pr-readable (seq-first s)) acc))))) ")"))
     (else (jolt-pr-str x))))
+(define (jolt-pr-readable x)
+  (let loop ((as jolt-pr-readable-arms))
+    (cond ((null? as) (jolt-pr-readable-base x))
+          (((caar as) x) ((cdar as) x))
+          (else (loop (cdr as))))))
 
 ;; __pr-str1: render ONE value readably (the overlay's pr-str joins these).
 (define (jolt-pr-str1 x) (jolt-pr-readable x))

host/chez/records.ss

@@ -83,10 +83,7 @@
 (define %r-jolt-conj1 jolt-conj1)
 (set! jolt-conj1 (lambda (coll x)
   (if (jrec? coll) (jolt-assoc1 coll (jolt-nth x 0) (jolt-nth x 1)) (%r-jolt-conj1 coll x))))
-(define %r-jolt-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (jrec? x) (jrec-pr x) (%r-jolt-pr-str x))))
-(define %r-jolt-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (jrec? x) (jrec-pr x) (%r-jolt-pr-readable x))))
+(register-pr-arm! jrec? jrec-pr)
 
 ;; records are map? and coll? (Clojure: a record IS an associative map). The
 ;; predicates.ss vars hold a snapshot, so re-def-var! after extending. record? is

host/chez/rt.ss

@@ -179,7 +179,13 @@
 ;; bare nil renders as the empty string (a nil ELEMENT inside a collection still
 ;; prints "nil", which jolt-pr-str handles).
 (define (jolt-final-str x) (if (jolt-nil? x) "" (jolt-pr-str x)))
-(define (jolt-pr-str x)
+;; A host shim registers a type's str-style rendering via register-pr-str-arm! (or
+;; register-pr-arm! in printing.ss for both printers at once) instead of
+;; set!-wrapping jolt-pr-str. Disjoint types, checked before the base cases.
+(define jolt-pr-str-arms '())
+(define (register-pr-str-arm! pred render)
+  (set! jolt-pr-str-arms (cons (cons pred render) jolt-pr-str-arms)))
+(define (jolt-pr-str-base x)
   (cond
     ((jolt-nil? x) "nil")
     ((eq? x #t) "true")
@@ -206,6 +212,11 @@
                    (if (jolt-nil? s) (reverse acc)
                        (loop (jolt-seq (seq-more s)) (cons (jolt-pr-str (seq-first s)) acc))))) ")"))
     (else (format "~a" x))))
+(define (jolt-pr-str x)
+  (let loop ((as jolt-pr-str-arms))
+    (cond ((null? as) (jolt-pr-str-base x))
+          (((caar as) x) ((cdar as) x))
+          (else (loop (cdr as))))))
 
 ;; converters + string ops: str/subs/vec/keyword/symbol/compare/int/
 ;; double/gensym — host-coupled seed natives def-var!'d into clojure.core. Loaded

host/chez/transients.ss

@@ -169,11 +169,7 @@
 
 ;; Redefine the native get/count/contains?/nth (captured first) so the existing
 ;; emit lowerings unwrap a transient; non-transients are untouched.
-(define %prev-jolt-get jolt-get)
-(set! jolt-get
-  (case-lambda
-    ((coll k) (if (jolt-transient? coll) (t-get coll k jolt-nil) (%prev-jolt-get coll k)))
-    ((coll k d) (if (jolt-transient? coll) (t-get coll k d) (%prev-jolt-get coll k d)))))
+(register-get-arm! jolt-transient? (lambda (coll k d) (t-get coll k d)))
 (define %prev-jolt-count jolt-count)
 (set! jolt-count (lambda (coll) (if (jolt-transient? coll) (t-count coll) (%prev-jolt-count coll))))
 (define %prev-jolt-contains? jolt-contains?)

host/chez/vars.ss

@@ -38,10 +38,7 @@
 
 ;; pr-str / str of a var -> #'ns/name.
 (define (var->str v) (string-append "#'" (var-cell-ns v) "/" (var-cell-name v)))
-(define %v-pr-str jolt-pr-str)
-(set! jolt-pr-str (lambda (x) (if (var-cell? x) (var->str x) (%v-pr-str x))))
-(define %v-pr-readable jolt-pr-readable)
-(set! jolt-pr-readable (lambda (x) (if (var-cell? x) (var->str x) (%v-pr-readable x))))
+(register-pr-arm! var-cell? var->str)
 (register-str-render! var-cell? var->str)
 
 ;; bound? — native (the overlay's (get v :root) is nil on a var-cell record).