kernel: $quasiquote runtime + reflective/quoting.sx sketch [shapes-reflective]

kernel-quasiquote-operative walks the template via mutually-recursive
knl-quasi-walk ↔ knl-quasi-walk-list. $unquote forms eval in dyn-env;
$unquote-splicing splices list-valued results. No depth tracking
(nested quasiquotes flatten). 8 new tests, 230 total. Sketched the
universal reflective quoting kit API for the eventual Phase 7 extraction.

lib/kernel/runtime.sx

@@ -194,6 +194,57 @@
         ((not (= (length args) 1)) (error "$quote: expects 1 argument"))
         (:else (first args))))))
 
+;; Quasiquote: walks the template, evaluating `$unquote` forms in the
+;; dynamic env and splicing `$unquote-splicing` list results.
+(define knl-quasi-walk
+  (fn (form dyn-env)
+    (cond
+      ((not (list? form)) form)
+      ((= (length form) 0) form)
+      ((and (string? (first form)) (= (first form) "$unquote"))
+        (cond
+          ((not (= (length form) 2))
+            (error "$unquote: expects exactly 1 argument"))
+          (:else (kernel-eval (nth form 1) dyn-env))))
+      (:else (knl-quasi-walk-list form dyn-env)))))
+
+(define knl-quasi-walk-list
+  (fn (forms dyn-env)
+    (cond
+      ((or (nil? forms) (= (length forms) 0)) (list))
+      (:else
+        (let ((head (first forms)))
+          (cond
+            ((and (list? head)
+                  (= (length head) 2)
+                  (string? (first head))
+                  (= (first head) "$unquote-splicing"))
+              (let ((spliced (kernel-eval (nth head 1) dyn-env)))
+                (cond
+                  ((not (list? spliced))
+                    (error "$unquote-splicing: value must be a list"))
+                  (:else
+                    (knl-list-concat
+                      spliced
+                      (knl-quasi-walk-list (rest forms) dyn-env))))))
+            (:else
+              (cons (knl-quasi-walk head dyn-env)
+                    (knl-quasi-walk-list (rest forms) dyn-env)))))))))
+
+(define knl-list-concat
+  (fn (xs ys)
+    (cond
+      ((or (nil? xs) (= (length xs) 0)) ys)
+      (:else (cons (first xs) (knl-list-concat (rest xs) ys))))))
+
+(define kernel-quasiquote-operative
+  (kernel-make-primitive-operative
+    (fn (args dyn-env)
+      (cond
+        ((not (= (length args) 1))
+          (error "$quasiquote: expects exactly 1 argument"))
+        (:else (knl-quasi-walk (first args) dyn-env))))))
+
 (define
   kernel-eval-applicative
   (kernel-make-primitive-applicative
@@ -462,6 +513,7 @@
       (kernel-env-bind! env "$define!" kernel-define!-operative)
       (kernel-env-bind! env "$sequence" kernel-sequence-operative)
       (kernel-env-bind! env "$quote"    kernel-quote-operative)
+      (kernel-env-bind! env "$quasiquote" kernel-quasiquote-operative)
       (kernel-env-bind! env "eval" kernel-eval-applicative)
       (kernel-env-bind!
         env

lib/kernel/tests/standard.sx

@@ -254,4 +254,35 @@
     (ks-eval-in "z" env))
   77)
 
+;; ── quasiquote ──────────────────────────────────────────────────
+(ks-test "qq: plain atom"      (ks-eval "`hello") "hello")
+(ks-test "qq: plain list"      (ks-eval "`(a b c)") (list "a" "b" "c"))
+(ks-test "qq: unquote splices value"
+  (let ((env (kernel-standard-env)))
+    (ks-eval-in "($define! x 42)" env)
+    (ks-eval-in "`(a ,x b)" env)) (list "a" 42 "b"))
+(ks-test "qq: unquote-splicing splices list"
+  (let ((env (kernel-standard-env)))
+    (ks-eval-in "($define! xs (list 1 2 3))" env)
+    (ks-eval-in "`(a ,@xs b)" env)) (list "a" 1 2 3 "b"))
+(ks-test "qq: unquote-splicing at end"
+  (let ((env (kernel-standard-env)))
+    (ks-eval-in "($define! xs (list 9 8))" env)
+    (ks-eval-in "`(a b ,@xs)" env)) (list "a" "b" 9 8))
+(ks-test "qq: unquote-splicing at start"
+  (let ((env (kernel-standard-env)))
+    (ks-eval-in "($define! xs (list 1 2))" env)
+    (ks-eval-in "`(,@xs c)" env)) (list 1 2 "c"))
+(ks-test "qq: nested list with unquote inside"
+  (let ((env (kernel-standard-env)))
+    (ks-eval-in "($define! x 5)" env)
+    (ks-eval-in "`(a (b ,x) c)" env))
+  (list "a" (list "b" 5) "c"))
+(ks-test "qq: error on bare unquote-splicing into non-list"
+  (let ((env (kernel-standard-env)))
+    (ks-eval-in "($define! x 42)" env)
+    (guard (e (true :raised))
+      (ks-eval-in "`(a ,@x b)" env)))
+  :raised)
+
 (define ks-tests-run! (fn () {:total (+ ks-test-pass ks-test-fail) :passed ks-test-pass :failed ks-test-fail :fails ks-test-fails}))