c9316dd372
0a (host/chez/values.ss): Jolt value model on Chez — nil sentinel distinct from #f/'(), interned keywords, ns+meta symbols, exactness-aware = and consistent hash. Chez numeric tower gives ratios/bignums free. 33/33 tests. 0b (test/chez/): extract test/spec/*.janet defspec tables into corpus.edn (2655 cases, valid as both EDN and Janet data), and a runner that drives ANY jolt binary via the CLI boundary with per-case subprocess isolation. Pluggable target (JOLT_BIN) so the same corpus gates every host. Baseline vs Janet build/jolt: 2641/2655, 14 known CLI divergences allowlisted; gate fails only on NEW ones.
74 lines
3.4 KiB
Scheme
74 lines
3.4 KiB
Scheme
;; Jolt value model on Chez Scheme — Phase 0a (jolt-cf1q.1).
|
|
;;
|
|
;; The irreducible value layer the self-hosted RT rests on. Maps Clojure's value
|
|
;; types onto Chez natives where possible, and adds records only where Chez lacks
|
|
;; a distinct type (nil sentinel, keywords, ns-bearing symbols). Loaded into an
|
|
;; env that has already (import (chezscheme)); becomes a real library in Phase 1.
|
|
;;
|
|
;; Design notes:
|
|
;; - nil is a UNIQUE sentinel, distinct from #f and '() (the classic Lisp-on-Lisp
|
|
;; trap). jolt false -> Chez #f, jolt true -> #t.
|
|
;; - Chez's numeric tower IS Clojure's: long->exact integer, double->flonum,
|
|
;; ratio->exact rational, bigint->bignum. A windfall vs Janet (ratios/bignums
|
|
;; for free). Clojure `=` is exactness-aware: (= 1 1.0) is FALSE.
|
|
|
|
;; --- nil ---------------------------------------------------------------------
|
|
(define-record-type jolt-nil-t (fields) (nongenerative jolt-nil-v1))
|
|
(define jolt-nil (make-jolt-nil-t))
|
|
(define (jolt-nil? x) (jolt-nil-t? x))
|
|
|
|
;; --- truthiness: only nil and false are falsey -------------------------------
|
|
(define (jolt-truthy? x) (not (or (jolt-nil? x) (eq? x #f))))
|
|
|
|
;; --- keywords: interned so identity works; optional namespace ----------------
|
|
(define-record-type keyword-t (fields ns name khash) (nongenerative keyword-v1))
|
|
(define keyword-table (make-hashtable string-hash string=?))
|
|
(define (keyword-intern-key ns name) (string-append (or ns "") "/" name))
|
|
(define (keyword ns name)
|
|
(let ((k (keyword-intern-key ns name)))
|
|
(or (hashtable-ref keyword-table k #f)
|
|
(let ((kw (make-keyword-t ns name (equal-hash k))))
|
|
(hashtable-set! keyword-table k kw)
|
|
kw))))
|
|
(define (keyword? x) (keyword-t? x))
|
|
|
|
;; --- symbols: ns + name + meta; NOT interned (meta varies), = by ns/name ------
|
|
(define-record-type symbol-t (fields ns name meta) (nongenerative symbol-v1))
|
|
(define (jolt-symbol ns name) (make-symbol-t ns name jolt-nil))
|
|
(define (jolt-symbol/meta ns name meta) (make-symbol-t ns name meta))
|
|
(define (jolt-symbol? x) (symbol-t? x))
|
|
|
|
;; chars/strings: Chez natives (strings treated immutable).
|
|
|
|
;; --- jolt equality (Clojure =) — scalars; collections land in Phase 2 --------
|
|
(define (jolt=2 a b)
|
|
(cond
|
|
((and (jolt-nil? a) (jolt-nil? b)) #t)
|
|
((or (jolt-nil? a) (jolt-nil? b)) #f)
|
|
((and (number? a) (number? b)) ; exactness-aware
|
|
(and (eq? (exact? a) (exact? b)) (= a b)))
|
|
((and (keyword-t? a) (keyword-t? b)) (eq? a b)) ; interned
|
|
((and (symbol-t? a) (symbol-t? b))
|
|
(and (equal? (symbol-t-ns a) (symbol-t-ns b))
|
|
(string=? (symbol-t-name a) (symbol-t-name b))))
|
|
((and (char? a) (char? b)) (char=? a b))
|
|
((and (string? a) (string? b)) (string=? a b))
|
|
((and (boolean? a) (boolean? b)) (eq? a b))
|
|
(else (eq? a b))))
|
|
(define (jolt= a . rest)
|
|
(let loop ((a a) (rest rest))
|
|
(cond ((null? rest) #t)
|
|
((jolt=2 a (car rest)) (loop (car rest) (cdr rest)))
|
|
(else #f))))
|
|
|
|
;; --- jolt hash — consistent with jolt= (for the HAMT in 0c / Phase 2) ---------
|
|
(define (jolt-hash x)
|
|
(cond
|
|
((jolt-nil? x) 0)
|
|
((keyword-t? x) (keyword-t-khash x))
|
|
((symbol-t? x) (equal-hash (cons (symbol-t-ns x) (symbol-t-name x))))
|
|
((number? x) (if (exact? x) (equal-hash x) (equal-hash (cons 'inexact (inexact->exact x)))))
|
|
((string? x) (string-hash x))
|
|
((char? x) (char->integer x))
|
|
((boolean? x) (if x 1 2))
|
|
(else (equal-hash x))))
|