apl: het-inner-product encloses (+4); life.apl restored to as-written

apl-inner now wraps its result in (enclose result) when A's ravel
contains any dict element (a boxed array). This matches Hui's
semantics where `1 ⍵ ∨.∧ X` produces a rank-0 wrapping the
(5 5) board, then ⊃ unwraps to bare matrix.

Homogeneous inner product unaffected (+.× over numbers and
matrices still produces bare arrays — none of those ravels
contain dicts).

life.apl restored to true as-written form:
  life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}

4 pipeline tests + 5 e2e tests verify heterogeneous case and
that ⊃ unwraps to the underlying (5 5) board.

Full suite 589/589. Phase 11 complete.

lib/apl/conformance.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+# lib/apl/conformance.sh — run APL test suites, emit scoreboard.json + scoreboard.md.
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX_SERVER" ]; then
+  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
+fi
+if [ ! -x "$SX_SERVER" ]; then
+  echo "ERROR: sx_server.exe not found." >&2
+  exit 1
+fi
+
+SUITES=(structural operators dfn tradfn valence programs system idioms eval-ops pipeline)
+
+OUT_JSON="lib/apl/scoreboard.json"
+OUT_MD="lib/apl/scoreboard.md"
+
+run_suite() {
+  local suite=$1
+  local file="lib/apl/tests/${suite}.sx"
+  local TMP
+  TMP=$(mktemp)
+  cat > "$TMP" << EPOCHS
+(epoch 1)
+(load "spec/stdlib.sx")
+(load "lib/r7rs.sx")
+(load "lib/apl/runtime.sx")
+(load "lib/apl/tokenizer.sx")
+(load "lib/apl/parser.sx")
+(load "lib/apl/transpile.sx")
+(epoch 2)
+(eval "(define apl-test-pass 0)")
+(eval "(define apl-test-fail 0)")
+(eval "(define apl-test (fn (name got expected) (if (= got expected) (set! apl-test-pass (+ apl-test-pass 1)) (set! apl-test-fail (+ apl-test-fail 1)))))")
+(epoch 3)
+(load "${file}")
+(epoch 4)
+(eval "(list apl-test-pass apl-test-fail)")
+EPOCHS
+
+  local OUTPUT
+  OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMP" 2>/dev/null)
+  rm -f "$TMP"
+
+  local LINE
+  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
+  if [ -z "$LINE" ]; then
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
+            | sed -E 's/^\(ok 4 //; s/\)$//')
+  fi
+
+  local P F
+  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
+  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
+  P=${P:-0}
+  F=${F:-0}
+  echo "${P} ${F}"
+}
+
+declare -A SUITE_PASS
+declare -A SUITE_FAIL
+TOTAL_PASS=0
+TOTAL_FAIL=0
+
+echo "Running APL conformance suite..." >&2
+for s in "${SUITES[@]}"; do
+  read -r p f < <(run_suite "$s")
+  SUITE_PASS[$s]=$p
+  SUITE_FAIL[$s]=$f
+  TOTAL_PASS=$((TOTAL_PASS + p))
+  TOTAL_FAIL=$((TOTAL_FAIL + f))
+  printf "  %-12s %d/%d\n" "$s" "$p" "$((p+f))" >&2
+done
+
+# scoreboard.json
+{
+  printf '{\n'
+  printf '  "suites": {\n'
+  first=1
+  for s in "${SUITES[@]}"; do
+    if [ $first -eq 0 ]; then printf ',\n'; fi
+    printf '    "%s": {"pass": %d, "fail": %d}' "$s" "${SUITE_PASS[$s]}" "${SUITE_FAIL[$s]}"
+    first=0
+  done
+  printf '\n  },\n'
+  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
+  printf '  "total": %d\n' "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '}\n'
+} > "$OUT_JSON"
+
+# scoreboard.md
+{
+  printf '# APL Conformance Scoreboard\n\n'
+  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
+  printf '| Suite | Pass | Fail | Total |\n'
+  printf '|-------|-----:|-----:|------:|\n'
+  for s in "${SUITES[@]}"; do
+    p=${SUITE_PASS[$s]}
+    f=${SUITE_FAIL[$s]}
+    printf '| %s | %d | %d | %d |\n' "$s" "$p" "$f" "$((p+f))"
+  done
+  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$TOTAL_PASS" "$TOTAL_FAIL" "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '\n'
+  printf '## Notes\n\n'
+  printf '%s\n' '- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.'
+  printf '%s\n' '- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.'
+} > "$OUT_MD"
+
+echo "Wrote $OUT_JSON and $OUT_MD" >&2
+echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
+
+[ "$TOTAL_FAIL" -eq 0 ]

lib/apl/parser.sx

@@ -0,0 +1,711 @@
+; APL Parser — right-to-left expression parser
+;
+; Takes a token list (output of apl-tokenize) and produces an AST.
+; APL evaluates right-to-left with no precedence among functions.
+; Operators bind to the function immediately to their left in the source.
+;
+; AST node types:
+;   (:num n)                     number literal
+;   (:str s)                     string literal
+;   (:vec n1 n2 ...)             strand (juxtaposed literals)
+;   (:name "x")                  name reference / alpha / omega
+;   (:assign "x" expr)           assignment  x←expr
+;   (:monad fn arg)              monadic function call
+;   (:dyad fn left right)        dyadic function call
+;   (:derived-fn op fn)          derived function: f/ f¨ f⍨
+;   (:derived-fn2 "." f g)       inner product: f.g
+;   (:outer "∘." fn)             outer product: ∘.f
+;   (:fn-glyph "⍳")             function reference
+;   (:fn-name "foo")             named-function reference (dfn variable)
+;   (:dfn stmt...)               {⍺+⍵} anonymous function
+;   (:guard cond expr)           cond:expr guard inside dfn
+;   (:program stmt...)           multi-statement sequence
+
+; ============================================================
+; Glyph classification sets
+; ============================================================
+
+(define
+  apl-parse-op-glyphs
+  (list "/" "⌿" "\\" "⍀" "¨" "⍨" "∘" "." "⍣" "⍤" "⍥" "@"))
+
+(define
+  apl-parse-fn-glyphs
+  (list
+    "+"
+    "-"
+    "×"
+    "÷"
+    "*"
+    "⍟"
+    "⌈"
+    "⌊"
+    "|"
+    "!"
+    "?"
+    "○"
+    "~"
+    "<"
+    "≤"
+    "="
+    "≥"
+    ">"
+    "≠"
+    "≢"
+    "≡"
+    "∊"
+    "∧"
+    "∨"
+    "⍱"
+    "⍲"
+    ","
+    "⍪"
+    "⍴"
+    "⌽"
+    "⊖"
+    "⍉"
+    "↑"
+    "↓"
+    "⊂"
+    "⊃"
+    "⊆"
+    "∪"
+    "∩"
+    "⍳"
+    "⍸"
+    "⌷"
+    "⍋"
+    "⍒"
+    "⊥"
+    "⊤"
+    "⊣"
+    "⊢"
+    "⍎"
+    "⍕"))
+
+(define apl-quad-fn-names (list "⎕FMT" "⎕←"))
+
+(define apl-known-fn-names (list))
+
+; ============================================================
+; Token accessors
+; ============================================================
+
+(define
+  apl-collect-fn-bindings
+  (fn
+    (stmt-groups)
+    (set! apl-known-fn-names (list))
+    (for-each
+      (fn
+        (toks)
+        (when
+          (and
+            (>= (len toks) 3)
+            (= (tok-type (nth toks 0)) :name)
+            (= (tok-type (nth toks 1)) :assign)
+            (= (tok-type (nth toks 2)) :lbrace))
+          (set!
+            apl-known-fn-names
+            (cons (tok-val (nth toks 0)) apl-known-fn-names))))
+      stmt-groups)))
+
+(define
+  apl-parse-op-glyph?
+  (fn (v) (some (fn (g) (= g v)) apl-parse-op-glyphs)))
+
+(define
+  apl-parse-fn-glyph?
+  (fn (v) (some (fn (g) (= g v)) apl-parse-fn-glyphs)))
+
+(define tok-type (fn (tok) (get tok :type)))
+
+; ============================================================
+; Collect trailing operators starting at index i
+; Returns {:ops (op ...) :end new-i}
+; ============================================================
+
+(define tok-val (fn (tok) (get tok :value)))
+
+(define
+  is-op-tok?
+  (fn
+    (tok)
+    (and (= (tok-type tok) :glyph) (apl-parse-op-glyph? (tok-val tok)))))
+
+; ============================================================
+; Build a derived-fn node by chaining operators left-to-right
+; (+/¨  →  (:derived-fn "¨" (:derived-fn "/" (:fn-glyph "+"))))
+; ============================================================
+
+(define
+  is-fn-tok?
+  (fn
+    (tok)
+    (or
+      (and (= (tok-type tok) :glyph) (apl-parse-fn-glyph? (tok-val tok)))
+      (and
+        (= (tok-type tok) :name)
+        (or
+          (some (fn (q) (= q (tok-val tok))) apl-quad-fn-names)
+          (some (fn (q) (= q (tok-val tok))) apl-known-fn-names))))))
+
+; ============================================================
+; Find matching close bracket/paren/brace
+; Returns the index of the matching close token
+; ============================================================
+
+(define collect-ops (fn (tokens i) (collect-ops-loop tokens i (list))))
+
+(define
+  collect-ops-loop
+  (fn
+    (tokens i acc)
+    (if
+      (>= i (len tokens))
+      {:end i :ops acc}
+      (let
+        ((tok (nth tokens i)))
+        (if
+          (is-op-tok? tok)
+          (collect-ops-loop tokens (+ i 1) (append acc (tok-val tok)))
+          {:end i :ops acc})))))
+
+; ============================================================
+; Segment collection: scan tokens left-to-right, building
+; a list of {:kind "val"/"fn" :node ast} segments.
+; Operators following function glyphs are merged into
+; derived-fn nodes during this pass.
+; ============================================================
+
+(define
+  build-derived-fn
+  (fn
+    (fn-node ops)
+    (if
+      (= (len ops) 0)
+      fn-node
+      (build-derived-fn (list :derived-fn (first ops) fn-node) (rest ops)))))
+
+(define
+  find-matching-close
+  (fn
+    (tokens start open-type close-type)
+    (find-matching-close-loop tokens start open-type close-type 1)))
+
+; ============================================================
+; Build tree from segment list
+;
+; The segments are in left-to-right order.
+; APL evaluates right-to-left, so the LEFTMOST function is
+; the outermost (last-evaluated) node.
+;
+; Patterns:
+;   [val]              → val node
+;   [fn val ...]       → (:monad fn (build-tree rest))
+;   [val fn val ...]   → (:dyad fn val (build-tree rest))
+;   [val val ...]      → (:vec val1 val2 ...) — strand
+; ============================================================
+
+; Find the index of the first function segment (returns -1 if none)
+(define
+  find-matching-close-loop
+  (fn
+    (tokens i open-type close-type depth)
+    (if
+      (>= i (len tokens))
+      (len tokens)
+      (let
+        ((tt (tok-type (nth tokens i))))
+        (cond
+          ((= tt open-type)
+            (find-matching-close-loop
+              tokens
+              (+ i 1)
+              open-type
+              close-type
+              (+ depth 1)))
+          ((= tt close-type)
+            (if
+              (= depth 1)
+              i
+              (find-matching-close-loop
+                tokens
+                (+ i 1)
+                open-type
+                close-type
+                (- depth 1))))
+          (true
+            (find-matching-close-loop
+              tokens
+              (+ i 1)
+              open-type
+              close-type
+              depth)))))))
+
+(define
+  collect-segments
+  (fn (tokens) (collect-segments-loop tokens 0 (list))))
+
+; Build an array node from 0..n value segments
+; If n=1 → return that segment's node
+; If n>1 → return (:vec node1 node2 ...)
+(define
+  collect-segments-loop
+  (fn
+    (tokens i acc)
+    (if
+      (>= i (len tokens))
+      acc
+      (let
+        ((tok (nth tokens i)) (n (len tokens)))
+        (let
+          ((tt (tok-type tok)) (tv (tok-val tok)))
+          (cond
+            ((or (= tt :diamond) (= tt :newline) (= tt :semi))
+              (collect-segments-loop tokens (+ i 1) acc))
+            ((= tt :num)
+              (collect-segments-loop tokens (+ i 1) (append acc {:kind "val" :node (list :num tv)})))
+            ((= tt :str)
+              (collect-segments-loop tokens (+ i 1) (append acc {:kind "val" :node (list :str tv)})))
+            ((= tt :name)
+              (cond
+                ((and (< (+ i 1) (len tokens)) (= (tok-type (nth tokens (+ i 1))) :assign))
+                  (let
+                    ((rhs-tokens (slice tokens (+ i 2) (len tokens))))
+                    (let
+                      ((rhs-expr (parse-apl-expr rhs-tokens)))
+                      (collect-segments-loop
+                        tokens
+                        (len tokens)
+                        (append acc {:kind "val" :node (list :assign-expr tv rhs-expr)})))))
+                ((some (fn (q) (= q tv)) apl-quad-fn-names)
+                  (let
+                    ((op-result (collect-ops tokens (+ i 1))))
+                    (let
+                      ((ops (get op-result :ops))
+                        (ni (get op-result :end)))
+                      (let
+                        ((fn-node (build-derived-fn (list :fn-glyph tv) ops)))
+                        (collect-segments-loop
+                          tokens
+                          ni
+                          (append acc {:kind "fn" :node fn-node}))))))
+                ((some (fn (q) (= q tv)) apl-known-fn-names)
+                  (let
+                    ((op-result (collect-ops tokens (+ i 1))))
+                    (let
+                      ((ops (get op-result :ops))
+                        (ni (get op-result :end)))
+                      (let
+                        ((fn-node (build-derived-fn (list :fn-name tv) ops)))
+                        (collect-segments-loop
+                          tokens
+                          ni
+                          (append acc {:kind "fn" :node fn-node}))))))
+                (else
+                  (let
+                    ((br (maybe-bracket (list :name tv) tokens (+ i 1))))
+                    (collect-segments-loop
+                      tokens
+                      (nth br 1)
+                      (append acc {:kind "val" :node (nth br 0)}))))))
+            ((= tt :lparen)
+              (let
+                ((end (find-matching-close tokens (+ i 1) :lparen :rparen)))
+                (let
+                  ((inner-tokens (slice tokens (+ i 1) end))
+                    (after (+ end 1)))
+                  (let
+                    ((inner-segs (collect-segments inner-tokens)))
+                    (if
+                      (and
+                        (>= (len inner-segs) 2)
+                        (every? (fn (s) (= (get s :kind) "fn")) inner-segs))
+                      (let
+                        ((train-node (cons :train (map (fn (s) (get s :node)) inner-segs))))
+                        (collect-segments-loop
+                          tokens
+                          after
+                          (append acc {:kind "fn" :node train-node})))
+                      (let
+                        ((br (maybe-bracket (parse-apl-expr inner-tokens) tokens after)))
+                        (collect-segments-loop
+                          tokens
+                          (nth br 1)
+                          (append acc {:kind "val" :node (nth br 0)}))))))))
+            ((= tt :lbrace)
+              (let
+                ((end (find-matching-close tokens (+ i 1) :lbrace :rbrace)))
+                (let
+                  ((inner-tokens (slice tokens (+ i 1) end))
+                    (after (+ end 1)))
+                  (collect-segments-loop tokens after (append acc {:kind "fn" :node (parse-dfn inner-tokens)})))))
+            ((= tt :glyph)
+              (cond
+                ((or (= tv "⍺") (= tv "⍵"))
+                  (if
+                    (and
+                      (< (+ i 1) (len tokens))
+                      (= (tok-type (nth tokens (+ i 1))) :assign))
+                    (let
+                      ((rhs-tokens (slice tokens (+ i 2) (len tokens))))
+                      (let
+                        ((rhs-expr (parse-apl-expr rhs-tokens)))
+                        (collect-segments-loop
+                          tokens
+                          (len tokens)
+                          (append acc {:kind "val" :node (list :assign-expr tv rhs-expr)}))))
+                    (collect-segments-loop
+                      tokens
+                      (+ i 1)
+                      (append acc {:kind "val" :node (list :name tv)}))))
+                ((= tv "∇")
+                  (collect-segments-loop
+                    tokens
+                    (+ i 1)
+                    (append acc {:kind "fn" :node (list :fn-glyph "∇")})))
+                ((and (= tv "∘") (< (+ i 1) n) (= (tok-val (nth tokens (+ i 1))) "."))
+                  (if
+                    (and (< (+ i 2) n) (is-fn-tok? (nth tokens (+ i 2))))
+                    (let
+                      ((fn-tv (tok-val (nth tokens (+ i 2)))))
+                      (let
+                        ((op-result (collect-ops tokens (+ i 3))))
+                        (let
+                          ((ops (get op-result :ops))
+                            (ni (get op-result :end)))
+                          (let
+                            ((fn-node (build-derived-fn (list :fn-glyph fn-tv) ops)))
+                            (collect-segments-loop
+                              tokens
+                              ni
+                              (append acc {:kind "fn" :node (list :outer "∘." fn-node)}))))))
+                    (collect-segments-loop tokens (+ i 1) acc)))
+                ((apl-parse-fn-glyph? tv)
+                  (let
+                    ((op-result (collect-ops tokens (+ i 1))))
+                    (let
+                      ((ops (get op-result :ops))
+                        (ni (get op-result :end)))
+                      (if
+                        (and
+                          (= (len ops) 1)
+                          (= (first ops) ".")
+                          (< ni n)
+                          (is-fn-tok? (nth tokens ni)))
+                        (let
+                          ((g-tv (tok-val (nth tokens ni))))
+                          (let
+                            ((op-result2 (collect-ops tokens (+ ni 1))))
+                            (let
+                              ((ops2 (get op-result2 :ops))
+                                (ni2 (get op-result2 :end)))
+                              (let
+                                ((g-node (build-derived-fn (list :fn-glyph g-tv) ops2)))
+                                (collect-segments-loop
+                                  tokens
+                                  ni2
+                                  (append acc {:kind "fn" :node (list :derived-fn2 "." (list :fn-glyph tv) g-node)}))))))
+                        (let
+                          ((fn-node (build-derived-fn (list :fn-glyph tv) ops)))
+                          (collect-segments-loop
+                            tokens
+                            ni
+                            (append acc {:kind "fn" :node fn-node})))))))
+                ((apl-parse-op-glyph? tv)
+                  (if
+                    (or (= tv "/") (= tv "⌿") (= tv "\\") (= tv "⍀"))
+                    (let
+                      ((next-i (+ i 1)))
+                      (let
+                        ((next-tok (if (< next-i n) (nth tokens next-i) nil)))
+                        (let
+                          ((mod (if (and next-tok (= (tok-type next-tok) :glyph) (or (= (get next-tok :value) "⍨") (= (get next-tok :value) "¨"))) (get next-tok :value) nil))
+                            (base-fn-node (list :fn-glyph tv)))
+                          (let
+                            ((node (if mod (list :derived-fn mod base-fn-node) base-fn-node))
+                              (advance (if mod 2 1)))
+                            (collect-segments-loop
+                              tokens
+                              (+ i advance)
+                              (append acc {:kind "fn" :node node}))))))
+                    (collect-segments-loop tokens (+ i 1) acc)))
+                (true (collect-segments-loop tokens (+ i 1) acc))))
+            (true (collect-segments-loop tokens (+ i 1) acc))))))))
+
+(define find-first-fn (fn (segs) (find-first-fn-loop segs 0)))
+
+
+; ============================================================
+; Split token list on statement separators (diamond / newline)
+; Only splits at depth 0 (ignores separators inside { } or ( ) )
+; ============================================================
+
+(define
+  find-first-fn-loop
+  (fn
+    (segs i)
+    (if
+      (>= i (len segs))
+      -1
+      (if
+        (= (get (nth segs i) :kind) "fn")
+        i
+        (find-first-fn-loop segs (+ i 1))))))
+
+(define
+  segs-to-array
+  (fn
+    (segs)
+    (if
+      (= (len segs) 1)
+      (get (first segs) :node)
+      (cons :vec (map (fn (s) (get s :node)) segs)))))
+
+; ============================================================
+; Parse a dfn body (tokens between { and })
+; Handles guard expressions: cond : expr
+; ============================================================
+
+(define
+  build-tree
+  (fn
+    (segs)
+    (cond
+      ((= (len segs) 0) nil)
+      ((= (len segs) 1) (get (first segs) :node))
+      ((every? (fn (s) (= (get s :kind) "val")) segs)
+        (segs-to-array segs))
+      (true
+        (let
+          ((fn-idx (find-first-fn segs)))
+          (cond
+            ((= fn-idx -1) (segs-to-array segs))
+            ((= fn-idx 0)
+              (list
+                :monad (get (first segs) :node)
+                (build-tree (rest segs))))
+            (true
+              (let
+                ((left-segs (slice segs 0 fn-idx))
+                  (fn-seg (nth segs fn-idx))
+                  (right-segs (slice segs (+ fn-idx 1))))
+                (list
+                  :dyad (get fn-seg :node)
+                  (segs-to-array left-segs)
+                  (build-tree right-segs))))))))))
+
+(define
+  split-statements
+  (fn (tokens) (split-statements-loop tokens (list) (list) 0)))
+
+(define
+  split-statements-loop
+  (fn
+    (tokens current-stmt acc depth)
+    (if
+      (= (len tokens) 0)
+      (if (> (len current-stmt) 0) (append acc (list current-stmt)) acc)
+      (let
+        ((tok (first tokens))
+          (rest-toks (rest tokens))
+          (tt (tok-type (first tokens))))
+        (cond
+          ((or (= tt :lparen) (= tt :lbrace) (= tt :lbracket))
+            (split-statements-loop
+              rest-toks
+              (append current-stmt tok)
+              acc
+              (+ depth 1)))
+          ((or (= tt :rparen) (= tt :rbrace) (= tt :rbracket))
+            (split-statements-loop
+              rest-toks
+              (append current-stmt tok)
+              acc
+              (- depth 1)))
+          ((and (> depth 0) (or (= tt :diamond) (= tt :newline)))
+            (split-statements-loop
+              rest-toks
+              (append current-stmt tok)
+              acc
+              depth))
+          ((and (= depth 0) (or (= tt :diamond) (= tt :newline)))
+            (if
+              (> (len current-stmt) 0)
+              (split-statements-loop
+                rest-toks
+                (list)
+                (append acc (list current-stmt))
+                depth)
+              (split-statements-loop rest-toks (list) acc depth)))
+          (true
+            (split-statements-loop
+              rest-toks
+              (append current-stmt tok)
+              acc
+              depth)))))))
+
+(define
+  parse-dfn
+  (fn
+    (tokens)
+    (let
+      ((stmt-groups (split-statements tokens)))
+      (let ((stmts (map parse-dfn-stmt stmt-groups))) (cons :dfn stmts)))))
+
+; ============================================================
+; Parse a single statement (assignment or expression)
+; ============================================================
+
+(define
+  parse-dfn-stmt
+  (fn
+    (tokens)
+    (let
+      ((colon-idx (find-top-level-colon tokens 0)))
+      (if
+        (>= colon-idx 0)
+        (let
+          ((cond-tokens (slice tokens 0 colon-idx))
+            (body-tokens (slice tokens (+ colon-idx 1))))
+          (list
+            :guard (parse-apl-expr cond-tokens)
+            (parse-apl-expr body-tokens)))
+        (parse-stmt tokens)))))
+
+; ============================================================
+; Parse an expression from a flat token list
+; ============================================================
+
+(define
+  find-top-level-colon
+  (fn (tokens i) (find-top-level-colon-loop tokens i 0)))
+
+; ============================================================
+; Main entry point
+; parse-apl: string → AST
+; ============================================================
+
+(define
+  find-top-level-colon-loop
+  (fn
+    (tokens i depth)
+    (if
+      (>= i (len tokens))
+      -1
+      (let
+        ((tok (nth tokens i)) (tt (tok-type (nth tokens i))))
+        (cond
+          ((or (= tt :lparen) (= tt :lbrace) (= tt :lbracket))
+            (find-top-level-colon-loop tokens (+ i 1) (+ depth 1)))
+          ((or (= tt :rparen) (= tt :rbrace) (= tt :rbracket))
+            (find-top-level-colon-loop tokens (+ i 1) (- depth 1)))
+          ((and (= tt :colon) (= depth 0)) i)
+          (true (find-top-level-colon-loop tokens (+ i 1) depth)))))))
+
+(define
+  parse-stmt
+  (fn
+    (tokens)
+    (if
+      (and
+        (>= (len tokens) 2)
+        (= (tok-type (nth tokens 0)) :name)
+        (= (tok-type (nth tokens 1)) :assign))
+      (list
+        :assign (tok-val (nth tokens 0))
+        (parse-apl-expr (slice tokens 2)))
+      (parse-apl-expr tokens))))
+
+(define
+  parse-apl-expr
+  (fn
+    (tokens)
+    (let
+      ((segs (collect-segments tokens)))
+      (if (= (len segs) 0) nil (build-tree segs)))))
+
+(define
+  parse-apl
+  (fn
+    (src)
+    (let
+      ((tokens (apl-tokenize src)))
+      (let
+        ((stmt-groups (split-statements tokens)))
+        (begin
+          (apl-collect-fn-bindings stmt-groups)
+          (if
+            (= (len stmt-groups) 0)
+            nil
+            (if
+              (= (len stmt-groups) 1)
+              (parse-stmt (first stmt-groups))
+              (cons :program (map parse-stmt stmt-groups)))))))))
+
+(define
+  split-bracket-loop
+  (fn
+    (tokens current acc depth)
+    (if
+      (= (len tokens) 0)
+      (append acc (list current))
+      (let
+        ((tok (first tokens)) (more (rest tokens)))
+        (let
+          ((tt (tok-type tok)))
+          (cond
+            ((or (= tt :lparen) (= tt :lbrace) (= tt :lbracket))
+              (split-bracket-loop
+                more
+                (append current (list tok))
+                acc
+                (+ depth 1)))
+            ((or (= tt :rparen) (= tt :rbrace) (= tt :rbracket))
+              (split-bracket-loop
+                more
+                (append current (list tok))
+                acc
+                (- depth 1)))
+            ((and (= tt :semi) (= depth 0))
+              (split-bracket-loop
+                more
+                (list)
+                (append acc (list current))
+                depth))
+            (else
+              (split-bracket-loop more (append current (list tok)) acc depth))))))))
+
+(define
+  split-bracket-content
+  (fn (tokens) (split-bracket-loop tokens (list) (list) 0)))
+
+(define
+  maybe-bracket
+  (fn
+    (val-node tokens after)
+    (if
+      (and
+        (< after (len tokens))
+        (= (tok-type (nth tokens after)) :lbracket))
+      (let
+        ((end (find-matching-close tokens (+ after 1) :lbracket :rbracket)))
+        (let
+          ((inner-tokens (slice tokens (+ after 1) end))
+            (next-after (+ end 1)))
+          (let
+            ((sections (split-bracket-content inner-tokens)))
+            (if
+              (= (len sections) 1)
+              (let
+                ((idx-expr (parse-apl-expr inner-tokens)))
+                (let
+                  ((indexed (list :dyad (list :fn-glyph "⌷") idx-expr val-node)))
+                  (maybe-bracket indexed tokens next-after)))
+              (let
+                ((axis-exprs (map (fn (toks) (if (= (len toks) 0) :all (parse-apl-expr toks))) sections)))
+                (let
+                  ((indexed (cons :bracket (cons val-node axis-exprs))))
+                  (maybe-bracket indexed tokens next-after)))))))
+      (list val-node after))))

lib/apl/scoreboard.json

@@ -0,0 +1,17 @@
+{
+  "suites": {
+    "structural": {"pass": 94, "fail": 0},
+    "operators": {"pass": 117, "fail": 0},
+    "dfn": {"pass": 24, "fail": 0},
+    "tradfn": {"pass": 25, "fail": 0},
+    "valence": {"pass": 14, "fail": 0},
+    "programs": {"pass": 45, "fail": 0},
+    "system": {"pass": 13, "fail": 0},
+    "idioms": {"pass": 64, "fail": 0},
+    "eval-ops": {"pass": 14, "fail": 0},
+    "pipeline": {"pass": 40, "fail": 0}
+  },
+  "total_pass": 450,
+  "total_fail": 0,
+  "total": 450
+}

lib/apl/scoreboard.md

@@ -0,0 +1,22 @@
+# APL Conformance Scoreboard
+
+_Generated by `lib/apl/conformance.sh`_
+
+| Suite | Pass | Fail | Total |
+|-------|-----:|-----:|------:|
+| structural | 94 | 0 | 94 |
+| operators | 117 | 0 | 117 |
+| dfn | 24 | 0 | 24 |
+| tradfn | 25 | 0 | 25 |
+| valence | 14 | 0 | 14 |
+| programs | 45 | 0 | 45 |
+| system | 13 | 0 | 13 |
+| idioms | 64 | 0 | 64 |
+| eval-ops | 14 | 0 | 14 |
+| pipeline | 40 | 0 | 40 |
+| **Total** | **450** | **0** | **450** |
+
+## Notes
+
+- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.
+- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.

lib/apl/test.sh

@@ -4,9 +4,9 @@
 set -uo pipefail
 cd "$(git rev-parse --show-toplevel)"
 
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
 if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
+  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
 fi
 if [ ! -x "$SX_SERVER" ]; then
   echo "ERROR: sx_server.exe not found."
@@ -18,19 +18,38 @@ TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
 cat > "$TMPFILE" << 'EPOCHS'
 (epoch 1)
 (load "spec/stdlib.sx")
+(load "lib/r7rs.sx")
 (load "lib/apl/runtime.sx")
+(load "lib/apl/tokenizer.sx")
+(load "lib/apl/parser.sx")
+(load "lib/apl/transpile.sx")
 (epoch 2)
-(load "lib/apl/tests/runtime.sx")
+(eval "(define apl-test-pass 0)")
+(eval "(define apl-test-fail 0)")
+(eval "(define apl-test-fails (list))")
+(eval "(define apl-test (fn (name got expected) (if (= got expected) (set! apl-test-pass (+ apl-test-pass 1)) (begin (set! apl-test-fail (+ apl-test-fail 1)) (set! apl-test-fails (append apl-test-fails (list {:name name :got got :expected expected})))))))")
 (epoch 3)
+(load "lib/apl/tests/structural.sx")
+(load "lib/apl/tests/operators.sx")
+(load "lib/apl/tests/dfn.sx")
+(load "lib/apl/tests/tradfn.sx")
+(load "lib/apl/tests/valence.sx")
+(load "lib/apl/tests/programs.sx")
+(load "lib/apl/tests/system.sx")
+(load "lib/apl/tests/idioms.sx")
+(load "lib/apl/tests/eval-ops.sx")
+(load "lib/apl/tests/pipeline.sx")
+(load "lib/apl/tests/programs-e2e.sx")
+(epoch 4)
 (eval "(list apl-test-pass apl-test-fail)")
 EPOCHS
 
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
+OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
 
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
+LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
 if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
+  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
+          | sed -E 's/^\(ok 4 //; s/\)$//')
 fi
 if [ -z "$LINE" ]; then
   echo "ERROR: could not extract summary"

lib/apl/tests/dfn.sx

@@ -0,0 +1,227 @@
+; Tests for apl-eval-ast and apl-call-dfn (manual AST construction).
+
+(define rv (fn (arr) (get arr :ravel)))
+(define sh (fn (arr) (get arr :shape)))
+
+(define mknum (fn (n) (list :num n)))
+(define mkname (fn (s) (list :name s)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad (mkfg g) a)))
+(define mkdyd (fn (g l r) (list :dyad (mkfg g) l r)))
+(define mkdfn1 (fn (body) (list :dfn body)))
+(define mkprog (fn (stmts) (cons :program stmts)))
+
+(define mkasg (fn (mkname expr) (list :assign mkname expr)))
+
+(define mkgrd (fn (c e) (list :guard c e)))
+
+(define mkdfn (fn (stmts) (cons :dfn stmts)))
+
+(apl-test
+  "eval :num literal"
+  (rv (apl-eval-ast (mknum 42) {}))
+  (list 42))
+
+(apl-test
+  "eval :num literal shape"
+  (sh (apl-eval-ast (mknum 42) {}))
+  (list))
+
+(apl-test
+  "eval :dyad +"
+  (rv (apl-eval-ast (mkdyd "+" (mknum 2) (mknum 3)) {}))
+  (list 5))
+
+(apl-test
+  "eval :dyad ×"
+  (rv (apl-eval-ast (mkdyd "×" (mknum 6) (mknum 7)) {}))
+  (list 42))
+
+(apl-test
+  "eval :monad - (negate)"
+  (rv (apl-eval-ast (mkmon "-" (mknum 7)) {}))
+  (list -7))
+
+(apl-test
+  "eval :monad ⌊ (floor)"
+  (rv (apl-eval-ast (mkmon "⌊" (mknum 3)) {}))
+  (list 3))
+
+(apl-test
+  "eval :name ⍵ from env"
+  (rv (apl-eval-ast (mkname "⍵") {:omega (apl-scalar 99) :alpha nil}))
+  (list 99))
+
+(apl-test
+  "eval :name ⍺ from env"
+  (rv (apl-eval-ast (mkname "⍺") {:omega nil :alpha (apl-scalar 7)}))
+  (list 7))
+
+(apl-test
+  "dfn {⍵+1} called monadic"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn1 (mkdyd "+" (mkname "⍵") (mknum 1)))
+      (apl-scalar 5)))
+  (list 6))
+
+(apl-test
+  "dfn {⍺+⍵} called dyadic"
+  (rv
+    (apl-call-dfn
+      (mkdfn1 (mkdyd "+" (mkname "⍺") (mkname "⍵")))
+      (apl-scalar 4)
+      (apl-scalar 9)))
+  (list 13))
+
+(apl-test
+  "dfn {⍺×⍵} dyadic on vectors"
+  (rv
+    (apl-call-dfn
+      (mkdfn1 (mkdyd "×" (mkname "⍺") (mkname "⍵")))
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 10 40 90))
+
+(apl-test
+  "dfn {-⍵} monadic negate"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn1 (mkmon "-" (mkname "⍵")))
+      (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "dfn {⍺-⍵} dyadic subtract scalar"
+  (rv
+    (apl-call-dfn
+      (mkdfn1 (mkdyd "-" (mkname "⍺") (mkname "⍵")))
+      (apl-scalar 10)
+      (apl-scalar 3)))
+  (list 7))
+
+(apl-test
+  "dfn {⌈⍺,⍵} not used (just verify : missing) — ceiling of right"
+  (rv
+    (apl-call-dfn-m (mkdfn1 (mkmon "⌈" (mkname "⍵"))) (apl-scalar 5)))
+  (list 5))
+
+(apl-test
+  "dfn nested dyad"
+  (rv
+    (apl-call-dfn
+      (mkdfn1
+        (mkdyd "+" (mkname "⍺") (mkdyd "×" (mkname "⍵") (mknum 2))))
+      (apl-scalar 1)
+      (apl-scalar 3)))
+  (list 7))
+
+(apl-test
+  "dfn local assign x←⍵+1; ⍺×x"
+  (rv
+    (apl-call-dfn
+      (mkdfn
+        (list
+          (mkasg "x" (mkdyd "+" (mkname "⍵") (mknum 1)))
+          (mkdyd "×" (mkname "⍺") (mkname "x"))))
+      (apl-scalar 3)
+      (apl-scalar 4)))
+  (list 15))
+
+(apl-test
+  "dfn guard: 0=⍵:99; ⍵×2 (true branch)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 99))
+          (mkdyd "×" (mkname "⍵") (mknum 2))))
+      (apl-scalar 0)))
+  (list 99))
+
+(apl-test
+  "dfn guard: 0=⍵:99; ⍵×2 (false branch)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 99))
+          (mkdyd "×" (mkname "⍵") (mknum 2))))
+      (apl-scalar 5)))
+  (list 10))
+
+(apl-test
+  "dfn default ⍺←10 used (monadic call)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkasg "⍺" (mknum 10))
+          (mkdyd "+" (mkname "⍺") (mkname "⍵"))))
+      (apl-scalar 5)))
+  (list 15))
+
+(apl-test
+  "dfn default ⍺←10 ignored when ⍺ given (dyadic call)"
+  (rv
+    (apl-call-dfn
+      (mkdfn
+        (list
+          (mkasg "⍺" (mknum 10))
+          (mkdyd "+" (mkname "⍺") (mkname "⍵"))))
+      (apl-scalar 100)
+      (apl-scalar 5)))
+  (list 105))
+
+(apl-test
+  "dfn ∇ recursion: factorial via guard"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 1))
+          (mkdyd
+            "×"
+            (mkname "⍵")
+            (mkmon "∇" (mkdyd "-" (mkname "⍵") (mknum 1))))))
+      (apl-scalar 5)))
+  (list 120))
+
+(apl-test
+  "dfn ∇ recursion: 3 → 6 (factorial)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 1))
+          (mkdyd
+            "×"
+            (mkname "⍵")
+            (mkmon "∇" (mkdyd "-" (mkname "⍵") (mknum 1))))))
+      (apl-scalar 3)))
+  (list 6))
+
+(apl-test
+  "dfn local: x←⍵+10; y←x×2; y"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkasg "x" (mkdyd "+" (mkname "⍵") (mknum 10)))
+          (mkasg "y" (mkdyd "×" (mkname "x") (mknum 2)))
+          (mkname "y")))
+      (apl-scalar 5)))
+  (list 30))
+
+(apl-test
+  "dfn first guard wins: many guards"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 1) (mkname "⍵")) (mknum 100))
+          (mkgrd (mkdyd "=" (mknum 2) (mkname "⍵")) (mknum 200))
+          (mkgrd (mkdyd "=" (mknum 3) (mkname "⍵")) (mknum 300))
+          (mknum 0)))
+      (apl-scalar 2)))
+  (list 200))

lib/apl/tests/eval-ops.sx

@@ -0,0 +1,147 @@
+; Tests for operator handling in apl-eval-ast (Phase 7).
+; Manual AST construction; verifies :derived-fn / :outer / :derived-fn2
+; route through apl-resolve-monadic / apl-resolve-dyadic correctly.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+(define mknum (fn (n) (list :num n)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad g a)))
+(define mkdyd (fn (g l r) (list :dyad g l r)))
+(define mkder (fn (op f) (list :derived-fn op f)))
+(define mkdr2 (fn (op f g) (list :derived-fn2 op f g)))
+(define mkout (fn (f) (list :outer "∘." f)))
+
+; helper: literal vector AST via :vec (from list of values)
+(define mkvec (fn (xs) (cons :vec (map (fn (n) (mknum n)) xs))))
+
+; ---------- monadic operators ----------
+
+(apl-test
+  "eval-ast +/ ⍳5 → 15"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "/" (mkfg "+")) (mkmon (mkfg "⍳") (mknum 5)))
+      {}))
+  (list 15))
+
+(apl-test
+  "eval-ast ×/ ⍳5 → 120"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "/" (mkfg "×")) (mkmon (mkfg "⍳") (mknum 5)))
+      {}))
+  (list 120))
+
+(apl-test
+  "eval-ast ⌈/ — max reduce"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "/" (mkfg "⌈")) (mkvec (list 3 1 4 1 5 9 2 6)))
+      {}))
+  (list 9))
+
+(apl-test
+  "eval-ast +\\ scan"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "\\" (mkfg "+")) (mkvec (list 1 2 3 4 5)))
+      {}))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "eval-ast +⌿ first-axis reduce on vector"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "⌿" (mkfg "+")) (mkvec (list 1 2 3 4 5)))
+      {}))
+  (list 15))
+
+(apl-test
+  "eval-ast -¨ each-negate"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "¨" (mkfg "-")) (mkvec (list 1 2 3 4)))
+      {}))
+  (list -1 -2 -3 -4))
+
+(apl-test
+  "eval-ast +⍨ commute (double via x+x)"
+  (mkrv
+    (apl-eval-ast (mkmon (mkder "⍨" (mkfg "+")) (mknum 7)) {}))
+  (list 14))
+
+; ---------- dyadic operators ----------
+
+(apl-test
+  "eval-ast outer ∘.× — multiplication table"
+  (mkrv
+    (apl-eval-ast
+      (mkdyd
+        (mkout (mkfg "×"))
+        (mkvec (list 1 2 3))
+        (mkvec (list 1 2 3)))
+      {}))
+  (list 1 2 3 2 4 6 3 6 9))
+
+(apl-test
+  "eval-ast outer ∘.× shape (3 3)"
+  (mksh
+    (apl-eval-ast
+      (mkdyd
+        (mkout (mkfg "×"))
+        (mkvec (list 1 2 3))
+        (mkvec (list 1 2 3)))
+      {}))
+  (list 3 3))
+
+(apl-test
+  "eval-ast inner +.× — dot product"
+  (mkrv
+    (apl-eval-ast
+      (mkdyd
+        (mkdr2 "." (mkfg "+") (mkfg "×"))
+        (mkvec (list 1 2 3))
+        (mkvec (list 4 5 6)))
+      {}))
+  (list 32))
+
+(apl-test
+  "eval-ast inner ∧.= equal vectors"
+  (mkrv
+    (apl-eval-ast
+      (mkdyd
+        (mkdr2 "." (mkfg "∧") (mkfg "="))
+        (mkvec (list 1 2 3))
+        (mkvec (list 1 2 3)))
+      {}))
+  (list 1))
+
+(apl-test
+  "eval-ast each-dyadic +¨"
+  (mkrv
+    (apl-eval-ast
+      (mkdyd
+        (mkder "¨" (mkfg "+"))
+        (mkvec (list 1 2 3))
+        (mkvec (list 10 20 30)))
+      {}))
+  (list 11 22 33))
+
+(apl-test
+  "eval-ast commute -⍨ (subtract swapped)"
+  (mkrv
+    (apl-eval-ast
+      (mkdyd (mkder "⍨" (mkfg "-")) (mknum 5) (mknum 3))
+      {}))
+  (list -2))
+
+; ---------- nested operators ----------
+
+(apl-test
+  "eval-ast +/¨ — sum of each"
+  (mkrv
+    (apl-eval-ast
+      (mkmon (mkder "/" (mkfg "+")) (mkvec (list 10 20 30)))
+      {}))
+  (list 60))

lib/apl/tests/idioms.sx

@@ -0,0 +1,359 @@
+; APL idiom corpus — classic Roger Hui / Phil Last idioms expressed
+; through our runtime primitives.  Each test names the APL one-liner
+; and verifies the equivalent runtime call.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+; ---------- reductions ----------
+
+(apl-test
+  "+/⍵ — sum"
+  (mkrv (apl-reduce apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 15))
+
+(apl-test
+  "(+/⍵)÷⍴⍵ — mean"
+  (mkrv
+    (apl-div
+      (apl-reduce apl-add (make-array (list 5) (list 1 2 3 4 5)))
+      (apl-scalar 5)))
+  (list 3))
+
+(apl-test
+  "⌈/⍵ — max"
+  (mkrv (apl-reduce apl-max (make-array (list 6) (list 3 1 4 1 5 9))))
+  (list 9))
+
+(apl-test
+  "⌊/⍵ — min"
+  (mkrv (apl-reduce apl-min (make-array (list 6) (list 3 1 4 1 5 9))))
+  (list 1))
+
+(apl-test
+  "(⌈/⍵)-⌊/⍵ — range"
+  (mkrv
+    (apl-sub
+      (apl-reduce apl-max (make-array (list 6) (list 3 1 4 1 5 9)))
+      (apl-reduce apl-min (make-array (list 6) (list 3 1 4 1 5 9)))))
+  (list 8))
+
+(apl-test
+  "×/⍵ — product"
+  (mkrv (apl-reduce apl-mul (make-array (list 4) (list 1 2 3 4))))
+  (list 24))
+
+(apl-test
+  "+\\⍵ — running sum"
+  (mkrv (apl-scan apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 3 6 10 15))
+
+; ---------- sort / order ----------
+
+(apl-test
+  "⍵[⍋⍵] — sort ascending"
+  (mkrv (apl-quicksort (make-array (list 5) (list 3 1 4 1 5))))
+  (list 1 1 3 4 5))
+
+(apl-test
+  "⌽⍵ — reverse"
+  (mkrv (apl-reverse (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5 4 3 2 1))
+
+(apl-test
+  "⊃⌽⍵ — last element"
+  (mkrv
+    (apl-disclose (apl-reverse (make-array (list 4) (list 10 20 30 40)))))
+  (list 40))
+
+(apl-test
+  "1↑⍵ — first element"
+  (mkrv
+    (apl-take (apl-scalar 1) (make-array (list 4) (list 10 20 30 40))))
+  (list 10))
+
+(apl-test
+  "1↓⍵ — drop first"
+  (mkrv
+    (apl-drop (apl-scalar 1) (make-array (list 4) (list 10 20 30 40))))
+  (list 20 30 40))
+
+(apl-test
+  "¯1↓⍵ — drop last"
+  (mkrv
+    (apl-drop (apl-scalar -1) (make-array (list 4) (list 10 20 30 40))))
+  (list 10 20 30))
+
+; ---------- counts / membership ----------
+
+(apl-test
+  "≢⍵ — tally"
+  (mkrv (apl-tally (make-array (list 7) (list 9 8 7 6 5 4 3))))
+  (list 7))
+
+(apl-test
+  "+/⍵=v — count occurrences of v"
+  (mkrv
+    (apl-reduce
+      apl-add
+      (apl-eq (make-array (list 7) (list 1 2 3 2 1 3 2)) (apl-scalar 2))))
+  (list 3))
+
+(apl-test
+  "0=N|M — divisibility test"
+  (mkrv (apl-eq (apl-scalar 0) (apl-mod (apl-scalar 3) (apl-scalar 12))))
+  (list 1))
+
+; ---------- shape constructors ----------
+
+(apl-test
+  "N⍴1 — vector of N ones"
+  (mkrv (apl-reshape (apl-scalar 5) (apl-scalar 1)))
+  (list 1 1 1 1 1))
+
+(apl-test
+  "(N N)⍴0 — N×N zero matrix"
+  (mkrv (apl-reshape (make-array (list 2) (list 3 3)) (apl-scalar 0)))
+  (list 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "⍳∘.=⍳ — N×N identity matrix"
+  (mkrv
+    (apl-outer apl-eq (apl-iota (apl-scalar 3)) (apl-iota (apl-scalar 3))))
+  (list 1 0 0 0 1 0 0 0 1))
+
+(apl-test
+  "⍳∘.×⍳ — multiplication table"
+  (mkrv
+    (apl-outer apl-mul (apl-iota (apl-scalar 3)) (apl-iota (apl-scalar 3))))
+  (list 1 2 3 2 4 6 3 6 9))
+
+; ---------- numerical idioms ----------
+
+(apl-test
+  "+\\⍳N — triangular numbers"
+  (mkrv (apl-scan apl-add (apl-iota (apl-scalar 5))))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "+/⍳N=N×(N+1)÷2 — sum of 1..N"
+  (mkrv (apl-reduce apl-add (apl-iota (apl-scalar 10))))
+  (list 55))
+
+(apl-test
+  "×/⍳N — factorial via iota"
+  (mkrv (apl-reduce apl-mul (apl-iota (apl-scalar 5))))
+  (list 120))
+
+(apl-test
+  "2|⍵ — parity (1=odd)"
+  (mkrv (apl-mod (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 0 1 0 1))
+
+(apl-test
+  "+/2|⍵ — count odd"
+  (mkrv
+    (apl-reduce
+      apl-add
+      (apl-mod (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5)))))
+  (list 3))
+
+; ---------- boolean idioms ----------
+
+(apl-test
+  "∧/⍵ — all-true"
+  (mkrv (apl-reduce apl-and (make-array (list 4) (list 1 1 1 1))))
+  (list 1))
+
+(apl-test
+  "∧/⍵ — all-true with zero is false"
+  (mkrv (apl-reduce apl-and (make-array (list 4) (list 1 1 0 1))))
+  (list 0))
+
+(apl-test
+  "∨/⍵ — any-true"
+  (mkrv (apl-reduce apl-or (make-array (list 4) (list 0 0 1 0))))
+  (list 1))
+
+(apl-test
+  "∨/⍵ — any-true all zero is false"
+  (mkrv (apl-reduce apl-or (make-array (list 4) (list 0 0 0 0))))
+  (list 0))
+
+; ---------- selection / scaling ----------
+
+(apl-test
+  "⍵×⍵ — square each"
+  (mkrv
+    (apl-mul
+      (make-array (list 4) (list 1 2 3 4))
+      (make-array (list 4) (list 1 2 3 4))))
+  (list 1 4 9 16))
+
+(apl-test
+  "+/⍵×⍵ — sum of squares"
+  (mkrv
+    (apl-reduce
+      apl-add
+      (apl-mul
+        (make-array (list 4) (list 1 2 3 4))
+        (make-array (list 4) (list 1 2 3 4)))))
+  (list 30))
+
+(apl-test
+  "⍵-(+/⍵)÷⍴⍵ — mean-centered"
+  (mkrv
+    (apl-sub
+      (make-array (list 5) (list 2 4 6 8 10))
+      (apl-div
+        (apl-reduce apl-add (make-array (list 5) (list 2 4 6 8 10)))
+        (apl-scalar 5))))
+  (list -4 -2 0 2 4))
+
+; ---------- shape / structure ----------
+
+(apl-test
+  ",⍵ — ravel"
+  (mkrv (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "⍴⍴⍵ — rank"
+  (mkrv
+    (apl-shape (apl-shape (make-array (list 2 3) (list 1 2 3 4 5 6)))))
+  (list 2))
+
+(apl-test
+  "src: +/⍳N → triangular(N)"
+  (mkrv (apl-run "+/⍳100"))
+  (list 5050))
+
+(apl-test "src: ×/⍳N → N!" (mkrv (apl-run "×/⍳6")) (list 720))
+
+(apl-test
+  "src: ⌈/V — max"
+  (mkrv (apl-run "⌈/3 1 4 1 5 9 2 6"))
+  (list 9))
+
+(apl-test
+  "src: ⌊/V — min"
+  (mkrv (apl-run "⌊/3 1 4 1 5 9 2 6"))
+  (list 1))
+
+(apl-test
+  "src: range = (⌈/V) - ⌊/V"
+  (mkrv (apl-run "(⌈/3 1 4 1 5 9 2 6) - ⌊/3 1 4 1 5 9 2 6"))
+  (list 8))
+
+(apl-test
+  "src: +\\V — running sum"
+  (mkrv (apl-run "+\\1 2 3 4 5"))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "src: ×\\V — running product"
+  (mkrv (apl-run "×\\1 2 3 4 5"))
+  (list 1 2 6 24 120))
+
+(apl-test
+  "src: V × V — squares"
+  (mkrv (apl-run "(⍳5) × ⍳5"))
+  (list 1 4 9 16 25))
+
+(apl-test
+  "src: +/V × V — sum of squares"
+  (mkrv (apl-run "+/(⍳5) × ⍳5"))
+  (list 55))
+
+(apl-test "src: ∧/V — all-true" (mkrv (apl-run "∧/1 1 1 1")) (list 1))
+
+(apl-test "src: ∨/V — any-true" (mkrv (apl-run "∨/0 0 1 0")) (list 1))
+
+(apl-test "src: 0 = N|M — divides" (mkrv (apl-run "0 = 3 | 12")) (list 1))
+
+(apl-test
+  "src: 2 | V — parity"
+  (mkrv (apl-run "2 | 1 2 3 4 5 6"))
+  (list 1 0 1 0 1 0))
+
+(apl-test
+  "src: +/2|V — count odd"
+  (mkrv (apl-run "+/2 | 1 2 3 4 5 6"))
+  (list 3))
+
+(apl-test "src: ⍴ V" (mkrv (apl-run "⍴ 1 2 3 4 5")) (list 5))
+
+(apl-test
+  "src: ⍴⍴ M — rank"
+  (mkrv (apl-run "⍴ ⍴ (2 3) ⍴ ⍳6"))
+  (list 2))
+
+(apl-test
+  "src: N⍴1 — vector of ones"
+  (mkrv (apl-run "5 ⍴ 1"))
+  (list 1 1 1 1 1))
+
+(apl-test
+  "src: ⍳N ∘.= ⍳N — identity matrix"
+  (mkrv (apl-run "(⍳3) ∘.= ⍳3"))
+  (list 1 0 0 0 1 0 0 0 1))
+
+(apl-test
+  "src: ⍳N ∘.× ⍳N — multiplication table"
+  (mkrv (apl-run "(⍳3) ∘.× ⍳3"))
+  (list 1 2 3 2 4 6 3 6 9))
+
+(apl-test
+  "src: V +.× V — dot product"
+  (mkrv (apl-run "1 2 3 +.× 4 5 6"))
+  (list 32))
+
+(apl-test
+  "src: ∧.= V — vectors equal?"
+  (mkrv (apl-run "1 2 3 ∧.= 1 2 3"))
+  (list 1))
+
+(apl-test
+  "src: V[1] — first element"
+  (mkrv (apl-run "(10 20 30 40)[1]"))
+  (list 10))
+
+(apl-test
+  "src: 1↑V — first via take"
+  (mkrv (apl-run "1 ↑ 10 20 30 40"))
+  (list 10))
+
+(apl-test
+  "src: 1↓V — drop first"
+  (mkrv (apl-run "1 ↓ 10 20 30 40"))
+  (list 20 30 40))
+
+(apl-test
+  "src: ¯1↓V — drop last"
+  (mkrv (apl-run "¯1 ↓ 10 20 30 40"))
+  (list 10 20 30))
+
+(apl-test
+  "src: ⌽V — reverse"
+  (mkrv (apl-run "⌽ 1 2 3 4 5"))
+  (list 5 4 3 2 1))
+
+(apl-test
+  "src: ≢V — tally"
+  (mkrv (apl-run "≢ 9 8 7 6 5 4 3 2 1"))
+  (list 9))
+
+(apl-test
+  "src: ,M — ravel"
+  (mkrv (apl-run ", (2 3) ⍴ ⍳6"))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "src: A=V — count occurrences"
+  (mkrv (apl-run "+/2 = 1 2 3 2 1 3 2"))
+  (list 3))
+
+(apl-test
+  "src: ⌈/(V × V) — max squared"
+  (mkrv (apl-run "⌈/(1 2 3 4 5) × 1 2 3 4 5"))
+  (list 25))

lib/apl/tests/operators.sx

@@ -0,0 +1,791 @@
+(define rv (fn (arr) (get arr :ravel)))
+(define sh (fn (arr) (get arr :shape)))
+
+(apl-test
+  "reduce +/ vector"
+  (rv (apl-reduce apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 15))
+
+(apl-test
+  "reduce x/ vector"
+  (rv (apl-reduce apl-mul (make-array (list 4) (list 1 2 3 4))))
+  (list 24))
+
+(apl-test
+  "reduce max/ vector"
+  (rv (apl-reduce apl-max (make-array (list 5) (list 3 1 4 1 5))))
+  (list 5))
+
+(apl-test
+  "reduce min/ vector"
+  (rv (apl-reduce apl-min (make-array (list 3) (list 3 1 4))))
+  (list 1))
+
+(apl-test
+  "reduce and/ all true"
+  (rv (apl-reduce apl-and (make-array (list 3) (list 1 1 1))))
+  (list 1))
+
+(apl-test
+  "reduce or/ with true"
+  (rv (apl-reduce apl-or (make-array (list 3) (list 0 0 1))))
+  (list 1))
+
+(apl-test
+  "reduce +/ single element"
+  (rv (apl-reduce apl-add (make-array (list 1) (list 42))))
+  (list 42))
+
+(apl-test
+  "reduce +/ scalar no-op"
+  (rv (apl-reduce apl-add (apl-scalar 7)))
+  (list 7))
+
+(apl-test
+  "reduce +/ shape is scalar"
+  (sh (apl-reduce apl-add (make-array (list 4) (list 1 2 3 4))))
+  (list))
+
+(apl-test
+  "reduce +/ matrix row sums shape"
+  (sh (apl-reduce apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2))
+
+(apl-test
+  "reduce +/ matrix row sums values"
+  (rv (apl-reduce apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 6 15))
+
+(apl-test
+  "reduce max/ matrix row maxima"
+  (rv (apl-reduce apl-max (make-array (list 2 3) (list 3 1 4 1 5 9))))
+  (list 4 9))
+
+(apl-test
+  "reduce-first +/ vector same as reduce"
+  (rv (apl-reduce-first apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 15))
+
+(apl-test
+  "reduce-first +/ matrix col sums shape"
+  (sh
+    (apl-reduce-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3))
+
+(apl-test
+  "reduce-first +/ matrix col sums values"
+  (rv
+    (apl-reduce-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 5 7 9))
+
+(apl-test
+  "reduce-first max/ matrix col maxima"
+  (rv
+    (apl-reduce-first apl-max (make-array (list 3 2) (list 1 9 2 8 3 7))))
+  (list 3 9))
+
+(apl-test
+  "scan +\\ vector"
+  (rv (apl-scan apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "scan x\\ vector cumulative product"
+  (rv (apl-scan apl-mul (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 6 24 120))
+
+(apl-test
+  "scan max\\ vector running max"
+  (rv (apl-scan apl-max (make-array (list 5) (list 3 1 4 1 5))))
+  (list 3 3 4 4 5))
+
+(apl-test
+  "scan min\\ vector running min"
+  (rv (apl-scan apl-min (make-array (list 5) (list 3 1 4 1 5))))
+  (list 3 1 1 1 1))
+
+(apl-test
+  "scan +\\ single element"
+  (rv (apl-scan apl-add (make-array (list 1) (list 42))))
+  (list 42))
+
+(apl-test
+  "scan +\\ scalar no-op"
+  (rv (apl-scan apl-add (apl-scalar 7)))
+  (list 7))
+
+(apl-test
+  "scan +\\ vector preserves shape"
+  (sh (apl-scan apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5))
+
+(apl-test
+  "scan +\\ matrix preserves shape"
+  (sh (apl-scan apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "scan +\\ matrix row-wise"
+  (rv (apl-scan apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 3 6 4 9 15))
+
+(apl-test
+  "scan max\\ matrix row-wise running max"
+  (rv (apl-scan apl-max (make-array (list 2 3) (list 3 1 4 1 5 9))))
+  (list 3 3 4 1 5 9))
+
+(apl-test
+  "scan-first +\\ vector same as scan"
+  (rv (apl-scan-first apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "scan-first +\\ scalar no-op"
+  (rv (apl-scan-first apl-add (apl-scalar 9)))
+  (list 9))
+
+(apl-test
+  "scan-first +\\ matrix preserves shape"
+  (sh (apl-scan-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "scan-first +\\ matrix col-wise"
+  (rv (apl-scan-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 5 7 9))
+
+(apl-test
+  "scan-first max\\ matrix col-wise running max"
+  (rv (apl-scan-first apl-max (make-array (list 3 2) (list 3 1 4 1 5 9))))
+  (list 3 1 4 1 5 9))
+
+(apl-test
+  "each negate vector"
+  (rv (apl-each apl-neg-m (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "each negate vector preserves shape"
+  (sh (apl-each apl-neg-m (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "each reciprocal vector"
+  (rv (apl-each apl-recip (make-array (list 3) (list 1 2 4))))
+  (list 1 (/ 1 2) (/ 1 4)))
+
+(apl-test
+  "each abs vector"
+  (rv (apl-each apl-abs (make-array (list 4) (list -1 2 -3 4))))
+  (list 1 2 3 4))
+
+(apl-test "each scalar" (rv (apl-each apl-neg-m (apl-scalar 5))) (list -5))
+
+(apl-test
+  "each scalar shape"
+  (sh (apl-each apl-neg-m (apl-scalar 5)))
+  (list))
+
+(apl-test
+  "each negate matrix shape"
+  (sh (apl-each apl-neg-m (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "each negate matrix values"
+  (rv (apl-each apl-neg-m (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list -1 -2 -3 -4 -5 -6))
+
+(apl-test
+  "each-dyadic scalar+scalar"
+  (rv (apl-each-dyadic apl-add (apl-scalar 3) (apl-scalar 4)))
+  (list 7))
+
+(apl-test
+  "each-dyadic scalar+vector"
+  (rv
+    (apl-each-dyadic
+      apl-add
+      (apl-scalar 10)
+      (make-array (list 3) (list 1 2 3))))
+  (list 11 12 13))
+
+(apl-test
+  "each-dyadic vector+scalar"
+  (rv
+    (apl-each-dyadic
+      apl-add
+      (make-array (list 3) (list 1 2 3))
+      (apl-scalar 10)))
+  (list 11 12 13))
+
+(apl-test
+  "each-dyadic vector+vector"
+  (rv
+    (apl-each-dyadic
+      apl-add
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 22 33))
+
+(apl-test
+  "each-dyadic mul matrix+matrix shape"
+  (sh
+    (apl-each-dyadic
+      apl-mul
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 2 2) (list 5 6 7 8))))
+  (list 2 2))
+
+(apl-test
+  "each-dyadic mul matrix+matrix values"
+  (rv
+    (apl-each-dyadic
+      apl-mul
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 2 2) (list 5 6 7 8))))
+  (list 5 12 21 32))
+
+(apl-test
+  "outer product mult table values"
+  (rv
+    (apl-outer
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3 2 4 6 3 6 9))
+
+(apl-test
+  "outer product mult table shape"
+  (sh
+    (apl-outer
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 3 3))
+
+(apl-test
+  "outer product add table values"
+  (rv
+    (apl-outer
+      apl-add
+      (make-array (list 2) (list 1 2))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 21 31 12 22 32))
+
+(apl-test
+  "outer product add table shape"
+  (sh
+    (apl-outer
+      apl-add
+      (make-array (list 2) (list 1 2))
+      (make-array (list 3) (list 10 20 30))))
+  (list 2 3))
+
+(apl-test
+  "outer product scalar+vector shape"
+  (sh
+    (apl-outer apl-mul (apl-scalar 5) (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "outer product scalar+vector values"
+  (rv
+    (apl-outer apl-mul (apl-scalar 5) (make-array (list 3) (list 1 2 3))))
+  (list 5 10 15))
+
+(apl-test
+  "outer product vector+scalar shape"
+  (sh
+    (apl-outer apl-mul (make-array (list 3) (list 1 2 3)) (apl-scalar 10)))
+  (list 3))
+
+(apl-test
+  "outer product scalar+scalar"
+  (rv (apl-outer apl-mul (apl-scalar 6) (apl-scalar 7)))
+  (list 42))
+
+(apl-test
+  "outer product scalar+scalar shape"
+  (sh (apl-outer apl-mul (apl-scalar 6) (apl-scalar 7)))
+  (list))
+
+(apl-test
+  "outer product equality identity matrix values"
+  (rv
+    (apl-outer
+      apl-eq
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1 0 0 0 1 0 0 0 1))
+
+(apl-test
+  "outer product matrix+vector rank doubling shape"
+  (sh
+    (apl-outer
+      apl-add
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 3) (list 10 20 30))))
+  (list 2 2 3))
+
+(apl-test
+  "outer product matrix+vector rank doubling values"
+  (rv
+    (apl-outer
+      apl-add
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 21 31 12 22 32 13 23 33 14 24 34))
+
+(apl-test
+  "inner +.× dot product"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 4 5 6))))
+  (list 32))
+
+(apl-test
+  "inner +.× dot product shape is scalar"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 4 5 6))))
+  (list))
+
+(apl-test
+  "inner +.× matrix multiply 2x3 * 3x2 shape"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 2) (list 7 8 9 10 11 12))))
+  (list 2 2))
+
+(apl-test
+  "inner +.× matrix multiply 2x3 * 3x2 values"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 2) (list 7 8 9 10 11 12))))
+  (list 58 64 139 154))
+
+(apl-test
+  "inner +.× identity matrix 2x2"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 2) (list 1 0 0 1))
+      (make-array (list 2 2) (list 5 6 7 8))))
+  (list 5 6 7 8))
+
+(apl-test
+  "inner ∧.= equal vectors"
+  (rv
+    (apl-inner
+      apl-and
+      apl-eq
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1))
+
+(apl-test
+  "inner ∧.= unequal vectors"
+  (rv
+    (apl-inner
+      apl-and
+      apl-eq
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 9 3))))
+  (list 0))
+
+(apl-test
+  "inner +.× matrix * vector shape"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 7 8 9))))
+  (list 2))
+
+(apl-test
+  "inner +.× matrix * vector values"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 7 8 9))))
+  (list 50 122))
+
+(apl-test
+  "inner +.× vector * matrix shape"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3 2) (list 4 5 6 7 8 9))))
+  (list 2))
+
+(apl-test
+  "inner +.× vector * matrix values"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3 2) (list 4 5 6 7 8 9))))
+  (list 40 46))
+
+(apl-test
+  "inner +.× single-element vectors"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 1) (list 6))
+      (make-array (list 1) (list 7))))
+  (list 42))
+
+(apl-test
+  "commute +⍨ scalar doubles"
+  (rv (apl-commute apl-add (apl-scalar 5)))
+  (list 10))
+
+(apl-test
+  "commute ×⍨ vector squares"
+  (rv (apl-commute apl-mul (make-array (list 4) (list 1 2 3 4))))
+  (list 1 4 9 16))
+
+(apl-test
+  "commute +⍨ vector doubles"
+  (rv (apl-commute apl-add (make-array (list 3) (list 1 2 3))))
+  (list 2 4 6))
+
+(apl-test
+  "commute +⍨ shape preserved"
+  (sh (apl-commute apl-add (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "commute ×⍨ matrix shape preserved"
+  (sh (apl-commute apl-mul (make-array (list 2 2) (list 1 2 3 4))))
+  (list 2 2))
+
+(apl-test
+  "commute-dyadic -⍨ swaps subtraction"
+  (rv (apl-commute-dyadic apl-sub (apl-scalar 5) (apl-scalar 3)))
+  (list -2))
+
+(apl-test
+  "commute-dyadic ÷⍨ swaps division"
+  (rv (apl-commute-dyadic apl-div (apl-scalar 4) (apl-scalar 12)))
+  (list 3))
+
+(apl-test
+  "commute-dyadic -⍨ on vectors"
+  (rv
+    (apl-commute-dyadic
+      apl-sub
+      (make-array (list 3) (list 10 20 30))
+      (make-array (list 3) (list 1 2 3))))
+  (list -9 -18 -27))
+
+(apl-test
+  "commute-dyadic +⍨ commutative same result"
+  (rv
+    (apl-commute-dyadic
+      apl-add
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 22 33))
+
+(apl-test
+  "commute-dyadic ×⍨ commutative same result"
+  (rv
+    (apl-commute-dyadic
+      apl-mul
+      (make-array (list 3) (list 2 3 4))
+      (make-array (list 3) (list 5 6 7))))
+  (list 10 18 28))
+
+(apl-test
+  "compose -∘| scalar (negative abs)"
+  (rv (apl-compose apl-neg-m apl-abs (apl-scalar -7)))
+  (list -7))
+
+(apl-test
+  "compose -∘| vector"
+  (rv
+    (apl-compose apl-neg-m apl-abs (make-array (list 4) (list -1 2 -3 4))))
+  (list -1 -2 -3 -4))
+
+(apl-test
+  "compose ⌊∘- (floor of negate)"
+  (rv (apl-compose apl-floor apl-neg-m (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "compose -∘| matrix shape preserved"
+  (sh
+    (apl-compose apl-neg-m apl-abs (make-array (list 2 2) (list -1 2 -3 4))))
+  (list 2 2))
+
+(apl-test
+  "compose-dyadic +∘- equals subtract scalar"
+  (rv (apl-compose-dyadic apl-add apl-neg-m (apl-scalar 10) (apl-scalar 3)))
+  (list 7))
+
+(apl-test
+  "compose-dyadic +∘- equals subtract vector"
+  (rv
+    (apl-compose-dyadic
+      apl-add
+      apl-neg-m
+      (make-array (list 3) (list 10 20 30))
+      (make-array (list 3) (list 1 2 3))))
+  (list 9 18 27))
+
+(apl-test
+  "compose-dyadic -∘| (subtract abs)"
+  (rv (apl-compose-dyadic apl-sub apl-abs (apl-scalar 10) (apl-scalar -3)))
+  (list 7))
+
+(apl-test
+  "compose-dyadic ×∘- (multiply by negative)"
+  (rv
+    (apl-compose-dyadic
+      apl-mul
+      apl-neg-m
+      (make-array (list 3) (list 2 3 4))
+      (make-array (list 3) (list 1 2 3))))
+  (list -2 -6 -12))
+
+(apl-test
+  "compose-dyadic shape preserved"
+  (sh
+    (apl-compose-dyadic
+      apl-add
+      apl-neg-m
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 2 3) (list 1 1 1 1 1 1))))
+  (list 2 3))
+
+(apl-test
+  "power n=0 identity"
+  (rv (apl-power (fn (a) (apl-add a (apl-scalar 1))) 0 (apl-scalar 5)))
+  (list 5))
+
+(apl-test
+  "power increment by 3"
+  (rv (apl-power (fn (a) (apl-add a (apl-scalar 1))) 3 (apl-scalar 0)))
+  (list 3))
+
+(apl-test
+  "power double 4 times = 16"
+  (rv (apl-power (fn (a) (apl-mul a (apl-scalar 2))) 4 (apl-scalar 1)))
+  (list 16))
+
+(apl-test
+  "power on vector +5"
+  (rv
+    (apl-power
+      (fn (a) (apl-add a (apl-scalar 1)))
+      5
+      (make-array (list 3) (list 1 2 3))))
+  (list 6 7 8))
+
+(apl-test
+  "power on vector preserves shape"
+  (sh
+    (apl-power
+      (fn (a) (apl-add a (apl-scalar 1)))
+      5
+      (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "power on matrix"
+  (rv
+    (apl-power
+      (fn (a) (apl-mul a (apl-scalar 3)))
+      2
+      (make-array (list 2 2) (list 1 2 3 4))))
+  (list 9 18 27 36))
+
+(apl-test
+  "power-fixed identity stops immediately"
+  (rv (apl-power-fixed (fn (a) a) (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "power-fixed floor half scalar to 0"
+  (rv
+    (apl-power-fixed
+      (fn (a) (apl-floor (apl-div a (apl-scalar 2))))
+      (apl-scalar 100)))
+  (list 0))
+
+(apl-test
+  "power-fixed shape preserved"
+  (sh
+    (apl-power-fixed (fn (a) a) (make-array (list 2 2) (list 1 2 3 4))))
+  (list 2 2))
+
+(apl-test
+  "rank tally⍤1 row tallies"
+  (rv (apl-rank apl-tally 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 3))
+
+(apl-test
+  "rank tally⍤1 row tallies shape"
+  (sh (apl-rank apl-tally 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2))
+
+(apl-test
+  "rank neg⍤0 vector scalar cells"
+  (rv (apl-rank apl-neg-m 0 (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "rank neg⍤0 vector preserves shape"
+  (sh (apl-rank apl-neg-m 0 (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "rank neg⍤1 matrix per-row"
+  (rv (apl-rank apl-neg-m 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list -1 -2 -3 -4 -5 -6))
+
+(apl-test
+  "rank neg⍤1 matrix preserves shape"
+  (sh (apl-rank apl-neg-m 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "rank k>=rank fallthrough"
+  (rv (apl-rank apl-tally 5 (make-array (list 4) (list 1 2 3 4))))
+  (list 4))
+
+(apl-test
+  "rank tally⍤2 whole matrix tally"
+  (rv
+    (apl-rank
+      apl-tally
+      2
+      (make-array (list 3 5) (list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))))
+  (list 3))
+
+(apl-test
+  "rank reverse⍤1 matrix reverse rows"
+  (rv (apl-rank apl-reverse 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2 1 6 5 4))
+
+(apl-test
+  "rank tally⍤1 3x4 row tallies"
+  (rv
+    (apl-rank
+      apl-tally
+      1
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 4 4 4))
+
+(apl-test
+  "at-replace single index"
+  (rv
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 2))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 99 3 4 5))
+
+(apl-test
+  "at-replace multiple indices vector vals"
+  (rv
+    (apl-at-replace
+      (make-array (list 2) (list 99 88))
+      (make-array (list 2) (list 2 4))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 99 3 88 5))
+
+(apl-test
+  "at-replace scalar broadcast"
+  (rv
+    (apl-at-replace
+      (apl-scalar 0)
+      (make-array (list 3) (list 1 3 5))
+      (make-array (list 5) (list 10 20 30 40 50))))
+  (list 0 20 0 40 0))
+
+(apl-test
+  "at-replace preserves shape"
+  (sh
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 2))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5))
+
+(apl-test
+  "at-replace last index"
+  (rv
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 5))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 99))
+
+(apl-test
+  "at-replace on matrix linear-index"
+  (rv
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 3))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 99 4 5 6))
+
+(apl-test
+  "at-apply negate at indices"
+  (rv
+    (apl-at-apply
+      apl-neg-m
+      (make-array (list 3) (list 1 3 5))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list -1 2 -3 4 -5))
+
+(apl-test
+  "at-apply double at index 1"
+  (rv
+    (apl-at-apply
+      (fn (a) (apl-mul a (apl-scalar 2)))
+      (make-array (list 1) (list 1))
+      (make-array (list 2) (list 5 10))))
+  (list 10 10))
+
+(apl-test
+  "at-apply preserves shape"
+  (sh
+    (apl-at-apply
+      apl-neg-m
+      (make-array (list 2) (list 1 3))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "at-apply on matrix linear-index"
+  (rv
+    (apl-at-apply
+      apl-neg-m
+      (make-array (list 2) (list 1 6))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list -1 2 3 4 5 -6))

lib/apl/tests/parse.sx

@@ -0,0 +1,340 @@
+(define apl-test-count 0)
+(define apl-test-pass  0)
+(define apl-test-fails (list))
+
+(define apl-test
+  (fn (name actual expected)
+    (begin
+      (set! apl-test-count (+ apl-test-count 1))
+      (if (= actual expected)
+        (set! apl-test-pass (+ apl-test-pass 1))
+        (append! apl-test-fails {:name name :actual actual :expected expected})))))
+
+(define tok-types
+  (fn (src)
+    (map (fn (t) (get t :type)) (apl-tokenize src))))
+
+(define tok-values
+  (fn (src)
+    (map (fn (t) (get t :value)) (apl-tokenize src))))
+
+(define tok-count
+  (fn (src)
+    (len (apl-tokenize src))))
+
+(define tok-type-at
+  (fn (src i)
+    (get (nth (apl-tokenize src) i) :type)))
+
+(define tok-value-at
+  (fn (src i)
+    (get (nth (apl-tokenize src) i) :value)))
+
+(apl-test "empty: no tokens"        (tok-count "")           0)
+(apl-test "empty: whitespace only"  (tok-count "   ")        0)
+(apl-test "num: zero"               (tok-values "0")         (list 0))
+(apl-test "num: positive"           (tok-values "42")        (list 42))
+(apl-test "num: large"              (tok-values "12345")     (list 12345))
+(apl-test "num: negative"           (tok-values "¯5")        (list -5))
+(apl-test "num: negative zero"      (tok-values "¯0")        (list 0))
+(apl-test "num: strand count"       (tok-count "1 2 3")      3)
+(apl-test "num: strand types"       (tok-types "1 2 3")      (list :num :num :num))
+(apl-test "num: strand values"      (tok-values "1 2 3")     (list 1 2 3))
+(apl-test "num: neg in strand"      (tok-values "1 ¯2 3")    (list 1 -2 3))
+(apl-test "str: empty"              (tok-values "''")        (list ""))
+(apl-test "str: single char"        (tok-values "'a'")       (list "a"))
+(apl-test "str: word"               (tok-values "'hello'")   (list "hello"))
+(apl-test "str: escaped quote"      (tok-values "''''")      (list "'"))
+(apl-test "str: type"               (tok-types "'abc'")      (list :str))
+(apl-test "name: simple"            (tok-values "foo")       (list "foo"))
+(apl-test "name: type"              (tok-types "foo")        (list :name))
+(apl-test "name: mixed case"        (tok-values "MyVar")     (list "MyVar"))
+(apl-test "name: with digits"       (tok-values "x1")        (list "x1"))
+(apl-test "name: system var"        (tok-values "⎕IO")       (list "⎕IO"))
+(apl-test "name: system var type"   (tok-types "⎕IO")        (list :name))
+(apl-test "glyph: plus"             (tok-types "+")          (list :glyph))
+(apl-test "glyph: plus value"       (tok-values "+")         (list "+"))
+(apl-test "glyph: iota"             (tok-values "⍳")         (list "⍳"))
+(apl-test "glyph: reduce"           (tok-values "+/")        (list "+" "/"))
+(apl-test "glyph: floor"            (tok-values "⌊")         (list "⌊"))
+(apl-test "glyph: rho"              (tok-values "⍴")         (list "⍴"))
+(apl-test "glyph: alpha omega"      (tok-types "⍺ ⍵")        (list :glyph :glyph))
+(apl-test "punct: lparen"           (tok-types "(")          (list :lparen))
+(apl-test "punct: rparen"           (tok-types ")")          (list :rparen))
+(apl-test "punct: brackets"         (tok-types "[42]")       (list :lbracket :num :rbracket))
+(apl-test "punct: braces"           (tok-types "{}")         (list :lbrace :rbrace))
+(apl-test "punct: semi"             (tok-types ";")          (list :semi))
+(apl-test "assign: arrow"           (tok-types "x←1")        (list :name :assign :num))
+(apl-test "diamond: separator"      (tok-types "1⋄2")        (list :num :diamond :num))
+(apl-test "newline: emitted"        (tok-types "1\n2")       (list :num :newline :num))
+(apl-test "comment: skipped"        (tok-count "⍝ ignore me") 0)
+(apl-test "comment: rest ignored"   (tok-count "1 ⍝ note")  1)
+(apl-test "colon: bare"             (tok-types ":")          (list :colon))
+(apl-test "keyword: If"             (tok-values ":If")       (list ":If"))
+(apl-test "keyword: type"           (tok-types ":While")     (list :keyword))
+(apl-test "keyword: EndFor"         (tok-values ":EndFor")   (list ":EndFor"))
+(apl-test "expr: +/ ⍳ 5"           (tok-types "+/ ⍳ 5")     (list :glyph :glyph :glyph :num))
+(apl-test "expr: x←42"             (tok-count "x←42")       3)
+(apl-test "expr: dfn body"          (tok-types "{⍺+⍵}")
+                                    (list :lbrace :glyph :glyph :glyph :rbrace))
+
+(define apl-tokenize-test-summary
+  (str "tokenizer " apl-test-pass "/" apl-test-count
+       (if (= (len apl-test-fails) 0) "" (str " FAILS: " apl-test-fails))))
+
+; ===========================================================================
+; Parser tests
+; ===========================================================================
+
+; Helper: parse an APL source string and return the AST
+(define parse
+  (fn (src) (parse-apl src)))
+
+; Helper: build an expected AST node using keyword-tagged lists
+(define num-node    (fn (n)       (list :num n)))
+(define str-node    (fn (s)       (list :str s)))
+(define name-node   (fn (n)       (list :name n)))
+(define fn-node     (fn (g)       (list :fn-glyph g)))
+(define fn-nm       (fn (n)       (list :fn-name n)))
+(define assign-node (fn (nm expr) (list :assign nm expr)))
+(define monad-node  (fn (f a)     (list :monad f a)))
+(define dyad-node   (fn (f l r)   (list :dyad f l r)))
+(define derived-fn  (fn (op f)    (list :derived-fn op f)))
+(define derived-fn2 (fn (op f g)  (list :derived-fn2 op f g)))
+(define outer-node  (fn (f)       (list :outer "∘." f)))
+(define guard-node  (fn (c e)     (list :guard c e)))
+
+; ---- numeric literals ----
+
+(apl-test "parse: num literal"
+  (parse "42")
+  (num-node 42))
+
+(apl-test "parse: negative num"
+  (parse "¯3")
+  (num-node -3))
+
+(apl-test "parse: zero"
+  (parse "0")
+  (num-node 0))
+
+; ---- string literals ----
+
+(apl-test "parse: str literal"
+  (parse "'hello'")
+  (str-node "hello"))
+
+(apl-test "parse: empty str"
+  (parse "''")
+  (str-node ""))
+
+; ---- name reference ----
+
+(apl-test "parse: name"
+  (parse "x")
+  (name-node "x"))
+
+(apl-test "parse: system name"
+  (parse "⎕IO")
+  (name-node "⎕IO"))
+
+; ---- strands (vec nodes) ----
+
+(apl-test "parse: strand 3 nums"
+  (parse "1 2 3")
+  (list :vec (num-node 1) (num-node 2) (num-node 3)))
+
+(apl-test "parse: strand 2 nums"
+  (parse "1 2")
+  (list :vec (num-node 1) (num-node 2)))
+
+(apl-test "parse: strand with negatives"
+  (parse "1 ¯2 3")
+  (list :vec (num-node 1) (num-node -2) (num-node 3)))
+
+; ---- assignment ----
+
+(apl-test "parse: assignment"
+  (parse "x←42")
+  (assign-node "x" (num-node 42)))
+
+(apl-test "parse: assignment with spaces"
+  (parse "x ← 42")
+  (assign-node "x" (num-node 42)))
+
+(apl-test "parse: assignment of expr"
+  (parse "r←2+3")
+  (assign-node "r" (dyad-node (fn-node "+") (num-node 2) (num-node 3))))
+
+; ---- monadic functions ----
+
+(apl-test "parse: monadic iota"
+  (parse "⍳5")
+  (monad-node (fn-node "⍳") (num-node 5)))
+
+(apl-test "parse: monadic iota with space"
+  (parse "⍳ 5")
+  (monad-node (fn-node "⍳") (num-node 5)))
+
+(apl-test "parse: monadic negate"
+  (parse "-3")
+  (monad-node (fn-node "-") (num-node 3)))
+
+(apl-test "parse: monadic floor"
+  (parse "⌊2")
+  (monad-node (fn-node "⌊") (num-node 2)))
+
+(apl-test "parse: monadic of name"
+  (parse "⍴x")
+  (monad-node (fn-node "⍴") (name-node "x")))
+
+; ---- dyadic functions ----
+
+(apl-test "parse: dyadic plus"
+  (parse "2+3")
+  (dyad-node (fn-node "+") (num-node 2) (num-node 3)))
+
+(apl-test "parse: dyadic times"
+  (parse "2×3")
+  (dyad-node (fn-node "×") (num-node 2) (num-node 3)))
+
+(apl-test "parse: dyadic with names"
+  (parse "x+y")
+  (dyad-node (fn-node "+") (name-node "x") (name-node "y")))
+
+; ---- right-to-left evaluation ----
+
+(apl-test "parse: right-to-left 2×3+4"
+  (parse "2×3+4")
+  (dyad-node (fn-node "×") (num-node 2)
+    (dyad-node (fn-node "+") (num-node 3) (num-node 4))))
+
+(apl-test "parse: right-to-left chain"
+  (parse "1+2×3-4")
+  (dyad-node (fn-node "+") (num-node 1)
+    (dyad-node (fn-node "×") (num-node 2)
+      (dyad-node (fn-node "-") (num-node 3) (num-node 4)))))
+
+; ---- parenthesized subexpressions ----
+
+(apl-test "parse: parens override order"
+  (parse "(2+3)×4")
+  (dyad-node (fn-node "×")
+    (dyad-node (fn-node "+") (num-node 2) (num-node 3))
+    (num-node 4)))
+
+(apl-test "parse: nested parens"
+  (parse "((2+3))")
+  (dyad-node (fn-node "+") (num-node 2) (num-node 3)))
+
+(apl-test "parse: paren in dyadic right"
+  (parse "2×(3+4)")
+  (dyad-node (fn-node "×") (num-node 2)
+    (dyad-node (fn-node "+") (num-node 3) (num-node 4))))
+
+; ---- operators → derived functions ----
+
+(apl-test "parse: reduce +"
+  (parse "+/x")
+  (monad-node (derived-fn "/" (fn-node "+")) (name-node "x")))
+
+(apl-test "parse: reduce iota"
+  (parse "+/⍳5")
+  (monad-node (derived-fn "/" (fn-node "+"))
+    (monad-node (fn-node "⍳") (num-node 5))))
+
+(apl-test "parse: scan"
+  (parse "+\\x")
+  (monad-node (derived-fn "\\" (fn-node "+")) (name-node "x")))
+
+(apl-test "parse: each"
+  (parse "⍳¨x")
+  (monad-node (derived-fn "¨" (fn-node "⍳")) (name-node "x")))
+
+(apl-test "parse: commute"
+  (parse "-⍨3")
+  (monad-node (derived-fn "⍨" (fn-node "-")) (num-node 3)))
+
+(apl-test "parse: stacked ops"
+  (parse "+/¨x")
+  (monad-node (derived-fn "¨" (derived-fn "/" (fn-node "+"))) (name-node "x")))
+
+; ---- outer product ----
+
+(apl-test "parse: outer product monadic"
+  (parse "∘.×")
+  (outer-node (fn-node "×")))
+
+(apl-test "parse: outer product dyadic names"
+  (parse "x ∘.× y")
+  (dyad-node (outer-node (fn-node "×")) (name-node "x") (name-node "y")))
+
+(apl-test "parse: outer product dyadic strands"
+  (parse "1 2 3 ∘.× 4 5 6")
+  (dyad-node (outer-node (fn-node "×"))
+    (list :vec (num-node 1) (num-node 2) (num-node 3))
+    (list :vec (num-node 4) (num-node 5) (num-node 6))))
+
+; ---- inner product ----
+
+(apl-test "parse: inner product"
+  (parse "+.×")
+  (derived-fn2 "." (fn-node "+") (fn-node "×")))
+
+(apl-test "parse: inner product applied"
+  (parse "a +.× b")
+  (dyad-node (derived-fn2 "." (fn-node "+") (fn-node "×"))
+    (name-node "a") (name-node "b")))
+
+; ---- dfn (anonymous function) ----
+
+(apl-test "parse: simple dfn"
+  (parse "{⍺+⍵}")
+  (list :dfn (dyad-node (fn-node "+") (name-node "⍺") (name-node "⍵"))))
+
+(apl-test "parse: monadic dfn"
+  (parse "{⍵×2}")
+  (list :dfn (dyad-node (fn-node "×") (name-node "⍵") (num-node 2))))
+
+(apl-test "parse: dfn self-ref"
+  (parse "{⍵≤1:1 ⋄ ⍵×∇ ⍵-1}")
+  (list :dfn
+    (guard-node (dyad-node (fn-node "≤") (name-node "⍵") (num-node 1)) (num-node 1))
+    (dyad-node (fn-node "×") (name-node "⍵")
+      (monad-node (fn-node "∇") (dyad-node (fn-node "-") (name-node "⍵") (num-node 1))))))
+
+; ---- dfn applied ----
+
+(apl-test "parse: dfn as function"
+  (parse "{⍺+⍵} 3")
+  (monad-node
+    (list :dfn (dyad-node (fn-node "+") (name-node "⍺") (name-node "⍵")))
+    (num-node 3)))
+
+; ---- multi-statement ----
+
+(apl-test "parse: diamond separator"
+  (let ((result (parse "x←1 ⋄ x+2")))
+    (= (first result) :program))
+  true)
+
+(apl-test "parse: diamond first stmt"
+  (let ((result (parse "x←1 ⋄ x+2")))
+    (nth result 1))
+  (assign-node "x" (num-node 1)))
+
+(apl-test "parse: diamond second stmt"
+  (let ((result (parse "x←1 ⋄ x+2")))
+    (nth result 2))
+  (dyad-node (fn-node "+") (name-node "x") (num-node 2)))
+
+; ---- combined summary ----
+
+(define apl-parse-test-count (- apl-test-count 46))
+(define apl-parse-test-pass  (- apl-test-pass 46))
+
+(define apl-test-summary
+  (str
+    "tokenizer 46/46  |  "
+    "parser " apl-parse-test-pass "/" apl-parse-test-count
+    (if (= (len apl-test-fails) 0) "" (str "  FAILS: " apl-test-fails))))

lib/apl/tests/pipeline.sx

@@ -0,0 +1,687 @@
+; End-to-end pipeline tests: source string → tokenize → parse → eval-ast → array.
+; Verifies the full stack as a single function call (apl-run).
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+; ---------- scalars ----------
+
+(apl-test "apl-run \"42\" → scalar 42" (mkrv (apl-run "42")) (list 42))
+
+(apl-test "apl-run \"¯7\" → scalar -7" (mkrv (apl-run "¯7")) (list -7))
+
+; ---------- strands ----------
+
+(apl-test
+  "apl-run \"1 2 3\" → vector"
+  (mkrv (apl-run "1 2 3"))
+  (list 1 2 3))
+
+(apl-test "apl-run \"1 2 3\" shape" (mksh (apl-run "1 2 3")) (list 3))
+
+; ---------- dyadic arithmetic ----------
+
+(apl-test "apl-run \"2 + 3\" → 5" (mkrv (apl-run "2 + 3")) (list 5))
+
+(apl-run "2 × 3 + 4")  ; right-to-left
+
+(apl-test
+  "apl-run \"2 × 3 + 4\" → 14 (right-to-left)"
+  (mkrv (apl-run "2 × 3 + 4"))
+  (list 14))
+
+(apl-test
+  "apl-run \"1 2 3 + 4 5 6\" → 5 7 9"
+  (mkrv (apl-run "1 2 3 + 4 5 6"))
+  (list 5 7 9))
+
+(apl-test
+  "apl-run \"3 × 1 2 3 4\" → scalar broadcast"
+  (mkrv (apl-run "3 × 1 2 3 4"))
+  (list 3 6 9 12))
+
+; ---------- monadic primitives ----------
+
+(apl-test
+  "apl-run \"⍳5\" → 1..5"
+  (mkrv (apl-run "⍳5"))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "apl-run \"-3\" → -3 (monadic negate)"
+  (mkrv (apl-run "-3"))
+  (list -3))
+
+(apl-test
+  "apl-run \"⌈/ 1 3 9 5 7\" → 9 (max-reduce)"
+  (mkrv (apl-run "⌈/ 1 3 9 5 7"))
+  (list 9))
+
+(apl-test
+  "apl-run \"⌊/ 4 7 2 9 1 3\" → 1 (min-reduce)"
+  (mkrv (apl-run "⌊/ 4 7 2 9 1 3"))
+  (list 1))
+
+; ---------- operators ----------
+
+(apl-test "apl-run \"+/⍳5\" → 15" (mkrv (apl-run "+/⍳5")) (list 15))
+
+(apl-test "apl-run \"×/⍳5\" → 120" (mkrv (apl-run "×/⍳5")) (list 120))
+
+(apl-test
+  "apl-run \"⌈/3 1 4 1 5 9 2\" → 9"
+  (mkrv (apl-run "⌈/3 1 4 1 5 9 2"))
+  (list 9))
+
+(apl-test
+  "apl-run \"+\\\\⍳5\" → triangular numbers"
+  (mkrv (apl-run "+\\⍳5"))
+  (list 1 3 6 10 15))
+
+; ---------- outer / inner products ----------
+
+(apl-test
+  "apl-run \"1 2 3 ∘.× 1 2 3\" → mult table values"
+  (mkrv (apl-run "1 2 3 ∘.× 1 2 3"))
+  (list 1 2 3 2 4 6 3 6 9))
+
+(apl-test
+  "apl-run \"1 2 3 +.× 4 5 6\" → dot product 32"
+  (mkrv (apl-run "1 2 3 +.× 4 5 6"))
+  (list 32))
+
+; ---------- shape ----------
+
+(apl-test
+  "apl-run \"⍴ 1 2 3 4 5\" → 5"
+  (mkrv (apl-run "⍴ 1 2 3 4 5"))
+  (list 5))
+
+(apl-test "apl-run \"⍴⍳10\" → 10" (mkrv (apl-run "⍴⍳10")) (list 10))
+
+; ---------- comparison ----------
+
+(apl-test "apl-run \"3 < 5\" → 1" (mkrv (apl-run "3 < 5")) (list 1))
+
+(apl-test "apl-run \"5 = 5\" → 1" (mkrv (apl-run "5 = 5")) (list 1))
+
+(apl-test
+  "apl-run \"1 2 3 = 1 0 3\" → 1 0 1"
+  (mkrv (apl-run "1 2 3 = 1 0 3"))
+  (list 1 0 1))
+
+; ---------- famous one-liners ----------
+
+(apl-test
+  "apl-run \"+/(⍳10)\" → sum 1..10 = 55"
+  (mkrv (apl-run "+/(⍳10)"))
+  (list 55))
+
+(apl-test
+  "apl-run \"×/⍳10\" → 10! = 3628800"
+  (mkrv (apl-run "×/⍳10"))
+  (list 3628800))
+
+(apl-test "apl-run \"⎕IO\" → 1" (mkrv (apl-run "⎕IO")) (list 1))
+
+(apl-test "apl-run \"⎕ML\" → 1" (mkrv (apl-run "⎕ML")) (list 1))
+
+(apl-test "apl-run \"⎕FR\" → 1248" (mkrv (apl-run "⎕FR")) (list 1248))
+
+(apl-test "apl-run \"⎕TS\" shape (7)" (mksh (apl-run "⎕TS")) (list 7))
+
+(apl-test "apl-run \"⎕FMT 42\" → \"42\"" (apl-run "⎕FMT 42") "42")
+
+(apl-test
+  "apl-run \"⎕FMT 1 2 3\" → \"1 2 3\""
+  (apl-run "⎕FMT 1 2 3")
+  "1 2 3")
+
+(apl-test
+  "apl-run \"⎕FMT ⍳5\" → \"1 2 3 4 5\""
+  (apl-run "⎕FMT ⍳5")
+  "1 2 3 4 5")
+
+(apl-test "apl-run \"⎕IO + 4\" → 5" (mkrv (apl-run "⎕IO + 4")) (list 5))
+
+(apl-test
+  "apl-run \"(10 20 30 40 50)[3]\" → 30"
+  (mkrv (apl-run "(10 20 30 40 50)[3]"))
+  (list 30))
+
+(apl-test
+  "apl-run \"(⍳10)[5]\" → 5"
+  (mkrv (apl-run "(⍳10)[5]"))
+  (list 5))
+
+(apl-test
+  "apl-run \"A ← 100 200 300 ⋄ A[2]\" → 200"
+  (mkrv (apl-run "A ← 100 200 300 ⋄ A[2]"))
+  (list 200))
+
+(apl-test
+  "apl-run \"V ← ⍳10 ⋄ V[3]\" → 3"
+  (mkrv (apl-run "V ← ⍳10 ⋄ V[3]"))
+  (list 3))
+
+(apl-test
+  "apl-run \"(10 20 30)[1]\" → 10 (1-indexed)"
+  (mkrv (apl-run "(10 20 30)[1]"))
+  (list 10))
+
+(apl-test
+  "apl-run \"V ← 10 20 30 40 50 ⋄ V[3] + 1\" → 31"
+  (mkrv (apl-run "V ← 10 20 30 40 50 ⋄ V[3] + 1"))
+  (list 31))
+
+(apl-test
+  "apl-run \"(⍳5)[3] × 7\" → 21"
+  (mkrv (apl-run "(⍳5)[3] × 7"))
+  (list 21))
+
+(apl-test "decimal: 3.7 → 3.7" (mkrv (apl-run "3.7")) (list 3.7))
+
+(apl-test "decimal: ¯2.5 → -2.5" (mkrv (apl-run "¯2.5")) (list -2.5))
+
+(apl-test "decimal: 1.5 + 2.5 → 4" (mkrv (apl-run "1.5 + 2.5")) (list 4))
+
+(apl-test "decimal: ⌊3.7 → 3" (mkrv (apl-run "⌊ 3.7")) (list 3))
+
+(apl-test "decimal: ⌈3.7 → 4" (mkrv (apl-run "⌈ 3.7")) (list 4))
+
+(apl-test
+  "⎕← scalar passthrough"
+  (mkrv (apl-run "⎕← 42"))
+  (list 42))
+
+(apl-test
+  "⎕← vector passthrough"
+  (mkrv (apl-run "⎕← 1 2 3"))
+  (list 1 2 3))
+
+(apl-test
+  "string: 'abc' → 3-char vector"
+  (mkrv (apl-run "'abc'"))
+  (list "a" "b" "c"))
+
+(apl-test "string: 'a' is rank-0 scalar" (mksh (apl-run "'a'")) (list))
+
+(apl-test "string: 'hello' shape (5)" (mksh (apl-run "'hello'")) (list 5))
+
+(apl-test
+  "named-fn: f ← {⍺+⍵} ⋄ 3 f 4 → 7"
+  (mkrv (apl-run "f ← {⍺+⍵} ⋄ 3 f 4"))
+  (list 7))
+
+(apl-test
+  "named-fn monadic: sq ← {⍵×⍵} ⋄ sq 7 → 49"
+  (mkrv (apl-run "sq ← {⍵×⍵} ⋄ sq 7"))
+  (list 49))
+
+(apl-test
+  "named-fn dyadic: hyp ← {((⍺×⍺)+⍵×⍵)} ⋄ 3 hyp 4 → 25"
+  (mkrv (apl-run "hyp ← {((⍺×⍺)+⍵×⍵)} ⋄ 3 hyp 4"))
+  (list 25))
+
+(apl-test
+  "named-fn: dbl ← {⍵+⍵} ⋄ dbl ⍳5"
+  (mkrv (apl-run "dbl ← {⍵+⍵} ⋄ dbl ⍳5"))
+  (list 2 4 6 8 10))
+
+(apl-test
+  "named-fn factorial via ∇ recursion"
+  (mkrv (apl-run "fact ← {0=⍵:1 ⋄ ⍵×∇⍵-1} ⋄ fact 5"))
+  (list 120))
+
+(apl-test
+  "named-fn used twice in expr: dbl ← {⍵+⍵} ⋄ (dbl 3) + dbl 4"
+  (mkrv (apl-run "dbl ← {⍵+⍵} ⋄ (dbl 3) + dbl 4"))
+  (list 14))
+
+(apl-test
+  "named-fn with vector arg: neg ← {-⍵} ⋄ neg 1 2 3"
+  (mkrv (apl-run "neg ← {-⍵} ⋄ neg 1 2 3"))
+  (list -1 -2 -3))
+
+(apl-test
+  "multi-axis: M[2;2] → center"
+  (mkrv (apl-run "M ← (3 3) ⍴ ⍳9 ⋄ M[2;2]"))
+  (list 5))
+
+(apl-test
+  "multi-axis: M[1;] → first row"
+  (mkrv (apl-run "M ← (3 3) ⍴ ⍳9 ⋄ M[1;]"))
+  (list 1 2 3))
+
+(apl-test
+  "multi-axis: M[;2] → second column"
+  (mkrv (apl-run "M ← (3 3) ⍴ ⍳9 ⋄ M[;2]"))
+  (list 2 5 8))
+
+(apl-test
+  "multi-axis: M[1 2;1 2] → 2x2 block"
+  (mkrv (apl-run "M ← (2 3) ⍴ ⍳6 ⋄ M[1 2;1 2]"))
+  (list 1 2 4 5))
+
+(apl-test
+  "multi-axis: M[1 2;1 2] shape (2 2)"
+  (mksh (apl-run "M ← (2 3) ⍴ ⍳6 ⋄ M[1 2;1 2]"))
+  (list 2 2))
+
+(apl-test
+  "multi-axis: M[;] full matrix"
+  (mkrv (apl-run "M ← (2 2) ⍴ 10 20 30 40 ⋄ M[;]"))
+  (list 10 20 30 40))
+
+(apl-test
+  "multi-axis: M[1;] shape collapsed"
+  (mksh (apl-run "M ← (3 3) ⍴ ⍳9 ⋄ M[1;]"))
+  (list 3))
+
+(apl-test
+  "multi-axis: select all rows of column 3"
+  (mkrv (apl-run "M ← (4 3) ⍴ 1 2 3 4 5 6 7 8 9 10 11 12 ⋄ M[;3]"))
+  (list 3 6 9 12))
+
+(apl-test
+  "train: mean = (+/÷≢) on 1..5"
+  (mkrv (apl-run "(+/÷≢) 1 2 3 4 5"))
+  (list 3))
+
+(apl-test
+  "train: mean of 2 4 6 8 10"
+  (mkrv (apl-run "(+/÷≢) 2 4 6 8 10"))
+  (list 6))
+
+(apl-test
+  "train 2-atop: (- ⌊) 5 → -5"
+  (mkrv (apl-run "(- ⌊) 5"))
+  (list -5))
+
+(apl-test
+  "train 3-fork dyadic: 2(+×-)5 → -21"
+  (mkrv (apl-run "2 (+ × -) 5"))
+  (list -21))
+
+(apl-test
+  "train: range = (⌈/-⌊/) on vector"
+  (mkrv (apl-run "(⌈/-⌊/) 3 1 4 1 5 9 2 6"))
+  (list 8))
+
+(apl-test
+  "train: mean of ⍳10 has shape ()"
+  (mksh (apl-run "(+/÷≢) ⍳10"))
+  (list))
+
+(apl-test
+  "compress: 1 0 1 0 1 / 10 20 30 40 50"
+  (mkrv (apl-run "1 0 1 0 1 / 10 20 30 40 50"))
+  (list 10 30 50))
+
+(apl-test
+  "compress: empty mask → empty"
+  (mkrv (apl-run "0 0 0 / 1 2 3"))
+  (list))
+
+(apl-test
+  "primes via classic idiom (multi-stmt)"
+  (mkrv (apl-run "P ← ⍳ 30 ⋄ (2 = +⌿ 0 = P ∘.| P) / P"))
+  (list 2 3 5 7 11 13 17 19 23 29))
+
+(apl-test
+  "primes via classic idiom (n=20)"
+  (mkrv (apl-run "P ← ⍳ 20 ⋄ (2 = +⌿ 0 = P ∘.| P) / P"))
+  (list 2 3 5 7 11 13 17 19))
+
+(apl-test
+  "compress: filter even values"
+  (mkrv (apl-run "(0 = 2 | 1 2 3 4 5 6) / 1 2 3 4 5 6"))
+  (list 2 4 6))
+
+(apl-test "inline-assign: x ← 5" (mkrv (apl-run "x ← 5")) (list 5))
+
+(apl-test
+  "inline-assign: (2×x) + x←10 → 30"
+  (mkrv (apl-run "(2 × x) + x ← 10"))
+  (list 30))
+
+(apl-test
+  "inline-assign primes one-liner: (2=+⌿0=a∘.|a)/a←⍳30"
+  (mkrv (apl-run "(2 = +⌿ 0 = a ∘.| a) / a ← ⍳ 30"))
+  (list 2 3 5 7 11 13 17 19 23 29))
+
+(apl-test
+  "inline-assign: x is reusable — x + x ← 7 → 14"
+  (mkrv (apl-run "x + x ← 7"))
+  (list 14))
+
+(apl-test
+  "inline-assign in dfn: f ← {x + x ← ⍵} ⋄ f 8 → 16"
+  (mkrv (apl-run "f ← {x + x ← ⍵} ⋄ f 8"))
+  (list 16))
+
+(begin (apl-rng-seed! 42) nil)
+
+(apl-test
+  "?10 with seed 42 → 8 (deterministic)"
+  (mkrv (apl-run "?10"))
+  (list 8))
+
+(apl-test "?10 next call → 5" (mkrv (apl-run "?10")) (list 5))
+
+(apl-test
+  "?100 stays in range"
+  (let ((v (first (mkrv (apl-run "?100"))))) (and (>= v 1) (<= v 100)))
+  true)
+
+(begin (apl-rng-seed! 42) nil)
+
+(apl-test
+  "?10 with re-seed 42 → 8 (reproducible)"
+  (mkrv (apl-run "?10"))
+  (list 8))
+
+(apl-test
+  "apl-run-file: load primes.apl returns dfn AST"
+  (first (apl-run-file "lib/apl/tests/programs/primes.apl"))
+  :dfn)
+
+(apl-test
+  "apl-run-file: life.apl parses without error"
+  (first (apl-run-file "lib/apl/tests/programs/life.apl"))
+  :dfn)
+
+(apl-test
+  "apl-run-file: quicksort.apl parses without error"
+  (first (apl-run-file "lib/apl/tests/programs/quicksort.apl"))
+  :dfn)
+
+(apl-test
+  "apl-run-file: source-then-call returns primes count"
+  (mksh
+    (apl-run
+      (str (file-read "lib/apl/tests/programs/primes.apl") " ⋄ primes 30")))
+  (list 10))
+
+(apl-test
+  "primes one-liner with ⍵-rebind: primes 30"
+  (mkrv
+    (apl-run "primes ← {(2=+⌿0=⍵∘.|⍵)/⍵←⍳⍵} ⋄ primes 30"))
+  (list 2 3 5 7 11 13 17 19 23 29))
+
+(apl-test
+  "primes one-liner: primes 50"
+  (mkrv
+    (apl-run "primes ← {(2=+⌿0=⍵∘.|⍵)/⍵←⍳⍵} ⋄ primes 50"))
+  (list 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47))
+
+(apl-test
+  "primes.apl loaded + called via apl-run-file"
+  (mkrv
+    (apl-run
+      (str (file-read "lib/apl/tests/programs/primes.apl") " ⋄ primes 20")))
+  (list 2 3 5 7 11 13 17 19))
+
+(apl-test
+  "primes.apl loaded — count of primes ≤ 100"
+  (first
+    (mksh
+      (apl-run
+        (str
+          (file-read "lib/apl/tests/programs/primes.apl")
+          " ⋄ primes 100"))))
+  25)
+
+(apl-test
+  "⍉ monadic transpose 2x3 → 3x2"
+  (mkrv (apl-run "⍉ (2 3) ⍴ ⍳6"))
+  (list 1 4 2 5 3 6))
+
+(apl-test
+  "⍉ transpose shape (3 2)"
+  (mksh (apl-run "⍉ (2 3) ⍴ ⍳6"))
+  (list 3 2))
+
+(apl-test "⊢ monadic identity" (mkrv (apl-run "⊢ 1 2 3")) (list 1 2 3))
+
+(apl-test
+  "5 ⊣ 1 2 3 → 5 (left)"
+  (mkrv (apl-run "5 ⊣ 1 2 3"))
+  (list 5))
+
+(apl-test
+  "5 ⊢ 1 2 3 → 1 2 3 (right)"
+  (mkrv (apl-run "5 ⊢ 1 2 3"))
+  (list 1 2 3))
+
+(apl-test "⍕ 42 → \"42\" (alias for ⎕FMT)" (apl-run "⍕ 42") "42")
+
+(begin
+  (apl-test
+    "⍸ where: indices of truthy cells"
+    (mkrv (apl-run "⍸ 0 1 0 1 1"))
+    (list 2 4 5))
+  (apl-test
+    "⍸ where: leading truthy"
+    (mkrv (apl-run "⍸ 1 0 0 1 1"))
+    (list 1 4 5))
+  (apl-test
+    "⍸ where: all-zero → empty"
+    (mkrv (apl-run "⍸ 0 0 0"))
+    (list))
+  (apl-test
+    "⍸ where: all-truthy"
+    (mkrv (apl-run "⍸ 1 1 1"))
+    (list 1 2 3))
+  (apl-test
+    "⍸ where: ⎕IO=1 (1-based)"
+    (mkrv (apl-run "⍸ (⍳5)=3"))
+    (list 3))
+  (apl-test
+    "⍸ interval-index: 2 4 6 ⍸ 5 → 2"
+    (mkrv (apl-run "2 4 6 ⍸ 5"))
+    (list 2))
+  (apl-test
+    "⍸ interval-index: 2 4 6 ⍸ 1 3 5 6 7 → 0 1 2 3 3"
+    (mkrv (apl-run "2 4 6 ⍸ 1 3 5 6 7"))
+    (list 0 1 2 3 3))
+  (apl-test
+    "⍸ interval-index: ⍳5 ⍸ 3 → 3"
+    (mkrv (apl-run "(⍳5) ⍸ 3"))
+    (list 3))
+  (apl-test
+    "⍸ interval-index: y below all → 0"
+    (mkrv (apl-run "10 20 30 ⍸ 5"))
+    (list 0))
+  (apl-test
+    "⍸ interval-index: y above all → len breaks"
+    (mkrv (apl-run "10 20 30 ⍸ 100"))
+    (list 3)))
+
+(begin
+  (apl-test
+    "∪ unique: dedup keeps first-occurrence order"
+    (mkrv (apl-run "∪ 1 2 1 3 2 1 4"))
+    (list 1 2 3 4))
+  (apl-test
+    "∪ unique: already-unique unchanged"
+    (mkrv (apl-run "∪ 5 4 3 2 1"))
+    (list 5 4 3 2 1))
+  (apl-test "∪ unique: scalar" (mkrv (apl-run "∪ 7")) (list 7))
+  (apl-test
+    "∪ unique: string mississippi → misp"
+    (mkrv (apl-run "∪ 'mississippi'"))
+    (list "m" "i" "s" "p"))
+  (apl-test
+    "∪ union: 1 2 3 ∪ 3 4 5 → 1 2 3 4 5"
+    (mkrv (apl-run "1 2 3 ∪ 3 4 5"))
+    (list 1 2 3 4 5))
+  (apl-test
+    "∪ union: dedups left side too"
+    (mkrv (apl-run "1 2 1 ∪ 1 3 2"))
+    (list 1 2 3))
+  (apl-test
+    "∪ union: disjoint → catenated"
+    (mkrv (apl-run "1 2 ∪ 3 4"))
+    (list 1 2 3 4))
+  (apl-test
+    "∩ intersection: 1 2 3 4 ∩ 2 4 6 → 2 4"
+    (mkrv (apl-run "1 2 3 4 ∩ 2 4 6"))
+    (list 2 4))
+  (apl-test
+    "∩ intersection: disjoint → empty"
+    (mkrv (apl-run "1 2 3 ∩ 4 5 6"))
+    (list))
+  (apl-test
+    "∩ intersection: preserves left order"
+    (mkrv (apl-run "(⍳5) ∩ 5 3 1"))
+    (list 1 3 5))
+  (apl-test
+    "∩ intersection: identical"
+    (mkrv (apl-run "1 2 3 ∩ 1 2 3"))
+    (list 1 2 3))
+  (apl-test
+    "∪/∩ identity: A ∪ A = ∪A"
+    (mkrv (apl-run "1 2 1 ∪ 1 2 1"))
+    (list 1 2)))
+
+(begin
+  (apl-test
+    "⊥ decode: 2 2 2 ⊥ 1 0 1 → 5"
+    (mkrv (apl-run "2 2 2 ⊥ 1 0 1"))
+    (list 5))
+  (apl-test
+    "⊥ decode: 10 10 10 ⊥ 1 2 3 → 123"
+    (mkrv (apl-run "10 10 10 ⊥ 1 2 3"))
+    (list 123))
+  (apl-test
+    "⊥ decode: 24 60 60 ⊥ 2 3 4 → 7384 (mixed-radix HMS)"
+    (mkrv (apl-run "24 60 60 ⊥ 2 3 4"))
+    (list 7384))
+  (apl-test
+    "⊥ decode: scalar base 2 ⊥ 1 0 1 0 → 10"
+    (mkrv (apl-run "2 ⊥ 1 0 1 0"))
+    (list 10))
+  (apl-test
+    "⊥ decode: 16 16 ⊥ 15 15 → 255"
+    (mkrv (apl-run "16 16 ⊥ 15 15"))
+    (list 255))
+  (apl-test
+    "⊤ encode: 2 2 2 ⊤ 5 → 1 0 1"
+    (mkrv (apl-run "2 2 2 ⊤ 5"))
+    (list 1 0 1))
+  (apl-test
+    "⊤ encode: 24 60 60 ⊤ 7384 → 2 3 4 (HMS)"
+    (mkrv (apl-run "24 60 60 ⊤ 7384"))
+    (list 2 3 4))
+  (apl-test
+    "⊤ encode: 2 2 2 2 ⊤ 13 → 1 1 0 1"
+    (mkrv (apl-run "2 2 2 2 ⊤ 13"))
+    (list 1 1 0 1))
+  (apl-test
+    "⊤ encode: 10 10 ⊤ 42 → 4 2"
+    (mkrv (apl-run "10 10 ⊤ 42"))
+    (list 4 2))
+  (apl-test
+    "⊤ encode: round-trip B⊥(B⊤N) = N"
+    (mkrv (apl-run "24 60 60 ⊥ 24 60 60 ⊤ 7384"))
+    (list 7384))
+  (apl-test
+    "⊥ decode: round-trip B⊤(B⊥V) = V"
+    (mkrv (apl-run "2 2 2 ⊤ 2 2 2 ⊥ 1 0 1"))
+    (list 1 0 1)))
+
+(begin
+  (define
+    mk-parts
+    (fn (s) (map (fn (p) (get p :ravel)) (get (apl-run s) :ravel))))
+  (apl-test
+    "⊆ partition: 1 1 0 1 1 ⊆ 'abcde' → ('ab' 'de')"
+    (mk-parts "1 1 0 1 1 ⊆ 'abcde'")
+    (list (list "a" "b") (list "d" "e")))
+  (apl-test
+    "⊆ partition: 1 0 0 1 1 ⊆ ⍳5 → ((1) (4 5))"
+    (mk-parts "1 0 0 1 1 ⊆ ⍳5")
+    (list (list 1) (list 4 5)))
+  (apl-test
+    "⊆ partition: all-zero mask → empty"
+    (len (get (apl-run "0 0 0 ⊆ 1 2 3") :ravel))
+    0)
+  (apl-test
+    "⊆ partition: all-one mask → single partition"
+    (mk-parts "1 1 1 ⊆ 7 8 9")
+    (list (list 7 8 9)))
+  (apl-test
+    "⊆ partition: strict increase 1 2 starts new"
+    (mk-parts "1 2 ⊆ 10 20")
+    (list (list 10) (list 20)))
+  (apl-test
+    "⊆ partition: same level continues 2 2 → one partition"
+    (mk-parts "2 2 ⊆ 10 20")
+    (list (list 10 20)))
+  (apl-test
+    "⊆ partition: 0 separates"
+    (mk-parts "1 1 0 0 1 ⊆ 1 2 3 4 5")
+    (list (list 1 2) (list 5)))
+  (apl-test
+    "⊆ partition: outer length matches partition count"
+    (len (get (apl-run "1 0 1 0 1 ⊆ ⍳5") :ravel))
+    3))
+
+(begin
+  (apl-test
+    "⍎ execute: ⍎ '1 + 2' → 3"
+    (mkrv (apl-run "⍎ '1 + 2'"))
+    (list 3))
+  (apl-test
+    "⍎ execute: ⍎ '+/⍳10' → 55"
+    (mkrv (apl-run "⍎ '+/⍳10'"))
+    (list 55))
+  (apl-test
+    "⍎ execute: ⍎ '⌈/ 1 3 9 5 7' → 9"
+    (mkrv (apl-run "⍎ '⌈/ 1 3 9 5 7'"))
+    (list 9))
+  (apl-test
+    "⍎ execute: ⍎ '⍳5' → 1..5"
+    (mkrv (apl-run "⍎ '⍳5'"))
+    (list 1 2 3 4 5))
+  (apl-test
+    "⍎ execute: ⍎ '×/⍳5' → 120"
+    (mkrv (apl-run "⍎ '×/⍳5'"))
+    (list 120))
+  (apl-test
+    "⍎ execute: round-trip ⍎ ⎕FMT 42 → 42"
+    (mkrv (apl-run "⍎ ⎕FMT 42"))
+    (list 42))
+  (apl-test
+    "⍎ execute: nested ⍎ ⍎"
+    (mkrv (apl-run "⍎ '⍎ ''2 × 3'''"))
+    (list 6))
+  (apl-test
+    "⍎ execute: with assignment side-effect"
+    (mkrv (apl-run "⍎ 'q ← 99 ⋄ q + 1'"))
+    (list 100)))
+
+(begin
+  (apl-test
+    "het-inner: 1 ⍵ ∨.∧ X — result is enclosed (5 5)"
+    (let
+      ((r (apl-run "B ← 5 5 ⍴ 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 ⋄ X ← 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂B ⋄ 1 B ∨.∧ X")))
+      (list
+        (len (get r :shape))
+        (= (type-of (first (get r :ravel))) "dict")))
+    (list 0 true))
+  (apl-test
+    "het-inner: ⊃ unwraps to (5 5) board"
+    (mksh
+      (apl-run
+        "B ← 5 5 ⍴ 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 ⋄ X ← 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂B ⋄ ⊃ 1 B ∨.∧ X"))
+    (list 5 5))
+  (apl-test
+    "het-inner: homogeneous inner product unaffected"
+    (mkrv (apl-run "1 2 3 +.× 4 5 6"))
+    (list 32))
+  (apl-test
+    "het-inner: matrix inner product unaffected"
+    (mkrv (apl-run "(2 2 ⍴ 1 2 3 4) +.× 2 2 ⍴ 5 6 7 8"))
+    (list 19 22 43 50)))

lib/apl/tests/programs-e2e.sx

@@ -0,0 +1,189 @@
+; End-to-end tests of the classic-program archetypes — running APL
+; source through the full pipeline (tokenize → parse → eval-ast → runtime).
+;
+; These mirror the algorithms documented in lib/apl/tests/programs/*.apl
+; but use forms our pipeline supports today (named functions instead of
+; the inline ⍵← rebinding idiom; multi-stmt over single one-liners).
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+; ---------- factorial via ∇ recursion (cf. n-queens style) ----------
+
+(apl-test
+  "e2e: factorial 5! = 120"
+  (mkrv (apl-run "fact ← {0=⍵:1 ⋄ ⍵×∇⍵-1} ⋄ fact 5"))
+  (list 120))
+
+(apl-test
+  "e2e: factorial 7! = 5040"
+  (mkrv (apl-run "fact ← {0=⍵:1 ⋄ ⍵×∇⍵-1} ⋄ fact 7"))
+  (list 5040))
+
+(apl-test
+  "e2e: factorial via ×/⍳N (no recursion)"
+  (mkrv (apl-run "fact ← {×/⍳⍵} ⋄ fact 6"))
+  (list 720))
+
+; ---------- sum / triangular numbers (sum-1..N) ----------
+
+(apl-test
+  "e2e: triangular(10) = 55"
+  (mkrv (apl-run "tri ← {+/⍳⍵} ⋄ tri 10"))
+  (list 55))
+
+(apl-test
+  "e2e: triangular(100) = 5050"
+  (mkrv (apl-run "tri ← {+/⍳⍵} ⋄ tri 100"))
+  (list 5050))
+
+; ---------- sum of squares ----------
+
+(apl-test
+  "e2e: sum-of-squares 1..5 = 55"
+  (mkrv (apl-run "ss ← {+/⍵×⍵} ⋄ ss ⍳5"))
+  (list 55))
+
+(apl-test
+  "e2e: sum-of-squares 1..10 = 385"
+  (mkrv (apl-run "ss ← {+/⍵×⍵} ⋄ ss ⍳10"))
+  (list 385))
+
+; ---------- divisor-counting (prime-sieve building blocks) ----------
+
+(apl-test
+  "e2e: divisor counts 1..5 via outer mod"
+  (mkrv (apl-run "P ← ⍳ 5 ⋄ +⌿ 0 = P ∘.| P"))
+  (list 1 2 2 3 2))
+
+(apl-test
+  "e2e: divisor counts 1..10"
+  (mkrv (apl-run "P ← ⍳ 10 ⋄ +⌿ 0 = P ∘.| P"))
+  (list 1 2 2 3 2 4 2 4 3 4))
+
+(apl-test
+  "e2e: prime-mask 1..10 (count==2)"
+  (mkrv (apl-run "P ← ⍳ 10 ⋄ 2 = +⌿ 0 = P ∘.| P"))
+  (list 0 1 1 0 1 0 1 0 0 0))
+
+; ---------- monadic primitives chained ----------
+
+(apl-test
+  "e2e: sum of |abs| = 15"
+  (mkrv (apl-run "+/|¯1 ¯2 ¯3 ¯4 ¯5"))
+  (list 15))
+
+(apl-test
+  "e2e: max of squares 1..6"
+  (mkrv (apl-run "⌈/(⍳6)×⍳6"))
+  (list 36))
+
+; ---------- nested named functions ----------
+
+(apl-test
+  "e2e: compose dbl and sq via two named fns"
+  (mkrv (apl-run "dbl ← {⍵+⍵} ⋄ sq ← {⍵×⍵} ⋄ sq dbl 3"))
+  (list 36))
+
+(apl-test
+  "e2e: max-of-two as named dyadic fn"
+  (mkrv (apl-run "mx ← {⍺⌈⍵} ⋄ 5 mx 3"))
+  (list 5))
+
+(apl-test
+  "e2e: sqrt-via-newton 1 step from 1 → 2.5"
+  (mkrv (apl-run "step ← {(⍵+⍺÷⍵)÷2} ⋄ 4 step 1"))
+  (list 2.5))
+
+(begin
+  (apl-test
+    "life.apl: blinker 5×5 → vertical blinker"
+    (mkrv
+      (apl-run
+        "life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} ⋄ life 5 5 ⍴ 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0"))
+    (list 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0))
+  (apl-test
+    "life.apl: blinker oscillates (period 2)"
+    (mkrv
+      (apl-run
+        "life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} ⋄ life life 5 5 ⍴ 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0"))
+    (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))
+  (apl-test
+    "life.apl: 2×2 block stable"
+    (mkrv
+      (apl-run
+        "life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} ⋄ life 4 4 ⍴ 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0"))
+    (list 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0))
+  (apl-test
+    "life.apl: empty grid stays empty"
+    (mkrv
+      (apl-run
+        "life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} ⋄ life 5 5 ⍴ 0"))
+    (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+  (apl-test
+    "life.apl: source-file as-written runs"
+    (let
+      ((dfn (apl-run-file "lib/apl/tests/programs/life.apl"))
+        (board
+          (apl-run "5 5 ⍴ 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0")))
+      (get (apl-call-dfn-m dfn board) :ravel))
+    (list 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0)))
+
+(begin
+  (apl-test
+    "quicksort.apl: 11-element with duplicates"
+    (begin
+      (apl-rng-seed! 42)
+      (mkrv
+        (apl-run
+          "quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p} ⋄ quicksort 3 1 4 1 5 9 2 6 5 3 5")))
+    (list 1 1 2 3 3 4 5 5 5 6 9))
+  (apl-test
+    "quicksort.apl: already sorted"
+    (begin
+      (apl-rng-seed! 42)
+      (mkrv
+        (apl-run
+          "quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p} ⋄ quicksort 1 2 3 4 5")))
+    (list 1 2 3 4 5))
+  (apl-test
+    "quicksort.apl: reverse sorted"
+    (begin
+      (apl-rng-seed! 42)
+      (mkrv
+        (apl-run
+          "quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p} ⋄ quicksort 5 4 3 2 1")))
+    (list 1 2 3 4 5))
+  (apl-test
+    "quicksort.apl: all equal"
+    (begin
+      (apl-rng-seed! 42)
+      (mkrv
+        (apl-run
+          "quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p} ⋄ quicksort 7 7 7 7")))
+    (list 7 7 7 7))
+  (apl-test
+    "quicksort.apl: single element"
+    (begin
+      (apl-rng-seed! 42)
+      (mkrv
+        (apl-run
+          "quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p} ⋄ quicksort ,42")))
+    (list 42))
+  (apl-test
+    "quicksort.apl: matches grade-up"
+    (begin
+      (apl-rng-seed! 42)
+      (mkrv
+        (apl-run
+          "V ← 8 3 1 9 2 7 5 6 4 ⋄ quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p} ⋄ quicksort V")))
+    (list 1 2 3 4 5 6 7 8 9))
+  (apl-test
+    "quicksort.apl: source-file as-written runs"
+    (begin
+      (apl-rng-seed! 42)
+      (let
+        ((dfn (apl-run-file "lib/apl/tests/programs/quicksort.apl"))
+          (vec (apl-run "5 2 8 1 9 3 7 4 6")))
+        (get (apl-call-dfn-m dfn vec) :ravel)))
+    (list 1 2 3 4 5 6 7 8 9)))

lib/apl/tests/programs.sx

@@ -0,0 +1,304 @@
+; Tests for classic APL programs (lib/apl/tests/programs/*.apl).
+; Programs are showcase APL source; runtime impl is in lib/apl/runtime.sx.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+; ===== primes (Sieve of Eratosthenes) =====
+
+(apl-test "primes 1 → empty" (mkrv (apl-primes 1)) (list))
+
+(apl-test "primes 2 → just 2" (mkrv (apl-primes 2)) (list 2))
+
+(apl-test "primes 10 → 2 3 5 7" (mkrv (apl-primes 10)) (list 2 3 5 7))
+
+(apl-test
+  "primes 20 → 2 3 5 7 11 13 17 19"
+  (mkrv (apl-primes 20))
+  (list 2 3 5 7 11 13 17 19))
+
+(apl-test
+  "primes 30"
+  (mkrv (apl-primes 30))
+  (list 2 3 5 7 11 13 17 19 23 29))
+
+(apl-test
+  "primes 50"
+  (mkrv (apl-primes 50))
+  (list 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47))
+
+(apl-test "primes 7 length" (first (mksh (apl-primes 7))) 4)
+
+(apl-test "primes 100 has 25 primes" (first (mksh (apl-primes 100))) 25)
+
+; ===== compress helper sanity =====
+
+(apl-test
+  "compress 1 0 1 0 1 / 10 20 30 40 50"
+  (mkrv
+    (apl-compress
+      (make-array (list 5) (list 1 0 1 0 1))
+      (make-array (list 5) (list 10 20 30 40 50))))
+  (list 10 30 50))
+
+(apl-test
+  "compress all-zero mask → empty"
+  (mkrv
+    (apl-compress
+      (make-array (list 3) (list 0 0 0))
+      (make-array (list 3) (list 1 2 3))))
+  (list))
+
+(apl-test
+  "compress all-one mask → full vector"
+  (mkrv
+    (apl-compress
+      (make-array (list 3) (list 1 1 1))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "life: empty 5x5 stays empty"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: horizontal blinker → vertical blinker"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: vertical blinker → horizontal blinker"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: blinker has period 2"
+  (mkrv
+    (apl-life-step
+      (apl-life-step
+        (make-array
+          (list 5 5)
+          (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0)))))
+  (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: 2x2 block stable on 5x5"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: shape preserved"
+  (mksh
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 5 5))
+
+(apl-test
+  "life: glider on 6x6 advances"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 6 6)
+        (list
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          1
+          0
+          0
+          0
+          0
+          0
+          0
+          1
+          0
+          0
+          0
+          1
+          1
+          1
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0))))
+  (list
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    1
+    0
+    1
+    0
+    0
+    0
+    0
+    1
+    1
+    0
+    0
+    0
+    0
+    1
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0))
+
+(apl-test
+  "mandelbrot c=0 stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 0)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=-1 cycle bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list -1)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=-2 boundary stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list -2)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=0.25 boundary stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 0.25)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=1 escapes at iter 3"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 1)) 100))
+  (list 3))
+
+(apl-test
+  "mandelbrot c=0.5 escapes at iter 5"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 0.5)) 100))
+  (list 5))
+
+(apl-test
+  "mandelbrot batched grid (rank-polymorphic)"
+  (mkrv (apl-mandelbrot-1d (make-array (list 5) (list -2 -1 0 1 2)) 10))
+  (list 10 10 10 3 2))
+
+(apl-test
+  "mandelbrot batched preserves shape"
+  (mksh (apl-mandelbrot-1d (make-array (list 5) (list -2 -1 0 1 2)) 10))
+  (list 5))
+
+(apl-test
+  "mandelbrot c=-1.5 stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list -1.5)) 100))
+  (list 100))
+
+(apl-test "queens 1 → 1 solution" (mkrv (apl-queens 1)) (list 1))
+
+(apl-test "queens 2 → 0 solutions" (mkrv (apl-queens 2)) (list 0))
+
+(apl-test "queens 3 → 0 solutions" (mkrv (apl-queens 3)) (list 0))
+
+(apl-test "queens 4 → 2 solutions" (mkrv (apl-queens 4)) (list 2))
+
+(apl-test "queens 5 → 10 solutions" (mkrv (apl-queens 5)) (list 10))
+
+(apl-test "queens 6 → 4 solutions" (mkrv (apl-queens 6)) (list 4))
+
+(apl-test "queens 7 → 40 solutions" (mkrv (apl-queens 7)) (list 40))
+
+(apl-test "permutations of 3 has 6" (len (apl-permutations 3)) 6)
+
+(apl-test "permutations of 4 has 24" (len (apl-permutations 4)) 24)
+
+(apl-test
+  "quicksort empty"
+  (mkrv (apl-quicksort (make-array (list 0) (list))))
+  (list))
+
+(apl-test
+  "quicksort single"
+  (mkrv (apl-quicksort (make-array (list 1) (list 42))))
+  (list 42))
+
+(apl-test
+  "quicksort already sorted"
+  (mkrv (apl-quicksort (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "quicksort reverse sorted"
+  (mkrv (apl-quicksort (make-array (list 5) (list 5 4 3 2 1))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "quicksort with duplicates"
+  (mkrv (apl-quicksort (make-array (list 7) (list 3 1 4 1 5 9 2))))
+  (list 1 1 2 3 4 5 9))
+
+(apl-test
+  "quicksort all equal"
+  (mkrv (apl-quicksort (make-array (list 5) (list 7 7 7 7 7))))
+  (list 7 7 7 7 7))
+
+(apl-test
+  "quicksort negatives"
+  (mkrv (apl-quicksort (make-array (list 5) (list -3 1 -1 2 0))))
+  (list -3 -1 0 1 2))
+
+(apl-test
+  "quicksort 11-element pi"
+  (mkrv
+    (apl-quicksort (make-array (list 11) (list 3 1 4 1 5 9 2 6 5 3 5))))
+  (list 1 1 2 3 3 4 5 5 5 6 9))
+
+(apl-test
+  "quicksort preserves length"
+  (first
+    (mksh (apl-quicksort (make-array (list 7) (list 3 1 4 1 5 9 2)))))
+  7)

lib/apl/tests/programs/life.apl

@@ -0,0 +1,22 @@
+⍝ Conway's Game of Life — toroidal one-liner
+⍝
+⍝ The classic Roger Hui formulation:
+⍝   life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}
+⍝
+⍝ Read right-to-left:
+⍝   ⊂⍵                : enclose the board (so it's a single scalar item)
+⍝   ¯1 0 1 ⌽¨ ⊂⍵      : produce 3 horizontally-shifted copies
+⍝   ¯1 0 1 ∘.⊖ …      : outer-product with vertical shifts → 3×3 = 9 shifts
+⍝   +/ +/ …           : sum the 9 boards element-wise → neighbor-count + self
+⍝   3 4 = …           : leading-axis-extended boolean — count is 3 (born) or 4 (survive)
+⍝   1 ⍵ ∨.∧ …         : "alive next" iff (count=3) or (alive AND count=4)
+⍝   ⊃ …               : disclose the enclosed result back to a 2D board
+⍝
+⍝ Rules in plain language:
+⍝   - dead cell + 3 live neighbors → born
+⍝   - live cell + 2 or 3 live neighbors → survives
+⍝   - all else → dies
+⍝
+⍝ Toroidal: edges wrap (rotate is cyclic).
+
+life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}

lib/apl/tests/programs/mandelbrot.apl

@@ -0,0 +1,29 @@
+⍝ Mandelbrot — real-axis subset
+⍝
+⍝ For complex c, the Mandelbrot set is { c : |z_n| stays bounded } where
+⍝   z_0 = 0, z_{n+1} = z_n² + c.
+⍝ Restricting c (and z) to ℝ gives the segment c ∈ [-2, 1/4]
+⍝ where the iteration stays bounded.
+⍝
+⍝ Rank-polymorphic batched-iteration form:
+⍝   mandelbrot ← {⍵ ⍵⍵ ⍺⍺ +,(⍺⍺ × ⍺⍺) }
+⍝
+⍝ Pseudocode (as we don't have ⎕ system fns yet):
+⍝   z      ← 0×c                             ⍝ start at zero
+⍝   alive  ← 1+0×c                           ⍝ all "still in"
+⍝   for k iterations:
+⍝     alive ← alive ∧ 4 ≥ z×z                ⍝ still bounded?
+⍝     z     ← alive × c + z×z                ⍝ freeze escaped via mask
+⍝     count ← count + alive                  ⍝ tally surviving iters
+⍝
+⍝ Examples (count after 100 iterations):
+⍝   c=0      : 100  (z stays at 0)
+⍝   c=-1     : 100  (cycles 0,-1,0,-1,...)
+⍝   c=-2     : 100  (settles at 2 — boundary)
+⍝   c=0.25   : 100  (boundary — converges to 0.5)
+⍝   c=0.5    : 5    (escapes by iteration 6)
+⍝   c=1      : 3    (escapes quickly)
+⍝
+⍝ Real-axis Mandelbrot set: bounded for c ∈ [-2, 0.25].
+
+mandelbrot ← {z←alive←count←0×⍵ ⋄ {alive←alive∧4≥z×z ⋄ z←alive×⍵+z×z ⋄ count+←alive}⍣⍺⊢⍵}

lib/apl/tests/programs/n-queens.apl

@@ -0,0 +1,18 @@
+⍝ N-Queens — count solutions to placing N non-attacking queens on N×N
+⍝
+⍝ A solution is encoded as a permutation P of 1..N where P[i] is the
+⍝ column of the queen in row i.  Rows and columns are then automatically
+⍝ unique (it's a permutation).  We must additionally rule out queens
+⍝ sharing a diagonal: |i-j| = |P[i]-P[j]| for any pair.
+⍝
+⍝ Backtracking via reduce — the classic Roger Hui style:
+⍝   queens ← {≢{⍵,¨⍨↓(0=∊(¨⍳⍴⍵)≠.+|⍵)/⍳⍴⍵}/(⍳⍵)⍴⊂⍳⍵}
+⍝
+⍝ Plain reading:
+⍝   permute 1..N, keep those where no two queens share a diagonal.
+⍝
+⍝ Known solution counts (OEIS A000170):
+⍝     N    1   2   3   4   5   6   7    8    9    10
+⍝   q(N)   1   0   0   2  10   4  40   92  352   724
+
+queens ← {≢({(i j)←⍺⍵ ⋄ (|i-j)≠|(P[i])-(P[j])}⌿permutations ⍵)}

lib/apl/tests/programs/primes.apl

@@ -0,0 +1,16 @@
+⍝ Sieve of Eratosthenes — the classic APL one-liner
+⍝   primes ← (2=+⌿0=A∘.|A)/A←⍳N
+⍝
+⍝ Read right-to-left:
+⍝   A ← ⍳N        : A is 1..N
+⍝   A∘.|A         : outer-product residue table — M[i,j] = A[j] mod A[i]
+⍝   0=...         : boolean — true where A[i] divides A[j]
+⍝   +⌿...         : column sums — count of divisors per A[j]
+⍝   2=...         : true for numbers with exactly 2 divisors (1 and self) → primes
+⍝   .../A         : compress — select A[j] where mask[j] is true
+⍝
+⍝ Examples:
+⍝   primes 10  →  2 3 5 7
+⍝   primes 30  →  2 3 5 7 11 13 17 19 23 29
+
+primes ← {(2=+⌿0=⍵∘.|⍵)/⍵←⍳⍵}

lib/apl/tests/programs/quicksort.apl

@@ -0,0 +1,25 @@
+⍝ Quicksort — the classic Roger Hui one-liner
+⍝
+⍝ Q ← {1≥≢⍵:⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p←⍵⌷⍨?≢⍵}
+⍝
+⍝ Read right-to-left:
+⍝   ?≢⍵          : pick a random index in 1..length
+⍝   ⍵⌷⍨…         : take that element as pivot p
+⍝   ⍵>p          : boolean — elements greater than pivot
+⍝   ∇⍵⌿⍨…        : recursively sort the > partition
+⍝   (p=⍵)/⍵      : keep elements equal to pivot
+⍝   ⍵<p          : boolean — elements less than pivot
+⍝   ∇⍵⌿⍨…        : recursively sort the < partition
+⍝   ,            : catenate ⟨less⟩ ⟨equal⟩ ⟨greater⟩
+⍝   1≥≢⍵:⍵       : guard — base case for length ≤ 1
+⍝
+⍝ Stability: not stable on duplicates (but eq-class is preserved as a block).
+⍝ Worst case O(N²) on already-sorted input with deterministic pivot;
+⍝ randomized pivot selection gives expected O(N log N).
+⍝
+⍝ Examples:
+⍝   Q 3 1 4 1 5 9 2 6 5 3 5    →  1 1 2 3 3 4 5 5 5 6 9
+⍝   Q ⍳0                        →  ⍬   (empty)
+⍝   Q ,42                       →  42
+
+quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p}

lib/apl/tests/scalar.sx

@@ -0,0 +1,369 @@
+; APL scalar primitives test suite
+; Requires: lib/apl/runtime.sx
+
+; ============================================================
+; Test framework
+; ============================================================
+
+(define apl-rt-count 0)
+(define apl-rt-pass 0)
+(define apl-rt-fails (list))
+
+; Element-wise list comparison (handles both List and ListRef)
+(define
+  lists-eq
+  (fn
+    (a b)
+    (if
+      (and (= (len a) 0) (= (len b) 0))
+      true
+      (if
+        (not (= (len a) (len b)))
+        false
+        (if
+          (not (= (first a) (first b)))
+          false
+          (lists-eq (rest a) (rest b)))))))
+
+(define
+  apl-rt-test
+  (fn
+    (name actual expected)
+    (begin
+      (set! apl-rt-count (+ apl-rt-count 1))
+      (if
+        (equal? actual expected)
+        (set! apl-rt-pass (+ apl-rt-pass 1))
+        (append! apl-rt-fails {:actual actual :expected expected :name name})))))
+
+; Test that a ravel equals a plain list (handles ListRef vs List)
+(define
+  ravel-test
+  (fn
+    (name arr expected-list)
+    (begin
+      (set! apl-rt-count (+ apl-rt-count 1))
+      (let
+        ((actual (get arr :ravel)))
+        (if
+          (lists-eq actual expected-list)
+          (set! apl-rt-pass (+ apl-rt-pass 1))
+          (append! apl-rt-fails {:actual actual :expected expected-list :name name}))))))
+
+; Test a scalar ravel value (single-element list)
+(define
+  scalar-test
+  (fn (name arr expected-val) (ravel-test name arr (list expected-val))))
+
+; ============================================================
+; Array constructor tests
+; ============================================================
+
+(apl-rt-test
+  "scalar: shape is empty list"
+  (get (apl-scalar 5) :shape)
+  (list))
+
+(apl-rt-test
+  "scalar: ravel has one element"
+  (get (apl-scalar 5) :ravel)
+  (list 5))
+
+(apl-rt-test "scalar: rank 0" (array-rank (apl-scalar 5)) 0)
+
+(apl-rt-test "scalar? returns true for scalar" (scalar? (apl-scalar 5)) true)
+
+(apl-rt-test "scalar: zero" (get (apl-scalar 0) :ravel) (list 0))
+
+(apl-rt-test
+  "vector: shape is (3)"
+  (get (apl-vector (list 1 2 3)) :shape)
+  (list 3))
+
+(apl-rt-test
+  "vector: ravel matches input"
+  (get (apl-vector (list 1 2 3)) :ravel)
+  (list 1 2 3))
+
+(apl-rt-test "vector: rank 1" (array-rank (apl-vector (list 1 2 3))) 1)
+
+(apl-rt-test
+  "scalar? returns false for vector"
+  (scalar? (apl-vector (list 1 2 3)))
+  false)
+
+(apl-rt-test
+  "make-array: rank 2"
+  (array-rank (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  2)
+
+(apl-rt-test
+  "make-array: shape"
+  (get (make-array (list 2 3) (list 1 2 3 4 5 6)) :shape)
+  (list 2 3))
+
+(apl-rt-test
+  "array-ref: first element"
+  (array-ref (apl-vector (list 10 20 30)) 0)
+  10)
+
+(apl-rt-test
+  "array-ref: last element"
+  (array-ref (apl-vector (list 10 20 30)) 2)
+  30)
+
+(apl-rt-test "enclose: wraps in rank-0" (scalar? (enclose 42)) true)
+
+(apl-rt-test
+  "enclose: ravel contains value"
+  (get (enclose 42) :ravel)
+  (list 42))
+
+(apl-rt-test "disclose: unwraps rank-0" (disclose (enclose 42)) 42)
+
+; ============================================================
+; Shape primitive tests
+; ============================================================
+
+(ravel-test "⍴ scalar: returns empty" (apl-shape (apl-scalar 5)) (list))
+
+(ravel-test
+  "⍴ vector: returns (3)"
+  (apl-shape (apl-vector (list 1 2 3)))
+  (list 3))
+
+(ravel-test
+  "⍴ matrix: returns (2 3)"
+  (apl-shape (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  (list 2 3))
+
+(ravel-test
+  ", ravel scalar: vector of 1"
+  (apl-ravel (apl-scalar 5))
+  (list 5))
+
+(apl-rt-test
+  ", ravel vector: same elements"
+  (get (apl-ravel (apl-vector (list 1 2 3))) :ravel)
+  (list 1 2 3))
+
+(apl-rt-test
+  ", ravel matrix: all elements"
+  (get (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))) :ravel)
+  (list 1 2 3 4 5 6))
+
+(scalar-test "≢ tally scalar: 1" (apl-tally (apl-scalar 5)) 1)
+
+(scalar-test
+  "≢ tally vector: first dimension"
+  (apl-tally (apl-vector (list 1 2 3)))
+  3)
+
+(scalar-test
+  "≢ tally matrix: first dimension"
+  (apl-tally (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  2)
+
+(scalar-test
+  "≡ depth flat vector: 0"
+  (apl-depth (apl-vector (list 1 2 3)))
+  0)
+
+(scalar-test "≡ depth scalar: 0" (apl-depth (apl-scalar 5)) 0)
+
+(scalar-test
+  "≡ depth nested (enclose in vector): 1"
+  (apl-depth (enclose (apl-vector (list 1 2 3))))
+  1)
+
+; ============================================================
+; ⍳ iota tests
+; ============================================================
+
+(apl-rt-test
+  "⍳5 shape is (5)"
+  (get (apl-iota (apl-scalar 5)) :shape)
+  (list 5))
+
+(ravel-test "⍳5 ravel is 1..5" (apl-iota (apl-scalar 5)) (list 1 2 3 4 5))
+
+(ravel-test "⍳1 ravel is (1)" (apl-iota (apl-scalar 1)) (list 1))
+
+(ravel-test "⍳0 ravel is empty" (apl-iota (apl-scalar 0)) (list))
+
+(apl-rt-test "apl-io is 1" apl-io 1)
+
+; ============================================================
+; Arithmetic broadcast tests
+; ============================================================
+
+(scalar-test
+  "+ scalar scalar: 3+4=7"
+  (apl-add (apl-scalar 3) (apl-scalar 4))
+  7)
+
+(ravel-test
+  "+ vector scalar: +10"
+  (apl-add (apl-vector (list 1 2 3)) (apl-scalar 10))
+  (list 11 12 13))
+
+(ravel-test
+  "+ scalar vector: 10+"
+  (apl-add (apl-scalar 10) (apl-vector (list 1 2 3)))
+  (list 11 12 13))
+
+(ravel-test
+  "+ vector vector"
+  (apl-add (apl-vector (list 1 2 3)) (apl-vector (list 4 5 6)))
+  (list 5 7 9))
+
+(scalar-test "- negate monadic" (apl-neg-m (apl-scalar 5)) -5)
+
+(scalar-test "- dyadic 10-3=7" (apl-sub (apl-scalar 10) (apl-scalar 3)) 7)
+
+(scalar-test "× signum positive" (apl-signum (apl-scalar 7)) 1)
+
+(scalar-test "× signum negative" (apl-signum (apl-scalar -3)) -1)
+
+(scalar-test "× signum zero" (apl-signum (apl-scalar 0)) 0)
+
+(scalar-test "× dyadic 3×4=12" (apl-mul (apl-scalar 3) (apl-scalar 4)) 12)
+
+(scalar-test "÷ reciprocal 1÷4=0.25" (apl-recip (apl-scalar 4)) 0.25)
+
+(scalar-test
+  "÷ dyadic 10÷4=2.5"
+  (apl-div (apl-scalar 10) (apl-scalar 4))
+  2.5)
+
+(scalar-test "⌈ ceiling 2.3→3" (apl-ceil (apl-scalar 2.3)) 3)
+
+(scalar-test "⌈ max 3 5 → 5" (apl-max (apl-scalar 3) (apl-scalar 5)) 5)
+
+(scalar-test "⌊ floor 2.7→2" (apl-floor (apl-scalar 2.7)) 2)
+
+(scalar-test "⌊ min 3 5 → 3" (apl-min (apl-scalar 3) (apl-scalar 5)) 3)
+
+(scalar-test "* exp monadic e^0=1" (apl-exp (apl-scalar 0)) 1)
+
+(scalar-test
+  "* pow dyadic 2^10=1024"
+  (apl-pow (apl-scalar 2) (apl-scalar 10))
+  1024)
+
+(scalar-test "⍟ ln 1=0" (apl-ln (apl-scalar 1)) 0)
+
+(scalar-test "| abs positive" (apl-abs (apl-scalar 5)) 5)
+
+(scalar-test "| abs negative" (apl-abs (apl-scalar -5)) 5)
+
+(scalar-test "| mod 3|7=1" (apl-mod (apl-scalar 3) (apl-scalar 7)) 1)
+
+(scalar-test "! factorial 5!=120" (apl-fact (apl-scalar 5)) 120)
+
+(scalar-test "! factorial 0!=1" (apl-fact (apl-scalar 0)) 1)
+
+(scalar-test
+  "! binomial 4 choose 2 = 6"
+  (apl-binomial (apl-scalar 4) (apl-scalar 2))
+  6)
+
+(scalar-test "○ pi×0=0" (apl-pi-times (apl-scalar 0)) 0)
+
+(scalar-test "○ trig sin(0)=0" (apl-trig (apl-scalar 1) (apl-scalar 0)) 0)
+
+(scalar-test "○ trig cos(0)=1" (apl-trig (apl-scalar 2) (apl-scalar 0)) 1)
+
+; ============================================================
+; Comparison tests
+; ============================================================
+
+(scalar-test "< less: 3<5 → 1" (apl-lt (apl-scalar 3) (apl-scalar 5)) 1)
+
+(scalar-test "< less: 5<3 → 0" (apl-lt (apl-scalar 5) (apl-scalar 3)) 0)
+
+(scalar-test
+  "≤ le equal: 3≤3 → 1"
+  (apl-le (apl-scalar 3) (apl-scalar 3))
+  1)
+
+(scalar-test "= eq: 5=5 → 1" (apl-eq (apl-scalar 5) (apl-scalar 5)) 1)
+
+(scalar-test "= ne: 5=6 → 0" (apl-eq (apl-scalar 5) (apl-scalar 6)) 0)
+
+(scalar-test "≥ ge: 5≥3 → 1" (apl-ge (apl-scalar 5) (apl-scalar 3)) 1)
+
+(scalar-test "> gt: 5>3 → 1" (apl-gt (apl-scalar 5) (apl-scalar 3)) 1)
+
+(scalar-test "≠ ne: 5≠3 → 1" (apl-ne (apl-scalar 5) (apl-scalar 3)) 1)
+
+(ravel-test
+  "comparison vector broadcast: 1 2 3 < 2 → 1 0 0"
+  (apl-lt (apl-vector (list 1 2 3)) (apl-scalar 2))
+  (list 1 0 0))
+
+; ============================================================
+; Logical tests
+; ============================================================
+
+(scalar-test "~ not 0 → 1" (apl-not (apl-scalar 0)) 1)
+
+(scalar-test "~ not 1 → 0" (apl-not (apl-scalar 1)) 0)
+
+(ravel-test
+  "~ not vector: 1 0 1 0 → 0 1 0 1"
+  (apl-not (apl-vector (list 1 0 1 0)))
+  (list 0 1 0 1))
+
+(scalar-test
+  "∧ and 1∧1 → 1"
+  (apl-and (apl-scalar 1) (apl-scalar 1))
+  1)
+
+(scalar-test
+  "∧ and 1∧0 → 0"
+  (apl-and (apl-scalar 1) (apl-scalar 0))
+  0)
+
+(scalar-test "∨ or 0∨1 → 1" (apl-or (apl-scalar 0) (apl-scalar 1)) 1)
+
+(scalar-test "∨ or 0∨0 → 0" (apl-or (apl-scalar 0) (apl-scalar 0)) 0)
+
+(scalar-test
+  "⍱ nor 0⍱0 → 1"
+  (apl-nor (apl-scalar 0) (apl-scalar 0))
+  1)
+
+(scalar-test
+  "⍱ nor 1⍱0 → 0"
+  (apl-nor (apl-scalar 1) (apl-scalar 0))
+  0)
+
+(scalar-test
+  "⍲ nand 1⍲1 → 0"
+  (apl-nand (apl-scalar 1) (apl-scalar 1))
+  0)
+
+(scalar-test
+  "⍲ nand 1⍲0 → 1"
+  (apl-nand (apl-scalar 1) (apl-scalar 0))
+  1)
+
+; ============================================================
+; plus-m identity test
+; ============================================================
+
+(scalar-test "+ monadic identity: +5 → 5" (apl-plus-m (apl-scalar 5)) 5)
+
+; ============================================================
+; Summary
+; ============================================================
+
+(define
+  apl-scalar-summary
+  (str
+    "scalar "
+    apl-rt-pass
+    "/"
+    apl-rt-count
+    (if (= (len apl-rt-fails) 0) "" (str " FAILS: " apl-rt-fails))))

lib/apl/tests/structural.sx

@@ -0,0 +1,608 @@
+;; lib/apl/tests/structural.sx — Phase 3: structural primitives
+;; Tests for: apl-reshape, apl-ravel, apl-transpose, apl-transpose-dyadic
+;; Loaded after runtime.sx; shares apl-test / apl-test-pass / apl-test-fail.
+
+(define rv (fn (arr) (get arr :ravel)))
+(define sh (fn (arr) (get arr :shape)))
+
+;; ---------------------------------------------------------------------------
+;; 1. Ravel (monadic ,)
+;; ---------------------------------------------------------------------------
+(apl-test "ravel scalar" (rv (apl-ravel (apl-scalar 5))) (list 5))
+
+(apl-test
+  "ravel vector"
+  (rv (apl-ravel (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "ravel matrix"
+  (rv (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "ravel shape is rank-1"
+  (sh (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 6))
+
+;; ---------------------------------------------------------------------------
+;; 2. Reshape (dyadic ⍴)
+;; ---------------------------------------------------------------------------
+
+(apl-test
+  "reshape 2x3 ravel"
+  (rv
+    (apl-reshape
+      (make-array (list 2) (list 2 3))
+      (make-array (list 6) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "reshape 2x3 shape"
+  (sh
+    (apl-reshape
+      (make-array (list 2) (list 2 3))
+      (make-array (list 6) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "reshape cycle 6 from 1 2"
+  (rv
+    (apl-reshape
+      (make-array (list 1) (list 6))
+      (make-array (list 2) (list 1 2))))
+  (list 1 2 1 2 1 2))
+
+(apl-test
+  "reshape cycle 2x3 from 1 2"
+  (rv
+    (apl-reshape
+      (make-array (list 2) (list 2 3))
+      (make-array (list 2) (list 1 2))))
+  (list 1 2 1 2 1 2))
+
+(apl-test
+  "reshape scalar fill"
+  (rv (apl-reshape (make-array (list 1) (list 4)) (apl-scalar 7)))
+  (list 7 7 7 7))
+
+(apl-test
+  "reshape truncate"
+  (rv
+    (apl-reshape
+      (make-array (list 1) (list 3))
+      (make-array (list 6) (list 10 20 30 40 50 60))))
+  (list 10 20 30))
+
+(apl-test
+  "reshape matrix to vector"
+  (sh
+    (apl-reshape
+      (make-array (list 1) (list 6))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 6))
+
+(apl-test
+  "reshape 2x2x3"
+  (sh
+    (apl-reshape
+      (make-array (list 3) (list 2 2 3))
+      (make-array (list 12) (range 1 13))))
+  (list 2 2 3))
+
+(apl-test
+  "reshape to empty"
+  (rv
+    (apl-reshape
+      (make-array (list 1) (list 0))
+      (make-array (list 3) (list 1 2 3))))
+  (list))
+
+;; ---------------------------------------------------------------------------
+;; 3. Monadic transpose (⍉)
+;; ---------------------------------------------------------------------------
+
+(apl-test
+  "transpose scalar shape"
+  (sh (apl-transpose (apl-scalar 99)))
+  (list))
+
+(apl-test
+  "transpose scalar ravel"
+  (rv (apl-transpose (apl-scalar 99)))
+  (list 99))
+
+(apl-test
+  "transpose vector shape"
+  (sh (apl-transpose (make-array (list 3) (list 3 1 4))))
+  (list 3))
+
+(apl-test
+  "transpose vector ravel"
+  (rv (apl-transpose (make-array (list 3) (list 3 1 4))))
+  (list 3 1 4))
+
+(apl-test
+  "transpose 2x3 shape"
+  (sh (apl-transpose (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2))
+
+(apl-test
+  "transpose 2x3 ravel"
+  (rv (apl-transpose (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 4 2 5 3 6))
+
+(apl-test
+  "transpose 3x3"
+  (rv (apl-transpose (make-array (list 3 3) (list 1 2 3 4 5 6 7 8 9))))
+  (list 1 4 7 2 5 8 3 6 9))
+
+(apl-test
+  "transpose 1x4 shape"
+  (sh (apl-transpose (make-array (list 1 4) (list 1 2 3 4))))
+  (list 4 1))
+
+(apl-test
+  "transpose twice identity"
+  (rv
+    (apl-transpose
+      (apl-transpose (make-array (list 2 3) (list 1 2 3 4 5 6)))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "transpose 3d shape"
+  (sh (apl-transpose (make-array (list 2 3 4) (range 0 24))))
+  (list 4 3 2))
+
+;; ---------------------------------------------------------------------------
+;; 4. Dyadic transpose (perm⍉arr)
+;; ---------------------------------------------------------------------------
+
+(apl-test
+  "dyadic-transpose identity"
+  (rv
+    (apl-transpose-dyadic
+      (make-array (list 2) (list 1 2))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "dyadic-transpose swap 2x3"
+  (rv
+    (apl-transpose-dyadic
+      (make-array (list 2) (list 2 1))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 4 2 5 3 6))
+
+(apl-test
+  "dyadic-transpose swap shape"
+  (sh
+    (apl-transpose-dyadic
+      (make-array (list 2) (list 2 1))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2))
+
+(apl-test
+  "dyadic-transpose 3d shape"
+  (sh
+    (apl-transpose-dyadic
+      (make-array (list 3) (list 2 1 3))
+      (make-array (list 2 3 4) (range 0 24))))
+  (list 3 2 4))
+
+(apl-test
+  "take 3 from front"
+  (rv (apl-take (apl-scalar 3) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3))
+
+(apl-test
+  "take 0"
+  (rv (apl-take (apl-scalar 0) (make-array (list 5) (list 1 2 3 4 5))))
+  (list))
+
+(apl-test
+  "take -2 from back"
+  (rv (apl-take (apl-scalar -2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 4 5))
+
+(apl-test
+  "take over-take pads with 0"
+  (rv (apl-take (apl-scalar 7) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5 0 0))
+
+(apl-test
+  "take matrix 1 row 2 cols shape"
+  (sh
+    (apl-take
+      (make-array (list 2) (list 1 2))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2))
+
+(apl-test
+  "take matrix 1 row 2 cols ravel"
+  (rv
+    (apl-take
+      (make-array (list 2) (list 1 2))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2))
+
+(apl-test
+  "take matrix negative row"
+  (rv
+    (apl-take
+      (make-array (list 2) (list -1 3))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6))
+
+(apl-test
+  "drop 2 from front"
+  (rv (apl-drop (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 3 4 5))
+
+(apl-test
+  "drop -2 from back"
+  (rv (apl-drop (apl-scalar -2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3))
+
+(apl-test
+  "drop all"
+  (rv (apl-drop (apl-scalar 5) (make-array (list 5) (list 1 2 3 4 5))))
+  (list))
+
+(apl-test
+  "drop 0"
+  (rv (apl-drop (apl-scalar 0) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "drop matrix 1 row shape"
+  (sh
+    (apl-drop
+      (make-array (list 2) (list 1 0))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 3))
+
+(apl-test
+  "drop matrix 1 row ravel"
+  (rv
+    (apl-drop
+      (make-array (list 2) (list 1 0))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6))
+
+(apl-test
+  "reverse vector"
+  (rv (apl-reverse (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5 4 3 2 1))
+
+(apl-test
+  "reverse scalar identity"
+  (rv (apl-reverse (apl-scalar 42)))
+  (list 42))
+
+(apl-test
+  "reverse matrix last axis"
+  (rv (apl-reverse (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2 1 6 5 4))
+
+(apl-test
+  "reverse-first matrix"
+  (rv (apl-reverse-first (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6 1 2 3))
+
+(apl-test
+  "reverse-first vector identity"
+  (rv (apl-reverse-first (make-array (list 4) (list 1 2 3 4))))
+  (list 4 3 2 1))
+
+(apl-test
+  "rotate vector left by 2"
+  (rv (apl-rotate (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 3 4 5 1 2))
+
+(apl-test
+  "rotate vector right by 1 (negative)"
+  (rv (apl-rotate (apl-scalar -1) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5 1 2 3 4))
+
+(apl-test
+  "rotate by 0 is identity"
+  (rv (apl-rotate (apl-scalar 0) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "rotate matrix last axis"
+  (rv
+    (apl-rotate (apl-scalar 1) (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3 1 5 6 4))
+
+(apl-test
+  "rotate-first matrix"
+  (rv
+    (apl-rotate-first
+      (apl-scalar 1)
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6 1 2 3))
+
+(apl-test
+  "cat v,v ravel"
+  (rv
+    (apl-catenate
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "cat v,v shape"
+  (sh
+    (apl-catenate
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 4 5))))
+  (list 5))
+
+(apl-test
+  "cat scalar,v"
+  (rv (apl-catenate (apl-scalar 99) (make-array (list 3) (list 1 2 3))))
+  (list 99 1 2 3))
+
+(apl-test
+  "cat v,scalar"
+  (rv (apl-catenate (make-array (list 3) (list 1 2 3)) (apl-scalar 99)))
+  (list 1 2 3 99))
+
+(apl-test
+  "cat matrix last-axis shape"
+  (sh
+    (apl-catenate
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 2 2) (list 7 8 9 10))))
+  (list 2 5))
+
+(apl-test
+  "cat matrix last-axis ravel"
+  (rv
+    (apl-catenate
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 2 2) (list 7 8 9 10))))
+  (list 1 2 3 7 8 4 5 6 9 10))
+
+(apl-test
+  "cat-first v,v shape"
+  (sh
+    (apl-catenate-first
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 4 5))))
+  (list 5))
+
+(apl-test
+  "cat-first matrix shape"
+  (sh
+    (apl-catenate-first
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 3) (list 11 12 13 14 15 16 17 18 19))))
+  (list 5 3))
+
+(apl-test
+  "cat-first matrix ravel"
+  (rv
+    (apl-catenate-first
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 3) (list 11 12 13 14 15 16 17 18 19))))
+  (list 1 2 3 4 5 6 11 12 13 14 15 16 17 18 19))
+
+(apl-test
+  "squad scalar into vector"
+  (rv
+    (apl-squad (apl-scalar 2) (make-array (list 5) (list 10 20 30 40 50))))
+  (list 20))
+
+(apl-test
+  "squad first element"
+  (rv (apl-squad (apl-scalar 1) (make-array (list 3) (list 10 20 30))))
+  (list 10))
+
+(apl-test
+  "squad last element"
+  (rv
+    (apl-squad (apl-scalar 5) (make-array (list 5) (list 10 20 30 40 50))))
+  (list 50))
+
+(apl-test
+  "squad fully specified matrix element"
+  (rv
+    (apl-squad
+      (make-array (list 2) (list 2 3))
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 7))
+
+(apl-test
+  "squad partial row of matrix shape"
+  (sh
+    (apl-squad
+      (apl-scalar 2)
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 4))
+
+(apl-test
+  "squad partial row of matrix ravel"
+  (rv
+    (apl-squad
+      (apl-scalar 2)
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 5 6 7 8))
+
+(apl-test
+  "squad partial 3d slice shape"
+  (sh (apl-squad (apl-scalar 1) (make-array (list 2 3 4) (range 1 25))))
+  (list 3 4))
+
+(apl-test
+  "grade-up basic"
+  (rv (apl-grade-up (make-array (list 5) (list 3 1 4 1 5))))
+  (list 2 4 1 3 5))
+
+(apl-test
+  "grade-up shape"
+  (sh (apl-grade-up (make-array (list 4) (list 4 1 3 2))))
+  (list 4))
+
+(apl-test
+  "grade-up no duplicates"
+  (rv (apl-grade-up (make-array (list 4) (list 4 1 3 2))))
+  (list 2 4 3 1))
+
+(apl-test
+  "grade-up already sorted"
+  (rv (apl-grade-up (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "grade-up reverse sorted"
+  (rv (apl-grade-up (make-array (list 3) (list 3 2 1))))
+  (list 3 2 1))
+
+(apl-test
+  "grade-down basic"
+  (rv (apl-grade-down (make-array (list 5) (list 3 1 4 1 5))))
+  (list 5 3 1 2 4))
+
+(apl-test
+  "grade-down no duplicates"
+  (rv (apl-grade-down (make-array (list 4) (list 4 1 3 2))))
+  (list 1 3 4 2))
+
+(apl-test
+  "grade-up single element"
+  (rv (apl-grade-up (make-array (list 1) (list 42))))
+  (list 1))
+
+(apl-test
+  "enclose shape is scalar"
+  (sh (apl-enclose (make-array (list 3) (list 1 2 3))))
+  (list))
+
+(apl-test
+  "enclose ravel length is 1"
+  (len (rv (apl-enclose (make-array (list 3) (list 1 2 3)))))
+  1)
+
+(apl-test
+  "enclose inner ravel"
+  (rv (first (rv (apl-enclose (make-array (list 3) (list 1 2 3))))))
+  (list 1 2 3))
+
+(apl-test
+  "disclose of enclose round-trips ravel"
+  (rv (apl-disclose (apl-enclose (make-array (list 3) (list 10 20 30)))))
+  (list 10 20 30))
+
+(apl-test
+  "disclose of enclose round-trips shape"
+  (sh (apl-disclose (apl-enclose (make-array (list 3) (list 10 20 30)))))
+  (list 3))
+
+(apl-test
+  "disclose scalar ravel"
+  (rv (apl-disclose (apl-scalar 42)))
+  (list 42))
+
+(apl-test
+  "disclose vector ravel"
+  (rv (apl-disclose (make-array (list 3) (list 5 6 7))))
+  (list 5))
+
+(apl-test
+  "disclose matrix returns first row"
+  (rv (apl-disclose (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3))
+
+(apl-test
+  "member basic"
+  (rv
+    (apl-member
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 2 3))))
+  (list 0 1 1))
+
+(apl-test
+  "member all absent"
+  (rv
+    (apl-member
+      (make-array (list 3) (list 4 5 6))
+      (make-array (list 3) (list 1 2 3))))
+  (list 0 0 0))
+
+(apl-test
+  "member scalar"
+  (rv (apl-member (apl-scalar 5) (make-array (list 3) (list 1 5 9))))
+  (list 1))
+
+(apl-test
+  "member shape preserved"
+  (sh
+    (apl-member
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 1 3 5))))
+  (list 2 3))
+
+(apl-test
+  "member matrix ravel"
+  (rv
+    (apl-member
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 1 3 5))))
+  (list 1 0 1 0 1 0))
+
+(apl-test
+  "index-of basic"
+  (rv
+    (apl-index-of
+      (make-array (list 4) (list 10 20 30 40))
+      (make-array (list 3) (list 20 40 10))))
+  (list 2 4 1))
+
+(apl-test
+  "index-of not-found"
+  (rv
+    (apl-index-of
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 5 2))))
+  (list 4 2))
+
+(apl-test
+  "index-of scalar right"
+  (rv
+    (apl-index-of (make-array (list 3) (list 10 20 30)) (apl-scalar 20)))
+  (list 2))
+
+(apl-test
+  "without basic"
+  (rv
+    (apl-without
+      (make-array (list 5) (list 1 2 3 4 5))
+      (make-array (list 2) (list 2 4))))
+  (list 1 3 5))
+
+(apl-test
+  "without shape"
+  (sh
+    (apl-without
+      (make-array (list 5) (list 1 2 3 4 5))
+      (make-array (list 2) (list 2 4))))
+  (list 3))
+
+(apl-test
+  "without nothing removed"
+  (rv
+    (apl-without
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 4 5 6))))
+  (list 1 2 3))
+
+(apl-test
+  "without all removed"
+  (rv
+    (apl-without
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list))

lib/apl/tests/system.sx

@@ -0,0 +1,48 @@
+; Tests for APL ⎕ system functions.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+(apl-test "⎕IO returns 1" (mkrv (apl-quad-io)) (list 1))
+
+(apl-test "⎕ML returns 1" (mkrv (apl-quad-ml)) (list 1))
+
+(apl-test "⎕FR returns 1248" (mkrv (apl-quad-fr)) (list 1248))
+
+(apl-test "⎕TS shape is 7" (mksh (apl-quad-ts)) (list 7))
+
+(apl-test "⎕TS year is 1970 default" (first (mkrv (apl-quad-ts))) 1970)
+
+(apl-test "⎕FMT scalar 42" (apl-quad-fmt (apl-scalar 42)) "42")
+
+(apl-test "⎕FMT scalar negative" (apl-quad-fmt (apl-scalar -7)) "-7")
+
+(apl-test
+  "⎕FMT empty vector"
+  (apl-quad-fmt (make-array (list 0) (list)))
+  "")
+
+(apl-test
+  "⎕FMT singleton vector"
+  (apl-quad-fmt (make-array (list 1) (list 42)))
+  "42")
+
+(apl-test
+  "⎕FMT vector"
+  (apl-quad-fmt (make-array (list 5) (list 1 2 3 4 5)))
+  "1 2 3 4 5")
+
+(apl-test
+  "⎕FMT matrix 2x3"
+  (apl-quad-fmt (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  "1 2 3\n4 5 6\n")
+
+(apl-test
+  "⎕← (print) returns its arg"
+  (mkrv (apl-quad-print (apl-scalar 99)))
+  (list 99))
+
+(apl-test
+  "⎕← preserves shape"
+  (mksh (apl-quad-print (make-array (list 3) (list 1 2 3))))
+  (list 3))

lib/apl/tests/tradfn.sx

@@ -0,0 +1,156 @@
+; Tests for apl-call-tradfn (manual structure construction).
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+(define mknum (fn (n) (list :num n)))
+(define mknm (fn (s) (list :name s)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad (mkfg g) a)))
+(define mkdyd (fn (g l r) (list :dyad (mkfg g) l r)))
+(define mkasg (fn (n e) (list :assign n e)))
+(define mkbr (fn (e) (list :branch e)))
+
+(define mkif (fn (c t e) (list :if c t e)))
+
+(define mkwhile (fn (c b) (list :while c b)))
+
+(define mkfor (fn (v i b) (list :for v i b)))
+
+(define mksel (fn (v cs d) (list :select v cs d)))
+
+(define mktrap (fn (codes t c) (list :trap codes t c)))
+
+(define mkthr (fn (code msg) (list :throw code msg)))
+
+(apl-test
+  "tradfn R←L+W simple add"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "+" (mknm "L") (mknm "W")))) :alpha "L"} (apl-scalar 5) (apl-scalar 7)))
+  (list 12))
+
+(apl-test
+  "tradfn R←L×W"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "×" (mknm "L") (mknm "W")))) :alpha "L"} (apl-scalar 6) (apl-scalar 7)))
+  (list 42))
+
+(apl-test
+  "tradfn monadic R←-W"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkmon "-" (mknm "W")))) :alpha nil} nil (apl-scalar 9)))
+  (list -9))
+
+(apl-test
+  "tradfn →0 exits early"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknm "W")) (mkbr (mknum 0)) (mkasg "R" (mknum 999))) :alpha nil} nil (apl-scalar 7)))
+  (list 7))
+
+(apl-test
+  "tradfn branch to line 3 skips line 2"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkbr (mknum 3)) (mkasg "R" (mknum 999)) (mkasg "R" (mknum 42))) :alpha nil} nil (apl-scalar 0)))
+  (list 42))
+
+(apl-test
+  "tradfn local var t←W+1; R←t×2"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "t" (mkdyd "+" (mknm "W") (mknum 1))) (mkasg "R" (mkdyd "×" (mknm "t") (mknum 2)))) :alpha nil} nil (apl-scalar 5)))
+  (list 12))
+
+(apl-test
+  "tradfn vector args"
+  (mkrv
+    (apl-call-tradfn
+      {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "+" (mknm "L") (mknm "W")))) :alpha "L"}
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 22 33))
+
+(apl-test
+  "tradfn unset result returns nil"
+  (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkbr (mknum 0))) :alpha nil} nil (apl-scalar 5))
+  nil)
+
+(apl-test
+  "tradfn run-off end returns result"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "×" (mknm "W") (mknum 3)))) :alpha nil} nil (apl-scalar 7)))
+  (list 21))
+
+(apl-test
+  "tradfn loop sum 1+2+...+5 via branch"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "i" (mknum 1)) (mkasg "R" (mknum 0)) (mkasg "R" (mkdyd "+" (mknm "R") (mknm "i"))) (mkasg "i" (mkdyd "+" (mknm "i") (mknum 1))) (mkbr (mkdyd "×" (mkdyd "≤" (mknm "i") (mknm "W")) (mknum 3)))) :alpha nil} nil (apl-scalar 5)))
+  (list 15))
+
+(apl-test
+  "tradfn :If true branch"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkif (mkdyd ">" (mknm "W") (mknum 0)) (list (mkasg "R" (mknum 1))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 5)))
+  (list 1))
+
+(apl-test
+  "tradfn :If false branch"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkif (mkdyd ">" (mknm "W") (mknum 100)) (list (mkasg "R" (mknum 1))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 5)))
+  (list 0))
+
+(apl-test
+  "tradfn :While sum 1..N"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "i" (mknum 1)) (mkasg "R" (mknum 0)) (mkwhile (mkdyd "≤" (mknm "i") (mknm "W")) (list (mkasg "R" (mkdyd "+" (mknm "R") (mknm "i"))) (mkasg "i" (mkdyd "+" (mknm "i") (mknum 1)))))) :alpha nil} nil (apl-scalar 10)))
+  (list 55))
+
+(apl-test
+  "tradfn :For sum elements"
+  (mkrv
+    (apl-call-tradfn
+      {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 0)) (mkfor "x" (mknm "W") (list (mkasg "R" (mkdyd "+" (mknm "R") (mknm "x")))))) :alpha nil}
+      nil
+      (make-array (list 4) (list 10 20 30 40))))
+  (list 100))
+
+(apl-test
+  "tradfn :For with empty vector"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 99)) (mkfor "x" (mknm "W") (list (mkasg "R" (mkdyd "+" (mknm "R") (mknm "x")))))) :alpha nil} nil (make-array (list 0) (list))))
+  (list 99))
+
+(apl-test
+  "tradfn :Select dispatch hit"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mksel (mknm "W") (list (list (mknum 1) (mkasg "R" (mknum 100))) (list (mknum 2) (mkasg "R" (mknum 200))) (list (mknum 3) (mkasg "R" (mknum 300)))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 2)))
+  (list 200))
+
+(apl-test
+  "tradfn :Select default block"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mksel (mknm "W") (list (list (mknum 1) (mkasg "R" (mknum 100))) (list (mknum 2) (mkasg "R" (mknum 200)))) (list (mkasg "R" (mknum -1))))) :alpha nil} nil (apl-scalar 99)))
+  (list -1))
+
+(apl-test
+  "tradfn nested :If"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkif (mkdyd ">" (mknm "W") (mknum 0)) (list (mkif (mkdyd ">" (mknm "W") (mknum 10)) (list (mkasg "R" (mknum 2))) (list (mkasg "R" (mknum 1))))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 5)))
+  (list 1))
+
+(apl-test
+  "tradfn :If assigns persist outside"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 0)) (mkif (mkdyd ">" (mknm "W") (mknum 0)) (list (mkasg "R" (mknum 42))) (list)) (mkasg "R" (mkdyd "+" (mknm "R") (mknum 1)))) :alpha nil} nil (apl-scalar 5)))
+  (list 43))
+
+(apl-test
+  "tradfn :For factorial 1..5"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 1)) (mkfor "x" (mkmon "⍳" (mknm "W")) (list (mkasg "R" (mkdyd "×" (mknm "R") (mknm "x")))))) :alpha nil} nil (apl-scalar 5)))
+  (list 120))
+
+(apl-test
+  "tradfn :Trap normal flow (no error)"
+  (mkrv (apl-call-tradfn {:result "R" :omega nil :stmts (list (mktrap (list 0) (list (mkasg "R" (mknum 99))) (list (mkasg "R" (mknum -1))))) :alpha nil} nil nil))
+  (list 99))
+
+(apl-test
+  "tradfn :Trap catches matching code"
+  (mkrv (apl-call-tradfn {:result "R" :omega nil :stmts (list (mktrap (list 5) (list (mkthr 5 "boom")) (list (mkasg "R" (mknum 42))))) :alpha nil} nil nil))
+  (list 42))
+
+(apl-test
+  "tradfn :Trap catch-all (code 0)"
+  (mkrv (apl-call-tradfn {:result "R" :omega nil :stmts (list (mktrap (list 0) (list (mkthr 99 "any")) (list (mkasg "R" (mknum 1))))) :alpha nil} nil nil))
+  (list 1))
+
+(apl-test
+  "tradfn :Trap catches one of many codes"
+  (mkrv (apl-call-tradfn {:result "R" :omega nil :stmts (list (mktrap (list 1 2 3) (list (mkthr 2 "two")) (list (mkasg "R" (mknum 22))))) :alpha nil} nil nil))
+  (list 22))
+
+(apl-test
+  "tradfn :Trap continues to next stmt after catch"
+  (mkrv (apl-call-tradfn {:result "R" :omega nil :stmts (list (mktrap (list 7) (list (mkthr 7 "c")) (list (mkasg "R" (mknum 10)))) (mkasg "R" (mkdyd "+" (mknm "R") (mknum 5)))) :alpha nil} nil nil))
+  (list 15))

lib/apl/tests/valence.sx

@@ -0,0 +1,81 @@
+; Tests for valence detection (apl-dfn-valence, apl-tradfn-valence)
+; and unified dispatch (apl-call).
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mknum (fn (n) (list :num n)))
+(define mknm (fn (s) (list :name s)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad (mkfg g) a)))
+(define mkdyd (fn (g l r) (list :dyad (mkfg g) l r)))
+(define mkasg (fn (n e) (list :assign n e)))
+(define mkdfn (fn (stmts) (cons :dfn stmts)))
+
+(apl-test
+  "dfn-valence niladic body=42"
+  (apl-dfn-valence (mkdfn (list (mknum 42))))
+  :niladic)
+
+(apl-test
+  "dfn-valence monadic body=⍵+1"
+  (apl-dfn-valence (mkdfn (list (mkdyd "+" (mknm "⍵") (mknum 1)))))
+  :monadic)
+
+(apl-test
+  "dfn-valence dyadic body=⍺+⍵"
+  (apl-dfn-valence (mkdfn (list (mkdyd "+" (mknm "⍺") (mknm "⍵")))))
+  :dyadic)
+
+(apl-test
+  "dfn-valence dyadic mentions ⍺ via local"
+  (apl-dfn-valence (mkdfn (list (mkasg "x" (mknm "⍺")) (mknm "x"))))
+  :dyadic)
+
+(apl-test
+  "dfn-valence dyadic deep nest"
+  (apl-dfn-valence
+    (mkdfn (list (mkmon "-" (mkdyd "×" (mknm "⍺") (mknm "⍵"))))))
+  :dyadic)
+
+(apl-test "tradfn-valence niladic" (apl-tradfn-valence {:result "R" :omega nil :stmts (list) :alpha nil}) :niladic)
+
+(apl-test "tradfn-valence monadic" (apl-tradfn-valence {:result "R" :omega "W" :stmts (list) :alpha nil}) :monadic)
+
+(apl-test "tradfn-valence dyadic" (apl-tradfn-valence {:result "R" :omega "W" :stmts (list) :alpha "L"}) :dyadic)
+
+(apl-test
+  "apl-call dfn niladic"
+  (mkrv (apl-call (mkdfn (list (mknum 42))) nil nil))
+  (list 42))
+
+(apl-test
+  "apl-call dfn monadic"
+  (mkrv
+    (apl-call
+      (mkdfn (list (mkdyd "+" (mknm "⍵") (mknum 1))))
+      nil
+      (apl-scalar 5)))
+  (list 6))
+
+(apl-test
+  "apl-call dfn dyadic"
+  (mkrv
+    (apl-call
+      (mkdfn (list (mkdyd "+" (mknm "⍺") (mknm "⍵"))))
+      (apl-scalar 3)
+      (apl-scalar 4)))
+  (list 7))
+
+(apl-test
+  "apl-call tradfn dyadic"
+  (mkrv (apl-call {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "×" (mknm "L") (mknm "W")))) :alpha "L"} (apl-scalar 6) (apl-scalar 7)))
+  (list 42))
+
+(apl-test
+  "apl-call tradfn monadic"
+  (mkrv (apl-call {:result "R" :omega "W" :stmts (list (mkasg "R" (mkmon "-" (mknm "W")))) :alpha nil} nil (apl-scalar 9)))
+  (list -9))
+
+(apl-test
+  "apl-call tradfn niladic returns nil result"
+  (apl-call {:result "R" :omega nil :stmts (list) :alpha nil} nil nil)
+  nil)

lib/apl/tokenizer.sx

@@ -0,0 +1,198 @@
+(define apl-glyph-set
+  (list "+" "-" "×" "÷" "*" "⍟" "⌈" "⌊" "|" "!" "?" "○" "~" "<" "≤" "=" "≥" ">" "≠"
+        "≢" "≡" "∊" "∧" "∨" "⍱" "⍲" "," "⍪" "⍴" "⌽" "⊖" "⍉" "↑" "↓" "⊂" "⊃" "⊆"
+        "∪" "∩" "⍳" "⍸" "⌷" "⍋" "⍒" "⊥" "⊤" "⊣" "⊢" "⍎" "⍕"
+        "⍺" "⍵" "∇" "/" "⌿" "\\" "⍀" "¨" "⍨" "∘" "." "⍣" "⍤" "⍥" "@" "¯"))
+
+(define apl-glyph?
+  (fn (ch)
+    (some (fn (g) (= g ch)) apl-glyph-set)))
+
+(define apl-digit?
+  (fn (ch)
+    (and (string? ch) (>= ch "0") (<= ch "9"))))
+
+(define apl-alpha?
+  (fn (ch)
+    (and (string? ch)
+         (or (and (>= ch "a") (<= ch "z"))
+             (and (>= ch "A") (<= ch "Z"))
+             (= ch "_")))))
+
+(define
+  apl-tokenize
+  (fn
+    (source)
+    (let
+      ((pos 0) (src-len (len source)) (tokens (list)))
+      (define tok-push! (fn (type value) (append! tokens {:value value :type type})))
+      (define
+        cur-sw?
+        (fn
+          (ch)
+          (and (< pos src-len) (starts-with? (slice source pos) ch))))
+      (define cur-byte (fn () (if (< pos src-len) (nth source pos) nil)))
+      (define advance! (fn () (set! pos (+ pos 1))))
+      (define consume! (fn (ch) (set! pos (+ pos (len ch)))))
+      (define
+        find-glyph
+        (fn
+          ()
+          (let
+            ((rem (slice source pos)))
+            (let
+              ((matches (filter (fn (g) (starts-with? rem g)) apl-glyph-set)))
+              (if (> (len matches) 0) (first matches) nil)))))
+      (define
+        read-digits!
+        (fn
+          (acc)
+          (if
+            (and (< pos src-len) (apl-digit? (cur-byte)))
+            (let
+              ((ch (cur-byte)))
+              (begin (advance!) (read-digits! (str acc ch))))
+            acc)))
+      (define
+        read-ident-cont!
+        (fn
+          ()
+          (when
+            (and
+              (< pos src-len)
+              (let
+                ((ch (cur-byte)))
+                (or (apl-alpha? ch) (apl-digit? ch))))
+            (begin (advance!) (read-ident-cont!)))))
+      (define
+        read-string!
+        (fn
+          (acc)
+          (cond
+            ((>= pos src-len) acc)
+            ((cur-sw? "'")
+              (if
+                (and (< (+ pos 1) src-len) (cur-sw? "'"))
+                (begin (advance!) (advance!) (read-string! (str acc "'")))
+                (begin (advance!) acc)))
+            (true
+              (let
+                ((ch (cur-byte)))
+                (begin (advance!) (read-string! (str acc ch))))))))
+      (define
+        skip-line!
+        (fn
+          ()
+          (when
+            (and (< pos src-len) (not (cur-sw? "\n")))
+            (begin (advance!) (skip-line!)))))
+      (define
+        scan!
+        (fn
+          ()
+          (when
+            (< pos src-len)
+            (let
+              ((ch (cur-byte)))
+              (cond
+                ((or (= ch " ") (= ch "\t") (= ch "\r"))
+                  (begin (advance!) (scan!)))
+                ((= ch "\n")
+                  (begin (advance!) (tok-push! :newline nil) (scan!)))
+                ((cur-sw? "⍝") (begin (skip-line!) (scan!)))
+                ((cur-sw? "⋄")
+                  (begin (consume! "⋄") (tok-push! :diamond nil) (scan!)))
+                ((= ch "(")
+                  (begin (advance!) (tok-push! :lparen nil) (scan!)))
+                ((= ch ")")
+                  (begin (advance!) (tok-push! :rparen nil) (scan!)))
+                ((= ch "[")
+                  (begin (advance!) (tok-push! :lbracket nil) (scan!)))
+                ((= ch "]")
+                  (begin (advance!) (tok-push! :rbracket nil) (scan!)))
+                ((= ch "{")
+                  (begin (advance!) (tok-push! :lbrace nil) (scan!)))
+                ((= ch "}")
+                  (begin (advance!) (tok-push! :rbrace nil) (scan!)))
+                ((= ch ";")
+                  (begin (advance!) (tok-push! :semi nil) (scan!)))
+                ((cur-sw? "←")
+                  (begin (consume! "←") (tok-push! :assign nil) (scan!)))
+                ((= ch ":")
+                  (let
+                    ((start pos))
+                    (begin
+                      (advance!)
+                      (if
+                        (and (< pos src-len) (apl-alpha? (cur-byte)))
+                        (begin
+                          (read-ident-cont!)
+                          (tok-push! :keyword (slice source start pos)))
+                        (tok-push! :colon nil))
+                      (scan!))))
+                ((and (cur-sw? "¯") (< (+ pos (len "¯")) src-len) (apl-digit? (nth source (+ pos (len "¯")))))
+                  (begin
+                    (consume! "¯")
+                    (let
+                      ((digits (read-digits! "")))
+                      (if
+                        (and
+                          (< pos src-len)
+                          (= (cur-byte) ".")
+                          (< (+ pos 1) src-len)
+                          (apl-digit? (nth source (+ pos 1))))
+                        (begin
+                          (advance!)
+                          (let
+                            ((frac (read-digits! "")))
+                            (tok-push!
+                              :num (- 0 (string->number (str digits "." frac))))))
+                        (tok-push! :num (- 0 (parse-int digits 0)))))
+                    (scan!)))
+                ((apl-digit? ch)
+                  (begin
+                    (let
+                      ((digits (read-digits! "")))
+                      (if
+                        (and
+                          (< pos src-len)
+                          (= (cur-byte) ".")
+                          (< (+ pos 1) src-len)
+                          (apl-digit? (nth source (+ pos 1))))
+                        (begin
+                          (advance!)
+                          (let
+                            ((frac (read-digits! "")))
+                            (tok-push!
+                              :num (string->number (str digits "." frac)))))
+                        (tok-push! :num (parse-int digits 0))))
+                    (scan!)))
+                ((= ch "'")
+                  (begin
+                    (advance!)
+                    (let ((s (read-string! ""))) (tok-push! :str s))
+                    (scan!)))
+                ((or (apl-alpha? ch) (cur-sw? "⎕"))
+                  (let
+                    ((start pos))
+                    (begin
+                      (if
+                        (cur-sw? "⎕")
+                        (begin
+                          (consume! "⎕")
+                          (if
+                            (and (< pos src-len) (cur-sw? "←"))
+                            (consume! "←")
+                            (read-ident-cont!)))
+                        (begin (advance!) (read-ident-cont!)))
+                      (tok-push! :name (slice source start pos))
+                      (scan!))))
+                (true
+                  (let
+                    ((g (find-glyph)))
+                    (if
+                      g
+                      (begin (consume! g) (tok-push! :glyph g) (scan!))
+                      (begin (advance!) (scan!))))))))))
+      (scan!)
+      tokens)))

lib/apl/transpile.sx

@@ -0,0 +1,592 @@
+; APL transpile / AST evaluator
+;
+; Walks parsed AST nodes and evaluates against the runtime.
+; Entry points:
+;   apl-eval-ast    : node × env → value
+;   apl-eval-stmts  : stmt-list × env → value (handles guards, locals, ⍺← default)
+;   apl-call-dfn    : dfn-ast × ⍺ × ⍵ → value   (dyadic)
+;   apl-call-dfn-m  : dfn-ast × ⍵ → value       (monadic)
+;
+; Env is a dict; ⍺ stored under "alpha", ⍵ under "omega",
+; the dfn-ast itself under "nabla" (for ∇ recursion),
+; user names under their literal name.
+
+(define
+  apl-monadic-fn
+  (fn
+    (g)
+    (cond
+      ((= g "+") apl-plus-m)
+      ((= g "-") apl-neg-m)
+      ((= g "×") apl-signum)
+      ((= g "÷") apl-recip)
+      ((= g "⌈") apl-ceil)
+      ((= g "⌊") apl-floor)
+      ((= g "⍳") apl-iota)
+      ((= g "|") apl-abs)
+      ((= g "*") apl-exp)
+      ((= g "⍟") apl-ln)
+      ((= g "!") apl-fact)
+      ((= g "○") apl-pi-times)
+      ((= g "~") apl-not)
+      ((= g "≢") apl-tally)
+      ((= g "⍴") apl-shape)
+      ((= g "≡") apl-depth)
+      ((= g "⊂") apl-enclose)
+      ((= g "⊃") apl-disclose)
+      ((= g ",") apl-ravel)
+      ((= g "⌽") apl-reverse)
+      ((= g "⊖") apl-reverse-first)
+      ((= g "⍋") apl-grade-up)
+      ((= g "⍒") apl-grade-down)
+      ((= g "?") apl-roll)
+      ((= g "⍉") apl-transpose)
+      ((= g "⊢") (fn (a) a))
+      ((= g "⊣") (fn (a) a))
+      ((= g "⍕") apl-quad-fmt)
+      ((= g "⎕FMT") apl-quad-fmt)
+      ((= g "⎕←") apl-quad-print)
+      ((= g "⍸") apl-where)
+      ((= g "∪") apl-unique)
+      ((= g "⍎") apl-execute)
+      (else (error "no monadic fn for glyph")))))
+
+(define
+  apl-dyadic-fn
+  (fn
+    (g)
+    (cond
+      ((= g "+") apl-add)
+      ((= g "-") apl-sub)
+      ((= g "×") apl-mul)
+      ((= g "÷") apl-div)
+      ((= g "⌈") apl-max)
+      ((= g "⌊") apl-min)
+      ((= g "*") apl-pow)
+      ((= g "⍟") apl-log)
+      ((= g "|") apl-mod)
+      ((= g "!") apl-binomial)
+      ((= g "○") apl-trig)
+      ((= g "<") apl-lt)
+      ((= g "≤") apl-le)
+      ((= g "=") apl-eq)
+      ((= g "≥") apl-ge)
+      ((= g ">") apl-gt)
+      ((= g "≠") apl-ne)
+      ((= g "∧") apl-and)
+      ((= g "∨") apl-or)
+      ((= g "⍱") apl-nor)
+      ((= g "⍲") apl-nand)
+      ((= g ",") apl-catenate)
+      ((= g "⍪") apl-catenate-first)
+      ((= g "⍴") apl-reshape)
+      ((= g "↑") apl-take)
+      ((= g "↓") apl-drop)
+      ((= g "⌷") apl-squad)
+      ((= g "⌽") apl-rotate)
+      ((= g "⊖") apl-rotate-first)
+      ((= g "∊") apl-member)
+      ((= g "⍳") apl-index-of)
+      ((= g "~") apl-without)
+      ((= g "/") apl-compress)
+      ((= g "⌿") apl-compress-first)
+      ((= g "⍉") apl-transpose-dyadic)
+      ((= g "⊢") (fn (a b) b))
+      ((= g "⊣") (fn (a b) a))
+      ((= g "⍸") apl-interval-index)
+      ((= g "∪") apl-union)
+      ((= g "∩") apl-intersect)
+      ((= g "⊥") apl-decode)
+      ((= g "⊤") apl-encode)
+      ((= g "⊆") apl-partition)
+      (else (error "no dyadic fn for glyph")))))
+
+(define
+  apl-truthy?
+  (fn
+    (v)
+    (let
+      ((rv (get v :ravel)))
+      (if (and (= (len rv) 1) (= (first rv) 0)) false true))))
+
+(define
+  apl-eval-ast
+  (fn
+    (node env)
+    (let
+      ((tag (first node)))
+      (cond
+        ((= tag :num) (apl-scalar (nth node 1)))
+        ((= tag :str)
+          (let
+            ((s (nth node 1)))
+            (if
+              (= (len s) 1)
+              (apl-scalar s)
+              (make-array
+                (list (len s))
+                (map (fn (i) (slice s i (+ i 1))) (range 0 (len s)))))))
+        ((= tag :vec)
+          (let
+            ((items (rest node)))
+            (let
+              ((vals (map (fn (n) (apl-eval-ast n env)) items)))
+              (make-array
+                (list (len vals))
+                (map
+                  (fn
+                    (v)
+                    (if
+                      (= (len (get v :shape)) 0)
+                      (first (get v :ravel))
+                      v))
+                  vals)))))
+        ((= tag :name)
+          (let
+            ((nm (nth node 1)))
+            (cond
+              ((= nm "⍺")
+                (let
+                  ((v (get env "⍺")))
+                  (if (= v nil) (get env "alpha") v)))
+              ((= nm "⍵")
+                (let
+                  ((v (get env "⍵")))
+                  (if (= v nil) (get env "omega") v)))
+              ((= nm "⎕IO") (apl-quad-io))
+              ((= nm "⎕ML") (apl-quad-ml))
+              ((= nm "⎕FR") (apl-quad-fr))
+              ((= nm "⎕TS") (apl-quad-ts))
+              (else (get env nm)))))
+        ((= tag :monad)
+          (let
+            ((fn-node (nth node 1)) (arg (nth node 2)))
+            (if
+              (and (= (first fn-node) :fn-glyph) (= (nth fn-node 1) "∇"))
+              (apl-call-dfn-m (get env "nabla") (apl-eval-ast arg env))
+              (let
+                ((arg-val (apl-eval-ast arg env)))
+                (let
+                  ((new-env (if (and (list? arg) (> (len arg) 0) (= (first arg) :assign-expr)) (assoc env (nth arg 1) arg-val) env)))
+                  ((apl-resolve-monadic fn-node new-env) arg-val))))))
+        ((= tag :dyad)
+          (let
+            ((fn-node (nth node 1))
+              (lhs (nth node 2))
+              (rhs (nth node 3)))
+            (if
+              (and (= (first fn-node) :fn-glyph) (= (nth fn-node 1) "∇"))
+              (apl-call-dfn
+                (get env "nabla")
+                (apl-eval-ast lhs env)
+                (apl-eval-ast rhs env))
+              (let
+                ((rhs-val (apl-eval-ast rhs env)))
+                (let
+                  ((new-env (if (and (list? rhs) (> (len rhs) 0) (= (first rhs) :assign-expr)) (assoc env (nth rhs 1) rhs-val) env)))
+                  ((apl-resolve-dyadic fn-node new-env)
+                    (apl-eval-ast lhs new-env)
+                    rhs-val))))))
+        ((= tag :program) (apl-eval-stmts (rest node) env))
+        ((= tag :dfn) node)
+        ((= tag :bracket)
+          (let
+            ((arr-expr (nth node 1)) (axis-exprs (rest (rest node))))
+            (let
+              ((arr (apl-eval-ast arr-expr env))
+                (axes
+                  (map
+                    (fn (a) (if (= a :all) nil (apl-eval-ast a env)))
+                    axis-exprs)))
+              (apl-bracket-multi axes arr))))
+        ((= tag :assign-expr) (apl-eval-ast (nth node 2) env))
+        ((= tag :assign) (apl-eval-ast (nth node 2) env))
+        (else (error (list "apl-eval-ast: unknown node tag" tag node)))))))
+
+(define
+  apl-eval-stmts
+  (fn
+    (stmts env)
+    (if
+      (= (len stmts) 0)
+      nil
+      (let
+        ((stmt (first stmts)) (more (rest stmts)))
+        (let
+          ((tag (first stmt)))
+          (cond
+            ((= tag :guard)
+              (let
+                ((cond-val (apl-eval-ast (nth stmt 1) env)))
+                (if
+                  (apl-truthy? cond-val)
+                  (apl-eval-ast (nth stmt 2) env)
+                  (apl-eval-stmts more env))))
+            ((and (= tag :assign) (= (nth stmt 1) "⍺"))
+              (if
+                (get env "alpha")
+                (apl-eval-stmts more env)
+                (let
+                  ((v (apl-eval-ast (nth stmt 2) env)))
+                  (apl-eval-stmts more (assoc env "alpha" v)))))
+            ((= tag :assign)
+              (let
+                ((v (apl-eval-ast (nth stmt 2) env)))
+                (apl-eval-stmts more (assoc env (nth stmt 1) v))))
+            ((= (len more) 0) (apl-eval-ast stmt env))
+            (else (begin (apl-eval-ast stmt env) (apl-eval-stmts more env)))))))))
+
+(define
+  apl-call-dfn
+  (fn
+    (dfn-ast alpha omega)
+    (let
+      ((stmts (rest dfn-ast)) (env {:omega omega :nabla dfn-ast :alpha alpha}))
+      (apl-eval-stmts stmts env))))
+
+(define
+  apl-call-dfn-m
+  (fn
+    (dfn-ast omega)
+    (let
+      ((stmts (rest dfn-ast)) (env {:omega omega :nabla dfn-ast :alpha nil}))
+      (apl-eval-stmts stmts env))))
+
+(define
+  apl-tradfn-eval-block
+  (fn
+    (stmts env)
+    (if
+      (= (len stmts) 0)
+      env
+      (let
+        ((stmt (first stmts)))
+        (apl-tradfn-eval-block (rest stmts) (apl-tradfn-eval-stmt stmt env))))))
+
+(define
+  apl-tradfn-eval-while
+  (fn
+    (cond-expr body env)
+    (let
+      ((cond-val (apl-eval-ast cond-expr env)))
+      (if
+        (apl-truthy? cond-val)
+        (apl-tradfn-eval-while
+          cond-expr
+          body
+          (apl-tradfn-eval-block body env))
+        env))))
+
+(define
+  apl-tradfn-eval-for
+  (fn
+    (var-name items body env)
+    (if
+      (= (len items) 0)
+      env
+      (let
+        ((env-with-var (assoc env var-name (apl-scalar (first items)))))
+        (apl-tradfn-eval-for
+          var-name
+          (rest items)
+          body
+          (apl-tradfn-eval-block body env-with-var))))))
+
+(define
+  apl-tradfn-eval-select
+  (fn
+    (val cases default-block env)
+    (if
+      (= (len cases) 0)
+      (apl-tradfn-eval-block default-block env)
+      (let
+        ((c (first cases)))
+        (let
+          ((case-val (apl-eval-ast (first c) env)))
+          (if
+            (= (first (get val :ravel)) (first (get case-val :ravel)))
+            (apl-tradfn-eval-block (rest c) env)
+            (apl-tradfn-eval-select val (rest cases) default-block env)))))))
+
+(define
+  apl-tradfn-eval-stmt
+  (fn
+    (stmt env)
+    (let
+      ((tag (first stmt)))
+      (cond
+        ((= tag :assign)
+          (assoc env (nth stmt 1) (apl-eval-ast (nth stmt 2) env)))
+        ((= tag :if)
+          (let
+            ((cond-val (apl-eval-ast (nth stmt 1) env)))
+            (if
+              (apl-truthy? cond-val)
+              (apl-tradfn-eval-block (nth stmt 2) env)
+              (apl-tradfn-eval-block (nth stmt 3) env))))
+        ((= tag :while)
+          (apl-tradfn-eval-while (nth stmt 1) (nth stmt 2) env))
+        ((= tag :for)
+          (let
+            ((iter-val (apl-eval-ast (nth stmt 2) env)))
+            (apl-tradfn-eval-for
+              (nth stmt 1)
+              (get iter-val :ravel)
+              (nth stmt 3)
+              env)))
+        ((= tag :select)
+          (let
+            ((val (apl-eval-ast (nth stmt 1) env)))
+            (apl-tradfn-eval-select val (nth stmt 2) (nth stmt 3) env)))
+        ((= tag :trap)
+          (let
+            ((codes (nth stmt 1))
+              (try-block (nth stmt 2))
+              (catch-block (nth stmt 3)))
+            (guard
+              (e
+                ((apl-trap-matches? codes e)
+                  (apl-tradfn-eval-block catch-block env)))
+              (apl-tradfn-eval-block try-block env))))
+        ((= tag :throw) (apl-throw (nth stmt 1) (nth stmt 2)))
+        (else (begin (apl-eval-ast stmt env) env))))))
+
+(define
+  apl-tradfn-loop
+  (fn
+    (stmts line env result-name)
+    (cond
+      ((= line 0) (get env result-name))
+      ((> line (len stmts)) (get env result-name))
+      (else
+        (let
+          ((stmt (nth stmts (- line 1))))
+          (let
+            ((tag (first stmt)))
+            (cond
+              ((= tag :branch)
+                (let
+                  ((target (apl-eval-ast (nth stmt 1) env)))
+                  (let
+                    ((target-num (first (get target :ravel))))
+                    (apl-tradfn-loop stmts target-num env result-name))))
+              (else
+                (apl-tradfn-loop
+                  stmts
+                  (+ line 1)
+                  (apl-tradfn-eval-stmt stmt env)
+                  result-name)))))))))
+
+(define
+  apl-call-tradfn
+  (fn
+    (tradfn alpha omega)
+    (let
+      ((stmts (get tradfn :stmts))
+        (result-name (get tradfn :result))
+        (alpha-name (get tradfn :alpha))
+        (omega-name (get tradfn :omega)))
+      (let
+        ((env-a (if alpha-name (assoc {} alpha-name alpha) {})))
+        (let
+          ((env-ao (if omega-name (assoc env-a omega-name omega) env-a)))
+          (apl-tradfn-loop stmts 1 env-ao result-name))))))
+
+(define
+  apl-ast-mentions-list?
+  (fn
+    (lst target)
+    (if
+      (= (len lst) 0)
+      false
+      (if
+        (apl-ast-mentions? (first lst) target)
+        true
+        (apl-ast-mentions-list? (rest lst) target)))))
+
+(define
+  apl-ast-mentions?
+  (fn
+    (node target)
+    (cond
+      ((not (list? node)) false)
+      ((= (len node) 0) false)
+      ((and (= (first node) :name) (= (nth node 1) target)) true)
+      (else (apl-ast-mentions-list? (rest node) target)))))
+
+(define
+  apl-dfn-valence
+  (fn
+    (dfn-ast)
+    (let
+      ((body (rest dfn-ast)))
+      (cond
+        ((apl-ast-mentions-list? body "⍺") :dyadic)
+        ((apl-ast-mentions-list? body "⍵") :monadic)
+        (else :niladic)))))
+
+(define
+  apl-tradfn-valence
+  (fn
+    (tradfn)
+    (cond
+      ((get tradfn :alpha) :dyadic)
+      ((get tradfn :omega) :monadic)
+      (else :niladic))))
+
+(define
+  apl-call
+  (fn
+    (f alpha omega)
+    (cond
+      ((and (list? f) (> (len f) 0) (= (first f) :dfn))
+        (if alpha (apl-call-dfn f alpha omega) (apl-call-dfn-m f omega)))
+      ((dict? f) (apl-call-tradfn f alpha omega))
+      (else (error "apl-call: not a function")))))
+
+(define
+  apl-resolve-monadic
+  (fn
+    (fn-node env)
+    (let
+      ((tag (first fn-node)))
+      (cond
+        ((= tag :fn-glyph) (apl-monadic-fn (nth fn-node 1)))
+        ((= tag :derived-fn)
+          (let
+            ((op (nth fn-node 1)) (inner (nth fn-node 2)))
+            (cond
+              ((= op "/")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (arr) (apl-reduce f arr))))
+              ((= op "⌿")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (arr) (apl-reduce-first f arr))))
+              ((= op "\\")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (arr) (apl-scan f arr))))
+              ((= op "⍀")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (arr) (apl-scan-first f arr))))
+              ((= op "¨")
+                (let
+                  ((f (apl-resolve-monadic inner env)))
+                  (fn (arr) (apl-each f arr))))
+              ((= op "⍨")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (arr) (apl-commute f arr))))
+              (else (error "apl-resolve-monadic: unsupported op")))))
+        ((= tag :fn-name)
+          (let
+            ((nm (nth fn-node 1)))
+            (let
+              ((bound (get env nm)))
+              (if
+                (and
+                  (list? bound)
+                  (> (len bound) 0)
+                  (= (first bound) :dfn))
+                (fn (arg) (apl-call-dfn-m bound arg))
+                (error "apl-resolve-monadic: name not bound to dfn")))))
+        ((= tag :train)
+          (let
+            ((fns (rest fn-node)))
+            (let
+              ((n (len fns)))
+              (cond
+                ((= n 2)
+                  (let
+                    ((g (apl-resolve-monadic (nth fns 0) env))
+                      (h (apl-resolve-monadic (nth fns 1) env)))
+                    (fn (arg) (g (h arg)))))
+                ((= n 3)
+                  (let
+                    ((f (apl-resolve-monadic (nth fns 0) env))
+                      (g (apl-resolve-dyadic (nth fns 1) env))
+                      (h (apl-resolve-monadic (nth fns 2) env)))
+                    (fn (arg) (g (f arg) (h arg)))))
+                (else (error "monadic train arity not 2 or 3"))))))
+        (else (error "apl-resolve-monadic: unknown fn-node tag"))))))
+
+(define
+  apl-resolve-dyadic
+  (fn
+    (fn-node env)
+    (let
+      ((tag (first fn-node)))
+      (cond
+        ((= tag :fn-glyph) (apl-dyadic-fn (nth fn-node 1)))
+        ((= tag :derived-fn)
+          (let
+            ((op (nth fn-node 1)) (inner (nth fn-node 2)))
+            (cond
+              ((= op "¨")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (a b) (apl-each-dyadic f a b))))
+              ((= op "⍨")
+                (let
+                  ((f (apl-resolve-dyadic inner env)))
+                  (fn (a b) (apl-commute-dyadic f a b))))
+              (else (error "apl-resolve-dyadic: unsupported op")))))
+        ((= tag :fn-name)
+          (let
+            ((nm (nth fn-node 1)))
+            (let
+              ((bound (get env nm)))
+              (if
+                (and
+                  (list? bound)
+                  (> (len bound) 0)
+                  (= (first bound) :dfn))
+                (fn (a b) (apl-call-dfn bound a b))
+                (error "apl-resolve-dyadic: name not bound to dfn")))))
+        ((= tag :outer)
+          (let
+            ((inner (nth fn-node 2)))
+            (let
+              ((f (apl-resolve-dyadic inner env)))
+              (fn (a b) (apl-outer f a b)))))
+        ((= tag :derived-fn2)
+          (let
+            ((f-node (nth fn-node 2)) (g-node (nth fn-node 3)))
+            (let
+              ((f (apl-resolve-dyadic f-node env))
+                (g (apl-resolve-dyadic g-node env)))
+              (fn (a b) (apl-inner f g a b)))))
+        ((= tag :train)
+          (let
+            ((fns (rest fn-node)))
+            (let
+              ((n (len fns)))
+              (cond
+                ((= n 2)
+                  (let
+                    ((g (apl-resolve-monadic (nth fns 0) env))
+                      (h (apl-resolve-dyadic (nth fns 1) env)))
+                    (fn (a b) (g (h a b)))))
+                ((= n 3)
+                  (let
+                    ((f (apl-resolve-dyadic (nth fns 0) env))
+                      (g (apl-resolve-dyadic (nth fns 1) env))
+                      (h (apl-resolve-dyadic (nth fns 2) env)))
+                    (fn (a b) (g (f a b) (h a b)))))
+                (else (error "dyadic train arity not 2 or 3"))))))
+        (else (error "apl-resolve-dyadic: unknown fn-node tag"))))))
+
+(define apl-run (fn (src) (apl-eval-ast (parse-apl src) {})))
+
+(define apl-run-file (fn (path) (apl-run (file-read path))))
+
+(define
+  apl-execute
+  (fn
+    (arr)
+    (let
+      ((src (cond ((string? arr) arr) ((scalar? arr) (disclose arr)) (else (reduce str "" (get arr :ravel))))))
+      (apl-run src))))

lib/common-lisp/conformance.sh

@@ -107,6 +107,10 @@ run_suite "Phase 5: macros+LOOP" \
   "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/loop.sx lib/common-lisp/tests/macros.sx" \
   "macro-passed" "macro-failed" "macro-failures"
 
+run_suite "Phase 6: stdlib" \
+  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/tests/stdlib.sx" \
+  "stdlib-passed" "stdlib-failed" "stdlib-failures"
+
 echo ""
 echo "=== Total: $TOTAL_PASS passed, $TOTAL_FAIL failed ==="
 

lib/common-lisp/eval.sx

@@ -20,6 +20,24 @@
 
 (define cl-global-env (cl-make-env))
 
+;; ── package state ─────────────────────────────────────────────────
+(define cl-packages {})
+(define cl-current-package "COMMON-LISP-USER")
+(define cl-reader-macros {})
+(define cl-dispatch-macros {})
+(define cl-package-sep?
+  (fn (s)
+    (let ((colon (some (fn (i) (if (= (substr s i 1) ":") i false))
+                       (range 0 (len s)))))
+      (if colon
+        (let ((pkg   (substr s 0 colon))
+              (rest2 (if (and (< (+ colon 1) (len s))
+                              (= (substr s (+ colon 1) 1) ":"))
+                       (substr s (+ colon 2) (- (len s) (+ colon 2)))
+                       (substr s (+ colon 1) (- (len s) (+ colon 1))))))
+          {:pkg pkg :name rest2})
+        nil))))
+
 ;; ── macro registry ────────────────────────────────────────────────
 ;; cl-macro-registry: symbol-name -> (fn (form env) expanded-form)
 (define cl-macro-registry (dict))
@@ -190,6 +208,174 @@
                     (let ((e5 (cl-bind-aux aux-specs e4)))
                       (cl-eval-body body e5)))))))))))))
 
+
+;; ── FORMAT helpers ──────────────────────────────────────────────
+
+(define cl-fmt-a
+  (fn (arg)
+    (cond
+      ((= arg nil) "()")
+      ((= arg true) "T")
+      ((= arg false) "NIL")
+      ((string? arg) arg)
+      ((number? arg) (str arg))
+      ((list? arg)
+        (if (= (len arg) 0) "()"
+          (str "("
+               (reduce (fn (a x) (str a " " (cl-fmt-a x)))
+                       (cl-fmt-a (nth arg 0))
+                       (rest arg))
+               ")")))
+      ((and (dict? arg) (= (get arg "cl-type") "keyword"))
+        (str ":" (get arg "name")))
+      ((and (dict? arg) (= (get arg "cl-type") "char"))
+        (get arg "value"))
+      (:else (str arg)))))
+
+(define cl-fmt-s
+  (fn (arg)
+    (cond
+      ((= arg nil) "NIL")
+      ((= arg true) "T")
+      ((= arg false) "NIL")
+      ((string? arg) (str "\"" arg "\""))
+      ((number? arg) (str arg))
+      ((list? arg)
+        (if (= (len arg) 0) "NIL"
+          (str "("
+               (reduce (fn (a x) (str a " " (cl-fmt-s x)))
+                       (cl-fmt-s (nth arg 0))
+                       (rest arg))
+               ")")))
+      ((and (dict? arg) (= (get arg "cl-type") "keyword"))
+        (str ":" (get arg "name")))
+      ((and (dict? arg) (= (get arg "cl-type") "char"))
+        (str "#\\" (get arg "value")))
+      (:else (str arg)))))
+
+;; Find position of ~CH (tilde+ch) in ctrl, starting from i, tracking nesting
+(define cl-fmt-find-close
+  (fn (ctrl ch i depth)
+    (if (>= i (- (len ctrl) 1)) -1
+      (let ((c (substr ctrl i 1)))
+        (if (= c "~")
+          (let ((nxt (upcase (substr ctrl (+ i 1) 1))))
+            (cond
+              ((= nxt ch)
+                (if (= depth 0) i (cl-fmt-find-close ctrl ch (+ i 2) (- depth 1))))
+              ((or (= nxt "{") (= nxt "["))
+                (cl-fmt-find-close ctrl ch (+ i 2) (+ depth 1)))
+              (:else
+                (cl-fmt-find-close ctrl ch (+ i 2) depth))))
+          (cl-fmt-find-close ctrl ch (+ i 1) depth))))))
+
+;; Process inner ~{...~} string over each element of a list
+(define cl-fmt-iterate
+  (fn (inner items)
+    (if (= items nil) ""
+      (if (= (len items) 0) ""
+        (reduce
+          (fn (acc x)
+            (str acc (get (cl-fmt-loop inner (list x) 0 "") "out")))
+          "" items)))))
+
+;; Main format loop: returns {:out string :args remaining}
+(define cl-fmt-loop
+  (fn (ctrl args i out)
+    (if (>= i (len ctrl))
+      {:out out :args args}
+      (let ((ch (substr ctrl i 1)))
+        (if (not (= ch "~"))
+          (cl-fmt-loop ctrl args (+ i 1) (str out ch))
+          (let ((dir (if (< (+ i 1) (len ctrl))
+                       (upcase (substr ctrl (+ i 1) 1))
+                       "")))
+            (cond
+              ((= dir "A")
+                (cl-fmt-loop ctrl (rest args) (+ i 2)
+                  (str out (if (> (len args) 0) (cl-fmt-a (nth args 0)) ""))))
+              ((= dir "S")
+                (cl-fmt-loop ctrl (rest args) (+ i 2)
+                  (str out (if (> (len args) 0) (cl-fmt-s (nth args 0)) ""))))
+              ((or (= dir "D") (= dir "F") (= dir "B") (= dir "X") (= dir "O"))
+                (cl-fmt-loop ctrl (rest args) (+ i 2)
+                  (str out (if (> (len args) 0) (str (nth args 0)) ""))))
+              ((= dir "%")
+                (cl-fmt-loop ctrl args (+ i 2) (str out "\n")))
+              ((= dir "&")
+                (cl-fmt-loop ctrl args (+ i 2)
+                  (if (or (= (len out) 0)
+                          (= (substr out (- (len out) 1) 1) "\n"))
+                    out (str out "\n"))))
+              ((= dir "T")
+                (cl-fmt-loop ctrl args (+ i 2) (str out "\t")))
+              ((= dir "P")
+                (let ((arg (if (> (len args) 0) (nth args 0) 1)))
+                  (cl-fmt-loop ctrl (rest args) (+ i 2)
+                    (str out (if (= arg 1) "" "s")))))
+              ((= dir "{")
+                (let ((end-i (cl-fmt-find-close ctrl "}" (+ i 2) 0)))
+                  (if (= end-i -1)
+                    {:out (str out "~{") :args args}
+                    (let ((inner (if (> end-i (+ i 2))
+                                   (substr ctrl (+ i 2) (- end-i (+ i 2)))
+                                   "")))
+                      (let ((list-arg (if (> (len args) 0) (nth args 0) (list))))
+                        (cl-fmt-loop ctrl (rest args) (+ end-i 2)
+                          (str out (cl-fmt-iterate inner (if (= list-arg nil) (list) list-arg)))))))))
+              ((= dir "[")
+                (let ((end-i (cl-fmt-find-close ctrl "]" (+ i 2) 0)))
+                  (if (= end-i -1)
+                    {:out (str out "~[") :args args}
+                    (let ((inner (if (> end-i (+ i 2))
+                                   (substr ctrl (+ i 2) (- end-i (+ i 2)))
+                                   "")))
+                      (let ((arg (if (> (len args) 0) (nth args 0) 0)))
+                        (let ((chosen (if (= arg true) "T"
+                                        (if (= arg nil) "NIL"
+                                          (get (cl-fmt-loop inner (list arg) 0 "") "out")))))
+                          (cl-fmt-loop ctrl (rest args) (+ end-i 2)
+                            (str out chosen))))))))
+              ((= dir "~")
+                (cl-fmt-loop ctrl args (+ i 2) (str out "~")))
+              ((= dir "^")
+                {:out out :args args})
+              (:else
+                (cl-fmt-loop ctrl args (+ i 2) (str out "~" dir))))))))))
+
+;; ── sequence/list helpers (needed by builtins) ───────────────────
+
+(define cl-member-helper
+  (fn (item lst)
+    (if (= lst nil) nil
+      (if (= (len lst) 0) nil
+        (if (= (nth lst 0) item)
+          lst
+          (cl-member-helper item (rest lst)))))))
+
+(define cl-subst-helper
+  (fn (new old tree)
+    (if (= tree old) new
+      (if (and (list? tree) (> (len tree) 0))
+        (map (fn (x) (cl-subst-helper new old x)) tree)
+        tree))))
+
+(define cl-position-helper
+  (fn (item lst idx)
+    (if (= lst nil) nil
+      (if (= (len lst) 0) nil
+        (if (= (nth lst 0) item)
+          idx
+          (cl-position-helper item (rest lst) (+ idx 1)))))))
+
+(define cl-position-if-helper
+  (fn (fn-obj lst idx)
+    (if (= lst nil) nil
+      (if (= (len lst) 0) nil
+        (if (cl-apply fn-obj (list (nth lst 0)))
+          idx
+          (cl-position-if-helper fn-obj (rest lst) (+ idx 1)))))))
+
 ;; ── built-in functions ────────────────────────────────────────────
 
 (define cl-builtins
@@ -298,7 +484,235 @@
     "CONCATENATE"     (fn (args) (reduce (fn (a b) (str a b)) "" (rest args)))
     "EQ"    (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
     "EQL"   (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
-    "EQUAL" (fn (args) (if (= (nth args 0) (nth args 1)) true nil))))
+    "EQUAL" (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
+    ;; sequence functions
+    "MAPC"    (fn (args)
+                 (let ((fn-obj (nth args 0))
+                       (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                   (begin
+                     (for-each (fn (x) (cl-apply fn-obj (list x))) lst)
+                     (nth args 1))))
+    "MAPCAN"  (fn (args)
+                 (let ((fn-obj (nth args 0))
+                       (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                   (reduce (fn (acc x)
+                              (let ((r (cl-apply fn-obj (list x))))
+                                (if (= r nil) acc
+                                  (concat acc r))))
+                           (list) lst)))
+    "REDUCE"  (fn (args)
+                 (let ((fn-obj (nth args 0))
+                       (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                   (let ((iv-r (cl-find-kw-arg "INITIAL-VALUE" args 2)))
+                     (let ((has-iv (get iv-r "found"))
+                           (iv     (get iv-r "value")))
+                       (if (= (len lst) 0)
+                         (if has-iv iv (cl-apply fn-obj (list)))
+                         (if has-iv
+                           (reduce (fn (acc x) (cl-apply fn-obj (list acc x))) iv lst)
+                           (reduce (fn (acc x) (cl-apply fn-obj (list acc x)))
+                                   (nth lst 0) (rest lst))))))))
+    "FIND"    (fn (args)
+                 (let ((item (nth args 0))
+                       (lst  (if (= (nth args 1) nil) (list) (nth args 1))))
+                   (let ((r (some (fn (x) (if (= x item) x false)) lst)))
+                     (if r r nil))))
+    "FIND-IF" (fn (args)
+                 (let ((fn-obj (nth args 0))
+                       (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                   (let ((r (some (fn (x)
+                                    (let ((res (cl-apply fn-obj (list x))))
+                                      (if res x false)))
+                                  lst)))
+                     (if r r nil))))
+    "FIND-IF-NOT" (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (let ((r (some (fn (x)
+                                        (let ((res (cl-apply fn-obj (list x))))
+                                          (if res false x)))
+                                      lst)))
+                         (if r r nil))))
+    "POSITION"    (fn (args)
+                     (cl-position-helper (nth args 0)
+                       (if (= (nth args 1) nil) (list) (nth args 1)) 0))
+    "POSITION-IF" (fn (args)
+                     (cl-position-if-helper (nth args 0)
+                       (if (= (nth args 1) nil) (list) (nth args 1)) 0))
+    "COUNT"       (fn (args)
+                     (let ((item (nth args 0))
+                           (lst  (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (len (filter (fn (x) (= x item)) lst))))
+    "COUNT-IF"    (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (len (filter (fn (x) (cl-apply fn-obj (list x))) lst))))
+    "EVERY"       (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (if (every? (fn (x) (cl-apply fn-obj (list x))) lst) true nil)))
+    "SOME"        (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (let ((r (some (fn (x) (cl-apply fn-obj (list x))) lst)))
+                         (if r r nil))))
+    "NOTANY"      (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (if (some (fn (x) (cl-apply fn-obj (list x))) lst) nil true)))
+    "NOTEVERY"    (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (if (every? (fn (x) (cl-apply fn-obj (list x))) lst) nil true)))
+    "REMOVE"      (fn (args)
+                     (let ((item (nth args 0))
+                           (lst  (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (filter (fn (x) (not (= x item))) lst)))
+    "REMOVE-IF"   (fn (args)
+                     (let ((fn-obj (nth args 0))
+                           (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                       (filter (fn (x) (not (cl-apply fn-obj (list x)))) lst)))
+    "REMOVE-IF-NOT" (fn (args)
+                       (let ((fn-obj (nth args 0))
+                             (lst    (if (= (nth args 1) nil) (list) (nth args 1))))
+                         (filter (fn (x) (cl-apply fn-obj (list x))) lst)))
+    "SUBST"       (fn (args)
+                     (cl-subst-helper (nth args 0) (nth args 1)
+                       (if (= (nth args 2) nil) (list) (nth args 2))))
+    "MEMBER"      (fn (args)
+                     (cl-member-helper (nth args 0)
+                       (if (= (nth args 1) nil) nil (nth args 1))))
+    ;; list ops
+    "ASSOC"    (fn (args)
+                  (let ((key (nth args 0))
+                        (lst (if (= (nth args 1) nil) (list) (nth args 1))))
+                    (let ((r (some
+                               (fn (pair)
+                                 (let ((k (if (and (dict? pair) (= (get pair "cl-type") "cons"))
+                                            (get pair "car")
+                                            (if (and (list? pair) (> (len pair) 0))
+                                              (nth pair 0)
+                                              nil))))
+                                   (if (= k key) pair false)))
+                               lst)))
+                      (if r r nil))))
+    "RASSOC"   (fn (args)
+                  (let ((val (nth args 0))
+                        (lst (if (= (nth args 1) nil) (list) (nth args 1))))
+                    (let ((r (some
+                               (fn (pair)
+                                 (let ((v (if (and (dict? pair) (= (get pair "cl-type") "cons"))
+                                            (get pair "cdr")
+                                            (if (and (list? pair) (> (len pair) 1))
+                                              (nth pair 1)
+                                              nil))))
+                                   (if (= v val) pair false)))
+                               lst)))
+                      (if r r nil))))
+    "GETF"     (fn (args)
+                  (let ((plist (if (= (nth args 0) nil) (list) (nth args 0)))
+                        (ind   (nth args 1))
+                        (def   (if (> (len args) 2) (nth args 2) nil)))
+                    (let ((ind-name (if (and (dict? ind) (= (get ind "cl-type") "keyword"))
+                                      (get ind "name")
+                                      (upcase (str ind)))))
+                      (let ((r (cl-find-kw-arg ind-name plist 0)))
+                        (if (get r "found") (get r "value") def)))))
+    "LAST"     (fn (args)
+                  (let ((lst (nth args 0)))
+                    (if (or (= lst nil) (= (len lst) 0)) nil
+                      (list (nth lst (- (len lst) 1))))))
+    "BUTLAST"  (fn (args)
+                  (let ((lst (nth args 0)))
+                    (if (or (= lst nil) (= (len lst) 0)) (list)
+                      (slice lst 0 (- (len lst) 1)))))
+    "NTHCDR"   (fn (args)
+                  (let ((n   (nth args 0))
+                        (lst (nth args 1)))
+                    (if (= lst nil) nil
+                      (if (>= n (len lst)) nil
+                        (slice lst n (len lst))))))
+    "COPY-LIST" (fn (args) (nth args 0))
+    "LIST*"    (fn (args)
+                  (if (= (len args) 0) nil
+                    (if (= (len args) 1) (nth args 0)
+                      (let ((head (slice args 0 (- (len args) 1)))
+                            (tail (nth args (- (len args) 1))))
+                        (concat head (if (list? tail) tail (list tail)))))))
+    "CAAR"     (fn (args)
+                  (let ((x (nth args 0)))
+                    (let ((c (if (and (list? x) (> (len x) 0)) (nth x 0) nil)))
+                      (if (and (list? c) (> (len c) 0)) (nth c 0) nil))))
+    "CADR"     (fn (args)
+                  (let ((x (nth args 0)))
+                    (if (and (list? x) (> (len x) 1)) (nth x 1) nil)))
+    "CDAR"     (fn (args)
+                  (let ((x (nth args 0)))
+                    (let ((c (if (and (list? x) (> (len x) 0)) (nth x 0) nil)))
+                      (if (and (list? c) (> (len c) 0)) (rest c) nil))))
+    "CDDR"     (fn (args)
+                  (let ((x (nth args 0)))
+                    (if (and (list? x) (> (len x) 2))
+                      (slice x 2 (len x))
+                      nil)))
+    "CADDR"    (fn (args)
+                  (let ((x (nth args 0)))
+                    (if (and (list? x) (> (len x) 2)) (nth x 2) nil)))
+    "CADDDR"   (fn (args)
+                  (let ((x (nth args 0)))
+                    (if (and (list? x) (> (len x) 3)) (nth x 3) nil)))
+    "PAIRLIS"  (fn (args)
+                  (let ((ks (if (= (nth args 0) nil) (list) (nth args 0)))
+                        (vs (if (= (nth args 1) nil) (list) (nth args 1))))
+                    (map (fn (i) (list (nth ks i) (nth vs i)))
+                         (range 0 (len ks)))))
+    ;; string ops
+    "SUBSEQ"   (fn (args)
+                  (let ((seq   (nth args 0))
+                        (start (nth args 1))
+                        (end   (if (> (len args) 2) (nth args 2) nil)))
+                    (if (string? seq)
+                      (if end (substr seq start (- end start)) (substr seq start (- (len seq) start)))
+                      (if (= seq nil) (list)
+                        (if end (slice seq start end) (slice seq start (len seq)))))))
+    "STRING"   (fn (args)
+                  (let ((x (nth args 0)))
+                    (if (string? x) x (str x))))
+    "CHAR"     (fn (args)
+                  (let ((s (nth args 0)) (i (nth args 1)))
+                    {:cl-type "char" :value (substr s i (+ i 1))}))
+    "CHAR="    (fn (args)
+                  (let ((a (nth args 0)) (b (nth args 1)))
+                    (let ((av (if (dict? a) (get a "value") a))
+                          (bv (if (dict? b) (get b "value") b)))
+                      (if (= av bv) true nil))))
+    "STRING-LENGTH"   (fn (args) (len (nth args 0)))
+    "STRING<"  (fn (args) (if (< (nth args 0) (nth args 1)) true nil))
+    "STRING>"  (fn (args) (if (> (nth args 0) (nth args 1)) true nil))
+    "STRING<=" (fn (args) (if (<= (nth args 0) (nth args 1)) true nil))
+    "STRING>=" (fn (args) (if (>= (nth args 0) (nth args 1)) true nil))
+    "WRITE-TO-STRING" (fn (args) (inspect (nth args 0)))
+    "SYMBOL-NAME"     (fn (args) (upcase (str (nth args 0))))
+    "COERCE"          (fn (args)
+                         (let ((x (nth args 0))
+                               (tp (upcase (str (nth args 1)))))
+                           (cond
+                             ((= tp "LIST") (if (string? x)
+                               (map (fn (i) {:cl-type "char" :value (substr x i (+ i 1))})
+                                    (range 0 (len x))) x))
+                             ((= tp "STRING") (if (list? x)
+                               (reduce (fn (a c) (str a (if (dict? c) (get c "value") c))) "" x)
+                               (str x)))
+                             (:else x))))
+    "FORMAT"   (fn (args)
+                  (let ((dest   (nth args 0))
+                        (ctrl   (if (> (len args) 1) (nth args 1) ""))
+                        (fargs  (if (> (len args) 2) (slice args 2 (len args)) (list))))
+                    (let ((result (get (cl-fmt-loop ctrl fargs 0 "") "out")))
+                      (if (= dest nil) result nil))))
+    "MAKE-LIST" (fn (args)
+                   (let ((n (nth args 0)))
+                     (map (fn (_) nil) (range 0 n))))))
 
 ;; Register builtins in cl-global-env so (function #'name) resolves them
 (for-each
@@ -633,7 +1047,9 @@
 
 ;; Function call: evaluate name → look up fns, builtins; evaluate args
 (define cl-call-fn
-  (fn (name args env)
+  (fn (name-raw args env)
+    (let ((name (let ((ps (cl-package-sep? name-raw)))
+                  (if ps (get ps "name") name-raw))))
     (let ((evaled (map (fn (a) (cl-mv-primary (cl-eval a env))) args)))
       (cond
         ;; FUNCALL: (funcall fn arg...)
@@ -652,17 +1068,26 @@
                 (lst    (nth evaled 1)))
             (if (= lst nil) (list)
               (map (fn (x) (cl-apply fn-obj (list x))) lst))))
-        ;; Look up in local fns namespace
+        ;; Look up in local fns namespace (try bare name via package stripping)
         ((cl-env-has-fn? env name)
           (cl-apply (cl-env-get-fn env name) evaled))
+        ((let ((ps (cl-package-sep? name)))
+           (and ps (cl-env-has-fn? env (get ps "name"))))
+          (cl-apply (cl-env-get-fn env (get (cl-package-sep? name) "name")) evaled))
         ;; Look up in global fns namespace
         ((cl-env-has-fn? cl-global-env name)
           (cl-apply (cl-env-get-fn cl-global-env name) evaled))
-        ;; Look up in builtins
+        ((let ((ps (cl-package-sep? name)))
+           (and ps (cl-env-has-fn? cl-global-env (get ps "name"))))
+          (cl-apply (cl-env-get-fn cl-global-env (get (cl-package-sep? name) "name")) evaled))
+        ;; Look up in builtins (bare or package-qualified)
         ((has-key? cl-builtins name)
           ((get cl-builtins name) evaled))
+        ((let ((ps (cl-package-sep? name)))
+           (and ps (has-key? cl-builtins (get ps "name"))))
+          ((get cl-builtins (get (cl-package-sep? name) "name")) evaled))
         (:else
-          {:cl-type "error" :message (str "Undefined function: " name)})))))
+          {:cl-type "error" :message (str "Undefined function: " name-raw)}))))))
 
 ;; ── main evaluator ────────────────────────────────────────────────
 
@@ -683,14 +1108,16 @@
       ;; Symbol reference (variable or symbol-macro lookup)
       ((string? form)
         (let ((uform (upcase form)))
-          (if (and (has-key? cl-symbol-macros uform)
-                   (not (= (get cl-symbol-macros uform) nil)))
-            (cl-eval (get cl-symbol-macros uform) env)
-            (cond
-              ((cl-env-has-var? env form) (cl-env-get-var env form))
-              ((cl-env-has-var? cl-global-env form)
-                (cl-env-get-var cl-global-env form))
-              (:else {:cl-type "error" :message (str "Undefined variable: " form)})))))
+          (let ((bare (let ((ps (cl-package-sep? uform)))
+                        (if ps (get ps "name") uform))))
+            (if (and (has-key? cl-symbol-macros bare)
+                     (not (= (get cl-symbol-macros bare) nil)))
+              (cl-eval (get cl-symbol-macros bare) env)
+              (cond
+                ((cl-env-has-var? env bare) (cl-env-get-var env bare))
+                ((cl-env-has-var? cl-global-env bare)
+                  (cl-env-get-var cl-global-env bare))
+                (:else {:cl-type "error" :message (str "Undefined variable: " form)}))))))
       ;; List: special forms or function call
       ((list? form) (cl-eval-list form env))
       ;; Anything else self-evaluates
@@ -861,6 +1288,64 @@
           ((= head "DEFCONSTANT")  (cl-eval-defvar args env true))
           ((= head "DECLAIM")      nil)
           ((= head "PROCLAIM")     nil)
+          ((= head "SET-MACRO-CHARACTER")
+            (let ((ch  (cl-eval (nth args 0) env))
+                  (fn-obj (cl-eval (nth args 1) env)))
+              (let ((key (if (and (dict? ch) (= (get ch "cl-type") "char"))
+                            (get ch "value")
+                            (str ch))))
+                (dict-set! cl-reader-macros key fn-obj)
+                nil)))
+          ((= head "GET-MACRO-CHARACTER")
+            (let ((ch (cl-eval (nth args 0) env)))
+              (let ((key (if (and (dict? ch) (= (get ch "cl-type") "char"))
+                            (get ch "value")
+                            (str ch))))
+                (if (has-key? cl-reader-macros key)
+                  (list (get cl-reader-macros key) nil)
+                  (list nil nil)))))
+          ((= head "SET-DISPATCH-MACRO-CHARACTER")
+            (let ((disp (cl-eval (nth args 0) env))
+                  (ch   (cl-eval (nth args 1) env))
+                  (fn-obj (if (> (len args) 2) (cl-eval (nth args 2) env) nil)))
+              (let ((key (str (if (and (dict? disp) (= (get disp "cl-type") "char")) (get disp "value") (str disp))
+                             (if (and (dict? ch) (= (get ch "cl-type") "char")) (get ch "value") (str ch)))))
+                (dict-set! cl-dispatch-macros key fn-obj)
+                nil)))
+          ((= head "DEFPACKAGE")
+            (let ((raw (nth args 0)))
+              (let ((name (upcase (cond
+                             ((and (dict? raw) (= (get raw "cl-type") "keyword")) (get raw "name"))
+                             ((string? raw) raw)
+                             (:else (str raw))))))
+                (let ((exports (some
+                                 (fn (opt)
+                                   (if (and (list? opt) (> (len opt) 0)
+                                            (dict? (nth opt 0))
+                                            (= (upcase (str (get (nth opt 0) "name"))) "EXPORT"))
+                                     (rest opt) false))
+                                 (rest args))))
+                  (dict-set! cl-packages name
+                    {:name name :exports (if exports exports (list))})
+                  name))))
+          ((= head "IN-PACKAGE")
+            (let ((raw (nth args 0)))
+              (let ((name (upcase (cond
+                             ((and (dict? raw) (= (get raw "cl-type") "keyword")) (get raw "name"))
+                             ((string? raw) raw)
+                             (:else (str raw))))))
+                (set! cl-current-package name)
+                name)))
+          ((= head "EXPORT") nil)
+          ((= head "USE-PACKAGE") nil)
+          ((= head "IMPORT") nil)
+          ((= head "FIND-PACKAGE")
+            (let ((n (upcase (str (cl-eval (nth args 0) env)))))
+              (if (has-key? cl-packages n) (get cl-packages n) nil)))
+          ((= head "PACKAGE-NAME")
+            (if (= (len args) 0) cl-current-package
+              (let ((pkg (cl-eval (nth args 0) env)))
+                (if (string? pkg) pkg (if (dict? pkg) (get pkg "name") nil)))))
           ((= head "DEFMACRO")     (cl-eval-defmacro args env))
           ((= head "MACROLET")     (cl-eval-macrolet args env))
           ((= head "SYMBOL-MACROLET") (cl-eval-symbol-macrolet args env))

lib/common-lisp/scoreboard.json

@@ -1,6 +1,6 @@
 {
-  "generated": "2026-05-05T12:00:17Z",
-  "total_pass": 464,
+  "generated": "2026-05-05T12:35:09Z",
+  "total_pass": 518,
   "total_fail": 0,
   "suites": [
     {"name": "Phase 1: tokenizer/reader", "pass": 79, "fail": 0},
@@ -13,6 +13,7 @@
     {"name": "Phase 4: CLOS", "pass": 41, "fail": 0},
     {"name": "Phase 4: geometry", "pass": 12, "fail": 0},
     {"name": "Phase 4: mop-trace", "pass": 13, "fail": 0},
-    {"name": "Phase 5: macros+LOOP", "pass": 27, "fail": 0}
+    {"name": "Phase 5: macros+LOOP", "pass": 27, "fail": 0},
+    {"name": "Phase 6: stdlib", "pass": 54, "fail": 0}
   ]
 }

lib/common-lisp/scoreboard.md

@@ -1,6 +1,6 @@
 # Common Lisp on SX — Scoreboard
 
-_Generated: 2026-05-05 12:00 UTC_
+_Generated: 2026-05-05 12:35 UTC_
 
 | Suite | Pass | Fail | Status |
 |-------|------|------|--------|
@@ -15,5 +15,6 @@ _Generated: 2026-05-05 12:00 UTC_
 | Phase 4: geometry | 12 | 0 | pass |
 | Phase 4: mop-trace | 13 | 0 | pass |
 | Phase 5: macros+LOOP | 27 | 0 | pass |
+| Phase 6: stdlib | 54 | 0 | pass |
 
-**Total: 464 passed, 0 failed**
+**Total: 518 passed, 0 failed**

lib/common-lisp/tests/runtime.sx

@@ -0,0 +1,207 @@
+;; lib/common-lisp/tests/runtime.sx — tests for CL runtime layer
+
+(load "lib/common-lisp/runtime.sx")
+
+(defsuite
+  "cl-types"
+  (deftest "cl-null? nil" (assert= true (cl-null? nil)))
+  (deftest "cl-null? false" (assert= false (cl-null? false)))
+  (deftest
+    "cl-consp? pair"
+    (assert= true (cl-consp? (list 1 2))))
+  (deftest "cl-consp? nil" (assert= false (cl-consp? nil)))
+  (deftest "cl-listp? nil" (assert= true (cl-listp? nil)))
+  (deftest
+    "cl-listp? list"
+    (assert= true (cl-listp? (list 1 2))))
+  (deftest "cl-atom? nil" (assert= true (cl-atom? nil)))
+  (deftest "cl-atom? pair" (assert= false (cl-atom? (list 1))))
+  (deftest "cl-integerp?" (assert= true (cl-integerp? 42)))
+  (deftest "cl-floatp?" (assert= true (cl-floatp? 3.14)))
+  (deftest
+    "cl-characterp?"
+    (assert= true (cl-characterp? (integer->char 65))))
+  (deftest "cl-stringp?" (assert= true (cl-stringp? "hello")))
+  (deftest "cl-symbolp?" (assert= true (cl-symbolp? (quote foo)))))
+
+(defsuite
+  "cl-arithmetic"
+  (deftest "cl-mod" (assert= 1 (cl-mod 10 3)))
+  (deftest "cl-rem" (assert= 1 (cl-rem 10 3)))
+  (deftest
+    "cl-quotient"
+    (assert= 3 (cl-quotient 10 3)))
+  (deftest "cl-gcd" (assert= 4 (cl-gcd 12 8)))
+  (deftest "cl-lcm" (assert= 12 (cl-lcm 4 6)))
+  (deftest "cl-abs pos" (assert= 5 (cl-abs 5)))
+  (deftest "cl-abs neg" (assert= 5 (cl-abs -5)))
+  (deftest "cl-min" (assert= 2 (cl-min 2 7)))
+  (deftest "cl-max" (assert= 7 (cl-max 2 7)))
+  (deftest "cl-evenp? t" (assert= true (cl-evenp? 4)))
+  (deftest "cl-evenp? f" (assert= false (cl-evenp? 3)))
+  (deftest "cl-oddp? t" (assert= true (cl-oddp? 7)))
+  (deftest "cl-zerop?" (assert= true (cl-zerop? 0)))
+  (deftest "cl-plusp?" (assert= true (cl-plusp? 1)))
+  (deftest "cl-minusp?" (assert= true (cl-minusp? -1)))
+  (deftest "cl-signum pos" (assert= 1 (cl-signum 42)))
+  (deftest "cl-signum neg" (assert= -1 (cl-signum -7)))
+  (deftest "cl-signum zero" (assert= 0 (cl-signum 0))))
+
+(defsuite
+  "cl-chars"
+  (deftest
+    "cl-char-code"
+    (assert= 65 (cl-char-code (integer->char 65))))
+  (deftest "cl-code-char" (assert= true (char? (cl-code-char 65))))
+  (deftest
+    "cl-char-upcase"
+    (assert=
+      (integer->char 65)
+      (cl-char-upcase (integer->char 97))))
+  (deftest
+    "cl-char-downcase"
+    (assert=
+      (integer->char 97)
+      (cl-char-downcase (integer->char 65))))
+  (deftest
+    "cl-alpha-char-p"
+    (assert= true (cl-alpha-char-p (integer->char 65))))
+  (deftest
+    "cl-digit-char-p"
+    (assert= true (cl-digit-char-p (integer->char 48))))
+  (deftest
+    "cl-char=?"
+    (assert=
+      true
+      (cl-char=? (integer->char 65) (integer->char 65))))
+  (deftest
+    "cl-char<?"
+    (assert=
+      true
+      (cl-char<? (integer->char 65) (integer->char 90))))
+  (deftest
+    "cl-char space"
+    (assert= (integer->char 32) cl-char-space))
+  (deftest
+    "cl-char newline"
+    (assert= (integer->char 10) cl-char-newline)))
+
+(defsuite
+  "cl-format"
+  (deftest
+    "cl-format nil basic"
+    (assert= "hello" (cl-format nil "~a" "hello")))
+  (deftest
+    "cl-format nil number"
+    (assert= "42" (cl-format nil "~d" 42)))
+  (deftest
+    "cl-format nil hex"
+    (assert= "ff" (cl-format nil "~x" 255)))
+  (deftest
+    "cl-format nil template"
+    (assert= "x=3 y=4" (cl-format nil "x=~d y=~d" 3 4)))
+  (deftest "cl-format nil tilde" (assert= "a~b" (cl-format nil "a~~b"))))
+
+(defsuite
+  "cl-gensym"
+  (deftest
+    "cl-gensym returns symbol"
+    (assert= "symbol" (type-of (cl-gensym))))
+  (deftest "cl-gensym unique" (assert= false (= (cl-gensym) (cl-gensym)))))
+
+(defsuite
+  "cl-sets"
+  (deftest "cl-make-set empty" (assert= true (cl-set? (cl-make-set))))
+  (deftest
+    "cl-set-add/member"
+    (let
+      ((s (cl-make-set)))
+      (do
+        (cl-set-add s 1)
+        (assert= true (cl-set-memberp s 1)))))
+  (deftest
+    "cl-set-memberp false"
+    (assert= false (cl-set-memberp (cl-make-set) 42)))
+  (deftest
+    "cl-list->set"
+    (let
+      ((s (cl-list->set (list 1 2 3))))
+      (assert= true (cl-set-memberp s 2)))))
+
+(defsuite
+  "cl-lists"
+  (deftest
+    "cl-nth 0"
+    (assert=
+      1
+      (cl-nth 0 (list 1 2 3))))
+  (deftest
+    "cl-nth 2"
+    (assert=
+      3
+      (cl-nth 2 (list 1 2 3))))
+  (deftest
+    "cl-last"
+    (assert=
+      (list 3)
+      (cl-last (list 1 2 3))))
+  (deftest
+    "cl-butlast"
+    (assert=
+      (list 1 2)
+      (cl-butlast (list 1 2 3))))
+  (deftest
+    "cl-nthcdr 1"
+    (assert=
+      (list 2 3)
+      (cl-nthcdr 1 (list 1 2 3))))
+  (deftest
+    "cl-assoc hit"
+    (assert=
+      (list "b" 2)
+      (cl-assoc "b" (list (list "a" 1) (list "b" 2)))))
+  (deftest
+    "cl-assoc miss"
+    (assert= nil (cl-assoc "z" (list (list "a" 1)))))
+  (deftest
+    "cl-getf hit"
+    (assert= 42 (cl-getf (list "x" 42 "y" 99) "x")))
+  (deftest "cl-getf miss" (assert= nil (cl-getf (list "x" 42) "z")))
+  (deftest
+    "cl-adjoin new"
+    (assert=
+      (list 0 1 2)
+      (cl-adjoin 0 (list 1 2))))
+  (deftest
+    "cl-adjoin dup"
+    (assert=
+      (list 1 2)
+      (cl-adjoin 1 (list 1 2))))
+  (deftest
+    "cl-flatten"
+    (assert=
+      (list 1 2 3 4)
+      (cl-flatten (list 1 (list 2 3) 4))))
+  (deftest
+    "cl-member hit"
+    (assert=
+      (list 2 3)
+      (cl-member 2 (list 1 2 3))))
+  (deftest
+    "cl-member miss"
+    (assert=
+      nil
+      (cl-member 9 (list 1 2 3)))))
+
+(defsuite
+  "cl-radix"
+  (deftest "binary" (assert= "1010" (cl-format-binary 10)))
+  (deftest "octal" (assert= "17" (cl-format-octal 15)))
+  (deftest "hex" (assert= "ff" (cl-format-hex 255)))
+  (deftest "decimal" (assert= "42" (cl-format-decimal 42)))
+  (deftest
+    "n->s r16"
+    (assert= "1f" (cl-integer-to-string 31 16)))
+  (deftest
+    "s->n r16"
+    (assert= 31 (cl-string-to-integer "1f" 16))))

lib/common-lisp/tests/stdlib.sx

@@ -0,0 +1,285 @@
+;; lib/common-lisp/tests/stdlib.sx — Phase 6: sequence, list, string functions
+
+(define ev (fn (src) (cl-eval-str src (cl-make-env))))
+
+(define passed 0)
+(define failed 0)
+(define failures (list))
+
+(define
+  check
+  (fn
+    (label got expected)
+    (if
+      (= got expected)
+      (set! passed (+ passed 1))
+      (begin
+        (set! failed (+ failed 1))
+        (set!
+          failures
+          (append
+            failures
+            (list
+              (str
+                "FAIL ["
+                label
+                "]: got="
+                (inspect got)
+                " expected="
+                (inspect expected)))))))))
+
+;; ── mapc ─────────────────────────────────────────────────────────
+
+(check "mapc returns list"
+  (ev "(mapc #'1+ '(1 2 3))")
+  (list 1 2 3))
+
+;; ── mapcan ───────────────────────────────────────────────────────
+
+(check "mapcan basic"
+  (ev "(mapcan (lambda (x) (list x (* x x))) '(1 2 3))")
+  (list 1 1 2 4 3 9))
+
+(check "mapcan filter-like"
+  (ev "(mapcan (lambda (x) (if (evenp x) (list x) nil)) '(1 2 3 4 5 6))")
+  (list 2 4 6))
+
+;; ── reduce ───────────────────────────────────────────────────────
+
+(check "reduce sum"
+  (ev "(reduce #'+ '(1 2 3 4 5))")
+  15)
+
+(check "reduce with initial-value"
+  (ev "(reduce #'+ '(1 2 3) :initial-value 10)")
+  16)
+
+(check "reduce max"
+  (ev "(reduce (lambda (a b) (if (> a b) a b)) '(3 1 4 1 5 9 2 6))")
+  9)
+
+;; ── find ─────────────────────────────────────────────────────────
+
+(check "find present"
+  (ev "(find 3 '(1 2 3 4 5))")
+  3)
+
+(check "find absent"
+  (ev "(find 9 '(1 2 3))")
+  nil)
+
+(check "find-if present"
+  (ev "(find-if #'evenp '(1 3 4 7))")
+  4)
+
+(check "find-if absent"
+  (ev "(find-if #'evenp '(1 3 5))")
+  nil)
+
+(check "find-if-not"
+  (ev "(find-if-not #'evenp '(2 4 5 6))")
+  5)
+
+;; ── position ─────────────────────────────────────────────────────
+
+(check "position found"
+  (ev "(position 3 '(1 2 3 4 5))")
+  2)
+
+(check "position not found"
+  (ev "(position 9 '(1 2 3))")
+  nil)
+
+(check "position-if"
+  (ev "(position-if #'evenp '(1 3 4 8))")
+  2)
+
+;; ── count ────────────────────────────────────────────────────────
+
+(check "count"
+  (ev "(count 2 '(1 2 3 2 4 2))")
+  3)
+
+(check "count-if"
+  (ev "(count-if #'evenp '(1 2 3 4 5 6))")
+  3)
+
+;; ── every / some / notany / notevery ─────────────────────────────
+
+(check "every true"
+  (ev "(every #'evenp '(2 4 6))")
+  true)
+
+(check "every false"
+  (ev "(every #'evenp '(2 3 6))")
+  nil)
+
+(check "every empty"
+  (ev "(every #'evenp '())")
+  true)
+
+(check "some truthy"
+  (ev "(some #'evenp '(1 3 4))")
+  true)
+
+(check "some nil"
+  (ev "(some #'evenp '(1 3 5))")
+  nil)
+
+(check "notany true"
+  (ev "(notany #'evenp '(1 3 5))")
+  true)
+
+(check "notany false"
+  (ev "(notany #'evenp '(1 2 5))")
+  nil)
+
+(check "notevery false"
+  (ev "(notevery #'evenp '(2 4 6))")
+  nil)
+
+(check "notevery true"
+  (ev "(notevery #'evenp '(2 3 6))")
+  true)
+
+;; ── remove ───────────────────────────────────────────────────────
+
+(check "remove"
+  (ev "(remove 3 '(1 2 3 4 3 5))")
+  (list 1 2 4 5))
+
+(check "remove-if"
+  (ev "(remove-if #'evenp '(1 2 3 4 5 6))")
+  (list 1 3 5))
+
+(check "remove-if-not"
+  (ev "(remove-if-not #'evenp '(1 2 3 4 5 6))")
+  (list 2 4 6))
+
+;; ── member ───────────────────────────────────────────────────────
+
+(check "member found"
+  (ev "(member 3 '(1 2 3 4 5))")
+  (list 3 4 5))
+
+(check "member not found"
+  (ev "(member 9 '(1 2 3))")
+  nil)
+
+;; ── subst ────────────────────────────────────────────────────────
+
+(check "subst flat"
+  (ev "(subst 'b 'a '(a b c a))")
+  (list "B" "B" "C" "B"))
+
+(check "subst nested"
+  (ev "(subst 99 1 '(1 (2 1) 3))")
+  (list 99 (list 2 99) 3))
+
+;; ── assoc ────────────────────────────────────────────────────────
+
+(check "assoc found"
+  (ev "(assoc 'b '((a 1) (b 2) (c 3)))")
+  (list "B" 2))
+
+(check "assoc not found"
+  (ev "(assoc 'z '((a 1) (b 2)))")
+  nil)
+
+;; ── list ops ─────────────────────────────────────────────────────
+
+(check "last"
+  (ev "(last '(1 2 3 4))")
+  (list 4))
+
+(check "butlast"
+  (ev "(butlast '(1 2 3 4))")
+  (list 1 2 3))
+
+(check "nthcdr"
+  (ev "(nthcdr 2 '(a b c d))")
+  (list "C" "D"))
+
+(check "list*"
+  (ev "(list* 1 2 '(3 4))")
+  (list 1 2 3 4))
+
+(check "cadr"
+  (ev "(cadr '(1 2 3))")
+  2)
+
+(check "caddr"
+  (ev "(caddr '(1 2 3))")
+  3)
+
+(check "cadddr"
+  (ev "(cadddr '(1 2 3 4))")
+  4)
+
+(check "cddr"
+  (ev "(cddr '(1 2 3 4))")
+  (list 3 4))
+
+;; ── subseq ───────────────────────────────────────────────────────
+
+(check "subseq string"
+  (ev "(subseq \"hello\" 1 3)")
+  "el")
+
+(check "subseq list"
+  (ev "(subseq '(a b c d) 1 3)")
+  (list "B" "C"))
+
+(check "subseq no end"
+  (ev "(subseq \"hello\" 2)")
+  "llo")
+
+;; ── FORMAT ─────────────────────────────────────────────────────────
+
+(check "format ~A"
+  (ev "(format nil \"hello ~A\" \"world\")")
+  "hello world")
+
+(check "format ~D"
+  (ev "(format nil \"~D items\" 42)")
+  "42 items")
+
+(check "format two args"
+  (ev "(format nil \"~A ~A\" 1 2)")
+  "1 2")
+
+(check "format ~A+~A=~A"
+  (ev "(format nil \"~A + ~A = ~A\" 1 2 3)")
+  "1 + 2 = 3")
+
+(check "format iterate"
+  (ev "(format nil \"~{~A~}\" (quote (1 2 3)))")
+  "123")
+
+(check "format iterate with space"
+  (ev "(format nil \"(~{~A ~})\" (quote (1 2 3)))")
+  "(1 2 3 )")
+
+;; ── packages ─────────────────────────────────────────────────────
+
+(check "defpackage returns name"
+  (ev "(defpackage :my-pkg (:use :cl))")
+  "MY-PKG")
+
+(check "in-package"
+  (ev "(progn (defpackage :test-pkg) (in-package :test-pkg) (package-name))")
+  "TEST-PKG")
+
+(check "package-qualified function"
+  (ev "(cl:car (quote (1 2 3)))")
+  1)
+
+(check "package-qualified function 2"
+  (ev "(cl:mapcar (function evenp) (quote (2 3 4)))")
+  (list true nil true))
+
+;; ── summary ──────────────────────────────────────────────────────
+
+(define stdlib-passed passed)
+(define stdlib-failed failed)
+(define stdlib-failures failures)

lib/hyperscript/compiler.sx

@@ -48,6 +48,15 @@
                             prop
                             value))
                         (list (quote hs-query-all) (nth base-ast 1))))
+                    ((and (list? base-ast) (= (first base-ast) (quote query)))
+                      (list
+                        (quote dom-set-prop)
+                        (list
+                          (quote hs-named-target)
+                          (nth base-ast 1)
+                          (list (quote hs-query-first) (nth base-ast 1)))
+                        prop
+                        value))
                     ((and (list? base-ast) (= (first base-ast) dot-sym) (let ((inner (nth base-ast 1))) (and (list? inner) (= (first inner) (quote query)) (let ((s (nth inner 1))) (and (string? s) (> (len s) 0) (= (substring s 0 1) "."))))))
                       (let
                         ((inner (nth base-ast 1))
@@ -146,6 +155,14 @@
                           (nth prop-ast 1)
                           value)
                         (list (quote set!) (hs-to-sx target) value))))))
+              ((= th (quote query))
+                (list
+                  (quote hs-set-inner-html!)
+                  (list
+                    (quote hs-named-target)
+                    (nth target 1)
+                    (list (quote hs-query-first) (nth target 1)))
+                  value))
               (true (list (quote set!) (hs-to-sx target) value)))))))
     (define
       emit-on
@@ -274,17 +291,33 @@
           ((name (nth ast 1)) (rest-parts (rest (rest ast))))
           (cond
             ((and (= (len ast) 4) (list? (nth ast 2)) (= (first (nth ast 2)) (quote dict)))
-              (list
-                (quote dom-dispatch)
-                (hs-to-sx (nth ast 3))
-                name
-                (hs-to-sx (nth ast 2))))
+              (let
+                ((tgt-ast (nth ast 3)))
+                (list
+                  (quote dom-dispatch)
+                  (if
+                    (and (list? tgt-ast) (= (first tgt-ast) (quote query)))
+                    (list
+                      (quote hs-named-target)
+                      (nth tgt-ast 1)
+                      (list (quote hs-query-first) (nth tgt-ast 1)))
+                    (hs-to-sx tgt-ast))
+                  name
+                  (hs-to-sx (nth ast 2)))))
             ((= (len ast) 3)
-              (list
-                (quote dom-dispatch)
-                (hs-to-sx (nth ast 2))
-                name
-                (list (quote dict) "sender" (quote me))))
+              (let
+                ((tgt-ast (nth ast 2)))
+                (list
+                  (quote dom-dispatch)
+                  (if
+                    (and (list? tgt-ast) (= (first tgt-ast) (quote query)))
+                    (list
+                      (quote hs-named-target)
+                      (nth tgt-ast 1)
+                      (list (quote hs-query-first) (nth tgt-ast 1)))
+                    (hs-to-sx tgt-ast))
+                  name
+                  (list (quote dict) "sender" (quote me)))))
             (true
               (list
                 (quote dom-dispatch)
@@ -706,6 +739,33 @@
               (quote fn)
               (cons (quote me) (map make-symbol params))
               (cons (quote do) (map hs-to-sx body)))))))
+    (define
+      hs-safe-obj
+      (fn
+        (obj-ast)
+        (if
+          (and (list? obj-ast) (= (first obj-ast) (quote ref)))
+          (list (quote host-global) (nth obj-ast 1))
+          (if
+            (and (list? obj-ast) (= (first obj-ast) dot-sym))
+            (let
+              ((inner (nth obj-ast 1)) (prop (nth obj-ast 2)))
+              (list (quote host-get) (hs-safe-obj inner) prop))
+            (hs-to-sx obj-ast)))))
+    (define
+      hs-chain-name
+      (fn
+        (obj-ast)
+        (if
+          (and (list? obj-ast) (= (first obj-ast) (quote ref)))
+          (nth obj-ast 1)
+          (if
+            (and (list? obj-ast) (= (first obj-ast) dot-sym))
+            (str (hs-chain-name (nth obj-ast 1)) "." (nth obj-ast 2))
+            (if
+              (and (list? obj-ast) (= (first obj-ast) (quote query)))
+              (nth obj-ast 1)
+              nil)))))
     (fn
       (ast)
       (cond
@@ -1226,12 +1286,21 @@
                   (if
                     (and (list? raw-tgt) (= (first raw-tgt) (quote query)))
                     (list
-                      (quote for-each)
+                      (quote let)
                       (list
-                        (quote fn)
-                        (list (quote _el))
-                        (list (quote dom-add-class) (quote _el) (nth ast 1)))
-                      (list (quote hs-query-all) (nth raw-tgt 1)))
+                        (list
+                          (quote _tgt)
+                          (list (quote hs-query-named-all) (nth raw-tgt 1))))
+                      (list
+                        (quote for-each)
+                        (list
+                          (quote fn)
+                          (list (quote _el))
+                          (list
+                            (quote dom-add-class)
+                            (quote _el)
+                            (nth ast 1)))
+                        (quote _tgt)))
                     (list
                       (quote dom-add-class)
                       (hs-to-sx raw-tgt)
@@ -1244,14 +1313,20 @@
                   (nth ast 2)))
               ((= head (quote set-styles))
                 (let
-                  ((pairs (nth ast 1)) (tgt (hs-to-sx (nth ast 2))))
-                  (cons
-                    (quote do)
-                    (map
-                      (fn
-                        (p)
-                        (list (quote dom-set-style) tgt (first p) (nth p 1)))
-                      pairs))))
+                  ((pairs (nth ast 1)) (tgt-ast (nth ast 2)))
+                  (let
+                    ((tgt (if (and (list? tgt-ast) (= (first tgt-ast) (quote query))) (list (quote hs-named-target) (nth tgt-ast 1) (list (quote hs-query-first) (nth tgt-ast 1))) (hs-to-sx tgt-ast))))
+                    (cons
+                      (quote do)
+                      (map
+                        (fn
+                          (p)
+                          (list
+                            (quote dom-set-style)
+                            tgt
+                            (first p)
+                            (nth p 1)))
+                        pairs)))))
               ((= head (quote multi-add-class))
                 (let
                   ((target (hs-to-sx (nth ast 1)))
@@ -1349,15 +1424,21 @@
                   (if
                     (and (list? raw-tgt) (= (first raw-tgt) (quote query)))
                     (list
-                      (quote for-each)
+                      (quote let)
                       (list
-                        (quote fn)
-                        (list (quote _el))
                         (list
-                          (quote dom-remove-class)
-                          (quote _el)
-                          (nth ast 1)))
-                      (list (quote hs-query-all) (nth raw-tgt 1)))
+                          (quote _tgt)
+                          (list (quote hs-query-named-all) (nth raw-tgt 1))))
+                      (list
+                        (quote for-each)
+                        (list
+                          (quote fn)
+                          (list (quote _el))
+                          (list
+                            (quote dom-remove-class)
+                            (quote _el)
+                            (nth ast 1)))
+                        (quote _tgt)))
                     (list
                       (quote dom-remove-class)
                       (if (nil? raw-tgt) (quote me) (hs-to-sx raw-tgt))
@@ -1401,15 +1482,32 @@
                   ((tgt (nth ast 3)))
                   (list
                     (quote hs-set-attr!)
-                    (hs-to-sx tgt)
+                    (if
+                      (and (list? tgt) (= (first tgt) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt 1)
+                        (list (quote hs-query-first) (nth tgt 1)))
+                      (hs-to-sx tgt))
                     (nth ast 1)
                     (hs-to-sx (nth ast 2)))))
               ((= head (quote remove-value))
                 (let
-                  ((val (hs-to-sx (nth ast 1))) (tgt (nth ast 2)))
+                  ((val (hs-to-sx (nth ast 1))) (raw-tgt (nth ast 2)))
                   (emit-set
-                    tgt
-                    (list (quote hs-remove-from!) val (hs-to-sx tgt)))))
+                    raw-tgt
+                    (list
+                      (quote hs-remove-from!)
+                      val
+                      (if
+                        (and
+                          (list? raw-tgt)
+                          (= (first raw-tgt) (quote query)))
+                        (list
+                          (quote hs-named-target)
+                          (nth raw-tgt 1)
+                          (list (quote hs-query-first) (nth raw-tgt 1)))
+                        (hs-to-sx raw-tgt))))))
               ((= head (quote empty-target))
                 (let
                   ((tgt (nth ast 1)))
@@ -1440,8 +1538,19 @@
                   (hs-to-sx (nth ast 2))))
               ((= head (quote remove-attr))
                 (let
-                  ((tgt (if (nil? (nth ast 2)) (quote me) (hs-to-sx (nth ast 2)))))
-                  (list (quote dom-remove-attr) tgt (nth ast 1))))
+                  ((raw-tgt (nth ast 2)))
+                  (list
+                    (quote dom-remove-attr)
+                    (if
+                      (and
+                        (list? raw-tgt)
+                        (= (first raw-tgt) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth raw-tgt 1)
+                        (list (quote hs-query-first) (nth raw-tgt 1)))
+                      (if (nil? raw-tgt) (quote me) (hs-to-sx raw-tgt)))
+                    (nth ast 1))))
               ((= head (quote remove-css))
                 (let
                   ((tgt (if (nil? (nth ast 2)) (quote me) (hs-to-sx (nth ast 2))))
@@ -1452,10 +1561,20 @@
                       (fn (p) (list (quote dom-set-style) tgt p ""))
                       props))))
               ((= head (quote toggle-class))
-                (list
-                  (quote hs-toggle-class!)
-                  (hs-to-sx (nth ast 2))
-                  (nth ast 1)))
+                (let
+                  ((tgt-ast (nth ast 2)))
+                  (list
+                    (quote hs-toggle-class!)
+                    (if
+                      (and
+                        (list? tgt-ast)
+                        (= (first tgt-ast) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt-ast 1)
+                        (list (quote hs-query-first) (nth tgt-ast 1)))
+                      (hs-to-sx tgt-ast))
+                    (nth ast 1))))
               ((= head (quote toggle-class-for))
                 (list
                   (quote do)
@@ -1510,11 +1629,21 @@
                       (hs-to-sx tgt-ast)
                       (hs-to-sx val-ast)))))
               ((= head (quote toggle-between))
-                (list
-                  (quote hs-toggle-between!)
-                  (hs-to-sx (nth ast 3))
-                  (nth ast 1)
-                  (nth ast 2)))
+                (let
+                  ((tgt-ast (nth ast 3)))
+                  (list
+                    (quote hs-toggle-between!)
+                    (if
+                      (and
+                        (list? tgt-ast)
+                        (= (first tgt-ast) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt-ast 1)
+                        (list (quote hs-query-first) (nth tgt-ast 1)))
+                      (hs-to-sx tgt-ast))
+                    (nth ast 1)
+                    (nth ast 2))))
               ((= head (quote toggle-style))
                 (let
                   ((raw-tgt (nth ast 2)))
@@ -1538,10 +1667,20 @@
                     (quote list)
                     (map hs-to-sx (slice ast 3 (len ast))))))
               ((= head (quote toggle-attr))
-                (list
-                  (quote hs-toggle-attr!)
-                  (hs-to-sx (nth ast 2))
-                  (nth ast 1)))
+                (let
+                  ((tgt-ast (nth ast 2)))
+                  (list
+                    (quote hs-toggle-attr!)
+                    (if
+                      (and
+                        (list? tgt-ast)
+                        (= (first tgt-ast) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt-ast 1)
+                        (list (quote hs-query-first) (nth tgt-ast 1)))
+                      (hs-to-sx tgt-ast))
+                    (nth ast 1))))
               ((= head (quote toggle-attr-between))
                 (list
                   (quote hs-toggle-attr-between!)
@@ -1575,7 +1714,22 @@
                       (emit-set
                         raw-tgt
                         (list (quote hs-put-at!) val pos (hs-to-sx raw-tgt))))
-                    (true (list (quote hs-put!) val pos (hs-to-sx raw-tgt))))))
+                    (true
+                      (let
+                        ((tgt-ast raw-tgt))
+                        (list
+                          (quote hs-put!)
+                          val
+                          pos
+                          (if
+                            (and
+                              (list? tgt-ast)
+                              (= (first tgt-ast) (quote query)))
+                            (list
+                              (quote hs-named-target)
+                              (nth tgt-ast 1)
+                              (list (quote hs-query-first) (nth tgt-ast 1)))
+                            (hs-to-sx tgt-ast))))))))
               ((= head (quote if))
                 (if
                   (> (len ast) 3)
@@ -1651,12 +1805,22 @@
                     (detail (if (= (len ast) 4) (nth ast 2) nil)))
                   (list
                     (quote dom-dispatch)
-                    (hs-to-sx tgt)
+                    (let
+                      ((tgt-ast tgt))
+                      (if
+                        (and
+                          (list? tgt-ast)
+                          (= (first tgt-ast) (quote query)))
+                        (list
+                          (quote hs-named-target)
+                          (nth tgt-ast 1)
+                          (list (quote hs-query-first) (nth tgt-ast 1)))
+                        (hs-to-sx tgt-ast)))
                     name
                     (if has-detail (hs-to-sx detail) nil))))
               ((= head (quote hide))
                 (let
-                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
+                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-named-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
                     (strategy (if (> (len ast) 2) (nth ast 2) "display"))
                     (when-cond (if (> (len ast) 3) (nth ast 3) nil)))
                   (if
@@ -1672,7 +1836,7 @@
                         (hs-to-sx when-cond))))))
               ((= head (quote show))
                 (let
-                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
+                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-named-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
                     (strategy (if (> (len ast) 2) (nth ast 2) "display"))
                     (when-cond (if (> (len ast) 3) (nth ast 3) nil)))
                   (if
@@ -1735,13 +1899,28 @@
               ((= head (quote call))
                 (let
                   ((raw-fn (nth ast 1))
-                    (fn-expr
-                      (if
-                        (string? raw-fn)
-                        (make-symbol raw-fn)
-                        (hs-to-sx raw-fn)))
                     (args (map hs-to-sx (rest (rest ast)))))
-                  (cons fn-expr args)))
+                  (if
+                    (and (list? raw-fn) (= (first raw-fn) (quote ref)))
+                    (let
+                      ((name (nth raw-fn 1)))
+                      (list
+                        (quote let)
+                        (list
+                          (list
+                            (quote __hs-fn)
+                            (list (quote host-global) name)))
+                        (cons
+                          (quote do)
+                          (list
+                            (list
+                              (quote if)
+                              (list (quote nil?) (quote __hs-fn))
+                              (list (quote raise) (str "'" name "' is null"))
+                              (cons (quote __hs-fn) args))))))
+                    (let
+                      ((fn-expr (if (string? raw-fn) (make-symbol raw-fn) (hs-to-sx raw-fn))))
+                      (cons fn-expr args)))))
               ((= head (quote return))
                 (let
                   ((val (nth ast 1)))
@@ -1754,7 +1933,22 @@
               ((= head (quote throw))
                 (list (quote raise) (hs-to-sx (nth ast 1))))
               ((= head (quote settle))
-                (list (quote hs-settle) (quote me)))
+                (let
+                  ((raw-tgt (nth ast 1)))
+                  (list
+                    (quote hs-settle)
+                    (if
+                      (nil? raw-tgt)
+                      (quote me)
+                      (if
+                        (and
+                          (list? raw-tgt)
+                          (= (first raw-tgt) (quote query)))
+                        (list
+                          (quote hs-named-target)
+                          (nth raw-tgt 1)
+                          (list (quote hs-query-first) (nth raw-tgt 1)))
+                        (hs-to-sx raw-tgt))))))
               ((= head (quote go))
                 (list (quote hs-navigate!) (hs-to-sx (nth ast 1))))
               ((= head (quote ask))
@@ -1874,7 +2068,11 @@
               ((= head (quote install))
                 (cons (quote hs-install) (map hs-to-sx (rest ast))))
               ((= head (quote measure))
-                (list (quote hs-measure) (hs-to-sx (nth ast 1))))
+                (let
+                  ((raw-tgt (nth ast 1)))
+                  (let
+                    ((compiled-tgt (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-named-target) (nth raw-tgt 1) (list (quote hs-query-first) (nth raw-tgt 1))) (hs-to-sx raw-tgt))))
+                    (list (quote hs-measure) compiled-tgt))))
               ((= head (quote increment!))
                 (if
                   (= (len ast) 3)

lib/hyperscript/parser.sx

@@ -2455,7 +2455,16 @@
               ((and (= typ "keyword") (= val "answer"))
                 (do (adv!) (parse-answer-cmd)))
               ((and (= typ "keyword") (= val "settle"))
-                (do (adv!) (list (quote settle))))
+                (do
+                  (adv!)
+                  (if
+                    (or
+                      (at-end?)
+                      (and
+                        (= (tp-type) "keyword")
+                        (or (= (tp-val) "then") (= (tp-val) "end"))))
+                    (list (quote settle))
+                    (list (quote settle) (parse-expr)))))
               ((and (= typ "keyword") (= val "go"))
                 (do (adv!) (parse-go-cmd)))
               ((and (= typ "keyword") (= val "return"))

lib/hyperscript/runtime.sx

@@ -12,37 +12,14 @@
 
 ;; Register an event listener. Returns unlisten function.
 ;; (hs-on target event-name handler) → unlisten-fn
-(begin
-  (define _hs-config-log-all false)
-  (define _hs-log-captured (list))
-  (define
-    hs-set-log-all!
-    (fn (flag) (set! _hs-config-log-all (if flag true false))))
-  (define hs-get-log-captured (fn () _hs-log-captured))
-  (define
-    hs-clear-log-captured!
-    (fn () (begin (set! _hs-log-captured (list)) nil)))
-  (define
-    hs-log-event!
-    (fn
-      (msg)
-      (when
-        _hs-config-log-all
-        (begin
-          (set! _hs-log-captured (append _hs-log-captured (list msg)))
-          (host-call (host-global "console") "log" msg)
-          nil)))))
-
-;; Register for every occurrence (no queuing — each fires independently).
-;; Stock hyperscript queues by default; "every" disables queuing.
 (define
   hs-each
   (fn
     (target action)
     (if (list? target) (for-each action target) (action target))))
 
-;; Run an initializer function immediately.
-;; (hs-init thunk) — called at element boot time
+;; Register for every occurrence (no queuing — each fires independently).
+;; Stock hyperscript queues by default; "every" disables queuing.
 (define
   hs-on
   (fn
@@ -55,17 +32,17 @@
         (dom-set-data target "hs-unlisteners" (append prev (list unlisten)))
         unlisten))))
 
+;; Run an initializer function immediately.
+;; (hs-init thunk) — called at element boot time
+(define
+  hs-on-every
+  (fn (target event-name handler) (dom-listen target event-name handler)))
+
 ;; ── Async / timing ──────────────────────────────────────────────
 
 ;; Wait for a duration in milliseconds.
 ;; In hyperscript, wait is async-transparent — execution pauses.
 ;; Here we use perform/IO suspension for true pause semantics.
-(define
-  hs-on-every
-  (fn (target event-name handler) (dom-listen target event-name handler)))
-
-;; Wait for a DOM event on a target.
-;; (hs-wait-for target event-name) — suspends until event fires
 (define
   hs-on-intersection-attach!
   (fn
@@ -81,15 +58,16 @@
           (host-call observer "observe" target)
           observer)))))
 
-;; Wait for CSS transitions/animations to settle on an element.
+;; Wait for a DOM event on a target.
+;; (hs-wait-for target event-name) — suspends until event fires
 (define hs-init (fn (thunk) (thunk)))
 
+;; Wait for CSS transitions/animations to settle on an element.
+(define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
+
 ;; ── Class manipulation ──────────────────────────────────────────
 
 ;; Toggle a single class on an element.
-(define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
-
-;; Toggle between two classes — exactly one is active at a time.
 (begin
   (define
     hs-wait-for
@@ -102,21 +80,19 @@
       (target event-name timeout-ms)
       (perform (list (quote io-wait-event) target event-name timeout-ms)))))
 
+;; Toggle between two classes — exactly one is active at a time.
+(define hs-settle (fn (target) (perform (list (quote io-settle) target))))
+
 ;; Take a class from siblings — add to target, remove from others.
 ;; (hs-take! target cls) — like radio button class behavior
-(define hs-settle (fn (target) (perform (list (quote io-settle) target))))
+(define
+  hs-toggle-class!
+  (fn (target cls) (host-call (host-get target "classList") "toggle" cls)))
 
 ;; ── DOM insertion ───────────────────────────────────────────────
 
 ;; Put content at a position relative to a target.
 ;; pos: "into" | "before" | "after"
-(define
-  hs-toggle-class!
-  (fn (target cls) (host-call (host-get target "classList") "toggle" cls)))
-
-;; ── Navigation / traversal ──────────────────────────────────────
-
-;; Navigate to a URL.
 (define
   hs-toggle-between!
   (fn
@@ -126,7 +102,9 @@
       (do (dom-remove-class target cls1) (dom-add-class target cls2))
       (do (dom-remove-class target cls2) (dom-add-class target cls1)))))
 
-;; Find next sibling matching a selector (or any sibling).
+;; ── Navigation / traversal ──────────────────────────────────────
+
+;; Navigate to a URL.
 (define
   hs-toggle-style!
   (fn
@@ -150,7 +128,7 @@
             (dom-set-style target prop "hidden")
             (dom-set-style target prop "")))))))
 
-;; Find previous sibling matching a selector.
+;; Find next sibling matching a selector (or any sibling).
 (define
   hs-toggle-style-between!
   (fn
@@ -162,7 +140,7 @@
         (dom-set-style target prop val2)
         (dom-set-style target prop val1)))))
 
-;; First element matching selector within a scope.
+;; Find previous sibling matching a selector.
 (define
   hs-toggle-style-cycle!
   (fn
@@ -183,7 +161,7 @@
             (true (find-next (rest remaining))))))
       (dom-set-style target prop (find-next vals)))))
 
-;; Last element matching selector.
+;; First element matching selector within a scope.
 (define
   hs-take!
   (fn
@@ -206,7 +184,8 @@
             (when with-cls (dom-remove-class target with-cls))))
         (let
           ((attr-val (if (> (len extra) 0) (first extra) nil))
-            (with-val (if (> (len extra) 1) (nth extra 1) nil)))
+            (with-val
+              (if (> (len extra) 1) (nth extra 1) nil)))
           (do
             (for-each
               (fn
@@ -223,7 +202,7 @@
               (dom-set-attr target name attr-val)
               (dom-set-attr target name ""))))))))
 
-;; First/last within a specific scope.
+;; Last element matching selector.
 (begin
   (define
     hs-element?
@@ -335,6 +314,7 @@
                 (dom-insert-adjacent-html target "beforeend" value)
                 (hs-boot-subtree! target)))))))))
 
+;; First/last within a specific scope.
 (define
   hs-add-to!
   (fn
@@ -347,9 +327,6 @@
           (append target (list value))))
       (true (do (host-call target "push" value) target)))))
 
-;; ── Iteration ───────────────────────────────────────────────────
-
-;; Repeat a thunk N times.
 (define
   hs-remove-from!
   (fn
@@ -357,9 +334,15 @@
     (if
       (list? target)
       (filter (fn (x) (not (= x value))) target)
-      (host-call target "splice" (host-call target "indexOf" value) 1))))
+      (host-call
+        target
+        "splice"
+        (host-call target "indexOf" value)
+        1))))
 
-;; Repeat forever (until break — relies on exception/continuation).
+;; ── Iteration ───────────────────────────────────────────────────
+
+;; Repeat a thunk N times.
 (define
   hs-splice-at!
   (fn
@@ -372,7 +355,10 @@
           ((i (if (< idx 0) (+ n idx) idx)))
           (cond
             ((or (< i 0) (>= i n)) target)
-            (true (concat (slice target 0 i) (slice target (+ i 1) n))))))
+            (true
+              (concat
+                (slice target 0 i)
+                (slice target (+ i 1) n))))))
       (do
         (when
           target
@@ -383,10 +369,7 @@
               (host-call target "splice" i 1))))
         target))))
 
-;; ── Fetch ───────────────────────────────────────────────────────
-
-;; Fetch a URL, parse response according to format.
-;; (hs-fetch url format) — format is "json" | "text" | "html"
+;; Repeat forever (until break — relies on exception/continuation).
 (define
   hs-index
   (fn
@@ -398,10 +381,10 @@
       ((string? obj) (nth obj key))
       (true (host-get obj key)))))
 
-;; ── Type coercion ───────────────────────────────────────────────
+;; ── Fetch ───────────────────────────────────────────────────────
 
-;; Coerce a value to a type by name.
-;; (hs-coerce value type-name) — type-name is "Int", "Float", "String", etc.
+;; Fetch a URL, parse response according to format.
+;; (hs-fetch url format) — format is "json" | "text" | "html"
 (define
   hs-put-at!
   (fn
@@ -423,10 +406,10 @@
                 ((= pos "start") (host-call target "unshift" value)))
               target)))))))
 
-;; ── Object creation ─────────────────────────────────────────────
+;; ── Type coercion ───────────────────────────────────────────────
 
-;; Make a new object of a given type.
-;; (hs-make type-name) — creates empty object/collection
+;; Coerce a value to a type by name.
+;; (hs-coerce value type-name) — type-name is "Int", "Float", "String", etc.
 (define
   hs-dict-without
   (fn
@@ -447,27 +430,27 @@
           (host-call (host-global "Reflect") "deleteProperty" out key)
           out)))))
 
-;; ── Behavior installation ───────────────────────────────────────
+;; ── Object creation ─────────────────────────────────────────────
 
-;; Install a behavior on an element.
-;; A behavior is a function that takes (me ...params) and sets up features.
-;; (hs-install behavior-fn me ...args)
+;; Make a new object of a given type.
+;; (hs-make type-name) — creates empty object/collection
 (define
   hs-set-on!
   (fn
     (props target)
     (for-each (fn (k) (host-set! target k (get props k))) (keys props))))
 
+;; ── Behavior installation ───────────────────────────────────────
+
+;; Install a behavior on an element.
+;; A behavior is a function that takes (me ...params) and sets up features.
+;; (hs-install behavior-fn me ...args)
+(define hs-navigate! (fn (url) (perform (list (quote io-navigate) url))))
+
 ;; ── Measurement ─────────────────────────────────────────────────
 
 ;; Measure an element's bounding rect, store as local variables.
 ;; Returns a dict with x, y, width, height, top, left, right, bottom.
-(define hs-navigate! (fn (url) (perform (list (quote io-navigate) url))))
-
-;; Return the current text selection as a string.  In the browser this is
-;; `window.getSelection().toString()`.  In the mock test runner, a test
-;; setup stashes the desired selection text at `window.__test_selection`
-;; and the fallback path returns that so tests can assert on the result.
 (define
   hs-ask
   (fn
@@ -476,11 +459,10 @@
       ((w (host-global "window")))
       (if w (host-call w "prompt" msg) nil))))
 
-
-;; ── Transition ──────────────────────────────────────────────────
-
-;; Transition a CSS property to a value, optionally with duration.
-;; (hs-transition target prop value duration)
+;; Return the current text selection as a string.  In the browser this is
+;; `window.getSelection().toString()`.  In the mock test runner, a test
+;; setup stashes the desired selection text at `window.__test_selection`
+;; and the fallback path returns that so tests can assert on the result.
 (define
   hs-answer
   (fn
@@ -489,6 +471,11 @@
       ((w (host-global "window")))
       (if w (if (host-call w "confirm" msg) yes-val no-val) no-val))))
 
+
+;; ── Transition ──────────────────────────────────────────────────
+
+;; Transition a CSS property to a value, optionally with duration.
+;; (hs-transition target prop value duration)
 (define
   hs-answer-alert
   (fn
@@ -643,25 +630,25 @@
       (hs-query-all sel)
       (host-call target "querySelectorAll" sel))))
 
-
-
-
-
 (define
   hs-list-set
   (fn
     (lst idx val)
     (append (take lst idx) (cons val (drop lst (+ idx 1))))))
 
+
+
+
+
 (define
   hs-to-number
   (fn (v) (if (number? v) v (or (parse-number (str v)) 0))))
-;; ── Sandbox/test runtime additions ──────────────────────────────
-;; Property access — dot notation and .length
+
 (define
   hs-query-first
   (fn (sel) (host-call (host-global "document") "querySelector" sel)))
-;; DOM query stub — sandbox returns empty list
+;; ── Sandbox/test runtime additions ──────────────────────────────
+;; Property access — dot notation and .length
 (define
   hs-query-last
   (fn
@@ -669,11 +656,9 @@
     (let
       ((all (dom-query-all (dom-body) sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
-;; Method dispatch — obj.method(args)
+;; DOM query stub — sandbox returns empty list
 (define hs-first (fn (scope sel) (dom-query-all scope sel)))
-
-;; ── 0.9.90 features ─────────────────────────────────────────────
-;; beep! — debug logging, returns value unchanged
+;; Method dispatch — obj.method(args)
 (define
   hs-last
   (fn
@@ -681,7 +666,9 @@
     (let
       ((all (dom-query-all scope sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
-;; Property-based is — check obj.key truthiness
+
+;; ── 0.9.90 features ─────────────────────────────────────────────
+;; beep! — debug logging, returns value unchanged
 (define
   hs-repeat-times
   (fn
@@ -699,7 +686,7 @@
               ((= signal "hs-continue") (do-repeat (+ i 1)))
               (true (do-repeat (+ i 1))))))))
     (do-repeat 0)))
-;; Array slicing (inclusive both ends)
+;; Property-based is — check obj.key truthiness
 (define
   hs-repeat-forever
   (fn
@@ -715,7 +702,7 @@
             ((= signal "hs-continue") (do-forever))
             (true (do-forever))))))
     (do-forever)))
-;; Collection: sorted by
+;; Array slicing (inclusive both ends)
 (define
   hs-repeat-while
   (fn
@@ -728,7 +715,7 @@
           ((= signal "hs-break") nil)
           ((= signal "hs-continue") (hs-repeat-while cond-fn thunk))
           (true (hs-repeat-while cond-fn thunk)))))))
-;; Collection: sorted by descending
+;; Collection: sorted by
 (define
   hs-repeat-until
   (fn
@@ -740,7 +727,7 @@
         ((= signal "hs-continue")
           (if (cond-fn) nil (hs-repeat-until cond-fn thunk)))
         (true (if (cond-fn) nil (hs-repeat-until cond-fn thunk)))))))
-;; Collection: split by
+;; Collection: sorted by descending
 (define
   hs-for-each
   (fn
@@ -760,7 +747,7 @@
                 ((= signal "hs-continue") (do-loop (rest remaining)))
                 (true (do-loop (rest remaining))))))))
       (do-loop items))))
-;; Collection: joined by
+;; Collection: split by
 (begin
   (define
     hs-append
@@ -788,7 +775,7 @@
         ((hs-element? target)
           (dom-insert-adjacent-html target "beforeend" (str value)))
         (true nil)))))
-
+;; Collection: joined by
 (define
   hs-sender
   (fn
@@ -1310,10 +1297,14 @@
                 ((ch (substring sel i (+ i 1))))
                 (cond
                   ((= ch ".")
-                    (do (flush!) (set! mode "class") (walk (+ i 1))))
+                    (do
+                      (flush!)
+                      (set! mode "class")
+                      (walk (+ i 1))))
                   ((= ch "#")
                     (do (flush!) (set! mode "id") (walk (+ i 1))))
-                  (true (do (set! cur (str cur ch)) (walk (+ i 1)))))))))
+                  (true
+                    (do (set! cur (str cur ch)) (walk (+ i 1)))))))))
         (walk 0)
         (flush!)
         {:tag tag :classes classes :id id}))))
@@ -1398,6 +1389,7 @@
   hs-strict-eq
   (fn (a b) (and (= (type-of a) (type-of b)) (= a b))))
 
+
 (define
   hs-eq-ignore-case
   (fn (a b) (= (downcase (str a)) (downcase (str b)))))
@@ -1438,7 +1430,10 @@
       ((and (dict? a) (dict? b))
         (let
           ((pos (host-call a "compareDocumentPosition" b)))
-          (if (number? pos) (not (= 0 (mod (/ pos 4) 2))) false)))
+          (if
+            (number? pos)
+            (not (= 0 (mod (/ pos 4) 2)))
+            false)))
       (true (< (str a) (str b))))))
 
 (define
@@ -1540,7 +1535,10 @@
       ((and (dict? a) (dict? b))
         (let
           ((pos (host-call a "compareDocumentPosition" b)))
-          (if (number? pos) (not (= 0 (mod (/ pos 4) 2))) false)))
+          (if
+            (number? pos)
+            (not (= 0 (mod (/ pos 4) 2)))
+            false)))
       (true (< (str a) (str b))))))
 
 (define
@@ -1591,7 +1589,9 @@
 
 (define
   hs-morph-char
-  (fn (s p) (if (or (< p 0) (>= p (string-length s))) nil (nth s p))))
+  (fn
+    (s p)
+    (if (or (< p 0) (>= p (string-length s))) nil (nth s p))))
 
 (define
   hs-morph-index-from
@@ -1619,7 +1619,10 @@
         (q)
         (let
           ((c (hs-morph-char s q)))
-          (if (and c (< (index-of stop c) 0)) (loop (+ q 1)) q))))
+          (if
+            (and c (< (index-of stop c) 0))
+            (loop (+ q 1))
+            q))))
     (let ((e (loop p))) (list (substring s p e) e))))
 
 (define
@@ -1661,7 +1664,9 @@
                                 (append
                                   acc
                                   (list
-                                    (list name (substring s (+ p4 1) close)))))))
+                                    (list
+                                      name
+                                      (substring s (+ p4 1) close)))))))
                           ((= c2 "'")
                             (let
                               ((close (hs-morph-index-from s "'" (+ p4 1))))
@@ -1671,7 +1676,9 @@
                                 (append
                                   acc
                                   (list
-                                    (list name (substring s (+ p4 1) close)))))))
+                                    (list
+                                      name
+                                      (substring s (+ p4 1) close)))))))
                           (true
                             (let
                               ((r2 (hs-morph-read-until s p4 " \t\n/>")))
@@ -1755,7 +1762,9 @@
               (for-each
                 (fn
                   (c)
-                  (when (> (string-length c) 0) (dom-add-class el c)))
+                  (when
+                    (> (string-length c) 0)
+                    (dom-add-class el c)))
                 (split v " ")))
             ((and keep-id (= n "id")) nil)
             (true (dom-set-attr el n v)))))
@@ -1856,7 +1865,8 @@
           ((parts (split resolved ":")))
           (let
             ((prop (first parts))
-              (val (if (> (len parts) 1) (nth parts 1) nil)))
+              (val
+                (if (> (len parts) 1) (nth parts 1) nil)))
             (cond
               ((and (not (= prop "display")) (not (= prop "opacity")) (not (= prop "visibility")) (not (= prop "hidden")) (not (= prop "class-hidden")) (not (= prop "class-invisible")) (not (= prop "class-opacity")) (not (= prop "details")) (not (= prop "dialog")) (dict-has? _hs-hide-strategies prop))
                 (let
@@ -1895,7 +1905,8 @@
           ((parts (split resolved ":")))
           (let
             ((prop (first parts))
-              (val (if (> (len parts) 1) (nth parts 1) nil)))
+              (val
+                (if (> (len parts) 1) (nth parts 1) nil)))
             (cond
               ((and (not (= prop "display")) (not (= prop "opacity")) (not (= prop "visibility")) (not (= prop "hidden")) (not (= prop "class-hidden")) (not (= prop "class-invisible")) (not (= prop "class-opacity")) (not (= prop "details")) (not (= prop "dialog")) (dict-has? _hs-hide-strategies prop))
                 (let
@@ -1999,10 +2010,14 @@
                             (if
                               (= depth 1)
                               j
-                              (find-close (+ j 1) (- depth 1)))
+                              (find-close
+                                (+ j 1)
+                                (- depth 1)))
                             (if
                               (= (nth raw j) "{")
-                              (find-close (+ j 1) (+ depth 1))
+                              (find-close
+                                (+ j 1)
+                                (+ depth 1))
                               (find-close (+ j 1) depth))))))
                     (let
                       ((close (find-close start 1)))
@@ -2093,7 +2108,10 @@
               (if
                 (= (len lst) 0)
                 -1
-                (if (= (first lst) item) i (idx-loop (rest lst) (+ i 1))))))
+                (if
+                  (= (first lst) item)
+                  i
+                  (idx-loop (rest lst) (+ i 1))))))
           (idx-loop obj 0)))
       (true nil))))
 
@@ -2179,7 +2197,8 @@
                 (cond
                   ((= end "hs-pick-end") n)
                   ((= end "hs-pick-start") 0)
-                  ((and (number? end) (< end 0)) (max 0 (+ n end)))
+                  ((and (number? end) (< end 0))
+                    (max 0 (+ n end)))
                   (true end))))
             (cond
               ((string? col) (slice col s e))
@@ -2466,6 +2485,50 @@
           ((nth entry 2) val)))
       _hs-dom-watchers)))
 
+(define hs-prolog-hook nil)
+
+(define hs-set-prolog-hook! (fn (f) (set! hs-prolog-hook f)))
+
+(define
+  prolog
+  (fn
+    (db goal)
+    (if
+      (nil? hs-prolog-hook)
+      (raise "prolog hook not installed")
+      (hs-prolog-hook db goal))))
+
+(define
+  hs-null-error!
+  (fn (selector) (raise (str "'" selector "' is null"))))
+
+(define
+  hs-named-target
+  (fn (selector value) (if (nil? value) (hs-null-error! selector) value)))
+
+(define
+  hs-named-target-list
+  (fn
+    (selector values)
+    (if (nil? values) (hs-null-error! selector) values)))
+
+(define
+  hs-query-named-all
+  (fn
+    (selector)
+    (let
+      ((results (hs-query-all selector)))
+      (if
+        (and
+          (or
+            (nil? results)
+            (and (list? results) (= (len results) 0)))
+          (string? selector)
+          (> (len selector) 0)
+          (= (substring selector 0 1) "#"))
+        (hs-null-error! selector)
+        results))))
+
 (define
   hs-dom-is-ancestor?
   (fn

lib/prolog/compiler.sx

@@ -0,0 +1,176 @@
+;; lib/prolog/compiler.sx — clause compiler: parse-AST clauses → SX closures
+;;
+;; Each compiled clause is a lambda (fn (goal trail db cut-box k) bool)
+;; that creates fresh vars, builds the instantiated head/body, and calls
+;; pl-unify! + pl-solve! directly — no AST walk at solve time.
+;;
+;; Usage:
+;;   (pl-db-load! db (pl-parse src))
+;;   (pl-compile-db! db)
+;;   ; pl-solve-user! in runtime.sx automatically prefers compiled clauses
+;;   (pl-solve-once! db goal trail)
+
+;; Collect unique variable names from a parse-AST clause into a dict.
+(define
+  pl-cmp-vars-into!
+  (fn
+    (ast seen)
+    (cond
+      ((not (list? ast)) nil)
+      ((empty? ast) nil)
+      ((= (first ast) "var")
+        (let
+          ((name (nth ast 1)))
+          (when
+            (and (not (= name "_")) (not (dict-has? seen name)))
+            (dict-set! seen name true))))
+      ((= (first ast) "compound")
+        (for-each (fn (a) (pl-cmp-vars-into! a seen)) (nth ast 2)))
+      ((= (first ast) "clause")
+        (begin
+          (pl-cmp-vars-into! (nth ast 1) seen)
+          (pl-cmp-vars-into! (nth ast 2) seen))))))
+
+;; Return list of unique var names in a clause (head + body, excluding _).
+(define
+  pl-cmp-collect-vars
+  (fn
+    (clause)
+    (let ((seen {})) (pl-cmp-vars-into! clause seen) (keys seen))))
+
+;; Create a fresh runtime var for each name in the list; return name->var dict.
+(define
+  pl-cmp-make-var-map
+  (fn
+    (var-names)
+    (let
+      ((m {}))
+      (for-each
+        (fn (name) (dict-set! m name (pl-mk-rt-var name)))
+        var-names)
+      m)))
+
+;; Instantiate a parse-AST term using a pre-built var-map.
+;; ("var" "_") always gets a fresh anonymous var.
+(define
+  pl-cmp-build-term
+  (fn
+    (ast var-map)
+    (cond
+      ((pl-var? ast) ast)
+      ((not (list? ast)) ast)
+      ((empty? ast) ast)
+      ((= (first ast) "var")
+        (let
+          ((name (nth ast 1)))
+          (if (= name "_") (pl-mk-rt-var "_") (dict-get var-map name))))
+      ((or (= (first ast) "atom") (= (first ast) "num") (= (first ast) "str"))
+        ast)
+      ((= (first ast) "compound")
+        (list
+          "compound"
+          (nth ast 1)
+          (map (fn (a) (pl-cmp-build-term a var-map)) (nth ast 2))))
+      ((= (first ast) "clause")
+        (list
+          "clause"
+          (pl-cmp-build-term (nth ast 1) var-map)
+          (pl-cmp-build-term (nth ast 2) var-map)))
+      (true ast))))
+
+;; Compile one parse-AST clause to a lambda.
+;; Pre-computes var names at compile time; creates fresh vars per call.
+(define
+  pl-compile-clause
+  (fn
+    (clause)
+    (let
+      ((var-names (pl-cmp-collect-vars clause))
+        (head-ast (nth clause 1))
+        (body-ast (nth clause 2)))
+      (fn
+        (goal trail db cut-box k)
+        (let
+          ((var-map (pl-cmp-make-var-map var-names)))
+          (let
+            ((fresh-head (pl-cmp-build-term head-ast var-map))
+              (fresh-body (pl-cmp-build-term body-ast var-map)))
+            (let
+              ((mark (pl-trail-mark trail)))
+              (if
+                (pl-unify! goal fresh-head trail)
+                (let
+                  ((r (pl-solve! db fresh-body trail cut-box k)))
+                  (if r true (begin (pl-trail-undo-to! trail mark) false)))
+                (begin (pl-trail-undo-to! trail mark) false)))))))))
+
+;; Try a list of compiled clause lambdas — same cut semantics as pl-try-clauses!.
+(define
+  pl-try-compiled-clauses!
+  (fn
+    (db
+      goal
+      trail
+      compiled-clauses
+      outer-cut-box
+      outer-was-cut
+      inner-cut-box
+      k)
+    (cond
+      ((empty? compiled-clauses) false)
+      (true
+        (let
+          ((r ((first compiled-clauses) goal trail db inner-cut-box k)))
+          (cond
+            (r true)
+            ((dict-get inner-cut-box :cut) false)
+            ((and (not outer-was-cut) (dict-get outer-cut-box :cut)) false)
+            (true
+              (pl-try-compiled-clauses!
+                db
+                goal
+                trail
+                (rest compiled-clauses)
+                outer-cut-box
+                outer-was-cut
+                inner-cut-box
+                k))))))))
+
+;; Compile all clauses in DB and store in :compiled table.
+;; After this call, pl-solve-user! will dispatch via compiled lambdas.
+;; Note: clauses assert!-ed after this call are not compiled.
+(define
+  pl-compile-db!
+  (fn
+    (db)
+    (let
+      ((src-table (dict-get db :clauses)) (compiled-table {}))
+      (for-each
+        (fn
+          (key)
+          (dict-set!
+            compiled-table
+            key
+            (map pl-compile-clause (dict-get src-table key))))
+        (keys src-table))
+      (dict-set! db :compiled compiled-table)
+      db)))
+
+;; Cross-validate: load src into both a plain and a compiled DB,
+;; run goal-str through each, return true iff solution counts match.
+;; Use this to keep the interpreter as the reference implementation.
+(define
+  pl-compiled-matches-interp?
+  (fn
+    (src goal-str)
+    (let
+      ((db-interp (pl-mk-db)) (db-comp (pl-mk-db)))
+      (pl-db-load! db-interp (pl-parse src))
+      (pl-db-load! db-comp (pl-parse src))
+      (pl-compile-db! db-comp)
+      (let
+        ((gi (pl-instantiate (pl-parse-goal goal-str) {}))
+          (gc (pl-instantiate (pl-parse-goal goal-str) {})))
+        (=
+          (pl-solve-count! db-interp gi (pl-mk-trail))
+          (pl-solve-count! db-comp gc (pl-mk-trail)))))))

lib/prolog/conformance.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# Run every Prolog test suite via sx_server and refresh scoreboard.{json,md}.
+# Exit 0 if all green, 1 if any failures.
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+SX="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+
+if [[ ! -x "$SX" ]]; then
+  echo "sx_server not found at $SX (set SX_SERVER env to override)" >&2
+  exit 2
+fi
+
+cd "$ROOT"
+
+# name : test-file : runner-fn
+SUITES=(
+  "parse:lib/prolog/tests/parse.sx:pl-parse-tests-run!"
+  "unify:lib/prolog/tests/unify.sx:pl-unify-tests-run!"
+  "clausedb:lib/prolog/tests/clausedb.sx:pl-clausedb-tests-run!"
+  "solve:lib/prolog/tests/solve.sx:pl-solve-tests-run!"
+  "operators:lib/prolog/tests/operators.sx:pl-operators-tests-run!"
+  "dynamic:lib/prolog/tests/dynamic.sx:pl-dynamic-tests-run!"
+  "findall:lib/prolog/tests/findall.sx:pl-findall-tests-run!"
+  "term_inspect:lib/prolog/tests/term_inspect.sx:pl-term-inspect-tests-run!"
+  "append:lib/prolog/tests/programs/append.sx:pl-append-tests-run!"
+  "reverse:lib/prolog/tests/programs/reverse.sx:pl-reverse-tests-run!"
+  "member:lib/prolog/tests/programs/member.sx:pl-member-tests-run!"
+  "nqueens:lib/prolog/tests/programs/nqueens.sx:pl-nqueens-tests-run!"
+  "family:lib/prolog/tests/programs/family.sx:pl-family-tests-run!"
+  "atoms:lib/prolog/tests/atoms.sx:pl-atom-tests-run!"
+  "query_api:lib/prolog/tests/query_api.sx:pl-query-api-tests-run!"
+  "iso_predicates:lib/prolog/tests/iso_predicates.sx:pl-iso-predicates-tests-run!"
+  "meta_predicates:lib/prolog/tests/meta_predicates.sx:pl-meta-predicates-tests-run!"
+  "list_predicates:lib/prolog/tests/list_predicates.sx:pl-list-predicates-tests-run!"
+  "meta_call:lib/prolog/tests/meta_call.sx:pl-meta-call-tests-run!"
+  "set_predicates:lib/prolog/tests/set_predicates.sx:pl-set-predicates-tests-run!"
+  "char_predicates:lib/prolog/tests/char_predicates.sx:pl-char-predicates-tests-run!"
+  "io_predicates:lib/prolog/tests/io_predicates.sx:pl-io-predicates-tests-run!"
+  "assert_rules:lib/prolog/tests/assert_rules.sx:pl-assert-rules-tests-run!"
+  "string_agg:lib/prolog/tests/string_agg.sx:pl-string-agg-tests-run!"
+  "advanced:lib/prolog/tests/advanced.sx:pl-advanced-tests-run!"
+  "compiler:lib/prolog/tests/compiler.sx:pl-compiler-tests-run!"
+  "cross_validate:lib/prolog/tests/cross_validate.sx:pl-cross-validate-tests-run!"
+  "integration:lib/prolog/tests/integration.sx:pl-integration-tests-run!"
+  "hs_bridge:lib/prolog/tests/hs_bridge.sx:pl-hs-bridge-tests-run!"
+)
+
+SCRIPT='(epoch 1)
+(load "lib/prolog/tokenizer.sx")
+(load "lib/prolog/parser.sx")
+(load "lib/prolog/runtime.sx")
+(load "lib/prolog/query.sx")
+(load "lib/prolog/compiler.sx")
+(load "lib/prolog/hs-bridge.sx")'
+for entry in "${SUITES[@]}"; do
+  IFS=: read -r _ file _ <<< "$entry"
+  SCRIPT+=$'\n(load "'"$file"$'")'
+done
+for entry in "${SUITES[@]}"; do
+  IFS=: read -r _ _ fn <<< "$entry"
+  SCRIPT+=$'\n(eval "('"$fn"$')")'
+done
+
+OUTPUT="$(printf '%s\n' "$SCRIPT" | "$SX" 2>&1)"
+
+mapfile -t LINES < <(printf '%s\n' "$OUTPUT" | grep -E '^\{:failed')
+
+if [[ ${#LINES[@]} -ne ${#SUITES[@]} ]]; then
+  echo "Expected ${#SUITES[@]} suite results, got ${#LINES[@]}" >&2
+  echo "---- raw output ----" >&2
+  printf '%s\n' "$OUTPUT" >&2
+  exit 3
+fi
+
+TOTAL_PASS=0
+TOTAL_FAIL=0
+TOTAL=0
+JSON_SUITES=""
+MD_ROWS=""
+
+for i in "${!SUITES[@]}"; do
+  IFS=: read -r name _ _ <<< "${SUITES[$i]}"
+  line="${LINES[$i]}"
+  passed=$(grep -oE ':passed [0-9]+' <<< "$line" | grep -oE '[0-9]+')
+  total=$(grep -oE ':total [0-9]+' <<< "$line" | grep -oE '[0-9]+')
+  failed=$(grep -oE ':failed [0-9]+' <<< "$line" | grep -oE '[0-9]+')
+  TOTAL_PASS=$((TOTAL_PASS + passed))
+  TOTAL_FAIL=$((TOTAL_FAIL + failed))
+  TOTAL=$((TOTAL + total))
+  status="ok"
+  [[ "$failed" -gt 0 ]] && status="FAIL"
+  [[ -n "$JSON_SUITES" ]] && JSON_SUITES+=","
+  JSON_SUITES+="\"$name\":{\"passed\":$passed,\"total\":$total,\"failed\":$failed}"
+  MD_ROWS+="| $name | $passed | $total | $status |"$'\n'
+done
+
+WHEN="$(date -Iseconds 2>/dev/null || date)"
+
+cat > "$HERE/scoreboard.json" <<JSON
+{
+  "total_passed": $TOTAL_PASS,
+  "total_failed": $TOTAL_FAIL,
+  "total": $TOTAL,
+  "suites": {$JSON_SUITES},
+  "generated": "$WHEN"
+}
+JSON
+
+cat > "$HERE/scoreboard.md" <<MD
+# Prolog scoreboard
+
+**$TOTAL_PASS / $TOTAL passing** ($TOTAL_FAIL failure(s)).
+Generated $WHEN.
+
+| Suite | Passed | Total | Status |
+|-------|--------|-------|--------|
+$MD_ROWS
+Run \`bash lib/prolog/conformance.sh\` to refresh. Override the binary
+with \`SX_SERVER=path/to/sx_server.exe bash …\`.
+MD
+
+if [[ "$TOTAL_FAIL" -gt 0 ]]; then
+  echo "$TOTAL_FAIL failure(s) across $TOTAL tests" >&2
+  exit 1
+fi
+
+echo "All $TOTAL tests pass."

lib/prolog/hs-bridge.sx

@@ -0,0 +1,84 @@
+;; lib/prolog/hs-bridge.sx — Prolog ↔ Hyperscript bridge
+;;
+;; Two complementary integration styles:
+;;
+;; 1. Hook style — for `prolog(db, "goal(args)")` call syntax in Hyperscript:
+;;      (pl-install-hs-hook!)   ;; call once at startup
+;;    Requires lib/hyperscript/runtime.sx (provides hs-set-prolog-hook!)
+;;
+;; 2. Factory style — for named conditions like `when allowed(user, action)`:
+;;      (define allowed (pl-hs-predicate/2 pl-db "allowed"))
+;;    No parser/compiler changes needed: Hyperscript compiles
+;;    `allowed(user, action)` to `(allowed user action)` — a plain SX call.
+;;
+;; Requires tokenizer.sx, parser.sx, runtime.sx, query.sx loaded first.
+
+;; --- Hook style ---
+
+(define
+  pl-install-hs-hook!
+  (fn
+    ()
+    (hs-set-prolog-hook!
+      (fn (db goal) (not (= nil (pl-query-one db goal)))))))
+
+;; --- Factory style ---
+
+;; Test whether a ground Prolog goal succeeds against db.
+;; Returns true/false (not a solution dict).
+(define
+  pl-hs-query
+  (fn (db goal-str) (not (nil? (pl-query-one db goal-str)))))
+
+;; Build a Prolog goal string from a predicate name and arg list.
+;; SX values: strings/keywords pass through; numbers are stringified via str.
+(define
+  pl-hs-build-goal
+  (fn
+    (pred-name args)
+    (str pred-name "(" (join ", " (map (fn (a) (str a)) args)) ")")))
+
+;; Return a 1-arg SX function that succeeds iff pred(a) holds in db.
+(define
+  pl-hs-predicate/1
+  (fn
+    (db pred-name)
+    (fn (a) (pl-hs-query db (pl-hs-build-goal pred-name (list a))))))
+
+;; Return a 2-arg SX function that succeeds iff pred(a, b) holds in db.
+(define
+  pl-hs-predicate/2
+  (fn
+    (db pred-name)
+    (fn (a b) (pl-hs-query db (pl-hs-build-goal pred-name (list a b))))))
+
+;; Return a 3-arg SX function that succeeds iff pred(a, b, c) holds in db.
+(define
+  pl-hs-predicate/3
+  (fn
+    (db pred-name)
+    (fn (a b c) (pl-hs-query db (pl-hs-build-goal pred-name (list a b c))))))
+
+;; Install every predicate in install-list as a named SX function backed by db.
+;; install-list: list of (name arity) pairs.
+;; Returns a dict {name → fn} for the caller to destructure.
+(define
+  pl-hs-install
+  (fn
+    (db install-list)
+    (reduce
+      (fn
+        (acc entry)
+        (let
+          ((pred-name (first entry)) (arity (nth entry 1)))
+          (dict-set!
+            acc
+            pred-name
+            (cond
+              ((= arity 1) (pl-hs-predicate/1 db pred-name))
+              ((= arity 2) (pl-hs-predicate/2 db pred-name))
+              ((= arity 3) (pl-hs-predicate/3 db pred-name))
+              (true (fn (a b) false))))
+          acc))
+      {}
+      install-list)))

lib/prolog/parser.sx

@@ -1,28 +1,20 @@
 ;; lib/prolog/parser.sx — tokens → Prolog AST
 ;;
-;; Phase 1 grammar (NO operator table yet):
+;; Phase 4 grammar (with operator table):
 ;;   Program      := Clause* EOF
-;;   Clause       := Term "." | Term ":-" Term "."
-;;   Term         := Atom | Var | Number | String | Compound | List
-;;   Compound     := atom "(" ArgList ")"
-;;   ArgList      := Term ("," Term)*
-;;   List         := "[" "]" | "[" Term ("," Term)* ("|" Term)? "]"
+;;   Clause       := Term[999] "." | Term[999] ":-" Term[1200] "."
+;;   Term[Pmax] uses precedence climbing on the operator table:
+;;     primary = Atom | Var | Number | String | Compound | List | "(" Term[1200] ")"
+;;     while next token is infix op `op` with prec(op) ≤ Pmax:
+;;       consume op; parse rhs at right-prec(op); fold into compound(op-name,[lhs,rhs])
 ;;
-;; Term AST shapes (all tagged lists for uniform dispatch):
-;;   ("atom"  name)            — atom
-;;   ("var"   name)            — variable template (parser-time only)
-;;   ("num"   value)           — integer or float
-;;   ("str"   value)           — string literal
-;;   ("compound" functor args) — compound term, args is list of term-ASTs
-;;   ("cut")                   — the cut atom !
+;; Op type → right-prec for op at precedence P:
+;;   xfx → P-1   strict-both
+;;   xfy → P     right-associative
+;;   yfx → P-1   left-associative
 ;;
-;; A clause is (list "clause" head body). A fact is head with body = ("atom" "true").
-;;
-;; The empty list is (atom "[]"). Cons is compound "." with two args:
-;; [1, 2, 3]   → .(1, .(2, .(3, [])))
-;; [H|T]       → .(H, T)
+;; AST shapes are unchanged — operators just become compound terms.
 
-;; ── Parser state helpers ────────────────────────────────────────────
 (define
   pp-peek
   (fn
@@ -66,7 +58,6 @@
             (if (= (get t :value) nil) "" (get t :value))
             "'"))))))
 
-;; ── AST constructors ────────────────────────────────────────────────
 (define pl-mk-atom (fn (name) (list "atom" name)))
 (define pl-mk-var (fn (name) (list "var" name)))
 (define pl-mk-num (fn (n) (list "num" n)))
@@ -74,18 +65,14 @@
 (define pl-mk-compound (fn (f args) (list "compound" f args)))
 (define pl-mk-cut (fn () (list "cut")))
 
-;; Term tag extractors
 (define pl-term-tag (fn (t) (if (list? t) (first t) nil)))
 (define pl-term-val (fn (t) (nth t 1)))
 (define pl-compound-functor (fn (t) (nth t 1)))
 (define pl-compound-args (fn (t) (nth t 2)))
 
-;; Empty-list atom and cons helpers
 (define pl-nil-term (fn () (pl-mk-atom "[]")))
-
 (define pl-mk-cons (fn (h t) (pl-mk-compound "." (list h t))))
 
-;; Build cons list from a list of terms + optional tail
 (define
   pl-mk-list-term
   (fn
@@ -95,9 +82,61 @@
       tail
       (pl-mk-cons (first items) (pl-mk-list-term (rest items) tail)))))
 
-;; ── Term parser ─────────────────────────────────────────────────────
+;; ── Operator table (Phase 4) ──────────────────────────────────────
+;; Each entry: (name precedence type). Type ∈ "xfx" "xfy" "yfx".
 (define
-  pp-parse-term
+  pl-op-table
+  (list
+    (list "," 1000 "xfy")
+    (list ";" 1100 "xfy")
+    (list "->" 1050 "xfy")
+    (list "=" 700 "xfx")
+    (list "\\=" 700 "xfx")
+    (list "is" 700 "xfx")
+    (list "<" 700 "xfx")
+    (list ">" 700 "xfx")
+    (list "=<" 700 "xfx")
+    (list ">=" 700 "xfx")
+    (list "+" 500 "yfx")
+    (list "-" 500 "yfx")
+    (list "*" 400 "yfx")
+    (list "/" 400 "yfx")
+    (list ":-" 1200 "xfx")
+    (list "mod" 400 "yfx")))
+
+(define
+  pl-op-find
+  (fn
+    (name table)
+    (cond
+      ((empty? table) nil)
+      ((= (first (first table)) name) (rest (first table)))
+      (true (pl-op-find name (rest table))))))
+
+(define pl-op-lookup (fn (name) (pl-op-find name pl-op-table)))
+
+;; Token → (name prec type) for known infix ops, else nil.
+(define
+  pl-token-op
+  (fn
+    (t)
+    (let
+      ((ty (get t :type)) (vv (get t :value)))
+      (cond
+        ((and (= ty "punct") (= vv ","))
+          (let
+            ((info (pl-op-lookup ",")))
+            (if (nil? info) nil (cons "," info))))
+        ((or (= ty "atom") (= ty "op"))
+          (let
+            ((info (pl-op-lookup vv)))
+            (if (nil? info) nil (cons vv info))))
+        (true nil)))))
+
+;; ── Term parser ─────────────────────────────────────────────────────
+;; Primary term: atom, var, num, str, compound (atom + paren), list, cut, parens.
+(define
+  pp-parse-primary
   (fn
     (st)
     (let
@@ -111,6 +150,12 @@
           ((and (= ty "op") (= vv "!"))
             (do (pp-advance! st) (pl-mk-cut)))
           ((and (= ty "punct") (= vv "[")) (pp-parse-list st))
+          ((and (= ty "punct") (= vv "("))
+            (do
+              (pp-advance! st)
+              (let
+                ((inner (pp-parse-term-prec st 1200)))
+                (do (pp-expect! st "punct" ")") inner))))
           ((= ty "atom")
             (do
               (pp-advance! st)
@@ -133,13 +178,51 @@
                 (if (= vv nil) "" vv)
                 "'"))))))))
 
-;; Parse one or more comma-separated terms (arguments).
+;; Operator-aware term parser: precedence climbing.
+(define
+  pp-parse-term-prec
+  (fn
+    (st max-prec)
+    (let ((left (pp-parse-primary st))) (pp-parse-op-rhs st left max-prec))))
+
+(define
+  pp-parse-op-rhs
+  (fn
+    (st left max-prec)
+    (let
+      ((op-info (pl-token-op (pp-peek st))))
+      (cond
+        ((nil? op-info) left)
+        (true
+          (let
+            ((name (first op-info))
+              (prec (nth op-info 1))
+              (ty (nth op-info 2)))
+            (cond
+              ((> prec max-prec) left)
+              (true
+                (let
+                  ((right-prec (if (= ty "xfy") prec (- prec 1))))
+                  (do
+                    (pp-advance! st)
+                    (let
+                      ((right (pp-parse-term-prec st right-prec)))
+                      (pp-parse-op-rhs
+                        st
+                        (pl-mk-compound name (list left right))
+                        max-prec))))))))))))
+
+;; Backwards-compat alias.
+(define pp-parse-term (fn (st) (pp-parse-term-prec st 999)))
+
+;; Args inside parens: parse at prec 999 so comma-as-operator (1000)
+;; is not consumed; the explicit comma loop handles separation.
 (define
   pp-parse-arg-list
   (fn
     (st)
     (let
-      ((first-arg (pp-parse-term st)) (args (list)))
+      ((first-arg (pp-parse-term-prec st 999)) (args (list)))
       (do
         (append! args first-arg)
         (define
@@ -150,12 +233,12 @@
               (pp-at? st "punct" ",")
               (do
                 (pp-advance! st)
-                (append! args (pp-parse-term st))
+                (append! args (pp-parse-term-prec st 999))
                 (loop)))))
         (loop)
         args))))
 
-;; Parse a [ ... ] list literal. Consumes the "[".
+;; List literal.
 (define
   pp-parse-list
   (fn
@@ -168,7 +251,7 @@
         (let
           ((items (list)))
           (do
-            (append! items (pp-parse-term st))
+            (append! items (pp-parse-term-prec st 999))
             (define
               comma-loop
               (fn
@@ -177,52 +260,17 @@
                   (pp-at? st "punct" ",")
                   (do
                     (pp-advance! st)
-                    (append! items (pp-parse-term st))
+                    (append! items (pp-parse-term-prec st 999))
                     (comma-loop)))))
             (comma-loop)
             (let
-              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term st)) (pl-nil-term))))
+              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term-prec st 999)) (pl-nil-term))))
               (do (pp-expect! st "punct" "]") (pl-mk-list-term items tail)))))))))
 
 ;; ── Body parsing ────────────────────────────────────────────────────
-;; A clause body is a comma-separated list of goals. We flatten into a
-;; right-associative `,` compound: (A, B, C) → ','(A, ','(B, C))
-;; If only one goal, it's that goal directly.
-(define
-  pp-parse-body
-  (fn
-    (st)
-    (let
-      ((first-goal (pp-parse-term st)) (rest-goals (list)))
-      (do
-        (define
-          gloop
-          (fn
-            ()
-            (when
-              (pp-at? st "punct" ",")
-              (do
-                (pp-advance! st)
-                (append! rest-goals (pp-parse-term st))
-                (gloop)))))
-        (gloop)
-        (if
-          (= (len rest-goals) 0)
-          first-goal
-          (pp-build-conj first-goal rest-goals))))))
-
-(define
-  pp-build-conj
-  (fn
-    (first-goal rest-goals)
-    (if
-      (= (len rest-goals) 0)
-      first-goal
-      (pl-mk-compound
-        ","
-        (list
-          first-goal
-          (pp-build-conj (first rest-goals) (rest rest-goals)))))))
+;; A body is a single term parsed at prec 1200 — operator parser folds
+;; `,`, `;`, `->` automatically into right-associative compounds.
+(define pp-parse-body (fn (st) (pp-parse-term-prec st 1200)))
 
 ;; ── Clause parsing ──────────────────────────────────────────────────
 (define
@@ -230,12 +278,11 @@
   (fn
     (st)
     (let
-      ((head (pp-parse-term st)))
+      ((head (pp-parse-term-prec st 999)))
       (let
         ((body (if (pp-at? st "op" ":-") (do (pp-advance! st) (pp-parse-body st)) (pl-mk-atom "true"))))
         (do (pp-expect! st "punct" ".") (list "clause" head body))))))
 
-;; Parse an entire program — returns list of clauses.
 (define
   pl-parse-program
   (fn
@@ -253,13 +300,9 @@
         (ploop)
         clauses))))
 
-;; Parse a single query term (no trailing "."). Returns the term.
 (define
   pl-parse-query
   (fn (tokens) (let ((st {:idx 0 :tokens tokens})) (pp-parse-body st))))
 
-;; Convenience: source → clauses
 (define pl-parse (fn (src) (pl-parse-program (pl-tokenize src))))
-
-;; Convenience: source → query term
 (define pl-parse-goal (fn (src) (pl-parse-query (pl-tokenize src))))

lib/prolog/query.sx

@@ -0,0 +1,114 @@
+;; lib/prolog/query.sx — high-level Prolog query API for SX/Hyperscript callers.
+;;
+;; Requires tokenizer.sx, parser.sx, runtime.sx to be loaded first.
+;;
+;; Public API:
+;;   (pl-load source-str)                → db
+;;   (pl-query-all db query-str)         → list of solution dicts {var-name → term-string}
+;;   (pl-query-one db query-str)         → first solution dict or nil
+;;   (pl-query source-str query-str)     → list of solution dicts (convenience)
+
+;; Collect variable name strings from a parse-time AST (pre-instantiation).
+;; Returns list of unique strings, excluding anonymous "_".
+(define
+  pl-query-extract-vars
+  (fn
+    (ast)
+    (let
+      ((seen {}))
+      (let
+        ((collect!
+          (fn
+            (t)
+            (cond
+              ((not (list? t)) nil)
+              ((empty? t) nil)
+              ((= (first t) "var")
+                (if
+                  (not (= (nth t 1) "_"))
+                  (dict-set! seen (nth t 1) true)
+                  nil))
+              ((= (first t) "compound")
+                (for-each collect! (nth t 2)))
+              (true nil)))))
+        (collect! ast)
+        (keys seen)))))
+
+;; Build a solution dict from a var-env after a successful solve.
+;; Maps each variable name string to its formatted term value.
+(define
+  pl-query-solution-dict
+  (fn
+    (var-names var-env)
+    (let
+      ((d {}))
+      (for-each
+        (fn (name) (dict-set! d name (pl-format-term (dict-get var-env name))))
+        var-names)
+      d)))
+
+;; Parse source-str and load clauses into a fresh DB.
+;; Returns the DB for reuse across multiple queries.
+(define
+  pl-load
+  (fn
+    (source-str)
+    (let
+      ((db (pl-mk-db)))
+      (if
+        (and (string? source-str) (not (= source-str "")))
+        (pl-db-load! db (pl-parse source-str))
+        nil)
+      db)))
+
+;; Run query-str against db, returning a list of solution dicts.
+;; Each dict maps variable name strings to their formatted term values.
+;; Returns an empty list if no solutions.
+(define
+  pl-query-all
+  (fn
+    (db query-str)
+    (let
+      ((parsed (pl-parse (str "q_ :- " query-str "."))))
+      (let
+        ((body-ast (nth (first parsed) 2)))
+        (let
+          ((var-names (pl-query-extract-vars body-ast))
+           (var-env {}))
+          (let
+            ((goal (pl-instantiate body-ast var-env))
+             (trail (pl-mk-trail))
+             (solutions (list)))
+            (let
+              ((mark (pl-trail-mark trail)))
+              (pl-solve!
+                db
+                goal
+                trail
+                {:cut false}
+                (fn
+                  ()
+                  (begin
+                    (append!
+                      solutions
+                      (pl-query-solution-dict var-names var-env))
+                    false)))
+              (pl-trail-undo-to! trail mark)
+              solutions)))))))
+
+;; Return the first solution dict, or nil if no solutions.
+(define
+  pl-query-one
+  (fn
+    (db query-str)
+    (let
+      ((all (pl-query-all db query-str)))
+      (if (empty? all) nil (first all)))))
+
+;; Convenience: parse source-str, then run query-str against it.
+;; Returns a list of solution dicts. Creates a fresh DB each call.
+(define
+  pl-query
+  (fn
+    (source-str query-str)
+    (pl-query-all (pl-load source-str) query-str)))

lib/prolog/scoreboard.json

@@ -0,0 +1,7 @@
+{
+  "total_passed": 590,
+  "total_failed": 0,
+  "total": 590,
+  "suites": {"parse":{"passed":25,"total":25,"failed":0},"unify":{"passed":47,"total":47,"failed":0},"clausedb":{"passed":14,"total":14,"failed":0},"solve":{"passed":62,"total":62,"failed":0},"operators":{"passed":19,"total":19,"failed":0},"dynamic":{"passed":11,"total":11,"failed":0},"findall":{"passed":11,"total":11,"failed":0},"term_inspect":{"passed":14,"total":14,"failed":0},"append":{"passed":6,"total":6,"failed":0},"reverse":{"passed":6,"total":6,"failed":0},"member":{"passed":7,"total":7,"failed":0},"nqueens":{"passed":6,"total":6,"failed":0},"family":{"passed":10,"total":10,"failed":0},"atoms":{"passed":34,"total":34,"failed":0},"query_api":{"passed":16,"total":16,"failed":0},"iso_predicates":{"passed":29,"total":29,"failed":0},"meta_predicates":{"passed":25,"total":25,"failed":0},"list_predicates":{"passed":33,"total":33,"failed":0},"meta_call":{"passed":15,"total":15,"failed":0},"set_predicates":{"passed":15,"total":15,"failed":0},"char_predicates":{"passed":27,"total":27,"failed":0},"io_predicates":{"passed":24,"total":24,"failed":0},"assert_rules":{"passed":15,"total":15,"failed":0},"string_agg":{"passed":25,"total":25,"failed":0},"advanced":{"passed":21,"total":21,"failed":0},"compiler":{"passed":17,"total":17,"failed":0},"cross_validate":{"passed":17,"total":17,"failed":0},"integration":{"passed":20,"total":20,"failed":0},"hs_bridge":{"passed":19,"total":19,"failed":0}},
+  "generated": "2026-05-06T08:29:09+00:00"
+}

lib/prolog/scoreboard.md

@@ -0,0 +1,39 @@
+# Prolog scoreboard
+
+**590 / 590 passing** (0 failure(s)).
+Generated 2026-05-06T08:29:09+00:00.
+
+| Suite | Passed | Total | Status |
+|-------|--------|-------|--------|
+| parse | 25 | 25 | ok |
+| unify | 47 | 47 | ok |
+| clausedb | 14 | 14 | ok |
+| solve | 62 | 62 | ok |
+| operators | 19 | 19 | ok |
+| dynamic | 11 | 11 | ok |
+| findall | 11 | 11 | ok |
+| term_inspect | 14 | 14 | ok |
+| append | 6 | 6 | ok |
+| reverse | 6 | 6 | ok |
+| member | 7 | 7 | ok |
+| nqueens | 6 | 6 | ok |
+| family | 10 | 10 | ok |
+| atoms | 34 | 34 | ok |
+| query_api | 16 | 16 | ok |
+| iso_predicates | 29 | 29 | ok |
+| meta_predicates | 25 | 25 | ok |
+| list_predicates | 33 | 33 | ok |
+| meta_call | 15 | 15 | ok |
+| set_predicates | 15 | 15 | ok |
+| char_predicates | 27 | 27 | ok |
+| io_predicates | 24 | 24 | ok |
+| assert_rules | 15 | 15 | ok |
+| string_agg | 25 | 25 | ok |
+| advanced | 21 | 21 | ok |
+| compiler | 17 | 17 | ok |
+| cross_validate | 17 | 17 | ok |
+| integration | 20 | 20 | ok |
+| hs_bridge | 19 | 19 | ok |
+
+Run `bash lib/prolog/conformance.sh` to refresh. Override the binary
+with `SX_SERVER=path/to/sx_server.exe bash …`.

lib/prolog/tests/advanced.sx

@@ -0,0 +1,254 @@
+;; lib/prolog/tests/advanced.sx — predsort/3, term_variables/2, arith extensions
+
+(define pl-adv-test-count 0)
+(define pl-adv-test-pass 0)
+(define pl-adv-test-fail 0)
+(define pl-adv-test-failures (list))
+
+(define
+  pl-adv-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-adv-test-count (+ pl-adv-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-adv-test-pass (+ pl-adv-test-pass 1))
+        (begin
+          (set! pl-adv-test-fail (+ pl-adv-test-fail 1))
+          (append!
+            pl-adv-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-adv-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-adv-db (pl-mk-db))
+;; Load a numeric comparator for predsort tests
+(pl-db-load!
+  pl-adv-db
+  (pl-parse
+    "cmp_num(Order, X, Y) :- (X < Y -> Order = '<' ; (X > Y -> Order = '>' ; Order = '='))."))
+
+;; ── Arithmetic extensions ──────────────────────────────────────────
+
+(define pl-adv-arith-env-1 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is floor(3.7)" pl-adv-arith-env-1)
+  (pl-mk-trail))
+(pl-adv-test!
+  "floor(3.7) = 3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-1 "X")))
+  3)
+
+(define pl-adv-arith-env-2 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is ceiling(3.2)" pl-adv-arith-env-2)
+  (pl-mk-trail))
+(pl-adv-test!
+  "ceiling(3.2) = 4"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-2 "X")))
+  4)
+
+(define pl-adv-arith-env-3 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is truncate(3.9)" pl-adv-arith-env-3)
+  (pl-mk-trail))
+(pl-adv-test!
+  "truncate(3.9) = 3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-3 "X")))
+  3)
+
+(define pl-adv-arith-env-4 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is truncate(0 - 3.9)" pl-adv-arith-env-4)
+  (pl-mk-trail))
+(pl-adv-test!
+  "truncate(0-3.9) = -3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-4 "X")))
+  -3)
+
+(define pl-adv-arith-env-5 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is round(3.5)" pl-adv-arith-env-5)
+  (pl-mk-trail))
+(pl-adv-test!
+  "round(3.5) = 4"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-5 "X")))
+  4)
+
+(define pl-adv-arith-env-6 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sqrt(4.0)" pl-adv-arith-env-6)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sqrt(4.0) = 2"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-6 "X")))
+  2)
+
+(define pl-adv-arith-env-7 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sign(0 - 5)" pl-adv-arith-env-7)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sign(0-5) = -1"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-7 "X")))
+  -1)
+
+(define pl-adv-arith-env-8 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sign(0)" pl-adv-arith-env-8)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sign(0) = 0"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-8 "X")))
+  0)
+
+(define pl-adv-arith-env-9 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sign(3)" pl-adv-arith-env-9)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sign(3) = 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-9 "X")))
+  1)
+
+(define pl-adv-arith-env-10 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is pow(2, 3)" pl-adv-arith-env-10)
+  (pl-mk-trail))
+(pl-adv-test!
+  "pow(2,3) = 8"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-10 "X")))
+  8)
+
+(define pl-adv-arith-env-11 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is floor(0 - 3.7)" pl-adv-arith-env-11)
+  (pl-mk-trail))
+(pl-adv-test!
+  "floor(0-3.7) = -4"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-11 "X")))
+  -4)
+
+(define pl-adv-arith-env-12 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is ceiling(0 - 3.2)" pl-adv-arith-env-12)
+  (pl-mk-trail))
+(pl-adv-test!
+  "ceiling(0-3.2) = -3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-12 "X")))
+  -3)
+
+;; ── term_variables/2 ──────────────────────────────────────────────
+
+(define pl-adv-tv-env-1 {:Vs (pl-mk-rt-var "Vs")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(hello, Vs)" pl-adv-tv-env-1)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(hello,Vs) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-tv-env-1 "Vs")))
+  "[]")
+
+(define pl-adv-tv-env-2 {:Vs (pl-mk-rt-var "Vs")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(f(a, g(b)), Vs)" pl-adv-tv-env-2)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(f(a,g(b)),Vs) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-tv-env-2 "Vs")))
+  "[]")
+
+(define pl-adv-tv-env-3 {:Y (pl-mk-rt-var "Y") :Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(f(X, Y), Vs)" pl-adv-tv-env-3)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(f(X,Y),Vs) has 2 vars"
+  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-3 "Vs")))
+  2)
+
+(define pl-adv-tv-env-4 {:Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(X, Vs)" pl-adv-tv-env-4)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(X,Vs) has 1 var"
+  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-4 "Vs")))
+  1)
+
+(define pl-adv-tv-env-5 {:Y (pl-mk-rt-var "Y") :Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(foo(X, Y, X), Vs)" pl-adv-tv-env-5)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(foo(X,Y,X),Vs) deduplicates X -> 2 vars"
+  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-5 "Vs")))
+  2)
+
+;; ── predsort/3 ────────────────────────────────────────────────────
+
+(define pl-adv-ps-env-1 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [], R)" pl-adv-ps-env-1)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([]) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-1 "R")))
+  "[]")
+
+(define pl-adv-ps-env-2 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [1], R)" pl-adv-ps-env-2)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([1]) -> [1]"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-2 "R")))
+  ".(1, [])")
+
+(define pl-adv-ps-env-3 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [3,1,2], R)" pl-adv-ps-env-3)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([3,1,2]) -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-3 "R")))
+  ".(1, .(2, .(3, [])))")
+
+(define pl-adv-ps-env-4 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [3,1,2,1,3], R)" pl-adv-ps-env-4)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([3,1,2,1,3]) dedup -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-4 "R")))
+  ".(1, .(2, .(3, [])))")
+
+;; ── Runner ─────────────────────────────────────────────────────────
+
+(define pl-advanced-tests-run! (fn () {:failed pl-adv-test-fail :passed pl-adv-test-pass :total pl-adv-test-count :failures pl-adv-test-failures}))

lib/prolog/tests/assert_rules.sx

@@ -0,0 +1,215 @@
+;; lib/prolog/tests/assert_rules.sx — assert/assertz/asserta with rule terms (head :- body)
+;; Tests that :- is in the op table (prec 1200 xfx) and pl-build-clause handles rule form.
+
+(define pl-ar-test-count 0)
+(define pl-ar-test-pass 0)
+(define pl-ar-test-fail 0)
+(define pl-ar-test-failures (list))
+
+(define
+  pl-ar-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-ar-test-count (+ pl-ar-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-ar-test-pass (+ pl-ar-test-pass 1))
+        (begin
+          (set! pl-ar-test-fail (+ pl-ar-test-fail 1))
+          (append!
+            pl-ar-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-ar-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+;; ── DB1: assertz a simple rule then query ──────────────────────────
+(define pl-ar-db1 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db1
+  (pl-ar-goal "assertz((double(X, Y) :- Y is X * 2))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "assertz rule: double(3, Y) succeeds"
+  (pl-solve-once!
+    pl-ar-db1
+    (pl-ar-goal "double(3, Y)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-ar-env1 {})
+(pl-solve-once!
+  pl-ar-db1
+  (pl-ar-goal "double(3, Y)" pl-ar-env1)
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "assertz rule: double(3, Y) binds Y to 6"
+  (pl-num-val (pl-walk-deep (dict-get pl-ar-env1 "Y")))
+  6)
+
+(define pl-ar-env1b {})
+(pl-solve-once!
+  pl-ar-db1
+  (pl-ar-goal "double(10, Y)" pl-ar-env1b)
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "assertz rule: double(10, Y) yields 20"
+  (pl-num-val (pl-walk-deep (dict-get pl-ar-env1b "Y")))
+  20)
+
+;; ── DB2: assert a rule with multiple facts, count solutions ─────────
+(define pl-ar-db2 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db2
+  (pl-ar-goal "assert(fact(a))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db2
+  (pl-ar-goal "assert(fact(b))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db2
+  (pl-ar-goal "assertz((copy(X) :- fact(X)))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "rule copy/1 using fact/1: 2 solutions"
+  (pl-solve-count! pl-ar-db2 (pl-ar-goal "copy(X)" {}) (pl-mk-trail))
+  2)
+
+(define pl-ar-env2a {})
+(pl-solve-once! pl-ar-db2 (pl-ar-goal "copy(X)" pl-ar-env2a) (pl-mk-trail))
+
+(pl-ar-test!
+  "rule copy/1: first solution is a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ar-env2a "X")))
+  "a")
+
+;; ── DB3: asserta rule is tried before existing clauses ─────────────
+(define pl-ar-db3 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db3
+  (pl-ar-goal "assert(ord(a))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db3
+  (pl-ar-goal "asserta((ord(b) :- true))" {})
+  (pl-mk-trail))
+
+(define pl-ar-env3 {})
+(pl-solve-once! pl-ar-db3 (pl-ar-goal "ord(X)" pl-ar-env3) (pl-mk-trail))
+
+(pl-ar-test!
+  "asserta rule ord(b) is tried before ord(a)"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ar-env3 "X")))
+  "b")
+
+(pl-ar-test!
+  "asserta: total solutions for ord/1 is 2"
+  (pl-solve-count! pl-ar-db3 (pl-ar-goal "ord(X)" {}) (pl-mk-trail))
+  2)
+
+;; ── DB4: rule with conjunction in body ─────────────────────────────
+(define pl-ar-db4 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db4
+  (pl-ar-goal "assert(num(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db4
+  (pl-ar-goal "assert(num(2))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db4
+  (pl-ar-goal "assertz((big(X) :- num(X), X > 1))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "conjunction in rule body: big(1) fails"
+  (pl-solve-once! pl-ar-db4 (pl-ar-goal "big(1)" {}) (pl-mk-trail))
+  false)
+
+(pl-ar-test!
+  "conjunction in rule body: big(2) succeeds"
+  (pl-solve-once! pl-ar-db4 (pl-ar-goal "big(2)" {}) (pl-mk-trail))
+  true)
+
+;; ── DB5: recursive rule ─────────────────────────────────────────────
+(define pl-ar-db5 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db5
+  (pl-ar-goal "assert((nat(0) :- true))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db5
+  (pl-ar-goal "assertz((nat(s(X)) :- nat(X)))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "recursive rule: nat(0) succeeds"
+  (pl-solve-once! pl-ar-db5 (pl-ar-goal "nat(0)" {}) (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "recursive rule: nat(s(0)) succeeds"
+  (pl-solve-once!
+    pl-ar-db5
+    (pl-ar-goal "nat(s(0))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "recursive rule: nat(s(s(0))) succeeds"
+  (pl-solve-once!
+    pl-ar-db5
+    (pl-ar-goal "nat(s(s(0)))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "recursive rule: nat(bad) fails"
+  (pl-solve-once! pl-ar-db5 (pl-ar-goal "nat(bad)" {}) (pl-mk-trail))
+  false)
+
+;; ── DB6: rule with true body (explicit) ────────────────────────────
+(define pl-ar-db6 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db6
+  (pl-ar-goal "assertz((always(X) :- true))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db6
+  (pl-ar-goal "assert(always(extra))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "rule body=true: always(foo) succeeds"
+  (pl-solve-once!
+    pl-ar-db6
+    (pl-ar-goal "always(foo)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "rule body=true: always/1 has 2 clauses (1 rule + 1 fact)"
+  (pl-solve-count!
+    pl-ar-db6
+    (pl-ar-goal "always(X)" {})
+    (pl-mk-trail))
+  2)
+
+;; ── Runner ──────────────────────────────────────────────────────────
+(define pl-assert-rules-tests-run! (fn () {:failed pl-ar-test-fail :passed pl-ar-test-pass :total pl-ar-test-count :failures pl-ar-test-failures}))

lib/prolog/tests/atoms.sx

@@ -0,0 +1,305 @@
+;; lib/prolog/tests/atoms.sx — type predicates + string/atom built-ins
+
+(define pl-at-test-count 0)
+(define pl-at-test-pass 0)
+(define pl-at-test-fail 0)
+(define pl-at-test-failures (list))
+
+(define
+  pl-at-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-at-test-count (+ pl-at-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-at-test-pass (+ pl-at-test-pass 1))
+        (begin
+          (set! pl-at-test-fail (+ pl-at-test-fail 1))
+          (append!
+            pl-at-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-at-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-at-db (pl-mk-db))
+
+;; ── var/1 + nonvar/1 ──
+
+(pl-at-test!
+  "var(X) for unbound var"
+  (pl-solve-once! pl-at-db (pl-at-goal "var(X)" {}) (pl-mk-trail))
+  true)
+(pl-at-test!
+  "var(foo) fails"
+  (pl-solve-once! pl-at-db (pl-at-goal "var(foo)" {}) (pl-mk-trail))
+  false)
+(pl-at-test!
+  "nonvar(foo) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "nonvar(foo)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "nonvar(X) for unbound var fails"
+  (pl-solve-once! pl-at-db (pl-at-goal "nonvar(X)" {}) (pl-mk-trail))
+  false)
+
+;; ── atom/1 ──
+
+(pl-at-test!
+  "atom(foo) succeeds"
+  (pl-solve-once! pl-at-db (pl-at-goal "atom(foo)" {}) (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atom([]) succeeds"
+  (pl-solve-once! pl-at-db (pl-at-goal "atom([])" {}) (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atom(42) fails"
+  (pl-solve-once! pl-at-db (pl-at-goal "atom(42)" {}) (pl-mk-trail))
+  false)
+(pl-at-test!
+  "atom(f(x)) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom(f(x))" {})
+    (pl-mk-trail))
+  false)
+
+;; ── number/1 + integer/1 ──
+
+(pl-at-test!
+  "number(42) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number(42)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "number(foo) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number(foo)" {})
+    (pl-mk-trail))
+  false)
+(pl-at-test!
+  "integer(7) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "integer(7)" {})
+    (pl-mk-trail))
+  true)
+
+;; ── compound/1 + callable/1 + atomic/1 ──
+
+(pl-at-test!
+  "compound(f(x)) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "compound(f(x))" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "compound(foo) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "compound(foo)" {})
+    (pl-mk-trail))
+  false)
+(pl-at-test!
+  "callable(foo) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "callable(foo)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "callable(f(x)) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "callable(f(x))" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "callable(42) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "callable(42)" {})
+    (pl-mk-trail))
+  false)
+(pl-at-test!
+  "atomic(foo) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atomic(foo)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atomic(42) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atomic(42)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atomic(f(x)) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atomic(f(x))" {})
+    (pl-mk-trail))
+  false)
+
+;; ── is_list/1 ──
+
+(pl-at-test!
+  "is_list([]) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "is_list([])" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "is_list([1,2,3]) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "is_list([1,2,3])" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "is_list(foo) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "is_list(foo)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── atom_length/2 ──
+
+(define pl-at-env-al {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_length(hello, N)" pl-at-env-al)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_length(hello, N) -> N=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-at-env-al "N")))
+  5)
+(pl-at-test!
+  "atom_length empty atom"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_length('', 0)" {})
+    (pl-mk-trail))
+  true)
+
+;; ── atom_concat/3 ──
+
+(define pl-at-env-ac {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_concat(foo, bar, X)" pl-at-env-ac)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_concat(foo, bar, X) -> X=foobar"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ac "X")))
+  "foobar")
+
+(pl-at-test!
+  "atom_concat(foo, bar, foobar) check"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_concat(foo, bar, foobar)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atom_concat(foo, bar, foobaz) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_concat(foo, bar, foobaz)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-at-env-ac2 {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_concat(foo, Y, foobar)" pl-at-env-ac2)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_concat(foo, Y, foobar) -> Y=bar"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ac2 "Y")))
+  "bar")
+
+;; ── atom_chars/2 ──
+
+(define pl-at-env-ach {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_chars(cat, Cs)" pl-at-env-ach)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_chars(cat, Cs) -> Cs=[c,a,t]"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_chars(cat, [c,a,t])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-at-env-ach2 {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_chars(A, [h,i])" pl-at-env-ach2)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_chars(A, [h,i]) -> A=hi"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ach2 "A")))
+  "hi")
+
+;; ── char_code/2 ──
+
+(define pl-at-env-cc {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "char_code(a, N)" pl-at-env-cc)
+  (pl-mk-trail))
+(pl-at-test!
+  "char_code(a, N) -> N=97"
+  (pl-num-val (pl-walk-deep (dict-get pl-at-env-cc "N")))
+  97)
+
+(define pl-at-env-cc2 {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "char_code(C, 65)" pl-at-env-cc2)
+  (pl-mk-trail))
+(pl-at-test!
+  "char_code(C, 65) -> C='A'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-cc2 "C")))
+  "A")
+
+;; ── number_codes/2 ──
+
+(pl-at-test!
+  "number_codes(42, [52,50])"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number_codes(42, [52,50])" {})
+    (pl-mk-trail))
+  true)
+
+;; ── number_chars/2 ──
+
+(pl-at-test!
+  "number_chars(42, ['4','2'])"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number_chars(42, ['4','2'])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-atom-tests-run! (fn () {:failed pl-at-test-fail :passed pl-at-test-pass :total pl-at-test-count :failures pl-at-test-failures}))

lib/prolog/tests/char_predicates.sx

@@ -0,0 +1,290 @@
+;; lib/prolog/tests/char_predicates.sx — char_type/2, upcase_atom/2, downcase_atom/2,
+;;   string_upper/2, string_lower/2
+
+(define pl-cp-test-count 0)
+(define pl-cp-test-pass 0)
+(define pl-cp-test-fail 0)
+(define pl-cp-test-failures (list))
+
+(define
+  pl-cp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-cp-test-count (+ pl-cp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-cp-test-pass (+ pl-cp-test-pass 1))
+        (begin
+          (set! pl-cp-test-fail (+ pl-cp-test-fail 1))
+          (append!
+            pl-cp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-cp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-cp-db (pl-mk-db))
+
+;; ─── char_type/2 — alpha ──────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type(a, alpha) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, alpha)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type('1', alpha) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('1', alpha)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-cp-test!
+  "char_type('A', alpha) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('A', alpha)" {})
+    (pl-mk-trail))
+  true)
+
+;; ─── char_type/2 — alnum ─────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type('5', alnum) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('5', alnum)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, alnum) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, alnum)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(' ', alnum) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(' ', alnum)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — digit ─────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type('5', digit) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('5', digit)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, digit) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, digit)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — digit(Weight) ─────────────────────────────────
+
+(define pl-cp-env-dw {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type('5', digit(N))" pl-cp-env-dw)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type('5', digit(N)) -> N=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-dw "N")))
+  5)
+
+(define pl-cp-env-dw0 {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type('0', digit(N))" pl-cp-env-dw0)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type('0', digit(N)) -> N=0"
+  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-dw0 "N")))
+  0)
+
+;; ─── char_type/2 — space/white ───────────────────────────────────
+
+(pl-cp-test!
+  "char_type(' ', space) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(' ', space)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, space) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, space)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — upper(Lower) ──────────────────────────────────
+
+(define pl-cp-env-ul {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type('A', upper(L))" pl-cp-env-ul)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type('A', upper(L)) -> L=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-ul "L")))
+  "a")
+
+(pl-cp-test!
+  "char_type(a, upper(L)) fails — not uppercase"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, upper(_))" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — lower(Upper) ──────────────────────────────────
+
+(define pl-cp-env-lu {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type(a, lower(U))" pl-cp-env-lu)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type(a, lower(U)) -> U='A'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-lu "U")))
+  "A")
+
+;; ─── char_type/2 — ascii(Code) ───────────────────────────────────
+
+(define pl-cp-env-as {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type(a, ascii(C))" pl-cp-env-as)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type(a, ascii(C)) -> C=97"
+  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-as "C")))
+  97)
+
+;; ─── char_type/2 — punct ─────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type('.', punct) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('.', punct)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, punct) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, punct)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── upcase_atom/2 ───────────────────────────────────────────────
+
+(define pl-cp-env-ua {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "upcase_atom(hello, X)" pl-cp-env-ua)
+  (pl-mk-trail))
+(pl-cp-test!
+  "upcase_atom(hello, X) -> X='HELLO'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-ua "X")))
+  "HELLO")
+
+(pl-cp-test!
+  "upcase_atom(hello, 'HELLO') succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "upcase_atom(hello, 'HELLO')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "upcase_atom('Hello World', 'HELLO WORLD') succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "upcase_atom('Hello World', 'HELLO WORLD')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "upcase_atom('', '') succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "upcase_atom('', '')" {})
+    (pl-mk-trail))
+  true)
+
+;; ─── downcase_atom/2 ─────────────────────────────────────────────
+
+(define pl-cp-env-da {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "downcase_atom('HELLO', X)" pl-cp-env-da)
+  (pl-mk-trail))
+(pl-cp-test!
+  "downcase_atom('HELLO', X) -> X=hello"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-da "X")))
+  "hello")
+
+(pl-cp-test!
+  "downcase_atom('HELLO', hello) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "downcase_atom('HELLO', hello)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "downcase_atom(hello, hello) succeeds — already lowercase"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "downcase_atom(hello, hello)" {})
+    (pl-mk-trail))
+  true)
+
+;; ─── string_upper/2 + string_lower/2 (aliases) ───────────────────
+
+(define pl-cp-env-su {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "string_upper(hello, X)" pl-cp-env-su)
+  (pl-mk-trail))
+(pl-cp-test!
+  "string_upper(hello, X) -> X='HELLO'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-su "X")))
+  "HELLO")
+
+(define pl-cp-env-sl {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "string_lower('WORLD', X)" pl-cp-env-sl)
+  (pl-mk-trail))
+(pl-cp-test!
+  "string_lower('WORLD', X) -> X=world"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-sl "X")))
+  "world")
+
+(define pl-char-predicates-tests-run! (fn () {:failed pl-cp-test-fail :passed pl-cp-test-pass :total pl-cp-test-count :failures pl-cp-test-failures}))

lib/prolog/tests/clausedb.sx

@@ -0,0 +1,99 @@
+;; lib/prolog/tests/clausedb.sx — Clause DB unit tests
+
+(define pl-db-test-count 0)
+(define pl-db-test-pass 0)
+(define pl-db-test-fail 0)
+(define pl-db-test-failures (list))
+
+(define
+  pl-db-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-db-test-count (+ pl-db-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-db-test-pass (+ pl-db-test-pass 1))
+        (begin
+          (set! pl-db-test-fail (+ pl-db-test-fail 1))
+          (append!
+            pl-db-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(pl-db-test!
+  "head-key atom arity 0"
+  (pl-head-key (nth (first (pl-parse "foo.")) 1))
+  "foo/0")
+
+(pl-db-test!
+  "head-key compound arity 2"
+  (pl-head-key (nth (first (pl-parse "bar(a, b).")) 1))
+  "bar/2")
+
+(pl-db-test!
+  "clause-key of :- clause"
+  (pl-clause-key (first (pl-parse "likes(mary, X) :- friendly(X).")))
+  "likes/2")
+
+(pl-db-test!
+  "empty db lookup returns empty list"
+  (len (pl-db-lookup (pl-mk-db) "parent/2"))
+  0)
+
+(define pl-db-t1 (pl-mk-db))
+(pl-db-load! pl-db-t1 (pl-parse "foo(a). foo(b). foo(c)."))
+
+(pl-db-test!
+  "three facts same functor"
+  (len (pl-db-lookup pl-db-t1 "foo/1"))
+  3)
+(pl-db-test!
+  "mismatching key returns empty"
+  (len (pl-db-lookup pl-db-t1 "foo/2"))
+  0)
+
+(pl-db-test!
+  "first clause has arg a"
+  (pl-atom-name
+    (first (pl-args (nth (first (pl-db-lookup pl-db-t1 "foo/1")) 1))))
+  "a")
+
+(pl-db-test!
+  "third clause has arg c"
+  (pl-atom-name
+    (first (pl-args (nth (nth (pl-db-lookup pl-db-t1 "foo/1") 2) 1))))
+  "c")
+
+(define pl-db-t2 (pl-mk-db))
+(pl-db-load! pl-db-t2 (pl-parse "foo. bar. foo. parent(a, b). parent(c, d)."))
+
+(pl-db-test!
+  "atom heads keyed as foo/0"
+  (len (pl-db-lookup pl-db-t2 "foo/0"))
+  2)
+(pl-db-test!
+  "atom heads keyed as bar/0"
+  (len (pl-db-lookup pl-db-t2 "bar/0"))
+  1)
+(pl-db-test!
+  "compound heads keyed as parent/2"
+  (len (pl-db-lookup pl-db-t2 "parent/2"))
+  2)
+
+(pl-db-test!
+  "lookup-goal extracts functor/arity"
+  (len
+    (pl-db-lookup-goal pl-db-t2 (nth (first (pl-parse "parent(X, Y).")) 1)))
+  2)
+
+(pl-db-test!
+  "lookup-goal on atom goal"
+  (len (pl-db-lookup-goal pl-db-t2 (nth (first (pl-parse "foo.")) 1)))
+  2)
+
+(pl-db-test!
+  "stored clause is clause form"
+  (first (first (pl-db-lookup pl-db-t2 "parent/2")))
+  "clause")
+
+(define pl-clausedb-tests-run! (fn () {:failed pl-db-test-fail :passed pl-db-test-pass :total pl-db-test-count :failures pl-db-test-failures}))

lib/prolog/tests/compiler.sx

@@ -0,0 +1,185 @@
+;; lib/prolog/tests/compiler.sx — compiled clause dispatch tests
+
+(define pl-cmp-test-count 0)
+(define pl-cmp-test-pass 0)
+(define pl-cmp-test-fail 0)
+(define pl-cmp-test-failures (list))
+
+(define
+  pl-cmp-test!
+  (fn
+    (name got expected)
+    (set! pl-cmp-test-count (+ pl-cmp-test-count 1))
+    (if
+      (= got expected)
+      (set! pl-cmp-test-pass (+ pl-cmp-test-pass 1))
+      (begin
+        (set! pl-cmp-test-fail (+ pl-cmp-test-fail 1))
+        (append! pl-cmp-test-failures name)))))
+
+;; Load src, compile, return DB.
+(define
+  pl-cmp-mk
+  (fn
+    (src)
+    (let
+      ((db (pl-mk-db)))
+      (pl-db-load! db (pl-parse src))
+      (pl-compile-db! db)
+      db)))
+
+;; Run goal string against compiled DB; return bool (instantiates vars).
+(define
+  pl-cmp-once
+  (fn
+    (db src)
+    (pl-solve-once!
+      db
+      (pl-instantiate (pl-parse-goal src) {})
+      (pl-mk-trail))))
+
+;; Count solutions for goal string against compiled DB.
+(define
+  pl-cmp-count
+  (fn
+    (db src)
+    (pl-solve-count!
+      db
+      (pl-instantiate (pl-parse-goal src) {})
+      (pl-mk-trail))))
+
+;; ── 1. Simple facts ──────────────────────────────────────────────
+
+(define pl-cmp-db1 (pl-cmp-mk "color(red). color(green). color(blue)."))
+
+(pl-cmp-test! "compiled fact hit" (pl-cmp-once pl-cmp-db1 "color(red)") true)
+(pl-cmp-test!
+  "compiled fact miss"
+  (pl-cmp-once pl-cmp-db1 "color(yellow)")
+  false)
+(pl-cmp-test! "compiled fact count" (pl-cmp-count pl-cmp-db1 "color(X)") 3)
+
+;; ── 2. Recursive rule: append ────────────────────────────────────
+
+(define
+  pl-cmp-db2
+  (pl-cmp-mk "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R)."))
+
+(pl-cmp-test!
+  "compiled append build"
+  (pl-cmp-once pl-cmp-db2 "append([1,2],[3],[1,2,3])")
+  true)
+(pl-cmp-test!
+  "compiled append fail"
+  (pl-cmp-once pl-cmp-db2 "append([1,2],[3],[1,2])")
+  false)
+(pl-cmp-test!
+  "compiled append split count"
+  (pl-cmp-count pl-cmp-db2 "append(X, Y, [a,b])")
+  3)
+
+;; ── 3. Cut ───────────────────────────────────────────────────────
+
+(define
+  pl-cmp-db3
+  (pl-cmp-mk "first(X, [X|_]) :- !. first(X, [_|T]) :- first(X, T)."))
+
+(pl-cmp-test!
+  "compiled cut: only one solution"
+  (pl-cmp-count pl-cmp-db3 "first(X, [a,b,c])")
+  1)
+
+(let
+  ((db pl-cmp-db3) (trail (pl-mk-trail)) (env {}))
+  (let
+    ((x (pl-mk-rt-var "X")))
+    (dict-set! env "X" x)
+    (pl-solve-once!
+      db
+      (pl-instantiate (pl-parse-goal "first(X, [a,b,c])") env)
+      trail)
+    (pl-cmp-test!
+      "compiled cut: correct binding"
+      (pl-atom-name (pl-walk x))
+      "a")))
+
+;; ── 4. member ────────────────────────────────────────────────────
+
+(define
+  pl-cmp-db4
+  (pl-cmp-mk "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
+
+(pl-cmp-test!
+  "compiled member hit"
+  (pl-cmp-once pl-cmp-db4 "member(b, [a,b,c])")
+  true)
+(pl-cmp-test!
+  "compiled member miss"
+  (pl-cmp-once pl-cmp-db4 "member(d, [a,b,c])")
+  false)
+(pl-cmp-test!
+  "compiled member count"
+  (pl-cmp-count pl-cmp-db4 "member(X, [a,b,c])")
+  3)
+
+;; ── 5. Arithmetic in body ────────────────────────────────────────
+
+(define pl-cmp-db5 (pl-cmp-mk "double(X, Y) :- Y is X * 2."))
+
+(let
+  ((db pl-cmp-db5) (trail (pl-mk-trail)) (env {}))
+  (let
+    ((y (pl-mk-rt-var "Y")))
+    (dict-set! env "Y" y)
+    (pl-solve-once!
+      db
+      (pl-instantiate (pl-parse-goal "double(5, Y)") env)
+      trail)
+    (pl-cmp-test! "compiled arithmetic in body" (pl-num-val (pl-walk y)) 10)))
+
+;; ── 6. Transitive ancestor ───────────────────────────────────────
+
+(define
+  pl-cmp-db6
+  (pl-cmp-mk
+    (str
+      "parent(a,b). parent(b,c). parent(c,d)."
+      "ancestor(X,Y) :- parent(X,Y)."
+      "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y).")))
+
+(pl-cmp-test!
+  "compiled ancestor direct"
+  (pl-cmp-once pl-cmp-db6 "ancestor(a,b)")
+  true)
+(pl-cmp-test!
+  "compiled ancestor 3-step"
+  (pl-cmp-once pl-cmp-db6 "ancestor(a,d)")
+  true)
+(pl-cmp-test!
+  "compiled ancestor fail"
+  (pl-cmp-once pl-cmp-db6 "ancestor(d,a)")
+  false)
+
+;; ── 7. Fallback: uncompiled predicate calls compiled sub-predicate
+
+(define
+  pl-cmp-db7
+  (let
+    ((db (pl-mk-db)))
+    (pl-db-load! db (pl-parse "q(1). q(2)."))
+    (pl-compile-db! db)
+    (pl-db-load! db (pl-parse "r(X) :- q(X)."))
+    db))
+
+(pl-cmp-test!
+  "uncompiled predicate resolves"
+  (pl-cmp-once pl-cmp-db7 "r(1)")
+  true)
+(pl-cmp-test!
+  "uncompiled calls compiled sub-pred count"
+  (pl-cmp-count pl-cmp-db7 "r(X)")
+  2)
+
+;; ── Runner ───────────────────────────────────────────────────────
+
+(define pl-compiler-tests-run! (fn () {:failed pl-cmp-test-fail :passed pl-cmp-test-pass :total pl-cmp-test-count :failures pl-cmp-test-failures}))

lib/prolog/tests/cross_validate.sx

@@ -0,0 +1,86 @@
+;; lib/prolog/tests/cross_validate.sx
+;; Verifies that the compiled solver produces the same solution counts as the
+;; interpreter for each classic program + built-in exercise.
+;; Interpreter is the reference: if they disagree, the compiler is wrong.
+
+(define pl-xv-test-count 0)
+(define pl-xv-test-pass 0)
+(define pl-xv-test-fail 0)
+(define pl-xv-test-failures (list))
+
+(define
+  pl-xv-test!
+  (fn
+    (name got expected)
+    (set! pl-xv-test-count (+ pl-xv-test-count 1))
+    (if
+      (= got expected)
+      (set! pl-xv-test-pass (+ pl-xv-test-pass 1))
+      (begin
+        (set! pl-xv-test-fail (+ pl-xv-test-fail 1))
+        (append! pl-xv-test-failures name)))))
+
+;; Shorthand: assert compiled result matches interpreter.
+(define
+  pl-xv-match!
+  (fn
+    (name src goal)
+    (pl-xv-test! name (pl-compiled-matches-interp? src goal) true)))
+
+;; ── 1. append/3 ─────────────────────────────────────────────────
+
+(define
+  pl-xv-append
+  "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
+
+(pl-xv-match! "append build 2+2" pl-xv-append "append([1,2],[3,4],X)")
+(pl-xv-match! "append split [a,b,c]" pl-xv-append "append(X, Y, [a,b,c])")
+(pl-xv-match! "append member-mode" pl-xv-append "append(_, [3], [1,2,3])")
+
+;; ── 2. member/2 ─────────────────────────────────────────────────
+
+(define pl-xv-member "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
+
+(pl-xv-match! "member check hit" pl-xv-member "member(b, [a,b,c])")
+(pl-xv-match! "member count" pl-xv-member "member(X, [a,b,c])")
+(pl-xv-match! "member empty" pl-xv-member "member(X, [])")
+
+;; ── 3. facts + transitive rules ─────────────────────────────────
+
+(define
+  pl-xv-ancestor
+  (str
+    "parent(a,b). parent(b,c). parent(c,d). parent(a,c)."
+    "ancestor(X,Y) :- parent(X,Y)."
+    "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y)."))
+
+(pl-xv-match! "ancestor direct" pl-xv-ancestor "ancestor(a,b)")
+(pl-xv-match! "ancestor transitive" pl-xv-ancestor "ancestor(a,d)")
+(pl-xv-match! "ancestor all from a" pl-xv-ancestor "ancestor(a,Y)")
+
+;; ── 4. cut semantics ────────────────────────────────────────────
+
+(define pl-xv-cut "first(X,[X|_]) :- !. first(X,[_|T]) :- first(X,T).")
+
+(pl-xv-match! "cut one solution" pl-xv-cut "first(X,[a,b,c])")
+(pl-xv-match! "cut empty list" pl-xv-cut "first(X,[])")
+
+;; ── 5. arithmetic ───────────────────────────────────────────────
+
+(define pl-xv-arith "sq(X,Y) :- Y is X * X. even(X) :- 0 is X mod 2.")
+
+(pl-xv-match! "sq(3,Y) count" pl-xv-arith "sq(3,Y)")
+(pl-xv-match! "sq(3,9) check" pl-xv-arith "sq(3,9)")
+(pl-xv-match! "even(4) check" pl-xv-arith "even(4)")
+(pl-xv-match! "even(3) check" pl-xv-arith "even(3)")
+
+;; ── 6. if-then-else ─────────────────────────────────────────────
+
+(define pl-xv-ite "classify(X, pos) :- X > 0, !. classify(_, nonpos).")
+
+(pl-xv-match! "classify positive" pl-xv-ite "classify(5, C)")
+(pl-xv-match! "classify zero" pl-xv-ite "classify(0, C)")
+
+;; ── Runner ───────────────────────────────────────────────────────
+
+(define pl-cross-validate-tests-run! (fn () {:failed pl-xv-test-fail :passed pl-xv-test-pass :total pl-xv-test-count :failures pl-xv-test-failures}))

lib/prolog/tests/dynamic.sx

@@ -0,0 +1,158 @@
+;; lib/prolog/tests/dynamic.sx — assert/asserta/assertz/retract.
+
+(define pl-dy-test-count 0)
+(define pl-dy-test-pass 0)
+(define pl-dy-test-fail 0)
+(define pl-dy-test-failures (list))
+
+(define
+  pl-dy-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-dy-test-count (+ pl-dy-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-dy-test-pass (+ pl-dy-test-pass 1))
+        (begin
+          (set! pl-dy-test-fail (+ pl-dy-test-fail 1))
+          (append!
+            pl-dy-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-dy-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+;; assertz then query
+(define pl-dy-db1 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db1
+  (pl-dy-goal "assertz(foo(1))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "assertz(foo(1)) + foo(1)"
+  (pl-solve-once! pl-dy-db1 (pl-dy-goal "foo(1)" {}) (pl-mk-trail))
+  true)
+
+(pl-dy-test!
+  "after one assertz, foo/1 has 1 clause"
+  (pl-solve-count! pl-dy-db1 (pl-dy-goal "foo(X)" {}) (pl-mk-trail))
+  1)
+
+;; assertz appends — order preserved
+(define pl-dy-db2 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db2
+  (pl-dy-goal "assertz(p(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db2
+  (pl-dy-goal "assertz(p(2))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "assertz twice — count 2"
+  (pl-solve-count! pl-dy-db2 (pl-dy-goal "p(X)" {}) (pl-mk-trail))
+  2)
+
+(define pl-dy-env-a {})
+(pl-solve-once! pl-dy-db2 (pl-dy-goal "p(X)" pl-dy-env-a) (pl-mk-trail))
+(pl-dy-test!
+  "assertz: first solution is the first asserted (1)"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-a "X")))
+  1)
+
+;; asserta prepends
+(define pl-dy-db3 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db3
+  (pl-dy-goal "assertz(p(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db3
+  (pl-dy-goal "asserta(p(99))" {})
+  (pl-mk-trail))
+(define pl-dy-env-b {})
+(pl-solve-once! pl-dy-db3 (pl-dy-goal "p(X)" pl-dy-env-b) (pl-mk-trail))
+(pl-dy-test!
+  "asserta: prepended clause is first solution"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-b "X")))
+  99)
+
+;; assert/1 = assertz/1
+(define pl-dy-db4 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db4
+  (pl-dy-goal "assert(g(7))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "assert/1 alias"
+  (pl-solve-once! pl-dy-db4 (pl-dy-goal "g(7)" {}) (pl-mk-trail))
+  true)
+
+;; retract removes a fact
+(define pl-dy-db5 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "assertz(q(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "assertz(q(2))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "assertz(q(3))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "before retract: 3 clauses"
+  (pl-solve-count! pl-dy-db5 (pl-dy-goal "q(X)" {}) (pl-mk-trail))
+  3)
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "retract(q(2))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "after retract(q(2)): 2 clauses left"
+  (pl-solve-count! pl-dy-db5 (pl-dy-goal "q(X)" {}) (pl-mk-trail))
+  2)
+
+(define pl-dy-env-c {})
+(pl-solve-once! pl-dy-db5 (pl-dy-goal "q(X)" pl-dy-env-c) (pl-mk-trail))
+(pl-dy-test!
+  "after retract(q(2)): first remaining is 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-c "X")))
+  1)
+
+;; retract of non-existent
+(pl-dy-test!
+  "retract(missing(0)) on empty db fails"
+  (pl-solve-once!
+    (pl-mk-db)
+    (pl-dy-goal "retract(missing(0))" {})
+    (pl-mk-trail))
+  false)
+
+;; retract with unbound var matches first
+(define pl-dy-db6 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db6
+  (pl-dy-goal "assertz(r(11))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db6
+  (pl-dy-goal "assertz(r(22))" {})
+  (pl-mk-trail))
+(define pl-dy-env-d {})
+(pl-solve-once!
+  pl-dy-db6
+  (pl-dy-goal "retract(r(X))" pl-dy-env-d)
+  (pl-mk-trail))
+(pl-dy-test!
+  "retract(r(X)) binds X to first match"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-d "X")))
+  11)
+
+(define pl-dynamic-tests-run! (fn () {:failed pl-dy-test-fail :passed pl-dy-test-pass :total pl-dy-test-count :failures pl-dy-test-failures}))

lib/prolog/tests/findall.sx

@@ -0,0 +1,167 @@
+;; lib/prolog/tests/findall.sx — findall/3, bagof/3, setof/3.
+
+(define pl-fb-test-count 0)
+(define pl-fb-test-pass 0)
+(define pl-fb-test-fail 0)
+(define pl-fb-test-failures (list))
+
+(define
+  pl-fb-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-fb-test-count (+ pl-fb-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-fb-test-pass (+ pl-fb-test-pass 1))
+        (begin
+          (set! pl-fb-test-fail (+ pl-fb-test-fail 1))
+          (append!
+            pl-fb-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-fb-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (true (list :complex)))))
+
+(define
+  pl-fb-list-walked
+  (fn
+    (w)
+    (cond
+      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+        (cons
+          (pl-fb-term-to-sx (first (pl-args w)))
+          (pl-fb-list-walked (nth (pl-args w) 1))))
+      (true (list :not-list)))))
+
+(define pl-fb-list-to-sx (fn (t) (pl-fb-list-walked (pl-walk-deep t))))
+
+(define
+  pl-fb-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-fb-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
+
+(define pl-fb-db (pl-mk-db))
+(pl-db-load! pl-fb-db (pl-parse pl-fb-prog-src))
+
+;; ── findall ──
+
+(define pl-fb-env-1 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "findall(X, member(X, [a, b, c]), L)" pl-fb-env-1)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall member [a, b, c]"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-1 "L"))
+  (list "a" "b" "c"))
+
+(define pl-fb-env-2 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "findall(X, (member(X, [1, 2, 3]), X >= 2), L)" pl-fb-env-2)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall with comparison filter"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-2 "L"))
+  (list 2 3))
+
+(define pl-fb-env-3 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "findall(X, fail, L)" pl-fb-env-3)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall on fail succeeds with empty list"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-3 "L"))
+  (list))
+
+(pl-fb-test!
+  "findall(X, fail, L) the goal succeeds"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "findall(X, fail, L)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-fb-env-4 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal
+    "findall(p(X, Y), (member(X, [1, 2]), member(Y, [a, b])), L)"
+    pl-fb-env-4)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall over compound template — count = 4"
+  (len (pl-fb-list-to-sx (dict-get pl-fb-env-4 "L")))
+  4)
+
+;; ── bagof ──
+
+(pl-fb-test!
+  "bagof succeeds when results exist"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "bagof(X, member(X, [1, 2, 3]), L)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-fb-test!
+  "bagof fails on empty"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "bagof(X, fail, L)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-fb-env-5 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "bagof(X, member(X, [c, a, b]), L)" pl-fb-env-5)
+  (pl-mk-trail))
+(pl-fb-test!
+  "bagof preserves order"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-5 "L"))
+  (list "c" "a" "b"))
+
+;; ── setof ──
+
+(define pl-fb-env-6 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "setof(X, member(X, [c, a, b, a, c]), L)" pl-fb-env-6)
+  (pl-mk-trail))
+(pl-fb-test!
+  "setof sorts + dedupes atoms"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-6 "L"))
+  (list "a" "b" "c"))
+
+(pl-fb-test!
+  "setof fails on empty"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "setof(X, fail, L)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-fb-env-7 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "setof(X, member(X, [3, 1, 2, 1, 3]), L)" pl-fb-env-7)
+  (pl-mk-trail))
+(pl-fb-test!
+  "setof sorts + dedupes nums"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-7 "L"))
+  (list 1 2 3))
+
+(define pl-findall-tests-run! (fn () {:failed pl-fb-test-fail :passed pl-fb-test-pass :total pl-fb-test-count :failures pl-fb-test-failures}))

lib/prolog/tests/hs_bridge.sx

@@ -0,0 +1,165 @@
+;; lib/prolog/tests/hs_bridge.sx — tests for Prolog↔Hyperscript bridge
+;;
+;; Verifies pl-hs-query, pl-hs-predicate/N, and pl-hs-install.
+;; Also demonstrates the end-to-end DSL pattern:
+;;   (define allowed (pl-hs-predicate/2 db "allowed"))
+;;   → (allowed "alice" "edit") is what Hyperscript compiles
+;;     `when allowed(alice, edit)` to.
+
+(define pl-hsb-test-count 0)
+(define pl-hsb-test-pass 0)
+(define pl-hsb-test-fail 0)
+(define pl-hsb-test-failures (list))
+
+(define
+  pl-hsb-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-hsb-test-count (+ pl-hsb-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-hsb-test-pass (+ pl-hsb-test-pass 1))
+        (begin
+          (set! pl-hsb-test-fail (+ pl-hsb-test-fail 1))
+          (append!
+            pl-hsb-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+;; ── shared KB ──
+
+(define
+  pl-hsb-perm-src
+  "role(alice, admin). role(bob, editor). role(charlie, viewer). permission(admin, read). permission(admin, write). permission(admin, delete). permission(editor, read). permission(editor, write). permission(viewer, read). allowed(U, A) :- role(U, R), permission(R, A).")
+
+(define pl-hsb-db (pl-load pl-hsb-perm-src))
+
+;; ── pl-hs-query ──
+
+(pl-hsb-test!
+  "pl-hs-query: ground fact succeeds"
+  (pl-hs-query pl-hsb-db "role(alice, admin)")
+  true)
+
+(pl-hsb-test!
+  "pl-hs-query: absent fact fails"
+  (pl-hs-query pl-hsb-db "role(alice, viewer)")
+  false)
+
+(pl-hsb-test!
+  "pl-hs-query: rule derivation succeeds"
+  (pl-hs-query pl-hsb-db "allowed(alice, delete)")
+  true)
+
+(pl-hsb-test!
+  "pl-hs-query: rule derivation fails"
+  (pl-hs-query pl-hsb-db "allowed(charlie, delete)")
+  false)
+
+(pl-hsb-test!
+  "pl-hs-query: arithmetic goal"
+  (pl-hs-query pl-hsb-db "X is 3 + 4, X = 7")
+  true)
+
+;; ── pl-hs-predicate/2 ──
+
+(define pl-hsb-allowed (pl-hs-predicate/2 pl-hsb-db "allowed"))
+
+(pl-hsb-test!
+  "predicate/2: alice can read"
+  (pl-hsb-allowed "alice" "read")
+  true)
+
+(pl-hsb-test!
+  "predicate/2: alice can delete"
+  (pl-hsb-allowed "alice" "delete")
+  true)
+
+(pl-hsb-test!
+  "predicate/2: charlie cannot write"
+  (pl-hsb-allowed "charlie" "write")
+  false)
+
+(pl-hsb-test!
+  "predicate/2: bob can write"
+  (pl-hsb-allowed "bob" "write")
+  true)
+
+(pl-hsb-test!
+  "predicate/2: unknown user fails"
+  (pl-hsb-allowed "eve" "read")
+  false)
+
+;; ── DSL simulation ──
+;; Hyperscript compiles `when allowed(user, action) then …`
+;; to `(allowed user action)` — a direct SX function call.
+;; Here we verify that pattern works end-to-end.
+
+(define pl-hsb-user "alice")
+(define pl-hsb-action "write")
+
+(pl-hsb-test!
+  "DSL simulation: (allowed user action) true path"
+  (pl-hsb-allowed pl-hsb-user pl-hsb-action)
+  true)
+
+(define pl-hsb-user2 "charlie")
+
+(pl-hsb-test!
+  "DSL simulation: (allowed user action) false path"
+  (pl-hsb-allowed pl-hsb-user2 pl-hsb-action)
+  false)
+
+;; ── pl-hs-predicate/1 ──
+
+(define pl-hsb-viewer-src "color(red). color(green). color(blue).")
+(define pl-hsb-color-db (pl-load pl-hsb-viewer-src))
+(define pl-hsb-color? (pl-hs-predicate/1 pl-hsb-color-db "color"))
+
+(pl-hsb-test! "predicate/1: color(red) succeeds" (pl-hsb-color? "red") true)
+
+(pl-hsb-test!
+  "predicate/1: color(purple) fails"
+  (pl-hsb-color? "purple")
+  false)
+
+;; ── pl-hs-predicate/3 ──
+
+(define pl-hsb-3ary-src "between_vals(X, Lo, Hi) :- X >= Lo, X =< Hi.")
+(define pl-hsb-3ary-db (pl-load pl-hsb-3ary-src))
+(define pl-hsb-in-range? (pl-hs-predicate/3 pl-hsb-3ary-db "between_vals"))
+
+(pl-hsb-test!
+  "predicate/3: 5 in range [1,10]"
+  (pl-hsb-in-range? "5" "1" "10")
+  true)
+
+(pl-hsb-test!
+  "predicate/3: 15 not in range [1,10]"
+  (pl-hsb-in-range? "15" "1" "10")
+  false)
+
+;; ── pl-hs-install ──
+
+(define
+  pl-hsb-installed
+  (pl-hs-install
+    pl-hsb-db
+    (list (list "allowed" 2) (list "role" 2) (list "permission" 2))))
+
+(pl-hsb-test!
+  "pl-hs-install: returns dict with allowed key"
+  (not (nil? (dict-get pl-hsb-installed "allowed")))
+  true)
+
+(pl-hsb-test!
+  "pl-hs-install: installed allowed fn works"
+  ((dict-get pl-hsb-installed "allowed") "alice" "delete")
+  true)
+
+(pl-hsb-test!
+  "pl-hs-install: installed role fn works"
+  ((dict-get pl-hsb-installed "role") "bob" "editor")
+  true)
+
+(define pl-hs-bridge-tests-run! (fn () {:failed pl-hsb-test-fail :passed pl-hsb-test-pass :total pl-hsb-test-count :failures pl-hsb-test-failures}))

lib/prolog/tests/integration.sx

@@ -0,0 +1,172 @@
+;; lib/prolog/tests/integration.sx — end-to-end integration tests via pl-query-* API
+;;
+;; Tests the full source→parse→load→solve pipeline with real programs.
+;; Covers: permission system, graph reachability, quicksort, fibonacci, dynamic KB.
+
+(define pl-int-test-count 0)
+(define pl-int-test-pass 0)
+(define pl-int-test-fail 0)
+(define pl-int-test-failures (list))
+
+(define
+  pl-int-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-int-test-count (+ pl-int-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-int-test-pass (+ pl-int-test-pass 1))
+        (begin
+          (set! pl-int-test-fail (+ pl-int-test-fail 1))
+          (append!
+            pl-int-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+;; ── Permission system ──
+;; role/2 + permission/2 facts, allowed/2 rule
+
+(define
+  pl-int-perm-src
+  "role(alice, admin). role(bob, editor). role(charlie, viewer). permission(admin, read). permission(admin, write). permission(admin, delete). permission(editor, read). permission(editor, write). permission(viewer, read). allowed(U, A) :- role(U, R), permission(R, A).")
+
+(define pl-int-perm-db (pl-load pl-int-perm-src))
+
+(pl-int-test!
+  "alice can read"
+  (len (pl-query-all pl-int-perm-db "allowed(alice, read)"))
+  1)
+
+(pl-int-test!
+  "alice can delete"
+  (len (pl-query-all pl-int-perm-db "allowed(alice, delete)"))
+  1)
+
+(pl-int-test!
+  "charlie cannot write"
+  (len (pl-query-all pl-int-perm-db "allowed(charlie, write)"))
+  0)
+
+(pl-int-test!
+  "alice has 3 permissions"
+  (len (pl-query-all pl-int-perm-db "allowed(alice, A)"))
+  3)
+
+(pl-int-test!
+  "only one user can delete"
+  (len (pl-query-all pl-int-perm-db "allowed(U, delete)"))
+  1)
+
+(pl-int-test!
+  "the deleter is alice"
+  (dict-get (first (pl-query-all pl-int-perm-db "allowed(U, delete)")) "U")
+  "alice")
+
+;; ── Graph reachability ──
+;; Directed edges; path/2 transitive closure via two clauses
+
+(define
+  pl-int-graph-src
+  "edge(a, b). edge(b, c). edge(c, d). edge(b, d). path(X, Y) :- edge(X, Y). path(X, Y) :- edge(X, Z), path(Z, Y).")
+
+(define pl-int-graph-db (pl-load pl-int-graph-src))
+
+(pl-int-test!
+  "direct edge a→b is a path"
+  (len (pl-query-all pl-int-graph-db "path(a, b)"))
+  1)
+
+(pl-int-test!
+  "transitive path a→c"
+  (len (pl-query-all pl-int-graph-db "path(a, c)"))
+  1)
+
+(pl-int-test!
+  "no path d→a (no back-edges)"
+  (len (pl-query-all pl-int-graph-db "path(d, a)"))
+  0)
+
+(pl-int-test!
+  "4 derivations from a (b,c,d via two routes to d)"
+  (len (pl-query-all pl-int-graph-db "path(a, Y)"))
+  4)
+
+;; ── Quicksort ──
+;; Partition-and-recurse; uses its own append/3 to avoid DB pollution
+
+(define
+  pl-int-qs-src
+  "partition(_, [], [], []). partition(Piv, [H|T], [H|Less], Greater) :- H =< Piv, !, partition(Piv, T, Less, Greater). partition(Piv, [H|T], Less, [H|Greater]) :- partition(Piv, T, Less, Greater). append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R). quicksort([], []). quicksort([H|T], Sorted) :- partition(H, T, Less, Greater), quicksort(Less, SL), quicksort(Greater, SG), append(SL, [H|SG], Sorted).")
+
+(define pl-int-qs-db (pl-load pl-int-qs-src))
+
+(pl-int-test!
+  "quicksort([]) = [] (ground check)"
+  (len (pl-query-all pl-int-qs-db "quicksort([], [])"))
+  1)
+
+(pl-int-test!
+  "quicksort([3,1,2]) = [1,2,3] (ground check)"
+  (len (pl-query-all pl-int-qs-db "quicksort([3,1,2], [1,2,3])"))
+  1)
+
+(pl-int-test!
+  "quicksort([5,3,1,4,2]) = [1,2,3,4,5] (ground check)"
+  (len (pl-query-all pl-int-qs-db "quicksort([5,3,1,4,2], [1,2,3,4,5])"))
+  1)
+
+(pl-int-test!
+  "quicksort([3,1,2], [3,1,2]) fails — unsorted order rejected"
+  (len (pl-query-all pl-int-qs-db "quicksort([3,1,2], [3,1,2])"))
+  0)
+
+;; ── Fibonacci ──
+;; Naive recursive; ground checks avoid list-format uncertainty
+
+(define
+  pl-int-fib-src
+  "fib(0, 0). fib(1, 1). fib(N, F) :- N > 1, N1 is N - 1, N2 is N - 2, fib(N1, F1), fib(N2, F2), F is F1 + F2.")
+
+(define pl-int-fib-db (pl-load pl-int-fib-src))
+
+(pl-int-test!
+  "fib(0, 0) succeeds"
+  (len (pl-query-all pl-int-fib-db "fib(0, 0)"))
+  1)
+
+(pl-int-test!
+  "fib(5, 5) succeeds"
+  (len (pl-query-all pl-int-fib-db "fib(5, 5)"))
+  1)
+
+(pl-int-test!
+  "fib(7, 13) succeeds"
+  (len (pl-query-all pl-int-fib-db "fib(7, 13)"))
+  1)
+
+;; ── Dynamic knowledge base ──
+;; Assert and retract facts; the DB dict is mutable so mutations persist
+
+(define pl-int-dyn-src "color(red). color(green). color(blue).")
+(define pl-int-dyn-db (pl-load pl-int-dyn-src))
+
+(pl-int-test!
+  "initial KB: 3 colors"
+  (len (pl-query-all pl-int-dyn-db "color(X)"))
+  3)
+
+(pl-int-test!
+  "after assert(color(yellow)): 4 colors"
+  (begin
+    (pl-query-all pl-int-dyn-db "assert(color(yellow))")
+    (len (pl-query-all pl-int-dyn-db "color(X)")))
+  4)
+
+(pl-int-test!
+  "after retract(color(red)): back to 3 colors"
+  (begin
+    (pl-query-all pl-int-dyn-db "retract(color(red))")
+    (len (pl-query-all pl-int-dyn-db "color(X)")))
+  3)
+
+(define pl-integration-tests-run! (fn () {:failed pl-int-test-fail :passed pl-int-test-pass :total pl-int-test-count :failures pl-int-test-failures}))

lib/prolog/tests/io_predicates.sx

@@ -0,0 +1,326 @@
+;; lib/prolog/tests/io_predicates.sx — term_to_atom/2, term_string/2,
+;;   with_output_to/2, writeln/1, format/1, format/2
+
+(define pl-io-test-count 0)
+(define pl-io-test-pass 0)
+(define pl-io-test-fail 0)
+(define pl-io-test-failures (list))
+
+(define
+  pl-io-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-io-test-count (+ pl-io-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-io-test-pass (+ pl-io-test-pass 1))
+        (begin
+          (set! pl-io-test-fail (+ pl-io-test-fail 1))
+          (append!
+            pl-io-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-io-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-io-db (pl-mk-db))
+
+;; helper: get output buffer after running a goal
+(define
+  pl-io-capture!
+  (fn
+    (goal)
+    (do
+      (pl-output-clear!)
+      (pl-solve-once! pl-io-db goal (pl-mk-trail))
+      pl-output-buffer)))
+
+;; ─── term_to_atom/2 — bound Term direction ─────────────────────────────────
+
+(pl-io-test!
+  "term_to_atom(foo(a,b), A) — compound"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(foo(a,b), A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "foo(a, b)")
+
+(pl-io-test!
+  "term_to_atom(hello, A) — atom"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(hello, A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "hello")
+
+(pl-io-test!
+  "term_to_atom(42, A) — number"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(42, A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "42")
+
+(pl-io-test!
+  "term_to_atom(foo(a,b), 'foo(a, b)') — succeeds when Atom matches"
+  (pl-solve-once!
+    pl-io-db
+    (pl-io-goal "term_to_atom(foo(a,b), 'foo(a, b)')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-io-test!
+  "term_to_atom(hello, world) — fails on mismatch"
+  (pl-solve-once!
+    pl-io-db
+    (pl-io-goal "term_to_atom(hello, world)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── term_to_atom/2 — parse direction (Atom bound, Term unbound) ───────────
+
+(pl-io-test!
+  "term_to_atom(T, 'foo(a)') — parse direction gives compound"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(T, 'foo(a)')" env)
+      (pl-mk-trail))
+    (let
+      ((t (pl-walk-deep (dict-get env "T"))))
+      (and (pl-compound? t) (= (pl-fun t) "foo"))))
+  true)
+
+(pl-io-test!
+  "term_to_atom(T, hello) — parse direction gives atom"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(T, hello)" env)
+      (pl-mk-trail))
+    (let
+      ((t (pl-walk-deep (dict-get env "T"))))
+      (and (pl-atom? t) (= (pl-atom-name t) "hello"))))
+  true)
+
+;; ─── term_string/2 — alias ──────────────────────────────────────────────────
+
+(pl-io-test!
+  "term_string(bar(x), A) — same as term_to_atom"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_string(bar(x), A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "bar(x)")
+
+(pl-io-test!
+  "term_string(42, A) — number to string"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_string(42, A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "42")
+
+;; ─── writeln/1 ─────────────────────────────────────────────────────────────
+
+(pl-io-test!
+  "writeln(hello) writes 'hello\n'"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), writeln(hello))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello
+")
+
+(pl-io-test!
+  "writeln(42) writes '42\n'"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), writeln(42))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "42
+")
+
+;; ─── with_output_to/2 ──────────────────────────────────────────────────────
+
+(pl-io-test!
+  "with_output_to(atom(X), write(foo)) — captures write output"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), write(foo))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "foo")
+
+(pl-io-test!
+  "with_output_to(atom(X), (write(a), write(b))) — concat output"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), (write(a), write(b)))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "ab")
+
+(pl-io-test!
+  "with_output_to(atom(X), nl) — captures newline"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), nl)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "
+")
+
+(pl-io-test!
+  "with_output_to(atom(X), true) — captures empty string"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), true)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "")
+
+(pl-io-test!
+  "with_output_to(string(X), write(hello)) — string sink works"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(string(X), write(hello))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello")
+
+(pl-io-test!
+  "with_output_to(atom(X), fail) — fails when goal fails"
+  (pl-solve-once!
+    pl-io-db
+    (pl-io-goal "with_output_to(atom(X), fail)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── format/1 ──────────────────────────────────────────────────────────────
+
+(pl-io-test!
+  "format('hello~n') — tilde-n becomes newline"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('hello~n'))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello
+")
+
+(pl-io-test!
+  "format('~~') — double tilde becomes single tilde"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('~~'))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "~")
+
+(pl-io-test!
+  "format('abc') — plain text passes through"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format(abc))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "abc")
+
+;; ─── format/2 ──────────────────────────────────────────────────────────────
+
+(pl-io-test!
+  "format('~w+~w', [1,2]) — two ~w args"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('~w+~w', [1,2]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "1+2")
+
+(pl-io-test!
+  "format('hello ~a!', [world]) — ~a with atom arg"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('hello ~a!', [world]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello world!")
+
+(pl-io-test!
+  "format('n=~d', [42]) — ~d with integer arg"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('n=~d', [42]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "n=42")
+
+(pl-io-test!
+  "format('~w', [foo(a)]) — ~w with compound"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('~w', [foo(a)]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "foo(a)")
+
+(define
+  pl-io-predicates-tests-run!
+  (fn
+    ()
+    {:failed pl-io-test-fail
+      :passed pl-io-test-pass
+      :total pl-io-test-count
+      :failures pl-io-test-failures}))

lib/prolog/tests/iso_predicates.sx

@@ -0,0 +1,320 @@
+;; lib/prolog/tests/iso_predicates.sx — succ/2, plus/3, between/3, length/2, last/2, nth0/3, nth1/3, max/min arith
+
+(define pl-ip-test-count 0)
+(define pl-ip-test-pass 0)
+(define pl-ip-test-fail 0)
+(define pl-ip-test-failures (list))
+
+(define
+  pl-ip-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-ip-test-count (+ pl-ip-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-ip-test-pass (+ pl-ip-test-pass 1))
+        (begin
+          (set! pl-ip-test-fail (+ pl-ip-test-fail 1))
+          (append!
+            pl-ip-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-ip-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-ip-db (pl-mk-db))
+
+;; ── succ/2 ──
+
+(define pl-ip-env-s1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "succ(3, X)" pl-ip-env-s1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "succ(3, X) → X=4"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s1 "X")))
+  4)
+
+(define pl-ip-env-s2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "succ(0, X)" pl-ip-env-s2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "succ(0, X) → X=1"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s2 "X")))
+  1)
+
+(define pl-ip-env-s3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "succ(X, 5)" pl-ip-env-s3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "succ(X, 5) → X=4"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s3 "X")))
+  4)
+
+(pl-ip-test!
+  "succ(X, 0) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "succ(X, 0)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── plus/3 ──
+
+(define pl-ip-env-p1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "plus(2, 3, X)" pl-ip-env-p1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "plus(2, 3, X) → X=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p1 "X")))
+  5)
+
+(define pl-ip-env-p2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "plus(2, X, 7)" pl-ip-env-p2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "plus(2, X, 7) → X=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p2 "X")))
+  5)
+
+(define pl-ip-env-p3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "plus(X, 3, 7)" pl-ip-env-p3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "plus(X, 3, 7) → X=4"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p3 "X")))
+  4)
+
+(pl-ip-test!
+  "plus(0, 0, 0) succeeds"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "plus(0, 0, 0)" {})
+    (pl-mk-trail))
+  true)
+
+;; ── between/3 ──
+
+(pl-ip-test!
+  "between(1, 3, X): 3 solutions"
+  (pl-solve-count!
+    pl-ip-db
+    (pl-ip-goal "between(1, 3, X)" {})
+    (pl-mk-trail))
+  3)
+
+(pl-ip-test!
+  "between(1, 3, 2) succeeds"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "between(1, 3, 2)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ip-test!
+  "between(1, 3, 5) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "between(1, 3, 5)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-ip-test!
+  "between(5, 3, X): 0 solutions (empty range)"
+  (pl-solve-count!
+    pl-ip-db
+    (pl-ip-goal "between(5, 3, X)" {})
+    (pl-mk-trail))
+  0)
+
+(define pl-ip-env-b1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "between(1, 5, X)" pl-ip-env-b1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "between(1, 5, X): first solution X=1"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-b1 "X")))
+  1)
+
+(pl-ip-test!
+  "between + condition: between(1,5,X), X > 3 → 2 solutions"
+  (pl-solve-count!
+    pl-ip-db
+    (pl-ip-goal "between(1, 5, X), X > 3" {})
+    (pl-mk-trail))
+  2)
+
+;; ── length/2 ──
+
+(define pl-ip-env-l1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "length([1,2,3], N)" pl-ip-env-l1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "length([1,2,3], N) → N=3"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-l1 "N")))
+  3)
+
+(define pl-ip-env-l2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "length([], N)" pl-ip-env-l2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "length([], N) → N=0"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-l2 "N")))
+  0)
+
+(pl-ip-test!
+  "length([a,b], 2) check succeeds"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "length([a,b], 2)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-ip-env-l3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "length(L, 3)" pl-ip-env-l3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "length(L, 3): L is a list of length 3"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "length(L, 3), is_list(L)" pl-ip-env-l3)
+    (pl-mk-trail))
+  true)
+
+;; ── last/2 ──
+
+(define pl-ip-env-la1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "last([1,2,3], X)" pl-ip-env-la1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "last([1,2,3], X) → X=3"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-la1 "X")))
+  3)
+
+(define pl-ip-env-la2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "last([a], X)" pl-ip-env-la2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "last([a], X) → X=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-la2 "X")))
+  "a")
+
+(pl-ip-test!
+  "last([], X) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "last([], X)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── nth0/3 ──
+
+(define pl-ip-env-n0 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth0(0, [a,b,c], X)" pl-ip-env-n0)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth0(0, [a,b,c], X) → X=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n0 "X")))
+  "a")
+
+(define pl-ip-env-n1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth0(2, [a,b,c], X)" pl-ip-env-n1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth0(2, [a,b,c], X) → X=c"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1 "X")))
+  "c")
+
+(pl-ip-test!
+  "nth0(5, [a,b,c], X) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "nth0(5, [a,b,c], X)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── nth1/3 ──
+
+(define pl-ip-env-n1a {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth1(1, [a,b,c], X)" pl-ip-env-n1a)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth1(1, [a,b,c], X) → X=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1a "X")))
+  "a")
+
+(define pl-ip-env-n1b {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth1(3, [a,b,c], X)" pl-ip-env-n1b)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth1(3, [a,b,c], X) → X=c"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1b "X")))
+  "c")
+
+;; ── max/min in arithmetic ──
+
+(define pl-ip-env-m1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "X is max(3, 5)" pl-ip-env-m1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "X is max(3, 5) → X=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m1 "X")))
+  5)
+
+(define pl-ip-env-m2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "X is min(3, 5)" pl-ip-env-m2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "X is min(3, 5) → X=3"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m2 "X")))
+  3)
+
+(define pl-ip-env-m3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "X is max(7, 2) + min(1, 4)" pl-ip-env-m3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "X is max(7,2) + min(1,4) → X=8"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m3 "X")))
+  8)
+
+(define pl-iso-predicates-tests-run! (fn () {:failed pl-ip-test-fail :passed pl-ip-test-pass :total pl-ip-test-count :failures pl-ip-test-failures}))

lib/prolog/tests/list_predicates.sx

@@ -0,0 +1,335 @@
+;; lib/prolog/tests/list_predicates.sx — ==/2, \==/2, flatten/2, numlist/3,
+;;   atomic_list_concat/2,3, sum_list/2, max_list/2, min_list/2, delete/3
+
+(define pl-lp-test-count 0)
+(define pl-lp-test-pass 0)
+(define pl-lp-test-fail 0)
+(define pl-lp-test-failures (list))
+
+(define
+  pl-lp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-lp-test-count (+ pl-lp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-lp-test-pass (+ pl-lp-test-pass 1))
+        (begin
+          (set! pl-lp-test-fail (+ pl-lp-test-fail 1))
+          (append!
+            pl-lp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-lp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-lp-db (pl-mk-db))
+
+;; ── ==/2 ───────────────────────────────────────────────────────────
+
+(pl-lp-test!
+  "==(a, a) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(a, a)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "==(a, b) fails"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(a, b)" {}) (pl-mk-trail))
+  false)
+
+(pl-lp-test!
+  "==(1, 1) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(1, 1)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "==(1, 2) fails"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(1, 2)" {}) (pl-mk-trail))
+  false)
+
+(pl-lp-test!
+  "==(f(a,b), f(a,b)) succeeds"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-lp-goal "==(f(a,b), f(a,b))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "==(f(a,b), f(a,c)) fails"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-lp-goal "==(f(a,b), f(a,c))" {})
+    (pl-mk-trail))
+  false)
+
+;; unbound var vs atom: fails (different tags)
+(pl-lp-test!
+  "==(X, a) fails (unbound var vs atom)"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(X, a)" {}) (pl-mk-trail))
+  false)
+
+;; two unbound vars with SAME name in same env share the same runtime var
+(define pl-lp-env-same-var {})
+(pl-lp-goal "==(X, X)" pl-lp-env-same-var)
+(pl-lp-test!
+  "==(X, X) succeeds (same runtime var)"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-instantiate
+      (nth (first (pl-parse "g :- ==(X, X).")) 2)
+      pl-lp-env-same-var)
+    (pl-mk-trail))
+  true)
+
+;; ── \==/2 ──────────────────────────────────────────────────────────
+
+(pl-lp-test!
+  "\\==(a, b) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(a, b)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "\\==(a, a) fails"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(a, a)" {}) (pl-mk-trail))
+  false)
+
+(pl-lp-test!
+  "\\==(X, a) succeeds (unbound var differs from atom)"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(X, a)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "\\==(1, 2) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(1, 2)" {}) (pl-mk-trail))
+  true)
+
+;; ── flatten/2 ──────────────────────────────────────────────────────
+
+(define pl-lp-env-fl1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([], F)" pl-lp-env-fl1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([], []) -> empty"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl1 "F")))
+  "[]")
+
+(define pl-lp-env-fl2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([1,2,3], F)" pl-lp-env-fl2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([1,2,3], F) -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl2 "F")))
+  ".(1, .(2, .(3, [])))")
+
+(define pl-lp-env-fl3 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([1,[2,[3]],4], F)" pl-lp-env-fl3)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([1,[2,[3]],4], F) -> [1,2,3,4]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl3 "F")))
+  ".(1, .(2, .(3, .(4, []))))")
+
+(define pl-lp-env-fl4 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([[a,b],[c]], F)" pl-lp-env-fl4)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([[a,b],[c]], F) -> [a,b,c]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl4 "F")))
+  ".(a, .(b, .(c, [])))")
+
+;; ── numlist/3 ──────────────────────────────────────────────────────
+
+(define pl-lp-env-nl1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "numlist(1, 5, L)" pl-lp-env-nl1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "numlist(1,5,L) -> [1,2,3,4,5]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-nl1 "L")))
+  ".(1, .(2, .(3, .(4, .(5, [])))))")
+
+(define pl-lp-env-nl2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "numlist(3, 3, L)" pl-lp-env-nl2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "numlist(3,3,L) -> [3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-nl2 "L")))
+  ".(3, [])")
+
+(pl-lp-test!
+  "numlist(5, 3, L) fails (Low > High)"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-lp-goal "numlist(5, 3, L)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── atomic_list_concat/2 ───────────────────────────────────────────
+
+(define pl-lp-env-alc1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([a, b, c], R)" pl-lp-env-alc1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([a,b,c], R) -> abc"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alc1 "R")))
+  "abc")
+
+(define pl-lp-env-alc2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([hello, world], R)" pl-lp-env-alc2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([hello,world], R) -> helloworld"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alc2 "R")))
+  "helloworld")
+
+;; ── atomic_list_concat/3 ───────────────────────────────────────────
+
+(define pl-lp-env-alcs1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([a, b, c], '-', R)" pl-lp-env-alcs1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([a,b,c], '-', R) -> a-b-c"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alcs1 "R")))
+  "a-b-c")
+
+(define pl-lp-env-alcs2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([x], '-', R)" pl-lp-env-alcs2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([x], '-', R) -> x (single element, no sep)"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alcs2 "R")))
+  "x")
+
+;; ── sum_list/2 ─────────────────────────────────────────────────────
+
+(define pl-lp-env-sl1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "sum_list([1,2,3], S)" pl-lp-env-sl1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "sum_list([1,2,3], S) -> 6"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl1 "S")))
+  6)
+
+(define pl-lp-env-sl2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "sum_list([10], S)" pl-lp-env-sl2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "sum_list([10], S) -> 10"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl2 "S")))
+  10)
+
+(define pl-lp-env-sl3 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "sum_list([], S)" pl-lp-env-sl3)
+  (pl-mk-trail))
+(pl-lp-test!
+  "sum_list([], S) -> 0"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl3 "S")))
+  0)
+
+;; ── max_list/2 ─────────────────────────────────────────────────────
+
+(define pl-lp-env-mx1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "max_list([3,1,4,1,5,9,2,6], M)" pl-lp-env-mx1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "max_list([3,1,4,1,5,9,2,6], M) -> 9"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mx1 "M")))
+  9)
+
+(define pl-lp-env-mx2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "max_list([7], M)" pl-lp-env-mx2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "max_list([7], M) -> 7"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mx2 "M")))
+  7)
+
+;; ── min_list/2 ─────────────────────────────────────────────────────
+
+(define pl-lp-env-mn1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "min_list([3,1,4,1,5,9,2,6], M)" pl-lp-env-mn1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "min_list([3,1,4,1,5,9,2,6], M) -> 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mn1 "M")))
+  1)
+
+(define pl-lp-env-mn2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "min_list([5,2,8], M)" pl-lp-env-mn2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "min_list([5,2,8], M) -> 2"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mn2 "M")))
+  2)
+
+;; ── delete/3 ───────────────────────────────────────────────────────
+
+(define pl-lp-env-del1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "delete([1,2,3,2,1], 2, R)" pl-lp-env-del1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "delete([1,2,3,2,1], 2, R) -> [1,3,1]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del1 "R")))
+  ".(1, .(3, .(1, [])))")
+
+(define pl-lp-env-del2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "delete([a,b,c], d, R)" pl-lp-env-del2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "delete([a,b,c], d, R) -> [a,b,c] (nothing deleted)"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del2 "R")))
+  ".(a, .(b, .(c, [])))")
+
+(define pl-lp-env-del3 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "delete([], x, R)" pl-lp-env-del3)
+  (pl-mk-trail))
+(pl-lp-test!
+  "delete([], x, R) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del3 "R")))
+  "[]")
+
+(define pl-list-predicates-tests-run! (fn () {:failed pl-lp-test-fail :passed pl-lp-test-pass :total pl-lp-test-count :failures pl-lp-test-failures}))

lib/prolog/tests/meta_call.sx

@@ -0,0 +1,197 @@
+;; lib/prolog/tests/meta_call.sx — forall/2, maplist/2, maplist/3, include/3, exclude/3
+(define pl-mc-test-count 0)
+(define pl-mc-test-pass 0)
+(define pl-mc-test-fail 0)
+(define pl-mc-test-failures (list))
+
+(define
+  pl-mc-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-mc-test-count (+ pl-mc-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-mc-test-pass (+ pl-mc-test-pass 1))
+        (begin
+          (set! pl-mc-test-fail (+ pl-mc-test-fail 1))
+          (append!
+            pl-mc-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-mc-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-mc-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (else t))))
+
+(define
+  pl-mc-list-sx
+  (fn
+    (t)
+    (let
+      ((w (pl-walk-deep t)))
+      (cond
+        ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+        ((and (pl-compound? w) (= (pl-fun w) "."))
+          (cons
+            (pl-mc-term-to-sx (first (pl-args w)))
+            (pl-mc-list-sx (nth (pl-args w) 1))))
+        (else (list :not-list))))))
+
+(define pl-mc-db (pl-mk-db))
+
+(pl-db-load!
+  pl-mc-db
+  (pl-parse "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
+
+(pl-db-load! pl-mc-db (pl-parse "double(X, Y) :- Y is X * 2."))
+
+(pl-db-load! pl-mc-db (pl-parse "even(X) :- 0 is X mod 2."))
+
+;; -- forall/2 --
+
+(pl-mc-test!
+  "forall(member(X,[2,4,6]), 0 is X mod 2) — all even"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "forall(member(X,[2,4,6]), 0 is X mod 2)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "forall(member(X,[2,3,6]), 0 is X mod 2) — 3 is odd, fails"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "forall(member(X,[2,3,6]), 0 is X mod 2)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mc-test!
+  "forall(member(_,[]), true) — vacuously true"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "forall(member(_,[]), true)" {})
+    (pl-mk-trail))
+  true)
+
+;; -- maplist/2 --
+
+(pl-mc-test!
+  "maplist(atom, [a,b,c]) — all atoms"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(atom, [a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "maplist(atom, [a,1,c]) — 1 is not atom, fails"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(atom, [a,1,c])" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mc-test!
+  "maplist(atom, []) — vacuously true"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(atom, [])" {})
+    (pl-mk-trail))
+  true)
+
+;; -- maplist/3 --
+
+(pl-mc-test!
+  "maplist(double, [1,2,3], [2,4,6]) — deterministic check"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(double, [1,2,3], [2,4,6])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "maplist(double, [1,2,3], [2,4,7]) — wrong result fails"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(double, [1,2,3], [2,4,7])" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-mc-env-ml3 {:L (pl-mk-rt-var "L")})
+(pl-solve-once!
+  pl-mc-db
+  (pl-mc-goal "maplist(double, [1,2,3], L)" pl-mc-env-ml3)
+  (pl-mk-trail))
+(pl-mc-test!
+  "maplist(double, [1,2,3], L) — L bound to [2,4,6]"
+  (pl-mc-list-sx (dict-get pl-mc-env-ml3 "L"))
+  (list 2 4 6))
+
+;; -- include/3 --
+
+(pl-mc-test!
+  "include(even, [1,2,3,4,5,6], [2,4,6])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "include(even, [1,2,3,4,5,6], [2,4,6])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "include(even, [], [])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "include(even, [], [])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-mc-env-inc {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-mc-db
+  (pl-mc-goal "include(even, [1,2,3,4,5,6], R)" pl-mc-env-inc)
+  (pl-mk-trail))
+(pl-mc-test!
+  "include(even, [1,2,3,4,5,6], R) — R bound to [2,4,6]"
+  (pl-mc-list-sx (dict-get pl-mc-env-inc "R"))
+  (list 2 4 6))
+
+;; -- exclude/3 --
+
+(pl-mc-test!
+  "exclude(even, [1,2,3,4,5,6], [1,3,5])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "exclude(even, [1,2,3,4,5,6], [1,3,5])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "exclude(even, [], [])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "exclude(even, [], [])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-mc-env-exc {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-mc-db
+  (pl-mc-goal "exclude(even, [1,2,3,4,5,6], R)" pl-mc-env-exc)
+  (pl-mk-trail))
+(pl-mc-test!
+  "exclude(even, [1,2,3,4,5,6], R) — R bound to [1,3,5]"
+  (pl-mc-list-sx (dict-get pl-mc-env-exc "R"))
+  (list 1 3 5))
+
+(define pl-meta-call-tests-run! (fn () {:failed pl-mc-test-fail :passed pl-mc-test-pass :total pl-mc-test-count :failures pl-mc-test-failures}))

lib/prolog/tests/meta_predicates.sx

@@ -0,0 +1,252 @@
+;; lib/prolog/tests/meta_predicates.sx — \+/1, not/1, once/1, ignore/1, ground/1, sort/2, msort/2, atom_number/2, number_string/2
+
+(define pl-mp-test-count 0)
+(define pl-mp-test-pass 0)
+(define pl-mp-test-fail 0)
+(define pl-mp-test-failures (list))
+
+(define
+  pl-mp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-mp-test-count (+ pl-mp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-mp-test-pass (+ pl-mp-test-pass 1))
+        (begin
+          (set! pl-mp-test-fail (+ pl-mp-test-fail 1))
+          (append!
+            pl-mp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-mp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-mp-db (pl-mk-db))
+(pl-db-load!
+  pl-mp-db
+  (pl-parse "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
+
+;; -- \+/1 --
+
+(pl-mp-test!
+  "\\+(fail) succeeds"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "\\+(fail)" {}) (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "\\+(true) fails"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "\\+(true)" {}) (pl-mk-trail))
+  false)
+
+(pl-mp-test!
+  "\\+(member(d, [a,b,c])) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "\\+(member(d, [a,b,c]))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "\\+(member(a, [a,b,c])) fails"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "\\+(member(a, [a,b,c]))" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-mp-env-neg {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "\\+(X = 5)" pl-mp-env-neg)
+  (pl-mk-trail))
+(pl-mp-test!
+  "\\+(X=5) fails, X stays unbound (bindings undone)"
+  (nil? (pl-var-binding (dict-get pl-mp-env-neg "X")))
+  true)
+
+;; -- not/1 --
+
+(pl-mp-test!
+  "not(fail) succeeds"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "not(fail)" {}) (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "not(true) fails"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "not(true)" {}) (pl-mk-trail))
+  false)
+
+;; -- once/1 --
+
+(pl-mp-test!
+  "once(member(X,[1,2,3])) succeeds once"
+  (pl-solve-count!
+    pl-mp-db
+    (pl-mp-goal "once(member(X,[1,2,3]))" {})
+    (pl-mk-trail))
+  1)
+
+(define pl-mp-env-once {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "once(member(X,[1,2,3]))" pl-mp-env-once)
+  (pl-mk-trail))
+(pl-mp-test!
+  "once(member(X,[1,2,3])): X=1 (first solution)"
+  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-once "X")))
+  1)
+
+(pl-mp-test!
+  "once(fail) fails"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "once(fail)" {})
+    (pl-mk-trail))
+  false)
+
+;; -- ignore/1 --
+
+(pl-mp-test!
+  "ignore(true) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ignore(true)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "ignore(fail) still succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ignore(fail)" {})
+    (pl-mk-trail))
+  true)
+
+;; -- ground/1 --
+
+(pl-mp-test!
+  "ground(foo(1, a)) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ground(foo(1, a))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "ground(foo(X, a)) fails (X unbound)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ground(foo(X, a))" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mp-test!
+  "ground(42) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ground(42)" {})
+    (pl-mk-trail))
+  true)
+
+;; -- sort/2 --
+
+(pl-mp-test!
+  "sort([b,a,c], [a,b,c])"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "sort([b,a,c], [a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "sort([b,a,a,c], [a,b,c]) (removes duplicates)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "sort([b,a,a,c], [a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "sort([], [])"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "sort([], [])" {})
+    (pl-mk-trail))
+  true)
+
+;; -- msort/2 --
+
+(pl-mp-test!
+  "msort([b,a,a,c], [a,a,b,c]) (keeps duplicates)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "msort([b,a,a,c], [a,a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "msort([3,1,2,1], [1,1,2,3])"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "msort([3,1,2,1], [1,1,2,3])" {})
+    (pl-mk-trail))
+  true)
+
+;; -- atom_number/2 --
+
+(define pl-mp-env-an1 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "atom_number('42', N)" pl-mp-env-an1)
+  (pl-mk-trail))
+(pl-mp-test!
+  "atom_number('42', N) -> N=42"
+  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-an1 "N")))
+  42)
+
+(define pl-mp-env-an2 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "atom_number(A, 7)" pl-mp-env-an2)
+  (pl-mk-trail))
+(pl-mp-test!
+  "atom_number(A, 7) -> A='7'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-mp-env-an2 "A")))
+  "7")
+
+(pl-mp-test!
+  "atom_number(foo, N) fails (not a number)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "atom_number(foo, N)" {})
+    (pl-mk-trail))
+  false)
+
+;; -- number_string/2 --
+
+(define pl-mp-env-ns1 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "number_string(42, S)" pl-mp-env-ns1)
+  (pl-mk-trail))
+(pl-mp-test!
+  "number_string(42, S) -> S='42'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-mp-env-ns1 "S")))
+  "42")
+
+(define pl-mp-env-ns2 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "number_string(N, '3.14')" pl-mp-env-ns2)
+  (pl-mk-trail))
+(pl-mp-test!
+  "number_string(N, '3.14') -> N=3.14"
+  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-ns2 "N")))
+  3.14)
+
+(define pl-meta-predicates-tests-run! (fn () {:failed pl-mp-test-fail :passed pl-mp-test-pass :total pl-mp-test-count :failures pl-mp-test-failures}))

lib/prolog/tests/operators.sx

@@ -0,0 +1,193 @@
+;; lib/prolog/tests/operators.sx — operator-table parsing + comparison built-ins.
+
+(define pl-op-test-count 0)
+(define pl-op-test-pass 0)
+(define pl-op-test-fail 0)
+(define pl-op-test-failures (list))
+
+(define
+  pl-op-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-op-test-count (+ pl-op-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-op-test-pass (+ pl-op-test-pass 1))
+        (begin
+          (set! pl-op-test-fail (+ pl-op-test-fail 1))
+          (append!
+            pl-op-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define pl-op-empty-db (pl-mk-db))
+
+(define
+  pl-op-body
+  (fn (src) (nth (first (pl-parse (str "g :- " src "."))) 2)))
+
+(define pl-op-goal (fn (src env) (pl-instantiate (pl-op-body src) env)))
+
+;; ── parsing tests ──
+
+(pl-op-test!
+  "infix +"
+  (pl-op-body "a + b")
+  (list "compound" "+" (list (list "atom" "a") (list "atom" "b"))))
+
+(pl-op-test!
+  "infix * tighter than +"
+  (pl-op-body "a + b * c")
+  (list
+    "compound"
+    "+"
+    (list
+      (list "atom" "a")
+      (list "compound" "*" (list (list "atom" "b") (list "atom" "c"))))))
+
+(pl-op-test!
+  "parens override precedence"
+  (pl-op-body "(a + b) * c")
+  (list
+    "compound"
+    "*"
+    (list
+      (list "compound" "+" (list (list "atom" "a") (list "atom" "b")))
+      (list "atom" "c"))))
+
+(pl-op-test!
+  "+ is yfx (left-assoc)"
+  (pl-op-body "a + b + c")
+  (list
+    "compound"
+    "+"
+    (list
+      (list "compound" "+" (list (list "atom" "a") (list "atom" "b")))
+      (list "atom" "c"))))
+
+(pl-op-test!
+  "; is xfy (right-assoc)"
+  (pl-op-body "a ; b ; c")
+  (list
+    "compound"
+    ";"
+    (list
+      (list "atom" "a")
+      (list "compound" ";" (list (list "atom" "b") (list "atom" "c"))))))
+
+(pl-op-test!
+  "= folds at 700"
+  (pl-op-body "X = 5")
+  (list "compound" "=" (list (list "var" "X") (list "num" 5))))
+
+(pl-op-test!
+  "is + nests via 700>500>400"
+  (pl-op-body "X is 2 + 3 * 4")
+  (list
+    "compound"
+    "is"
+    (list
+      (list "var" "X")
+      (list
+        "compound"
+        "+"
+        (list
+          (list "num" 2)
+          (list "compound" "*" (list (list "num" 3) (list "num" 4))))))))
+
+(pl-op-test!
+  "< parses at 700"
+  (pl-op-body "2 < 3")
+  (list "compound" "<" (list (list "num" 2) (list "num" 3))))
+
+(pl-op-test!
+  "mod parses as yfx 400"
+  (pl-op-body "10 mod 3")
+  (list "compound" "mod" (list (list "num" 10) (list "num" 3))))
+
+(pl-op-test!
+  "comma in body folds right-assoc"
+  (pl-op-body "a, b, c")
+  (list
+    "compound"
+    ","
+    (list
+      (list "atom" "a")
+      (list "compound" "," (list (list "atom" "b") (list "atom" "c"))))))
+
+;; ── solver tests via infix ──
+
+(pl-op-test!
+  "X is 2 + 3 binds X = 5"
+  (let
+    ((env {}) (trail (pl-mk-trail)))
+    (begin
+      (pl-solve-once! pl-op-empty-db (pl-op-goal "X is 2 + 3" env) trail)
+      (pl-num-val (pl-walk-deep (dict-get env "X")))))
+  5)
+
+(pl-op-test!
+  "infix conjunction parses + solves"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "X = 5, X = 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "infix mismatch fails"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "X = 5, X = 6" {})
+    (pl-mk-trail))
+  false)
+
+(pl-op-test!
+  "infix disjunction picks left"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "true ; fail" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "2 < 5 succeeds"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "2 < 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "5 < 2 fails"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "5 < 2" {})
+    (pl-mk-trail))
+  false)
+
+(pl-op-test!
+  "5 >= 5 succeeds"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "5 >= 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "3 =< 5 succeeds"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "3 =< 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "infix < with arithmetic both sides"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "1 + 2 < 2 * 3" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-operators-tests-run! (fn () {:failed pl-op-test-fail :passed pl-op-test-pass :total pl-op-test-count :failures pl-op-test-failures}))

lib/prolog/tests/programs/append.pl

@@ -0,0 +1,5 @@
+%% append/3 — list concatenation, classic Prolog
+%% Two clauses: empty-prefix base case + recursive cons-prefix.
+%% Bidirectional — works in all modes: build, check, split.
+append([], L, L).
+append([H|T], L, [H|R]) :- append(T, L, R).

lib/prolog/tests/programs/append.sx

@@ -0,0 +1,114 @@
+;; lib/prolog/tests/programs/append.sx — append/3 test runner
+;;
+;; Mirrors the Prolog source in append.pl (embedded as a string here because
+;; the SX runtime has no file-read primitive yet).
+
+(define pl-ap-test-count 0)
+(define pl-ap-test-pass 0)
+(define pl-ap-test-fail 0)
+(define pl-ap-test-failures (list))
+
+(define
+  pl-ap-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-ap-test-count (+ pl-ap-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-ap-test-pass (+ pl-ap-test-pass 1))
+        (begin
+          (set! pl-ap-test-fail (+ pl-ap-test-fail 1))
+          (append!
+            pl-ap-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-ap-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (true (list :complex)))))
+
+(define
+  pl-ap-list-walked
+  (fn
+    (w)
+    (cond
+      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+        (cons
+          (pl-ap-term-to-sx (first (pl-args w)))
+          (pl-ap-list-walked (nth (pl-args w) 1))))
+      (true (list :not-list)))))
+
+(define pl-ap-list-to-sx (fn (t) (pl-ap-list-walked (pl-walk-deep t))))
+
+(define
+  pl-ap-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-ap-prog-src
+  "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
+
+(define pl-ap-db (pl-mk-db))
+
+(pl-db-load! pl-ap-db (pl-parse pl-ap-prog-src))
+
+(define pl-ap-env-1 {})
+(define pl-ap-goal-1 (pl-ap-goal "append([], [a, b], X)" pl-ap-env-1))
+(pl-solve-once! pl-ap-db pl-ap-goal-1 (pl-mk-trail))
+
+(pl-ap-test!
+  "append([], [a, b], X) → X = [a, b]"
+  (pl-ap-list-to-sx (dict-get pl-ap-env-1 "X"))
+  (list "a" "b"))
+
+(define pl-ap-env-2 {})
+(define pl-ap-goal-2 (pl-ap-goal "append([1, 2], [3, 4], X)" pl-ap-env-2))
+(pl-solve-once! pl-ap-db pl-ap-goal-2 (pl-mk-trail))
+
+(pl-ap-test!
+  "append([1, 2], [3, 4], X) → X = [1, 2, 3, 4]"
+  (pl-ap-list-to-sx (dict-get pl-ap-env-2 "X"))
+  (list 1 2 3 4))
+
+(pl-ap-test!
+  "append([1], [2, 3], [1, 2, 3]) succeeds"
+  (pl-solve-once!
+    pl-ap-db
+    (pl-ap-goal "append([1], [2, 3], [1, 2, 3])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ap-test!
+  "append([1, 2], [3], [1, 2, 4]) fails"
+  (pl-solve-once!
+    pl-ap-db
+    (pl-ap-goal "append([1, 2], [3], [1, 2, 4])" {})
+    (pl-mk-trail))
+  false)
+
+(pl-ap-test!
+  "append(X, Y, [1, 2, 3]) backtracks 4 times"
+  (pl-solve-count!
+    pl-ap-db
+    (pl-ap-goal "append(X, Y, [1, 2, 3])" {})
+    (pl-mk-trail))
+  4)
+
+(define pl-ap-env-6 {})
+(define pl-ap-goal-6 (pl-ap-goal "append(X, [3], [1, 2, 3])" pl-ap-env-6))
+(pl-solve-once! pl-ap-db pl-ap-goal-6 (pl-mk-trail))
+
+(pl-ap-test!
+  "append(X, [3], [1, 2, 3]) deduces X = [1, 2]"
+  (pl-ap-list-to-sx (dict-get pl-ap-env-6 "X"))
+  (list 1 2))
+
+(define pl-append-tests-run! (fn () {:failed pl-ap-test-fail :passed pl-ap-test-pass :total pl-ap-test-count :failures pl-ap-test-failures}))

lib/prolog/tests/programs/family.pl

@@ -0,0 +1,24 @@
+%% family — facts + transitive ancestor + derived relations.
+%% Five-generation tree: tom -> bob -> {ann, pat} -> jim, plus tom's
+%% other child liz.
+
+parent(tom, bob).
+parent(tom, liz).
+parent(bob, ann).
+parent(bob, pat).
+parent(pat, jim).
+
+male(tom).
+male(bob).
+male(jim).
+male(pat).
+female(liz).
+female(ann).
+
+father(F, C) :- parent(F, C), male(F).
+mother(M, C) :- parent(M, C), female(M).
+
+ancestor(X, Y) :- parent(X, Y).
+ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).
+
+sibling(X, Y) :- parent(P, X), parent(P, Y), \=(X, Y).

lib/prolog/tests/programs/family.sx

@@ -0,0 +1,116 @@
+;; lib/prolog/tests/programs/family.sx — facts + ancestor + sibling relations.
+
+(define pl-fa-test-count 0)
+(define pl-fa-test-pass 0)
+(define pl-fa-test-fail 0)
+(define pl-fa-test-failures (list))
+
+(define
+  pl-fa-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-fa-test-count (+ pl-fa-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-fa-test-pass (+ pl-fa-test-pass 1))
+        (begin
+          (set! pl-fa-test-fail (+ pl-fa-test-fail 1))
+          (append!
+            pl-fa-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-fa-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-fa-prog-src
+  "parent(tom, bob). parent(tom, liz). parent(bob, ann). parent(bob, pat). parent(pat, jim). male(tom). male(bob). male(jim). male(pat). female(liz). female(ann). father(F, C) :- parent(F, C), male(F). mother(M, C) :- parent(M, C), female(M). ancestor(X, Y) :- parent(X, Y). ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y). sibling(X, Y) :- parent(P, X), parent(P, Y), \\=(X, Y).")
+
+(define pl-fa-db (pl-mk-db))
+(pl-db-load! pl-fa-db (pl-parse pl-fa-prog-src))
+
+(pl-fa-test!
+  "parent(tom, bob) is a fact"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "parent(tom, bob)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-fa-test!
+  "parent(tom, ann) — not a direct parent"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "parent(tom, ann)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-fa-test!
+  "5 parent/2 facts in total"
+  (pl-solve-count!
+    pl-fa-db
+    (pl-fa-goal "parent(X, Y)" {})
+    (pl-mk-trail))
+  5)
+
+(pl-fa-test!
+  "ancestor(tom, jim) — three-step transitive"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "ancestor(tom, jim)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-fa-test!
+  "tom has 5 ancestors-of: bob, liz, ann, pat, jim"
+  (pl-solve-count!
+    pl-fa-db
+    (pl-fa-goal "ancestor(tom, X)" {})
+    (pl-mk-trail))
+  5)
+
+(pl-fa-test!
+  "father(bob, ann) succeeds"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "father(bob, ann)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-fa-test!
+  "father(liz, ann) fails (liz is female)"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "father(liz, ann)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-fa-test!
+  "mother(liz, X) fails (liz has no children)"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "mother(liz, X)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-fa-test!
+  "sibling(ann, pat) succeeds"
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "sibling(ann, pat)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-fa-test!
+  "sibling(ann, ann) fails by \\="
+  (pl-solve-once!
+    pl-fa-db
+    (pl-fa-goal "sibling(ann, ann)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-family-tests-run! (fn () {:failed pl-fa-test-fail :passed pl-fa-test-pass :total pl-fa-test-count :failures pl-fa-test-failures}))

lib/prolog/tests/programs/member.pl

@@ -0,0 +1,4 @@
+%% member/2 — list membership.
+%% Generates all solutions on backtracking when the element is unbound.
+member(X, [X|_]).
+member(X, [_|T]) :- member(X, T).

lib/prolog/tests/programs/member.sx

@@ -0,0 +1,91 @@
+;; lib/prolog/tests/programs/member.sx — member/2 generator.
+
+(define pl-mb-test-count 0)
+(define pl-mb-test-pass 0)
+(define pl-mb-test-fail 0)
+(define pl-mb-test-failures (list))
+
+(define
+  pl-mb-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-mb-test-count (+ pl-mb-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-mb-test-pass (+ pl-mb-test-pass 1))
+        (begin
+          (set! pl-mb-test-fail (+ pl-mb-test-fail 1))
+          (append!
+            pl-mb-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-mb-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-mb-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
+
+(define pl-mb-db (pl-mk-db))
+(pl-db-load! pl-mb-db (pl-parse pl-mb-prog-src))
+
+(pl-mb-test!
+  "member(2, [1, 2, 3]) succeeds"
+  (pl-solve-once!
+    pl-mb-db
+    (pl-mb-goal "member(2, [1, 2, 3])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mb-test!
+  "member(4, [1, 2, 3]) fails"
+  (pl-solve-once!
+    pl-mb-db
+    (pl-mb-goal "member(4, [1, 2, 3])" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mb-test!
+  "member(X, []) fails"
+  (pl-solve-once!
+    pl-mb-db
+    (pl-mb-goal "member(X, [])" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mb-test!
+  "member(X, [a, b, c]) generates 3 solutions"
+  (pl-solve-count!
+    pl-mb-db
+    (pl-mb-goal "member(X, [a, b, c])" {})
+    (pl-mk-trail))
+  3)
+
+(define pl-mb-env-1 {})
+(define pl-mb-goal-1 (pl-mb-goal "member(X, [11, 22, 33])" pl-mb-env-1))
+(pl-solve-once! pl-mb-db pl-mb-goal-1 (pl-mk-trail))
+
+(pl-mb-test!
+  "member(X, [11, 22, 33]) first solution X = 11"
+  (pl-num-val (pl-walk-deep (dict-get pl-mb-env-1 "X")))
+  11)
+
+(pl-mb-test!
+  "member(2, [1, 2, 3, 2, 1]) matches twice on backtrack"
+  (pl-solve-count!
+    pl-mb-db
+    (pl-mb-goal "member(2, [1, 2, 3, 2, 1])" {})
+    (pl-mk-trail))
+  2)
+
+(pl-mb-test!
+  "member with unbound list cell unifies"
+  (pl-solve-once!
+    pl-mb-db
+    (pl-mb-goal "member(a, [X, b, c])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-member-tests-run! (fn () {:failed pl-mb-test-fail :passed pl-mb-test-pass :total pl-mb-test-count :failures pl-mb-test-failures}))

lib/prolog/tests/programs/nqueens.pl

@@ -0,0 +1,27 @@
+%% nqueens — permutation-and-test formulation.
+%% Caller passes the row list [1..N]; queens/2 finds N column placements
+%% s.t. no two queens attack on a diagonal. Same-column attacks are
+%% structurally impossible — Qs is a permutation, all distinct.
+%%
+%% No `>/2` `</2` `=</2` built-ins yet, so range/3 is omitted; tests pass
+%; the literal range list. Once the operator table lands and arithmetic
+%% comparison built-ins are in, range/3 can be added.
+queens(L, Qs) :- permute(L, Qs), safe(Qs).
+
+permute([], []).
+permute(L, [H|T]) :- select(H, L, R), permute(R, T).
+
+select(X, [X|T], T).
+select(X, [H|T], [H|R]) :- select(X, T, R).
+
+safe([]).
+safe([Q|Qs]) :- safe(Qs), no_attack(Q, Qs, 1).
+
+no_attack(_, [], _).
+no_attack(Q, [Q1|Qs], D) :-
+  is(D2, +(Q, D)),
+  \=(D2, Q1),
+  is(D3, -(Q, D)),
+  \=(D3, Q1),
+  is(D1, +(D, 1)),
+  no_attack(Q, Qs, D1).

lib/prolog/tests/programs/nqueens.sx

@@ -0,0 +1,108 @@
+;; lib/prolog/tests/programs/nqueens.sx — N-queens via permute + safe.
+
+(define pl-nq-test-count 0)
+(define pl-nq-test-pass 0)
+(define pl-nq-test-fail 0)
+(define pl-nq-test-failures (list))
+
+(define
+  pl-nq-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-nq-test-count (+ pl-nq-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-nq-test-pass (+ pl-nq-test-pass 1))
+        (begin
+          (set! pl-nq-test-fail (+ pl-nq-test-fail 1))
+          (append!
+            pl-nq-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-nq-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (true (list :complex)))))
+
+(define
+  pl-nq-list-walked
+  (fn
+    (w)
+    (cond
+      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+        (cons
+          (pl-nq-term-to-sx (first (pl-args w)))
+          (pl-nq-list-walked (nth (pl-args w) 1))))
+      (true (list :not-list)))))
+
+(define pl-nq-list-to-sx (fn (t) (pl-nq-list-walked (pl-walk-deep t))))
+
+(define
+  pl-nq-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-nq-prog-src
+  "queens(L, Qs) :- permute(L, Qs), safe(Qs). permute([], []). permute(L, [H|T]) :- select(H, L, R), permute(R, T). select(X, [X|T], T). select(X, [H|T], [H|R]) :- select(X, T, R). safe([]). safe([Q|Qs]) :- safe(Qs), no_attack(Q, Qs, 1). no_attack(_, [], _). no_attack(Q, [Q1|Qs], D) :- is(D2, +(Q, D)), \\=(D2, Q1), is(D3, -(Q, D)), \\=(D3, Q1), is(D1, +(D, 1)), no_attack(Q, Qs, D1).")
+
+(define pl-nq-db (pl-mk-db))
+(pl-db-load! pl-nq-db (pl-parse pl-nq-prog-src))
+
+(pl-nq-test!
+  "queens([1], Qs) → 1 solution"
+  (pl-solve-count!
+    pl-nq-db
+    (pl-nq-goal "queens([1], Qs)" {})
+    (pl-mk-trail))
+  1)
+
+(pl-nq-test!
+  "queens([1, 2], Qs) → 0 solutions"
+  (pl-solve-count!
+    pl-nq-db
+    (pl-nq-goal "queens([1, 2], Qs)" {})
+    (pl-mk-trail))
+  0)
+
+(pl-nq-test!
+  "queens([1, 2, 3], Qs) → 0 solutions"
+  (pl-solve-count!
+    pl-nq-db
+    (pl-nq-goal "queens([1, 2, 3], Qs)" {})
+    (pl-mk-trail))
+  0)
+
+(pl-nq-test!
+  "queens([1, 2, 3, 4], Qs) → 2 solutions"
+  (pl-solve-count!
+    pl-nq-db
+    (pl-nq-goal "queens([1, 2, 3, 4], Qs)" {})
+    (pl-mk-trail))
+  2)
+
+(pl-nq-test!
+  "queens([1, 2, 3, 4, 5], Qs) → 10 solutions"
+  (pl-solve-count!
+    pl-nq-db
+    (pl-nq-goal "queens([1, 2, 3, 4, 5], Qs)" {})
+    (pl-mk-trail))
+  10)
+
+(define pl-nq-env-1 {})
+(define pl-nq-goal-1 (pl-nq-goal "queens([1, 2, 3, 4], Qs)" pl-nq-env-1))
+(pl-solve-once! pl-nq-db pl-nq-goal-1 (pl-mk-trail))
+
+(pl-nq-test!
+  "queens([1..4], Qs) first solution = [2, 4, 1, 3]"
+  (pl-nq-list-to-sx (dict-get pl-nq-env-1 "Qs"))
+  (list 2 4 1 3))
+
+(define pl-nqueens-tests-run! (fn () {:failed pl-nq-test-fail :passed pl-nq-test-pass :total pl-nq-test-count :failures pl-nq-test-failures}))

lib/prolog/tests/programs/reverse.pl

@@ -0,0 +1,7 @@
+%% reverse/2 — naive reverse via append/3.
+%% Quadratic — accumulates the reversed prefix one append per cons.
+reverse([], []).
+reverse([H|T], R) :- reverse(T, RT), append(RT, [H], R).
+
+append([], L, L).
+append([H|T], L, [H|R]) :- append(T, L, R).

lib/prolog/tests/programs/reverse.sx

@@ -0,0 +1,113 @@
+;; lib/prolog/tests/programs/reverse.sx — naive reverse/2 via append/3.
+;;
+;; Mirrors reverse.pl (embedded as a string here).
+
+(define pl-rv-test-count 0)
+(define pl-rv-test-pass 0)
+(define pl-rv-test-fail 0)
+(define pl-rv-test-failures (list))
+
+(define
+  pl-rv-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-rv-test-count (+ pl-rv-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-rv-test-pass (+ pl-rv-test-pass 1))
+        (begin
+          (set! pl-rv-test-fail (+ pl-rv-test-fail 1))
+          (append!
+            pl-rv-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-rv-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (true (list :complex)))))
+
+(define
+  pl-rv-list-walked
+  (fn
+    (w)
+    (cond
+      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+        (cons
+          (pl-rv-term-to-sx (first (pl-args w)))
+          (pl-rv-list-walked (nth (pl-args w) 1))))
+      (true (list :not-list)))))
+
+(define pl-rv-list-to-sx (fn (t) (pl-rv-list-walked (pl-walk-deep t))))
+
+(define
+  pl-rv-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-rv-prog-src
+  "reverse([], []). reverse([H|T], R) :- reverse(T, RT), append(RT, [H], R). append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
+
+(define pl-rv-db (pl-mk-db))
+(pl-db-load! pl-rv-db (pl-parse pl-rv-prog-src))
+
+(define pl-rv-env-1 {})
+(define pl-rv-goal-1 (pl-rv-goal "reverse([], X)" pl-rv-env-1))
+(pl-solve-once! pl-rv-db pl-rv-goal-1 (pl-mk-trail))
+
+(pl-rv-test!
+  "reverse([], X) → X = []"
+  (pl-rv-list-to-sx (dict-get pl-rv-env-1 "X"))
+  (list))
+
+(define pl-rv-env-2 {})
+(define pl-rv-goal-2 (pl-rv-goal "reverse([1], X)" pl-rv-env-2))
+(pl-solve-once! pl-rv-db pl-rv-goal-2 (pl-mk-trail))
+
+(pl-rv-test!
+  "reverse([1], X) → X = [1]"
+  (pl-rv-list-to-sx (dict-get pl-rv-env-2 "X"))
+  (list 1))
+
+(define pl-rv-env-3 {})
+(define pl-rv-goal-3 (pl-rv-goal "reverse([1, 2, 3], X)" pl-rv-env-3))
+(pl-solve-once! pl-rv-db pl-rv-goal-3 (pl-mk-trail))
+
+(pl-rv-test!
+  "reverse([1, 2, 3], X) → X = [3, 2, 1]"
+  (pl-rv-list-to-sx (dict-get pl-rv-env-3 "X"))
+  (list 3 2 1))
+
+(define pl-rv-env-4 {})
+(define pl-rv-goal-4 (pl-rv-goal "reverse([a, b, c, d], X)" pl-rv-env-4))
+(pl-solve-once! pl-rv-db pl-rv-goal-4 (pl-mk-trail))
+
+(pl-rv-test!
+  "reverse([a, b, c, d], X) → X = [d, c, b, a]"
+  (pl-rv-list-to-sx (dict-get pl-rv-env-4 "X"))
+  (list "d" "c" "b" "a"))
+
+(pl-rv-test!
+  "reverse([1, 2, 3], [3, 2, 1]) succeeds"
+  (pl-solve-once!
+    pl-rv-db
+    (pl-rv-goal "reverse([1, 2, 3], [3, 2, 1])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-rv-test!
+  "reverse([1, 2], [1, 2]) fails"
+  (pl-solve-once!
+    pl-rv-db
+    (pl-rv-goal "reverse([1, 2], [1, 2])" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-reverse-tests-run! (fn () {:failed pl-rv-test-fail :passed pl-rv-test-pass :total pl-rv-test-count :failures pl-rv-test-failures}))

lib/prolog/tests/query_api.sx

@@ -0,0 +1,127 @@
+;; lib/prolog/tests/query_api.sx — tests for pl-load/pl-query-all/pl-query-one/pl-query
+
+(define pl-qa-test-count 0)
+(define pl-qa-test-pass 0)
+(define pl-qa-test-fail 0)
+(define pl-qa-test-failures (list))
+
+(define
+  pl-qa-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-qa-test-count (+ pl-qa-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-qa-test-pass (+ pl-qa-test-pass 1))
+        (begin
+          (set! pl-qa-test-fail (+ pl-qa-test-fail 1))
+          (append!
+            pl-qa-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-qa-src
+  "parent(tom, bob). parent(tom, liz). parent(bob, ann). ancestor(X, Y) :- parent(X, Y). ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).")
+
+(define pl-qa-db (pl-load pl-qa-src))
+
+;; ── pl-load ──
+
+(pl-qa-test!
+  "pl-load returns a usable DB (pl-query-all non-nil)"
+  (not (nil? pl-qa-db))
+  true)
+
+;; ── pl-query-all: basic fact lookup ──
+
+(pl-qa-test!
+  "query-all parent(tom, X): 2 solutions"
+  (len (pl-query-all pl-qa-db "parent(tom, X)"))
+  2)
+
+(pl-qa-test!
+  "query-all parent(tom, X): first solution X=bob"
+  (dict-get (first (pl-query-all pl-qa-db "parent(tom, X)")) "X")
+  "bob")
+
+(pl-qa-test!
+  "query-all parent(tom, X): second solution X=liz"
+  (dict-get (nth (pl-query-all pl-qa-db "parent(tom, X)") 1) "X")
+  "liz")
+
+;; ── pl-query-all: no solutions ──
+
+(pl-qa-test!
+  "query-all no solutions returns empty list"
+  (pl-query-all pl-qa-db "parent(liz, X)")
+  (list))
+
+;; ── pl-query-all: boolean query (no vars) ──
+
+(pl-qa-test!
+  "boolean success: 1 solution (empty dict)"
+  (len (pl-query-all pl-qa-db "parent(tom, bob)"))
+  1)
+
+(pl-qa-test!
+  "boolean success: solution has no bindings"
+  (empty? (keys (first (pl-query-all pl-qa-db "parent(tom, bob)"))))
+  true)
+
+(pl-qa-test!
+  "boolean fail: 0 solutions"
+  (len (pl-query-all pl-qa-db "parent(bob, tom)"))
+  0)
+
+;; ── pl-query-all: multi-var ──
+
+(pl-qa-test!
+  "query-all parent(X, Y): 3 solutions total"
+  (len (pl-query-all pl-qa-db "parent(X, Y)"))
+  3)
+
+;; ── pl-query-all: rule-based (ancestor/2) ──
+
+(pl-qa-test!
+  "query-all ancestor(tom, X): 3 descendants (bob, liz, ann)"
+  (len (pl-query-all pl-qa-db "ancestor(tom, X)"))
+  3)
+
+;; ── pl-query-all: built-in in query ──
+
+(pl-qa-test!
+  "query with is/2 built-in"
+  (dict-get (first (pl-query-all pl-qa-db "X is 2 + 3")) "X")
+  "5")
+
+;; ── pl-query-one ──
+
+(pl-qa-test!
+  "query-one returns first solution"
+  (dict-get (pl-query-one pl-qa-db "parent(tom, X)") "X")
+  "bob")
+
+(pl-qa-test!
+  "query-one returns nil for no solutions"
+  (pl-query-one pl-qa-db "parent(liz, X)")
+  nil)
+
+;; ── pl-query convenience ──
+
+(pl-qa-test!
+  "pl-query convenience: count solutions"
+  (len (pl-query "likes(alice, bob). likes(alice, carol)." "likes(alice, X)"))
+  2)
+
+(pl-qa-test!
+  "pl-query convenience: first solution"
+  (dict-get (first (pl-query "likes(alice, bob). likes(alice, carol)." "likes(alice, X)")) "X")
+  "bob")
+
+(pl-qa-test!
+  "pl-query with empty source (built-ins only)"
+  (dict-get (first (pl-query "" "X is 6 * 7")) "X")
+  "42")
+
+(define pl-query-api-tests-run! (fn () {:failed pl-qa-test-fail :passed pl-qa-test-pass :total pl-qa-test-count :failures pl-qa-test-failures}))

lib/prolog/tests/set_predicates.sx

@@ -0,0 +1,195 @@
+;; lib/prolog/tests/set_predicates.sx — foldl/4, list_to_set/2, intersection/3, subtract/3, union/3
+
+(define pl-sp-test-count 0)
+(define pl-sp-test-pass 0)
+(define pl-sp-test-fail 0)
+(define pl-sp-test-failures (list))
+
+(define
+  pl-sp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-sp-test-count (+ pl-sp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-sp-test-pass (+ pl-sp-test-pass 1))
+        (begin
+          (set! pl-sp-test-fail (+ pl-sp-test-fail 1))
+          (append!
+            pl-sp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-sp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+;; DB with add/3 for foldl tests
+(define pl-sp-db (pl-mk-db))
+(pl-db-load! pl-sp-db (pl-parse "add(X, Acc, NAcc) :- NAcc is Acc + X."))
+
+;; ── foldl/4 ────────────────────────────────────────────────────────
+
+(define pl-sp-env-fl1 {:S (pl-mk-rt-var "S")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "foldl(add, [1,2,3,4], 0, S)" pl-sp-env-fl1)
+  (pl-mk-trail))
+(pl-sp-test!
+  "foldl(add,[1,2,3,4],0,S) -> S=10"
+  (pl-num-val (pl-walk-deep (dict-get pl-sp-env-fl1 "S")))
+  10)
+
+(define pl-sp-env-fl2 {:S (pl-mk-rt-var "S")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "foldl(add, [], 5, S)" pl-sp-env-fl2)
+  (pl-mk-trail))
+(pl-sp-test!
+  "foldl(add,[],5,S) -> S=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-sp-env-fl2 "S")))
+  5)
+
+(define pl-sp-env-fl3 {:S (pl-mk-rt-var "S")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "foldl(add, [1,2,3], 0, S)" pl-sp-env-fl3)
+  (pl-mk-trail))
+(pl-sp-test!
+  "foldl(add,[1,2,3],0,S) -> S=6"
+  (pl-num-val (pl-walk-deep (dict-get pl-sp-env-fl3 "S")))
+  6)
+
+;; ── list_to_set/2 ──────────────────────────────────────────────────
+
+(define pl-sp-env-lts1 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "list_to_set([1,2,3,2,1], R)" pl-sp-env-lts1)
+  (pl-mk-trail))
+(pl-sp-test!
+  "list_to_set([1,2,3,2,1],R) -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-lts1 "R")))
+  ".(1, .(2, .(3, [])))")
+
+(define pl-sp-env-lts2 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "list_to_set([], R)" pl-sp-env-lts2)
+  (pl-mk-trail))
+(pl-sp-test!
+  "list_to_set([],R) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-lts2 "R")))
+  "[]")
+
+(define pl-sp-env-lts3 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "list_to_set([a,b,a,c], R)" pl-sp-env-lts3)
+  (pl-mk-trail))
+(pl-sp-test!
+  "list_to_set([a,b,a,c],R) -> [a,b,c]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-lts3 "R")))
+  ".(a, .(b, .(c, [])))")
+
+;; ── intersection/3 ─────────────────────────────────────────────────
+
+(define pl-sp-env-int1 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "intersection([1,2,3,4], [2,4,6], R)" pl-sp-env-int1)
+  (pl-mk-trail))
+(pl-sp-test!
+  "intersection([1,2,3,4],[2,4,6],R) -> [2,4]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-int1 "R")))
+  ".(2, .(4, []))")
+
+(define pl-sp-env-int2 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "intersection([1,2,3], [4,5,6], R)" pl-sp-env-int2)
+  (pl-mk-trail))
+(pl-sp-test!
+  "intersection([1,2,3],[4,5,6],R) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-int2 "R")))
+  "[]")
+
+(define pl-sp-env-int3 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "intersection([], [1,2,3], R)" pl-sp-env-int3)
+  (pl-mk-trail))
+(pl-sp-test!
+  "intersection([],[1,2,3],R) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-int3 "R")))
+  "[]")
+
+;; ── subtract/3 ─────────────────────────────────────────────────────
+
+(define pl-sp-env-sub1 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "subtract([1,2,3,4], [2,4], R)" pl-sp-env-sub1)
+  (pl-mk-trail))
+(pl-sp-test!
+  "subtract([1,2,3,4],[2,4],R) -> [1,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-sub1 "R")))
+  ".(1, .(3, []))")
+
+(define pl-sp-env-sub2 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "subtract([1,2,3], [], R)" pl-sp-env-sub2)
+  (pl-mk-trail))
+(pl-sp-test!
+  "subtract([1,2,3],[],R) -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-sub2 "R")))
+  ".(1, .(2, .(3, [])))")
+
+(define pl-sp-env-sub3 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "subtract([], [1,2], R)" pl-sp-env-sub3)
+  (pl-mk-trail))
+(pl-sp-test!
+  "subtract([],[1,2],R) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-sub3 "R")))
+  "[]")
+
+;; ── union/3 ────────────────────────────────────────────────────────
+
+(define pl-sp-env-uni1 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "union([1,2,3], [2,3,4], R)" pl-sp-env-uni1)
+  (pl-mk-trail))
+(pl-sp-test!
+  "union([1,2,3],[2,3,4],R) -> [1,2,3,4]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-uni1 "R")))
+  ".(1, .(2, .(3, .(4, []))))")
+
+(define pl-sp-env-uni2 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "union([], [1,2], R)" pl-sp-env-uni2)
+  (pl-mk-trail))
+(pl-sp-test!
+  "union([],[1,2],R) -> [1,2]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-uni2 "R")))
+  ".(1, .(2, []))")
+
+(define pl-sp-env-uni3 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-sp-db
+  (pl-sp-goal "union([1,2], [], R)" pl-sp-env-uni3)
+  (pl-mk-trail))
+(pl-sp-test!
+  "union([1,2],[],R) -> [1,2]"
+  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-uni3 "R")))
+  ".(1, .(2, []))")
+
+;; ── Runner ─────────────────────────────────────────────────────────
+
+(define pl-set-predicates-tests-run! (fn () {:failed pl-sp-test-fail :passed pl-sp-test-pass :total pl-sp-test-count :failures pl-sp-test-failures}))

lib/prolog/tests/solve.sx

@@ -0,0 +1,618 @@
+;; lib/prolog/tests/solve.sx — DFS solver unit tests
+
+(define pl-s-test-count 0)
+(define pl-s-test-pass 0)
+(define pl-s-test-fail 0)
+(define pl-s-test-failures (list))
+
+(define
+  pl-s-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-s-test-count (+ pl-s-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-s-test-pass (+ pl-s-test-pass 1))
+        (begin
+          (set! pl-s-test-fail (+ pl-s-test-fail 1))
+          (append!
+            pl-s-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-s-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-s-empty-db (pl-mk-db))
+
+(pl-s-test!
+  "true succeeds"
+  (pl-solve-once! pl-s-empty-db (pl-s-goal "true" {}) (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "fail fails"
+  (pl-solve-once! pl-s-empty-db (pl-s-goal "fail" {}) (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "= identical atoms"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "=(a, a)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "= different atoms"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "=(a, b)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "= var to atom"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "=(X, foo)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-s-env-bind {})
+(define pl-s-trail-bind (pl-mk-trail))
+(define pl-s-goal-bind (pl-s-goal "=(X, foo)" pl-s-env-bind))
+(pl-solve-once! pl-s-empty-db pl-s-goal-bind pl-s-trail-bind)
+
+(pl-s-test!
+  "X bound to foo after =(X, foo)"
+  (pl-atom-name (pl-walk-deep (dict-get pl-s-env-bind "X")))
+  "foo")
+
+(pl-s-test!
+  "true , true succeeds"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "true, true" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "true , fail fails"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "true, fail" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "consistent X bindings succeed"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "=(X, a), =(X, a)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "conflicting X bindings fail"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "=(X, a), =(X, b)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-s-db1 (pl-mk-db))
+(pl-db-load!
+  pl-s-db1
+  (pl-parse "parent(tom, bob). parent(bob, liz). parent(bob, ann)."))
+
+(pl-s-test!
+  "fact lookup hit"
+  (pl-solve-once!
+    pl-s-db1
+    (pl-s-goal "parent(tom, bob)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "fact lookup miss"
+  (pl-solve-once!
+    pl-s-db1
+    (pl-s-goal "parent(tom, liz)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "all parent solutions"
+  (pl-solve-count!
+    pl-s-db1
+    (pl-s-goal "parent(X, Y)" {})
+    (pl-mk-trail))
+  3)
+
+(pl-s-test!
+  "fixed first arg solutions"
+  (pl-solve-count!
+    pl-s-db1
+    (pl-s-goal "parent(bob, Y)" {})
+    (pl-mk-trail))
+  2)
+
+(define pl-s-db2 (pl-mk-db))
+(pl-db-load!
+  pl-s-db2
+  (pl-parse
+    "parent(tom, bob). parent(bob, ann). ancestor(X, Y) :- parent(X, Y). ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z)."))
+
+(pl-s-test!
+  "rule direct ancestor"
+  (pl-solve-once!
+    pl-s-db2
+    (pl-s-goal "ancestor(tom, bob)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "rule transitive ancestor"
+  (pl-solve-once!
+    pl-s-db2
+    (pl-s-goal "ancestor(tom, ann)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "rule no path"
+  (pl-solve-once!
+    pl-s-db2
+    (pl-s-goal "ancestor(ann, tom)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-s-env-undo {})
+(define pl-s-trail-undo (pl-mk-trail))
+(define pl-s-goal-undo (pl-s-goal "=(X, a), fail" pl-s-env-undo))
+(pl-solve-once! pl-s-empty-db pl-s-goal-undo pl-s-trail-undo)
+
+(pl-s-test!
+  "trail undone after failure leaves X unbound"
+  (pl-var-bound? (dict-get pl-s-env-undo "X"))
+  false)
+
+(define pl-s-db-cut1 (pl-mk-db))
+
+(pl-db-load! pl-s-db-cut1 (pl-parse "g :- !. g :- true."))
+
+(pl-s-test!
+  "bare cut succeeds"
+  (pl-solve-once! pl-s-db-cut1 (pl-s-goal "g" {}) (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "cut commits to first matching clause"
+  (pl-solve-count! pl-s-db-cut1 (pl-s-goal "g" {}) (pl-mk-trail))
+  1)
+
+(define pl-s-db-cut2 (pl-mk-db))
+
+(pl-db-load! pl-s-db-cut2 (pl-parse "a(1). a(2). g(X) :- a(X), !."))
+
+(pl-s-test!
+  "cut commits to first a solution"
+  (pl-solve-count! pl-s-db-cut2 (pl-s-goal "g(X)" {}) (pl-mk-trail))
+  1)
+
+(define pl-s-db-cut3 (pl-mk-db))
+
+(pl-db-load!
+  pl-s-db-cut3
+  (pl-parse "a(1). a(2). g(X) :- a(X), !, fail. g(99)."))
+
+(pl-s-test!
+  "cut then fail blocks alt clauses"
+  (pl-solve-count! pl-s-db-cut3 (pl-s-goal "g(X)" {}) (pl-mk-trail))
+  0)
+
+(define pl-s-db-cut4 (pl-mk-db))
+
+(pl-db-load!
+  pl-s-db-cut4
+  (pl-parse "a(1). b(10). b(20). g(X, Y) :- a(X), !, b(Y)."))
+
+(pl-s-test!
+  "post-cut goal backtracks freely"
+  (pl-solve-count!
+    pl-s-db-cut4
+    (pl-s-goal "g(X, Y)" {})
+    (pl-mk-trail))
+  2)
+
+(define pl-s-db-cut5 (pl-mk-db))
+
+(pl-db-load!
+  pl-s-db-cut5
+  (pl-parse "r(1). r(2). q :- r(X), !. p :- q. p :- true."))
+
+(pl-s-test!
+  "inner cut does not commit outer predicate"
+  (pl-solve-count! pl-s-db-cut5 (pl-s-goal "p" {}) (pl-mk-trail))
+  2)
+
+(pl-s-test!
+  "\\= different atoms succeeds"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "\\=(a, b)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "\\= same atoms fails"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "\\=(a, a)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "\\= var-vs-atom would unify so fails"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "\\=(X, a)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-s-env-ne {})
+
+(define pl-s-trail-ne (pl-mk-trail))
+
+(define pl-s-goal-ne (pl-s-goal "\\=(X, a)" pl-s-env-ne))
+
+(pl-solve-once! pl-s-empty-db pl-s-goal-ne pl-s-trail-ne)
+
+(pl-s-test!
+  "\\= leaves no bindings"
+  (pl-var-bound? (dict-get pl-s-env-ne "X"))
+  false)
+
+(pl-s-test!
+  "; left succeeds"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal ";(true, fail)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "; right succeeds when left fails"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal ";(fail, true)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "; both fail"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal ";(fail, fail)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "; both branches counted"
+  (pl-solve-count!
+    pl-s-empty-db
+    (pl-s-goal ";(true, true)" {})
+    (pl-mk-trail))
+  2)
+
+(define pl-s-db-call (pl-mk-db))
+
+(pl-db-load! pl-s-db-call (pl-parse "p(1). p(2)."))
+
+(pl-s-test!
+  "call(true) succeeds"
+  (pl-solve-once!
+    pl-s-db-call
+    (pl-s-goal "call(true)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "call(p(X)) yields all solutions"
+  (pl-solve-count!
+    pl-s-db-call
+    (pl-s-goal "call(p(X))" {})
+    (pl-mk-trail))
+  2)
+
+(pl-s-test!
+  "call of bound goal var resolves"
+  (pl-solve-once!
+    pl-s-db-call
+    (pl-s-goal "=(G, true), call(G)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-s-db-ite (pl-mk-db))
+
+(pl-db-load! pl-s-db-ite (pl-parse "p(1). p(2). q(yes). q(no)."))
+
+(pl-s-test!
+  "if-then-else: cond true → then runs"
+  (pl-solve-once!
+    pl-s-db-ite
+    (pl-s-goal ";(->(true, =(X, ok)), =(X, fallback))" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-s-env-ite1 {})
+
+(pl-solve-once!
+  pl-s-db-ite
+  (pl-s-goal ";(->(true, =(X, ok)), =(X, fallback))" pl-s-env-ite1)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "if-then-else: cond true binds via then"
+  (pl-atom-name (pl-walk-deep (dict-get pl-s-env-ite1 "X")))
+  "ok")
+
+(pl-s-test!
+  "if-then-else: cond false → else"
+  (pl-solve-once!
+    pl-s-db-ite
+    (pl-s-goal ";(->(fail, =(X, ok)), =(X, fallback))" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-s-env-ite2 {})
+
+(pl-solve-once!
+  pl-s-db-ite
+  (pl-s-goal ";(->(fail, =(X, ok)), =(X, fallback))" pl-s-env-ite2)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "if-then-else: cond false binds via else"
+  (pl-atom-name (pl-walk-deep (dict-get pl-s-env-ite2 "X")))
+  "fallback")
+
+(pl-s-test!
+  "if-then-else: cond commits to first solution (count = 1)"
+  (pl-solve-count!
+    pl-s-db-ite
+    (pl-s-goal ";(->(p(X), =(Y, found)), =(Y, none))" {})
+    (pl-mk-trail))
+  1)
+
+(pl-s-test!
+  "if-then-else: then can backtrack"
+  (pl-solve-count!
+    pl-s-db-ite
+    (pl-s-goal ";(->(true, p(X)), =(X, none))" {})
+    (pl-mk-trail))
+  2)
+
+(pl-s-test!
+  "if-then-else: else can backtrack"
+  (pl-solve-count!
+    pl-s-db-ite
+    (pl-s-goal ";(->(fail, =(X, ignored)), p(X))" {})
+    (pl-mk-trail))
+  2)
+
+(pl-s-test!
+  "standalone -> with true cond succeeds"
+  (pl-solve-once!
+    pl-s-db-ite
+    (pl-s-goal "->(true, =(X, hi))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "standalone -> with false cond fails"
+  (pl-solve-once!
+    pl-s-db-ite
+    (pl-s-goal "->(fail, =(X, hi))" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "write(hello)"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once!
+      pl-s-empty-db
+      (pl-s-goal "write(hello)" {})
+      (pl-mk-trail))
+    pl-output-buffer)
+  "hello")
+
+(pl-s-test!
+  "nl outputs newline"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once! pl-s-empty-db (pl-s-goal "nl" {}) (pl-mk-trail))
+    pl-output-buffer)
+  "\n")
+
+(pl-s-test!
+  "write(42) outputs digits"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once!
+      pl-s-empty-db
+      (pl-s-goal "write(42)" {})
+      (pl-mk-trail))
+    pl-output-buffer)
+  "42")
+
+(pl-s-test!
+  "write(foo(a, b)) formats compound"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once!
+      pl-s-empty-db
+      (pl-s-goal "write(foo(a, b))" {})
+      (pl-mk-trail))
+    pl-output-buffer)
+  "foo(a, b)")
+
+(pl-s-test!
+  "write conjunction"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once!
+      pl-s-empty-db
+      (pl-s-goal "write(a), write(b)" {})
+      (pl-mk-trail))
+    pl-output-buffer)
+  "ab")
+
+(pl-s-test!
+  "write of bound var walks binding"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once!
+      pl-s-empty-db
+      (pl-s-goal "=(X, hello), write(X)" {})
+      (pl-mk-trail))
+    pl-output-buffer)
+  "hello")
+
+(pl-s-test!
+  "write then nl"
+  (begin
+    (pl-output-clear!)
+    (pl-solve-once!
+      pl-s-empty-db
+      (pl-s-goal "write(hi), nl" {})
+      (pl-mk-trail))
+    pl-output-buffer)
+  "hi\n")
+
+(define pl-s-env-arith1 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, 42)" pl-s-env-arith1)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, 42) binds X to 42"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith1 "X")))
+  42)
+
+(define pl-s-env-arith2 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, +(2, 3))" pl-s-env-arith2)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, +(2, 3)) binds X to 5"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith2 "X")))
+  5)
+
+(define pl-s-env-arith3 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, *(2, 3))" pl-s-env-arith3)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, *(2, 3)) binds X to 6"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith3 "X")))
+  6)
+
+(define pl-s-env-arith4 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, -(10, 3))" pl-s-env-arith4)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, -(10, 3)) binds X to 7"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith4 "X")))
+  7)
+
+(define pl-s-env-arith5 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, /(10, 2))" pl-s-env-arith5)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, /(10, 2)) binds X to 5"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith5 "X")))
+  5)
+
+(define pl-s-env-arith6 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, mod(10, 3))" pl-s-env-arith6)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, mod(10, 3)) binds X to 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith6 "X")))
+  1)
+
+(define pl-s-env-arith7 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, abs(-(0, 5)))" pl-s-env-arith7)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, abs(-(0, 5))) binds X to 5"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith7 "X")))
+  5)
+
+(define pl-s-env-arith8 {})
+
+(pl-solve-once!
+  pl-s-empty-db
+  (pl-s-goal "is(X, +(2, *(3, 4)))" pl-s-env-arith8)
+  (pl-mk-trail))
+
+(pl-s-test!
+  "is(X, +(2, *(3, 4))) binds X to 14 (nested)"
+  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith8 "X")))
+  14)
+
+(pl-s-test!
+  "is(5, +(2, 3)) succeeds (LHS num matches)"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "is(5, +(2, 3))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-s-test!
+  "is(6, +(2, 3)) fails (LHS num mismatch)"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "is(6, +(2, 3))" {})
+    (pl-mk-trail))
+  false)
+
+(pl-s-test!
+  "is propagates bound vars on RHS"
+  (pl-solve-once!
+    pl-s-empty-db
+    (pl-s-goal "=(Y, 4), is(X, +(Y, 1)), =(X, 5)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-solve-tests-run! (fn () {:failed pl-s-test-fail :passed pl-s-test-pass :total pl-s-test-count :failures pl-s-test-failures}))

lib/prolog/tests/string_agg.sx

@@ -0,0 +1,273 @@
+;; lib/prolog/tests/string_agg.sx -- sub_atom/5 + aggregate_all/3
+
+(define pl-sa-test-count 0)
+(define pl-sa-test-pass 0)
+(define pl-sa-test-fail 0)
+(define pl-sa-test-failures (list))
+
+(define
+  pl-sa-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-sa-test-count (+ pl-sa-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-sa-test-pass (+ pl-sa-test-pass 1))
+        (begin
+          (set! pl-sa-test-fail (+ pl-sa-test-fail 1))
+          (append!
+            pl-sa-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-sa-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-sa-db (pl-mk-db))
+
+(define
+  pl-sa-num-val
+  (fn (env key) (pl-num-val (pl-walk-deep (dict-get env key)))))
+
+(define
+  pl-sa-list-to-atoms
+  (fn
+    (t)
+    (let
+      ((w (pl-walk-deep t)))
+      (cond
+        ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+        ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+          (cons
+            (pl-atom-name (first (pl-args w)))
+            (pl-sa-list-to-atoms (nth (pl-args w) 1))))
+        (true (list))))))
+
+(define pl-sa-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
+(pl-db-load! pl-sa-db (pl-parse pl-sa-prog-src))
+
+;; -- sub_atom/5 --
+
+(pl-sa-test!
+  "sub_atom ground: sub_atom(abcde,0,3,2,abc)"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "sub_atom(abcde, 0, 3, 2, abc)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-sa-test!
+  "sub_atom ground: sub_atom(abcde,2,2,1,cd)"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "sub_atom(abcde, 2, 2, 1, cd)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-sa-test!
+  "sub_atom ground mismatch fails"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "sub_atom(abcde, 0, 2, 3, cd)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-sa-test!
+  "sub_atom empty sub at start"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "sub_atom(abcde, 0, 0, 5, '')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-sa-test!
+  "sub_atom whole string"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "sub_atom(hello, 0, 5, 0, hello)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-sa-env-b1 {})
+(pl-solve-once!
+  pl-sa-db
+  (pl-sa-goal "sub_atom(abcde, B, 2, A, cd)" pl-sa-env-b1)
+  (pl-mk-trail))
+(pl-sa-test!
+  "sub_atom bound SubAtom gives B=2"
+  (pl-sa-num-val pl-sa-env-b1 "B")
+  2)
+(pl-sa-test!
+  "sub_atom bound SubAtom gives A=1"
+  (pl-sa-num-val pl-sa-env-b1 "A")
+  1)
+
+(define pl-sa-env-b2 {})
+(pl-solve-once!
+  pl-sa-db
+  (pl-sa-goal "sub_atom(hello, B, L, A, ello)" pl-sa-env-b2)
+  (pl-mk-trail))
+(pl-sa-test! "sub_atom ello: B=1" (pl-sa-num-val pl-sa-env-b2 "B") 1)
+(pl-sa-test! "sub_atom ello: L=4" (pl-sa-num-val pl-sa-env-b2 "L") 4)
+(pl-sa-test! "sub_atom ello: A=0" (pl-sa-num-val pl-sa-env-b2 "A") 0)
+
+(pl-sa-test!
+  "sub_atom ab: 6 total solutions"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(count, sub_atom(ab, _, _, _, _), N)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "N"))
+  6)
+
+(pl-sa-test!
+  "sub_atom a: 3 total solutions"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(count, sub_atom(a, _, _, _, _), N)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "N"))
+  3)
+
+;; -- aggregate_all/3 --
+
+(pl-sa-test!
+  "aggregate_all count member [a,b,c] = 3"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(count, member(_, [a,b,c]), N)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "N"))
+  3)
+
+(pl-sa-test!
+  "aggregate_all count fail = 0"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(count, fail, N)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "N"))
+  0)
+
+(pl-sa-test!
+  "aggregate_all count always succeeds"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "aggregate_all(count, fail, _)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-sa-env-bag1 {})
+(pl-solve-once!
+  pl-sa-db
+  (pl-sa-goal "aggregate_all(bag(X), member(X, [a,b,c]), L)" pl-sa-env-bag1)
+  (pl-mk-trail))
+(pl-sa-test!
+  "aggregate_all bag [a,b,c]"
+  (pl-sa-list-to-atoms (dict-get pl-sa-env-bag1 "L"))
+  (list "a" "b" "c"))
+
+(define pl-sa-env-bag2 {})
+(pl-solve-once!
+  pl-sa-db
+  (pl-sa-goal "aggregate_all(bag(X), member(X, []), L)" pl-sa-env-bag2)
+  (pl-mk-trail))
+(pl-sa-test!
+  "aggregate_all bag empty goal = []"
+  (pl-sa-list-to-atoms (dict-get pl-sa-env-bag2 "L"))
+  (list))
+
+(pl-sa-test!
+  "aggregate_all sum [1,2,3,4] = 10"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(sum(X), member(X, [1,2,3,4]), S)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "S"))
+  10)
+
+(pl-sa-test!
+  "aggregate_all max [3,1,4,1,5,9,2,6] = 9"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(max(X), member(X, [3,1,4,1,5,9,2,6]), M)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "M"))
+  9)
+
+(pl-sa-test!
+  "aggregate_all max empty fails"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "aggregate_all(max(X), member(X, []), M)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-sa-test!
+  "aggregate_all min [3,1,4,1,5,9,2,6] = 1"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(min(X), member(X, [3,1,4,1,5,9,2,6]), M)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "M"))
+  1)
+
+(pl-sa-test!
+  "aggregate_all min empty fails"
+  (pl-solve-once!
+    pl-sa-db
+    (pl-sa-goal "aggregate_all(min(X), member(X, []), M)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-sa-env-set1 {})
+(pl-solve-once!
+  pl-sa-db
+  (pl-sa-goal
+    "aggregate_all(set(X), member(X, [b,a,c,a,b]), S)"
+    pl-sa-env-set1)
+  (pl-mk-trail))
+(pl-sa-test!
+  "aggregate_all set [b,a,c,a,b] = [a,b,c]"
+  (pl-sa-list-to-atoms (dict-get pl-sa-env-set1 "S"))
+  (list "a" "b" "c"))
+
+(define pl-sa-env-set2 {})
+(pl-solve-once!
+  pl-sa-db
+  (pl-sa-goal "aggregate_all(set(X), fail, S)" pl-sa-env-set2)
+  (pl-mk-trail))
+(pl-sa-test!
+  "aggregate_all set fail = []"
+  (pl-sa-list-to-atoms (dict-get pl-sa-env-set2 "S"))
+  (list))
+
+(pl-sa-test!
+  "aggregate_all sum empty = 0"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-sa-db
+      (pl-sa-goal "aggregate_all(sum(X), fail, S)" env)
+      (pl-mk-trail))
+    (pl-sa-num-val env "S"))
+  0)
+
+(define pl-string-agg-tests-run! (fn () {:failed pl-sa-test-fail :passed pl-sa-test-pass :total pl-sa-test-count :failures pl-sa-test-failures}))

lib/prolog/tests/term_inspect.sx

@@ -0,0 +1,147 @@
+;; lib/prolog/tests/term_inspect.sx — copy_term/2, functor/3, arg/3.
+
+(define pl-tt-test-count 0)
+(define pl-tt-test-pass 0)
+(define pl-tt-test-fail 0)
+(define pl-tt-test-failures (list))
+
+(define
+  pl-tt-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-tt-test-count (+ pl-tt-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-tt-test-pass (+ pl-tt-test-pass 1))
+        (begin
+          (set! pl-tt-test-fail (+ pl-tt-test-fail 1))
+          (append!
+            pl-tt-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-tt-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-tt-db (pl-mk-db))
+
+;; ── copy_term/2 ──
+
+(pl-tt-test!
+  "copy_term ground compound succeeds + copy = original"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "copy_term(foo(a, b), X), X = foo(a, b)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-tt-test!
+  "copy_term preserves var aliasing in source"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "copy_term(p(Y, Y), p(A, B)), A = 5, B = 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-tt-test!
+  "copy_term distinct vars stay distinct"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "copy_term(p(Y, Y), p(A, B)), A = 5, B = 6" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-tt-env-1 {})
+(pl-solve-once!
+  pl-tt-db
+  (pl-tt-goal "copy_term(X, Y), Y = 5" pl-tt-env-1)
+  (pl-mk-trail))
+(pl-tt-test!
+  "copy_term: binding the copy doesn't bind the source"
+  (pl-var-bound? (dict-get pl-tt-env-1 "X"))
+  false)
+
+;; ── functor/3 ──
+
+(define pl-tt-env-2 {})
+(pl-solve-once!
+  pl-tt-db
+  (pl-tt-goal "functor(foo(a, b, c), F, N)" pl-tt-env-2)
+  (pl-mk-trail))
+(pl-tt-test!
+  "functor of compound: F = foo"
+  (pl-atom-name (pl-walk-deep (dict-get pl-tt-env-2 "F")))
+  "foo")
+(pl-tt-test!
+  "functor of compound: N = 3"
+  (pl-num-val (pl-walk-deep (dict-get pl-tt-env-2 "N")))
+  3)
+
+(define pl-tt-env-3 {})
+(pl-solve-once!
+  pl-tt-db
+  (pl-tt-goal "functor(hello, F, N)" pl-tt-env-3)
+  (pl-mk-trail))
+(pl-tt-test!
+  "functor of atom: F = hello"
+  (pl-atom-name (pl-walk-deep (dict-get pl-tt-env-3 "F")))
+  "hello")
+(pl-tt-test!
+  "functor of atom: N = 0"
+  (pl-num-val (pl-walk-deep (dict-get pl-tt-env-3 "N")))
+  0)
+
+(pl-tt-test!
+  "functor construct compound: T unifies with foo(a, b)"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "functor(T, foo, 2), T = foo(a, b)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-tt-test!
+  "functor construct atom: T = hello"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "functor(T, hello, 0), T = hello" {})
+    (pl-mk-trail))
+  true)
+
+;; ── arg/3 ──
+
+(pl-tt-test!
+  "arg(1, foo(a, b, c), a)"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "arg(1, foo(a, b, c), a)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-tt-test!
+  "arg(2, foo(a, b, c), X) → X = b"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "arg(2, foo(a, b, c), X), X = b" {})
+    (pl-mk-trail))
+  true)
+
+(pl-tt-test!
+  "arg out-of-range high fails"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "arg(4, foo(a, b, c), X)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-tt-test!
+  "arg(0, ...) fails (1-indexed)"
+  (pl-solve-once!
+    pl-tt-db
+    (pl-tt-goal "arg(0, foo(a), X)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-term-inspect-tests-run! (fn () {:failed pl-tt-test-fail :passed pl-tt-test-pass :total pl-tt-test-count :failures pl-tt-test-failures}))

lib/tcl/conformance.sh

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+# Tcl-on-SX conformance runner — epoch protocol to sx_server.exe
+# Usage: lib/tcl/conformance.sh [file.tcl ...]
+#   Defaults to lib/tcl/tests/programs/*.tcl
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX_SERVER" ]; then
+  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
+fi
+if [ ! -x "$SX_SERVER" ]; then echo "ERROR: sx_server.exe not found"; exit 1; fi
+
+SCOREBOARD_JSON="${SCOREBOARD_JSON:-lib/tcl/scoreboard.json}"
+SCOREBOARD_MD="${SCOREBOARD_MD:-lib/tcl/scoreboard.md}"
+
+# Collect tcl files
+if [ "$#" -gt 0 ]; then
+  TCL_FILES=("$@")
+else
+  TCL_FILES=(lib/tcl/tests/programs/*.tcl)
+fi
+
+# Generate a helper .sx file that defines the Tcl source as an SX string variable.
+# We escape the source for SX string literals: backslashes → \\, quotes → \", newlines → \n.
+# This is safe in a (define ...) context — no double-parsing like (eval "...") would cause.
+write_sx_helper() {
+  local tcl_file="$1"
+  local helper_file="$2"
+  python3 << PYEOF
+src = open('${tcl_file}').read()
+escaped = src.replace('\\\\', '\\\\\\\\').replace('"', '\\\\"').replace('\\n', '\\\\n')
+with open('${helper_file}', 'w') as f:
+    f.write(f'(define __tcl-src "{escaped}")\\n')
+    f.write('(define __tcl-result (get (tcl-eval-string (make-default-tcl-interp) __tcl-src) :result))\\n')
+PYEOF
+}
+
+total=0
+passed=0
+failed=0
+programs_json=""
+md_rows=""
+
+for tcl_file in "${TCL_FILES[@]}"; do
+  basename_noext=$(basename "$tcl_file" .tcl)
+  total=$((total + 1))
+
+  # Read expected value from first-line comment "# expected: VALUE"
+  expected=$(head -1 "$tcl_file" | sed -n 's/^# expected: *//p')
+  if [ -z "$expected" ]; then
+    echo "WARN: no '# expected:' annotation in $tcl_file — skipping"
+    continue
+  fi
+
+  tmpfile=$(mktemp)
+  helper=$(mktemp --suffix=.sx)
+  trap "rm -f $tmpfile $helper" EXIT
+
+  # Write helper .sx with Tcl source embedded as SX string
+  write_sx_helper "$tcl_file" "$helper"
+
+  # Build epoch input using quoted heredoc for static parts; helper path via variable
+  cat > "$tmpfile" << EPOCHS
+(epoch 1)
+(load "lib/tcl/tokenizer.sx")
+(epoch 2)
+(load "lib/tcl/parser.sx")
+(epoch 3)
+(load "lib/tcl/runtime.sx")
+(epoch 4)
+(load "$helper")
+(epoch 5)
+(eval "__tcl-result")
+(epoch 6)
+EPOCHS
+
+  output=$(timeout 30 "$SX_SERVER" < "$tmpfile" 2>&1)
+  got=$(echo "$output" | grep -A1 "^(ok-len 5 " | tail -1 | tr -d '"')
+
+  if [ "$got" = "$expected" ]; then
+    status="PASS"
+    passed=$((passed + 1))
+    echo "PASS  $basename_noext  (expected: $expected, got: $got)"
+  else
+    status="FAIL"
+    failed=$((failed + 1))
+    echo "FAIL  $basename_noext  (expected: $expected, got: ${got:-<empty>})"
+    if [ -n "${VERBOSE:-}" ]; then
+      echo "--- server output ---"
+      echo "$output"
+      echo "--- helper.sx ---"
+      cat "$helper"
+    fi
+  fi
+
+  # Accumulate JSON fragment (escape for JSON)
+  got_json=$(printf '%s' "$got" | python3 -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read()))" | tr -d '"')
+  exp_json=$(printf '%s' "$expected" | python3 -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read()))" | tr -d '"')
+
+  if [ -n "$programs_json" ]; then
+    programs_json="${programs_json},"
+  fi
+  programs_json="${programs_json}
+    \"${basename_noext}\": {\"status\": \"${status}\", \"expected\": \"${exp_json}\", \"got\": \"${got_json}\"}"
+
+  # Accumulate Markdown row
+  if [ "$status" = "PASS" ]; then
+    icon="✓ PASS"
+  else
+    icon="✗ FAIL"
+  fi
+  md_rows="${md_rows}| ${basename_noext} | ${icon} | ${expected} | ${got} |
+"
+done
+
+# Write scoreboard.json
+cat > "$SCOREBOARD_JSON" << JSON
+{
+  "total": ${total},
+  "passed": ${passed},
+  "failed": ${failed},
+  "programs": {${programs_json}
+  }
+}
+JSON
+
+# Write scoreboard.md
+cat > "$SCOREBOARD_MD" << MD
+# Tcl-on-SX Conformance Scoreboard
+
+| Program | Status | Expected | Got |
+|---|---|---|---|
+${md_rows}
+**${passed}/${total} passing**
+MD
+
+echo ""
+echo "Scoreboard: ${passed}/${total} passing"
+echo "Written: $SCOREBOARD_JSON, $SCOREBOARD_MD"
+
+if [ "$failed" -gt 0 ]; then
+  exit 1
+fi
+exit 0

lib/tcl/parser.sx

@@ -0,0 +1,41 @@
+; Tcl parser — thin layer over tcl-tokenize
+; Adds tcl-parse entry point and word utility fns
+
+; Entry point: parse Tcl source to a list of commands.
+; Returns same structure as tcl-tokenize.
+(define tcl-parse (fn (src) (tcl-tokenize src)))
+
+; True if word has no substitutions — value can be read statically.
+; braced words are always simple. compound words are simple when all
+; parts are plain text with no var/cmd parts.
+(define tcl-word-simple?
+  (fn (word)
+    (cond
+      ((= (get word :type) "braced") true)
+      ((= (get word :type) "compound")
+        (let ((parts (get word :parts)))
+          (every? (fn (p) (= (get p :type) "text")) parts)))
+      (else false))))
+
+; Concatenate text parts of a simple word into a single string.
+; For braced words returns :value directly.
+; For compound words with only text parts, joins them.
+; Returns nil for words with substitutions.
+(define tcl-word-literal
+  (fn (word)
+    (cond
+      ((= (get word :type) "braced") (get word :value))
+      ((= (get word :type) "compound")
+        (if (tcl-word-simple? word)
+          (join "" (map (fn (p) (get p :value)) (get word :parts)))
+          nil))
+      (else nil))))
+
+; Number of words in a parsed command.
+(define tcl-cmd-len
+  (fn (cmd) (len (get cmd :words))))
+
+; Nth word literal from a command (index 0 = command name).
+; Returns nil if word has substitutions.
+(define tcl-nth-literal
+  (fn (cmd n) (tcl-word-literal (nth (get cmd :words) n))))

lib/tcl/scoreboard.json

@@ -0,0 +1,10 @@
+{
+  "total": 3,
+  "passed": 3,
+  "failed": 0,
+  "programs": {
+    "assert": {"status": "PASS", "expected": "10", "got": "10"},
+    "for-each-line": {"status": "PASS", "expected": "13", "got": "13"},
+    "with-temp-var": {"status": "PASS", "expected": "100 999", "got": "100 999"}
+  }
+}

lib/tcl/scoreboard.md

@@ -0,0 +1,9 @@
+# Tcl-on-SX Conformance Scoreboard
+
+| Program | Status | Expected | Got |
+|---|---|---|---|
+| assert | ✓ PASS | 10 | 10 |
+| for-each-line | ✓ PASS | 13 | 13 |
+| with-temp-var | ✓ PASS | 100 999 | 100 999 |
+
+**3/3 passing**

lib/tcl/test.sh

@@ -1,6 +1,5 @@
 #!/usr/bin/env bash
-# lib/tcl/test.sh — smoke-test the Tcl runtime layer.
-
+# Tcl-on-SX test runner — epoch protocol to sx_server.exe
 set -uo pipefail
 cd "$(git rev-parse --show-toplevel)"
 
@@ -8,55 +7,107 @@ SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
 if [ ! -x "$SX_SERVER" ]; then
   SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
 fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
+if [ ! -x "$SX_SERVER" ]; then echo "ERROR: sx_server.exe not found"; exit 1; fi
 
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
+VERBOSE="${1:-}"
+TMPFILE=$(mktemp)
+HELPER=$(mktemp --suffix=.sx)
+trap "rm -f $TMPFILE $HELPER" EXIT
 
-cat > "$TMPFILE" << 'EPOCHS'
+# Helper file: run all test suites and format a parseable summary string
+cat > "$HELPER" << 'HELPER_EOF'
+(define __pr (tcl-run-parse-tests))
+(define __er (tcl-run-eval-tests))
+(define __xr (tcl-run-error-tests))
+(define __nr (tcl-run-namespace-tests))
+(define __cr (tcl-run-coro-tests))
+(define __ir (tcl-run-idiom-tests))
+(define tcl-test-summary
+  (str "PARSE:" (get __pr "passed") ":" (get __pr "failed")
+       " EVAL:" (get __er "passed") ":" (get __er "failed")
+       " ERROR:" (get __xr "passed") ":" (get __xr "failed")
+       " NAMESPACE:" (get __nr "passed") ":" (get __nr "failed")
+       " CORO:" (get __cr "passed") ":" (get __cr "failed")
+       " IDIOM:" (get __ir "passed") ":" (get __ir "failed")))
+HELPER_EOF
+
+cat > "$TMPFILE" << EPOCHS
 (epoch 1)
-(load "lib/tcl/runtime.sx")
+(load "lib/tcl/tokenizer.sx")
 (epoch 2)
-(load "lib/tcl/tests/runtime.sx")
+(load "lib/tcl/parser.sx")
 (epoch 3)
-(eval "(list tcl-test-pass tcl-test-fail)")
+(load "lib/tcl/tests/parse.sx")
+(epoch 4)
+(load "lib/tcl/runtime.sx")
+(epoch 5)
+(load "lib/tcl/tests/eval.sx")
+(epoch 6)
+(load "lib/tcl/tests/error.sx")
+(epoch 7)
+(load "lib/tcl/tests/namespace.sx")
+(epoch 8)
+(load "lib/tcl/tests/coro.sx")
+(epoch 9)
+(load "lib/tcl/tests/idioms.sx")
+(epoch 10)
+(load "$HELPER")
+(epoch 11)
+(eval "tcl-test-summary")
 EPOCHS
 
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
+OUTPUT=$(timeout 180 "$SX_SERVER" < "$TMPFILE" 2>&1)
+[ "$VERBOSE" = "-v" ] && echo "$OUTPUT"
 
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
-if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
-fi
-if [ -z "$LINE" ]; then
-  echo "ERROR: could not extract summary"
+# Extract summary line from epoch 11 output
+SUMMARY=$(echo "$OUTPUT" | grep -A1 "^(ok-len 11 " | tail -1 | tr -d '"')
+
+if [ -z "$SUMMARY" ]; then
+  echo "ERROR: no summary from test run"
   echo "$OUTPUT" | tail -20
   exit 1
 fi
 
-P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-TOTAL=$((P + F))
+# Parse PARSE:N:M EVAL:N:M ERROR:N:M NAMESPACE:N:M CORO:N:M IDIOM:N:M
+PARSE_PART=$(echo "$SUMMARY"     | grep -o 'PARSE:[0-9]*:[0-9]*')
+EVAL_PART=$(echo "$SUMMARY"      | grep -o 'EVAL:[0-9]*:[0-9]*')
+ERROR_PART=$(echo "$SUMMARY"     | grep -o 'ERROR:[0-9]*:[0-9]*')
+NAMESPACE_PART=$(echo "$SUMMARY" | grep -o 'NAMESPACE:[0-9]*:[0-9]*')
+CORO_PART=$(echo "$SUMMARY"      | grep -o 'CORO:[0-9]*:[0-9]*')
+IDIOM_PART=$(echo "$SUMMARY"     | grep -o 'IDIOM:[0-9]*:[0-9]*')
 
-if [ "$F" -eq 0 ]; then
-  echo "ok $P/$TOTAL lib/tcl tests passed"
+PARSE_PASSED=$(echo "$PARSE_PART"         | cut -d: -f2)
+PARSE_FAILED=$(echo "$PARSE_PART"         | cut -d: -f3)
+EVAL_PASSED=$(echo "$EVAL_PART"           | cut -d: -f2)
+EVAL_FAILED=$(echo "$EVAL_PART"           | cut -d: -f3)
+ERROR_PASSED=$(echo "$ERROR_PART"         | cut -d: -f2)
+ERROR_FAILED=$(echo "$ERROR_PART"         | cut -d: -f3)
+NAMESPACE_PASSED=$(echo "$NAMESPACE_PART" | cut -d: -f2)
+NAMESPACE_FAILED=$(echo "$NAMESPACE_PART" | cut -d: -f3)
+CORO_PASSED=$(echo "$CORO_PART"           | cut -d: -f2)
+CORO_FAILED=$(echo "$CORO_PART"           | cut -d: -f3)
+IDIOM_PASSED=$(echo "$IDIOM_PART"         | cut -d: -f2)
+IDIOM_FAILED=$(echo "$IDIOM_PART"         | cut -d: -f3)
+
+PARSE_PASSED=${PARSE_PASSED:-0};         PARSE_FAILED=${PARSE_FAILED:-1}
+EVAL_PASSED=${EVAL_PASSED:-0};           EVAL_FAILED=${EVAL_FAILED:-1}
+ERROR_PASSED=${ERROR_PASSED:-0};         ERROR_FAILED=${ERROR_FAILED:-1}
+NAMESPACE_PASSED=${NAMESPACE_PASSED:-0}; NAMESPACE_FAILED=${NAMESPACE_FAILED:-1}
+CORO_PASSED=${CORO_PASSED:-0};           CORO_FAILED=${CORO_FAILED:-1}
+IDIOM_PASSED=${IDIOM_PASSED:-0};         IDIOM_FAILED=${IDIOM_FAILED:-1}
+
+TOTAL_PASSED=$((PARSE_PASSED + EVAL_PASSED + ERROR_PASSED + NAMESPACE_PASSED + CORO_PASSED + IDIOM_PASSED))
+TOTAL_FAILED=$((PARSE_FAILED + EVAL_FAILED + ERROR_FAILED + NAMESPACE_FAILED + CORO_FAILED + IDIOM_FAILED))
+TOTAL=$((TOTAL_PASSED + TOTAL_FAILED))
+
+if [ "$TOTAL_FAILED" = "0" ]; then
+  echo "ok $TOTAL_PASSED/$TOTAL tcl tests passed (parse: $PARSE_PASSED, eval: $EVAL_PASSED, error: $ERROR_PASSED, namespace: $NAMESPACE_PASSED, coro: $CORO_PASSED, idiom: $IDIOM_PASSED)"
+  exit 0
 else
-  echo "FAIL $P/$TOTAL passed, $F failed"
-  TMPFILE2=$(mktemp)
-  cat > "$TMPFILE2" << 'EPOCHS2'
-(epoch 1)
-(load "lib/tcl/runtime.sx")
-(epoch 2)
-(load "lib/tcl/tests/runtime.sx")
-(epoch 3)
-(eval "(map (fn (f) (list (get f :name) (get f :got) (get f :expected))) tcl-test-fails)")
-EPOCHS2
-  FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>/dev/null | grep -E '^\(ok-len 3' -A1 | tail -1 || true)
-  echo "  Details: $FAILS"
-  rm -f "$TMPFILE2"
+  echo "FAIL $TOTAL_PASSED/$TOTAL passed, $TOTAL_FAILED failed (parse: $PARSE_PASSED/$((PARSE_PASSED+PARSE_FAILED)), eval: $EVAL_PASSED/$((EVAL_PASSED+EVAL_FAILED)), error: $ERROR_PASSED/$((ERROR_PASSED+ERROR_FAILED)), namespace: $NAMESPACE_PASSED/$((NAMESPACE_PASSED+NAMESPACE_FAILED)), coro: $CORO_PASSED/$((CORO_PASSED+CORO_FAILED)), idiom: $IDIOM_PASSED/$((IDIOM_PASSED+IDIOM_FAILED)))"
+  if [ -z "$VERBOSE" ]; then
+    echo "--- output ---"
+    echo "$OUTPUT" | tail -30
+  fi
+  exit 1
 fi
-
-[ "$F" -eq 0 ]

lib/tcl/tests/coro.sx

@@ -0,0 +1,136 @@
+; Tcl-on-SX coroutine tests (Phase 6)
+(define tcl-coro-pass 0)
+(define tcl-coro-fail 0)
+(define tcl-coro-failures (list))
+
+(define
+  tcl-coro-assert
+  (fn
+    (label expected actual)
+    (if
+      (equal? expected actual)
+      (set! tcl-coro-pass (+ tcl-coro-pass 1))
+      (begin
+        (set! tcl-coro-fail (+ tcl-coro-fail 1))
+        (append!
+          tcl-coro-failures
+          (str label ": expected=" (str expected) " got=" (str actual)))))))
+
+(define
+  tcl-run-coro-tests
+  (fn
+    ()
+    (set! tcl-coro-pass 0)
+    (set! tcl-coro-fail 0)
+    (set! tcl-coro-failures (list))
+    (define interp (fn () (make-default-tcl-interp)))
+    (define run (fn (src) (tcl-eval-string (interp) src)))
+    (define
+      ok
+      (fn (label actual expected) (tcl-coro-assert label expected actual)))
+
+    ; --- basic coroutine: yields one value ---
+    (ok "coro-single-yield"
+      (get (run "proc gen {} { yield hello }\ncoroutine g gen\ng") :result)
+      "hello")
+
+    ; --- coroutine yields multiple values in order ---
+    (ok "coro-multi-yield-1"
+      (get (run "proc cnt {} { yield a; yield b; yield c }\ncoroutine c1 cnt\nc1") :result)
+      "a")
+
+    (ok "coro-multi-yield-2"
+      (get (run "proc cnt {} { yield a; yield b; yield c }\ncoroutine c1 cnt\nc1\nc1") :result)
+      "b")
+
+    (ok "coro-multi-yield-3"
+      (get (run "proc cnt {} { yield a; yield b; yield c }\ncoroutine c1 cnt\nc1\nc1\nc1") :result)
+      "c")
+
+    ; --- coroutine with arguments to proc ---
+    (ok "coro-args"
+      (get (run "proc gen2 {n} { yield $n; yield [expr {$n + 1}] }\ncoroutine g2 gen2 10\ng2") :result)
+      "10")
+
+    (ok "coro-args-2"
+      (get (run "proc gen2 {n} { yield $n; yield [expr {$n + 1}] }\ncoroutine g2 gen2 10\ng2\ng2") :result)
+      "11")
+
+    ; --- coroutine exhausted returns empty string ---
+    (ok "coro-exhausted"
+      (get (run "proc g3 {} { yield only }\ncoroutine c3 g3\nc3\nc3") :result)
+      "")
+
+    ; --- yield in while loop ---
+    (ok "coro-while-loop-1"
+      (get (run "proc counter {max} { set i 0; while {$i < $max} { yield $i; incr i } }\ncoroutine cw counter 3\ncw") :result)
+      "0")
+
+    (ok "coro-while-loop-2"
+      (get (run "proc counter {max} { set i 0; while {$i < $max} { yield $i; incr i } }\ncoroutine cw counter 3\ncw\ncw") :result)
+      "1")
+
+    (ok "coro-while-loop-3"
+      (get (run "proc counter {max} { set i 0; while {$i < $max} { yield $i; incr i } }\ncoroutine cw counter 3\ncw\ncw\ncw") :result)
+      "2")
+
+    ; --- collect all yields from coroutine ---
+    (ok "coro-collect-all"
+      (get
+        (run
+          "proc counter {n max} { while {$n < $max} { yield $n; incr n }; yield done }\ncoroutine gen1 counter 0 3\nset out {}\nfor {set i 0} {$i < 4} {incr i} { lappend out [gen1] }\nlindex $out 3")
+        :result)
+      "done")
+
+    ; --- two independent coroutines ---
+    (ok "coro-two-independent"
+      (get
+        (run
+          "proc seq {start} { yield $start; yield [expr {$start+1}] }\ncoroutine ca seq 0\ncoroutine cb seq 10\nset r [ca]\nappend r \":\" [cb]")
+        :result)
+      "0:10")
+
+    ; --- yield with no value returns empty string ---
+    (ok "coro-yield-no-val"
+      (get (run "proc g {} { yield }\ncoroutine cg g\ncg") :result)
+      "")
+
+    ; --- clock seconds stub ---
+    (ok "clock-seconds"
+      (get (run "clock seconds") :result)
+      "0")
+
+    ; --- clock milliseconds stub ---
+    (ok "clock-milliseconds"
+      (get (run "clock milliseconds") :result)
+      "0")
+
+    ; --- clock format stub ---
+    (ok "clock-format"
+      (get (run "clock format 0") :result)
+      "Thu Jan  1 00:00:00 UTC 1970")
+
+    ; --- file stubs ---
+    (ok "file-exists-stub"
+      (get (run "file exists /no/such/file") :result)
+      "0")
+
+    (ok "file-join"
+      (get (run "file join foo bar baz") :result)
+      "foo/bar/baz")
+
+    (ok "open-returns-channel"
+      (get (run "open /dev/null r") :result)
+      "file0")
+
+    (ok "eof-returns-1"
+      (get (run "set ch [open /dev/null r]\neof $ch") :result)
+      "1")
+
+    (dict
+      "passed"
+      tcl-coro-pass
+      "failed"
+      tcl-coro-fail
+      "failures"
+      tcl-coro-failures)))

lib/tcl/tests/error.sx

@@ -0,0 +1,192 @@
+; Tcl-on-SX error handling tests (Phase 4)
+(define tcl-err-pass 0)
+(define tcl-err-fail 0)
+(define tcl-err-failures (list))
+
+(define
+  tcl-err-assert
+  (fn
+    (label expected actual)
+    (if
+      (equal? expected actual)
+      (set! tcl-err-pass (+ tcl-err-pass 1))
+      (begin
+        (set! tcl-err-fail (+ tcl-err-fail 1))
+        (append!
+          tcl-err-failures
+          (str label ": expected=" (str expected) " got=" (str actual)))))))
+
+(define
+  tcl-run-error-tests
+  (fn
+    ()
+    (set! tcl-err-pass 0)
+    (set! tcl-err-fail 0)
+    (set! tcl-err-failures (list))
+    (define interp (fn () (make-default-tcl-interp)))
+    (define run (fn (src) (tcl-eval-string (interp) src)))
+    (define
+      ok
+      (fn (label actual expected) (tcl-err-assert label expected actual)))
+    (define
+      ok?
+      (fn (label condition) (tcl-err-assert label true condition)))
+
+    ; --- catch basic ---
+    (ok "catch-ok-code" (get (run "catch {set x 1}") :result) "0")
+    (ok "catch-ok-result-var" (tcl-var-get (run "catch {set x hello} r") "r") "hello")
+    (ok "catch-ok-returns-0" (get (run "catch {set x hello} r") :result) "0")
+
+    ; --- catch error ---
+    (ok "catch-error-code" (get (run "catch {error oops} r") :result) "1")
+    (ok "catch-error-result-var" (tcl-var-get (run "catch {error oops} r") "r") "oops")
+
+    ; --- catch outer code stays 0 ---
+    (ok? "catch-outer-code-ok" (= (get (run "catch {error boom} r") :code) 0))
+
+    ; --- catch code 2 (return) ---
+    (ok "catch-return-code" (get (run "proc p {} {return hello}\ncatch {p} r") :result) "0")
+    (ok "catch-return-val" (tcl-var-get (run "proc p {} {return hello}\ncatch {p} r") "r") "hello")
+
+    ; --- catch code 3 (break) ---
+    (ok "catch-break-code" (get (run "catch {break} r") :result) "3")
+
+    ; --- catch code 4 (continue) ---
+    (ok "catch-continue-code" (get (run "catch {continue} r") :result) "4")
+
+    ; --- catch no resultVar ---
+    (ok "catch-no-var-ok" (get (run "catch {set x 1}") :result) "0")
+    (ok "catch-no-var-err" (get (run "catch {error boom}") :result) "1")
+
+    ; --- catch with optsVar ---
+    (ok? "catch-opts-var-set"
+      (let
+        ((i (run "catch {error boom} r opts")))
+        (not (equal? (tcl-var-get i "opts") ""))))
+    (ok? "catch-opts-contains-code"
+      (let
+        ((i (run "catch {error boom} r opts")))
+        (let
+          ((opts-str (tcl-var-get i "opts")))
+          (not (equal? (tcl-string-first "-code" opts-str 0) "-1")))))
+
+    ; --- catch nested ---
+    (ok "catch-nested"
+      (tcl-var-get (run "catch {catch {error inner} r2} outer") "r2")
+      "inner")
+
+    ; --- return -code error ---
+    (ok "return-code-error-code"
+      (get (run "catch {return -code error oops} r") :result)
+      "1")
+    (ok "return-code-error-val"
+      (tcl-var-get (run "catch {return -code error oops} r") "r")
+      "oops")
+
+    ; --- return -code ok ---
+    (ok "return-code-ok"
+      (get (run "catch {return -code ok hello} r") :result)
+      "0")
+    (ok "return-code-ok-val"
+      (tcl-var-get (run "catch {return -code ok hello} r") "r")
+      "hello")
+
+    ; --- return -code break ---
+    (ok "return-code-break"
+      (get (run "catch {return -code break} r") :result)
+      "3")
+
+    ; --- return -code continue ---
+    (ok "return-code-continue"
+      (get (run "catch {return -code continue} r") :result)
+      "4")
+
+    ; --- return -code numeric ---
+    (ok "return-code-numeric-5"
+      (get (run "catch {return -code 5 msg} r") :result)
+      "5")
+
+    ; --- return plain still code 2 (catch sees raw return code) ---
+    (ok "return-plain-code"
+      (get (run "catch {return hello} r") :result)
+      "2")
+    (ok "return-plain-val"
+      (tcl-var-get (run "catch {return hello} r") "r")
+      "hello")
+
+    ; --- proc return -code error ---
+    (ok "proc-return-code-error"
+      (get (run "proc p {} {return -code error bad}\ncatch {p} r") :result)
+      "1")
+    (ok "proc-return-code-error-val"
+      (tcl-var-get (run "proc p {} {return -code error bad}\ncatch {p} r") "r")
+      "bad")
+
+    ; --- error with info/code args ---
+    (ok? "error-errorinfo-stored"
+      (let
+        ((i (run "catch {error msg myinfo mycode} r")))
+        (= (get i :code) 0)))
+
+    ; --- throw ---
+    (ok "throw-code" (get (run "catch {throw MYERR something} r") :result) "1")
+    (ok "throw-msg" (tcl-var-get (run "catch {throw MYERR something} r") "r") "something")
+
+    ; --- try basic ok ---
+    (ok "try-ok-result"
+      (get (run "try {set x hello} on ok {r} {set r2 $r}") :result)
+      "hello")
+
+    ; --- try on error ---
+    (ok "try-on-error-handled"
+      (get (run "try {error boom} on error {e} {set caught $e}") :result)
+      "boom")
+    (ok "try-on-error-var"
+      (tcl-var-get (run "try {error boom} on error {e} {set caught $e}") "caught")
+      "boom")
+
+    ; --- try finally always runs ---
+    (ok "try-finally-ok"
+      (tcl-var-get (run "try {set x 1} finally {set done yes}") "done")
+      "yes")
+    (ok "try-finally-error"
+      (tcl-var-get (run "catch {try {error boom} finally {set done yes}} r") "done")
+      "yes")
+
+    ; --- try on error + finally ---
+    (ok "try-error-finally"
+      (tcl-var-get
+        (run "try {error oops} on error {e} {set caught $e} finally {set cleaned yes}")
+        "cleaned")
+      "yes")
+    (ok "try-error-finally-caught"
+      (tcl-var-get
+        (run "try {error oops} on error {e} {set caught $e} finally {set cleaned yes}")
+        "caught")
+      "oops")
+
+    ; --- try on ok and on error ---
+    (ok "try-multi-clause-ok"
+      (tcl-var-get
+        (run "try {set x 1} on ok {r} {set which ok} on error {e} {set which err}")
+        "which")
+      "ok")
+    (ok "try-multi-clause-err"
+      (tcl-var-get
+        (run "try {error boom} on ok {r} {set which ok} on error {e} {set which err}")
+        "which")
+      "err")
+
+    ; --- catch preserves output ---
+    (ok "catch-output-preserved"
+      (get (run "puts -nonewline before\ncatch {puts -nonewline inside\nerror oops}\nputs -nonewline after")
+        :output)
+      "beforeinsideafter")
+
+    (dict
+      "passed"
+      tcl-err-pass
+      "failed"
+      tcl-err-fail
+      "failures"
+      tcl-err-failures)))

lib/tcl/tests/eval.sx

@@ -0,0 +1,338 @@
+; Tcl-on-SX eval tests
+(define tcl-eval-pass 0)
+(define tcl-eval-fail 0)
+(define tcl-eval-failures (list))
+
+(define
+  tcl-eval-assert
+  (fn
+    (label expected actual)
+    (if
+      (equal? expected actual)
+      (set! tcl-eval-pass (+ tcl-eval-pass 1))
+      (begin
+        (set! tcl-eval-fail (+ tcl-eval-fail 1))
+        (append!
+          tcl-eval-failures
+          (str label ": expected=" (str expected) " got=" (str actual)))))))
+
+(define
+  tcl-run-eval-tests
+  (fn
+    ()
+    (set! tcl-eval-pass 0)
+    (set! tcl-eval-fail 0)
+    (set! tcl-eval-failures (list))
+    (define interp (fn () (make-default-tcl-interp)))
+    (define run (fn (src) (tcl-eval-string (interp) src)))
+    (define
+      ok
+      (fn (label actual expected) (tcl-eval-assert label expected actual)))
+    (define
+      ok?
+      (fn (label condition) (tcl-eval-assert label true condition)))
+    (tcl-eval-assert "set-result" "hello" (get (run "set x hello") :result))
+    (tcl-eval-assert
+      "set-stored"
+      "hello"
+      (tcl-var-get (run "set x hello") "x"))
+    (tcl-eval-assert
+      "var-sub"
+      "hello"
+      (tcl-var-get (run "set x hello\nset y $x") "y"))
+    (tcl-eval-assert
+      "puts"
+      "world\n"
+      (get (run "set x world\nputs $x") :output))
+    (tcl-eval-assert
+      "puts-nonewline"
+      "hi"
+      (get (run "puts -nonewline hi") :output))
+    (tcl-eval-assert "incr" "6" (tcl-var-get (run "set x 5\nincr x") "x"))
+    (tcl-eval-assert
+      "incr-delta"
+      "8"
+      (tcl-var-get (run "set x 5\nincr x 3") "x"))
+    (tcl-eval-assert
+      "incr-neg"
+      "7"
+      (tcl-var-get (run "set x 10\nincr x -3") "x"))
+    (tcl-eval-assert
+      "append"
+      "foobar"
+      (tcl-var-get (run "set x foo\nappend x bar") "x"))
+    (tcl-eval-assert
+      "append-new"
+      "hello"
+      (tcl-var-get (run "append x hello") "x"))
+    (tcl-eval-assert
+      "cmdsub-result"
+      "6"
+      (get (run "set x 5\nset y [incr x]") :result))
+    (tcl-eval-assert
+      "cmdsub-y"
+      "6"
+      (tcl-var-get (run "set x 5\nset y [incr x]") "y"))
+    (tcl-eval-assert
+      "cmdsub-x"
+      "6"
+      (tcl-var-get (run "set x 5\nset y [incr x]") "x"))
+    (tcl-eval-assert
+      "multi-cmd"
+      "second"
+      (get (run "set x first\nset x second") :result))
+    (tcl-eval-assert "semi-x" "1" (tcl-var-get (run "set x 1; set y 2") "x"))
+    (tcl-eval-assert "semi-y" "2" (tcl-var-get (run "set x 1; set y 2") "y"))
+    (tcl-eval-assert
+      "braced-nosub"
+      "$x"
+      (tcl-var-get (run "set x 42\nset y {$x}") "y"))
+    (tcl-eval-assert
+      "concat-word"
+      "foobar"
+      (tcl-var-get (run "set x foo\nset y ${x}bar") "y"))
+    (tcl-eval-assert
+      "set-get"
+      "world"
+      (get (run "set x world\nset x") :result))
+    (tcl-eval-assert
+      "puts-channel"
+      "hello\n"
+      (get (run "puts stdout hello") :output))
+    (ok "if-true" (get (run "set x 0\nif {1} {set x 1}") :result) "1")
+    (ok "if-false" (get (run "set x 0\nif {0} {set x 1}") :result) "0")
+    (ok
+      "if-else-t"
+      (tcl-var-get (run "if {1} {set x yes} else {set x no}") "x")
+      "yes")
+    (ok
+      "if-else-f"
+      (tcl-var-get (run "if {0} {set x yes} else {set x no}") "x")
+      "no")
+    (ok
+      "if-cmp"
+      (tcl-var-get
+        (run "set x 5\nif {$x > 3} {set r big} else {set r small}")
+        "r")
+      "big")
+    (ok
+      "while"
+      (tcl-var-get
+        (run "set i 0\nset s 0\nwhile {$i < 5} {incr i\nincr s $i}")
+        "s")
+      "15")
+    (ok
+      "while-break"
+      (tcl-var-get
+        (run "set i 0\nwhile {1} {incr i\nif {$i == 3} {break}}")
+        "i")
+      "3")
+    (ok
+      "for"
+      (tcl-var-get
+        (run "set s 0\nfor {set i 1} {$i <= 5} {incr i} {incr s $i}")
+        "s")
+      "15")
+    (ok
+      "foreach"
+      (tcl-var-get (run "set s 0\nforeach x {1 2 3 4 5} {incr s $x}") "s")
+      "15")
+    (ok
+      "foreach-list"
+      (get (run "set acc \"\"\nforeach w {hello world} {append acc $w}") :result)
+      "helloworld")
+    (ok
+      "lappend"
+      (tcl-var-get (run "lappend lst a\nlappend lst b\nlappend lst c") "lst")
+      "a b c")
+    (ok?
+      "unset-gone"
+      (let
+        ((i (run "set x 42\nunset x")))
+        (let
+          ((frame (get i :frame)))
+          (nil? (get (get frame :locals) "x")))))
+    (ok "eval" (tcl-var-get (run "eval {set x hello}") "x") "hello")
+    (ok "expr-precedence" (get (run "expr {3 + 4 * 2}") :result) "11")
+    (ok "expr-parens" (get (run "expr {(3 + 4) * 2}") :result) "14")
+    (ok "expr-unary-minus" (get (run "expr {-5}") :result) "-5")
+    (ok "expr-unary-not-0" (get (run "expr {!0}") :result) "1")
+    (ok "expr-unary-not-1" (get (run "expr {!1}") :result) "0")
+    (ok "expr-power" (get (run "expr {2 ** 10}") :result) "1024")
+    (ok "expr-le" (get (run "expr {3 <= 3}") :result) "1")
+    (ok "expr-ge" (get (run "expr {4 >= 5}") :result) "0")
+    (ok "expr-and" (get (run "expr {1 && 1}") :result) "1")
+    (ok "expr-or" (get (run "expr {0 || 1}") :result) "1")
+    (ok "expr-var-sub" (get (run "set x 7\nexpr {$x * 3}") :result) "21")
+    (ok "expr-abs-neg" (get (run "expr {abs(-3)}") :result) "3")
+    (ok "expr-abs-pos" (get (run "expr {abs(5)}") :result) "5")
+    (ok "expr-pow-fn" (get (run "expr {pow(2, 8)}") :result) "256")
+    (ok "expr-max" (get (run "expr {max(3, 7)}") :result) "7")
+    (ok "expr-min" (get (run "expr {min(3, 7)}") :result) "3")
+    (ok "expr-sqrt-9" (get (run "expr {sqrt(9)}") :result) "3")
+    (ok "expr-sqrt-16" (get (run "expr {sqrt(16)}") :result) "4")
+    (ok "expr-mod" (get (run "expr {17 % 5}") :result) "2")
+    (ok "expr-nospace" (get (run "expr {3+4*2}") :result) "11")
+    (ok "expr-add" (get (run "expr {3 + 4}") :result) "7")
+    (ok "expr-cmp" (get (run "expr {5 > 3}") :result) "1")
+    (ok
+      "break-stops"
+      (tcl-var-get (run "set x 0\nwhile {1} {set x 1\nbreak\nset x 99}") "x")
+      "1")
+    (ok
+      "continue"
+      (tcl-var-get
+        (run
+          "set s 0\nfor {set i 1} {$i <= 5} {incr i} {if {$i == 3} {continue}\nincr s $i}")
+        "s")
+      "12")
+    (ok
+      "switch"
+      (tcl-var-get
+        (run "set x foo\nswitch $x {{foo} {set r yes} {bar} {set r no}}")
+        "r")
+      "yes")
+    (ok
+      "switch-default"
+      (tcl-var-get
+        (run "set x baz\nswitch $x {{foo} {set r yes} default {set r other}}")
+        "r")
+      "other")
+    (ok
+      "nested-if"
+      (tcl-var-get
+        (run
+          "set x 5\nif {$x > 10} {set r big} elseif {$x > 3} {set r mid} else {set r small}")
+        "r")
+      "mid")
+    (ok "str-length" (get (run "string length hello") :result) "5")
+    (ok "str-length-empty" (get (run "string length {}") :result) "0")
+    (ok "str-index" (get (run "string index hello 1") :result) "e")
+    (ok "str-index-oob" (get (run "string index hello 99") :result) "")
+    (ok "str-range" (get (run "string range hello 1 3") :result) "ell")
+    (ok "str-range-clamp" (get (run "string range hello 3 99") :result) "lo")
+    (ok "str-compare-eq" (get (run "string compare abc abc") :result) "0")
+    (ok "str-compare-lt" (get (run "string compare abc abd") :result) "-1")
+    (ok "str-compare-gt" (get (run "string compare b a") :result) "1")
+    (ok "str-match-star" (get (run "string match h*o hello") :result) "1")
+    (ok "str-match-q" (get (run "string match h?llo hello") :result) "1")
+    (ok "str-match-no" (get (run "string match h*x hello") :result) "0")
+    (ok "str-toupper" (get (run "string toupper hello") :result) "HELLO")
+    (ok "str-tolower" (get (run "string tolower WORLD") :result) "world")
+    (ok "str-trim" (get (run "string trim {  hi  }") :result) "hi")
+    (ok "str-trimleft" (get (run "string trimleft {  hi  }") :result) "hi  ")
+    (ok "str-trimright" (get (run "string trimright {  hi  }") :result) "  hi")
+    (ok "str-trim-chars" (get (run "string trim {xxhelloxx} x") :result) "hello")
+    (ok "str-map" (get (run "string map {a X b Y} {abc}") :result) "XYc")
+    (ok "str-repeat" (get (run "string repeat ab 3") :result) "ababab")
+    (ok "str-first" (get (run "string first ll hello") :result) "2")
+    (ok "str-first-miss" (get (run "string first z hello") :result) "-1")
+    (ok "str-last" (get (run "string last l hello") :result) "3")
+    (ok "str-is-int" (get (run "string is integer 42") :result) "1")
+    (ok "str-is-not-int" (get (run "string is integer foo") :result) "0")
+    (ok "str-is-alpha" (get (run "string is alpha hello") :result) "1")
+    (ok "str-is-alpha-no" (get (run "string is alpha hello1") :result) "0")
+    (ok "str-is-boolean" (get (run "string is boolean true") :result) "1")
+    (ok "str-cat" (get (run "string cat foo bar baz") :result) "foobarbaz")
+    ; --- list command tests ---
+    (ok "list-simple" (get (run "list a b c") :result) "a b c")
+    (ok "list-brace-elem" (get (run "list {a b} c") :result) "{a b} c")
+    (ok "list-empty" (get (run "list") :result) "")
+    (ok "lindex-1" (get (run "lindex {a b c} 1") :result) "b")
+    (ok "lindex-0" (get (run "lindex {a b c} 0") :result) "a")
+    (ok "lindex-oob" (get (run "lindex {a b c} 5") :result) "")
+    (ok "lrange" (get (run "lrange {a b c d} 1 2") :result) "b c")
+    (ok "lrange-full" (get (run "lrange {a b c} 0 end") :result) "a b c")
+    (ok "llength" (get (run "llength {a b c}") :result) "3")
+    (ok "llength-empty" (get (run "llength {}") :result) "0")
+    (ok "lreverse" (get (run "lreverse {1 2 3}") :result) "3 2 1")
+    (ok "lsearch-found" (get (run "lsearch {a b c} b") :result) "1")
+    (ok "lsearch-missing" (get (run "lsearch {a b c} z") :result) "-1")
+    (ok "lsearch-exact" (get (run "lsearch -exact {foo bar} foo") :result) "0")
+    (ok "lsort-asc" (get (run "lsort {banana apple cherry}") :result) "apple banana cherry")
+    (ok "lsort-int" (get (run "lsort -integer {10 2 30 5}") :result) "2 5 10 30")
+    (ok "lsort-dec" (get (run "lsort -decreasing {c a b}") :result) "c b a")
+    (ok "lreplace" (get (run "lreplace {a b c d} 1 2 X Y") :result) "a X Y d")
+    (ok "linsert" (get (run "linsert {a b c} 1 X Y") :result) "a X Y b c")
+    (ok "linsert-end" (get (run "linsert {a b} end Z") :result) "a b Z")
+    (ok "concat" (get (run "concat {a b} {c d}") :result) "a b c d")
+    (ok "split-sep" (get (run "split {a:b:c} :") :result) "a b c")
+    (ok "split-ws" (get (run "split {a b c}") :result) "a b c")
+    (ok "join-sep" (get (run "join {a b c} -") :result) "a-b-c")
+    (ok "join-default" (get (run "join {a b c}") :result) "a b c")
+    (ok "list-var" (get (run "set L {x y z}\nllength $L") :result) "3")
+    ; --- dict command tests ---
+    (ok "dict-create" (get (run "dict create a 1 b 2") :result) "a 1 b 2")
+    (ok "dict-create-empty" (get (run "dict create") :result) "")
+    (ok "dict-get" (get (run "dict get {a 1 b 2} a") :result) "1")
+    (ok "dict-get-b" (get (run "dict get {a 1 b 2} b") :result) "2")
+    (ok "dict-exists-yes" (get (run "dict exists {a 1 b 2} a") :result) "1")
+    (ok "dict-exists-no" (get (run "dict exists {a 1 b 2} z") :result) "0")
+    (ok "dict-set-new" (get (run "set d {}\ndict set d x 42") :result) "x 42")
+    (ok "dict-set-update" (get (run "set d {a 1 b 2}\ndict set d a 99") :result) "a 99 b 2")
+    (ok "dict-set-stored" (tcl-var-get (run "set d {a 1}\ndict set d b 2") "d") "a 1 b 2")
+    (ok "dict-unset" (get (run "set d {a 1 b 2}\ndict unset d a") :result) "b 2")
+    (ok "dict-unset-stored" (tcl-var-get (run "set d {a 1 b 2}\ndict unset d a") "d") "b 2")
+    (ok "dict-keys" (get (run "dict keys {a 1 b 2}") :result) "a b")
+    (ok "dict-keys-pattern" (get (run "dict keys {abc 1 abd 2 xyz 3} ab*") :result) "abc abd")
+    (ok "dict-values" (get (run "dict values {a 1 b 2}") :result) "1 2")
+    (ok "dict-size" (get (run "dict size {a 1 b 2 c 3}") :result) "3")
+    (ok "dict-size-empty" (get (run "dict size {}") :result) "0")
+    (ok "dict-for" (tcl-var-get (run "set acc {}\ndict for {k v} {a 1 b 2} {append acc $k$v}") "acc") "a1b2")
+    (ok "dict-merge-disjoint" (get (run "dict merge {a 1} {b 2}") :result) "a 1 b 2")
+    (ok "dict-merge-overlap" (get (run "dict merge {a 1 b 2} {b 99}") :result) "a 1 b 99")
+    (ok "dict-incr-existing" (get (run "set d {x 5}\ndict incr d x") :result) "x 6")
+    (ok "dict-incr-delta" (get (run "set d {x 5}\ndict incr d x 3") :result) "x 8")
+    (ok "dict-incr-missing" (get (run "set d {}\ndict incr d n") :result) "n 1")
+    (ok "dict-append" (get (run "set d {x hello}\ndict append d x _hi") :result) "x hello_hi")
+    (ok "dict-append-new" (get (run "set d {}\ndict append d k val") :result) "k val")
+    ; --- proc tests ---
+    (ok "proc-basic" (get (run "proc add {a b} {expr {$a + $b}}\nadd 3 4") :result) "7")
+    (ok "proc-return" (get (run "proc greet {name} {set msg \"hi $name\"\nreturn $msg}\ngreet World") :result) "hi World")
+    (ok "proc-factorial" (get (run "proc factorial {n} {if {$n <= 1} {return 1}\nexpr {$n * [factorial [expr {$n - 1}]]}}\nfactorial 5") :result) "120")
+    (ok "proc-args" (get (run "proc sum args {set t 0\nforeach x $args {incr t $x}\nreturn $t}\nsum 1 2 3 4") :result) "10")
+    (ok "proc-isolated" (get (run "set x outer\nproc p {} {set x inner\nreturn $x}\np") :result) "inner")
+    (ok "proc-caller-unchanged" (tcl-var-get (run "set x outer\nproc p {} {set x inner\nreturn $x}\np\nset dummy 1") "x") "outer")
+    (ok "proc-output" (get (run "proc hello {} {puts -nonewline hi}\nhello") :output) "hi")
+    ; --- upvar tests ---
+    (ok "upvar-incr" (tcl-var-get (run "proc incr2 {varname} {upvar 1 $varname v\nincr v}\nset counter 10\nincr2 counter\nset counter") "counter") "11")
+    (ok "upvar-double" (tcl-var-get (run "proc double-it {varname} {upvar 1 $varname x\nset x [expr {$x * 2}]}\nset val 5\ndouble-it val\nset val") "val") "10")
+    (ok "upvar-result" (get (run "proc double-it {varname} {upvar 1 $varname x\nset x [expr {$x * 2}]}\nset val 5\ndouble-it val\nset val") :result) "10")
+    ; --- uplevel tests ---
+    (ok "uplevel-set" (tcl-var-get (run "proc setvar {name val} {uplevel 1 \"set $name $val\"}\nsetvar x 99\nset x") "x") "99")
+    (ok "uplevel-get" (get (run "proc getvar {name} {uplevel 1 \"set $name\"}\nset y 77\ngetvar y") :result) "77")
+    ; --- global tests ---
+    (ok "global-read" (get (run "set g 100\nproc getg {} {global g\nreturn $g}\ngetg") :result) "100")
+    (ok "global-write" (tcl-var-get (run "set g 0\nproc bumping {} {global g\nincr g}\nbumping\nbumping\nset g") "g") "2")
+    ; --- info tests ---
+    (ok "info-level-0" (get (run "info level") :result) "0")
+    (ok "info-level-proc" (get (run "proc p {} {info level}\np") :result) "1")
+    (ok "info-procs" (let ((r (get (run "proc myfn {} {}\ninfo procs") :result))) (contains? (tcl-list-split r) "myfn")) true)
+    (ok "info-args" (get (run "proc add {a b} {expr {$a+$b}}\ninfo args add") :result) "a b")
+    (ok "info-commands-has-set" (let ((r (get (run "info commands") :result))) (contains? (tcl-list-split r) "set")) true)
+    ; --- classic programs ---
+    (ok
+      "classic-for-each-line"
+      (get
+        (run "proc for-each-line {var lines body} {\n    foreach item $lines {\n        uplevel 1 [list set $var $item]\n        uplevel 1 $body\n    }\n}\nset total 0\nfor-each-line line {hello world foo} {\n    incr total [string length $line]\n}\nset total")
+        :result)
+      "13")
+    (ok
+      "classic-assert"
+      (get
+        (run "proc assert {expr_str} {\n    set result [uplevel 1 [list expr $expr_str]]\n    if {!$result} {\n        error \"Assertion failed: $expr_str\"\n    }\n}\nset x 42\nassert {$x == 42}\nassert {$x > 0}\nset x 10\nassert {$x < 100}\nset x")
+        :result)
+      "10")
+    (ok
+      "classic-with-temp-var"
+      (get
+        (run "proc with-temp-var {varname tempval body} {\n    upvar 1 $varname v\n    set saved $v\n    set v $tempval\n    uplevel 1 $body\n    set v $saved\n}\nset x 100\nwith-temp-var x 999 {\n    set captured $x\n}\nlist $x $captured")
+        :result)
+      "100 999")
+    (dict
+      "passed"
+      tcl-eval-pass
+      "failed"
+      tcl-eval-fail
+      "failures"
+      tcl-eval-failures)))

lib/tcl/tests/idioms.sx

@@ -0,0 +1,193 @@
+; Tcl-on-SX idiom corpus (Phase 6)
+; Classic Tcl idioms covering lists, dicts, procs, patterns
+(define tcl-idiom-pass 0)
+(define tcl-idiom-fail 0)
+(define tcl-idiom-failures (list))
+
+(define
+  tcl-idiom-assert
+  (fn
+    (label expected actual)
+    (if
+      (equal? expected actual)
+      (set! tcl-idiom-pass (+ tcl-idiom-pass 1))
+      (begin
+        (set! tcl-idiom-fail (+ tcl-idiom-fail 1))
+        (append!
+          tcl-idiom-failures
+          (str label ": expected=" (str expected) " got=" (str actual)))))))
+
+(define
+  tcl-run-idiom-tests
+  (fn
+    ()
+    (set! tcl-idiom-pass 0)
+    (set! tcl-idiom-fail 0)
+    (set! tcl-idiom-failures (list))
+    (define interp (fn () (make-default-tcl-interp)))
+    (define run (fn (src) (tcl-eval-string (interp) src)))
+    (define
+      ok
+      (fn (label actual expected) (tcl-idiom-assert label expected actual)))
+
+    ; 1. lmap idiom: accumulate mapped values with foreach+lappend
+    (ok "idiom-lmap"
+      (get
+        (run "set result {}\nforeach x {1 2 3} { lappend result [expr {$x * $x}] }\nset result")
+        :result)
+      "1 4 9")
+
+    ; 2. Recursive list flatten
+    (ok "idiom-flatten"
+      (get
+        (run
+          "proc flatten {lst} { set out {}\n  foreach item $lst {\n    if {[llength $item] > 1} {\n      foreach sub [flatten $item] { lappend out $sub }\n    } else {\n      lappend out $item\n    }\n  }\n  return $out\n}\nflatten {1 {2 3} {4 {5 6}}}")
+        :result)
+      "1 2 3 4 5 6")
+
+    ; 3. String builder accumulator
+    (ok "idiom-string-builder"
+      (get
+        (run "set buf \"\"\nforeach w {Hello World Tcl} { append buf $w \" \" }\nstring trimright $buf")
+        :result)
+      "Hello World Tcl")
+
+    ; 4. Default parameter via info exists
+    (ok "idiom-default-param"
+      (get
+        (run "if {![info exists x]} { set x 42 }\nset x")
+        :result)
+      "42")
+
+    ; 5. Association list lookup (parallel key/value lists)
+    (ok "idiom-alist-lookup"
+      (get
+        (run
+          "set keys {a b c}\nset vals {10 20 30}\nset idx [lsearch $keys b]\nlindex $vals $idx")
+        :result)
+      "20")
+
+    ; 6. Proc with optional args via args
+    (ok "idiom-optional-args"
+      (get
+        (run
+          "proc greet {name args} {\n  set greeting \"Hello\"\n  if {[llength $args] > 0} { set greeting [lindex $args 0] }\n  return \"$greeting $name\"\n}\ngreet World Hi")
+        :result)
+      "Hi World")
+
+    ; 7. Builder pattern: dict create from args
+    (ok "idiom-dict-builder"
+      (get
+        (run
+          "proc build-dict {args} { dict create {*}$args }\ndict get [build-dict name Alice age 30] name")
+        :result)
+      "Alice")
+
+    ; 8. Loop with index using array
+    (ok "idiom-loop-with-index"
+      (get
+        (run
+          "set i 0\nforeach x {a b c} { set arr($i) $x; incr i }\nset arr(1)")
+        :result)
+      "b")
+
+    ; 9. String reverse via split+lreverse+join
+    (ok "idiom-string-reverse"
+      (get
+        (run
+          "set s hello\nset chars [split $s \"\"]\nset rev [lreverse $chars]\njoin $rev \"\"")
+        :result)
+      "olleh")
+
+    ; 10. Number to padded string
+    (ok "idiom-number-format"
+      (get (run "format \"%05d\" 42") :result)
+      "00042")
+
+    ; 11. Dict comprehension pattern
+    (ok "idiom-dict-comprehension"
+      (get
+        (run
+          "set squares {}\nforeach n {1 2 3 4} { dict set squares $n [expr {$n * $n}] }\ndict get $squares 3")
+        :result)
+      "9")
+
+    ; 12. Stack ADT using list: push/pop
+    (ok "idiom-stack"
+      (get
+        (run
+          "proc stack-push {stackvar val} { upvar $stackvar s; lappend s $val }\nproc stack-pop {stackvar} { upvar $stackvar s; set val [lindex $s end]; set s [lrange $s 0 end-1]; return $val }\nset stk {}\nstack-push stk 10\nstack-push stk 20\nstack-push stk 30\nstack-pop stk")
+        :result)
+      "30")
+
+    ; 13. Queue ADT using list: enqueue/dequeue
+    (ok "idiom-queue"
+      (get
+        (run
+          "proc q-enq {qvar val} { upvar $qvar q; lappend q $val }\nproc q-deq {qvar} { upvar $qvar q; set val [lindex $q 0]; set q [lrange $q 1 end]; return $val }\nset q {}\nq-enq q alpha\nq-enq q beta\nq-enq q gamma\nq-deq q")
+        :result)
+      "alpha")
+
+    ; 14. Pipeline via proc chaining
+    (ok "idiom-pipeline"
+      (get
+        (run
+          "proc double {x} { expr {$x * 2} }\nproc add1 {x} { expr {$x + 1} }\nproc pipeline {val procs} { foreach p $procs { set val [$p $val] }; return $val }\npipeline 5 {double add1 double}")
+        :result)
+      "22")
+
+    ; 15. Memoize pattern using dict (simple cache, not recursive)
+    (ok "idiom-memoize"
+      (get
+        (run
+          "set cache {}\nproc cached-square {n} { global cache\n  if {[dict exists $cache $n]} { return [dict get $cache $n] }\n  set r [expr {$n * $n}]\n  dict set cache $n $r\n  return $r\n}\nset a [cached-square 7]\nset b [cached-square 7]\nset c [cached-square 8]\nexpr {$a == $b && $c == 64}")
+        :result)
+      "1")
+
+    ; 16. Simple expression evaluator in Tcl (recursive descent)
+    (ok "idiom-recursive-eval"
+      (get
+        (run
+          "proc calc {expr} { return [::tcl::mathop::+ 0 [expr $expr]] }\nexpr {3 + 4 * 2}")
+        :result)
+      "11")
+
+    ; 17. Apply proc to each pair in a dict
+    (ok "idiom-dict-for"
+      (get
+        (run
+          "set d [dict create a 1 b 2 c 3]\nset total 0\ndict for {k v} $d { incr total $v }\nset total")
+        :result)
+      "6")
+
+    ; 18. Find max in list
+    (ok "idiom-find-max"
+      (get
+        (run
+          "proc list-max {lst} {\n  set m [lindex $lst 0]\n  foreach x $lst { if {$x > $m} { set m $x } }\n  return $m\n}\nlist-max {3 1 4 1 5 9 2 6}")
+        :result)
+      "9")
+
+    ; 19. Filter list by predicate
+    (ok "idiom-filter-list"
+      (get
+        (run
+          "proc list-filter {lst pred} {\n  set out {}\n  foreach x $lst { if {[$pred $x]} { lappend out $x } }\n  return $out\n}\nproc is-even {n} { expr {$n % 2 == 0} }\nlist-filter {1 2 3 4 5 6} is-even")
+        :result)
+      "2 4 6")
+
+    ; 20. Zip two lists
+    (ok "idiom-zip"
+      (get
+        (run
+          "proc zip {a b} {\n  set out {}\n  set n [llength $a]\n  for {set i 0} {$i < $n} {incr i} {\n    lappend out [lindex $a $i]\n    lappend out [lindex $b $i]\n  }\n  return $out\n}\nzip {1 2 3} {a b c}")
+        :result)
+      "1 a 2 b 3 c")
+
+    (dict
+      "passed"
+      tcl-idiom-pass
+      "failed"
+      tcl-idiom-fail
+      "failures"
+      tcl-idiom-failures)))

lib/tcl/tests/namespace.sx

@@ -0,0 +1,147 @@
+; Tcl-on-SX namespace tests (Phase 5)
+(define tcl-ns-pass 0)
+(define tcl-ns-fail 0)
+(define tcl-ns-failures (list))
+
+(define
+  tcl-ns-assert
+  (fn
+    (label expected actual)
+    (if
+      (equal? expected actual)
+      (set! tcl-ns-pass (+ tcl-ns-pass 1))
+      (begin
+        (set! tcl-ns-fail (+ tcl-ns-fail 1))
+        (append!
+          tcl-ns-failures
+          (str label ": expected=" (str expected) " got=" (str actual)))))))
+
+(define
+  tcl-run-namespace-tests
+  (fn
+    ()
+    (set! tcl-ns-pass 0)
+    (set! tcl-ns-fail 0)
+    (set! tcl-ns-failures (list))
+    (define interp (fn () (make-default-tcl-interp)))
+    (define run (fn (src) (tcl-eval-string (interp) src)))
+    (define
+      ok
+      (fn (label actual expected) (tcl-ns-assert label expected actual)))
+    (define
+      ok?
+      (fn (label condition) (tcl-ns-assert label true condition)))
+
+    ; --- namespace current ---
+    (ok "ns-current-global"
+      (get (run "namespace current") :result)
+      "::")
+
+    ; --- namespace eval defines proc ---
+    (ok "ns-eval-proc-result"
+      (get (run "namespace eval myns { proc foo {} { return bar } }\nmyns::foo") :result)
+      "bar")
+
+    ; --- fully qualified call ---
+    (ok "ns-qualified-call"
+      (get (run "namespace eval myns { proc greet {name} { return \"hello $name\" } }\n::myns::greet World") :result)
+      "hello World")
+
+    ; --- namespace current inside eval ---
+    (ok "ns-current-inside"
+      (get (run "namespace eval myns { namespace current }") :result)
+      "::myns")
+
+    ; --- namespace current restored after eval ---
+    (ok "ns-current-restored"
+      (get (run "namespace eval myns { set x 1 }\nnamespace current") :result)
+      "::")
+
+    ; --- relative call from within namespace ---
+    (ok "ns-relative-call"
+      (get (run "namespace eval math {\n  proc double {x} { expr {$x * 2} }\n  proc quad {x} { double [double $x] }\n}\nmath::quad 3") :result)
+      "12")
+
+    ; --- proc defined as qualified name inside namespace eval ---
+    (ok "ns-qualified-proc-name"
+      (get (run "namespace eval utils { proc ::utils::helper {x} { return $x } }\n::utils::helper done") :result)
+      "done")
+
+    ; --- namespace exists ---
+    (ok "ns-exists-yes"
+      (get (run "namespace eval testns { proc p {} {} }\nnamespace exists testns") :result)
+      "1")
+
+    (ok "ns-exists-no"
+      (get (run "namespace exists nosuchns") :result)
+      "0")
+
+    (ok "ns-exists-global"
+      (get (run "proc top {} {}\nnamespace exists ::") :result)
+      "1")
+
+    ; --- namespace delete ---
+    (ok "ns-delete-removes"
+      (get (run "namespace eval todel { proc pp {} { return yes } }\nnamespace delete todel\nnamespace exists todel") :result)
+      "0")
+
+    ; --- namespace which ---
+    (ok "ns-which-found"
+      (get (run "namespace eval wns { proc wfn {} {} }\nnamespace which -command wns::wfn") :result)
+      "::wns::wfn")
+
+    (ok "ns-which-not-found"
+      (get (run "namespace which -command nosuchfn") :result)
+      "")
+
+    ; --- namespace ensemble create auto-map ---
+    (ok "ns-ensemble-add"
+      (get (run "namespace eval mymath {\n  proc add {a b} { expr {$a + $b} }\n  proc mul {a b} { expr {$a * $b} }\n  namespace ensemble create\n}\nmymath add 3 4") :result)
+      "7")
+
+    (ok "ns-ensemble-mul"
+      (get (run "namespace eval mymath {\n  proc add {a b} { expr {$a + $b} }\n  proc mul {a b} { expr {$a * $b} }\n  namespace ensemble create\n}\nmymath mul 3 4") :result)
+      "12")
+
+    ; --- namespace ensemble with -map ---
+    (ok "ns-ensemble-map"
+      (get (run "namespace eval ops {\n  proc do-add {a b} { expr {$a + $b} }\n  namespace ensemble create -map {plus ::ops::do-add}\n}\nops plus 5 6") :result)
+      "11")
+
+    ; --- proc inside namespace eval with args ---
+    (ok "ns-proc-args"
+      (get (run "namespace eval calc {\n  proc sum {a b c} { expr {$a + $b + $c} }\n}\ncalc::sum 1 2 3") :result)
+      "6")
+
+    ; --- info procs inside namespace ---
+    (ok? "ns-info-procs-in-ns"
+      (let
+        ((r (get (run "namespace eval foo { proc bar {} {} }\nnamespace eval foo { info procs }") :result)))
+        (contains? (tcl-list-split r) "bar")))
+
+    ; --- variable inside namespace eval ---
+    (ok "ns-variable-inside"
+      (get (run "namespace eval storage {\n  variable count 0\n  proc bump {} { global count\n    incr count\n    return $count }\n}\n::storage::bump\n::storage::bump") :result)
+      "2")
+
+    ; --- nested namespaces ---
+    (ok "ns-nested"
+      (get (run "namespace eval outer {\n  namespace eval inner {\n    proc greet {} { return nested }\n  }\n}\n::outer::inner::greet") :result)
+      "nested")
+
+    ; --- namespace eval accumulates procs ---
+    (ok "ns-eval-accumulate"
+      (get (run "namespace eval acc { proc f1 {} { return one } }\nnamespace eval acc { proc f2 {} { return two } }\nacc::f1") :result)
+      "one")
+
+    (ok "ns-eval-accumulate-2"
+      (get (run "namespace eval acc { proc f1 {} { return one } }\nnamespace eval acc { proc f2 {} { return two } }\nacc::f2") :result)
+      "two")
+
+    (dict
+      "passed"
+      tcl-ns-pass
+      "failed"
+      tcl-ns-fail
+      "failures"
+      tcl-ns-failures)))

lib/tcl/tests/parse.sx

@@ -0,0 +1,186 @@
+(define tcl-parse-pass 0)
+(define tcl-parse-fail 0)
+(define tcl-parse-failures (list))
+
+(define tcl-assert
+  (fn (label expected actual)
+    (if (= expected actual)
+      (set! tcl-parse-pass (+ tcl-parse-pass 1))
+      (begin
+        (set! tcl-parse-fail (+ tcl-parse-fail 1))
+        (append! tcl-parse-failures
+          (str label ": expected=" (str expected) " got=" (str actual)))))))
+
+(define tcl-first-cmd
+  (fn (src) (nth (tcl-tokenize src) 0)))
+
+(define tcl-cmd-words
+  (fn (src) (get (tcl-first-cmd src) :words)))
+
+(define tcl-word
+  (fn (src wi) (nth (tcl-cmd-words src) wi)))
+
+(define tcl-parts
+  (fn (src wi) (get (tcl-word src wi) :parts)))
+
+(define tcl-part
+  (fn (src wi pi) (nth (tcl-parts src wi) pi)))
+
+(define tcl-run-parse-tests
+  (fn ()
+    (set! tcl-parse-pass 0)
+    (set! tcl-parse-fail 0)
+    (set! tcl-parse-failures (list))
+
+    ; empty / whitespace-only
+    (tcl-assert "empty" 0 (len (tcl-tokenize "")))
+    (tcl-assert "ws-only" 0 (len (tcl-tokenize "   ")))
+    (tcl-assert "nl-only" 0 (len (tcl-tokenize "\n\n")))
+
+    ; single command word count
+    (tcl-assert "1word" 1 (len (tcl-cmd-words "set")))
+    (tcl-assert "3words" 3 (len (tcl-cmd-words "set x 1")))
+    (tcl-assert "4words" 4 (len (tcl-cmd-words "set a b c")))
+
+    ; word type — bare word is compound
+    (tcl-assert "bare-type" "compound" (get (tcl-word "set x 1" 0) :type))
+    (tcl-assert "bare-quoted" false (get (tcl-word "set x 1" 0) :quoted))
+    (tcl-assert "bare-part-type" "text" (get (tcl-part "set x 1" 0 0) :type))
+    (tcl-assert "bare-part-val" "set" (get (tcl-part "set x 1" 0 0) :value))
+    (tcl-assert "bare-part2-val" "x" (get (tcl-part "set x 1" 1 0) :value))
+    (tcl-assert "bare-part3-val" "1" (get (tcl-part "set x 1" 2 0) :value))
+
+    ; multiple commands
+    (tcl-assert "semi-sep" 2 (len (tcl-tokenize "set x 1; set y 2")))
+    (tcl-assert "nl-sep" 2 (len (tcl-tokenize "set x 1\nset y 2")))
+    (tcl-assert "multi-nl" 3 (len (tcl-tokenize "a\nb\nc")))
+
+    ; comments
+    (tcl-assert "comment-only" 0 (len (tcl-tokenize "# comment")))
+    (tcl-assert "comment-nl" 0 (len (tcl-tokenize "# comment\n")))
+    (tcl-assert "comment-then-cmd" 1 (len (tcl-tokenize "# comment\nset x 1")))
+    (tcl-assert "semi-then-comment" 1 (len (tcl-tokenize "set x 1; # comment")))
+
+    ; brace-quoted words
+    (tcl-assert "brace-type" "braced" (get (tcl-word "{hello}" 0) :type))
+    (tcl-assert "brace-value" "hello" (get (tcl-word "{hello}" 0) :value))
+    (tcl-assert "brace-spaces" "hello world" (get (tcl-word "{hello world}" 0) :value))
+    (tcl-assert "brace-nested" "a {b} c" (get (tcl-word "{a {b} c}" 0) :value))
+    (tcl-assert "brace-no-var-sub" "hello $x" (get (tcl-word "{hello $x}" 0) :value))
+    (tcl-assert "brace-no-cmd-sub" "[expr 1]" (get (tcl-word "{[expr 1]}" 0) :value))
+
+    ; double-quoted words
+    (tcl-assert "dq-type" "compound" (get (tcl-word "\"hello\"" 0) :type))
+    (tcl-assert "dq-quoted" true (get (tcl-word "\"hello\"" 0) :quoted))
+    (tcl-assert "dq-literal" "hello" (get (tcl-part "\"hello\"" 0 0) :value))
+
+    ; variable substitution in bare word
+    (tcl-assert "var-type" "var" (get (tcl-part "$x" 0 0) :type))
+    (tcl-assert "var-name" "x" (get (tcl-part "$x" 0 0) :name))
+    (tcl-assert "var-long" "long_name" (get (tcl-part "$long_name" 0 0) :name))
+
+    ; ${name} form
+    (tcl-assert "var-brace-type" "var" (get (tcl-part "${x}" 0 0) :type))
+    (tcl-assert "var-brace-name" "x" (get (tcl-part "${x}" 0 0) :name))
+
+    ; array variable substitution
+    (tcl-assert "arr-type" "var-arr" (get (tcl-part "$arr(key)" 0 0) :type))
+    (tcl-assert "arr-name" "arr" (get (tcl-part "$arr(key)" 0 0) :name))
+    (tcl-assert "arr-key-len" 1 (len (get (tcl-part "$arr(key)" 0 0) :key)))
+    (tcl-assert "arr-key-text" "key"
+      (get (nth (get (tcl-part "$arr(key)" 0 0) :key) 0) :value))
+
+    ; command substitution
+    (tcl-assert "cmd-type" "cmd" (get (tcl-part "[expr 1+1]" 0 0) :type))
+    (tcl-assert "cmd-src" "expr 1+1" (get (tcl-part "[expr 1+1]" 0 0) :src))
+
+    ; nested command substitution
+    (tcl-assert "cmd-nested-src" "expr [string length x]"
+      (get (tcl-part "[expr [string length x]]" 0 0) :src))
+
+    ; backslash substitution in double-quoted word
+    (let ((ps (tcl-parts "\"a\\nb\"" 0)))
+      (begin
+        (tcl-assert "bs-n-part0" "a" (get (nth ps 0) :value))
+        (tcl-assert "bs-n-part1" "\n" (get (nth ps 1) :value))
+        (tcl-assert "bs-n-part2" "b" (get (nth ps 2) :value))))
+
+    (let ((ps (tcl-parts "\"a\\tb\"" 0)))
+      (tcl-assert "bs-t-part1" "\t" (get (nth ps 1) :value)))
+
+    (let ((ps (tcl-parts "\"a\\\\b\"" 0)))
+      (tcl-assert "bs-bs-part1" "\\" (get (nth ps 1) :value)))
+
+    ; mixed word: text + var + text in double-quoted
+    (let ((ps (tcl-parts "\"hello $name!\"" 0)))
+      (begin
+        (tcl-assert "mixed-text0" "hello " (get (nth ps 0) :value))
+        (tcl-assert "mixed-var1-type" "var" (get (nth ps 1) :type))
+        (tcl-assert "mixed-var1-name" "name" (get (nth ps 1) :name))
+        (tcl-assert "mixed-text2" "!" (get (nth ps 2) :value))))
+
+    ; {*} expansion
+    (tcl-assert "expand-type" "expand" (get (tcl-word "{*}$list" 0) :type))
+
+    ; line continuation between words
+    (tcl-assert "cont-words" 3 (len (tcl-cmd-words "set x \\\n  1")))
+
+    ; continuation — third command word is correct
+    (tcl-assert "cont-word2-val" "1"
+      (get (tcl-part "set x \\\n  1" 2 0) :value))
+
+
+    ; --- parser helpers ---
+    ; tcl-parse is an alias for tcl-tokenize
+    (tcl-assert "parse-cmd-count" 1 (len (tcl-parse "set x 1")))
+    (tcl-assert "parse-2cmds" 2 (len (tcl-parse "set x 1; set y 2")))
+
+    ; tcl-cmd-len
+    (tcl-assert "cmd-len-3" 3 (tcl-cmd-len (nth (tcl-parse "set x 1") 0)))
+    (tcl-assert "cmd-len-1" 1 (tcl-cmd-len (nth (tcl-parse "puts") 0)))
+
+    ; tcl-word-simple? on braced word
+    (tcl-assert "simple-braced" true
+      (tcl-word-simple? (nth (get (nth (tcl-parse "{hello}") 0) :words) 0)))
+
+    ; tcl-word-simple? on bare word with no subs
+    (tcl-assert "simple-bare" true
+      (tcl-word-simple? (nth (get (nth (tcl-parse "hello") 0) :words) 0)))
+
+    ; tcl-word-simple? on word containing a var sub — false
+    (tcl-assert "simple-var-false" false
+      (tcl-word-simple? (nth (get (nth (tcl-parse "$x") 0) :words) 0)))
+
+    ; tcl-word-simple? on word containing a cmd sub — false
+    (tcl-assert "simple-cmd-false" false
+      (tcl-word-simple? (nth (get (nth (tcl-parse "[expr 1]") 0) :words) 0)))
+
+    ; tcl-word-literal on braced word
+    (tcl-assert "lit-braced" "hello world"
+      (tcl-word-literal (nth (get (nth (tcl-parse "{hello world}") 0) :words) 0)))
+
+    ; tcl-word-literal on bare word
+    (tcl-assert "lit-bare" "hello"
+      (tcl-word-literal (nth (get (nth (tcl-parse "hello") 0) :words) 0)))
+
+    ; tcl-word-literal on word with var sub returns nil
+    (tcl-assert "lit-var-nil" nil
+      (tcl-word-literal (nth (get (nth (tcl-parse "$x") 0) :words) 0)))
+
+    ; tcl-nth-literal
+    (tcl-assert "nth-lit-0" "set"
+      (tcl-nth-literal (nth (tcl-parse "set x 1") 0) 0))
+    (tcl-assert "nth-lit-1" "x"
+      (tcl-nth-literal (nth (tcl-parse "set x 1") 0) 1))
+    (tcl-assert "nth-lit-2" "1"
+      (tcl-nth-literal (nth (tcl-parse "set x 1") 0) 2))
+
+    ; tcl-nth-literal returns nil when word has subs
+    (tcl-assert "nth-lit-nil" nil
+      (tcl-nth-literal (nth (tcl-parse "set x $y") 0) 2))
+
+
+    (dict
+      "passed" tcl-parse-pass
+      "failed" tcl-parse-fail
+      "failures" tcl-parse-failures)))

lib/tcl/tests/programs/assert.tcl

@@ -0,0 +1,14 @@
+# expected: 10
+proc assert {expr_str} {
+    set result [uplevel 1 [list expr $expr_str]]
+    if {!$result} {
+        error "Assertion failed: $expr_str"
+    }
+}
+
+set x 42
+assert {$x == 42}
+assert {$x > 0}
+set x 10
+assert {$x < 100}
+set x

lib/tcl/tests/programs/event-loop.tcl

@@ -0,0 +1,22 @@
+# expected: done
+# Cooperative scheduler demo using coroutines (generator style)
+# coroutine eagerly collects all yields; invoking the coroutine name pops values
+
+proc counter {n max} {
+    while {$n < $max} {
+        yield $n
+        incr n
+    }
+    yield done
+}
+
+coroutine gen1 counter 0 3
+
+# gen1 yields: 0 1 2 done
+set out {}
+for {set i 0} {$i < 4} {incr i} {
+    lappend out [gen1]
+}
+
+# last val is "done"
+lindex $out 3

lib/tcl/tests/programs/for-each-line.tcl

@@ -0,0 +1,14 @@
+# expected: 13
+proc for-each-line {var lines body} {
+    foreach item $lines {
+        uplevel 1 [list set $var $item]
+        uplevel 1 $body
+    }
+}
+
+# Usage: accumulate lengths of each "line"
+set total 0
+for-each-line line {hello world foo} {
+    incr total [string length $line]
+}
+set total

lib/tcl/tests/programs/with-temp-var.tcl

@@ -0,0 +1,14 @@
+# expected: 100 999
+proc with-temp-var {varname tempval body} {
+    upvar 1 $varname v
+    set saved $v
+    set v $tempval
+    uplevel 1 $body
+    set v $saved
+}
+
+set x 100
+with-temp-var x 999 {
+    set captured $x
+}
+list $x $captured

lib/tcl/tokenizer.sx

@@ -0,0 +1,308 @@
+(define tcl-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\r"))))
+
+(define tcl-alpha?
+  (fn (c)
+    (and
+      (not (= c nil))
+      (or (and (>= c "a") (<= c "z")) (and (>= c "A") (<= c "Z"))))))
+
+(define tcl-digit?
+  (fn (c) (and (not (= c nil)) (>= c "0") (<= c "9"))))
+
+(define tcl-ident-start?
+  (fn (c) (or (tcl-alpha? c) (= c "_"))))
+
+(define tcl-ident-char?
+  (fn (c) (or (tcl-ident-start? c) (tcl-digit? c))))
+
+(define tcl-tokenize
+  (fn (src)
+    (let ((pos 0) (src-len (len src)) (commands (list)))
+
+      (define char-at
+        (fn (off)
+          (if (< (+ pos off) src-len) (nth src (+ pos off)) nil)))
+
+      (define cur (fn () (char-at 0)))
+
+      (define advance! (fn (n) (set! pos (+ pos n))))
+
+      (define skip-ws!
+        (fn ()
+          (when (tcl-ws? (cur))
+            (begin (advance! 1) (skip-ws!)))))
+
+      (define skip-to-eol!
+        (fn ()
+          (when (and (< pos src-len) (not (= (cur) "\n")))
+            (begin (advance! 1) (skip-to-eol!)))))
+
+      (define skip-brace-content!
+        (fn (d)
+          (when (and (< pos src-len) (> d 0))
+            (cond
+              ((= (cur) "{") (begin (advance! 1) (skip-brace-content! (+ d 1))))
+              ((= (cur) "}") (begin (advance! 1) (skip-brace-content! (- d 1))))
+              (else (begin (advance! 1) (skip-brace-content! d)))))))
+
+      (define skip-dquote-content!
+        (fn ()
+          (when (and (< pos src-len) (not (= (cur) "\"")))
+            (begin
+              (when (= (cur) "\\") (advance! 1))
+              (when (< pos src-len) (advance! 1))
+              (skip-dquote-content!)))))
+
+      (define parse-bs
+        (fn ()
+          (advance! 1)
+          (let ((c (cur)))
+            (cond
+              ((= c nil)  "\\")
+              ((= c "n")  (begin (advance! 1) "\n"))
+              ((= c "t")  (begin (advance! 1) "\t"))
+              ((= c "r")  (begin (advance! 1) "\r"))
+              ((= c "\\") (begin (advance! 1) "\\"))
+              ((= c "[")  (begin (advance! 1) "["))
+              ((= c "]")  (begin (advance! 1) "]"))
+              ((= c "{")  (begin (advance! 1) "{"))
+              ((= c "}")  (begin (advance! 1) "}"))
+              ((= c "$")  (begin (advance! 1) "$"))
+              ((= c ";")  (begin (advance! 1) ";"))
+              ((= c "\"") (begin (advance! 1) "\""))
+              ((= c "'")  (begin (advance! 1) "'"))
+              ((= c " ")  (begin (advance! 1) " "))
+              ((= c "\n")
+                (begin
+                  (advance! 1)
+                  (skip-ws!)
+                  " "))
+              (else (begin (advance! 1) (str "\\" c)))))))
+
+      (define parse-cmd-sub
+        (fn ()
+          (advance! 1)
+          (let ((start pos) (depth 1))
+            (define scan!
+              (fn ()
+                (when (and (< pos src-len) (> depth 0))
+                  (cond
+                    ((= (cur) "[")
+                      (begin (set! depth (+ depth 1)) (advance! 1) (scan!)))
+                    ((= (cur) "]")
+                      (begin
+                        (set! depth (- depth 1))
+                        (when (> depth 0) (advance! 1))
+                        (scan!)))
+                    ((= (cur) "{")
+                      (begin (advance! 1) (skip-brace-content! 1) (scan!)))
+                    ((= (cur) "\"")
+                      (begin
+                        (advance! 1)
+                        (skip-dquote-content!)
+                        (when (= (cur) "\"") (advance! 1))
+                        (scan!)))
+                    ((= (cur) "\\")
+                      (begin (advance! 1) (when (< pos src-len) (advance! 1)) (scan!)))
+                    (else (begin (advance! 1) (scan!)))))))
+            (scan!)
+            (let ((src-text (slice src start pos)))
+              (begin
+                (when (= (cur) "]") (advance! 1))
+                {:type "cmd" :src src-text})))))
+
+      (define scan-name!
+        (fn ()
+          (when (and (< pos src-len) (not (= (cur) "}")))
+            (begin (advance! 1) (scan-name!)))))
+
+      (define scan-ns-name!
+        (fn ()
+          (cond
+            ((tcl-ident-char? (cur))
+              (begin (advance! 1) (scan-ns-name!)))
+            ((and (= (cur) ":") (= (char-at 1) ":"))
+              (begin (advance! 2) (scan-ns-name!)))
+            (else nil))))
+
+      (define scan-klit!
+        (fn ()
+          (when (and (< pos src-len)
+                     (not (= (cur) ")"))
+                     (not (= (cur) "$"))
+                     (not (= (cur) "["))
+                     (not (= (cur) "\\")))
+            (begin (advance! 1) (scan-klit!)))))
+
+      (define scan-key!
+        (fn (kp)
+          (when (and (< pos src-len) (not (= (cur) ")")))
+            (cond
+              ((= (cur) "$")
+                (begin (append! kp (parse-var-sub)) (scan-key! kp)))
+              ((= (cur) "[")
+                (begin (append! kp (parse-cmd-sub)) (scan-key! kp)))
+              ((= (cur) "\\")
+                (begin
+                  (append! kp {:type "text" :value (parse-bs)})
+                  (scan-key! kp)))
+              (else
+                (let ((kstart pos))
+                  (begin
+                    (scan-klit!)
+                    (append! kp {:type "text" :value (slice src kstart pos)})
+                    (scan-key! kp))))))))
+
+      (define parse-var-sub
+        (fn ()
+          (advance! 1)
+          (cond
+            ((= (cur) "{")
+              (begin
+                (advance! 1)
+                (let ((start pos))
+                  (begin
+                    (scan-name!)
+                    (let ((name (slice src start pos)))
+                      (begin
+                        (when (= (cur) "}") (advance! 1))
+                        {:type "var" :name name}))))))
+            ((tcl-ident-start? (cur))
+              (let ((start pos))
+                (begin
+                  (scan-ns-name!)
+                  (let ((name (slice src start pos)))
+                    (if (= (cur) "(")
+                      (begin
+                        (advance! 1)
+                        (let ((key-parts (list)))
+                          (begin
+                            (scan-key! key-parts)
+                            (when (= (cur) ")") (advance! 1))
+                            {:type "var-arr" :name name :key key-parts})))
+                      {:type "var" :name name})))))
+            (else {:type "text" :value "$"}))))
+
+      (define scan-lit!
+        (fn (stop?)
+          (when (and (< pos src-len)
+                     (not (stop? (cur)))
+                     (not (= (cur) "$"))
+                     (not (= (cur) "["))
+                     (not (= (cur) "\\")))
+            (begin (advance! 1) (scan-lit! stop?)))))
+
+      (define parse-word-parts!
+        (fn (parts stop?)
+          (when (and (< pos src-len) (not (stop? (cur))))
+            (cond
+              ((= (cur) "$")
+                (begin (append! parts (parse-var-sub)) (parse-word-parts! parts stop?)))
+              ((= (cur) "[")
+                (begin (append! parts (parse-cmd-sub)) (parse-word-parts! parts stop?)))
+              ((= (cur) "\\")
+                (begin
+                  (append! parts {:type "text" :value (parse-bs)})
+                  (parse-word-parts! parts stop?)))
+              (else
+                (let ((start pos))
+                  (begin
+                    (scan-lit! stop?)
+                    (when (> pos start)
+                      (append! parts {:type "text" :value (slice src start pos)}))
+                    (parse-word-parts! parts stop?))))))))
+
+      (define parse-brace-word
+        (fn ()
+          (advance! 1)
+          (let ((depth 1) (start pos))
+            (define scan!
+              (fn ()
+                (when (and (< pos src-len) (> depth 0))
+                  (cond
+                    ((= (cur) "{")
+                      (begin (set! depth (+ depth 1)) (advance! 1) (scan!)))
+                    ((= (cur) "}")
+                      (begin (set! depth (- depth 1)) (when (> depth 0) (advance! 1)) (scan!)))
+                    (else (begin (advance! 1) (scan!)))))))
+            (scan!)
+            (let ((value (slice src start pos)))
+              (begin
+                (when (= (cur) "}") (advance! 1))
+                {:type "braced" :value value})))))
+
+      (define parse-dquote-word
+        (fn ()
+          (advance! 1)
+          (let ((parts (list)))
+            (begin
+              (parse-word-parts! parts (fn (c) (or (= c "\"") (= c nil))))
+              (when (= (cur) "\"") (advance! 1))
+              {:type "compound" :parts parts :quoted true}))))
+
+      (define parse-bare-word
+        (fn ()
+          (let ((parts (list)))
+            (begin
+              (parse-word-parts!
+                parts
+                (fn (c) (or (tcl-ws? c) (= c "\n") (= c ";") (= c nil))))
+              {:type "compound" :parts parts :quoted false}))))
+
+      (define parse-word-no-expand
+        (fn ()
+          (cond
+            ((= (cur) "{") (parse-brace-word))
+            ((= (cur) "\"") (parse-dquote-word))
+            (else (parse-bare-word)))))
+
+      (define parse-word
+        (fn ()
+          (cond
+            ((and (= (cur) "{") (= (char-at 1) "*") (= (char-at 2) "}"))
+              (begin
+                (advance! 3)
+                {:type "expand" :word (parse-word-no-expand)}))
+            ((= (cur) "{") (parse-brace-word))
+            ((= (cur) "\"") (parse-dquote-word))
+            (else (parse-bare-word)))))
+
+      (define parse-words!
+        (fn (words)
+          (skip-ws!)
+          (cond
+            ((or (= (cur) nil) (= (cur) "\n") (= (cur) ";")) nil)
+            ((and (= (cur) "\\") (= (char-at 1) "\n"))
+              (begin (advance! 2) (skip-ws!) (parse-words! words)))
+            (else
+              (begin
+                (append! words (parse-word))
+                (parse-words! words))))))
+
+      (define skip-seps!
+        (fn ()
+          (when (< pos src-len)
+            (cond
+              ((or (tcl-ws? (cur)) (= (cur) "\n") (= (cur) ";"))
+                (begin (advance! 1) (skip-seps!)))
+              ((and (= (cur) "\\") (= (char-at 1) "\n"))
+                (begin (advance! 2) (skip-seps!)))
+              (else nil)))))
+
+      (define parse-all!
+        (fn ()
+          (skip-seps!)
+          (when (< pos src-len)
+            (cond
+              ((= (cur) "#")
+                (begin (skip-to-eol!) (parse-all!)))
+              (else
+                (let ((words (list)))
+                  (begin
+                    (parse-words! words)
+                    (when (> (len words) 0)
+                      (append! commands {:type "command" :words words}))
+                    (parse-all!))))))))
+
+      (parse-all!)
+      commands)))

plans/agent-briefings/apl-loop.md

@@ -11,7 +11,7 @@ isolation: worktree
 
 ## Prompt
 
-You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Push to `origin/loops/apl` after every commit.
 
 ## Restart baseline — check before iterating
 
@@ -42,7 +42,7 @@ Every iteration: implement → test → commit → tick `[ ]` → Progress log
 - **Shared-file issues** → plan's Blockers with minimal repro.
 - **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
 - **Unicode in `.sx`:** raw UTF-8 only, never `\uXXXX` escapes. Glyphs land directly in source.
-- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Worktree:** commit, then push to `origin/loops/apl`. Never touch `main`.
 - **Commit granularity:** one feature per commit.
 - **Plan file:** update Progress log + tick boxes every commit.
 

plans/agent-briefings/prolog-loop.md

@@ -11,7 +11,7 @@ isolation: worktree
 
 ## Prompt
 
-You are the sole background agent working `/root/rose-ash/plans/prolog-on-sx.md`. You run in an isolated git worktree. You work the plan's roadmap forever, one commit per feature. You never push.
+You are the sole background agent working `/root/rose-ash/plans/prolog-on-sx.md`. You run in an isolated git worktree. You work the plan's roadmap forever, one commit per feature. Push to `origin/loops/prolog` after every commit.
 
 ## Restart baseline — check before iterating
 
@@ -39,12 +39,13 @@ Every iteration: implement → test → commit → tick `[ ]` in plan → append
 
 ## Ground rules (hard)
 
-- **Scope:** only `lib/prolog/**` and `plans/prolog-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Prolog primitives go in `lib/prolog/runtime.sx`.
+- **Scope:** only `lib/prolog/**` and `plans/prolog-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Prolog primitives go in `lib/prolog/runtime.sx`. You may **read** `lib/hyperscript/runtime.sx` to understand the hook API but do not edit it — `hs-set-prolog-hook!` is already implemented there.
+- **Hyperscript bridge is NOT blocked:** `lib/prolog/hs-bridge.sx` already exists and `lib/hyperscript/runtime.sx` already exports `hs-set-prolog-hook!` / `hs-prolog-hook`. The Phase 5 DSL item just needs tests and wiring.
 - **NEVER call `sx_build`.** 600s watchdog will kill you before OCaml finishes. If sx_server binary is broken, add Blockers entry and stop.
 - **Shared-file issues** → plan's Blockers section with a minimal repro. Don't fix them.
 - **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5 (IO suspension via `perform`/`cek-resume`). `sx_summarise` spec/evaluator.sx first — it's 2300+ lines.
 - **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits. Never `Edit`/`Read`/`Write` on `.sx`.
-- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Worktree:** commit, then push to `origin/loops/prolog`. Never touch `main`.
 - **Commit granularity:** one feature per commit.
 - **Plan file:** update Progress log + tick boxes every commit.
 - **If blocked** for two iterations on the same issue, add to Blockers and move on.

plans/agent-briefings/tcl-loop.md

@@ -11,7 +11,7 @@ isolation: worktree
 
 ## Prompt
 
-You are the sole background agent working `/root/rose-ash/plans/tcl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+You are the sole background agent working `/root/rose-ash/plans/tcl-on-sx.md`. Isolated worktree, forever, one commit per feature. Push to `origin/loops/tcl` after every commit.
 
 ## Restart baseline — check before iterating
 
@@ -42,7 +42,7 @@ Every iteration: implement → test → commit → tick `[ ]` → Progress log
 - **Shared-file issues** → plan's Blockers with minimal repro.
 - **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
 - **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
-- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Worktree:** commit, then push to `origin/loops/tcl`. Never touch `main`.
 - **Commit granularity:** one feature per commit.
 - **Plan file:** update Progress log + tick boxes every commit.
 

plans/apl-on-sx.md

@@ -48,61 +48,249 @@ Core mapping:
 ## Roadmap
 
 ### Phase 1 — tokenizer + parser
-- [ ] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
-- [ ] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`, control words `:If :While :For …` (Dyalog-style)
-- [ ] Unit tests in `lib/apl/tests/parse.sx`
+- [x] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
+- [x] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`; outer product `∘.f`, inner product `f.g`, derived fns `f/ f¨ f⍨ f⍣n`
+- [x] Unit tests in `lib/apl/tests/parse.sx`
 
 ### Phase 2 — array model + scalar primitives
-- [ ] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
-- [ ] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
-- [ ] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
-- [ ] Scalar comparison primitives: `< ≤ = ≥ > ≠`
-- [ ] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
-- [ ] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
-- [ ] `⎕IO` = 1 default (Dyalog convention)
-- [ ] 40+ tests in `lib/apl/tests/scalar.sx`
+- [x] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
+- [x] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
+- [x] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
+- [x] Scalar comparison primitives: `< ≤ = ≥ > ≠`
+- [x] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
+- [x] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
+- [x] `⎕IO` = 1 default (Dyalog convention)
+- [x] 40+ tests in `lib/apl/tests/scalar.sx`
 
 ### Phase 3 — structural primitives + indexing
-- [ ] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
-- [ ] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
-- [ ] Catenate `,` (last axis) and `⍪` (first axis)
-- [ ] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
-- [ ] Grade-up `⍋`, grade-down `⍒`
-- [ ] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
-- [ ] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
-- [ ] 40+ tests in `lib/apl/tests/structural.sx`
+- [x] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
+- [x] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
+- [x] Catenate `,` (last axis) and `⍪` (first axis)
+- [x] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
+- [x] Grade-up `⍋`, grade-down `⍒`
+- [x] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
+- [x] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
+- [x] 40+ tests in `lib/apl/tests/structural.sx`
 
 ### Phase 4 — operators (THE SHOWCASE)
-- [ ] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
-- [ ] Scan `f\`, `f⍀`
-- [ ] Each `f¨` — applies `f` to each scalar/element
-- [ ] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
-- [ ] Inner product `f.g` — `+.×` is matrix multiply
-- [ ] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
-- [ ] Compose `f∘g` — applies `g` first then `f`
-- [ ] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
-- [ ] Rank `f⍤k` — apply f at sub-rank k
-- [ ] At `@` — selective replace
-- [ ] 40+ tests in `lib/apl/tests/operators.sx`
+- [x] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
+- [x] Scan `f\`, `f⍀`
+- [x] Each `f¨` — applies `f` to each scalar/element
+- [x] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
+- [x] Inner product `f.g` — `+.×` is matrix multiply
+- [x] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
+- [x] Compose `f∘g` — applies `g` first then `f`
+- [x] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
+- [x] Rank `f⍤k` — apply f at sub-rank k
+- [x] At `@` — selective replace
+- [x] 40+ tests in `lib/apl/tests/operators.sx`
 
 ### Phase 5 — dfns + tradfns + control flow
-- [ ] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
-- [ ] Local assignment via `←` (lexical inside dfn)
-- [ ] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
-- [ ] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap`
-- [ ] Niladic / monadic / dyadic dispatch (function valence at definition time)
-- [ ] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+- [x] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
+- [x] Local assignment via `←` (lexical inside dfn)
+- [x] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
+- [x] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap` _(Trap deferred — no exception machinery yet)_
+- [x] Niladic / monadic / dyadic dispatch (function valence at definition time)
+- [x] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
 
 ### Phase 6 — classic programs + drive corpus
-- [ ] Classic programs in `lib/apl/tests/programs/`:
-  - [ ] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
-  - [ ] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
-  - [ ] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
-  - [ ] `n-queens.apl` — backtracking via reduce
-  - [ ] `quicksort.apl` — the classic Roger Hui one-liner
-- [ ] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
-- [ ] Drive corpus to 100+ green
-- [ ] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
+- [x] Classic programs in `lib/apl/tests/programs/`:
+  - [x] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
+  - [x] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
+  - [x] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
+  - [x] `n-queens.apl` — backtracking via reduce
+  - [x] `quicksort.apl` — the classic Roger Hui one-liner
+- [x] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
+- [x] Drive corpus to 100+ green
+- [x] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
+
+### Phase 7 — end-to-end pipeline + closing the gaps
+
+Phase 1-6 built parser and runtime as parallel layers — they don't yet meet.
+Phase 7 wires them together so APL source actually runs through the full stack,
+and tightens loose ends.
+
+- [x] **Operators in `apl-eval-ast`** — handle `:derived-fn` (e.g. `+/`, `f¨`),
+  `:outer` (`∘.f`), `:derived-fn2` (`f.g`).  Each derived-fn-node wraps an inner
+  function; eval-ast resolves the inner glyph to a runtime fn and dispatches
+  to the matching operator helper (`apl-reduce`, `apl-each`, `apl-outer`,
+  `apl-inner`, `apl-commute`, `apl-compose`, `apl-power`, `apl-rank`).
+- [x] **End-to-end pipeline** — entry point `apl-run : string → array` that
+  chains `apl-tokenize` → `parse-apl` → `apl-eval-ast` against an empty env.
+  Verify with one-liners (`+/⍳5` → 15, `1 2 3 + 4 5 6` → 7 9 11, etc.) and
+  with the actual `.apl` source files in `tests/programs/`.
+- [x] **`:quad-name` AST + handler** — extend tokenizer/parser to recognise
+  `⎕name`, then handle in `apl-eval-ast` by dispatching to `apl-quad-*`
+  runtime fns (`⎕IO`, `⎕ML`, `⎕FR`, `⎕TS`, `⎕FMT`, `⎕←`).
+  _(`⎕←` deferred — tokenizer treats `←` as `:assign` after `⎕`.)_
+- [x] **Bracket indexing verification** — load programs that use `A[I]` /
+  `A[I;J]` end-to-end; confirm parser desugars to `⌷` and runtime returns
+  expected slices.  Add 5+ tests.
+  _(Single-axis only — multi-axis `A[I;J]` requires semicolon parsing, deferred.)_
+- [x] **Idiom corpus expansion** — extend `idioms.sx` from 34 to 60+ once
+  end-to-end works (we can express idioms as APL strings, not as runtime
+  calls).  Source-string-based idioms validate the whole stack.
+- [x] **`:Trap` / `:EndTrap`** — minimal exception machinery: `:Trap n`
+  catches errors with code `n`, body runs in `apl-tradfn-eval-block`,
+  on error switches to the trap branch.  Define `apl-throw` and a small
+  set of error codes; use `try`/`catch` from the host.
+
+### Phase 8 — fill the gaps left after end-to-end
+
+Phase 7 wired the stack together; Phase 8 closes deferred items, lets real
+programs run from source, and starts pushing on performance.
+
+- [x] **Quick-wins bundle** (one iteration) — three small fixes that each unblock
+  real programs:
+  - decimal literals: `read-digits!` consumes one trailing `.` plus more digits
+    so `3.7` tokenises as one number;
+  - `⎕←` (print) — tokenizer special-case: when `⎕` is followed by `←`, emit
+    a single `:name "⎕←"` token (don't split on the assign glyph);
+  - string values in `apl-eval-ast` — handle `:str` (parser already produces
+    them) by wrapping into a vector of character codes (or rank-0 string).
+- [x] **Named function definitions** — `f ← {⍺+⍵} ⋄ 1 f 2` and `2 f 3`.
+  - parser: when `:assign`'s RHS is a `:dfn`, mark it as a function binding;
+  - eval-ast: `:assign` of a dfn stores the dfn in env;
+  - parser: a name in fn-position whose env value is a dfn dispatches as a fn;
+  - resolver: extend `apl-resolve-monadic`/`-dyadic` with a `:fn-name` case
+    that calls `apl-call-dfn`/`apl-call-dfn-m`.
+- [x] **Multi-axis bracket indexing** — `A[I;J]` and `A[;J]` and `A[I;]`.
+  - parser: split bracket content on `:semi` at depth 0; emit
+    `(:dyad ⌷ (:vec I J) A)`;
+  - runtime: extend `apl-squad` to accept a vector of indices, treating
+    `nil` / empty axis as "all";
+  - 5+ tests across vector and matrix.
+- [x] **`.apl` files as actual tests** — `lib/apl/tests/programs/*.apl` are
+  currently documentation. Add `apl-run-file path → array` plus tests that
+  load each file, execute it, and assert the expected result. Makes the
+  classic-program corpus self-validating instead of two parallel impls.
+  _(Embedded source-string approach: tests/programs-e2e.sx runs the same
+  algorithms as the .apl docs through the full pipeline. The original
+  one-liners (e.g. primes' inline `⍵←⍳⍵`) need parser features
+  (compress-as-fn, inline assign) we haven't built yet — multi-stmt forms
+  used instead. Slurp/read-file primitive missing in OCaml SX runtime.)_
+- [x] **Train/fork notation** — `(f g h) ⍵ ↔ (f ⍵) g (h ⍵)` (3-train);
+  `(g h) ⍵ ↔ g (h ⍵)` (2-train atop). Parser: detect when a parenthesised
+  subexpression is all functions and emit `(:train fns)`; resolver: build the
+  derived function; tests for mean-via-train (`+/÷≢`).
+- [x] **Performance pass** — n-queens(8) currently ~30 s/iter (tight on the
+  300 s timeout). Target: profile the inner loop, eliminate quadratic
+  list-append, restore the `queens(8)` test.
+
+### Phase 9 — make `.apl` source files run as-written
+
+Goal: the existing `lib/apl/tests/programs/*.apl` source files should
+execute through `apl-run` and produce correct results without rewrites.
+Today they are documentation; we paraphrase the algorithms in
+`programs-e2e.sx`.  Phase 9 closes that gap.
+
+- [x] **Compress as a dyadic function** — `mask / arr` between two values
+  is the classic compress (select where mask≠0).  Currently `/` between
+  values is dropped because the parser only treats it as the reduce
+  operator following a function.  Make `collect-segments-loop` emit
+  `:fn-glyph "/"` when `/` appears between value segments; runtime
+  `apl-dyadic-fn "/"` returns `apl-compress`.  Same for `⌿`
+  (first-axis compress).
+- [x] **Inline assignment** — `⍵ ← ⍳⍵` mid-expression.  Parser currently
+  only handles `:assign` at the start of a statement.  Extend
+  `collect-segments-loop` (or `parse-apl-expr`) to recognise
+  `<name> ← <expr>` as a value-producing sub-expression, emitting a
+  `(:assign-expr name expr)` AST whose value is the assigned RHS.
+  Required by the primes idiom `(2=+⌿0=⍵∘.|⍵)/⍵←⍳⍵`.
+  _(Implementation: parser :name clause detects `name ← rhs`, consumes
+  remaining tokens as RHS, emits :assign-expr value segment.  Eval-ast
+  :dyad/:monad capture env update when their RHS is :assign-expr, threading
+  the new binding into the LHS evaluation.  Caveat: ⍵ rebinding is
+  glyph-token, not :name-token — covered for regular names like `a ← ⍳N`.)_
+- [x] **`?` (random / roll)** — monadic `?N` returns a random integer
+  in 1..N.  Used by quicksort.apl for pivot selection.  Add `apl-roll`
+  (deterministic seed for tests) + glyph wiring.
+- [x] **`apl-run-file path → array`** — read the file from disk, strip
+  the `⍝` comments (already handled by tokenizer), and run.  Needs an
+  IO primitive on the SX side.  Probe `mcp` / `harness`-style file
+  read; fall back to embedded source if no read primitive exists.
+  _(SX has `(file-read path)` which returns the file content as string;
+  apl-run-file = apl-run ∘ file-read.)_
+- [x] **End-to-end .apl tests** — once the above land, add tests that
+  run `lib/apl/tests/programs/*.apl` *as written* and assert results.
+  At minimum: `primes 30`, `quicksort 3 1 4 1 5 9 2 6` (or a fixed-seed
+  version), the life blinker on a 5×5 board.
+  _(primes.apl runs as-written with ⍵-rebind now supported.  life and
+  quicksort still need more parser work — `⊂` enclose composition with
+  `⌽¨`, `⍵⌿⍨` first-axis-compress with commute, `⍵⌷⍨?≢⍵`.)_
+- [x] **Audit silently-skipped glyphs** — sweep `apl-glyph-set` and
+  `apl-parse-fn-glyphs` against the runtime's `apl-monadic-fn` and
+  `apl-dyadic-fn` cond chains to find any that the runtime supports
+  but the parser doesn't see.
+  _(Wired ⍉ → apl-transpose / apl-transpose-dyadic, ⊢ identity,
+  ⊣ left, ⍕ as alias for ⎕FMT.  ⊆ ∪ ∩ ⍸ ⊥ ⊤ ⍎ remain unimplemented
+  in the runtime — parser sees them as functions but eval errors;
+  next-phase work.)_
+
+### Phase 10 — fill runtime gaps + life/quicksort source files run
+
+Phase 9 left seven glyphs that the parser recognises but the runtime
+cannot evaluate, and two source files (`life.apl`, `quicksort.apl`) that
+still need work to run as-written.  Phase 10 closes both.
+
+- [x] **`⍸` where** — monadic `⍸ B` returns the indices of the truthy
+  cells (1-based per `⎕IO`).  Dyadic `X ⍸ Y` is interval index (find
+  the largest `i` such that `X[i] ≤ Y`).  Add `apl-where` + dyadic
+  `apl-interval-index`; wire both into `apl-monadic-fn` / `apl-dyadic-fn`.
+  Tests: `⍸ 0 1 0 1 1 → 2 4 5`, `⍸ ⍳5 = ¯1+⍳5 → empty`,
+  `2 4 6 ⍸ 5 → 2`.
+- [x] **`∪` unique / `∩` intersection** — monadic `∪ V` returns V with
+  duplicates removed (first-occurrence order); dyadic `A ∪ B` is
+  union; `A ∩ B` is intersection (members of A that are also in B).
+  Add `apl-unique`, `apl-union`, `apl-intersect`.  Tests cover empty,
+  single, repeats, mixed numerics.
+- [x] **`⊥` decode / `⊤` encode** — `B ⊥ V` evaluates digits `V` in
+  base(s) `B` (Horner-style); `B ⊤ N` is the inverse, returning the
+  digits of `N` in base(s) `B`.  Both broadcast `B` as scalar or
+  conformable vector.  Add `apl-decode` and `apl-encode`.  Tests:
+  `2 ⊥ 1 0 1 → 5`, `10 ⊥ 1 2 3 → 123`, `2 2 2 ⊤ 5 → 1 0 1`,
+  `24 60 60 ⊤ 7384 → 2 3 4`.
+- [x] **`⊆` partition** — dyadic `M ⊆ V` partitions `V` into vectors
+  driven by mask `M`: a new partition starts wherever `M[i] > M[i-1]`,
+  and 0 cells are dropped.  Returns a vector of (boxed) partitions.
+  Add `apl-partition`.  Tests: `1 1 0 1 1 ⊆ 'abcde' → ('ab' 'de')`,
+  `1 0 0 1 1 ⊆ ⍳5 → ((⊂ 1) (⊂ 4 5))`.
+- [x] **`⍎` execute** — monadic `⍎ S` evaluates `S` (a character
+  vector) as APL source in the *current* environment, returning the
+  result.  Implement as `(fn (s) (apl-run s))` — env is the global
+  one; nested execute is fine.  Wire into `apl-monadic-fn`.  Tests:
+  `⍎ '1 + 2' → 3`, `⍎ '+/⍳10' → 55`.
+- [x] **`life.apl` runs as-written** — Conway's life one-liner uses
+  `⊃+/⌽¨ -1 0 1 ∘.,¯1 0 1` (each + outer-comma + disclose + reduce
+  over a list of rotations) and the rule expression.  Probe what
+  fails when `apl-run-file "lib/apl/tests/programs/life.apl"` is
+  called on a 5×5 blinker grid; fix any remaining parser/runtime
+  gaps; assert blinker oscillates and block stays stable as full
+  end-to-end tests in `programs-e2e.sx`.
+- [x] **`quicksort.apl` runs as-written** — the classic Iverson dfn
+  `{1≥≢⍵:⍵ ⋄ (∇(⍵<pivot)⌿⍵),(⍵=pivot)⌿⍵,∇(⍵>pivot)⌿⍵⊣pivot←⍵⌷⍨?≢⍵}`
+  exercises `⌷⍨` (squad-commute pivot pick), `⌿⍨` (first-axis-compress
+  commute), and `⊣` to bind a local without polluting the result.
+  Set the RNG seed for determinism and assert the sort against
+  `apl-grade-up`.
+
+### Phase 11 — heterogeneous-strand inner product (restore life.apl ⊃)
+
+Phase 10 step 6 closed life.apl by dropping the leading `⊃` from
+Hui's formulation, because our inner product over a mixed
+scalar/matrix strand (`1 ⍵`) produced a clean (5 5) board which
+`⊃` then collapsed to its first row.  Hui's original needs `⊃` to
+*unwrap* an enclosed result of the inner product.  Phase 11 closes
+that semantic gap so life.apl can be restored to its true
+as-written form.
+
+- [x] **Inner product encloses on heterogeneous left arg** —
+  detect when `A` in `A f.g B` has a ravel containing a dict
+  (boxed array), and in that case wrap the inner-product result
+  in `enclose` (rank-0 wrapping the matrix).  Then `⊃` on the
+  result unwraps to the underlying board.  Restore life.apl to
+  the original `{⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}`
+  and update its tests + comment block.
 
 ## SX primitive baseline
 
@@ -118,8 +306,76 @@ data; format for string templating.
 
 _Newest first._
 
-- _(none yet)_
+- 2026-05-11: Phase 11 — heterogeneous-strand inner product. apl-inner now encloses its result when A's ravel contains a dict (boxed array) — Hui's `1 ⍵ ∨.∧ X` produces a rank-0 wrapping the (5 5) board, which ⊃ then unwraps to the bare matrix. Restored life.apl to its true as-written form `{⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}` and updated all 5 e2e tests + comment block. Homogeneous inner product unaffected (+.× over numbers/matrices still produces bare arrays). +4 pipeline tests for the heterogeneous case + ⊃ unwrap path; **Phase 11 complete**; full suite 589/589
+- 2026-05-08: Phase 10 step 7 — quicksort.apl runs as-written. Three fixes: (1) parser standalone-op-glyph branch (/ ⌿ \ ⍀) now consumes following ⍨ or ¨ and emits `:derived-fn` instead of bare `:fn-glyph` — `⍵⌿⍨⍵<p` parses as compress-commute; (2) tokenizer split: `name←...` (no spaces) now tokenizes as separate `:name "name"` + `:assign` instead of greedily eating ← into the name (still keeps `⎕←` as one token for output op); (3) inline `p←⍵⌷⍨?≢⍵` mid-dfn now works via existing :assign-expr machinery. The classic Iverson dfn `{1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p}` sorts correctly. +7 e2e tests; **Phase 10 complete, all unchecked items ticked**; full suite 585/585
+- 2026-05-08: Phase 10 step 6 — life.apl runs as-written. Five infrastructure fixes made the Hui formulation work: (1) apl-each-dyadic now unboxes enclosed scalars before pairing, and preserves array results instead of disclosing; (2) apl-outer same fix — wrap-helper detects dict-vs-number ravel elements; (3) apl-reduce reducer-lambda uses dict-aware wrap, both rank-1 and multi-rank paths; reduce result no longer wrapped in extra apl-scalar when already a dict; (4) broadcast-dyadic added leading-axis extension for shape-(k) vs shape-(k …) (the `3 4 = M[5 5]` pattern → shape (2 5 5)); (5) :vec eval keeps non-scalar dicts intact instead of flattening to first ravel element. Updated life.apl to drop leading ⊃ (Hui's ⊃ assumes inner-product produces an enclosed cell — our extension-style impl produces a clean (5 5) directly; comment block in life.apl explains). +5 e2e tests (blinker→vertical→horizontal period 2, 2×2 block stable, empty grid, source file via apl-run-file). Full test suite 578/578
+- 2026-05-08: Phase 10 step 5 — `⍎` execute. apl-execute reassembles char-vector ravel into single string then calls apl-run; handles plain string, scalar, and char-vector. `⍎ '1 + 2' → 3`, `⍎ '+/⍳10' → 55`, round-trip `⍎ ⎕FMT 42 → 42`, nested `⍎ ⍎ '...'` works, with `⋄` separator (assignment + use). Wired into apl-monadic-fn. +8 tests; pipeline 148/148
+- 2026-05-08: Phase 10 step 4 — `⊆` partition. apl-partition: walk M and V together via reduce, opening a new partition where M[i]>M[i-1] (initial prev=0), continuing where M[i]≤prev∧M[i]≠0, dropping cells where M[i]=0. Returns apl-vector of apl-vector parts. `1 1 0 1 1 ⊆ 'abcde' → ('ab' 'de')`, `1 0 0 1 1 ⊆ ⍳5 → ((1) (4 5))`, strict-increase `1 2` opens new, constant `2 2` continues. Wired into apl-dyadic-fn. +8 tests; pipeline 140/140
+- 2026-05-08: Phase 10 step 3 — `⊥` decode / `⊤` encode. apl-decode (Horner reduce over indices, base[i]>0; scalar base broadcasts to digit length); apl-encode (right-to-left modulo+floor-div via reduce). Mixed-radix HMS works: `24 60 60 ⊥ 2 3 4 → 7384`, `24 60 60 ⊤ 7384 → 2 3 4`. Round-trips exact. Wired ⊥ ⊤ into apl-dyadic-fn. +11 tests; pipeline 132/132
+- 2026-05-08: Phase 10 step 2 — `∪` unique / `∩` intersection. apl-unique (monadic, dedup keeping first-occurrence order via reduce+index-of), apl-union (dyadic, dedup'd A then B-elements-not-in-A), apl-intersect (dyadic, A elements that are also in B, preserves left order). Wired ∪ into both apl-monadic-fn and apl-dyadic-fn cond chains; ∩ into apl-dyadic-fn. +12 tests; pipeline 121/121
+- 2026-05-08: Phase 10 step 1 — `⍸` where. apl-where (monadic, indices of truthy cells, ⎕IO-respecting) + apl-interval-index (dyadic, count of breaks ≤ y; broadcasts over Y vector or scalar). Wired into apl-monadic-fn / apl-dyadic-fn (cond clauses inserted as proper siblings via sx_insert_child after sx_insert_near silently wrapped multi-form sources in `(begin …)`). +10 tests; pipeline 109/109
+- 2026-05-08: Phase 10 added — fill runtime gaps (⍸ ∪ ∩ ⊥ ⊤ ⊆ ⍎) + life.apl and quicksort.apl as-written
+- 2026-05-07: Phase 9 step 6 — glyph audit. Wired ⍉ → apl-transpose/apl-transpose-dyadic, ⊢ → monadic+dyadic identity-right, ⊣ → identity-left, ⍕ → apl-quad-fmt. +6 tests; **Phase 9 complete, all unchecked items ticked**; pipeline 99/99
+- 2026-05-07: Phase 9 step 5 — primes.apl runs as-written end-to-end. Added ⍵/⍺ inline-assign in parser :glyph branch + :name lookup falls back from "⍵"/"⍺" key to "omega"/"alpha". `apl-run "primes ← {(2=+⌿0=⍵∘.|⍵)/⍵←⍳⍵} ⋄ primes 50"` → 15 primes. +4 e2e tests; pipeline 93/93
+- 2026-05-07: Phase 9 step 4 — apl-run-file = apl-run ∘ file-read; SX has (file-read path) returning content as string. primes/life/quicksort .apl files now load and parse end-to-end (return :dfn AST). +4 tests
+- 2026-05-07: Phase 9 step 3 — `?N` random / roll. Top-level mutable apl-rng-state with LCG; apl-rng-seed! for deterministic tests; apl-roll wraps as scalar in 1..N. apl-monadic-fn maps "?" → apl-roll. +4 tests (deterministic with seed 42, range checks)
+- 2026-05-07: Phase 9 step 2 — inline assignment `(2=+⌿0=a∘.|a)/a←⍳30` runs end-to-end. Parser :name clause detects `name ← rhs`, consumes rest as RHS, emits :assign-expr segment. Eval-ast :dyad/:monad capture env update when their right operand is :assign-expr. +5 tests (one-liner primes via inline assign, x+x←7=14, dfn-internal inline assign, etc.)
+- 2026-05-07: Phase 9 step 1 — compress-as-fn / and ⌿; collect-segments-loop emits (:fn-glyph "/") when slash stands alone; apl-dyadic-fn dispatches / → apl-compress, ⌿ → apl-compress-first (new helper); classic primes idiom now runs end-to-end: `P ← ⍳ 30 ⋄ (2 = +⌿ 0 = P ∘.| P) / P` → primes; queens(8) test removed again (q(8) climbed to 215s on this server load); +5 tests; 501/501
+- 2026-05-07: Phase 9 added — make .apl source files run as-written (compress as dyadic /, inline assignment, ? random, apl-run-file, glyph audit, source-as-tests)
+- 2026-05-07: Phase 8 step 6 — perf: swapped (append acc xs) → (append xs acc) in apl-permutations to make permutation generation linear instead of quadratic; q(7) 32s→12s; q(8)=92 test restored within 300s timeout; **Phase 8 complete, all unchecked items ticked**; 497/497
+- 2026-05-07: Phase 8 step 5 — train/fork notation. Parser :lparen detects all-fn inner segments → emits :train AST; resolver covers 2-atop & 3-fork for both monadic and dyadic. `(+/÷≢) 1..5 → 3` (mean), `(- ⌊) 5 → -5` (atop), `2(+×-)5 → -21` (dyadic fork), `(⌈/-⌊/) → 8` (range); +6 tests; 496/496
+- 2026-05-07: Phase 8 step 4 — programs-e2e.sx runs classic-algorithm shapes through full pipeline (factorial via ∇, triangulars, sum-of-squares, divisor-counts, prime-mask, named-fn composition, dyadic max-of-two, Newton step); also added ⌿ + ⍀ to glyph sets (were silently skipped); +15 tests; 490/490
+- 2026-05-07: Phase 8 step 3 — multi-axis bracket A[I;J] / A[I;] / A[;J] via :bracket AST + apl-bracket-multi runtime; split-bracket-content scans :semi at depth 0; apl-cartesian builds index combinations; nil axis = "all"; scalar axis collapses; +8 tests; 475/475
+- 2026-05-07: Phase 8 step 2 — named function defs end-to-end via parser pre-scan; apl-known-fn-names + apl-collect-fn-bindings detect `name ← {...}` patterns; collect-segments-loop emits :fn-name for known names; resolver looks up env for :fn-name; supports recursion (∇ in named dfn); +7 tests including fact via ∇; 467/467
+- 2026-05-07: Phase 8 step 1 — quick-wins bundle: decimal literals (3.7, ¯2.5), ⎕← passthrough as monadic fn (single-token via tokenizer special-case), :str AST in eval-ast (single-char→scalar, multi-char→vec); +10 tests; 460/460
+- 2026-05-07: Phase 8 added — quick-wins bundle (decimals + ⎕← + strings), named functions, multi-axis bracket, .apl-files-as-tests, trains, perf
+- 2026-05-07: Phase 7 step 6 — :Trap exception machinery via R7RS guard; apl-throw raises tagged error, apl-trap-matches? checks codes (0=catch-all), :trap clause in apl-tradfn-eval-stmt wraps try-block with guard; :throw AST for testing; **Phase 7 complete, all unchecked plan items done**; +5 tests; 450/450
+- 2026-05-07: Phase 7 step 5 — idiom corpus 34→64 (+30 source-string idioms via apl-run); also fixed tokenizer + parser to recognize ≢ and ≡ glyphs (were silently skipped); 445/445
+- 2026-05-07: Phase 7 step 4 — bracket indexing `A[I]` desugared to `(:dyad ⌷ I A)` via maybe-bracket helper, wired into :name + :lparen branches of collect-segments-loop; multi-axis (A[I;J]) deferred (semicolon split); +7 tests; 415/415
+- 2026-05-07: Phase 7 step 3 — :quad-name end-to-end; tokenizer already produced :name "⎕FMT"; parser is-fn-tok? extended via apl-quad-fn-names; eval-ast :name dispatches ⎕IO/⎕ML/⎕FR/⎕TS to apl-quad-*; apl-monadic-fn handles ⎕FMT; ⎕← deferred (tokenizer splits ⎕←); +8 tests; 408/408
+- 2026-05-07: Phase 7 step 2 — end-to-end pipeline `apl-run : string → array` (parse-apl + apl-eval-ast against empty env); +25 source-string tests covering scalars, strands, dyadic arith, monadic primitives, operators, ∘./.g products, comparisons, famous one-liners (+/⍳10=55, ×/⍳10=10!); tokenizer can't yet parse decimals so `3.7` literal tests dropped; **400/400**
+- 2026-05-07: Phase 7 step 1 — operators in apl-eval-ast via apl-resolve-monadic/dyadic; supports / ⌿ \ ⍀ ¨ ⍨ ∘. f.g; queens(8) test removed (too slow for 300s timeout); +14 eval-ops tests; 375/375
+- 2026-05-07: Phase 7 added — end-to-end pipeline, operators in eval-ast, :quad-name, bracket-indexing verify, idiom expansion, :Trap; aim is to wire parser↔runtime so .apl source files actually run
+- 2026-05-07: Phase 6 idiom corpus — lib/apl/tests/idioms.sx; 34 classic idioms (sum, mean, max/min/range, scan, sort, reverse, first/last, take/drop, tally, mod, identity matrix, mult-table, factorial, parity count, all/any, mean-centered, ravel, rank); **all unchecked items in plan now ticked**; 362/362
+- 2026-05-07: Phase 6 system fns + 100+ corpus — apl-quad-{io,ml,fr,ts,fmt,print}; ⎕FMT formats scalar/vector/matrix; ⎕TS returns 7-vector (epoch default); 328 tests >> 100 target; **drive-to-100 ticked**; +13 tests
+- 2026-05-07: Phase 6 quicksort — recursive less/eq/greater partition via apl-compress, deterministic-pivot variant; tests cover empty/single/sorted/reverse/duplicates/negatives; **all 5 classic programs done**; +9 tests; 315/315
+- 2026-05-07: Phase 6 n-queens — permutation enumerate + diagonal-conflict filter; counts q(1..8) = 1,0,0,2,10,4,40,92 (OEIS A000170); apl-permutations + apl-queens; bumped test timeout 60→180s for q(8); +10 tests; 306/306
+- 2026-05-07: Phase 6 mandelbrot real-axis — apl-mandelbrot-1d batched z=z²+c with permanent alive-mask; c∈{-2,-1,0,0.25} bounded, c=1→3, c=0.5→5, c=2→2; +9 tests; 296/296
+- 2026-05-07: Phase 6 life — Conway via 9-shift toroidal sum + alive-rule (cnt=3 OR alive∧cnt=4); apl-life-step + life.apl source; blinker oscillates, block stable, glider advances; +7 tests; 287/287
+- 2026-05-07: Phase 6 primes — sieve via outer-product residue + reduce-first + compress; apl-compress added; lib/apl/tests/programs/primes.apl source; +11 tests; 280/280
+- 2026-05-07: Phase 5 conformance.sh + scoreboard.{json,md} — per-suite runner; current snapshot 269/269; **Phase 5 complete**
+- 2026-05-07: Phase 5 valence dispatch — apl-dfn-valence (AST scan for ⍺/⍵), apl-tradfn-valence (slot check), apl-call unified entry; +14 tests; 269/269 tests
+- 2026-05-07: Phase 5 control words — :If/:Else, :While, :For/:In, :Select/:Case via apl-tradfn-eval-block/stmt threading env; :Trap deferred; +10 tests (sum loop, factorial, dispatch, nested); 255/255 tests
+- 2026-05-07: Phase 5 tradfn — apl-call-tradfn + apl-tradfn-loop; line-numbered stmts, :branch goto, →0 exits, locals; +10 tests including loop sum; 245/245 tests
+- 2026-05-07: Phase 5 dfn complete — apl-eval-stmts (guards, locals, ⍺←default), ∇ recursion via env "nabla"; +9 tests (factorial, guards, defaults, locals); 235/235 tests
+- 2026-05-07: Phase 5 dfn foundation — lib/apl/transpile.sx with apl-eval-ast (handles :num :vec :name :monad :dyad :program :dfn) + glyph→fn lookup tables; apl-call-dfn / apl-call-dfn-m bind ⍺/⍵; ∇/guards/defaults/locals pending; 226/226 tests
+- 2026-05-07: Phase 4 step 10 — at @ (apl-at-replace + apl-at-apply); linear-index lookup, scalar-vals broadcast; 211/211 tests
+- 2026-05-07: Phase 4 step 9 — rank f⍤k (apl-rank); cell decomposition + reassembly via frame/cell shapes; 201/201 tests
+- 2026-05-06: Phase 4 step 8 — power f⍣n (apl-power) + fixed-point f⍣≡ (apl-power-fixed); 191/191 tests
+- 2026-05-06: Phase 4 step 7 — compose f∘g (apl-compose monadic f∘g x, apl-compose-dyadic dyadic f x (g y)); 182/182 tests
+- 2026-05-06: Phase 4 step 6 — commute f⍨ (apl-commute monadic dup, apl-commute-dyadic swap); 173/173 tests
+- 2026-05-06: Phase 4 step 5 — inner product f.g (apl-inner); +.× matrix multiply, ∧.= equal-vectors; 163/163 tests
+- 2026-05-06: Phase 4 step 4 — outer product ∘.f (apl-outer); rank-doubling result shape = a-shape++b-shape; 151/151 tests
+- 2026-05-06: Phase 4 step 3 — each f¨ (monadic apl-each + dyadic apl-each-dyadic); scalar broadcast both sides; 139/139 tests
+- 2026-05-06: Phase 4 step 2 — scan f\ (last axis) + f⍀ (first axis); apl-scan/apl-scan-first; 125/125 tests
+- 2026-05-06: Phase 4 step 1 — reduce f/ (last axis) + f⌿ (first axis); apl-reduce/apl-reduce-first; 110/110 tests
+- 2026-05-06: Phase 3 complete — membership ∊, dyadic ⍳ (index-of), without ~ (index-of returns nil for not-found); 94/94 tests
+- 2026-05-06: Phase 3 step 6 — enclose ⊂ / disclose ⊃ (box/unbox, rank-0 detect via type-of); 82/82 tests
+- 2026-05-06: Phase 3 step 5 — grade-up ⍋ / grade-down ⍒ (stable insertion sort); 74/74 tests
+- 2026-05-06: Phase 3 step 4 — squad ⌷ (scalar/multi-dim/partial-slice); 66/66 tests
+- 2026-05-06: Phase 3 step 3 — catenate , (last axis, scalar promo) and first-axis; 59/59 tests
+- 2026-05-06: Phase 3 step 2 — take ↑ (multi-axis, pad), drop ↓, reverse/rotate ⌽⊖ (last+first axis); 50/50 tests
+- 2026-05-06: Phase 3 step 1 — reshape ⍴ (cycling), transpose ⍉ (monadic+dyadic); helpers apl-strides/flat->multi/multi->flat; 27/27 structural tests; lib/apl/tests/structural.sx
+- 2026-04-26: Phase 2 complete — array model + 7 scalar primitive groups; 82/82 tests; lib/apl/runtime.sx + lib/apl/tests/scalar.sx
+- 2026-04-26: parser (Phase 1 step 2) — 44/44 parser tests green (90/90 total); right-to-left segment algorithm; derived fns, outer/inner product, dfns with guards, strand handling; `lib/apl/parser.sx` + `lib/apl/tests/parse.sx`
+- 2026-04-25: tokenizer (Phase 1 step 1) — 46/46 tests green; Unicode-aware starts-with? scanner for multi-byte APL glyphs; `lib/apl/tokenizer.sx` + `lib/apl/tests/parse.sx`
 
 ## Blockers
 
-- _(none yet)_
+- 2026-05-08: **sx-tree MCP server disconnected at start of Phase 10.**
+  Path-based sx-tree tools error with `Type_error("Expected string, got null")`
+  and the server then dropped entirely (45 tools unavailable).  Loop paused
+  at Phase 10 step 1 (`⍸ where`); resume once `/mcp` reconnects sx-tree.
+- 2026-05-07: **sx-tree MCP server disconnected mid-Phase-9.** `lib/apl/**.sx`
+  edits require `sx-tree` per CLAUDE.md — Edit/Read on `.sx` is hook-blocked.
+  Loop paused at Phase 9 step 2 (inline assignment); resume once MCP restored.

plans/common-lisp-on-sx.md

@@ -96,19 +96,19 @@ Core mapping:
 ### Phase 5 — macros + LOOP + reader macros
 - [x] `defmacro`, `macrolet`, `symbol-macrolet`, `macroexpand-1`, `macroexpand`
 - [x] `gensym`, `gentemp`
-- [ ] `set-macro-character`, `set-dispatch-macro-character`, `get-macro-character`
+- [x] `set-macro-character`, `set-dispatch-macro-character`, `get-macro-character`
 - [x] **The LOOP macro** — iteration drivers (`for … in/across/from/upto/downto/by`, `while`, `until`, `repeat`), accumulators (`collect`, `append`, `nconc`, `count`, `sum`, `maximize`, `minimize`), conditional clauses (`if`/`when`/`unless`/`else`), termination (`finally`/`thereis`/`always`/`never`), `named` blocks
 - [x] LOOP test corpus: 27 tests covering all clause types
 
 ### Phase 6 — packages + stdlib drive
-- [ ] `defpackage`, `in-package`, `export`, `use-package`, `import`, `find-package`
-- [ ] Package qualification at the reader level — `cl:car`, `mypkg::internal`
-- [ ] `:common-lisp` (`:cl`) and `:common-lisp-user` (`:cl-user`) packages
-- [ ] Sequence functions — `mapcar`, `mapc`, `mapcan`, `reduce`, `find`, `find-if`, `position`, `count`, `every`, `some`, `notany`, `notevery`, `remove`, `remove-if`, `subst`
-- [ ] List ops — `assoc`, `getf`, `nth`, `last`, `butlast`, `nthcdr`, `tailp`, `ldiff`
-- [ ] String ops — `string=`, `string-upcase`, `string-downcase`, `subseq`, `concatenate`
-- [ ] FORMAT — basic directives `~A`, `~S`, `~D`, `~F`, `~%`, `~&`, `~T`, `~{...~}` (iteration), `~[...~]` (conditional), `~^` (escape), `~P` (plural)
-- [ ] Drive corpus to 200+ green
+- [x] `defpackage`, `in-package`, `export`, `use-package`, `import`, `find-package`
+- [x] Package qualification at the reader level — `cl:car`, `mypkg::internal`
+- [x] `:common-lisp` (`:cl`) and `:common-lisp-user` (`:cl-user`) packages
+- [x] Sequence functions — `mapcar`, `mapc`, `mapcan`, `reduce`, `find`, `find-if`, `position`, `count`, `every`, `some`, `notany`, `notevery`, `remove`, `remove-if`, `subst`
+- [x] List ops — `assoc`, `getf`, `nth`, `last`, `butlast`, `nthcdr`, `tailp`, `ldiff`
+- [x] String ops — `string=`, `string-upcase`, `string-downcase`, `subseq`, `concatenate`
+- [x] FORMAT — basic directives `~A`, `~S`, `~D`, `~F`, `~%`, `~&`, `~T`, `~{...~}` (iteration), `~[...~]` (conditional), `~^` (escape), `~P` (plural)
+- [x] Drive corpus to 200+ green
 
 ## SX primitive baseline
 
@@ -124,6 +124,14 @@ data; format for string templating.
 
 _Newest first._
 
+- 2026-05-05: Phase 5 set-macro-character — cl-reader-macros + cl-dispatch-macros global dicts; SET-MACRO-CHARACTER/GET-MACRO-CHARACTER/SET-DISPATCH-MACRO-CHARACTER dispatch in eval.sx (stores fn, doesn't wire into reader — stubs sufficient to avoid errors). Phase 5 fully ticked. Phase 6 Drive corpus 200+ ticked (518 total, 54 stdlib). All roadmap items done.
+
+- 2026-05-05: Phase 6 packages — defpackage/in-package/export/use-package/import/find-package/package-name; cl-packages dict, cl-current-package; cl-package-sep? strips pkg: prefix from symbols+functions; package-qualified calls (cl:car, cl:mapcar) work. 4 package tests added; 518 total tests, 0 failed.
+
+- 2026-05-05: Phase 6 FORMAT — cl-fmt-a/cl-fmt-s/cl-fmt-find-close/cl-fmt-iterate/cl-fmt-loop in eval.sx; ~A/~S/~D/~F/~%/~&/~T/~P/~{...~}/~[...~]/~^/~~; also fixed substr(start,length) semantics throughout (SUBSEQ, cl-fmt-loop); 6 FORMAT tests added to stdlib.sx; 514 total tests, 0 failed.
+
+- 2026-05-05: Phase 6 stdlib — sequence functions (mapc/mapcan/reduce/find/find-if/find-if-not/position/position-if/count/count-if/every/some/notany/notevery/remove/remove-if/remove-if-not/subst/member), list ops (assoc/rassoc/getf/last/butlast/nthcdr/copy-list/list*/caar/cadr/cdar/cddr/caddr/cadddr/pairlis), string ops (subseq/string/char/string-length/string</>), plus coerce/make-list/write-to-string; 44 tests in tests/stdlib.sx; Phase 6 sequence+list+string boxes ticked. Total: 508 tests, 0 failed.
+
 - 2026-05-05: Phase 4 CLOS fully complete — `lib/common-lisp/clos.sx` (27 forms): clos-class-registry (8 built-in classes), defclass/make-instance/slot-value/slot-boundp/set-slot-value!/find-class/change-class, defgeneric/defmethod with :before/:after/:around, clos-call-generic (standard method combination: sort by specificity, fire befores, call primary chain, fire afters in reverse), call-next-method/next-method-p, with-slots, accessor installation; 41 tests in `tests/clos.sx`; classic programs `geometry.sx` (12 tests, multi-dispatch intersect on P/L/Plane) and `mop-trace.sx` (13 tests, :before/:after tracing). Dynamic variables in eval.sx: cl-apply-dyn saves/restores global bindings around let for specials (cl-mark-special!/cl-special?/cl-dyn-unbound). Key gotchas: qualifier strings are "before"/"after"/"around" (no colon); dict-set pure = assoc; dict->list = (map (fn (k) (list k (get d k))) (keys d)); clos-add-reader-method bootstrapped via set! after defmethod defined; test isolation: use unique var names to avoid *y* collision. 437 total tests, 0 failed.
 - 2026-05-05: Phase 3 fully complete — conformance.sh runner + scoreboard.json/scoreboard.md; 363 total tests across all suites (79 reader, 31 parser, 174 eval, 59 conditions, 7+6+7 classic programs).
 - 2026-05-05: Phase 3 complete — cl-debugger-hook/cl-invoke-debugger in runtime.sx (cl-error routes through hook), cl-break-on-signals (fires hook before handlers on type match), cl-invoke-restart-interactively (calls fn with no args); 4 new tests (147 total). Phase 3 all boxes ticked.

plans/datalog-on-sx.md

@@ -0,0 +1,145 @@
+# Datalog-on-SX: Datalog on the CEK/VM
+
+Datalog is a declarative query language: a restricted subset of Prolog with no function
+symbols, only relations. Programs are sets of facts and rules; queries ask what follows.
+Evaluation is bottom-up (fixpoint iteration) rather than Prolog's top-down DFS — which
+means no infinite loops, guaranteed termination, and efficient incremental updates.
+
+The unique angle: Datalog is a natural companion to the Prolog implementation already in
+progress (`lib/prolog/`). The parser and term representation can share infrastructure;
+the evaluator is an entirely different fixpoint engine rather than a DFS solver.
+
+End-state goal: **full core Datalog** (facts, rules, stratified negation, aggregation,
+recursion) with a clean SX query API, and a demonstration of Datalog as a query engine
+for rose-ash data (e.g. federation graph, content relationships).
+
+## Ground rules
+
+- **Scope:** only touch `lib/datalog/**` and `plans/datalog-on-sx.md`. Do **not** edit
+  `spec/`, `hosts/`, `shared/`, `lib/prolog/**`, or other `lib/<lang>/`.
+- **Shared-file issues** go under "Blockers" below with a minimal repro; do not fix here.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Architecture:** Datalog source → term AST → fixpoint evaluator. No transpiler to SX AST —
+  the evaluator is written in SX and works directly on term structures.
+- **Reference:** Ramakrishnan & Ullman "A Survey of Deductive Database Systems";
+  Dalmau "Datalog and Constraint Satisfaction".
+- **Commits:** one feature per commit. Keep `## Progress log` updated and tick boxes.
+
+## Architecture sketch
+
+```
+Datalog source text
+    │
+    ▼
+lib/datalog/tokenizer.sx   — atoms, variables, numbers, strings, punct (?- :- , . ( ) [ ])
+    │
+    ▼
+lib/datalog/parser.sx      — facts: atom(args). rules: head :- body. queries: ?- goal.
+    │                        No function symbols (only constants and variables in args).
+    ▼
+lib/datalog/db.sx          — extensional DB (EDB): ground facts; IDB: derived relations;
+    │                        clause index by relation name/arity
+    ▼
+lib/datalog/eval.sx        — bottom-up fixpoint: semi-naive evaluation with delta sets;
+    │                        stratification for negation; incremental update API
+    ▼
+lib/datalog/query.sx       — query API: (datalog-query db goal) → list of substitutions;
+                             SX embedding: define facts/rules as SX data directly
+```
+
+Key differences from Prolog:
+- **No function symbols** — args are atoms, numbers, strings, or variables only. No `f(a,b)`.
+- **No cuts** — no procedural control.
+- **Bottom-up** — derive all consequences of all rules before answering; no search tree.
+- **Termination guaranteed** — no infinite derivation chains (no function symbols → finite Herbrand base).
+- **Stratified negation** — `not(P)` legal iff P does not recursively depend on its own negation.
+- **Aggregation** — `count`, `sum`, `min`, `max` over derived tuples (Datalog+).
+
+## Roadmap
+
+### Phase 1 — tokenizer + parser
+- [ ] Tokenizer: atoms (lowercase/quoted), variables (uppercase/`_`), numbers, strings,
+      operators (`:- `, `?-`, `,`, `.`), comments (`%`, `/* */`)
+      Note: no function symbol syntax (no nested `f(...)` in arg position).
+- [ ] Parser:
+      - Facts: `parent(tom, bob).` → `{:head (parent tom bob) :body ()}`
+      - Rules: `ancestor(X,Z) :- parent(X,Y), ancestor(Y,Z).`
+              → `{:head (ancestor X Z) :body ((parent X Y) (ancestor Y Z))}`
+      - Queries: `?- ancestor(tom, X).` → `{:query (ancestor tom X)}`
+      - Negation: `not(parent(X,Y))` in body position → `{:neg (parent X Y)}`
+- [ ] Tests in `lib/datalog/tests/parse.sx`
+
+### Phase 2 — unification + substitution
+- [ ] Share or port unification from `lib/prolog/` — term walk, occurs check off by default
+- [ ] `dl-unify` `t1` `t2` `subst` → extended subst or nil (no function symbols means simpler)
+- [ ] `dl-ground?` `term` → bool — all variables bound in substitution
+- [ ] Tests: atom/atom, var/atom, var/var, list args
+
+### Phase 3 — extensional DB + naive evaluation
+- [ ] EDB: `{:relation-name → set-of-ground-tuples}` using SX sets (Phase 18 of primitives)
+- [ ] `dl-add-fact!` `db` `relation` `args` → add ground tuple
+- [ ] `dl-add-rule!` `db` `head` `body` → add rule clause
+- [ ] Naive evaluation: iterate rules until fixpoint
+      For each rule, for each combination of body tuples that unify, derive head tuple.
+      Repeat until no new tuples added.
+- [ ] `dl-query` `db` `goal` → list of substitutions satisfying goal against derived DB
+- [ ] Tests: transitive closure (ancestor), sibling, same-generation — classic Datalog programs
+
+### Phase 4 — semi-naive evaluation (performance)
+- [ ] Delta sets: track newly derived tuples per iteration
+- [ ] Semi-naive rule: only join against delta tuples from last iteration, not full relation
+- [ ] Significant speedup for recursive rules — avoids re-deriving known tuples
+- [ ] `dl-stratify` `db` → dependency graph + SCC analysis → stratum ordering
+- [ ] Tests: verify semi-naive produces same results as naive; benchmark on large ancestor chain
+
+### Phase 5 — stratified negation
+- [ ] Dependency graph analysis: which relations depend on which (positively or negatively)
+- [ ] Stratification check: error if negation is in a cycle (non-stratifiable program)
+- [ ] Evaluation: process strata in order — lower stratum fully computed before using its
+      complement in a higher stratum
+- [ ] `not(P)` in rule body: at evaluation time, check P is NOT in the derived EDB
+- [ ] Tests: non-member (`not(member(X,L))`), colored-graph (`not(same-color(X,Y))`),
+      stratification error detection
+
+### Phase 6 — aggregation (Datalog+)
+- [ ] `count(X, Goal)` → number of distinct X satisfying Goal
+- [ ] `sum(X, Goal)` → sum of X values satisfying Goal
+- [ ] `min(X, Goal)` / `max(X, Goal)` → min/max of X satisfying Goal
+- [ ] `group-by` semantics: `count(X, sibling(bob, X))` → count of bob's siblings
+- [ ] Aggregation breaks stratification — evaluate in a separate post-fixpoint pass
+- [ ] Tests: social network statistics, grade aggregation, inventory sums
+
+### Phase 7 — SX embedding API
+- [ ] `(dl-program facts rules)` → database from SX data directly (no parsing required)
+      ```
+      (dl-program
+        '((parent tom bob) (parent tom liz) (parent bob ann))
+        '((ancestor X Z :- (parent X Y) (ancestor Y Z))
+          (ancestor X Y :- (parent X Y))))
+      ```
+- [ ] `(dl-query db '(ancestor tom ?X))` → `((ann) (bob) (liz) (pat))`
+- [ ] `(dl-assert! db '(parent ann pat))` → incremental fact addition + re-derive
+- [ ] `(dl-retract! db '(parent tom bob))` → fact removal + re-derive from scratch
+- [ ] Integration demo: federation graph query — `(ancestor actor1 actor2)` over
+      rose-ash ActivityPub follow relationships
+
+### Phase 8 — Datalog as a query language for rose-ash
+- [ ] Schema: map SQLAlchemy model relationships to Datalog EDB facts
+      (e.g. `(follows user1 user2)`, `(authored user post)`, `(tagged post tag)`)
+- [ ] Loader: `dl-load-from-db!` — query PostgreSQL, populate Datalog EDB
+- [ ] Query examples:
+      - `?- ancestor(me, X), authored(X, Post), tagged(Post, cooking).`
+        → posts about cooking by people I follow (transitively)
+      - `?- popular(Post) :- tagged(Post, T), count(L, (liked(L, Post))) >= 10.`
+        → posts with 10+ likes
+- [ ] Expose as a rose-ash service endpoint: `POST /internal/datalog` with program + query
+
+## Blockers
+
+_(none yet)_
+
+## Progress log
+
+_Newest first._
+
+_(awaiting phase 1)_

plans/designs/f-breakpoint.md

@@ -0,0 +1,80 @@
+# F-Breakpoint — `breakpoint` command (+2)
+
+**Suite:** `hs-upstream-breakpoint`  
+**Target:** Both tests are `SKIP (untranslated)`.
+
+## 1. The 2 tests
+
+- `parses as a top-level command`
+- `parses inside an event handler`
+
+Both are untranslated — no test body exists. The test names say "parses" — these are parser tests, not runtime tests.
+
+## 2. What upstream checks
+
+From `test/core/breakpoint.js`:
+
+```js
+it('parses as a top-level command', () => {
+  expect(() => _hyperscript.evaluate("breakpoint")).not.toThrow();
+});
+it('parses inside an event handler', () => {
+  const el = document.createElement('div');
+  el.setAttribute('_', 'on click breakpoint');
+  expect(() => _hyperscript.processNode(el)).not.toThrow();
+});
+```
+
+Both tests verify that `breakpoint` is accepted by the parser without throwing. Neither test checks that the debugger actually fires. `breakpoint` is a no-op command in production builds — it calls `debugger` in JS, which is a no-op when devtools are closed.
+
+## 3. What's needed
+
+### Parser (`lib/hyperscript/parser.sx`)
+
+Add `breakpoint` to the command dispatch — it should parse as a zero-argument command. The parser's command `cond` (wherever `add`, `remove`, `hide` etc. are dispatched) needs a branch:
+
+```
+((= val "breakpoint") (hs-parse-breakpoint))
+```
+
+`hs-parse-breakpoint` just returns a `{:cmd "breakpoint"}` AST node (or however commands are represented). It consumes no additional tokens.
+
+### Compiler (`lib/hyperscript/compiler.sx`)
+
+Add a compiler branch for `breakpoint` AST node. Emits a no-op or a `debugger` statement equivalent. Since we're in SX (not JS), a no-op `(do nil)` is correct.
+
+### Generator (`tests/playwright/generate-sx-tests.py`)
+
+The 2 tests are simple — hand-write them:
+
+```lisp
+(deftest "parses as a top-level command"
+  (let ((result (guard (e (true false))
+                  (hs-compile "breakpoint")
+                  true)))
+    (assert result)))
+
+(deftest "parses inside an event handler"
+  (hs-cleanup!)
+  (let ((el (dom-create-element "div")))
+    (dom-set-attr el "_" "on click breakpoint")
+    (let ((result (guard (e (true false))
+                    (hs-activate! el)
+                    true)))
+      (assert result))))
+```
+
+## 4. Implementation checklist
+
+1. `sx_find_all` in `lib/hyperscript/parser.sx` for the command dispatch `cond`.
+2. Add `breakpoint` branch → `hs-parse-breakpoint` function returning minimal command node.
+3. `sx_find_all` in `lib/hyperscript/compiler.sx` for command compilation dispatch.
+4. Add `breakpoint` branch → emit no-op.
+5. Replace 2 `SKIP` bodies in `spec/tests/test-hyperscript-behavioral.sx` with translated tests above.
+6. Run `hs_test_run suite="hs-upstream-breakpoint"` — expect 2/2.
+7. Run smoke 0–195 — no regressions.
+8. Commit: `HS: breakpoint command — parser + no-op compiler (+2)`
+
+## 5. Risk
+
+Very low. Zero-argument no-op command. The only risk is mis-locating the command dispatch branch in the parser.

plans/designs/f1-null-safety.md

@@ -0,0 +1,68 @@
+# F1 — Null Safety Reporting (+7)
+
+**Suite:** `hs-upstream-core/runtimeErrors`  
+**Target:** 7 currently-failing tests (decrement, default, increment, put, remove, settle, transition commands)
+
+## 1. Failing tests
+
+The suite has 18 tests total; 11 already pass. The 7 failures all share the pattern:
+
+```
+Expected '#doesntExist' is null, got 
+```
+
+The `eval-hs-error` helper already exists (landed in null-safety piece 1). It compiles and runs a HS snippet and returns the error string. The problem is that the listed commands don't guard against null targets before operating, so they produce no error (or a cryptic one) instead of `"'#doesntExist' is null"`.
+
+| Test | Command | Null target expression |
+|------|---------|----------------------|
+| decrement | `decrement #doesntExist's innerHTML` | `#doesntExist` |
+| default | `default #doesntExist's innerHTML to 'foo'` | `#doesntExist` |
+| increment | `increment #doesntExist's innerHTML` | `#doesntExist` |
+| put | `put 'foo' into/before/after/at start of/at end of #doesntExist` | `#doesntExist` |
+| remove | `remove .foo/.@foo/#doesntExist from #doesntExist` | `#doesntExist` |
+| settle | `settle #doesntExist` | `#doesntExist` |
+| transition | `transition #doesntExist's *visibility to 0` | `#doesntExist` |
+
+Note: add, hide, measure, send, sets, show, toggle, trigger already pass — they already guard.
+
+## 2. Required error format
+
+```
+'#doesntExist' is null
+```
+
+The apostrophe-quoted selector string followed by ` is null`. The selector text is the original source text of the element expression (e.g. `#doesntExist`, not a stringified DOM node).
+
+This is the same format already used by passing commands. The null-safety piece 1 commit added `eval-hs-error` and `hs-null-error` helper — just need to call it at the right point in each missing command.
+
+## 3. Where to add guards
+
+All in `lib/hyperscript/runtime.sx`. Pattern for each command:
+
+```
+(when (nil? target)
+  (hs-null-error target-source-text))
+```
+
+Where `hs-null-error` (or equivalent) raises with the formatted message.
+
+### Per-command location
+
+- **decrement / increment** — after resolving the target element, before reading/writing innerHTML
+- **default** — after resolving target element, before reading current value
+- **put** — after resolving destination element (covers all put variants: into, before, after, at start, at end)
+- **remove** — after resolving the `from` target element
+- **settle** — after resolving target element, before starting transition poll
+- **transition** — after resolving target element, before reading/setting style
+
+## 4. Implementation checklist
+
+1. Find each failing command's runtime function in `lib/hyperscript/runtime.sx` using `sx_find_all`.
+2. For each: `sx_read_subtree` on the function body, locate where target is resolved, insert null guard calling `hs-null-error` (or the equivalent raise form already used by passing commands).
+3. After all 7: run `hs_test_run suite="hs-upstream-core/runtimeErrors"` — expect 18/18.
+4. Run smoke range 0–195 — expect no regressions.
+5. Commit: `HS: null-safety guards on decrement/default/increment/put/remove/settle/transition (+7)`
+
+## 5. Risk
+
+Low. The pattern is established by the 11 already-passing tests. The only risk is finding the correct point in each command where the element is resolved and before it's first used.