plans: tick conformance.sh + Phase 3 complete

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

lib/haskell/conformance.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# lib/haskell/conformance.sh — run the 5 classic-program test suites.
+# Writes lib/haskell/scoreboard.json and lib/haskell/scoreboard.md.
+#
+# Usage:
+#   bash lib/haskell/conformance.sh           # run + write scoreboards
+#   bash lib/haskell/conformance.sh --check   # run only, exit 1 on failure
+
+set -euo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
+if [ ! -x "$SX_SERVER" ]; then
+  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
+  if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
+    SX_SERVER="$MAIN_ROOT/$SX_SERVER"
+  else
+    echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
+    exit 1
+  fi
+fi
+
+PROGRAMS=(fib sieve quicksort nqueens calculator)
+PASS_COUNTS=()
+FAIL_COUNTS=()
+
+run_suite() {
+  local prog="$1"
+  local FILE="lib/haskell/tests/program-${prog}.sx"
+  local TMPFILE
+  TMPFILE=$(mktemp)
+  cat > "$TMPFILE" <<EPOCHS
+(epoch 1)
+(load "lib/haskell/tokenizer.sx")
+(load "lib/haskell/layout.sx")
+(load "lib/haskell/parser.sx")
+(load "lib/haskell/desugar.sx")
+(load "lib/haskell/runtime.sx")
+(load "lib/haskell/match.sx")
+(load "lib/haskell/eval.sx")
+(load "lib/haskell/testlib.sx")
+(epoch 2)
+(load "$FILE")
+(epoch 3)
+(eval "(list hk-test-pass hk-test-fail)")
+EPOCHS
+  local OUTPUT
+  OUTPUT=$(timeout 120 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
+  rm -f "$TMPFILE"
+
+  local LINE
+  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/\)$//' || true)
+  fi
+  if [ -z "$LINE" ]; then
+    echo "0 1"
+  else
+    local P F
+    P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/' || echo "0")
+    F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/' || echo "1")
+    echo "$P $F"
+  fi
+}
+
+for prog in "${PROGRAMS[@]}"; do
+  RESULT=$(run_suite "$prog")
+  P=$(echo "$RESULT" | cut -d' ' -f1)
+  F=$(echo "$RESULT" | cut -d' ' -f2)
+  PASS_COUNTS+=("$P")
+  FAIL_COUNTS+=("$F")
+  T=$((P + F))
+  if [ "$F" -eq 0 ]; then
+    printf '✓ %-14s  %d/%d\n' "${prog}.hs" "$P" "$T"
+  else
+    printf '✗ %-14s  %d/%d\n' "${prog}.hs" "$P" "$T"
+  fi
+done
+
+TOTAL_PASS=0
+TOTAL_FAIL=0
+PROG_PASS=0
+for i in "${!PROGRAMS[@]}"; do
+  TOTAL_PASS=$((TOTAL_PASS + PASS_COUNTS[i]))
+  TOTAL_FAIL=$((TOTAL_FAIL + FAIL_COUNTS[i]))
+  [ "${FAIL_COUNTS[$i]}" -eq 0 ] && PROG_PASS=$((PROG_PASS + 1))
+done
+PROG_TOTAL=${#PROGRAMS[@]}
+
+echo ""
+echo "Classic programs: ${TOTAL_PASS}/$((TOTAL_PASS + TOTAL_FAIL)) tests  |  ${PROG_PASS}/${PROG_TOTAL} programs passing"
+
+if [[ "${1:-}" == "--check" ]]; then
+  [ $TOTAL_FAIL -eq 0 ]
+  exit $?
+fi
+
+DATE=$(date '+%Y-%m-%d')
+
+# scoreboard.json
+{
+  printf '{\n'
+  printf '  "date": "%s",\n' "$DATE"
+  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
+  printf '  "programs": {\n'
+  last=$((${#PROGRAMS[@]} - 1))
+  for i in "${!PROGRAMS[@]}"; do
+    prog="${PROGRAMS[$i]}"
+    if [ $i -lt $last ]; then
+      printf '    "%s": {"pass": %d, "fail": %d},\n' "$prog" "${PASS_COUNTS[$i]}" "${FAIL_COUNTS[$i]}"
+    else
+      printf '    "%s": {"pass": %d, "fail": %d}\n'  "$prog" "${PASS_COUNTS[$i]}" "${FAIL_COUNTS[$i]}"
+    fi
+  done
+  printf '  }\n'
+  printf '}\n'
+} > lib/haskell/scoreboard.json
+
+# scoreboard.md
+{
+  printf '# Haskell-on-SX Scoreboard\n\n'
+  printf 'Updated %s · Phase 3 (laziness + classic programs)\n\n' "$DATE"
+  printf '| Program | Tests | Status |\n'
+  printf '|---------|-------|--------|\n'
+  for i in "${!PROGRAMS[@]}"; do
+    prog="${PROGRAMS[$i]}"
+    P=${PASS_COUNTS[$i]}
+    F=${FAIL_COUNTS[$i]}
+    T=$((P + F))
+    [ "$F" -eq 0 ] && STATUS="✓" || STATUS="✗"
+    printf '| %s | %d/%d | %s |\n' "${prog}.hs" "$P" "$T" "$STATUS"
+  done
+  printf '| **Total** | **%d/%d** | **%d/%d programs** |\n' \
+    "$TOTAL_PASS" "$((TOTAL_PASS + TOTAL_FAIL))" "$PROG_PASS" "$PROG_TOTAL"
+} > lib/haskell/scoreboard.md
+
+echo "Wrote lib/haskell/scoreboard.json and lib/haskell/scoreboard.md"
+[ $TOTAL_FAIL -eq 0 ]

lib/haskell/desugar.sx

@@ -0,0 +1,249 @@
+;; Desugar the Haskell surface AST into a smaller core AST.
+;;
+;; Eliminates the three surface-only shapes produced by the parser:
+;;   :where BODY DECLS     →  :let DECLS BODY
+;;   :guarded GUARDS       →  :if C1 E1 (:if C2 E2 … (:app error …))
+;;   :list-comp EXPR QUALS →  concatMap-based expression (§3.11)
+;;
+;; Everything else (:app, :op, :lambda, :let, :case, :do, :tuple,
+;; :list, :range, :if, :neg, :sect-left / :sect-right, plus all
+;; leaf forms and pattern / type nodes) is passed through after
+;; recursing into children.
+
+(define
+  hk-guards-to-if
+  (fn
+    (guards)
+    (cond
+      ((empty? guards)
+        (list
+          :app
+          (list :var "error")
+          (list :string "Non-exhaustive guards")))
+      (:else
+        (let
+          ((g (first guards)))
+          (list
+            :if
+            (hk-desugar (nth g 1))
+            (hk-desugar (nth g 2))
+            (hk-guards-to-if (rest guards))))))))
+
+;; do-notation desugaring (Haskell 98 §3.14):
+;;   do { e }              =  e
+;;   do { e ; ss }         =  e >> do { ss }
+;;   do { p <- e ; ss }    =  e >>= \p -> do { ss }
+;;   do { let decls ; ss } =  let decls in do { ss }
+(define
+  hk-desugar-do
+  (fn
+    (stmts)
+    (cond
+      ((empty? stmts) (raise "empty do block"))
+      ((empty? (rest stmts))
+        (let ((s (first stmts)))
+          (cond
+            ((= (first s) "do-expr") (hk-desugar (nth s 1)))
+            (:else
+              (raise "do block must end with an expression")))))
+      (:else
+        (let
+          ((s (first stmts)) (rest-stmts (rest stmts)))
+          (let
+            ((rest-do (hk-desugar-do rest-stmts)))
+            (cond
+              ((= (first s) "do-expr")
+                (list
+                  :app
+                  (list
+                    :app
+                    (list :var ">>")
+                    (hk-desugar (nth s 1)))
+                  rest-do))
+              ((= (first s) "do-bind")
+                (list
+                  :app
+                  (list
+                    :app
+                    (list :var ">>=")
+                    (hk-desugar (nth s 2)))
+                  (list :lambda (list (nth s 1)) rest-do)))
+              ((= (first s) "do-let")
+                (list
+                  :let
+                  (map hk-desugar (nth s 1))
+                  rest-do))
+              (:else (raise "unknown do-stmt tag")))))))))
+
+;; List-comprehension desugaring (Haskell 98 §3.11):
+;;   [e |             ]  =  [e]
+;;   [e | b,     Q    ]  =  if b then [e | Q] else []
+;;   [e | p <- l, Q    ]  =  concatMap (\p -> [e | Q]) l
+;;   [e | let ds, Q    ]  =  let ds in [e | Q]
+(define
+  hk-lc-desugar
+  (fn
+    (e quals)
+    (cond
+      ((empty? quals) (list :list (list e)))
+      (:else
+        (let
+          ((q (first quals)))
+          (let
+            ((qtag (first q)))
+            (cond
+              ((= qtag "q-guard")
+                (list
+                  :if
+                  (hk-desugar (nth q 1))
+                  (hk-lc-desugar e (rest quals))
+                  (list :list (list))))
+              ((= qtag "q-gen")
+                (list
+                  :app
+                  (list
+                    :app
+                    (list :var "concatMap")
+                    (list
+                      :lambda
+                      (list (nth q 1))
+                      (hk-lc-desugar e (rest quals))))
+                  (hk-desugar (nth q 2))))
+              ((= qtag "q-let")
+                (list
+                  :let
+                  (map hk-desugar (nth q 1))
+                  (hk-lc-desugar e (rest quals))))
+              (:else
+                (raise
+                  (str
+                    "hk-lc-desugar: unknown qualifier tag "
+                    qtag))))))))))
+
+(define
+  hk-desugar
+  (fn
+    (node)
+    (cond
+      ((not (list? node)) node)
+      ((empty? node) node)
+      (:else
+        (let
+          ((tag (first node)))
+          (cond
+            ;; Transformations
+            ((= tag "where")
+              (list
+                :let
+                (map hk-desugar (nth node 2))
+                (hk-desugar (nth node 1))))
+            ((= tag "guarded") (hk-guards-to-if (nth node 1)))
+            ((= tag "list-comp")
+              (hk-lc-desugar
+                (hk-desugar (nth node 1))
+                (nth node 2)))
+
+            ;; Expression nodes
+            ((= tag "app")
+              (list
+                :app
+                (hk-desugar (nth node 1))
+                (hk-desugar (nth node 2))))
+            ((= tag "op")
+              (list
+                :op
+                (nth node 1)
+                (hk-desugar (nth node 2))
+                (hk-desugar (nth node 3))))
+            ((= tag "neg") (list :neg (hk-desugar (nth node 1))))
+            ((= tag "if")
+              (list
+                :if
+                (hk-desugar (nth node 1))
+                (hk-desugar (nth node 2))
+                (hk-desugar (nth node 3))))
+            ((= tag "tuple")
+              (list :tuple (map hk-desugar (nth node 1))))
+            ((= tag "list")
+              (list :list (map hk-desugar (nth node 1))))
+            ((= tag "range")
+              (list
+                :range
+                (hk-desugar (nth node 1))
+                (hk-desugar (nth node 2))))
+            ((= tag "range-step")
+              (list
+                :range-step
+                (hk-desugar (nth node 1))
+                (hk-desugar (nth node 2))
+                (hk-desugar (nth node 3))))
+            ((= tag "lambda")
+              (list
+                :lambda
+                (nth node 1)
+                (hk-desugar (nth node 2))))
+            ((= tag "let")
+              (list
+                :let
+                (map hk-desugar (nth node 1))
+                (hk-desugar (nth node 2))))
+            ((= tag "case")
+              (list
+                :case
+                (hk-desugar (nth node 1))
+                (map hk-desugar (nth node 2))))
+            ((= tag "alt")
+              (list :alt (nth node 1) (hk-desugar (nth node 2))))
+            ((= tag "do") (hk-desugar-do (nth node 1)))
+            ((= tag "sect-left")
+              (list
+                :sect-left
+                (nth node 1)
+                (hk-desugar (nth node 2))))
+            ((= tag "sect-right")
+              (list
+                :sect-right
+                (nth node 1)
+                (hk-desugar (nth node 2))))
+
+            ;; Top-level
+            ((= tag "program")
+              (list :program (map hk-desugar (nth node 1))))
+            ((= tag "module")
+              (list
+                :module
+                (nth node 1)
+                (nth node 2)
+                (nth node 3)
+                (map hk-desugar (nth node 4))))
+
+            ;; Decls carrying a body
+            ((= tag "fun-clause")
+              (list
+                :fun-clause
+                (nth node 1)
+                (nth node 2)
+                (hk-desugar (nth node 3))))
+            ((= tag "pat-bind")
+              (list
+                :pat-bind
+                (nth node 1)
+                (hk-desugar (nth node 2))))
+            ((= tag "bind")
+              (list
+                :bind
+                (nth node 1)
+                (hk-desugar (nth node 2))))
+
+            ;; Everything else: leaf literals, vars, cons, patterns,
+            ;; types, imports, type-sigs, data / newtype / fixity, …
+            (:else node)))))))
+
+;; Convenience — tokenize + layout + parse + desugar.
+(define
+  hk-core
+  (fn (src) (hk-desugar (hk-parse-top src))))
+
+(define
+  hk-core-expr
+  (fn (src) (hk-desugar (hk-parse src))))

lib/haskell/eval.sx

@@ -0,0 +1,792 @@
+;; Haskell strict evaluator (Phase 2).
+;;
+;; Consumes the post-desugar core AST and produces SX values. Strict
+;; throughout — laziness and thunks are Phase 3.
+;;
+;; Value representation:
+;;   numbers / strings / chars      → raw SX values
+;;   constructor values             → tagged lists (con-name first)
+;;   functions: closure / multifun  → {:type "fn" :kind … …}
+;;   constructor partials           → {:type "con-partial" …}
+;;   built-ins                      → {:type "builtin" …}
+;;
+;; Multi-clause top-level definitions are bundled into a single
+;; multifun keyed by name; arguments are gathered through currying
+;; until arity is reached, then each clause's pattern list is matched
+;; in order. Recursive let bindings work because the binding env is
+;; built mutably so closures captured during evaluation see the
+;; eventual full env.
+
+(define
+  hk-dict-copy
+  (fn
+    (d)
+    (let ((nd (dict)))
+      (for-each
+        (fn (k) (dict-set! nd k (get d k)))
+        (keys d))
+      nd)))
+
+;; ── Thunks (Phase 3 — laziness) ─────────────────────────────
+;; A thunk wraps an unevaluated AST plus the env in which it was
+;; created. The first call to `hk-force` evaluates the body, replaces
+;; the body with the cached value, and flips `forced`. Subsequent
+;; forces return the cached value directly.
+(define
+  hk-mk-thunk
+  (fn
+    (body env)
+    {:type "thunk" :body body :env env :forced false :value nil}))
+
+(define
+  hk-is-thunk?
+  (fn (v) (and (dict? v) (= (get v "type") "thunk"))))
+
+(define
+  hk-force
+  (fn
+    (v)
+    (cond
+      ((hk-is-thunk? v)
+        (cond
+          ((get v "forced") (get v "value"))
+          (:else
+            (let
+              ((res (hk-force (hk-eval (get v "body") (get v "env")))))
+              (dict-set! v "forced" true)
+              (dict-set! v "value" res)
+              res))))
+      (:else v))))
+
+;; Recursive force — used at the test/output boundary so test
+;; expectations can compare against fully-evaluated structures.
+(define
+  hk-deep-force
+  (fn
+    (v)
+    (let ((fv (hk-force v)))
+      (cond
+        ((not (list? fv)) fv)
+        ((empty? fv) fv)
+        (:else (map hk-deep-force fv))))))
+
+;; ── Function value constructors ──────────────────────────────
+(define
+  hk-mk-closure
+  (fn
+    (params body env)
+    {:type "fn" :kind "closure" :params params :body body :env env}))
+
+(define
+  hk-mk-multifun
+  (fn
+    (arity clauses env)
+    {:type "fn" :kind "multi" :arity arity :clauses clauses :env env :collected (list)}))
+
+(define
+  hk-mk-builtin
+  (fn
+    (name fn arity)
+    {:type "builtin" :name name :fn fn :arity arity :lazy false :collected (list)}))
+
+;; A lazy built-in receives its collected args as raw thunks (or
+;; values, if those happened to be eager) — the implementation is
+;; responsible for forcing exactly what it needs. Used for `seq`
+;; and `deepseq`, which are non-strict in their second argument.
+(define
+  hk-mk-lazy-builtin
+  (fn
+    (name fn arity)
+    {:type "builtin" :name name :fn fn :arity arity :lazy true :collected (list)}))
+
+;; ── Apply a function value to one argument ──────────────────
+(define
+  hk-apply
+  (fn
+    (f arg)
+    (let ((f (hk-force f)))
+      (cond
+        ((not (dict? f))
+          (raise (str "apply: not a function value: " f)))
+        ((= (get f "type") "fn")
+          (cond
+            ((= (get f "kind") "closure") (hk-apply-closure f arg))
+            ((= (get f "kind") "multi") (hk-apply-multi f arg))
+            (:else (raise "apply: unknown fn kind"))))
+        ((= (get f "type") "con-partial") (hk-apply-con-partial f arg))
+        ((= (get f "type") "builtin") (hk-apply-builtin f arg))
+        (:else (raise "apply: not a function dict"))))))
+
+(define
+  hk-apply-closure
+  (fn
+    (cl arg)
+    (let
+      ((params (get cl "params"))
+        (body (get cl "body"))
+        (env (get cl "env")))
+      (cond
+        ((empty? params) (raise "apply-closure: no params"))
+        (:else
+          (let
+            ((p1 (first params)) (rest-p (rest params)))
+            (let
+              ((env-after (hk-match p1 arg env)))
+              (cond
+                ((nil? env-after)
+                  (raise "pattern match failure in lambda"))
+                ((empty? rest-p) (hk-eval body env-after))
+                (:else
+                  (hk-mk-closure rest-p body env-after))))))))))
+
+(define
+  hk-apply-multi
+  (fn
+    (mf arg)
+    (let
+      ((arity (get mf "arity"))
+        (clauses (get mf "clauses"))
+        (env (get mf "env"))
+        (collected (append (get mf "collected") (list arg))))
+      (cond
+        ((< (len collected) arity)
+          (assoc mf "collected" collected))
+        (:else (hk-dispatch-multi clauses collected env))))))
+
+(define
+  hk-dispatch-multi
+  (fn
+    (clauses args env)
+    (cond
+      ((empty? clauses)
+        (raise "non-exhaustive patterns in function definition"))
+      (:else
+        (let
+          ((c (first clauses)))
+          (let
+            ((pats (first c)) (body (first (rest c))))
+            (let
+              ((env-after (hk-match-args pats args env)))
+              (cond
+                ((nil? env-after)
+                  (hk-dispatch-multi (rest clauses) args env))
+                (:else (hk-eval body env-after))))))))))
+
+(define
+  hk-match-args
+  (fn
+    (pats args env)
+    (cond
+      ((empty? pats) env)
+      (:else
+        (let
+          ((res (hk-match (first pats) (first args) env)))
+          (cond
+            ((nil? res) nil)
+            (:else
+              (hk-match-args (rest pats) (rest args) res))))))))
+
+(define
+  hk-apply-con-partial
+  (fn
+    (cp arg)
+    (let
+      ((name (get cp "name"))
+        (arity (get cp "arity"))
+        (args (append (get cp "args") (list arg))))
+      (cond
+        ((= (len args) arity) (hk-mk-con name args))
+        (:else (assoc cp "args" args))))))
+
+(define
+  hk-apply-builtin
+  (fn
+    (b arg)
+    (let
+      ((arity (get b "arity"))
+        (collected (append (get b "collected") (list arg))))
+      (cond
+        ((< (len collected) arity)
+          (assoc b "collected" collected))
+        (:else
+          ;; Strict built-ins force every collected arg before
+          ;; calling. Lazy ones (`seq`, `deepseq`) receive the raw
+          ;; thunks so they can choose what to force.
+          (cond
+            ((get b "lazy") (apply (get b "fn") collected))
+            (:else
+              (apply
+                (get b "fn")
+                (map hk-force collected)))))))))
+
+;; ── Bool helpers (Bool values are tagged conses) ────────────
+(define
+  hk-truthy?
+  (fn
+    (v)
+    (and (list? v) (not (empty? v)) (= (first v) "True"))))
+
+(define hk-true (hk-mk-con "True" (list)))
+(define hk-false (hk-mk-con "False" (list)))
+(define hk-of-bool (fn (b) (if b hk-true hk-false)))
+
+;; ── Core eval ───────────────────────────────────────────────
+(define
+  hk-eval
+  (fn
+    (node env)
+    (cond
+      ((not (list? node)) (raise (str "eval: not a list: " node)))
+      ((empty? node) (raise "eval: empty list node"))
+      (:else
+        (let
+          ((tag (first node)))
+          (cond
+            ((= tag "int") (nth node 1))
+            ((= tag "float") (nth node 1))
+            ((= tag "string") (nth node 1))
+            ((= tag "char") (nth node 1))
+            ((= tag "var") (hk-eval-var (nth node 1) env))
+            ((= tag "con") (hk-eval-con-ref (nth node 1)))
+            ((= tag "neg")
+              (- 0 (hk-force (hk-eval (nth node 1) env))))
+            ((= tag "if") (hk-eval-if node env))
+            ((= tag "let") (hk-eval-let (nth node 1) (nth node 2) env))
+            ((= tag "lambda")
+              (hk-mk-closure (nth node 1) (nth node 2) env))
+            ((= tag "app")
+              (hk-apply
+                (hk-eval (nth node 1) env)
+                (hk-mk-thunk (nth node 2) env)))
+            ((= tag "op")
+              (hk-eval-op
+                (nth node 1)
+                (nth node 2)
+                (nth node 3)
+                env))
+            ((= tag "case")
+              (hk-eval-case (nth node 1) (nth node 2) env))
+            ((= tag "tuple")
+              (hk-mk-tuple
+                (map (fn (e) (hk-eval e env)) (nth node 1))))
+            ((= tag "list")
+              (hk-mk-list
+                (map (fn (e) (hk-eval e env)) (nth node 1))))
+            ((= tag "range")
+              (let
+                ((from (hk-force (hk-eval (nth node 1) env)))
+                  (to (hk-force (hk-eval (nth node 2) env))))
+                (hk-build-range from to 1)))
+            ((= tag "range-step")
+              (let
+                ((from (hk-force (hk-eval (nth node 1) env)))
+                  (nxt (hk-force (hk-eval (nth node 2) env)))
+                  (to (hk-force (hk-eval (nth node 3) env))))
+                (hk-build-range from to (- nxt from))))
+            ((= tag "range-from")
+              ;; [from..] = iterate (+ 1) from — uses the Prelude.
+              (hk-eval
+                (list
+                  :app
+                  (list
+                    :app
+                    (list :var "iterate")
+                    (list
+                      :sect-right
+                      "+"
+                      (list :int 1)))
+                  (nth node 1))
+                env))
+            ((= tag "sect-left")
+              (hk-eval-sect-left (nth node 1) (nth node 2) env))
+            ((= tag "sect-right")
+              (hk-eval-sect-right (nth node 1) (nth node 2) env))
+            (:else
+              (raise (str "eval: unknown node tag '" tag "'")))))))))
+
+(define
+  hk-eval-var
+  (fn
+    (name env)
+    (cond
+      ((has-key? env name) (get env name))
+      ((hk-is-con? name) (hk-eval-con-ref name))
+      (:else (raise (str "unbound variable: " name))))))
+
+(define
+  hk-eval-con-ref
+  (fn
+    (name)
+    (let ((arity (hk-con-arity name)))
+      (cond
+        ((nil? arity) (raise (str "unknown constructor: " name)))
+        ((= arity 0) (hk-mk-con name (list)))
+        (:else
+          {:type "con-partial" :name name :arity arity :args (list)})))))
+
+(define
+  hk-eval-if
+  (fn
+    (node env)
+    (let ((cv (hk-force (hk-eval (nth node 1) env))))
+      (cond
+        ((hk-truthy? cv) (hk-eval (nth node 2) env))
+        ((and (list? cv) (= (first cv) "False"))
+          (hk-eval (nth node 3) env))
+        ((= cv true) (hk-eval (nth node 2) env))
+        ((= cv false) (hk-eval (nth node 3) env))
+        (:else (raise "if: condition is not Bool"))))))
+
+(define
+  hk-extend-env-with-match!
+  (fn
+    (env match-env)
+    (for-each
+      (fn (k) (dict-set! env k (get match-env k)))
+      (keys match-env))))
+
+(define
+  hk-eval-let-bind!
+  (fn
+    (b env)
+    (let ((tag (first b)))
+      (cond
+        ((= tag "fun-clause")
+          (let
+            ((name (nth b 1))
+              (pats (nth b 2))
+              (body (nth b 3)))
+            (cond
+              ((empty? pats)
+                (dict-set! env name (hk-eval body env)))
+              (:else
+                (dict-set! env name (hk-mk-closure pats body env))))))
+        ((or (= tag "bind") (= tag "pat-bind"))
+          (let ((pat (nth b 1)) (body (nth b 2)))
+            (let ((val (hk-eval body env)))
+              (let ((res (hk-match pat val env)))
+                (cond
+                  ((nil? res)
+                    (raise "let: pattern bind failure"))
+                  (:else
+                    (hk-extend-env-with-match! env res)))))))
+        (:else nil)))))
+
+(define
+  hk-eval-let
+  (fn
+    (binds body env)
+    ;; Reuse hk-bind-decls! so multi-clause fun bindings in where/let
+    ;; are grouped into multifuns, enabling patterns like:
+    ;;   let { go 0 = [[]]; go k = [...] } in go n
+    (let ((new-env (hk-dict-copy env)))
+      (hk-bind-decls! new-env binds)
+      (hk-eval body new-env))))
+
+(define
+  hk-eval-case
+  (fn
+    (scrut alts env)
+    (let ((sv (hk-force (hk-eval scrut env))))
+      (hk-try-alts alts sv env))))
+
+(define
+  hk-try-alts
+  (fn
+    (alts val env)
+    (cond
+      ((empty? alts) (raise "case: non-exhaustive patterns"))
+      (:else
+        (let
+          ((alt (first alts)))
+          (let
+            ((pat (nth alt 1)) (body (nth alt 2)))
+            (let
+              ((res (hk-match pat val env)))
+              (cond
+                ((nil? res) (hk-try-alts (rest alts) val env))
+                (:else (hk-eval body res))))))))))
+
+(define
+  hk-eval-op
+  (fn
+    (op left right env)
+    (cond
+      ;; Cons is non-strict in both args: build a cons cell whose
+      ;; head and tail are deferred. This is what makes `repeat x =
+      ;; x : repeat x` and `fibs = 0 : 1 : zipWith (+) fibs (tail
+      ;; fibs)` terminate.
+      ((= op ":")
+        (hk-mk-cons
+          (hk-mk-thunk left env)
+          (hk-mk-thunk right env)))
+      (:else
+        (let
+          ((lv (hk-force (hk-eval left env)))
+            (rv (hk-force (hk-eval right env))))
+          (hk-binop op lv rv))))))
+
+(define
+  hk-list-append
+  (fn
+    (a b)
+    (cond
+      ((and (list? a) (= (first a) "[]")) b)
+      ((and (list? a) (= (first a) ":"))
+        (hk-mk-cons (nth a 1) (hk-list-append (nth a 2) b)))
+      (:else (raise "++: not a list")))))
+
+;; Eager finite-range spine — handles [from..to] and [from,next..to].
+;; Step direction is governed by the sign of `step`; when step > 0 we
+;; stop at to; when step < 0 we stop at to going down.
+(define
+  hk-build-range
+  (fn
+    (from to step)
+    (cond
+      ((and (> step 0) (> from to)) (hk-mk-nil))
+      ((and (< step 0) (< from to)) (hk-mk-nil))
+      ((= step 0) (hk-mk-nil))
+      (:else
+        (hk-mk-cons from (hk-build-range (+ from step) to step))))))
+
+(define
+  hk-binop
+  (fn
+    (op lv rv)
+    (cond
+      ((= op "+") (+ lv rv))
+      ((= op "-") (- lv rv))
+      ((= op "*") (* lv rv))
+      ((= op "/") (/ lv rv))
+      ((= op "==") (hk-of-bool (= lv rv)))
+      ((= op "/=") (hk-of-bool (not (= lv rv))))
+      ((= op "<") (hk-of-bool (< lv rv)))
+      ((= op "<=") (hk-of-bool (<= lv rv)))
+      ((= op ">") (hk-of-bool (> lv rv)))
+      ((= op ">=") (hk-of-bool (>= lv rv)))
+      ((= op "&&") (hk-of-bool (and (hk-truthy? lv) (hk-truthy? rv))))
+      ((= op "||") (hk-of-bool (or (hk-truthy? lv) (hk-truthy? rv))))
+      ((= op ":") (hk-mk-cons lv rv))
+      ((= op "++") (hk-list-append lv rv))
+      ((= op "mod") (mod lv rv))
+      ((= op "div") (floor (/ lv rv)))
+      ((= op "rem") (mod lv rv))
+      ((= op "quot") (truncate (/ lv rv)))
+      (:else (raise (str "unknown operator: " op))))))
+
+(define
+  hk-eval-sect-left
+  (fn
+    (op e env)
+    ;; (e op) = \x -> e op x — bind e once, defer the operator call.
+    (let ((ev (hk-eval e env)))
+      (let ((cenv (hk-dict-copy env)))
+        (dict-set! cenv "__hk-sect-l" ev)
+        (hk-mk-closure
+          (list (list :p-var "__hk-sect-x"))
+          (list
+            :op
+            op
+            (list :var "__hk-sect-l")
+            (list :var "__hk-sect-x"))
+          cenv)))))
+
+(define
+  hk-eval-sect-right
+  (fn
+    (op e env)
+    (let ((ev (hk-eval e env)))
+      (let ((cenv (hk-dict-copy env)))
+        (dict-set! cenv "__hk-sect-r" ev)
+        (hk-mk-closure
+          (list (list :p-var "__hk-sect-x"))
+          (list
+            :op
+            op
+            (list :var "__hk-sect-x")
+            (list :var "__hk-sect-r"))
+          cenv)))))
+
+;; ── Top-level program evaluation ────────────────────────────
+;; Operator-as-value built-ins — let `(+)`, `(*)`, etc. work as
+;; first-class functions for `zipWith (+)` and friends. Strict in
+;; both args (built-ins are forced via hk-apply-builtin).
+(define
+  hk-make-binop-builtin
+  (fn
+    (name op-name)
+    (hk-mk-builtin
+      name
+      (fn (a b) (hk-binop op-name a b))
+      2)))
+
+;; Inline Prelude source — loaded into the initial env so simple
+;; programs can use `head`, `take`, `repeat`, etc. without each
+;; user file redefining them. The Prelude itself uses lazy `:` for
+;; the recursive list-building functions.
+(define
+  hk-prelude-src
+  "head (x:_) = x
+tail (_:xs) = xs
+fst (a, _) = a
+snd (_, b) = b
+take 0 _ = []
+take _ [] = []
+take n (x:xs) = x : take (n - 1) xs
+drop 0 xs = xs
+drop _ [] = []
+drop n (_:xs) = drop (n - 1) xs
+repeat x = x : repeat x
+iterate f x = x : iterate f (f x)
+length [] = 0
+length (_:xs) = 1 + length xs
+map _ [] = []
+map f (x:xs) = f x : map f xs
+filter _ [] = []
+filter p (x:xs) = if p x then x : filter p xs else filter p xs
+zipWith _ [] _ = []
+zipWith _ _ [] = []
+zipWith f (x:xs) (y:ys) = f x y : zipWith f xs ys
+fibs = 0 : 1 : zipWith plus fibs (tail fibs)
+plus a b = a + b
+concat [] = []
+concat (xs:xss) = xs ++ concat xss
+concatMap f [] = []
+concatMap f (x:xs) = f x ++ concatMap f xs
+abs x = if x < 0 then 0 - x else x
+negate x = 0 - x
+")
+
+(define
+  hk-load-into!
+  (fn
+    (env src)
+    (let ((ast (hk-core src)))
+      (hk-register-program! ast)
+      (let
+        ((decls
+            (cond
+              ((= (first ast) "program") (nth ast 1))
+              ((= (first ast) "module") (nth ast 4))
+              (:else (list)))))
+        (hk-bind-decls! env decls)))))
+
+(define
+  hk-init-env
+  (fn
+    ()
+    (let ((env (dict)))
+      (dict-set! env "otherwise" hk-true)
+      (dict-set!
+        env
+        "error"
+        (hk-mk-builtin
+          "error"
+          (fn (msg) (raise (str "*** Exception: " msg)))
+          1))
+      (dict-set!
+        env
+        "not"
+        (hk-mk-builtin
+          "not"
+          (fn (b) (hk-of-bool (not (hk-truthy? b))))
+          1))
+      (dict-set!
+        env
+        "id"
+        (hk-mk-builtin "id" (fn (x) x) 1))
+      ;; `seq a b` — strict in `a`, lazy in `b`. Forces `a` to WHNF
+      ;; and returns `b` unchanged (still a thunk if it was one).
+      (dict-set!
+        env
+        "seq"
+        (hk-mk-lazy-builtin
+          "seq"
+          (fn (a b) (do (hk-force a) b))
+          2))
+      ;; `deepseq a b` — like seq but forces `a` to normal form.
+      (dict-set!
+        env
+        "deepseq"
+        (hk-mk-lazy-builtin
+          "deepseq"
+          (fn (a b) (do (hk-deep-force a) b))
+          2))
+      ;; ── Stub IO monad ─────────────────────────────────────
+      ;; IO actions are tagged values `("IO" payload)`; `>>=` and
+      ;; `>>` chain them. Lazy in the action arguments so do-blocks
+      ;; can be deeply structured without forcing the whole chain
+      ;; up front.
+      (dict-set!
+        env
+        "return"
+        (hk-mk-lazy-builtin
+          "return"
+          (fn (x) (list "IO" x))
+          1))
+      (dict-set!
+        env
+        ">>="
+        (hk-mk-lazy-builtin
+          ">>="
+          (fn (m f)
+            (let ((io-val (hk-force m)))
+              (cond
+                ((and
+                    (list? io-val)
+                    (= (first io-val) "IO"))
+                  (hk-apply (hk-force f) (nth io-val 1)))
+                (:else
+                  (raise "(>>=): left side is not an IO action")))))
+          2))
+      (dict-set!
+        env
+        ">>"
+        (hk-mk-lazy-builtin
+          ">>"
+          (fn (m n)
+            (let ((io-val (hk-force m)))
+              (cond
+                ((and
+                    (list? io-val)
+                    (= (first io-val) "IO"))
+                  (hk-force n))
+                (:else
+                  (raise "(>>): left side is not an IO action")))))
+          2))
+      ;; Operators as first-class values
+      (dict-set! env "+" (hk-make-binop-builtin "+" "+"))
+      (dict-set! env "-" (hk-make-binop-builtin "-" "-"))
+      (dict-set! env "*" (hk-make-binop-builtin "*" "*"))
+      (dict-set! env "/" (hk-make-binop-builtin "/" "/"))
+      (dict-set! env "==" (hk-make-binop-builtin "==" "=="))
+      (dict-set! env "/=" (hk-make-binop-builtin "/=" "/="))
+      (dict-set! env "<" (hk-make-binop-builtin "<" "<"))
+      (dict-set! env "<=" (hk-make-binop-builtin "<=" "<="))
+      (dict-set! env ">" (hk-make-binop-builtin ">" ">"))
+      (dict-set! env ">=" (hk-make-binop-builtin ">=" ">="))
+      (dict-set! env "&&" (hk-make-binop-builtin "&&" "&&"))
+      (dict-set! env "||" (hk-make-binop-builtin "||" "||"))
+      (dict-set! env "++" (hk-make-binop-builtin "++" "++"))
+      (dict-set! env "mod" (hk-make-binop-builtin "mod" "mod"))
+      (dict-set! env "div" (hk-make-binop-builtin "div" "div"))
+      (dict-set! env "rem" (hk-make-binop-builtin "rem" "rem"))
+      (dict-set! env "quot" (hk-make-binop-builtin "quot" "quot"))
+      (hk-load-into! env hk-prelude-src)
+      env)))
+
+(define
+  hk-bind-decls!
+  (fn
+    (env decls)
+    (let
+      ((groups (dict))
+        (group-order (list))
+        (pat-binds (list)))
+      ;; Pass 1: collect fun-clause groups by name; track first-seen
+      ;; order so pass 3 can evaluate 0-arity bodies in source order
+      ;; (forward references to other 0-arity definitions still need
+      ;; the earlier name to be bound first).
+      (for-each
+        (fn (d)
+          (cond
+            ((= (first d) "fun-clause")
+              (let
+                ((name (nth d 1)))
+                (when (not (has-key? groups name))
+                  (append! group-order name))
+                (dict-set!
+                  groups
+                  name
+                  (append
+                    (if
+                      (has-key? groups name)
+                      (get groups name)
+                      (list))
+                    (list (list (nth d 2) (nth d 3)))))
+                (when
+                  (not (has-key? env name))
+                  (dict-set! env name nil))))
+            ((or (= (first d) "bind") (= (first d) "pat-bind"))
+              (append! pat-binds d))
+            (:else nil)))
+        decls)
+      ;; Pass 2: install multifuns (arity > 0) — order doesn't matter
+      ;; because they're closures; collect 0-arity names in source
+      ;; order for pass 3.
+      (let ((zero-arity (list)))
+        (for-each
+          (fn (name)
+            (let ((clauses (get groups name)))
+              (let ((arity (len (first (first clauses)))))
+                (cond
+                  ((> arity 0)
+                    (dict-set!
+                      env
+                      name
+                      (hk-mk-multifun arity clauses env)))
+                  (:else (append! zero-arity name))))))
+          group-order)
+        ;; Pass 3: evaluate 0-arity bodies and pat-binds in source
+        ;; order — forward references to a later 0-arity name will
+        ;; still see its placeholder (nil) and fail noisily, but the
+        ;; common case of a top-down program works.
+        (for-each
+          (fn (name)
+            (let ((clauses (get groups name)))
+              (dict-set!
+                env
+                name
+                (hk-eval (first (rest (first clauses))) env))))
+          zero-arity)
+        (for-each
+          (fn (d)
+            (let ((pat (nth d 1)) (body (nth d 2)))
+              (let ((val (hk-eval body env)))
+                (let ((res (hk-match pat val env)))
+                  (cond
+                    ((nil? res)
+                      (raise "top-level pattern bind failure"))
+                    (:else (hk-extend-env-with-match! env res)))))))
+          pat-binds))
+      env)))
+
+(define
+  hk-eval-program
+  (fn
+    (ast)
+    (cond
+      ((nil? ast) (raise "eval-program: nil ast"))
+      ((not (list? ast)) (raise "eval-program: not a list"))
+      (:else
+        (do
+          (hk-register-program! ast)
+          (let ((env (hk-init-env)))
+            (let
+              ((decls
+                  (cond
+                    ((= (first ast) "program") (nth ast 1))
+                    ((= (first ast) "module") (nth ast 4))
+                    (:else (raise "eval-program: bad shape")))))
+              (hk-bind-decls! env decls))))))))
+
+;; ── Source-level convenience ────────────────────────────────
+(define
+  hk-run
+  (fn
+    (src)
+    (let ((env (hk-eval-program (hk-core src))))
+      (cond
+        ((has-key? env "main") (get env "main"))
+        (:else env)))))
+
+;; Eagerly build the Prelude env once at load time; each call to
+;; hk-eval-expr-source copies it instead of re-parsing the whole Prelude.
+(define hk-env0 (hk-init-env))
+
+(define
+  hk-eval-expr-source
+  (fn
+    (src)
+    (hk-deep-force (hk-eval (hk-core-expr src) (hk-dict-copy hk-env0)))))

lib/haskell/layout.sx

@@ -0,0 +1,329 @@
+;; Haskell 98 layout algorithm (§10.3).
+;;
+;; Consumes the raw token stream produced by hk-tokenize and inserts
+;; virtual braces / semicolons (types vlbrace / vrbrace / vsemi) based
+;; on indentation. Newline tokens are consumed and stripped.
+;;
+;;   (hk-layout (hk-tokenize src))  →  tokens-with-virtual-layout
+
+;; ── Pre-pass ──────────────────────────────────────────────────────
+;;
+;; Walks the raw token list and emits an augmented stream containing
+;; two fresh pseudo-tokens:
+;;
+;;   {:type "layout-open"   :col N :keyword K}
+;;     At stream start (K = "<module>") unless the first real token is
+;;     `module` or `{`. Also immediately after every `let` / `where` /
+;;     `do` / `of` whose following token is NOT `{`. N is the column
+;;     of the token that follows.
+;;
+;;   {:type "layout-indent" :col N}
+;;     Before any token whose line is strictly greater than the line
+;;     of the previously emitted real token, EXCEPT when that token
+;;     is already preceded by a layout-open (Haskell 98 §10.3 note 3).
+;;
+;; Raw newline tokens are dropped.
+
+(define
+  hk-layout-keyword?
+  (fn
+    (tok)
+    (and
+      (= (get tok "type") "reserved")
+      (or
+        (= (get tok "value") "let")
+        (= (get tok "value") "where")
+        (= (get tok "value") "do")
+        (= (get tok "value") "of")))))
+
+(define
+  hk-layout-pre
+  (fn
+    (tokens)
+    (let
+      ((result (list))
+        (n (len tokens))
+        (i 0)
+        (prev-line -1)
+        (first-real-emitted false)
+        (suppress-next-indent false))
+      (define
+        hk-next-real-idx
+        (fn
+          (start)
+          (let
+            ((j start))
+            (define
+              hk-nri-loop
+              (fn
+                ()
+                (when
+                  (and
+                    (< j n)
+                    (= (get (nth tokens j) "type") "newline"))
+                  (do (set! j (+ j 1)) (hk-nri-loop)))))
+            (hk-nri-loop)
+            j)))
+      (define
+        hk-pre-step
+        (fn
+          ()
+          (when
+            (< i n)
+            (let
+              ((tok (nth tokens i)) (ty (get tok "type")))
+              (cond
+                ((= ty "newline") (do (set! i (+ i 1)) (hk-pre-step)))
+                (:else
+                  (do
+                    (when
+                      (not first-real-emitted)
+                      (do
+                        (set! first-real-emitted true)
+                        (when
+                          (not
+                            (or
+                              (and
+                                (= ty "reserved")
+                                (= (get tok "value") "module"))
+                              (= ty "lbrace")))
+                          (do
+                            (append!
+                              result
+                              {:type "layout-open"
+                                :col (get tok "col")
+                                :keyword "<module>"
+                                :line (get tok "line")})
+                            (set! suppress-next-indent true)))))
+                    (when
+                      (and
+                        (>= prev-line 0)
+                        (> (get tok "line") prev-line)
+                        (not suppress-next-indent))
+                      (append!
+                        result
+                        {:type "layout-indent"
+                          :col (get tok "col")
+                          :line (get tok "line")}))
+                    (set! suppress-next-indent false)
+                    (set! prev-line (get tok "line"))
+                    (append! result tok)
+                    (when
+                      (hk-layout-keyword? tok)
+                      (let
+                        ((j (hk-next-real-idx (+ i 1))))
+                        (cond
+                          ((>= j n)
+                            (do
+                              (append!
+                                result
+                                {:type "layout-open"
+                                  :col 0
+                                  :keyword (get tok "value")
+                                  :line (get tok "line")})
+                              (set! suppress-next-indent true)))
+                          ((= (get (nth tokens j) "type") "lbrace") nil)
+                          (:else
+                            (do
+                              (append!
+                                result
+                                {:type "layout-open"
+                                  :col (get (nth tokens j) "col")
+                                  :keyword (get tok "value")
+                                  :line (get tok "line")})
+                              (set! suppress-next-indent true))))))
+                    (set! i (+ i 1))
+                    (hk-pre-step))))))))
+      (hk-pre-step)
+      result)))
+
+;; ── Main pass: L algorithm ────────────────────────────────────────
+;;
+;; Stack is a list; the head is the top of stack. Each entry is
+;; either the keyword :explicit (pushed by an explicit `{`) or a dict
+;; {:col N :keyword K} pushed by a layout-open marker.
+;;
+;; Rules (following Haskell 98 §10.3):
+;;
+;;   layout-open(n)  vs stack:
+;;     empty or explicit top                 → push n; emit {
+;;     n > top-col                           → push n; emit {
+;;     otherwise                             → emit { }; retry as indent(n)
+;;
+;;   layout-indent(n) vs stack:
+;;     empty or explicit top                 → drop
+;;     n == top-col                          → emit ;
+;;     n <  top-col                          → emit }; pop; recurse
+;;     n >  top-col                          → drop
+;;
+;;   lbrace                                  → push :explicit; emit {
+;;   rbrace                                  → pop if :explicit; emit }
+;;   `in` with implicit let on top           → emit }; pop; emit in
+;;   any other token                         → emit
+;;
+;; EOF: emit } for every remaining implicit context.
+
+(define
+  hk-layout-L
+  (fn
+    (pre-toks)
+    (let
+      ((result (list))
+        (stack (list))
+        (n (len pre-toks))
+        (i 0))
+      (define hk-emit (fn (t) (append! result t)))
+      (define
+        hk-indent-at
+        (fn
+          (col line)
+          (cond
+            ((or (empty? stack) (= (first stack) :explicit)) nil)
+            (:else
+              (let
+                ((top-col (get (first stack) "col")))
+                (cond
+                  ((= col top-col)
+                    (hk-emit
+                      {:type "vsemi" :value ";" :line line :col col}))
+                  ((< col top-col)
+                    (do
+                      (hk-emit
+                        {:type "vrbrace" :value "}" :line line :col col})
+                      (set! stack (rest stack))
+                      (hk-indent-at col line)))
+                  (:else nil)))))))
+      (define
+        hk-open-at
+        (fn
+          (col keyword line)
+          (cond
+            ((and
+                (> col 0)
+                (or
+                  (empty? stack)
+                  (= (first stack) :explicit)
+                  (> col (get (first stack) "col"))))
+              (do
+                (hk-emit
+                  {:type "vlbrace" :value "{" :line line :col col})
+                (set! stack (cons {:col col :keyword keyword} stack))))
+            (:else
+              (do
+                (hk-emit
+                  {:type "vlbrace" :value "{" :line line :col col})
+                (hk-emit
+                  {:type "vrbrace" :value "}" :line line :col col})
+                (hk-indent-at col line))))))
+      (define
+        hk-close-eof
+        (fn
+          ()
+          (when
+            (and
+              (not (empty? stack))
+              (not (= (first stack) :explicit)))
+            (do
+              (hk-emit {:type "vrbrace" :value "}" :line 0 :col 0})
+              (set! stack (rest stack))
+              (hk-close-eof)))))
+      ;; Peek past further layout-indent / layout-open markers to find
+      ;; the next real token's value when its type is `reserved`.
+      ;; Returns nil if no such token.
+      (define
+        hk-peek-next-reserved
+        (fn
+          (start)
+          (let ((j (+ start 1)) (found nil) (done false))
+            (define
+              hk-pnr-loop
+              (fn
+                ()
+                (when
+                  (and (not done) (< j n))
+                  (let
+                    ((t (nth pre-toks j)) (ty (get t "type")))
+                    (cond
+                      ((or
+                          (= ty "layout-indent")
+                          (= ty "layout-open"))
+                        (do (set! j (+ j 1)) (hk-pnr-loop)))
+                      ((= ty "reserved")
+                        (do (set! found (get t "value")) (set! done true)))
+                      (:else (set! done true)))))))
+            (hk-pnr-loop)
+            found)))
+      (define
+        hk-layout-step
+        (fn
+          ()
+          (when
+            (< i n)
+            (let
+              ((tok (nth pre-toks i)) (ty (get tok "type")))
+              (cond
+                ((= ty "eof")
+                  (do
+                    (hk-close-eof)
+                    (hk-emit tok)
+                    (set! i (+ i 1))
+                    (hk-layout-step)))
+                ((= ty "layout-open")
+                  (do
+                    (hk-open-at
+                      (get tok "col")
+                      (get tok "keyword")
+                      (get tok "line"))
+                    (set! i (+ i 1))
+                    (hk-layout-step)))
+                ((= ty "layout-indent")
+                  (cond
+                    ((= (hk-peek-next-reserved i) "in")
+                      (do (set! i (+ i 1)) (hk-layout-step)))
+                    (:else
+                      (do
+                        (hk-indent-at (get tok "col") (get tok "line"))
+                        (set! i (+ i 1))
+                        (hk-layout-step)))))
+                ((= ty "lbrace")
+                  (do
+                    (set! stack (cons :explicit stack))
+                    (hk-emit tok)
+                    (set! i (+ i 1))
+                    (hk-layout-step)))
+                ((= ty "rbrace")
+                  (do
+                    (when
+                      (and
+                        (not (empty? stack))
+                        (= (first stack) :explicit))
+                      (set! stack (rest stack)))
+                    (hk-emit tok)
+                    (set! i (+ i 1))
+                    (hk-layout-step)))
+                ((and
+                    (= ty "reserved")
+                    (= (get tok "value") "in")
+                    (not (empty? stack))
+                    (not (= (first stack) :explicit))
+                    (= (get (first stack) "keyword") "let"))
+                  (do
+                    (hk-emit
+                      {:type "vrbrace"
+                        :value "}"
+                        :line (get tok "line")
+                        :col (get tok "col")})
+                    (set! stack (rest stack))
+                    (hk-emit tok)
+                    (set! i (+ i 1))
+                    (hk-layout-step)))
+                (:else
+                  (do
+                    (hk-emit tok)
+                    (set! i (+ i 1))
+                    (hk-layout-step))))))))
+      (hk-layout-step)
+      (hk-close-eof)
+      result)))
+
+(define hk-layout (fn (tokens) (hk-layout-L (hk-layout-pre tokens))))

lib/haskell/match.sx

@@ -0,0 +1,201 @@
+;; Value-level pattern matching.
+;;
+;; Constructor values are tagged lists whose first element is the
+;; constructor name (a string). Tuples use the special tag "Tuple".
+;; Lists use the spine of `:` cons and `[]` nil.
+;;
+;;   Just 5         →  ("Just" 5)
+;;   Nothing        →  ("Nothing")
+;;   (1, 2)         →  ("Tuple" 1 2)
+;;   [1, 2]         →  (":" 1 (":" 2 ("[]")))
+;;   ()             →  ("()")
+;;
+;; Primitive values (numbers, strings, chars) are stored raw.
+;;
+;; The matcher takes a pattern AST node, a value, and an environment
+;; dict; it returns an extended dict on success, or `nil` on failure.
+
+;; ── Value builders ──────────────────────────────────────────
+(define
+  hk-mk-con
+  (fn
+    (cname args)
+    (let ((result (list cname)))
+      (for-each (fn (a) (append! result a)) args)
+      result)))
+
+(define
+  hk-mk-tuple
+  (fn
+    (items)
+    (let ((result (list "Tuple")))
+      (for-each (fn (x) (append! result x)) items)
+      result)))
+
+(define hk-mk-nil (fn () (list "[]")))
+
+(define hk-mk-cons (fn (h t) (list ":" h t)))
+
+(define
+  hk-mk-list
+  (fn
+    (items)
+    (cond
+      ((empty? items) (hk-mk-nil))
+      (:else
+        (hk-mk-cons (first items) (hk-mk-list (rest items)))))))
+
+;; ── Predicates / accessors on constructor values ───────────
+(define
+  hk-is-con-val?
+  (fn
+    (v)
+    (and
+      (list? v)
+      (not (empty? v))
+      (string? (first v)))))
+
+(define hk-val-con-name (fn (v) (first v)))
+
+(define hk-val-con-args (fn (v) (rest v)))
+
+;; ── The matcher ────────────────────────────────────────────
+;;
+;; Pattern match forces the scrutinee to WHNF before inspecting it
+;; — except for `p-wild`, `p-var`, and `p-lazy`, which never need
+;; to look at the value. Args of constructor / tuple / list values
+;; remain thunked (they're forced only when their own pattern needs
+;; to inspect them, recursively).
+(define
+  hk-match
+  (fn
+    (pat val env)
+    (cond
+      ((not (list? pat)) nil)
+      ((empty? pat) nil)
+      (:else
+        (let
+          ((tag (first pat)))
+          (cond
+            ((= tag "p-wild") env)
+            ((= tag "p-var") (assoc env (nth pat 1) val))
+            ((= tag "p-lazy") (hk-match (nth pat 1) val env))
+            ((= tag "p-as")
+              (let
+                ((res (hk-match (nth pat 2) val env)))
+                (cond
+                  ((nil? res) nil)
+                  (:else (assoc res (nth pat 1) val)))))
+            (:else
+              (let ((fv (hk-force val)))
+                (cond
+                  ((= tag "p-int")
+                    (if
+                      (and (number? fv) (= fv (nth pat 1)))
+                      env
+                      nil))
+                  ((= tag "p-float")
+                    (if
+                      (and (number? fv) (= fv (nth pat 1)))
+                      env
+                      nil))
+                  ((= tag "p-string")
+                    (if
+                      (and (string? fv) (= fv (nth pat 1)))
+                      env
+                      nil))
+                  ((= tag "p-char")
+                    (if
+                      (and (string? fv) (= fv (nth pat 1)))
+                      env
+                      nil))
+                  ((= tag "p-con")
+                    (let
+                      ((pat-name (nth pat 1)) (pat-args (nth pat 2)))
+                      (cond
+                        ((not (hk-is-con-val? fv)) nil)
+                        ((not (= (hk-val-con-name fv) pat-name)) nil)
+                        (:else
+                          (let
+                            ((val-args (hk-val-con-args fv)))
+                            (cond
+                              ((not (= (len pat-args) (len val-args)))
+                                nil)
+                              (:else
+                                (hk-match-all
+                                  pat-args
+                                  val-args
+                                  env))))))))
+                  ((= tag "p-tuple")
+                    (let
+                      ((items (nth pat 1)))
+                      (cond
+                        ((not (hk-is-con-val? fv)) nil)
+                        ((not (= (hk-val-con-name fv) "Tuple")) nil)
+                        ((not (= (len (hk-val-con-args fv)) (len items)))
+                          nil)
+                        (:else
+                          (hk-match-all
+                            items
+                            (hk-val-con-args fv)
+                            env)))))
+                  ((= tag "p-list")
+                    (hk-match-list-pat (nth pat 1) fv env))
+                  (:else nil))))))))))
+
+(define
+  hk-match-all
+  (fn
+    (pats vals env)
+    (cond
+      ((empty? pats) env)
+      (:else
+        (let
+          ((res (hk-match (first pats) (first vals) env)))
+          (cond
+            ((nil? res) nil)
+            (:else
+              (hk-match-all (rest pats) (rest vals) res))))))))
+
+(define
+  hk-match-list-pat
+  (fn
+    (items val env)
+    (let ((fv (hk-force val)))
+      (cond
+        ((empty? items)
+          (if
+            (and
+              (hk-is-con-val? fv)
+              (= (hk-val-con-name fv) "[]"))
+            env
+            nil))
+        (:else
+          (cond
+            ((not (hk-is-con-val? fv)) nil)
+            ((not (= (hk-val-con-name fv) ":")) nil)
+            (:else
+              (let
+                ((args (hk-val-con-args fv)))
+                (let
+                  ((h (first args)) (t (first (rest args))))
+                  (let
+                    ((res (hk-match (first items) h env)))
+                    (cond
+                      ((nil? res) nil)
+                      (:else
+                        (hk-match-list-pat
+                          (rest items)
+                          t
+                          res)))))))))))))
+
+;; ── Convenience: parse a pattern from source for tests ─────
+;; (Uses the parser's case-alt entry — `case _ of pat -> 0` —
+;; to extract a pattern AST.)
+(define
+  hk-parse-pat-source
+  (fn
+    (src)
+    (let
+      ((expr (hk-parse (str "case 0 of " src " -> 0"))))
+      (nth (nth (nth expr 2) 0) 1))))

lib/haskell/runtime.sx

@@ -0,0 +1,130 @@
+;; Haskell runtime: constructor registry.
+;;
+;; A mutable dict keyed by constructor name (e.g. "Just", "[]") with
+;; entries of shape  {:arity N :type TYPE-NAME-STRING}.
+;; Populated by ingesting `data` / `newtype` decls from parsed ASTs.
+;; Pre-registers a small set of constructors tied to Haskell syntactic
+;; forms (Bool, list, unit) — every nontrivial program depends on
+;; these, and the parser/desugar pipeline emits them as (:var "True")
+;; etc. without a corresponding `data` decl.
+
+(define hk-constructors (dict))
+
+(define
+  hk-register-con!
+  (fn
+    (cname arity type-name)
+    (dict-set!
+      hk-constructors
+      cname
+      {:arity arity :type type-name})))
+
+(define hk-is-con? (fn (name) (has-key? hk-constructors name)))
+
+(define
+  hk-con-arity
+  (fn
+    (name)
+    (if
+      (has-key? hk-constructors name)
+      (get (get hk-constructors name) "arity")
+      nil)))
+
+(define
+  hk-con-type
+  (fn
+    (name)
+    (if
+      (has-key? hk-constructors name)
+      (get (get hk-constructors name) "type")
+      nil)))
+
+(define hk-con-names (fn () (keys hk-constructors)))
+
+;; ── Registration from AST ────────────────────────────────────
+;; (:data NAME TVARS ((:con-def CNAME FIELDS) …))
+(define
+  hk-register-data!
+  (fn
+    (data-node)
+    (let
+      ((type-name (nth data-node 1))
+        (cons-list (nth data-node 3)))
+      (for-each
+        (fn
+          (cd)
+          (hk-register-con!
+            (nth cd 1)
+            (len (nth cd 2))
+            type-name))
+        cons-list))))
+
+;; (:newtype NAME TVARS CNAME FIELD)
+(define
+  hk-register-newtype!
+  (fn
+    (nt-node)
+    (hk-register-con!
+      (nth nt-node 3)
+      1
+      (nth nt-node 1))))
+
+;; Walk a decls list, registering every `data` / `newtype` decl.
+(define
+  hk-register-decls!
+  (fn
+    (decls)
+    (for-each
+      (fn
+        (d)
+        (cond
+          ((and
+              (list? d)
+              (not (empty? d))
+              (= (first d) "data"))
+            (hk-register-data! d))
+          ((and
+              (list? d)
+              (not (empty? d))
+              (= (first d) "newtype"))
+            (hk-register-newtype! d))
+          (:else nil)))
+      decls)))
+
+(define
+  hk-register-program!
+  (fn
+    (ast)
+    (cond
+      ((nil? ast) nil)
+      ((not (list? ast)) nil)
+      ((empty? ast) nil)
+      ((= (first ast) "program")
+        (hk-register-decls! (nth ast 1)))
+      ((= (first ast) "module")
+        (hk-register-decls! (nth ast 4)))
+      (:else nil))))
+
+;; Convenience: source → AST → desugar → register.
+(define
+  hk-load-source!
+  (fn (src) (hk-register-program! (hk-core src))))
+
+;; ── Built-in constructors pre-registered ─────────────────────
+;; Bool — used implicitly by `if`, comparison operators.
+(hk-register-con! "True" 0 "Bool")
+(hk-register-con! "False" 0 "Bool")
+;; List — used by list literals, range syntax, and cons operator.
+(hk-register-con! "[]" 0 "List")
+(hk-register-con! ":" 2 "List")
+;; Unit — produced by empty parens `()`.
+(hk-register-con! "()" 0 "Unit")
+;; Standard Prelude types — pre-registered so expression-level
+;; programs can use them without a `data` decl.
+(hk-register-con! "Nothing" 0 "Maybe")
+(hk-register-con! "Just"    1 "Maybe")
+(hk-register-con! "Left"    1 "Either")
+(hk-register-con! "Right"   1 "Either")
+(hk-register-con! "LT" 0 "Ordering")
+(hk-register-con! "EQ" 0 "Ordering")
+(hk-register-con! "GT" 0 "Ordering")

lib/haskell/scoreboard.json

@@ -0,0 +1,12 @@
+{
+  "date": "2026-04-25",
+  "total_pass": 16,
+  "total_fail": 0,
+  "programs": {
+    "fib": {"pass": 2, "fail": 0},
+    "sieve": {"pass": 2, "fail": 0},
+    "quicksort": {"pass": 5, "fail": 0},
+    "nqueens": {"pass": 2, "fail": 0},
+    "calculator": {"pass": 5, "fail": 0}
+  }
+}

lib/haskell/scoreboard.md

@@ -0,0 +1,12 @@
+# Haskell-on-SX Scoreboard
+
+Updated 2026-04-25 · Phase 3 (laziness + classic programs)
+
+| Program | Tests | Status |
+|---------|-------|--------|
+| fib.hs | 2/2 | ✓ |
+| sieve.hs | 2/2 | ✓ |
+| quicksort.hs | 5/5 | ✓ |
+| nqueens.hs | 2/2 | ✓ |
+| calculator.hs | 5/5 | ✓ |
+| **Total** | **16/16** | **5/5 programs** |

lib/haskell/test.sh

@@ -46,6 +46,13 @@ for FILE in "${FILES[@]}"; do
   cat > "$TMPFILE" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
+(load "lib/haskell/layout.sx")
+(load "lib/haskell/parser.sx")
+(load "lib/haskell/desugar.sx")
+(load "lib/haskell/runtime.sx")
+(load "lib/haskell/match.sx")
+(load "lib/haskell/eval.sx")
+(load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
@@ -81,6 +88,13 @@ EPOCHS
     cat > "$TMPFILE2" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
+(load "lib/haskell/layout.sx")
+(load "lib/haskell/parser.sx")
+(load "lib/haskell/desugar.sx")
+(load "lib/haskell/runtime.sx")
+(load "lib/haskell/match.sx")
+(load "lib/haskell/eval.sx")
+(load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)

lib/haskell/testlib.sx

@@ -0,0 +1,58 @@
+;; Shared test harness for Haskell-on-SX tests.
+;; Each test file expects hk-test / hk-deep=? / counters to already be bound.
+
+(define
+  hk-deep=?
+  (fn
+    (a b)
+    (cond
+      ((= a b) true)
+      ((and (dict? a) (dict? b))
+        (let
+          ((ak (keys a)) (bk (keys b)))
+          (if
+            (not (= (len ak) (len bk)))
+            false
+            (every?
+              (fn
+                (k)
+                (and (has-key? b k) (hk-deep=? (get a k) (get b k))))
+              ak))))
+      ((and (list? a) (list? b))
+        (if
+          (not (= (len a) (len b)))
+          false
+          (let
+            ((i 0) (ok true))
+            (define
+              hk-de-loop
+              (fn
+                ()
+                (when
+                  (and ok (< i (len a)))
+                  (do
+                    (when
+                      (not (hk-deep=? (nth a i) (nth b i)))
+                      (set! ok false))
+                    (set! i (+ i 1))
+                    (hk-de-loop)))))
+            (hk-de-loop)
+            ok)))
+      (:else false))))
+
+(define hk-test-pass 0)
+(define hk-test-fail 0)
+(define hk-test-fails (list))
+
+(define
+  hk-test
+  (fn
+    (name actual expected)
+    (if
+      (hk-deep=? actual expected)
+      (set! hk-test-pass (+ hk-test-pass 1))
+      (do
+        (set! hk-test-fail (+ hk-test-fail 1))
+        (append!
+          hk-test-fails
+          {:actual actual :expected expected :name name})))))

lib/haskell/tests/desugar.sx

@@ -0,0 +1,305 @@
+;; Desugar tests — surface AST → core AST.
+;;   :guarded   →  nested :if
+;;   :where     →  :let
+;;   :list-comp →  concatMap-based tree
+
+(define
+  hk-prog
+  (fn (&rest decls) (list :program decls)))
+
+;; ── Guards → if ──
+(hk-test
+  "two-way guarded rhs"
+  (hk-desugar (hk-parse-top "abs x | x < 0 = - x\n      | otherwise = x"))
+  (hk-prog
+    (list
+      :fun-clause
+      "abs"
+      (list (list :p-var "x"))
+      (list
+        :if
+        (list :op "<" (list :var "x") (list :int 0))
+        (list :neg (list :var "x"))
+        (list
+          :if
+          (list :var "otherwise")
+          (list :var "x")
+          (list
+            :app
+            (list :var "error")
+            (list :string "Non-exhaustive guards")))))))
+
+(hk-test
+  "three-way guarded rhs"
+  (hk-desugar
+    (hk-parse-top "sign n | n > 0 = 1\n       | n < 0 = -1\n       | otherwise = 0"))
+  (hk-prog
+    (list
+      :fun-clause
+      "sign"
+      (list (list :p-var "n"))
+      (list
+        :if
+        (list :op ">" (list :var "n") (list :int 0))
+        (list :int 1)
+        (list
+          :if
+          (list :op "<" (list :var "n") (list :int 0))
+          (list :neg (list :int 1))
+          (list
+            :if
+            (list :var "otherwise")
+            (list :int 0)
+            (list
+              :app
+              (list :var "error")
+              (list :string "Non-exhaustive guards"))))))))
+
+(hk-test
+  "case-alt guards desugared too"
+  (hk-desugar
+    (hk-parse "case x of\n  Just y | y > 0 -> y\n         | otherwise -> 0\n  Nothing -> -1"))
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list :p-con "Just" (list (list :p-var "y")))
+        (list
+          :if
+          (list :op ">" (list :var "y") (list :int 0))
+          (list :var "y")
+          (list
+            :if
+            (list :var "otherwise")
+            (list :int 0)
+            (list
+              :app
+              (list :var "error")
+              (list :string "Non-exhaustive guards")))))
+      (list
+        :alt
+        (list :p-con "Nothing" (list))
+        (list :neg (list :int 1))))))
+
+;; ── Where → let ──
+(hk-test
+  "where with single binding"
+  (hk-desugar (hk-parse-top "f x = y\n  where y = x + 1"))
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :let
+        (list
+          (list
+            :fun-clause
+            "y"
+            (list)
+            (list :op "+" (list :var "x") (list :int 1))))
+        (list :var "y")))))
+
+(hk-test
+  "where with two bindings"
+  (hk-desugar
+    (hk-parse-top "f x = y + z\n  where y = x + 1\n        z = x - 1"))
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :let
+        (list
+          (list
+            :fun-clause
+            "y"
+            (list)
+            (list :op "+" (list :var "x") (list :int 1)))
+          (list
+            :fun-clause
+            "z"
+            (list)
+            (list :op "-" (list :var "x") (list :int 1))))
+        (list :op "+" (list :var "y") (list :var "z"))))))
+
+(hk-test
+  "guards + where — guarded body inside let"
+  (hk-desugar
+    (hk-parse-top "f x | x > 0 = y\n    | otherwise = 0\n  where y = 99"))
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :let
+        (list (list :fun-clause "y" (list) (list :int 99)))
+        (list
+          :if
+          (list :op ">" (list :var "x") (list :int 0))
+          (list :var "y")
+          (list
+            :if
+            (list :var "otherwise")
+            (list :int 0)
+            (list
+              :app
+              (list :var "error")
+              (list :string "Non-exhaustive guards"))))))))
+
+;; ── List comprehensions → concatMap / if / let ──
+(hk-test
+  "list-comp: single generator"
+  (hk-core-expr "[x | x <- xs]")
+  (list
+    :app
+    (list
+      :app
+      (list :var "concatMap")
+      (list
+        :lambda
+        (list (list :p-var "x"))
+        (list :list (list (list :var "x")))))
+    (list :var "xs")))
+
+(hk-test
+  "list-comp: generator then guard"
+  (hk-core-expr "[x * 2 | x <- xs, x > 0]")
+  (list
+    :app
+    (list
+      :app
+      (list :var "concatMap")
+      (list
+        :lambda
+        (list (list :p-var "x"))
+        (list
+          :if
+          (list :op ">" (list :var "x") (list :int 0))
+          (list
+            :list
+            (list (list :op "*" (list :var "x") (list :int 2))))
+          (list :list (list)))))
+    (list :var "xs")))
+
+(hk-test
+  "list-comp: generator then let"
+  (hk-core-expr "[y | x <- xs, let y = x + 1]")
+  (list
+    :app
+    (list
+      :app
+      (list :var "concatMap")
+      (list
+        :lambda
+        (list (list :p-var "x"))
+        (list
+          :let
+          (list
+            (list
+              :bind
+              (list :p-var "y")
+              (list :op "+" (list :var "x") (list :int 1))))
+          (list :list (list (list :var "y"))))))
+    (list :var "xs")))
+
+(hk-test
+  "list-comp: two generators (nested concatMap)"
+  (hk-core-expr "[(x, y) | x <- xs, y <- ys]")
+  (list
+    :app
+    (list
+      :app
+      (list :var "concatMap")
+      (list
+        :lambda
+        (list (list :p-var "x"))
+        (list
+          :app
+          (list
+            :app
+            (list :var "concatMap")
+            (list
+              :lambda
+              (list (list :p-var "y"))
+              (list
+                :list
+                (list
+                  (list
+                    :tuple
+                    (list (list :var "x") (list :var "y")))))))
+          (list :var "ys"))))
+    (list :var "xs")))
+
+;; ── Pass-through cases ──
+(hk-test
+  "plain int literal unchanged"
+  (hk-core-expr "42")
+  (list :int 42))
+
+(hk-test
+  "lambda + if passes through"
+  (hk-core-expr "\\x -> if x > 0 then x else - x")
+  (list
+    :lambda
+    (list (list :p-var "x"))
+    (list
+      :if
+      (list :op ">" (list :var "x") (list :int 0))
+      (list :var "x")
+      (list :neg (list :var "x")))))
+
+(hk-test
+  "simple fun-clause (no guards/where) passes through"
+  (hk-desugar (hk-parse-top "id x = x"))
+  (hk-prog
+    (list
+      :fun-clause
+      "id"
+      (list (list :p-var "x"))
+      (list :var "x"))))
+
+(hk-test
+  "data decl passes through"
+  (hk-desugar (hk-parse-top "data Maybe a = Nothing | Just a"))
+  (hk-prog
+    (list
+      :data
+      "Maybe"
+      (list "a")
+      (list
+        (list :con-def "Nothing" (list))
+        (list :con-def "Just" (list (list :t-var "a")))))))
+
+(hk-test
+  "module header passes through, body desugared"
+  (hk-desugar
+    (hk-parse-top "module M where\nf x | x > 0 = 1\n    | otherwise = 0"))
+  (list
+    :module
+    "M"
+    nil
+    (list)
+    (list
+      (list
+        :fun-clause
+        "f"
+        (list (list :p-var "x"))
+        (list
+          :if
+          (list :op ">" (list :var "x") (list :int 0))
+          (list :int 1)
+          (list
+            :if
+            (list :var "otherwise")
+            (list :int 0)
+            (list
+              :app
+              (list :var "error")
+              (list :string "Non-exhaustive guards"))))))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/do-io.sx

@@ -0,0 +1,117 @@
+;; do-notation + stub IO monad. Desugaring is per Haskell 98 §3.14:
+;;   do { e ; ss }      = e >> do { ss }
+;;   do { p <- e ; ss } = e >>= \p -> do { ss }
+;;   do { let ds ; ss } = let ds in do { ss }
+;;   do { e }           = e
+;; The IO type is just `("IO" payload)` for now — no real side
+;; effects yet. `return`, `>>=`, `>>` are built-ins.
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+;; ── Single-statement do ──
+(hk-test
+  "do with a single expression"
+  (hk-eval-expr-source "do { return 5 }")
+  (list "IO" 5))
+
+(hk-test
+  "return wraps any expression"
+  (hk-eval-expr-source "return (1 + 2 * 3)")
+  (list "IO" 7))
+
+;; ── Bind threads results ──
+(hk-test
+  "single bind"
+  (hk-eval-expr-source
+    "do { x <- return 5 ; return (x + 1) }")
+  (list "IO" 6))
+
+(hk-test
+  "two binds"
+  (hk-eval-expr-source
+    "do\n  x <- return 5\n  y <- return 7\n  return (x + y)")
+  (list "IO" 12))
+
+(hk-test
+  "three binds — accumulating"
+  (hk-eval-expr-source
+    "do\n  a <- return 1\n  b <- return 2\n  c <- return 3\n  return (a + b + c)")
+  (list "IO" 6))
+
+;; ── Mixing >> and >>= ──
+(hk-test
+  ">> sequencing — last wins"
+  (hk-eval-expr-source
+    "do\n  return 1\n  return 2\n  return 3")
+  (list "IO" 3))
+
+(hk-test
+  ">> then >>= — last bind wins"
+  (hk-eval-expr-source
+    "do\n  return 99\n  x <- return 5\n  return x")
+  (list "IO" 5))
+
+;; ── do-let ──
+(hk-test
+  "do-let single binding"
+  (hk-eval-expr-source
+    "do\n  let x = 3\n  return (x * 2)")
+  (list "IO" 6))
+
+(hk-test
+  "do-let multi-bind, used after"
+  (hk-eval-expr-source
+    "do\n  let x = 4\n      y = 5\n  return (x * y)")
+  (list "IO" 20))
+
+(hk-test
+  "do-let interleaved with bind"
+  (hk-eval-expr-source
+    "do\n  x <- return 10\n  let y = x + 1\n  return (x * y)")
+  (list "IO" 110))
+
+;; ── Bind + pattern ──
+(hk-test
+  "bind to constructor pattern"
+  (hk-eval-expr-source
+    "do\n  Just x <- return (Just 7)\n  return (x + 100)")
+  (list "IO" 107))
+
+(hk-test
+  "bind to tuple pattern"
+  (hk-eval-expr-source
+    "do\n  (a, b) <- return (3, 4)\n  return (a * b)")
+  (list "IO" 12))
+
+;; ── User-defined IO functions ──
+(hk-test
+  "do inside top-level fun"
+  (hk-prog-val
+    "addM x y = do\n  a <- return x\n  b <- return y\n  return (a + b)\nresult = addM 5 6"
+    "result")
+  (list "IO" 11))
+
+(hk-test
+  "nested do"
+  (hk-eval-expr-source
+    "do\n  x <- do { y <- return 3 ; return (y + 1) }\n  return (x * 2)")
+  (list "IO" 8))
+
+;; ── (>>=) and (>>) used directly as functions ──
+(hk-test
+  ">>= used directly"
+  (hk-eval-expr-source
+    "(return 4) >>= (\\x -> return (x + 100))")
+  (list "IO" 104))
+
+(hk-test
+  ">> used directly"
+  (hk-eval-expr-source
+    "(return 1) >> (return 2)")
+  (list "IO" 2))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/eval.sx

@@ -0,0 +1,278 @@
+;; Strict evaluator tests. Each test parses, desugars, and evaluates
+;; either an expression (hk-eval-expr-source) or a full program
+;; (hk-eval-program → look up a named value).
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+;; ── Literals ──
+(hk-test "int literal" (hk-eval-expr-source "42") 42)
+(hk-test "float literal" (hk-eval-expr-source "3.14") 3.14)
+(hk-test "string literal" (hk-eval-expr-source "\"hi\"") "hi")
+(hk-test "char literal" (hk-eval-expr-source "'a'") "a")
+(hk-test "negative literal" (hk-eval-expr-source "- 5") -5)
+
+;; ── Arithmetic ──
+(hk-test "addition" (hk-eval-expr-source "1 + 2") 3)
+(hk-test
+  "precedence"
+  (hk-eval-expr-source "1 + 2 * 3")
+  7)
+(hk-test
+  "parens override precedence"
+  (hk-eval-expr-source "(1 + 2) * 3")
+  9)
+(hk-test
+  "subtraction left-assoc"
+  (hk-eval-expr-source "10 - 3 - 2")
+  5)
+
+;; ── Comparison + Bool ──
+(hk-test
+  "less than is True"
+  (hk-eval-expr-source "3 < 5")
+  (list "True"))
+(hk-test
+  "equality is False"
+  (hk-eval-expr-source "1 == 2")
+  (list "False"))
+(hk-test
+  "&& shortcuts"
+  (hk-eval-expr-source "(1 == 1) && (2 == 2)")
+  (list "True"))
+
+;; ── if / otherwise ──
+(hk-test
+  "if True"
+  (hk-eval-expr-source "if True then 1 else 2")
+  1)
+(hk-test
+  "if comparison branch"
+  (hk-eval-expr-source "if 5 > 3 then \"yes\" else \"no\"")
+  "yes")
+(hk-test "otherwise is True" (hk-eval-expr-source "otherwise") (list "True"))
+
+;; ── let ──
+(hk-test
+  "let single binding"
+  (hk-eval-expr-source "let x = 5 in x + 1")
+  6)
+(hk-test
+  "let two bindings"
+  (hk-eval-expr-source "let x = 1; y = 2 in x + y")
+  3)
+(hk-test
+  "let recursive: factorial 5"
+  (hk-eval-expr-source
+    "let f n = if n == 0 then 1 else n * f (n - 1) in f 5")
+  120)
+
+;; ── Lambdas ──
+(hk-test
+  "lambda apply"
+  (hk-eval-expr-source "(\\x -> x + 1) 5")
+  6)
+(hk-test
+  "lambda multi-arg"
+  (hk-eval-expr-source "(\\x y -> x * y) 3 4")
+  12)
+(hk-test
+  "lambda with constructor pattern"
+  (hk-eval-expr-source "(\\(Just x) -> x + 1) (Just 7)")
+  8)
+
+;; ── Constructors ──
+(hk-test
+  "0-arity constructor"
+  (hk-eval-expr-source "Nothing")
+  (list "Nothing"))
+(hk-test
+  "1-arity constructor applied"
+  (hk-eval-expr-source "Just 5")
+  (list "Just" 5))
+(hk-test
+  "True / False as bools"
+  (hk-eval-expr-source "True")
+  (list "True"))
+
+;; ── case ──
+(hk-test
+  "case Just"
+  (hk-eval-expr-source
+    "case Just 7 of Just x -> x ; Nothing -> 0")
+  7)
+(hk-test
+  "case Nothing"
+  (hk-eval-expr-source
+    "case Nothing of Just x -> x ; Nothing -> 99")
+  99)
+(hk-test
+  "case literal pattern"
+  (hk-eval-expr-source
+    "case 0 of 0 -> \"zero\" ; n -> \"other\"")
+  "zero")
+(hk-test
+  "case tuple"
+  (hk-eval-expr-source
+    "case (1, 2) of (a, b) -> a + b")
+  3)
+(hk-test
+  "case wildcard fallback"
+  (hk-eval-expr-source
+    "case 5 of 0 -> \"z\" ; _ -> \"nz\"")
+  "nz")
+
+;; ── List literals + cons ──
+(hk-test
+  "list literal as cons spine"
+  (hk-eval-expr-source "[1, 2, 3]")
+  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
+(hk-test
+  "empty list literal"
+  (hk-eval-expr-source "[]")
+  (list "[]"))
+(hk-test
+  "cons via :"
+  (hk-eval-expr-source "1 : []")
+  (list ":" 1 (list "[]")))
+(hk-test
+  "++ concatenates lists"
+  (hk-eval-expr-source "[1, 2] ++ [3]")
+  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
+
+;; ── Tuples ──
+(hk-test
+  "2-tuple"
+  (hk-eval-expr-source "(1, 2)")
+  (list "Tuple" 1 2))
+(hk-test
+  "3-tuple"
+  (hk-eval-expr-source "(\"a\", 5, True)")
+  (list "Tuple" "a" 5 (list "True")))
+
+;; ── Sections ──
+(hk-test
+  "right section (+ 1) applied"
+  (hk-eval-expr-source "(+ 1) 5")
+  6)
+(hk-test
+  "left section (10 -) applied"
+  (hk-eval-expr-source "(10 -) 4")
+  6)
+
+;; ── Multi-clause top-level functions ──
+(hk-test
+  "multi-clause: factorial"
+  (hk-prog-val
+    "fact 0 = 1\nfact n = n * fact (n - 1)\nresult = fact 6"
+    "result")
+  720)
+
+(hk-test
+  "multi-clause: list length via cons pattern"
+  (hk-prog-val
+    "len [] = 0\nlen (x:xs) = 1 + len xs\nresult = len [10, 20, 30, 40]"
+    "result")
+  4)
+
+(hk-test
+  "multi-clause: Maybe handler"
+  (hk-prog-val
+    "fromMaybe d Nothing = d\nfromMaybe _ (Just x) = x\nresult = fromMaybe 0 (Just 9)"
+    "result")
+  9)
+
+(hk-test
+  "multi-clause: Maybe with default"
+  (hk-prog-val
+    "fromMaybe d Nothing = d\nfromMaybe _ (Just x) = x\nresult = fromMaybe 0 Nothing"
+    "result")
+  0)
+
+;; ── User-defined data and matching ──
+(hk-test
+  "custom data with pattern match"
+  (hk-prog-val
+    "data Color = Red | Green | Blue\nname Red = \"red\"\nname Green = \"green\"\nname Blue = \"blue\"\nresult = name Green"
+    "result")
+  "green")
+
+(hk-test
+  "custom binary tree height"
+  (hk-prog-val
+    "data Tree = Leaf | Node Tree Tree\nh Leaf = 0\nh (Node l r) = 1 + max (h l) (h r)\nmax a b = if a > b then a else b\nresult = h (Node (Node Leaf Leaf) Leaf)"
+    "result")
+  2)
+
+;; ── Currying ──
+(hk-test
+  "partial application"
+  (hk-prog-val
+    "add x y = x + y\nadd5 = add 5\nresult = add5 7"
+    "result")
+  12)
+
+;; ── Higher-order ──
+(hk-test
+  "higher-order: function as arg"
+  (hk-prog-val
+    "twice f x = f (f x)\ninc x = x + 1\nresult = twice inc 10"
+    "result")
+  12)
+
+;; ── Error built-in ──
+(hk-test
+  "error short-circuits via if"
+  (hk-eval-expr-source
+    "if True then 1 else error \"unreachable\"")
+  1)
+
+;; ── Laziness: app args evaluate only when forced ──
+(hk-test
+  "second arg never forced"
+  (hk-eval-expr-source
+    "(\\x y -> x) 1 (error \"never\")")
+  1)
+
+(hk-test
+  "first arg never forced"
+  (hk-eval-expr-source
+    "(\\x y -> y) (error \"never\") 99")
+  99)
+
+(hk-test
+  "constructor argument is lazy under wildcard pattern"
+  (hk-eval-expr-source
+    "case Just (error \"deeply\") of Just _ -> 7 ; Nothing -> 0")
+  7)
+
+(hk-test
+  "lazy: const drops its second argument"
+  (hk-prog-val
+    "const x y = x\nresult = const 5 (error \"boom\")"
+    "result")
+  5)
+
+(hk-test
+  "lazy: head ignores tail"
+  (hk-prog-val
+    "myHead (x:_) = x\nresult = myHead (1 : (error \"tail\") : [])"
+    "result")
+  1)
+
+(hk-test
+  "lazy: Just on undefined evaluates only on force"
+  (hk-prog-val
+    "wrapped = Just (error \"oh no\")\nresult = case wrapped of Just _ -> True ; Nothing -> False"
+    "result")
+  (list "True"))
+
+;; ── not / id built-ins ──
+(hk-test "not True" (hk-eval-expr-source "not True") (list "False"))
+(hk-test "not False" (hk-eval-expr-source "not False") (list "True"))
+(hk-test "id" (hk-eval-expr-source "id 42") 42)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/infinite.sx

@@ -0,0 +1,137 @@
+;; Infinite structures + Prelude tests. The lazy `:` operator builds
+;; cons cells with thunked head/tail so recursive list-defining
+;; functions terminate when only a finite prefix is consumed.
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define hk-as-list
+  (fn (xs)
+    (cond
+      ((and (list? xs) (= (first xs) "[]")) (list))
+      ((and (list? xs) (= (first xs) ":"))
+        (cons (nth xs 1) (hk-as-list (nth xs 2))))
+      (:else xs))))
+
+(define
+  hk-eval-list
+  (fn (src) (hk-as-list (hk-eval-expr-source src))))
+
+;; ── Prelude basics ──
+(hk-test "head of literal" (hk-eval-expr-source "head [1, 2, 3]") 1)
+(hk-test
+  "tail of literal"
+  (hk-eval-list "tail [1, 2, 3]")
+  (list 2 3))
+(hk-test "length" (hk-eval-expr-source "length [10, 20, 30, 40]") 4)
+(hk-test "length empty" (hk-eval-expr-source "length []") 0)
+(hk-test
+  "map with section"
+  (hk-eval-list "map (+ 1) [1, 2, 3]")
+  (list 2 3 4))
+(hk-test
+  "filter"
+  (hk-eval-list "filter (\\x -> x > 2) [1, 2, 3, 4, 5]")
+  (list 3 4 5))
+(hk-test
+  "drop"
+  (hk-eval-list "drop 2 [10, 20, 30, 40]")
+  (list 30 40))
+(hk-test "fst" (hk-eval-expr-source "fst (7, 9)") 7)
+(hk-test "snd" (hk-eval-expr-source "snd (7, 9)") 9)
+(hk-test
+  "zipWith"
+  (hk-eval-list "zipWith plus [1, 2, 3] [10, 20, 30]")
+  (list 11 22 33))
+
+;; ── Infinite structures ──
+(hk-test
+  "take from repeat"
+  (hk-eval-list "take 5 (repeat 7)")
+  (list 7 7 7 7 7))
+(hk-test
+  "take 0 from repeat returns empty"
+  (hk-eval-list "take 0 (repeat 7)")
+  (list))
+(hk-test
+  "take from iterate"
+  (hk-eval-list "take 5 (iterate (\\x -> x + 1) 0)")
+  (list 0 1 2 3 4))
+(hk-test
+  "iterate with multiplication"
+  (hk-eval-list "take 4 (iterate (\\x -> x * 2) 1)")
+  (list 1 2 4 8))
+(hk-test
+  "head of repeat"
+  (hk-eval-expr-source "head (repeat 99)")
+  99)
+
+;; ── Fibonacci stream ──
+(hk-test
+  "first 10 Fibonacci numbers"
+  (hk-eval-list "take 10 fibs")
+  (list 0 1 1 2 3 5 8 13 21 34))
+(hk-test
+  "fib at position 8"
+  (hk-eval-expr-source "head (drop 8 fibs)")
+  21)
+
+;; ── Building infinite structures in user code ──
+(hk-test
+  "user-defined infinite ones"
+  (hk-prog-val
+    "ones = 1 : ones\nresult = take 6 ones"
+    "result")
+  (list ":" 1 (list ":" 1 (list ":" 1 (list ":" 1 (list ":" 1 (list ":" 1 (list "[]"))))))))
+
+(hk-test
+  "user-defined nats"
+  (hk-prog-val
+    "nats = naturalsFrom 1\nnaturalsFrom n = n : naturalsFrom (n + 1)\nresult = take 5 nats"
+    "result")
+  (list ":" 1 (list ":" 2 (list ":" 3 (list ":" 4 (list ":" 5 (list "[]")))))))
+
+;; ── Range syntax ──
+(hk-test
+  "finite range [1..5]"
+  (hk-eval-list "[1..5]")
+  (list 1 2 3 4 5))
+(hk-test
+  "empty range when from > to"
+  (hk-eval-list "[10..3]")
+  (list))
+(hk-test
+  "stepped range"
+  (hk-eval-list "[1, 3..10]")
+  (list 1 3 5 7 9))
+(hk-test
+  "open range — head"
+  (hk-eval-expr-source "head [1..]")
+  1)
+(hk-test
+  "open range — drop then head"
+  (hk-eval-expr-source "head (drop 99 [1..])")
+  100)
+(hk-test
+  "open range — take 5"
+  (hk-eval-list "take 5 [10..]")
+  (list 10 11 12 13 14))
+
+;; ── Composing Prelude functions ──
+(hk-test
+  "map then filter"
+  (hk-eval-list
+    "filter (\\x -> x > 5) (map (\\x -> x * 2) [1, 2, 3, 4])")
+  (list 6 8))
+
+(hk-test
+  "sum-via-foldless"
+  (hk-prog-val
+    "mySum [] = 0\nmySum (x:xs) = x + mySum xs\nresult = mySum (take 5 (iterate (\\x -> x + 1) 1))"
+    "result")
+  15)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/layout.sx

@@ -0,0 +1,245 @@
+;; Haskell layout-rule tests. hk-tokenizer + hk-layout produce a
+;; virtual-brace-annotated stream; these tests cover the algorithm
+;; from Haskell 98 §10.3 plus the pragmatic let/in single-line rule.
+
+;; Convenience — tokenize, run layout, strip eof, keep :type/:value.
+(define
+  hk-lay
+  (fn
+    (src)
+    (map
+      (fn (tok) {:value (get tok "value") :type (get tok "type")})
+      (filter
+        (fn (tok) (not (= (get tok "type") "eof")))
+        (hk-layout (hk-tokenize src))))))
+
+;; ── 1. Basics ──
+(hk-test
+  "empty input produces empty module { }"
+  (hk-lay "")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "}" :type "vrbrace"}))
+
+(hk-test
+  "single token → module open+close"
+  (hk-lay "foo")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "foo" :type "varid"}
+    {:value "}" :type "vrbrace"}))
+
+(hk-test
+  "two top-level decls get vsemi between"
+  (hk-lay "foo = 1\nbar = 2")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "foo" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value ";" :type "vsemi"}
+    {:value "bar" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 2 :type "integer"}
+    {:value "}" :type "vrbrace"}))
+
+;; ── 2. Layout keywords — do / let / where / of ──
+(hk-test
+  "do block with two stmts"
+  (hk-lay "f = do\n  x\n  y")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "f" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value "do" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "x" :type "varid"}
+    {:value ";" :type "vsemi"}
+    {:value "y" :type "varid"}
+    {:value "}" :type "vrbrace"}
+    {:value "}" :type "vrbrace"}))
+
+(hk-test
+  "single-line let ... in"
+  (hk-lay "let x = 1 in x")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "let" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "x" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value "}" :type "vrbrace"}
+    {:value "in" :type "reserved"}
+    {:value "x" :type "varid"}
+    {:value "}" :type "vrbrace"}))
+
+(hk-test
+  "where block with two bindings"
+  (hk-lay "f = g\n  where\n    g = 1\n    h = 2")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "f" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value "g" :type "varid"}
+    {:value "where" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "g" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value ";" :type "vsemi"}
+    {:value "h" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 2 :type "integer"}
+    {:value "}" :type "vrbrace"}
+    {:value "}" :type "vrbrace"}))
+
+(hk-test
+  "case … of with arms"
+  (hk-lay "f x = case x of\n  Just y -> y\n  Nothing -> 0")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "f" :type "varid"}
+    {:value "x" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value "case" :type "reserved"}
+    {:value "x" :type "varid"}
+    {:value "of" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "Just" :type "conid"}
+    {:value "y" :type "varid"}
+    {:value "->" :type "reservedop"}
+    {:value "y" :type "varid"}
+    {:value ";" :type "vsemi"}
+    {:value "Nothing" :type "conid"}
+    {:value "->" :type "reservedop"}
+    {:value 0 :type "integer"}
+    {:value "}" :type "vrbrace"}
+    {:value "}" :type "vrbrace"}))
+
+;; ── 3. Explicit braces disable layout ──
+(hk-test
+  "explicit braces — no implicit vlbrace/vsemi/vrbrace inside"
+  (hk-lay "do { x ; y }")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "do" :type "reserved"}
+    {:value "{" :type "lbrace"}
+    {:value "x" :type "varid"}
+    {:value ";" :type "semi"}
+    {:value "y" :type "varid"}
+    {:value "}" :type "rbrace"}
+    {:value "}" :type "vrbrace"}))
+
+;; ── 4. Dedent closes nested blocks ──
+(hk-test
+  "dedent back to module level closes do block"
+  (hk-lay "f = do\n  x\n  y\ng = 2")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "f" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value "do" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "x" :type "varid"}
+    {:value ";" :type "vsemi"}
+    {:value "y" :type "varid"}
+    {:value "}" :type "vrbrace"}
+    {:value ";" :type "vsemi"}
+    {:value "g" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 2 :type "integer"}
+    {:value "}" :type "vrbrace"}))
+
+(hk-test
+  "dedent closes inner let, emits vsemi at outer do level"
+  (hk-lay "main = do\n  let x = 1\n  print x")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "main" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value "do" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "let" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "x" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value "}" :type "vrbrace"}
+    {:value ";" :type "vsemi"}
+    {:value "print" :type "varid"}
+    {:value "x" :type "varid"}
+    {:value "}" :type "vrbrace"}
+    {:value "}" :type "vrbrace"}))
+
+;; ── 5. Module header skips outer implicit open ──
+(hk-test
+  "module M where — only where opens a block"
+  (hk-lay "module M where\n  f = 1")
+  (list
+    {:value "module" :type "reserved"}
+    {:value "M" :type "conid"}
+    {:value "where" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "f" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value "}" :type "vrbrace"}))
+
+;; ── 6. Newlines are stripped ──
+(hk-test
+  "newline tokens do not appear in output"
+  (let
+    ((toks (hk-layout (hk-tokenize "foo\nbar"))))
+    (every?
+      (fn (t) (not (= (get t "type") "newline")))
+      toks))
+  true)
+
+;; ── 7. Continuation — deeper indent does NOT emit vsemi ──
+(hk-test
+  "line continuation (deeper indent) just merges"
+  (hk-lay "foo = 1 +\n   2")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "foo" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value "+" :type "varsym"}
+    {:value 2 :type "integer"}
+    {:value "}" :type "vrbrace"}))
+
+;; ── 8. Stack closing at EOF ──
+(hk-test
+  "EOF inside nested do closes all implicit blocks"
+  (let
+    ((toks (hk-lay "main = do\n  do\n    x")))
+    (let
+      ((n (len toks)))
+      (list
+        (get (nth toks (- n 1)) "type")
+        (get (nth toks (- n 2)) "type")
+        (get (nth toks (- n 3)) "type"))))
+  (list "vrbrace" "vrbrace" "vrbrace"))
+
+;; ── 9. Qualified-newline: x at deeper col than stack top does nothing ──
+(hk-test
+  "mixed where + do"
+  (hk-lay "f = do\n    x\n  where\n    x = 1")
+  (list
+    {:value "{" :type "vlbrace"}
+    {:value "f" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value "do" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "x" :type "varid"}
+    {:value "}" :type "vrbrace"}
+    {:value "where" :type "reserved"}
+    {:value "{" :type "vlbrace"}
+    {:value "x" :type "varid"}
+    {:value "=" :type "reservedop"}
+    {:value 1 :type "integer"}
+    {:value "}" :type "vrbrace"}
+    {:value "}" :type "vrbrace"}))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/match.sx

@@ -0,0 +1,256 @@
+;; Pattern-matcher tests. The matcher takes (pat val env) and returns
+;; an extended env dict on success, or `nil` on failure. Constructor
+;; values are tagged lists (con-name first); tuples use the "Tuple"
+;; tag; lists use chained `:` cons with `[]` nil.
+
+;; ── Atomic patterns ──
+(hk-test
+  "wildcard always matches"
+  (hk-match (list :p-wild) 42 (dict))
+  (dict))
+
+(hk-test
+  "var binds value"
+  (hk-match (list :p-var "x") 42 (dict))
+  {:x 42})
+
+(hk-test
+  "var preserves prior env"
+  (hk-match (list :p-var "y") 7 {:x 1})
+  {:x 1 :y 7})
+
+(hk-test
+  "int literal matches equal"
+  (hk-match (list :p-int 5) 5 (dict))
+  (dict))
+
+(hk-test
+  "int literal fails on mismatch"
+  (hk-match (list :p-int 5) 6 (dict))
+  nil)
+
+(hk-test
+  "negative int literal matches"
+  (hk-match (list :p-int -3) -3 (dict))
+  (dict))
+
+(hk-test
+  "string literal matches"
+  (hk-match (list :p-string "hi") "hi" (dict))
+  (dict))
+
+(hk-test
+  "string literal fails"
+  (hk-match (list :p-string "hi") "bye" (dict))
+  nil)
+
+(hk-test
+  "char literal matches"
+  (hk-match (list :p-char "a") "a" (dict))
+  (dict))
+
+;; ── Constructor patterns ──
+(hk-test
+  "0-arity con matches"
+  (hk-match
+    (list :p-con "Nothing" (list))
+    (hk-mk-con "Nothing" (list))
+    (dict))
+  (dict))
+
+(hk-test
+  "1-arity con matches and binds"
+  (hk-match
+    (list :p-con "Just" (list (list :p-var "y")))
+    (hk-mk-con "Just" (list 9))
+    (dict))
+  {:y 9})
+
+(hk-test
+  "con name mismatch fails"
+  (hk-match
+    (list :p-con "Just" (list (list :p-var "y")))
+    (hk-mk-con "Nothing" (list))
+    (dict))
+  nil)
+
+(hk-test
+  "con arity mismatch fails"
+  (hk-match
+    (list :p-con "Pair" (list (list :p-var "a") (list :p-var "b")))
+    (hk-mk-con "Pair" (list 1))
+    (dict))
+  nil)
+
+(hk-test
+  "nested con: Just (Just x)"
+  (hk-match
+    (list
+      :p-con
+      "Just"
+      (list
+        (list
+          :p-con
+          "Just"
+          (list (list :p-var "x")))))
+    (hk-mk-con "Just" (list (hk-mk-con "Just" (list 42))))
+    (dict))
+  {:x 42})
+
+;; ── Tuple patterns ──
+(hk-test
+  "2-tuple matches and binds"
+  (hk-match
+    (list
+      :p-tuple
+      (list (list :p-var "a") (list :p-var "b")))
+    (hk-mk-tuple (list 10 20))
+    (dict))
+  {:a 10 :b 20})
+
+(hk-test
+  "tuple arity mismatch fails"
+  (hk-match
+    (list
+      :p-tuple
+      (list (list :p-var "a") (list :p-var "b")))
+    (hk-mk-tuple (list 10 20 30))
+    (dict))
+  nil)
+
+;; ── List patterns ──
+(hk-test
+  "[] pattern matches empty list"
+  (hk-match (list :p-list (list)) (hk-mk-nil) (dict))
+  (dict))
+
+(hk-test
+  "[] pattern fails on non-empty"
+  (hk-match (list :p-list (list)) (hk-mk-list (list 1)) (dict))
+  nil)
+
+(hk-test
+  "[a] pattern matches singleton"
+  (hk-match
+    (list :p-list (list (list :p-var "a")))
+    (hk-mk-list (list 7))
+    (dict))
+  {:a 7})
+
+(hk-test
+  "[a, b] pattern matches pair-list and binds"
+  (hk-match
+    (list
+      :p-list
+      (list (list :p-var "a") (list :p-var "b")))
+    (hk-mk-list (list 1 2))
+    (dict))
+  {:a 1 :b 2})
+
+(hk-test
+  "[a, b] fails on too-long list"
+  (hk-match
+    (list
+      :p-list
+      (list (list :p-var "a") (list :p-var "b")))
+    (hk-mk-list (list 1 2 3))
+    (dict))
+  nil)
+
+;; Cons-style infix pattern (which the parser produces as :p-con ":")
+(hk-test
+  "cons (h:t) on non-empty list"
+  (hk-match
+    (list
+      :p-con
+      ":"
+      (list (list :p-var "h") (list :p-var "t")))
+    (hk-mk-list (list 1 2 3))
+    (dict))
+  {:h 1 :t (list ":" 2 (list ":" 3 (list "[]")))})
+
+(hk-test
+  "cons fails on empty list"
+  (hk-match
+    (list
+      :p-con
+      ":"
+      (list (list :p-var "h") (list :p-var "t")))
+    (hk-mk-nil)
+    (dict))
+  nil)
+
+;; ── as patterns ──
+(hk-test
+  "as binds whole + sub-pattern"
+  (hk-match
+    (list
+      :p-as
+      "all"
+      (list :p-con "Just" (list (list :p-var "x"))))
+    (hk-mk-con "Just" (list 99))
+    (dict))
+  {:all (list "Just" 99) :x 99})
+
+(hk-test
+  "as on wildcard binds whole"
+  (hk-match
+    (list :p-as "v" (list :p-wild))
+    "anything"
+    (dict))
+  {:v "anything"})
+
+(hk-test
+  "as fails when sub-pattern fails"
+  (hk-match
+    (list
+      :p-as
+      "n"
+      (list :p-con "Just" (list (list :p-var "x"))))
+    (hk-mk-con "Nothing" (list))
+    (dict))
+  nil)
+
+;; ── lazy ~ pattern (eager equivalent for now) ──
+(hk-test
+  "lazy pattern eager-matches its inner"
+  (hk-match
+    (list :p-lazy (list :p-var "y"))
+    42
+    (dict))
+  {:y 42})
+
+;; ── Source-driven: parse a real Haskell pattern, match a value ──
+(hk-test
+  "parsed pattern: Just x against Just 5"
+  (hk-match
+    (hk-parse-pat-source "Just x")
+    (hk-mk-con "Just" (list 5))
+    (dict))
+  {:x 5})
+
+(hk-test
+  "parsed pattern: x : xs against [10, 20, 30]"
+  (hk-match
+    (hk-parse-pat-source "x : xs")
+    (hk-mk-list (list 10 20 30))
+    (dict))
+  {:x 10 :xs (list ":" 20 (list ":" 30 (list "[]")))})
+
+(hk-test
+  "parsed pattern: (a, b) against (1, 2)"
+  (hk-match
+    (hk-parse-pat-source "(a, b)")
+    (hk-mk-tuple (list 1 2))
+    (dict))
+  {:a 1 :b 2})
+
+(hk-test
+  "parsed pattern: n@(Just x) against Just 7"
+  (hk-match
+    (hk-parse-pat-source "n@(Just x)")
+    (hk-mk-con "Just" (list 7))
+    (dict))
+  {:n (list "Just" 7) :x 7})
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parse.sx

@@ -3,60 +3,8 @@
 ;; Lightweight runner: each test checks actual vs expected with
 ;; structural (deep) equality and accumulates pass/fail counters.
 ;; Final value of this file is a summary dict with :pass :fail :fails.
-
-(define
-  hk-deep=?
-  (fn
-    (a b)
-    (cond
-      ((= a b) true)
-      ((and (dict? a) (dict? b))
-        (let
-          ((ak (keys a)) (bk (keys b)))
-          (if
-            (not (= (len ak) (len bk)))
-            false
-            (every?
-              (fn
-                (k)
-                (and (has-key? b k) (hk-deep=? (get a k) (get b k))))
-              ak))))
-      ((and (list? a) (list? b))
-        (if
-          (not (= (len a) (len b)))
-          false
-          (let
-            ((i 0) (ok true))
-            (define
-              hk-de-loop
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (hk-deep=? (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (hk-de-loop)))))
-            (hk-de-loop)
-            ok)))
-      (:else false))))
-
-(define hk-test-pass 0)
-(define hk-test-fail 0)
-(define hk-test-fails (list))
-
-(define
-  hk-test
-  (fn
-    (name actual expected)
-    (if
-      (hk-deep=? actual expected)
-      (set! hk-test-pass (+ hk-test-pass 1))
-      (do
-        (set! hk-test-fail (+ hk-test-fail 1))
-        (append! hk-test-fails {:actual actual :expected expected :name name})))))
+;; The hk-test / hk-deep=? helpers live in lib/haskell/testlib.sx
+;; and are preloaded by lib/haskell/test.sh.
 
 ;; Convenience: tokenize and drop newline + eof tokens so tests focus
 ;; on meaningful content. Returns list of {:type :value} pairs.

lib/haskell/tests/parser-case-do.sx

@@ -0,0 +1,278 @@
+;; case-of and do-notation parser tests.
+;; Covers the minimal patterns needed to make these meaningful: var,
+;; wildcard, literal, constructor (with and without args), tuple, list.
+
+;; ── Patterns (in case arms) ──
+(hk-test
+  "wildcard pat"
+  (hk-parse "case x of _ -> 0")
+  (list
+    :case
+    (list :var "x")
+    (list (list :alt (list :p-wild) (list :int 0)))))
+
+(hk-test
+  "var pat"
+  (hk-parse "case x of y -> y")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list :alt (list :p-var "y") (list :var "y")))))
+
+(hk-test
+  "0-arity constructor pat"
+  (hk-parse "case x of\n  Nothing -> 0\n  Just y -> y")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list :alt (list :p-con "Nothing" (list)) (list :int 0))
+      (list
+        :alt
+        (list :p-con "Just" (list (list :p-var "y")))
+        (list :var "y")))))
+
+(hk-test
+  "int literal pat"
+  (hk-parse "case n of\n  0 -> 1\n  _ -> n")
+  (list
+    :case
+    (list :var "n")
+    (list
+      (list :alt (list :p-int 0) (list :int 1))
+      (list :alt (list :p-wild) (list :var "n")))))
+
+(hk-test
+  "string literal pat"
+  (hk-parse "case s of\n  \"hi\" -> 1\n  _ -> 0")
+  (list
+    :case
+    (list :var "s")
+    (list
+      (list :alt (list :p-string "hi") (list :int 1))
+      (list :alt (list :p-wild) (list :int 0)))))
+
+(hk-test
+  "tuple pat"
+  (hk-parse "case p of (a, b) -> a")
+  (list
+    :case
+    (list :var "p")
+    (list
+      (list
+        :alt
+        (list
+          :p-tuple
+          (list (list :p-var "a") (list :p-var "b")))
+        (list :var "a")))))
+
+(hk-test
+  "list pat"
+  (hk-parse "case xs of\n  [] -> 0\n  [a] -> a")
+  (list
+    :case
+    (list :var "xs")
+    (list
+      (list :alt (list :p-list (list)) (list :int 0))
+      (list
+        :alt
+        (list :p-list (list (list :p-var "a")))
+        (list :var "a")))))
+
+(hk-test
+  "nested constructor pat"
+  (hk-parse "case x of\n  Just (a, b) -> a\n  _ -> 0")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list
+          :p-con
+          "Just"
+          (list
+            (list
+              :p-tuple
+              (list (list :p-var "a") (list :p-var "b")))))
+        (list :var "a"))
+      (list :alt (list :p-wild) (list :int 0)))))
+
+(hk-test
+  "constructor with multiple var args"
+  (hk-parse "case t of Pair a b -> a")
+  (list
+    :case
+    (list :var "t")
+    (list
+      (list
+        :alt
+        (list
+          :p-con
+          "Pair"
+          (list (list :p-var "a") (list :p-var "b")))
+        (list :var "a")))))
+
+;; ── case-of shapes ──
+(hk-test
+  "case with explicit braces"
+  (hk-parse "case x of { Just y -> y ; Nothing -> 0 }")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list :p-con "Just" (list (list :p-var "y")))
+        (list :var "y"))
+      (list :alt (list :p-con "Nothing" (list)) (list :int 0)))))
+
+(hk-test
+  "case scrutinee is a full expression"
+  (hk-parse "case f x + 1 of\n  y -> y")
+  (list
+    :case
+    (list
+      :op
+      "+"
+      (list :app (list :var "f") (list :var "x"))
+      (list :int 1))
+    (list (list :alt (list :p-var "y") (list :var "y")))))
+
+(hk-test
+  "case arm body is full expression"
+  (hk-parse "case x of\n  Just y -> y + 1")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list :p-con "Just" (list (list :p-var "y")))
+        (list :op "+" (list :var "y") (list :int 1))))))
+
+;; ── do blocks ──
+(hk-test
+  "do with two expressions"
+  (hk-parse "do\n  putStrLn \"hi\"\n  return 0")
+  (list
+    :do
+    (list
+      (list
+        :do-expr
+        (list :app (list :var "putStrLn") (list :string "hi")))
+      (list
+        :do-expr
+        (list :app (list :var "return") (list :int 0))))))
+
+(hk-test
+  "do with bind"
+  (hk-parse "do\n  x <- getLine\n  putStrLn x")
+  (list
+    :do
+    (list
+      (list :do-bind (list :p-var "x") (list :var "getLine"))
+      (list
+        :do-expr
+        (list :app (list :var "putStrLn") (list :var "x"))))))
+
+(hk-test
+  "do with let"
+  (hk-parse "do\n  let y = 5\n  print y")
+  (list
+    :do
+    (list
+      (list
+        :do-let
+        (list (list :bind (list :p-var "y") (list :int 5))))
+      (list
+        :do-expr
+        (list :app (list :var "print") (list :var "y"))))))
+
+(hk-test
+  "do with multiple let bindings"
+  (hk-parse "do\n  let x = 1\n      y = 2\n  print (x + y)")
+  (list
+    :do
+    (list
+      (list
+        :do-let
+        (list
+          (list :bind (list :p-var "x") (list :int 1))
+          (list :bind (list :p-var "y") (list :int 2))))
+      (list
+        :do-expr
+        (list
+          :app
+          (list :var "print")
+          (list :op "+" (list :var "x") (list :var "y")))))))
+
+(hk-test
+  "do with bind using constructor pat"
+  (hk-parse "do\n  Just x <- getMaybe\n  return x")
+  (list
+    :do
+    (list
+      (list
+        :do-bind
+        (list :p-con "Just" (list (list :p-var "x")))
+        (list :var "getMaybe"))
+      (list
+        :do-expr
+        (list :app (list :var "return") (list :var "x"))))))
+
+(hk-test
+  "do with explicit braces"
+  (hk-parse "do { x <- a ; y <- b ; return (x + y) }")
+  (list
+    :do
+    (list
+      (list :do-bind (list :p-var "x") (list :var "a"))
+      (list :do-bind (list :p-var "y") (list :var "b"))
+      (list
+        :do-expr
+        (list
+          :app
+          (list :var "return")
+          (list :op "+" (list :var "x") (list :var "y")))))))
+
+;; ── Mixing case/do inside expressions ──
+(hk-test
+  "case inside let"
+  (hk-parse "let f = \\x -> case x of\n                 Just y -> y\n                 _ -> 0\nin f 5")
+  (list
+    :let
+    (list
+      (list
+        :bind
+        (list :p-var "f")
+        (list
+          :lambda
+          (list (list :p-var "x"))
+          (list
+            :case
+            (list :var "x")
+            (list
+              (list
+                :alt
+                (list :p-con "Just" (list (list :p-var "y")))
+                (list :var "y"))
+              (list :alt (list :p-wild) (list :int 0)))))))
+    (list :app (list :var "f") (list :int 5))))
+
+(hk-test
+  "lambda containing do"
+  (hk-parse "\\x -> do\n  y <- x\n  return y")
+  (list
+    :lambda
+    (list (list :p-var "x"))
+    (list
+      :do
+      (list
+        (list :do-bind (list :p-var "y") (list :var "x"))
+        (list
+          :do-expr
+          (list :app (list :var "return") (list :var "y")))))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parser-decls.sx

@@ -0,0 +1,273 @@
+;; Top-level declarations: function clauses, type signatures, data,
+;; type, newtype, fixity. Driven by hk-parse-top which produces
+;; a (:program DECLS) node.
+
+(define
+  hk-prog
+  (fn
+    (&rest decls)
+    (list :program decls)))
+
+;; ── Function clauses & pattern bindings ──
+(hk-test
+  "simple fun-clause"
+  (hk-parse-top "f x = x + 1")
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list :op "+" (list :var "x") (list :int 1)))))
+
+(hk-test
+  "nullary decl"
+  (hk-parse-top "answer = 42")
+  (hk-prog
+    (list :fun-clause "answer" (list) (list :int 42))))
+
+(hk-test
+  "multi-clause fn (separate defs for each pattern)"
+  (hk-parse-top "fact 0 = 1\nfact n = n")
+  (hk-prog
+    (list :fun-clause "fact" (list (list :p-int 0)) (list :int 1))
+    (list
+      :fun-clause
+      "fact"
+      (list (list :p-var "n"))
+      (list :var "n"))))
+
+(hk-test
+  "constructor pattern in fn args"
+  (hk-parse-top "fromJust (Just x) = x")
+  (hk-prog
+    (list
+      :fun-clause
+      "fromJust"
+      (list (list :p-con "Just" (list (list :p-var "x"))))
+      (list :var "x"))))
+
+(hk-test
+  "pattern binding at top level"
+  (hk-parse-top "(a, b) = pair")
+  (hk-prog
+    (list
+      :pat-bind
+      (list
+        :p-tuple
+        (list (list :p-var "a") (list :p-var "b")))
+      (list :var "pair"))))
+
+;; ── Type signatures ──
+(hk-test
+  "single-name sig"
+  (hk-parse-top "f :: Int -> Int")
+  (hk-prog
+    (list
+      :type-sig
+      (list "f")
+      (list :t-fun (list :t-con "Int") (list :t-con "Int")))))
+
+(hk-test
+  "multi-name sig"
+  (hk-parse-top "f, g, h :: Int -> Bool")
+  (hk-prog
+    (list
+      :type-sig
+      (list "f" "g" "h")
+      (list :t-fun (list :t-con "Int") (list :t-con "Bool")))))
+
+(hk-test
+  "sig with type application"
+  (hk-parse-top "f :: Maybe a -> a")
+  (hk-prog
+    (list
+      :type-sig
+      (list "f")
+      (list
+        :t-fun
+        (list :t-app (list :t-con "Maybe") (list :t-var "a"))
+        (list :t-var "a")))))
+
+(hk-test
+  "sig with list type"
+  (hk-parse-top "len :: [a] -> Int")
+  (hk-prog
+    (list
+      :type-sig
+      (list "len")
+      (list
+        :t-fun
+        (list :t-list (list :t-var "a"))
+        (list :t-con "Int")))))
+
+(hk-test
+  "sig with tuple and right-assoc ->"
+  (hk-parse-top "pair :: a -> b -> (a, b)")
+  (hk-prog
+    (list
+      :type-sig
+      (list "pair")
+      (list
+        :t-fun
+        (list :t-var "a")
+        (list
+          :t-fun
+          (list :t-var "b")
+          (list
+            :t-tuple
+            (list (list :t-var "a") (list :t-var "b"))))))))
+
+(hk-test
+  "sig + implementation together"
+  (hk-parse-top "id :: a -> a\nid x = x")
+  (hk-prog
+    (list
+      :type-sig
+      (list "id")
+      (list :t-fun (list :t-var "a") (list :t-var "a")))
+    (list
+      :fun-clause
+      "id"
+      (list (list :p-var "x"))
+      (list :var "x"))))
+
+;; ── data declarations ──
+(hk-test
+  "data Maybe"
+  (hk-parse-top "data Maybe a = Nothing | Just a")
+  (hk-prog
+    (list
+      :data
+      "Maybe"
+      (list "a")
+      (list
+        (list :con-def "Nothing" (list))
+        (list :con-def "Just" (list (list :t-var "a")))))))
+
+(hk-test
+  "data Either"
+  (hk-parse-top "data Either a b = Left a | Right b")
+  (hk-prog
+    (list
+      :data
+      "Either"
+      (list "a" "b")
+      (list
+        (list :con-def "Left" (list (list :t-var "a")))
+        (list :con-def "Right" (list (list :t-var "b")))))))
+
+(hk-test
+  "data with no type parameters"
+  (hk-parse-top "data Bool = True | False")
+  (hk-prog
+    (list
+      :data
+      "Bool"
+      (list)
+      (list
+        (list :con-def "True" (list))
+        (list :con-def "False" (list))))))
+
+(hk-test
+  "recursive data type"
+  (hk-parse-top "data Tree a = Leaf | Node (Tree a) a (Tree a)")
+  (hk-prog
+    (list
+      :data
+      "Tree"
+      (list "a")
+      (list
+        (list :con-def "Leaf" (list))
+        (list
+          :con-def
+          "Node"
+          (list
+            (list :t-app (list :t-con "Tree") (list :t-var "a"))
+            (list :t-var "a")
+            (list :t-app (list :t-con "Tree") (list :t-var "a"))))))))
+
+;; ── type synonyms ──
+(hk-test
+  "simple type synonym"
+  (hk-parse-top "type Name = String")
+  (hk-prog
+    (list :type-syn "Name" (list) (list :t-con "String"))))
+
+(hk-test
+  "parameterised type synonym"
+  (hk-parse-top "type Pair a = (a, a)")
+  (hk-prog
+    (list
+      :type-syn
+      "Pair"
+      (list "a")
+      (list
+        :t-tuple
+        (list (list :t-var "a") (list :t-var "a"))))))
+
+;; ── newtype ──
+(hk-test
+  "newtype"
+  (hk-parse-top "newtype Age = Age Int")
+  (hk-prog (list :newtype "Age" (list) "Age" (list :t-con "Int"))))
+
+(hk-test
+  "parameterised newtype"
+  (hk-parse-top "newtype Wrap a = Wrap a")
+  (hk-prog
+    (list :newtype "Wrap" (list "a") "Wrap" (list :t-var "a"))))
+
+;; ── fixity declarations ──
+(hk-test
+  "infixl with precedence"
+  (hk-parse-top "infixl 5 +:, -:")
+  (hk-prog (list :fixity "l" 5 (list "+:" "-:"))))
+
+(hk-test
+  "infixr"
+  (hk-parse-top "infixr 9 .")
+  (hk-prog (list :fixity "r" 9 (list "."))))
+
+(hk-test
+  "infix (non-assoc) default prec"
+  (hk-parse-top "infix ==")
+  (hk-prog (list :fixity "n" 9 (list "=="))))
+
+(hk-test
+  "fixity with backtick operator name"
+  (hk-parse-top "infixl 7 `div`")
+  (hk-prog (list :fixity "l" 7 (list "div"))))
+
+;; ── Several decls combined ──
+(hk-test
+  "mixed: data + sig + fn + type"
+  (hk-parse-top "data Maybe a = Nothing | Just a\ntype Entry = Maybe Int\nf :: Entry -> Int\nf (Just x) = x\nf Nothing = 0")
+  (hk-prog
+    (list
+      :data
+      "Maybe"
+      (list "a")
+      (list
+        (list :con-def "Nothing" (list))
+        (list :con-def "Just" (list (list :t-var "a")))))
+    (list
+      :type-syn
+      "Entry"
+      (list)
+      (list :t-app (list :t-con "Maybe") (list :t-con "Int")))
+    (list
+      :type-sig
+      (list "f")
+      (list :t-fun (list :t-con "Entry") (list :t-con "Int")))
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-con "Just" (list (list :p-var "x"))))
+      (list :var "x"))
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-con "Nothing" (list)))
+      (list :int 0))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parser-expr.sx

@@ -0,0 +1,258 @@
+;; Haskell expression parser tests.
+;; hk-parse tokenises, runs layout, then parses. Output is an AST
+;; whose head is a keyword tag (evaluates to its string name).
+
+;; ── 1. Literals ──
+(hk-test "integer" (hk-parse "42") (list :int 42))
+(hk-test "float" (hk-parse "3.14") (list :float 3.14))
+(hk-test "string" (hk-parse "\"hi\"") (list :string "hi"))
+(hk-test "char" (hk-parse "'a'") (list :char "a"))
+
+;; ── 2. Variables and constructors ──
+(hk-test "varid" (hk-parse "foo") (list :var "foo"))
+(hk-test "conid" (hk-parse "Nothing") (list :con "Nothing"))
+(hk-test "qvarid" (hk-parse "Data.Map.lookup") (list :var "Data.Map.lookup"))
+(hk-test "qconid" (hk-parse "Data.Map") (list :con "Data.Map"))
+
+;; ── 3. Parens / unit / tuple ──
+(hk-test "parens strip" (hk-parse "(42)") (list :int 42))
+(hk-test "unit" (hk-parse "()") (list :con "()"))
+(hk-test
+  "2-tuple"
+  (hk-parse "(1, 2)")
+  (list :tuple (list (list :int 1) (list :int 2))))
+(hk-test
+  "3-tuple"
+  (hk-parse "(x, y, z)")
+  (list
+    :tuple
+    (list (list :var "x") (list :var "y") (list :var "z"))))
+
+;; ── 4. Lists ──
+(hk-test "empty list" (hk-parse "[]") (list :list (list)))
+(hk-test
+  "singleton list"
+  (hk-parse "[1]")
+  (list :list (list (list :int 1))))
+(hk-test
+  "list of ints"
+  (hk-parse "[1, 2, 3]")
+  (list
+    :list
+    (list (list :int 1) (list :int 2) (list :int 3))))
+(hk-test
+  "range"
+  (hk-parse "[1..10]")
+  (list :range (list :int 1) (list :int 10)))
+(hk-test
+  "range with step"
+  (hk-parse "[1, 3..10]")
+  (list
+    :range-step
+    (list :int 1)
+    (list :int 3)
+    (list :int 10)))
+
+;; ── 5. Application ──
+(hk-test
+  "one-arg app"
+  (hk-parse "f x")
+  (list :app (list :var "f") (list :var "x")))
+(hk-test
+  "multi-arg app is left-assoc"
+  (hk-parse "f x y z")
+  (list
+    :app
+    (list
+      :app
+      (list :app (list :var "f") (list :var "x"))
+      (list :var "y"))
+    (list :var "z")))
+(hk-test
+  "app with con"
+  (hk-parse "Just 5")
+  (list :app (list :con "Just") (list :int 5)))
+
+;; ── 6. Infix operators ──
+(hk-test
+  "simple +"
+  (hk-parse "1 + 2")
+  (list :op "+" (list :int 1) (list :int 2)))
+(hk-test
+  "precedence: * binds tighter than +"
+  (hk-parse "1 + 2 * 3")
+  (list
+    :op
+    "+"
+    (list :int 1)
+    (list :op "*" (list :int 2) (list :int 3))))
+(hk-test
+  "- is left-assoc"
+  (hk-parse "10 - 3 - 2")
+  (list
+    :op
+    "-"
+    (list :op "-" (list :int 10) (list :int 3))
+    (list :int 2)))
+(hk-test
+  ": is right-assoc"
+  (hk-parse "a : b : c")
+  (list
+    :op
+    ":"
+    (list :var "a")
+    (list :op ":" (list :var "b") (list :var "c"))))
+(hk-test
+  "app binds tighter than op"
+  (hk-parse "f x + g y")
+  (list
+    :op
+    "+"
+    (list :app (list :var "f") (list :var "x"))
+    (list :app (list :var "g") (list :var "y"))))
+(hk-test
+  "$ is lowest precedence, right-assoc"
+  (hk-parse "f $ g x")
+  (list
+    :op
+    "$"
+    (list :var "f")
+    (list :app (list :var "g") (list :var "x"))))
+
+;; ── 7. Backticks (varid-as-operator) ──
+(hk-test
+  "backtick operator"
+  (hk-parse "x `mod` 3")
+  (list :op "mod" (list :var "x") (list :int 3)))
+
+;; ── 8. Unary negation ──
+(hk-test
+  "unary -"
+  (hk-parse "- 5")
+  (list :neg (list :int 5)))
+(hk-test
+  "unary - on application"
+  (hk-parse "- f x")
+  (list :neg (list :app (list :var "f") (list :var "x"))))
+(hk-test
+  "- n + m → (- n) + m"
+  (hk-parse "- 1 + 2")
+  (list
+    :op
+    "+"
+    (list :neg (list :int 1))
+    (list :int 2)))
+
+;; ── 9. Lambda ──
+(hk-test
+  "lambda single param"
+  (hk-parse "\\x -> x")
+  (list :lambda (list (list :p-var "x")) (list :var "x")))
+(hk-test
+  "lambda multi-param"
+  (hk-parse "\\x y -> x + y")
+  (list
+    :lambda
+    (list (list :p-var "x") (list :p-var "y"))
+    (list :op "+" (list :var "x") (list :var "y"))))
+(hk-test
+  "lambda body is full expression"
+  (hk-parse "\\f -> f 1 + f 2")
+  (list
+    :lambda
+    (list (list :p-var "f"))
+    (list
+      :op
+      "+"
+      (list :app (list :var "f") (list :int 1))
+      (list :app (list :var "f") (list :int 2)))))
+
+;; ── 10. if-then-else ──
+(hk-test
+  "if basic"
+  (hk-parse "if x then 1 else 2")
+  (list :if (list :var "x") (list :int 1) (list :int 2)))
+(hk-test
+  "if with infix cond"
+  (hk-parse "if x == 0 then y else z")
+  (list
+    :if
+    (list :op "==" (list :var "x") (list :int 0))
+    (list :var "y")
+    (list :var "z")))
+
+;; ── 11. let-in ──
+(hk-test
+  "let single binding"
+  (hk-parse "let x = 1 in x")
+  (list
+    :let
+    (list (list :bind (list :p-var "x") (list :int 1)))
+    (list :var "x")))
+(hk-test
+  "let two bindings (multi-line)"
+  (hk-parse "let x = 1\n    y = 2\nin x + y")
+  (list
+    :let
+    (list
+      (list :bind (list :p-var "x") (list :int 1))
+      (list :bind (list :p-var "y") (list :int 2)))
+    (list :op "+" (list :var "x") (list :var "y"))))
+(hk-test
+  "let with explicit braces"
+  (hk-parse "let { x = 1 ; y = 2 } in x + y")
+  (list
+    :let
+    (list
+      (list :bind (list :p-var "x") (list :int 1))
+      (list :bind (list :p-var "y") (list :int 2)))
+    (list :op "+" (list :var "x") (list :var "y"))))
+
+;; ── 12. Mixed / nesting ──
+(hk-test
+  "nested application"
+  (hk-parse "f (g x) y")
+  (list
+    :app
+    (list
+      :app
+      (list :var "f")
+      (list :app (list :var "g") (list :var "x")))
+    (list :var "y")))
+(hk-test
+  "lambda applied"
+  (hk-parse "(\\x -> x + 1) 5")
+  (list
+    :app
+    (list
+      :lambda
+      (list (list :p-var "x"))
+      (list :op "+" (list :var "x") (list :int 1)))
+    (list :int 5)))
+(hk-test
+  "lambda + if"
+  (hk-parse "\\n -> if n == 0 then 1 else n")
+  (list
+    :lambda
+    (list (list :p-var "n"))
+    (list
+      :if
+      (list :op "==" (list :var "n") (list :int 0))
+      (list :int 1)
+      (list :var "n"))))
+
+;; ── 13. Precedence corners ──
+(hk-test
+  ". is right-assoc (prec 9)"
+  (hk-parse "f . g . h")
+  (list
+    :op
+    "."
+    (list :var "f")
+    (list :op "." (list :var "g") (list :var "h"))))
+(hk-test
+  "== is non-associative (single use)"
+  (hk-parse "x == y")
+  (list :op "==" (list :var "x") (list :var "y")))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parser-guards-where.sx

@@ -0,0 +1,261 @@
+;; Guards and where-clauses — on fun-clauses, case alts, and
+;; let-bindings (which now also accept funclause-style LHS like
+;; `let f x = e` or `let f x | g = e | g = e`).
+
+(define
+  hk-prog
+  (fn (&rest decls) (list :program decls)))
+
+;; ── Guarded fun-clauses ──
+(hk-test
+  "simple guards (two branches)"
+  (hk-parse-top "abs x | x < 0 = - x\n      | otherwise = x")
+  (hk-prog
+    (list
+      :fun-clause
+      "abs"
+      (list (list :p-var "x"))
+      (list
+        :guarded
+        (list
+          (list
+            :guard
+            (list :op "<" (list :var "x") (list :int 0))
+            (list :neg (list :var "x")))
+          (list :guard (list :var "otherwise") (list :var "x")))))))
+
+(hk-test
+  "three-way guard"
+  (hk-parse-top "sign n | n > 0 = 1\n       | n < 0 = -1\n       | otherwise = 0")
+  (hk-prog
+    (list
+      :fun-clause
+      "sign"
+      (list (list :p-var "n"))
+      (list
+        :guarded
+        (list
+          (list
+            :guard
+            (list :op ">" (list :var "n") (list :int 0))
+            (list :int 1))
+          (list
+            :guard
+            (list :op "<" (list :var "n") (list :int 0))
+            (list :neg (list :int 1)))
+          (list
+            :guard
+            (list :var "otherwise")
+            (list :int 0)))))))
+
+(hk-test
+  "mixed: one eq clause plus one guarded clause"
+  (hk-parse-top "sign 0 = 0\nsign n | n > 0 = 1\n       | otherwise = -1")
+  (hk-prog
+    (list
+      :fun-clause
+      "sign"
+      (list (list :p-int 0))
+      (list :int 0))
+    (list
+      :fun-clause
+      "sign"
+      (list (list :p-var "n"))
+      (list
+        :guarded
+        (list
+          (list
+            :guard
+            (list :op ">" (list :var "n") (list :int 0))
+            (list :int 1))
+          (list
+            :guard
+            (list :var "otherwise")
+            (list :neg (list :int 1))))))))
+
+;; ── where on fun-clauses ──
+(hk-test
+  "where with one binding"
+  (hk-parse-top "f x = y + y\n  where y = x + 1")
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :where
+        (list :op "+" (list :var "y") (list :var "y"))
+        (list
+          (list
+            :fun-clause
+            "y"
+            (list)
+            (list :op "+" (list :var "x") (list :int 1))))))))
+
+(hk-test
+  "where with multiple bindings"
+  (hk-parse-top "f x = y * z\n  where y = x + 1\n        z = x - 1")
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :where
+        (list :op "*" (list :var "y") (list :var "z"))
+        (list
+          (list
+            :fun-clause
+            "y"
+            (list)
+            (list :op "+" (list :var "x") (list :int 1)))
+          (list
+            :fun-clause
+            "z"
+            (list)
+            (list :op "-" (list :var "x") (list :int 1))))))))
+
+(hk-test
+  "guards + where"
+  (hk-parse-top "f x | x > 0 = y\n    | otherwise = 0\n  where y = 99")
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :where
+        (list
+          :guarded
+          (list
+            (list
+              :guard
+              (list :op ">" (list :var "x") (list :int 0))
+              (list :var "y"))
+            (list
+              :guard
+              (list :var "otherwise")
+              (list :int 0))))
+        (list
+          (list :fun-clause "y" (list) (list :int 99)))))))
+
+;; ── Guards in case alts ──
+(hk-test
+  "case alt with guards"
+  (hk-parse "case x of\n  Just y | y > 0 -> y\n         | otherwise -> 0\n  Nothing -> 0")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list :p-con "Just" (list (list :p-var "y")))
+        (list
+          :guarded
+          (list
+            (list
+              :guard
+              (list :op ">" (list :var "y") (list :int 0))
+              (list :var "y"))
+            (list
+              :guard
+              (list :var "otherwise")
+              (list :int 0)))))
+      (list :alt (list :p-con "Nothing" (list)) (list :int 0)))))
+
+(hk-test
+  "case alt with where"
+  (hk-parse "case x of\n  Just y -> y + z where z = 5\n  Nothing -> 0")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list :p-con "Just" (list (list :p-var "y")))
+        (list
+          :where
+          (list :op "+" (list :var "y") (list :var "z"))
+          (list
+            (list :fun-clause "z" (list) (list :int 5)))))
+      (list :alt (list :p-con "Nothing" (list)) (list :int 0)))))
+
+;; ── let-bindings: funclause form, guards, where ──
+(hk-test
+  "let with funclause shorthand"
+  (hk-parse "let f x = x + 1 in f 5")
+  (list
+    :let
+    (list
+      (list
+        :fun-clause
+        "f"
+        (list (list :p-var "x"))
+        (list :op "+" (list :var "x") (list :int 1))))
+    (list :app (list :var "f") (list :int 5))))
+
+(hk-test
+  "let with guards"
+  (hk-parse "let f x | x > 0 = x\n        | otherwise = 0\nin f 3")
+  (list
+    :let
+    (list
+      (list
+        :fun-clause
+        "f"
+        (list (list :p-var "x"))
+        (list
+          :guarded
+          (list
+            (list
+              :guard
+              (list :op ">" (list :var "x") (list :int 0))
+              (list :var "x"))
+            (list
+              :guard
+              (list :var "otherwise")
+              (list :int 0))))))
+    (list :app (list :var "f") (list :int 3))))
+
+(hk-test
+  "let funclause + where"
+  (hk-parse "let f x = y where y = x + 1\nin f 7")
+  (list
+    :let
+    (list
+      (list
+        :fun-clause
+        "f"
+        (list (list :p-var "x"))
+        (list
+          :where
+          (list :var "y")
+          (list
+            (list
+              :fun-clause
+              "y"
+              (list)
+              (list :op "+" (list :var "x") (list :int 1)))))))
+    (list :app (list :var "f") (list :int 7))))
+
+;; ── Nested: where inside where (via recursive hk-parse-decl) ──
+(hk-test
+  "where block can contain a type signature"
+  (hk-parse-top "f x = y\n  where y :: Int\n        y = x")
+  (hk-prog
+    (list
+      :fun-clause
+      "f"
+      (list (list :p-var "x"))
+      (list
+        :where
+        (list :var "y")
+        (list
+          (list :type-sig (list "y") (list :t-con "Int"))
+          (list
+            :fun-clause
+            "y"
+            (list)
+            (list :var "x")))))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parser-module.sx

@@ -0,0 +1,202 @@
+;; Module header + imports. The parser switches from (:program DECLS)
+;; to (:module NAME EXPORTS IMPORTS DECLS) as soon as a module header
+;; or any `import` decl appears.
+
+;; ── Module header ──
+(hk-test
+  "simple module, no exports"
+  (hk-parse-top "module M where\n  f = 1")
+  (list
+    :module
+    "M"
+    nil
+    (list)
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "module with dotted name"
+  (hk-parse-top "module Data.Map where\nf = 1")
+  (list
+    :module
+    "Data.Map"
+    nil
+    (list)
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "module with empty export list"
+  (hk-parse-top "module M () where\nf = 1")
+  (list
+    :module
+    "M"
+    (list)
+    (list)
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "module with exports (var, tycon-all, tycon-with)"
+  (hk-parse-top "module M (f, g, Maybe(..), List(Cons, Nil)) where\nf = 1\ng = 2")
+  (list
+    :module
+    "M"
+    (list
+      (list :ent-var "f")
+      (list :ent-var "g")
+      (list :ent-all "Maybe")
+      (list :ent-with "List" (list "Cons" "Nil")))
+    (list)
+    (list
+      (list :fun-clause "f" (list) (list :int 1))
+      (list :fun-clause "g" (list) (list :int 2)))))
+
+(hk-test
+  "module export list including another module"
+  (hk-parse-top "module M (module Foo, f) where\nf = 1")
+  (list
+    :module
+    "M"
+    (list (list :ent-module "Foo") (list :ent-var "f"))
+    (list)
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "module export with operator"
+  (hk-parse-top "module M ((+:), f) where\nf = 1")
+  (list
+    :module
+    "M"
+    (list (list :ent-var "+:") (list :ent-var "f"))
+    (list)
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "empty module body"
+  (hk-parse-top "module M where")
+  (list :module "M" nil (list) (list)))
+
+;; ── Imports ──
+(hk-test
+  "plain import"
+  (hk-parse-top "import Foo")
+  (list
+    :module
+    nil
+    nil
+    (list (list :import false "Foo" nil nil))
+    (list)))
+
+(hk-test
+  "qualified import"
+  (hk-parse-top "import qualified Data.Map")
+  (list
+    :module
+    nil
+    nil
+    (list (list :import true "Data.Map" nil nil))
+    (list)))
+
+(hk-test
+  "import with alias"
+  (hk-parse-top "import Data.Map as M")
+  (list
+    :module
+    nil
+    nil
+    (list (list :import false "Data.Map" "M" nil))
+    (list)))
+
+(hk-test
+  "import with explicit list"
+  (hk-parse-top "import Foo (bar, Baz(..), Quux(X, Y))")
+  (list
+    :module
+    nil
+    nil
+    (list
+      (list
+        :import
+        false
+        "Foo"
+        nil
+        (list
+          :spec-items
+          (list
+            (list :ent-var "bar")
+            (list :ent-all "Baz")
+            (list :ent-with "Quux" (list "X" "Y"))))))
+    (list)))
+
+(hk-test
+  "import hiding"
+  (hk-parse-top "import Foo hiding (x, y)")
+  (list
+    :module
+    nil
+    nil
+    (list
+      (list
+        :import
+        false
+        "Foo"
+        nil
+        (list
+          :spec-hiding
+          (list (list :ent-var "x") (list :ent-var "y")))))
+    (list)))
+
+(hk-test
+  "qualified + alias + hiding"
+  (hk-parse-top "import qualified Data.List as L hiding (sort)")
+  (list
+    :module
+    nil
+    nil
+    (list
+      (list
+        :import
+        true
+        "Data.List"
+        "L"
+        (list :spec-hiding (list (list :ent-var "sort")))))
+    (list)))
+
+;; ── Combinations ──
+(hk-test
+  "module with multiple imports and a decl"
+  (hk-parse-top "module M where\nimport Foo\nimport qualified Bar as B\nf = 1")
+  (list
+    :module
+    "M"
+    nil
+    (list
+      (list :import false "Foo" nil nil)
+      (list :import true "Bar" "B" nil))
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "headerless file with imports"
+  (hk-parse-top "import Foo\nimport Bar (baz)\nf = 1")
+  (list
+    :module
+    nil
+    nil
+    (list
+      (list :import false "Foo" nil nil)
+      (list
+        :import
+        false
+        "Bar"
+        nil
+        (list :spec-items (list (list :ent-var "baz")))))
+    (list (list :fun-clause "f" (list) (list :int 1)))))
+
+(hk-test
+  "plain program (no header, no imports) still uses :program"
+  (hk-parse-top "f = 1\ng = 2")
+  (list
+    :program
+    (list
+      (list :fun-clause "f" (list) (list :int 1))
+      (list :fun-clause "g" (list) (list :int 2)))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parser-patterns.sx

@@ -0,0 +1,234 @@
+;; Full-pattern parser tests: as-patterns, lazy ~, negative literals,
+;; infix constructor patterns (`:`, any consym), lambda pattern args,
+;; and let pattern-bindings.
+
+;; ── as-patterns ──
+(hk-test
+  "as pattern, wraps constructor"
+  (hk-parse "case x of n@(Just y) -> n")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list
+          :p-as
+          "n"
+          (list :p-con "Just" (list (list :p-var "y"))))
+        (list :var "n")))))
+
+(hk-test
+  "as pattern, wraps wildcard"
+  (hk-parse "case x of all@_ -> all")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list
+        :alt
+        (list :p-as "all" (list :p-wild))
+        (list :var "all")))))
+
+(hk-test
+  "as in lambda"
+  (hk-parse "\\xs@(a : rest) -> xs")
+  (list
+    :lambda
+    (list
+      (list
+        :p-as
+        "xs"
+        (list
+          :p-con
+          ":"
+          (list (list :p-var "a") (list :p-var "rest")))))
+    (list :var "xs")))
+
+;; ── lazy patterns ──
+(hk-test
+  "lazy var"
+  (hk-parse "case x of ~y -> y")
+  (list
+    :case
+    (list :var "x")
+    (list
+      (list :alt (list :p-lazy (list :p-var "y")) (list :var "y")))))
+
+(hk-test
+  "lazy constructor"
+  (hk-parse "\\(~(Just x)) -> x")
+  (list
+    :lambda
+    (list
+      (list
+        :p-lazy
+        (list :p-con "Just" (list (list :p-var "x")))))
+    (list :var "x")))
+
+;; ── negative literal patterns ──
+(hk-test
+  "negative int pattern"
+  (hk-parse "case n of\n  -1 -> 0\n  _ -> n")
+  (list
+    :case
+    (list :var "n")
+    (list
+      (list :alt (list :p-int -1) (list :int 0))
+      (list :alt (list :p-wild) (list :var "n")))))
+
+(hk-test
+  "negative float pattern"
+  (hk-parse "case x of -0.5 -> 1")
+  (list
+    :case
+    (list :var "x")
+    (list (list :alt (list :p-float -0.5) (list :int 1)))))
+
+;; ── infix constructor patterns (`:` and any consym) ──
+(hk-test
+  "cons pattern"
+  (hk-parse "case xs of x : rest -> x")
+  (list
+    :case
+    (list :var "xs")
+    (list
+      (list
+        :alt
+        (list
+          :p-con
+          ":"
+          (list (list :p-var "x") (list :p-var "rest")))
+        (list :var "x")))))
+
+(hk-test
+  "cons is right-associative in pats"
+  (hk-parse "case xs of a : b : rest -> rest")
+  (list
+    :case
+    (list :var "xs")
+    (list
+      (list
+        :alt
+        (list
+          :p-con
+          ":"
+          (list
+            (list :p-var "a")
+            (list
+              :p-con
+              ":"
+              (list (list :p-var "b") (list :p-var "rest")))))
+        (list :var "rest")))))
+
+(hk-test
+  "consym pattern"
+  (hk-parse "case p of a :+: b -> a")
+  (list
+    :case
+    (list :var "p")
+    (list
+      (list
+        :alt
+        (list
+          :p-con
+          ":+:"
+          (list (list :p-var "a") (list :p-var "b")))
+        (list :var "a")))))
+
+;; ── lambda with pattern args ──
+(hk-test
+  "lambda with constructor pattern"
+  (hk-parse "\\(Just x) -> x")
+  (list
+    :lambda
+    (list (list :p-con "Just" (list (list :p-var "x"))))
+    (list :var "x")))
+
+(hk-test
+  "lambda with tuple pattern"
+  (hk-parse "\\(a, b) -> a + b")
+  (list
+    :lambda
+    (list
+      (list
+        :p-tuple
+        (list (list :p-var "a") (list :p-var "b"))))
+    (list :op "+" (list :var "a") (list :var "b"))))
+
+(hk-test
+  "lambda with wildcard"
+  (hk-parse "\\_ -> 42")
+  (list :lambda (list (list :p-wild)) (list :int 42)))
+
+(hk-test
+  "lambda with mixed apats"
+  (hk-parse "\\x _ (Just y) -> y")
+  (list
+    :lambda
+    (list
+      (list :p-var "x")
+      (list :p-wild)
+      (list :p-con "Just" (list (list :p-var "y"))))
+    (list :var "y")))
+
+;; ── let pattern-bindings ──
+(hk-test
+  "let tuple pattern-binding"
+  (hk-parse "let (x, y) = pair in x + y")
+  (list
+    :let
+    (list
+      (list
+        :bind
+        (list
+          :p-tuple
+          (list (list :p-var "x") (list :p-var "y")))
+        (list :var "pair")))
+    (list :op "+" (list :var "x") (list :var "y"))))
+
+(hk-test
+  "let constructor pattern-binding"
+  (hk-parse "let Just x = m in x")
+  (list
+    :let
+    (list
+      (list
+        :bind
+        (list :p-con "Just" (list (list :p-var "x")))
+        (list :var "m")))
+    (list :var "x")))
+
+(hk-test
+  "let cons pattern-binding"
+  (hk-parse "let (x : rest) = xs in x")
+  (list
+    :let
+    (list
+      (list
+        :bind
+        (list
+          :p-con
+          ":"
+          (list (list :p-var "x") (list :p-var "rest")))
+        (list :var "xs")))
+    (list :var "x")))
+
+;; ── do with constructor-pattern binds ──
+(hk-test
+  "do bind to tuple pattern"
+  (hk-parse "do\n  (a, b) <- pairs\n  return a")
+  (list
+    :do
+    (list
+      (list
+        :do-bind
+        (list
+          :p-tuple
+          (list (list :p-var "a") (list :p-var "b")))
+        (list :var "pairs"))
+      (list
+        :do-expr
+        (list :app (list :var "return") (list :var "a"))))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/parser-sect-comp.sx

@@ -0,0 +1,191 @@
+;; Operator sections and list comprehensions.
+
+;; ── Operator references (unchanged expr shape) ──
+(hk-test
+  "op as value (+)"
+  (hk-parse "(+)")
+  (list :var "+"))
+
+(hk-test
+  "op as value (-)"
+  (hk-parse "(-)")
+  (list :var "-"))
+
+(hk-test
+  "op as value (:)"
+  (hk-parse "(:)")
+  (list :var ":"))
+
+(hk-test
+  "backtick op as value"
+  (hk-parse "(`div`)")
+  (list :var "div"))
+
+;; ── Right sections (op expr) ──
+(hk-test
+  "right section (+ 5)"
+  (hk-parse "(+ 5)")
+  (list :sect-right "+" (list :int 5)))
+
+(hk-test
+  "right section (* x)"
+  (hk-parse "(* x)")
+  (list :sect-right "*" (list :var "x")))
+
+(hk-test
+  "right section with backtick op"
+  (hk-parse "(`div` 2)")
+  (list :sect-right "div" (list :int 2)))
+
+;; `-` is unary in expr position — (- 5) is negation, not a right section
+(hk-test
+  "(- 5) is negation, not a section"
+  (hk-parse "(- 5)")
+  (list :neg (list :int 5)))
+
+;; ── Left sections (expr op) ──
+(hk-test
+  "left section (5 +)"
+  (hk-parse "(5 +)")
+  (list :sect-left "+" (list :int 5)))
+
+(hk-test
+  "left section with backtick"
+  (hk-parse "(x `mod`)")
+  (list :sect-left "mod" (list :var "x")))
+
+(hk-test
+  "left section with cons (x :)"
+  (hk-parse "(x :)")
+  (list :sect-left ":" (list :var "x")))
+
+;; ── Mixed / nesting ──
+(hk-test
+  "map (+ 1) xs"
+  (hk-parse "map (+ 1) xs")
+  (list
+    :app
+    (list
+      :app
+      (list :var "map")
+      (list :sect-right "+" (list :int 1)))
+    (list :var "xs")))
+
+(hk-test
+  "filter (< 0) xs"
+  (hk-parse "filter (< 0) xs")
+  (list
+    :app
+    (list
+      :app
+      (list :var "filter")
+      (list :sect-right "<" (list :int 0)))
+    (list :var "xs")))
+
+;; ── Plain parens and tuples still work ──
+(hk-test
+  "plain parens unwrap"
+  (hk-parse "(1 + 2)")
+  (list :op "+" (list :int 1) (list :int 2)))
+
+(hk-test
+  "tuple still parses"
+  (hk-parse "(a, b, c)")
+  (list
+    :tuple
+    (list (list :var "a") (list :var "b") (list :var "c"))))
+
+;; ── List comprehensions ──
+(hk-test
+  "simple list comprehension"
+  (hk-parse "[x | x <- xs]")
+  (list
+    :list-comp
+    (list :var "x")
+    (list
+      (list :q-gen (list :p-var "x") (list :var "xs")))))
+
+(hk-test
+  "comprehension with filter"
+  (hk-parse "[x * 2 | x <- xs, x > 0]")
+  (list
+    :list-comp
+    (list :op "*" (list :var "x") (list :int 2))
+    (list
+      (list :q-gen (list :p-var "x") (list :var "xs"))
+      (list
+        :q-guard
+        (list :op ">" (list :var "x") (list :int 0))))))
+
+(hk-test
+  "comprehension with let"
+  (hk-parse "[y | x <- xs, let y = x + 1]")
+  (list
+    :list-comp
+    (list :var "y")
+    (list
+      (list :q-gen (list :p-var "x") (list :var "xs"))
+      (list
+        :q-let
+        (list
+          (list
+            :bind
+            (list :p-var "y")
+            (list :op "+" (list :var "x") (list :int 1))))))))
+
+(hk-test
+  "nested generators"
+  (hk-parse "[(x, y) | x <- xs, y <- ys]")
+  (list
+    :list-comp
+    (list :tuple (list (list :var "x") (list :var "y")))
+    (list
+      (list :q-gen (list :p-var "x") (list :var "xs"))
+      (list :q-gen (list :p-var "y") (list :var "ys")))))
+
+(hk-test
+  "comprehension with constructor pattern"
+  (hk-parse "[v | Just v <- xs]")
+  (list
+    :list-comp
+    (list :var "v")
+    (list
+      (list
+        :q-gen
+        (list :p-con "Just" (list (list :p-var "v")))
+        (list :var "xs")))))
+
+(hk-test
+  "comprehension with tuple pattern"
+  (hk-parse "[x + y | (x, y) <- pairs]")
+  (list
+    :list-comp
+    (list :op "+" (list :var "x") (list :var "y"))
+    (list
+      (list
+        :q-gen
+        (list
+          :p-tuple
+          (list (list :p-var "x") (list :p-var "y")))
+        (list :var "pairs")))))
+
+(hk-test
+  "combination: generator, let, guard"
+  (hk-parse "[z | x <- xs, let z = x * 2, z > 10]")
+  (list
+    :list-comp
+    (list :var "z")
+    (list
+      (list :q-gen (list :p-var "x") (list :var "xs"))
+      (list
+        :q-let
+        (list
+          (list
+            :bind
+            (list :p-var "z")
+            (list :op "*" (list :var "x") (list :int 2)))))
+      (list
+        :q-guard
+        (list :op ">" (list :var "z") (list :int 10))))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-calculator.sx

@@ -0,0 +1,55 @@
+;; calculator.hs — recursive descent expression evaluator.
+;;
+;; Exercises:
+;;   - ADTs with constructor fields: TNum Int, TOp String, R Int [Token]
+;;   - Nested constructor pattern matching: (R v (TOp "+":rest))
+;;   - let bindings in function bodies
+;;   - Integer arithmetic including `div` (backtick infix)
+;;   - Left-associative multi-level operator precedence
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define
+  hk-calc-src
+  "data Token = TNum Int | TOp String\ndata Result = R Int [Token]\ngetV (R v _) = v\ngetR (R _ r) = r\neval ts = getV (parseExpr ts)\nparseExpr ts = parseExprRest (parseTerm ts)\nparseExprRest (R v (TOp \"+\":rest)) =\n  let t = parseTerm rest\n  in parseExprRest (R (v + getV t) (getR t))\nparseExprRest (R v (TOp \"-\":rest)) =\n  let t = parseTerm rest\n  in parseExprRest (R (v - getV t) (getR t))\nparseExprRest r = r\nparseTerm ts = parseTermRest (parseFactor ts)\nparseTermRest (R v (TOp \"*\":rest)) =\n  let t = parseFactor rest\n  in parseTermRest (R (v * getV t) (getR t))\nparseTermRest (R v (TOp \"/\":rest)) =\n  let t = parseFactor rest\n  in parseTermRest (R (v `div` getV t) (getR t))\nparseTermRest r = r\nparseFactor (TNum n:rest) = R n rest\n")
+
+(hk-test
+  "calculator: 2 + 3 = 5"
+  (hk-prog-val
+    (str hk-calc-src "result = eval [TNum 2, TOp \"+\", TNum 3]\n")
+    "result")
+  5)
+
+(hk-test
+  "calculator: 2 + 3 * 4 = 14 (precedence)"
+  (hk-prog-val
+    (str hk-calc-src "result = eval [TNum 2, TOp \"+\", TNum 3, TOp \"*\", TNum 4]\n")
+    "result")
+  14)
+
+(hk-test
+  "calculator: 10 - 3 - 2 = 5 (left-assoc)"
+  (hk-prog-val
+    (str hk-calc-src "result = eval [TNum 10, TOp \"-\", TNum 3, TOp \"-\", TNum 2]\n")
+    "result")
+  5)
+
+(hk-test
+  "calculator: 6 / 2 * 3 = 9 (left-assoc)"
+  (hk-prog-val
+    (str hk-calc-src "result = eval [TNum 6, TOp \"/\", TNum 2, TOp \"*\", TNum 3]\n")
+    "result")
+  9)
+
+(hk-test
+  "calculator: single number"
+  (hk-prog-val
+    (str hk-calc-src "result = eval [TNum 42]\n")
+    "result")
+  42)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-fib.sx

@@ -0,0 +1,45 @@
+;; fib.hs — infinite Fibonacci stream classic program.
+;;
+;; The canonical artefact lives at lib/haskell/tests/programs/fib.hs.
+;; The source is mirrored here as an SX string because the evaluator
+;; doesn't have read-file in the default env. If you change one, keep
+;; the other in sync — there's a runner-level cross-check against the
+;; expected first-15 list.
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define hk-as-list
+  (fn (xs)
+    (cond
+      ((and (list? xs) (= (first xs) "[]")) (list))
+      ((and (list? xs) (= (first xs) ":"))
+        (cons (nth xs 1) (hk-as-list (nth xs 2))))
+      (:else xs))))
+
+(define
+  hk-fib-source
+  "zipPlus (x:xs) (y:ys) = x + y : zipPlus xs ys
+zipPlus _ _ = []
+myFibs = 0 : 1 : zipPlus myFibs (tail myFibs)
+result = take 15 myFibs
+")
+
+(hk-test
+  "fib.hs — first 15 Fibonacci numbers"
+  (hk-as-list (hk-prog-val hk-fib-source "result"))
+  (list 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377))
+
+;; Spot-check that the user-defined zipPlus is also reachable
+(hk-test
+  "fib.hs — zipPlus is a multi-clause user fn"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-fib-source "extra = zipPlus [1, 2, 3] [10, 20, 30]\n")
+      "extra"))
+  (list 11 22 33))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-nqueens.sx

@@ -0,0 +1,38 @@
+;; nqueens.hs — n-queens solver via list comprehension + where.
+;;
+;; Also exercises:
+;;   - multi-clause let/where binding (go 0 = ...; go k = ...)
+;;   - list comprehensions (desugared to concatMap)
+;;   - abs (from Prelude)
+;;   - [1..n] finite range
+;;
+;; n=8 is too slow for a 60s timeout; n=4 and n=5 run in ~17s combined.
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define
+  hk-nq-base
+  "queens n = go n
+  where
+    go 0 = [[]]
+    go k = [q:qs | qs <- go (k - 1), q <- [1..n], safe q qs]
+safe q qs = check q qs 1
+check q [] _ = True
+check q (c:cs) d = q /= c && abs (q - c) /= d && check q cs (d + 1)
+")
+
+(hk-test
+  "nqueens: queens 4 has 2 solutions"
+  (hk-prog-val (str hk-nq-base "result = length (queens 4)\n") "result")
+  2)
+
+(hk-test
+  "nqueens: queens 5 has 10 solutions"
+  (hk-prog-val (str hk-nq-base "result = length (queens 5)\n") "result")
+  10)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-quicksort.sx

@@ -0,0 +1,65 @@
+;; quicksort.hs — naive functional quicksort.
+
+(define
+  hk-as-list
+  (fn (xs)
+    (cond
+      ((and (list? xs) (= (first xs) "[]")) (list))
+      ((and (list? xs) (= (first xs) ":"))
+        (cons (nth xs 1) (hk-as-list (nth xs 2))))
+      (:else xs))))
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define
+  hk-qs-source
+  "qsort [] = []
+qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
+  where
+    smaller = filter (< x) xs
+    larger  = filter (>= x) xs
+result = qsort [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
+")
+
+(hk-test
+  "quicksort.hs — sort a list of ints"
+  (hk-as-list (hk-prog-val hk-qs-source "result"))
+  (list 1 1 2 3 3 4 5 5 5 6 9))
+
+(hk-test
+  "quicksort.hs — empty list"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "e = qsort []\n")
+      "e"))
+  (list))
+
+(hk-test
+  "quicksort.hs — singleton"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "s = qsort [42]\n")
+      "s"))
+  (list 42))
+
+(hk-test
+  "quicksort.hs — already sorted"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "asc = qsort [1, 2, 3, 4, 5]\n")
+      "asc"))
+  (list 1 2 3 4 5))
+
+(hk-test
+  "quicksort.hs — reverse sorted"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "desc = qsort [5, 4, 3, 2, 1]\n")
+      "desc"))
+  (list 1 2 3 4 5))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-sieve.sx

@@ -0,0 +1,48 @@
+;; sieve.hs — lazy sieve of Eratosthenes.
+;;
+;; The canonical artefact lives at lib/haskell/tests/programs/sieve.hs.
+;; Mirrored here as an SX string because the default eval env has no
+;; read-file. Uses filter + backtick `mod` + lazy [2..] — all of which
+;; are now wired in via Phase 3 + the mod/div additions to hk-binop.
+
+(define
+  hk-as-list
+  (fn (xs)
+    (cond
+      ((and (list? xs) (= (first xs) "[]")) (list))
+      ((and (list? xs) (= (first xs) ":"))
+        (cons (nth xs 1) (hk-as-list (nth xs 2))))
+      (:else xs))))
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define
+  hk-sieve-source
+  "sieve (p:xs) = p : sieve (filter (\\x -> x `mod` p /= 0) xs)
+sieve [] = []
+primes = sieve [2..]
+result = take 10 primes
+")
+
+(hk-test
+  "sieve.hs — first 10 primes"
+  (hk-as-list (hk-prog-val hk-sieve-source "result"))
+  (list 2 3 5 7 11 13 17 19 23 29))
+
+(hk-test
+  "sieve.hs — 20th prime is 71"
+  (nth
+    (hk-as-list
+      (hk-prog-val
+        (str
+          hk-sieve-source
+          "result20 = take 20 primes\n")
+        "result20"))
+    19)
+  71)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/programs/calculator.hs

@@ -0,0 +1,40 @@
+-- calculator.hs — recursive descent expression evaluator.
+--
+-- Tokens are represented as an ADT; the parser threads a [Token] list
+-- through a custom Result type so pattern matching can destructure the
+-- pair (value, remaining-tokens) directly inside constructor patterns.
+--
+-- Operator precedence: * and / bind tighter than + and -.
+-- All operators are left-associative.
+
+data Token = TNum Int | TOp String
+data Result = R Int [Token]
+
+getV (R v _) = v
+getR (R _ r) = r
+
+eval ts = getV (parseExpr ts)
+
+parseExpr ts = parseExprRest (parseTerm ts)
+
+parseExprRest (R v (TOp "+":rest)) =
+  let t = parseTerm rest
+  in parseExprRest (R (v + getV t) (getR t))
+parseExprRest (R v (TOp "-":rest)) =
+  let t = parseTerm rest
+  in parseExprRest (R (v - getV t) (getR t))
+parseExprRest r = r
+
+parseTerm ts = parseTermRest (parseFactor ts)
+
+parseTermRest (R v (TOp "*":rest)) =
+  let t = parseFactor rest
+  in parseTermRest (R (v * getV t) (getR t))
+parseTermRest (R v (TOp "/":rest)) =
+  let t = parseFactor rest
+  in parseTermRest (R (v `div` getV t) (getR t))
+parseTermRest r = r
+
+parseFactor (TNum n:rest) = R n rest
+
+result = eval [TNum 2, TOp "+", TNum 3, TOp "*", TNum 4]

lib/haskell/tests/programs/fib.hs

@@ -0,0 +1,15 @@
+-- fib.hs — infinite Fibonacci stream.
+--
+-- The classic two-line definition: `fibs` is a self-referential
+-- lazy list built by zipping itself with its own tail, summing the
+-- pair at each step. Without lazy `:` (cons cell with thunked head
+-- and tail) this would diverge before producing any output; with
+-- it, `take 15 fibs` evaluates exactly as much of the spine as
+-- demanded.
+
+zipPlus (x:xs) (y:ys) = x + y : zipPlus xs ys
+zipPlus _ _ = []
+
+myFibs = 0 : 1 : zipPlus myFibs (tail myFibs)
+
+result = take 15 myFibs

lib/haskell/tests/programs/nqueens.hs

@@ -0,0 +1,18 @@
+-- nqueens.hs — n-queens backtracking solver.
+--
+-- `queens n` returns all solutions as lists of column positions,
+-- one per row. Each call to `go k` extends all partial `(k-1)`-row
+-- solutions by one safe queen, using a list comprehension whose guard
+-- checks the new queen against all already-placed queens.
+
+queens n = go n
+  where
+    go 0 = [[]]
+    go k = [q:qs | qs <- go (k - 1), q <- [1..n], safe q qs]
+
+safe q qs = check q qs 1
+
+check q [] _     = True
+check q (c:cs) d = q /= c && abs (q - c) /= d && check q cs (d + 1)
+
+result = length (queens 8)

lib/haskell/tests/programs/quicksort.hs

@@ -0,0 +1,12 @@
+-- quicksort.hs — naive functional quicksort.
+--
+-- Partition by pivot, recurse on each half, concatenate.
+-- Uses right sections `(< x)` and `(>= x)` with filter.
+
+qsort [] = []
+qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
+  where
+    smaller = filter (< x) xs
+    larger  = filter (>= x) xs
+
+result = qsort [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

lib/haskell/tests/programs/sieve.hs

@@ -0,0 +1,13 @@
+-- sieve.hs — lazy sieve of Eratosthenes.
+--
+-- Each recursive call to `sieve` consumes one prime `p` off the front
+-- of the input stream and produces an infinite stream of composites
+-- filtered out via `filter`. Because cons is lazy, only as much of
+-- the stream is forced as demanded by `take`.
+
+sieve (p:xs) = p : sieve (filter (\x -> x `mod` p /= 0) xs)
+sieve [] = []
+
+primes = sieve [2..]
+
+result = take 10 primes

lib/haskell/tests/runtime.sx

@@ -0,0 +1,127 @@
+;; Runtime constructor-registry tests. Built-ins are pre-registered
+;; when lib/haskell/runtime.sx loads; user types are registered by
+;; walking a parsed+desugared AST with hk-register-program! (or the
+;; `hk-load-source!` convenience).
+
+;; ── Pre-registered built-ins ──
+(hk-test "True is a con" (hk-is-con? "True") true)
+(hk-test "False is a con" (hk-is-con? "False") true)
+(hk-test "[] is a con" (hk-is-con? "[]") true)
+(hk-test ": (cons) is a con" (hk-is-con? ":") true)
+(hk-test "() is a con" (hk-is-con? "()") true)
+
+(hk-test "True arity 0" (hk-con-arity "True") 0)
+(hk-test ": arity 2" (hk-con-arity ":") 2)
+(hk-test "[] arity 0" (hk-con-arity "[]") 0)
+(hk-test "True type Bool" (hk-con-type "True") "Bool")
+(hk-test "False type Bool" (hk-con-type "False") "Bool")
+(hk-test ": type List" (hk-con-type ":") "List")
+(hk-test "() type Unit" (hk-con-type "()") "Unit")
+
+;; ── Unknown names ──
+(hk-test "is-con? false for varid" (hk-is-con? "foo") false)
+(hk-test "arity nil for unknown" (hk-con-arity "NotACon") nil)
+(hk-test "type nil for unknown" (hk-con-type "NotACon") nil)
+
+;; ── data MyBool = Yes | No ──
+(hk-test
+  "register simple data"
+  (do
+    (hk-load-source! "data MyBool = Yes | No")
+    (list
+      (hk-con-arity "Yes")
+      (hk-con-arity "No")
+      (hk-con-type "Yes")
+      (hk-con-type "No")))
+  (list 0 0 "MyBool" "MyBool"))
+
+;; ── data Maybe a = Nothing | Just a ──
+(hk-test
+  "register Maybe"
+  (do
+    (hk-load-source! "data Maybe a = Nothing | Just a")
+    (list
+      (hk-con-arity "Nothing")
+      (hk-con-arity "Just")
+      (hk-con-type "Nothing")
+      (hk-con-type "Just")))
+  (list 0 1 "Maybe" "Maybe"))
+
+;; ── data Either a b = Left a | Right b ──
+(hk-test
+  "register Either"
+  (do
+    (hk-load-source! "data Either a b = Left a | Right b")
+    (list
+      (hk-con-arity "Left")
+      (hk-con-arity "Right")
+      (hk-con-type "Left")
+      (hk-con-type "Right")))
+  (list 1 1 "Either" "Either"))
+
+;; ── Recursive data ──
+(hk-test
+  "register recursive Tree"
+  (do
+    (hk-load-source!
+      "data Tree a = Leaf | Node (Tree a) a (Tree a)")
+    (list
+      (hk-con-arity "Leaf")
+      (hk-con-arity "Node")
+      (hk-con-type "Leaf")
+      (hk-con-type "Node")))
+  (list 0 3 "Tree" "Tree"))
+
+;; ── newtype ──
+(hk-test
+  "register newtype"
+  (do
+    (hk-load-source! "newtype Age = MkAge Int")
+    (list
+      (hk-con-arity "MkAge")
+      (hk-con-type "MkAge")))
+  (list 1 "Age"))
+
+;; ── Multiple data decls in one program ──
+(hk-test
+  "multiple data decls"
+  (do
+    (hk-load-source!
+      "data Color = Red | Green | Blue\ndata Shape = Circle | Square\nf x = x")
+    (list
+      (hk-con-type "Red")
+      (hk-con-type "Green")
+      (hk-con-type "Blue")
+      (hk-con-type "Circle")
+      (hk-con-type "Square")))
+  (list "Color" "Color" "Color" "Shape" "Shape"))
+
+;; ── Inside a module header ──
+(hk-test
+  "register from module body"
+  (do
+    (hk-load-source!
+      "module M where\ndata Pair a = Pair a a")
+    (list
+      (hk-con-arity "Pair")
+      (hk-con-type "Pair")))
+  (list 2 "Pair"))
+
+;; ── Non-data decls are ignored ──
+(hk-test
+  "program with only fun-decl leaves registry unchanged for that name"
+  (do
+    (hk-load-source! "myFunctionNotACon x = x + 1")
+    (hk-is-con? "myFunctionNotACon"))
+  false)
+
+;; ── Re-registering overwrites (last wins) ──
+(hk-test
+  "re-registration overwrites the entry"
+  (do
+    (hk-load-source! "data Foo = Bar Int")
+    (hk-load-source! "data Foo = Bar Int Int")
+    (hk-con-arity "Bar"))
+  2)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/seq.sx

@@ -0,0 +1,85 @@
+;; seq / deepseq tests. seq is strict in its first arg (forces to
+;; WHNF) and returns the second arg unchanged. deepseq additionally
+;; forces the first arg to normal form.
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define hk-as-list
+  (fn (xs)
+    (cond
+      ((and (list? xs) (= (first xs) "[]")) (list))
+      ((and (list? xs) (= (first xs) ":"))
+        (cons (nth xs 1) (hk-as-list (nth xs 2))))
+      (:else xs))))
+
+(define
+  hk-eval-list
+  (fn (src) (hk-as-list (hk-eval-expr-source src))))
+
+;; ── seq returns its second arg ──
+(hk-test
+  "seq with primitive first arg"
+  (hk-eval-expr-source "seq 1 99")
+  99)
+
+(hk-test
+  "seq forces first arg via let"
+  (hk-eval-expr-source "let x = 1 + 2 in seq x x")
+  3)
+
+(hk-test
+  "seq second arg is whatever shape"
+  (hk-eval-expr-source "seq 0 \"hello\"")
+  "hello")
+
+;; ── seq enables previously-lazy bottom to be forced ──
+;; Without seq the let-binding `x = error …` is never forced;
+;; with seq it must be forced because seq is strict in its first
+;; argument. We don't run that error case here (it would terminate
+;; the test), but we do verify the negative — that without seq,
+;; the bottom bound is never demanded.
+(hk-test
+  "lazy let — bottom never forced when unused"
+  (hk-eval-expr-source "let x = error \"never\" in 42")
+  42)
+
+;; ── deepseq forces nested structure ──
+(hk-test
+  "deepseq with finite list"
+  (hk-eval-expr-source "deepseq [1, 2, 3] 7")
+  7)
+
+(hk-test
+  "deepseq with constructor value"
+  (hk-eval-expr-source "deepseq (Just 5) 11")
+  11)
+
+(hk-test
+  "deepseq with tuple"
+  (hk-eval-expr-source "deepseq (1, 2) 13")
+  13)
+
+;; ── seq + arithmetic ──
+(hk-test
+  "seq used inside arithmetic doesn't poison the result"
+  (hk-eval-expr-source "(seq 1 5) + (seq 2 7)")
+  12)
+
+;; ── seq in user code ──
+(hk-test
+  "seq via fun-clause"
+  (hk-prog-val
+    "f x = seq x (x + 1)\nresult = f 10"
+    "result")
+  11)
+
+(hk-test
+  "seq sequences list construction"
+  (hk-eval-list "[seq 1 10, seq 2 20]")
+  (list 10 20))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/hyperscript/compiler.sx

@@ -164,16 +164,13 @@
                   every?
                   catch-info
                   finally-info
-                  having-info
-                  of-filter-info
-                  count-filter-info
-                  elsewhere?)
+                  having-info)
                 (cond
                   ((<= (len items) 1)
                     (let
                       ((body (if (> (len items) 0) (first items) nil)))
                       (let
-                        ((target (cond (elsewhere? (list (quote dom-body))) (source (hs-to-sx source)) (true (quote me)))))
+                        ((target (if source (hs-to-sx source) (quote me))))
                         (let
                           ((event-refs (if (and (list? body) (= (first body) (quote do))) (filter (fn (x) (and (list? x) (= (first x) (quote ref)))) (rest body)) (list))))
                           (let
@@ -181,51 +178,30 @@
                             (let
                               ((raw-compiled (hs-to-sx stripped-body)))
                               (let
-                                ((compiled-body (let ((base (if (> (len event-refs) 0) (let ((bindings (map (fn (r) (let ((name (nth r 1))) (list (make-symbol name) (list (quote host-get) (list (quote host-get) (quote event) "detail") name)))) event-refs))) (list (quote let) bindings raw-compiled)) raw-compiled))) (if elsewhere? (list (quote when) (list (quote not) (list (quote host-call) (quote me) "contains" (list (quote host-get) (quote event) "target"))) base) base))))
+                                ((compiled-body (if (> (len event-refs) 0) (let ((bindings (map (fn (r) (let ((name (nth r 1))) (list (make-symbol name) (list (quote host-get) (list (quote host-get) (quote event) "detail") name)))) event-refs))) (list (quote let) bindings raw-compiled)) raw-compiled)))
                                 (let
                                   ((wrapped-body (if catch-info (let ((var (make-symbol (nth catch-info 0))) (catch-body (hs-to-sx (nth catch-info 1)))) (if finally-info (list (quote do) (list (quote guard) (list var (list true catch-body)) compiled-body) (hs-to-sx finally-info)) (list (quote guard) (list var (list true catch-body)) compiled-body))) (if finally-info (list (quote do) compiled-body (hs-to-sx finally-info)) compiled-body))))
                                   (let
-                                    ((handler (let ((uses-the-result? (fn (expr) (cond ((= expr (quote the-result)) true) ((list? expr) (some (fn (x) (uses-the-result? x)) expr)) (true false))))) (let ((base-handler (list (quote fn) (list (quote event)) (if (uses-the-result? wrapped-body) (list (quote let) (list (list (quote the-result) nil)) wrapped-body) wrapped-body)))) (if count-filter-info (let ((mn (get count-filter-info "min")) (mx (get count-filter-info "max"))) (list (quote let) (list (list (quote __hs-count) 0)) (list (quote fn) (list (quote event)) (list (quote begin) (list (quote set!) (quote __hs-count) (list (quote +) (quote __hs-count) 1)) (list (quote when) (if (= mx -1) (list (quote >=) (quote __hs-count) mn) (list (quote and) (list (quote >=) (quote __hs-count) mn) (list (quote <=) (quote __hs-count) mx))) (nth base-handler 2)))))) base-handler)))))
+                                    ((handler (let ((uses-the-result? (fn (expr) (cond ((= expr (quote the-result)) true) ((list? expr) (some (fn (x) (uses-the-result? x)) expr)) (true false))))) (list (quote fn) (list (quote event)) (if (uses-the-result? wrapped-body) (list (quote let) (list (list (quote the-result) nil)) wrapped-body) wrapped-body)))))
                                     (let
                                       ((on-call (if every? (list (quote hs-on-every) target event-name handler) (list (quote hs-on) target event-name handler))))
-                                      (cond
-                                        ((= event-name "mutation")
+                                      (if
+                                        (= event-name "intersection")
+                                        (list
+                                          (quote do)
+                                          on-call
                                           (list
-                                            (quote do)
-                                            on-call
-                                            (list
-                                              (quote hs-on-mutation-attach!)
-                                              target
-                                              (if
-                                                of-filter-info
-                                                (get of-filter-info "type")
-                                                "any")
-                                              (if
-                                                of-filter-info
-                                                (let
-                                                  ((a (get of-filter-info "attrs")))
-                                                  (if
-                                                    a
-                                                    (cons (quote list) a)
-                                                    nil))
-                                                nil))))
-                                        ((= event-name "intersection")
-                                          (list
-                                            (quote do)
-                                            on-call
-                                            (list
-                                              (quote
-                                                hs-on-intersection-attach!)
-                                              target
-                                              (if
-                                                having-info
-                                                (get having-info "margin")
-                                                nil)
-                                              (if
-                                                having-info
-                                                (get having-info "threshold")
-                                                nil))))
-                                        (true on-call))))))))))))
+                                            (quote hs-on-intersection-attach!)
+                                            target
+                                            (if
+                                              having-info
+                                              (get having-info "margin")
+                                              nil)
+                                            (if
+                                              having-info
+                                              (get having-info "threshold")
+                                              nil)))
+                                        on-call)))))))))))
                   ((= (first items) :from)
                     (scan-on
                       (rest (rest items))
@@ -234,10 +210,7 @@
                       every?
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :filter)
                     (scan-on
                       (rest (rest items))
@@ -246,10 +219,7 @@
                       every?
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :every)
                     (scan-on
                       (rest (rest items))
@@ -258,10 +228,7 @@
                       true
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :catch)
                     (scan-on
                       (rest (rest items))
@@ -270,10 +237,7 @@
                       every?
                       (nth items 1)
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :finally)
                     (scan-on
                       (rest (rest items))
@@ -282,10 +246,7 @@
                       every?
                       catch-info
                       (nth items 1)
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :having)
                     (scan-on
                       (rest (rest items))
@@ -294,45 +255,6 @@
                       every?
                       catch-info
                       finally-info
-                      (nth items 1)
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
-                  ((= (first items) :of-filter)
-                    (scan-on
-                      (rest (rest items))
-                      source
-                      filter
-                      every?
-                      catch-info
-                      finally-info
-                      having-info
-                      (nth items 1)
-                      count-filter-info
-                      elsewhere?))
-                  ((= (first items) :count-filter)
-                    (scan-on
-                      (rest (rest items))
-                      source
-                      filter
-                      every?
-                      catch-info
-                      finally-info
-                      having-info
-                      of-filter-info
-                      (nth items 1)
-                      elsewhere?))
-                  ((= (first items) :elsewhere)
-                    (scan-on
-                      (rest (rest items))
-                      source
-                      filter
-                      every?
-                      catch-info
-                      finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
                       (nth items 1)))
                   (true
                     (scan-on
@@ -342,11 +264,8 @@
                       every?
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?)))))
-            (scan-on (rest parts) nil nil false nil nil nil nil nil false)))))
+                      having-info)))))
+            (scan-on (rest parts) nil nil false nil nil nil)))))
     (define
       emit-send
       (fn
@@ -1058,17 +977,9 @@
                       (cons
                         (quote hs-method-call)
                         (cons obj (cons method args))))
-                    (if
-                      (and
-                        (list? dot-node)
-                        (= (first dot-node) (quote ref)))
-                      (list
-                        (quote hs-win-call)
-                        (nth dot-node 1)
-                        (cons (quote list) args))
-                      (cons
-                        (quote hs-method-call)
-                        (cons (hs-to-sx dot-node) args))))))
+                    (cons
+                      (quote hs-method-call)
+                      (cons (hs-to-sx dot-node) args)))))
               ((= head (quote string-postfix))
                 (list (quote str) (hs-to-sx (nth ast 1)) (nth ast 2)))
               ((= head (quote block-literal))
@@ -1238,12 +1149,7 @@
                 (list (quote hs-coerce) (hs-to-sx (nth ast 1)) (nth ast 2)))
               ((= head (quote in?))
                 (list
-                  (quote hs-in?)
-                  (hs-to-sx (nth ast 2))
-                  (hs-to-sx (nth ast 1))))
-              ((= head (quote in-bool?))
-                (list
-                  (quote hs-in-bool?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 2))
                   (hs-to-sx (nth ast 1))))
               ((= head (quote of))
@@ -1727,19 +1633,7 @@
                               body)))
                         (nth compiled (- (len compiled) 1))
                         (rest (reverse compiled)))
-                      (let
-                        ((defs (filter (fn (c) (and (list? c) (> (len c) 0) (= (first c) (quote define)))) compiled))
-                          (non-defs
-                            (filter
-                              (fn
-                                (c)
-                                (not
-                                  (and
-                                    (list? c)
-                                    (> (len c) 0)
-                                    (= (first c) (quote define)))))
-                              compiled)))
-                        (cons (quote do) (append defs non-defs)))))))
+                      (cons (quote do) compiled)))))
               ((= head (quote wait)) (list (quote hs-wait) (nth ast 1)))
               ((= head (quote wait-for)) (emit-wait-for ast))
               ((= head (quote log))
@@ -1847,13 +1741,7 @@
                         (make-symbol raw-fn)
                         (hs-to-sx raw-fn)))
                     (args (map hs-to-sx (rest (rest ast)))))
-                  (if
-                    (and (list? raw-fn) (= (first raw-fn) (quote ref)))
-                    (list
-                      (quote hs-win-call)
-                      (nth raw-fn 1)
-                      (cons (quote list) args))
-                    (cons fn-expr args))))
+                  (cons fn-expr args)))
               ((= head (quote return))
                 (let
                   ((val (nth ast 1)))
@@ -2041,39 +1929,26 @@
                     (quote define)
                     (make-symbol (nth ast 1))
                     (list
-                      (quote let)
+                      (quote fn)
+                      params
                       (list
+                        (quote guard)
                         (list
-                          (quote _hs-def-val)
+                          (quote _e)
                           (list
-                            (quote fn)
-                            params
+                            (quote true)
                             (list
-                              (quote guard)
+                              (quote if)
                               (list
-                                (quote _e)
+                                (quote and)
+                                (list (quote list?) (quote _e))
                                 (list
-                                  (quote true)
-                                  (list
-                                    (quote if)
-                                    (list
-                                      (quote and)
-                                      (list (quote list?) (quote _e))
-                                      (list
-                                        (quote =)
-                                        (list (quote first) (quote _e))
-                                        "hs-return"))
-                                    (list (quote nth) (quote _e) 1)
-                                    (list (quote raise) (quote _e)))))
-                              body))))
-                      (list
-                        (quote do)
-                        (list
-                          (quote host-set!)
-                          (list (quote host-global) "window")
-                          (nth ast 1)
-                          (quote _hs-def-val))
-                        (quote _hs-def-val))))))
+                                  (quote =)
+                                  (list (quote first) (quote _e))
+                                  "hs-return"))
+                              (list (quote nth) (quote _e) 1)
+                              (list (quote raise) (quote _e)))))
+                        body)))))
               ((= head (quote behavior)) (emit-behavior ast))
               ((= head (quote sx-eval))
                 (let
@@ -2123,7 +1998,7 @@
                     (hs-to-sx (nth ast 1)))))
               ((= head (quote in?))
                 (list
-                  (quote hs-in?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 2))
                   (hs-to-sx (nth ast 1))))
               ((= head (quote type-check))

lib/hyperscript/integration.sx

@@ -80,14 +80,11 @@
       ((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
       (when
         (and src (not (= src prev)))
-        (when
-          (dom-dispatch el "hyperscript:before:init" nil)
-          (hs-log-event! "hyperscript:init")
-          (dom-set-data el "hs-script" src)
-          (dom-set-data el "hs-active" true)
-          (dom-set-attr el "data-hyperscript-powered" "true")
-          (let ((handler (hs-handler src))) (handler el))
-          (dom-dispatch el "hyperscript:after:init" nil))))))
+        (hs-log-event! "hyperscript:init")
+        (dom-set-data el "hs-script" src)
+        (dom-set-data el "hs-active" true)
+        (dom-set-attr el "data-hyperscript-powered" "true")
+        (let ((handler (hs-handler src))) (handler el))))))
 
 ;; ── Boot: scan entire document ──────────────────────────────────
 ;; Called once at page load. Finds all elements with _ attribute,

lib/hyperscript/parser.sx

@@ -495,8 +495,7 @@
                             (quote and)
                             (list (quote >=) left lo)
                             (list (quote <=) left hi)))))
-                    ((match-kw "in")
-                      (list (quote in-bool?) left (parse-expr)))
+                    ((match-kw "in") (list (quote in?) left (parse-expr)))
                     ((match-kw "really")
                       (do
                         (match-kw "equal")
@@ -572,8 +571,7 @@
                           (let
                             ((right (parse-expr)))
                             (list (quote not) (list (quote =) left right))))))
-                    ((match-kw "in")
-                      (list (quote in-bool?) left (parse-expr)))
+                    ((match-kw "in") (list (quote in?) left (parse-expr)))
                     ((match-kw "empty") (list (quote empty?) left))
                     ((match-kw "between")
                       (let
@@ -1557,7 +1555,7 @@
         (fn
           ()
           (let
-            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show") (= (tp-val) "on"))) (list (quote me))) (true (parse-expr)))))
+            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show"))) (list (quote me))) (true (parse-expr)))))
             (let
               ((strategy (if (match-kw "with") (if (at-end?) "display" (let ((s (tp-val))) (do (adv!) (cond ((at-end?) s) ((= (tp-type) "colon") (do (adv!) (let ((v (tp-val))) (do (adv!) (str s ":" v))))) ((= (tp-type) "local") (let ((v (tp-val))) (do (adv!) (str s ":" v)))) (true s))))) "display")))
               (let
@@ -1568,7 +1566,7 @@
         (fn
           ()
           (let
-            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show") (= (tp-val) "on"))) (list (quote me))) (true (parse-expr)))))
+            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show"))) (list (quote me))) (true (parse-expr)))))
             (let
               ((strategy (if (match-kw "with") (if (at-end?) "display" (let ((s (tp-val))) (do (adv!) (cond ((at-end?) s) ((= (tp-type) "colon") (do (adv!) (let ((v (tp-val))) (do (adv!) (str s ":" v))))) ((= (tp-type) "local") (let ((v (tp-val))) (do (adv!) (str s ":" v)))) (true s))))) "display")))
               (let
@@ -2603,77 +2601,63 @@
         (fn
           ()
           (let
-            ((every? (match-kw "every")) (first? (match-kw "first")))
+            ((every? (match-kw "every")))
             (let
               ((event-name (parse-compound-event-name)))
               (let
-                ((count-filter (let ((mn nil) (mx nil)) (when first? (do (set! mn 1) (set! mx 1))) (when (= (tp-type) "number") (let ((n (parse-number (tp-val)))) (do (adv!) (set! mn n) (cond ((match-kw "to") (cond ((= (tp-type) "number") (let ((mv (parse-number (tp-val)))) (do (adv!) (set! mx mv)))) (true (set! mx n)))) ((match-kw "and") (cond ((match-kw "on") (set! mx -1)) (true (set! mx n)))) (true (set! mx n)))))) (if mn (dict "min" mn "max" mx) nil))))
+                ((flt (if (= (tp-type) "bracket-open") (do (adv!) (let ((f (parse-expr))) (if (= (tp-type) "bracket-close") (adv!) nil) f)) nil)))
                 (let
-                  ((of-filter (when (and (= event-name "mutation") (match-kw "of")) (cond ((and (= (tp-type) "ident") (or (= (tp-val) "attributes") (= (tp-val) "childList") (= (tp-val) "characterData"))) (let ((nm (tp-val))) (do (adv!) (dict "type" nm)))) ((= (tp-type) "attr") (let ((attrs (list (tp-val)))) (do (adv!) (define collect-or! (fn () (when (match-kw "or") (cond ((= (tp-type) "attr") (do (set! attrs (append attrs (list (tp-val)))) (adv!) (collect-or!))) (true (set! p (- p 1))))))) (collect-or!) (dict "type" "attrs" "attrs" attrs)))) (true nil)))))
+                  ((source (if (match-kw "from") (parse-expr) nil)))
                   (let
-                    ((flt (if (= (tp-type) "bracket-open") (do (adv!) (let ((f (parse-expr))) (if (= (tp-type) "bracket-close") (adv!) nil) f)) nil)))
+                    ((h-margin nil) (h-threshold nil))
+                    (define
+                      consume-having!
+                      (fn
+                        ()
+                        (cond
+                          ((and (= (tp-type) "ident") (= (tp-val) "having"))
+                            (do
+                              (adv!)
+                              (cond
+                                ((and (= (tp-type) "ident") (= (tp-val) "margin"))
+                                  (do
+                                    (adv!)
+                                    (set! h-margin (parse-expr))
+                                    (consume-having!)))
+                                ((and (= (tp-type) "ident") (= (tp-val) "threshold"))
+                                  (do
+                                    (adv!)
+                                    (set! h-threshold (parse-expr))
+                                    (consume-having!)))
+                                (true nil))))
+                          (true nil))))
+                    (consume-having!)
                     (let
-                      ((elsewhere? (cond ((match-kw "elsewhere") true) ((and (= (tp-type) "keyword") (= (tp-val) "from") (let ((nxt (if (< (+ p 1) tok-len) (nth tokens (+ p 1)) nil))) (and nxt (= (get nxt "type") "keyword") (= (get nxt "value") "elsewhere")))) (do (adv!) (adv!) true)) (true false)))
-                        (source (if (match-kw "from") (parse-expr) nil)))
+                      ((having (if (or h-margin h-threshold) (dict "margin" h-margin "threshold" h-threshold) nil)))
                       (let
-                        ((h-margin nil) (h-threshold nil))
-                        (define
-                          consume-having!
-                          (fn
-                            ()
-                            (cond
-                              ((and (= (tp-type) "ident") (= (tp-val) "having"))
-                                (do
-                                  (adv!)
-                                  (cond
-                                    ((and (= (tp-type) "ident") (= (tp-val) "margin"))
-                                      (do
-                                        (adv!)
-                                        (set! h-margin (parse-expr))
-                                        (consume-having!)))
-                                    ((and (= (tp-type) "ident") (= (tp-val) "threshold"))
-                                      (do
-                                        (adv!)
-                                        (set! h-threshold (parse-expr))
-                                        (consume-having!)))
-                                    (true nil))))
-                              (true nil))))
-                        (consume-having!)
+                        ((body (parse-cmd-list)))
                         (let
-                          ((having (if (or h-margin h-threshold) (dict "margin" h-margin "threshold" h-threshold) nil)))
+                          ((catch-clause (if (match-kw "catch") (let ((var (let ((v (tp-val))) (adv!) v)) (handler (parse-cmd-list))) (list var handler)) nil))
+                            (finally-clause
+                              (if (match-kw "finally") (parse-cmd-list) nil)))
+                          (match-kw "end")
                           (let
-                            ((body (parse-cmd-list)))
+                            ((parts (list (quote on) event-name)))
                             (let
-                              ((catch-clause (if (match-kw "catch") (let ((var (let ((v (tp-val))) (adv!) v)) (handler (parse-cmd-list))) (list var handler)) nil))
-                                (finally-clause
-                                  (if
-                                    (match-kw "finally")
-                                    (parse-cmd-list)
-                                    nil)))
-                              (match-kw "end")
+                              ((parts (if every? (append parts (list :every true)) parts)))
                               (let
-                                ((parts (list (quote on) event-name)))
+                                ((parts (if flt (append parts (list :filter flt)) parts)))
                                 (let
-                                  ((parts (if every? (append parts (list :every true)) parts)))
+                                  ((parts (if source (append parts (list :from source)) parts)))
                                   (let
-                                    ((parts (if flt (append parts (list :filter flt)) parts)))
+                                    ((parts (if having (append parts (list :having having)) parts)))
                                     (let
-                                      ((parts (if elsewhere? (append parts (list :elsewhere true)) parts)))
+                                      ((parts (if catch-clause (append parts (list :catch catch-clause)) parts)))
                                       (let
-                                        ((parts (if source (append parts (list :from source)) parts)))
+                                        ((parts (if finally-clause (append parts (list :finally finally-clause)) parts)))
                                         (let
-                                          ((parts (if count-filter (append parts (list :count-filter count-filter)) parts)))
-                                          (let
-                                            ((parts (if of-filter (append parts (list :of-filter of-filter)) parts)))
-                                            (let
-                                              ((parts (if having (append parts (list :having having)) parts)))
-                                              (let
-                                                ((parts (if catch-clause (append parts (list :catch catch-clause)) parts)))
-                                                (let
-                                                  ((parts (if finally-clause (append parts (list :finally finally-clause)) parts)))
-                                                  (let
-                                                    ((parts (append parts (list body))))
-                                                    parts)))))))))))))))))))))))
+                                          ((parts (append parts (list body))))
+                                          parts))))))))))))))))))
       (define
         parse-init-feat
         (fn
@@ -2749,7 +2733,6 @@
               ((= val "behavior") (do (adv!) (parse-behavior-feat)))
               ((= val "live") (do (adv!) (parse-live-feat)))
               ((= val "when") (do (adv!) (parse-when-feat)))
-              ((= val "worker") (error "worker plugin is not installed — see https://hyperscript.org/features/worker"))
               (true (parse-cmd-list))))))
       (define
         coll-feats

lib/hyperscript/runtime.sx

@@ -82,36 +82,14 @@
           observer)))))
 
 ;; Wait for CSS transitions/animations to settle on an element.
-(define
-  hs-on-mutation-attach!
-  (fn
-    (target mode attr-list)
-    (let
-      ((cfg-attributes (or (= mode "any") (= mode "attributes") (= mode "attrs")))
-        (cfg-childList (or (= mode "any") (= mode "childList")))
-        (cfg-characterData (or (= mode "any") (= mode "characterData"))))
-      (let
-        ((opts (dict "attributes" cfg-attributes "childList" cfg-childList "characterData" cfg-characterData "subtree" true)))
-        (when
-          (and (= mode "attrs") attr-list)
-          (dict-set! opts "attributeFilter" attr-list))
-        (let
-          ((cb (fn (records observer) (dom-dispatch target "mutation" (dict "records" records)))))
-          (let
-            ((observer (host-new "MutationObserver" cb)))
-            (host-call observer "observe" target opts)
-            observer))))))
+(define hs-init (fn (thunk) (thunk)))
 
 ;; ── Class manipulation ──────────────────────────────────────────
 
 ;; Toggle a single class on an element.
-(define hs-init (fn (thunk) (thunk)))
-
-;; Toggle between two classes — exactly one is active at a time.
 (define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
 
-;; Take a class from siblings — add to target, remove from others.
-;; (hs-take! target cls) — like radio button class behavior
+;; Toggle between two classes — exactly one is active at a time.
 (begin
   (define
     hs-wait-for
@@ -124,20 +102,21 @@
       (target event-name timeout-ms)
       (perform (list (quote io-wait-event) target event-name timeout-ms)))))
 
+;; 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))))
+
 ;; ── DOM insertion ───────────────────────────────────────────────
 
 ;; Put content at a position relative to a target.
 ;; pos: "into" | "before" | "after"
-(define hs-settle (fn (target) (perform (list (quote io-settle) target))))
-
-;; ── Navigation / traversal ──────────────────────────────────────
-
-;; Navigate to a URL.
 (define
   hs-toggle-class!
   (fn (target cls) (host-call (host-get target "classList") "toggle" cls)))
 
-;; Find next sibling matching a selector (or any sibling).
+;; ── Navigation / traversal ──────────────────────────────────────
+
+;; Navigate to a URL.
 (define
   hs-toggle-between!
   (fn
@@ -147,7 +126,7 @@
       (do (dom-remove-class target cls1) (dom-add-class target cls2))
       (do (dom-remove-class target cls2) (dom-add-class target cls1)))))
 
-;; Find previous sibling matching a selector.
+;; Find next sibling matching a selector (or any sibling).
 (define
   hs-toggle-style!
   (fn
@@ -171,7 +150,7 @@
             (dom-set-style target prop "hidden")
             (dom-set-style target prop "")))))))
 
-;; First element matching selector within a scope.
+;; Find previous sibling matching a selector.
 (define
   hs-toggle-style-between!
   (fn
@@ -183,7 +162,7 @@
         (dom-set-style target prop val2)
         (dom-set-style target prop val1)))))
 
-;; Last element matching selector.
+;; First element matching selector within a scope.
 (define
   hs-toggle-style-cycle!
   (fn
@@ -204,7 +183,7 @@
             (true (find-next (rest remaining))))))
       (dom-set-style target prop (find-next vals)))))
 
-;; First/last within a specific scope.
+;; Last element matching selector.
 (define
   hs-take!
   (fn
@@ -244,6 +223,7 @@
               (dom-set-attr target name attr-val)
               (dom-set-attr target name ""))))))))
 
+;; First/last within a specific scope.
 (begin
   (define
     hs-element?
@@ -355,9 +335,6 @@
                 (dom-insert-adjacent-html target "beforeend" value)
                 (hs-boot-subtree! target)))))))))
 
-;; ── Iteration ───────────────────────────────────────────────────
-
-;; Repeat a thunk N times.
 (define
   hs-add-to!
   (fn
@@ -370,7 +347,9 @@
           (append target (list value))))
       (true (do (host-call target "push" value) target)))))
 
-;; Repeat forever (until break — relies on exception/continuation).
+;; ── Iteration ───────────────────────────────────────────────────
+
+;; Repeat a thunk N times.
 (define
   hs-remove-from!
   (fn
@@ -380,10 +359,7 @@
       (filter (fn (x) (not (= x value))) target)
       (host-call target "splice" (host-call target "indexOf" value) 1))))
 
-;; ── 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-splice-at!
   (fn
@@ -407,10 +383,10 @@
               (host-call target "splice" i 1))))
         target))))
 
-;; ── 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-index
   (fn
@@ -422,10 +398,10 @@
       ((string? obj) (nth obj key))
       (true (host-get obj key)))))
 
-;; ── 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-put-at!
   (fn
@@ -447,11 +423,10 @@
                 ((= pos "start") (host-call target "unshift" value)))
               target)))))))
 
-;; ── 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-dict-without
   (fn
@@ -472,27 +447,27 @@
           (host-call (host-global "Reflect") "deleteProperty" out key)
           out)))))
 
-;; ── Measurement ─────────────────────────────────────────────────
+;; ── Behavior installation ───────────────────────────────────────
 
-;; Measure an element's bounding rect, store as local variables.
-;; Returns a dict with x, y, width, height, top, left, right, bottom.
+;; 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-set-on!
   (fn
     (props target)
     (for-each (fn (k) (host-set! target k (get props k))) (keys props))))
 
+;; ── 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-navigate! (fn (url) (perform (list (quote io-navigate) url))))
-
-
-;; ── Transition ──────────────────────────────────────────────────
-
-;; Transition a CSS property to a value, optionally with duration.
-;; (hs-transition target prop value duration)
 (define
   hs-ask
   (fn
@@ -501,6 +476,11 @@
       ((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)
 (define
   hs-answer
   (fn
@@ -654,10 +634,6 @@
   hs-query-all
   (fn (sel) (host-call (dom-body) "querySelectorAll" sel)))
 
-
-
-
-
 (define
   hs-query-all-in
   (fn
@@ -667,21 +643,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))))))
-;; ── Sandbox/test runtime additions ──────────────────────────────
-;; Property access — dot notation and .length
+
 (define
   hs-to-number
   (fn (v) (if (number? v) v (or (parse-number (str v)) 0))))
-;; DOM query stub — sandbox returns empty list
+;; ── Sandbox/test runtime additions ──────────────────────────────
+;; Property access — dot notation and .length
 (define
   hs-query-first
   (fn (sel) (host-call (host-global "document") "querySelector" sel)))
-;; Method dispatch — obj.method(args)
+;; DOM query stub — sandbox returns empty list
 (define
   hs-query-last
   (fn
@@ -689,11 +669,11 @@
     (let
       ((all (dom-query-all (dom-body) sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
+;; Method dispatch — obj.method(args)
+(define hs-first (fn (scope sel) (dom-query-all scope sel)))
 
 ;; ── 0.9.90 features ─────────────────────────────────────────────
 ;; beep! — debug logging, returns value unchanged
-(define hs-first (fn (scope sel) (dom-query-all scope sel)))
-;; Property-based is — check obj.key truthiness
 (define
   hs-last
   (fn
@@ -701,7 +681,7 @@
     (let
       ((all (dom-query-all scope sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
-;; Array slicing (inclusive both ends)
+;; Property-based is — check obj.key truthiness
 (define
   hs-repeat-times
   (fn
@@ -719,7 +699,7 @@
               ((= signal "hs-continue") (do-repeat (+ i 1)))
               (true (do-repeat (+ i 1))))))))
     (do-repeat 0)))
-;; Collection: sorted by
+;; Array slicing (inclusive both ends)
 (define
   hs-repeat-forever
   (fn
@@ -735,7 +715,7 @@
             ((= signal "hs-continue") (do-forever))
             (true (do-forever))))))
     (do-forever)))
-;; Collection: sorted by descending
+;; Collection: sorted by
 (define
   hs-repeat-while
   (fn
@@ -748,7 +728,7 @@
           ((= signal "hs-break") nil)
           ((= signal "hs-continue") (hs-repeat-while cond-fn thunk))
           (true (hs-repeat-while cond-fn thunk)))))))
-;; Collection: split by
+;; Collection: sorted by descending
 (define
   hs-repeat-until
   (fn
@@ -760,7 +740,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: joined by
+;; Collection: split by
 (define
   hs-for-each
   (fn
@@ -780,7 +760,7 @@
                 ((= signal "hs-continue") (do-loop (rest remaining)))
                 (true (do-loop (rest remaining))))))))
       (do-loop items))))
-
+;; Collection: joined by
 (begin
   (define
     hs-append
@@ -1535,25 +1515,6 @@
                 (hs-contains? (rest collection) item))))))
       (true false))))
 
-(define
-  hs-in?
-  (fn
-    (collection item)
-    (cond
-      ((nil? collection) (list))
-      ((list? collection)
-        (cond
-          ((nil? item) (list))
-          ((list? item)
-            (filter (fn (x) (hs-contains? collection x)) item))
-          ((hs-contains? collection item) (list item))
-          (true (list))))
-      (true (list)))))
-
-(define
-  hs-in-bool?
-  (fn (collection item) (not (hs-falsy? (hs-in? collection item)))))
-
 (define
   hs-is
   (fn
@@ -2134,13 +2095,7 @@
                 -1
                 (if (= (first lst) item) i (idx-loop (rest lst) (+ i 1))))))
           (idx-loop obj 0)))
-      (true
-        (let
-          ((fn-val (host-get obj method)))
-          (cond
-            ((and fn-val (callable? fn-val)) (apply fn-val args))
-            (fn-val (apply host-call (cons obj (cons method args))))
-            (true nil)))))))
+      (true nil))))
 
 (define hs-beep (fn (v) v))
 
@@ -2519,9 +2474,3 @@
       ((nil? b) false)
       ((= a b) true)
       (true (hs-dom-is-ancestor? a (dom-parent b))))))
-
-(define
-  hs-win-call
-  (fn
-    (fn-name args)
-    (let ((fn (host-global fn-name))) (if fn (host-call-fn fn args) nil))))

plans/haskell-on-sx.md

@@ -55,33 +55,40 @@ Key mappings:
 
 ### Phase 1 — tokenizer + parser + layout rule
 - [x] Tokenizer: reserved words, qualified names, operators, numbers (int, float, Rational later), chars/strings, comments (`--` and `{-` nested)
-- [ ] Layout algorithm: turn indentation into virtual `{`, `;`, `}` tokens per Haskell 98 §10.3
-- [ ] Parser: modules, imports (stub), top-level decls, type sigs, function clauses with patterns + guards + where-clauses, expressions with operator precedence, lambdas, `let`, `if`, `case`, `do`, list comp, sections
-- [ ] AST design modelled on GHC's HsSyn at a surface level
+- [x] Layout algorithm: turn indentation into virtual `{`, `;`, `}` tokens per Haskell 98 §10.3
+- Parser (split into sub-items — implement one per iteration):
+  - [x] Expressions: atoms, parens, tuples, lists, ranges, application, infix with full Haskell-98 precedence table, unary `-`, backtick operators, lambdas, `if`, `let`
+  - [x] `case … of` and `do`-notation expressions (plus minimal patterns needed for arms/binds: var, wildcard, literal, 0-arity and applied constructor, tuple, list)
+  - [x] Patterns — full: `as` patterns, nested, negative literal, `~` lazy, infix constructor (`:` / consym), extend lambdas/let with non-var patterns
+  - [x] Top-level decls: function clauses (simple — no guards/where yet), pattern bindings, multi-name type signatures, `data` with type vars and recursive constructors, `type` synonyms, `newtype`, fixity (`infix`/`infixl`/`infixr` with optional precedence, comma-separated ops, backtick names). Types: vars / constructors / application / `->` (right-assoc) / tuples / lists. `hk-parse-top` entry.
+  - [x] `where` clauses + guards (on fun-clauses, case alts, and let/do-let bindings — with the let funclause shorthand `let f x = …` now supported)
+  - [x] Module header + imports — `module NAME [exports] where …`, qualified/as/hiding/explicit imports, operator exports, `module Foo` exports, dotted names, headerless-with-imports
+  - [x] List comprehensions + operator sections — `(op)` / `(op e)` / `(e op)` (excluding `-` from right sections), `[e | q1, q2, …]` with `q-gen` / `q-guard` / `q-let` qualifiers
+- [x] AST design modelled on GHC's HsSyn at a surface level — keyword-tagged lists cover modules/imports/decls/types/patterns/expressions; see parser.sx docstrings for the full node catalogue
 - [x] Unit tests in `lib/haskell/tests/parse.sx` (43 tokenizer tests, all green)
 
 ### Phase 2 — desugar + eager-ish eval + ADTs (untyped)
-- [ ] Desugar: guards → nested `if`s; `where` → `let`; list comp → `concatMap`-based; do-notation stays for now (desugared in phase 3)
-- [ ] `data` declarations register constructors in runtime
-- [ ] Pattern match (tag-based, value-level): atoms, vars, wildcards, constructor patterns, `as` patterns, nested
-- [ ] Evaluator (still strict internally — laziness in phase 3): `let`, `lambda`, application, `case`, literals, constructors
-- [ ] 30+ eval tests in `lib/haskell/tests/eval.sx`
+- [x] Desugar: guards → nested `if`s; `where` → `let`; list comp → `concatMap`-based; do-notation stays for now (desugared in phase 3)
+- [x] `data` declarations register constructors in runtime
+- [x] Pattern match (tag-based, value-level): atoms, vars, wildcards, constructor patterns, `as` patterns, nested
+- [x] Evaluator (still strict internally — laziness in phase 3): `let`, `lambda`, application, `case`, literals, constructors
+- [x] 30+ eval tests in `lib/haskell/tests/eval.sx`
 
 ### Phase 3 — laziness + classic programs
-- [ ] Transpile to thunk-wrapped SX: every application arg becomes `(make-thunk (lambda () <arg>))`
-- [ ] `force` = SX eval-thunk-to-WHNF primitive
-- [ ] Pattern match forces scrutinee before matching
-- [ ] Infinite structures: `repeat x`, `iterate f x`, `[1..]`, Fibonacci stream, sieve of Eratosthenes
-- [ ] `seq`, `deepseq` from Prelude
-- [ ] Do-notation for a stub `IO` monad (just threading, no real side effects yet)
-- [ ] Classic programs in `lib/haskell/tests/programs/`:
-  - [ ] `fib.hs` — infinite Fibonacci stream
-  - [ ] `sieve.hs` — lazy sieve of Eratosthenes
-  - [ ] `quicksort.hs` — naive QS
-  - [ ] `nqueens.hs`
-  - [ ] `calculator.hs` — parser combinator style expression evaluator
-- [ ] `lib/haskell/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
-- [ ] Target: 5/5 classic programs passing
+- [x] Transpile to thunk-wrapped SX: every application arg becomes `(make-thunk (lambda () <arg>))`
+- [x] `force` = SX eval-thunk-to-WHNF primitive
+- [x] Pattern match forces scrutinee before matching
+- [x] Infinite structures: `repeat x`, `iterate f x`, `[1..]`, Fibonacci stream (sieve deferred — needs lazy `++` and is exercised under `Classic programs`)
+- [x] `seq`, `deepseq` from Prelude
+- [x] Do-notation for a stub `IO` monad (just threading, no real side effects yet)
+- [x] Classic programs in `lib/haskell/tests/programs/`:
+  - [x] `fib.hs` — infinite Fibonacci stream
+  - [x] `sieve.hs` — lazy sieve of Eratosthenes
+  - [x] `quicksort.hs` — naive QS
+  - [x] `nqueens.hs`
+  - [x] `calculator.hs` — parser combinator style expression evaluator
+- [x] `lib/haskell/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
+- [x] Target: 5/5 classic programs passing
 
 ### Phase 4 — Hindley-Milner inference
 - [ ] Algorithm W: unification + type schemes + generalisation + instantiation
@@ -107,6 +114,435 @@ Key mappings:
 
 _Newest first._
 
+- **2026-04-25** — `conformance.sh` runner + `scoreboard.json` + `scoreboard.md`.
+  Script runs each classic program's test suite, prints per-program pass/fail,
+  and writes both files. `--check` mode skips writing for CI use.
+  Initial snapshot: 16/16 tests, 5/5 programs passing. Phase 3 complete.
+
+- **2026-04-25** — Classic program `calculator.hs`: recursive descent
+  expression evaluator using ADTs for tokens and results.
+  `data Token = TNum Int | TOp String` + `data Result = R Int [Token]`;
+  parser threads token lists through `R` constructors enabling nested
+  constructor pattern matching (`R v (TOp "+":rest)`). Handles two-level
+  operator precedence (* / tighter than + −) and left-associativity.
+  5 tests: addition, precedence, left-assoc subtraction, left-assoc
+  div+mul, single number. All 5 classic programs complete. 402/402 green.
+
+- **2026-04-25** — Classic program `nqueens.hs`: backtracking n-queens via list
+  comprehension and multi-clause `where`. Three fixes needed: (1) `hk-eval-let`
+  now delegates to `hk-bind-decls!` so multi-clause `where`/`let` bindings
+  (e.g., `go 0 = [[]]; go k = [...]`) are grouped as multifuns; (2) added
+  `concatMap`, `concat`, `abs`, `negate` to `hk-prelude-src` (list comprehensions
+  desugar to `concatMap`); (3) cached the Prelude env in `hk-env0` so
+  `hk-eval-expr-source` copies it instead of re-parsing. Tests: `queens 4 = 2`,
+  `queens 5 = 10`. n=8 (92 solutions) is too slow at ~50s/n — omitted.
+  397/397 green.
+
+- **2026-04-25** — Classic program `quicksort.hs`: naive functional quicksort.
+  `qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger where smaller = filter (< x) xs; larger = filter (>= x) xs`.
+  No new runtime additions needed — right sections, `filter`, `++` all worked out of the box.
+  5 tests (general sort, empty, singleton, already-sorted, reverse-sorted). 395/395 green.
+
+- **2026-04-25** — Classic program `sieve.hs`: lazy sieve of Eratosthenes.
+  Added `mod`, `div`, `rem`, `quot` to `hk-binop` (and as first-class
+  values in `hk-init-env`), enabling backtick operator use. The filter-based
+  sieve `sieve (p:xs) = p : sieve (filter (\x -> x \`mod\` p /= 0) xs)` works
+  with the existing lazy cons + Prelude `filter`. 2 new tests in
+  `lib/haskell/tests/program-sieve.sx` (first 10 primes, 20th prime = 71).
+  390/390 green.
+
+- **2026-04-25** — First classic program: `fib.hs`. Canonical Haskell
+  source lives at `lib/haskell/tests/programs/fib.hs` (the
+  two-cons-cell self-referential fibs definition plus a hand-rolled
+  `zipPlus`). The runner at `lib/haskell/tests/program-fib.sx`
+  mirrors the source as an SX string (the OCaml server's
+  `read-file` lives in the page-helpers env, not the default load
+  env, so direct file reads from inside `eval` aren't available).
+  Tests: `take 15 myFibs == [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]`,
+  plus a spot-check that the user-defined `zipPlus` is also
+  reachable. Found and fixed an ordering bug in `hk-bind-decls!`:
+  pass 3 (0-arity body evaluation) iterated `(keys groups)` whose
+  order is implementation-defined, so a top-down program where
+  `result = take 15 myFibs` came after `myFibs = …` could see
+  `myFibs` still bound to its `nil` placeholder. Now group names
+  are tracked in source order via a parallel list and pass 3 walks
+  that. 388/388 green.
+
+- **2026-04-25** — Phase 3 do-notation + stub IO monad. Added a
+  `hk-desugar-do` pass that follows Haskell 98 §3.14 verbatim:
+  `do { e } = e`, `do { e ; ss } = e >> do { ss }`,
+  `do { p <- e ; ss } = e >>= \p -> do { ss }`, and
+  `do { let ds ; ss } = let ds in do { ss }`. The desugarer's
+  `:do` branch now invokes this pass directly so the surface
+  AST forms (`:do-expr`, `:do-bind`, `:do-let`) never reach the
+  evaluator. IO is represented as a tagged value
+  `("IO" payload)` — `return` (lazy builtin) wraps; `>>=` (lazy
+  builtin) forces the action, unwraps, and calls the bound
+  function on the payload; `>>` (lazy builtin) forces the
+  action and returns the second one. All three are non-strict
+  in their action arguments so deeply nested do-blocks don't
+  walk the whole chain at construction time. 14 new tests in
+  `lib/haskell/tests/do-io.sx` cover single-stmt do, single
+  and multi-bind, `>>` sequencing (last action wins), do-let
+  (single, multi, interleaved with bind), bind-to-`Just`,
+  bind-to-tuple, do inside a top-level fun, nested do, and
+  using `(>>=)`/`(>>)` directly as functions. 382/382 green.
+
+- **2026-04-25** — Phase 3 `seq` + `deepseq`. Built-ins were strict
+  in all args by default (every collected thunk forced before
+  invoking the underlying SX fn) — that defeats `seq`'s purpose,
+  which is strict in its first argument and lazy in its second.
+  Added a tiny `lazy` flag on the builtin record (set by a new
+  `hk-mk-lazy-builtin` constructor) and routed `hk-apply-builtin`
+  to skip the auto-force when the flag is true. `seq a b` calls
+  `hk-force a` then returns `b` unchanged so its laziness is
+  preserved; `deepseq` does the same with `hk-deep-force`. 9 new
+  tests in `lib/haskell/tests/seq.sx` cover primitive, computed,
+  and let-bound first args, deepseq on a list / `Just` /
+  tuple, seq inside arithmetic, seq via a fun-clause, and
+  `[seq 1 10, seq 2 20]` to confirm seq composes inside list
+  literals. The lazy-when-unused negative case is also tested:
+  `let x = error "never" in 42 == 42`. 368/368 green.
+
+- **2026-04-24** — Phase 3 infinite structures + Prelude. Two
+  evaluator changes turn the lazy primitives into a working
+  language:
+  1. Op-form `:` is now non-strict in both args — `hk-eval-op`
+     special-cases it before the eager force-and-binop path, so a
+     cons-cell holds two thunks. This is what makes `repeat x =
+     x : repeat x`, `iterate f x = x : iterate f (f x)`, and the
+     classic `fibs = 0 : 1 : zipWith plus fibs (tail fibs)`
+     terminate when only a finite prefix is consumed.
+  2. Operators are now first-class values via a small
+     `hk-make-binop-builtin` helper, so `(+)`, `(*)`, `(==)` etc.
+     can be passed to `zipWith` and `map`.
+  Added range support across parser + evaluator: `[from..to]` and
+  `[from,next..to]` evaluate eagerly via `hk-build-range` (handles
+  step direction); `[from..]` parses to a new `:range-from` node
+  that the evaluator desugars to `iterate (+ 1) from`. New
+  `hk-load-into!` runs the regular pipeline (parse → desugar →
+  register data → bind decls) on a source string, and `hk-init-env`
+  preloads `hk-prelude-src` with the Phase-3 Prelude:
+  `head`, `tail`, `fst`, `snd`, `take`, `drop`, `repeat`, `iterate`,
+  `length`, `map`, `filter`, `zipWith`, plus `fibs` and `plus`.
+  25 new tests in `lib/haskell/tests/infinite.sx`, including
+  `take 10 fibs == [0,1,1,2,3,5,8,13,21,34]`,
+  `head (drop 99 [1..])`, `iterate (\x -> x * 2) 1` powers of two,
+  user-defined `ones = 1 : ones`, `naturalsFrom`, range edge cases,
+  composed `map`/`filter`, and a custom `mySum`. 359/359 green.
+  Sieve of Eratosthenes is deferred — it needs lazy `++` plus a
+  `mod` primitive — and lives under `Classic programs` anyway.
+
+- **2026-04-24** — Phase 3 laziness foundation. Added a thunk type to
+  `lib/haskell/eval.sx` (`hk-mk-thunk` / `hk-is-thunk?`) backed by a
+  one-shot memoizing `hk-force` that evaluates the deferred AST, then
+  flips a `forced` flag and caches the value on the thunk dict; the
+  shared `hk-deep-force` walks the result tree at the test/output
+  boundary. Three single-line wiring changes in the evaluator make
+  every application argument lazy: `:app` now wraps its argument in
+  `hk-mk-thunk` rather than evaluating it. To preserve correctness
+  where values must be inspected, `hk-apply`, `hk-eval-op`,
+  `hk-eval-if`, `hk-eval-case`, and `hk-eval` for `:neg` now force
+  their operand. `hk-apply-builtin` forces every collected arg
+  before invoking the underlying SX fn so built-ins (`error`, `not`,
+  `id`) stay strict. The pattern matcher in `match.sx` now forces
+  the scrutinee just-in-time only for patterns that need to inspect
+  shape — `p-wild`, `p-var`, `p-as`, and `p-lazy` are no-force
+  paths, so the value flows through as a thunk and binding
+  preserves laziness. `hk-match-list-pat` forces at every cons-spine
+  step. 6 new lazy-specific tests in `lib/haskell/tests/eval.sx`
+  verify that `(\x y -> x) 1 (error …)` and `(\x y -> y) (error …) 99`
+  return without diverging, that `case Just (error …) of Just _ -> 7`
+  short-circuits, that `const` drops its second arg, that
+  `myHead (1 : error … : [])` returns 1 without touching the tail,
+  and that `Just (error …)` survives a wildcard-arm `case`. 333/333
+  green, all prior eval tests preserved by deep-forcing the result
+  in `hk-eval-expr-source` and `hk-prog-val`.
+
+- **2026-04-24** — Phase 2 evaluator (`lib/haskell/eval.sx`) — ties
+  the whole pipeline together. Strict semantics throughout (laziness
+  is Phase 3). Function values are tagged dicts: `closure`,
+  `multi`(fun), `con-partial`, `builtin`. `hk-apply` unifies dispatch
+  across all four; closures and multifuns curry one argument at a
+  time, multifuns trying each clause's pat-list in order once arity
+  is reached. Top-level `hk-bind-decls!` is three-pass —
+  collect groups + pre-seed names → install multifuns (so closures
+  observe later names) → eval 0-arity bodies and pat-binds — making
+  forward and mutually recursive references work. `hk-eval-let` does
+  the same trick with a mutable child env. Built-ins:
+  `error`/`not`/`id`, plus `otherwise = True`. Operators wired:
+  arithmetic, comparison (returning Bool conses), `&&`, `||`, `:`,
+  `++`. Sections evaluate the captured operand once and return a
+  closure synthesized via the existing AST. `hk-eval-program`
+  registers data decls then binds, returning the env; `hk-run`
+  fetches `main` if present. Also extended `runtime.sx` to
+  pre-register the standard Prelude conses (`Maybe`, `Either`,
+  `Ordering`) so expression-level eval doesn't need a leading
+  `data` decl. 48 new tests in `lib/haskell/tests/eval.sx` cover
+  literals, arithmetic precedence, comparison/Bool, `if`, `let`
+  (incl. recursive factorial), lambdas (incl. constructor pattern
+  args), constructors, `case` (Just/Nothing/literal/tuple/wildcard),
+  list literals + cons + `++`, tuples, sections, multi-clause
+  top-level (factorial, list length via cons pattern, Maybe handler
+  with default), user-defined `data` with case-style matching, a
+  binary-tree height program, currying, higher-order (`twice`),
+  short-circuit `error` via `if`, and the three built-ins. 329/329
+  green. Phase 2 is now complete; Phase 3 (laziness) is next.
+
+- **2026-04-24** — Phase 2: value-level pattern matcher
+  (`lib/haskell/match.sx`). Core entry `hk-match pat val env` returns
+  an extended env dict on success or `nil` on failure (uses `assoc`
+  rather than `dict-set!` so failed branches never pollute the
+  caller's env). Constructor values are tagged lists with the
+  constructor name as the first element; tuples use the tag `"Tuple"`,
+  lists are chained `(":" h t)` cons cells terminated by `("[]")`.
+  Value builders `hk-mk-con` / `hk-mk-tuple` / `hk-mk-nil` /
+  `hk-mk-cons` / `hk-mk-list` keep tests readable. The matcher
+  handles every pattern node the parser emits:
+  - `:p-wild` (always matches), `:p-var` (binds), `:p-int` /
+    `:p-float` / `:p-string` / `:p-char` (literal equality)
+  - `:p-as` (sub-match then bind whole), `:p-lazy` (eager for now;
+    laziness wired in phase 3)
+  - `:p-con` with arity check + recursive arg matching, including
+    deeply nested patterns and infix `:` cons (uses the same
+    code path as named constructors)
+  - `:p-tuple` against `"Tuple"` values, `:p-list` against an
+    exact-length cons spine.
+  Helper `hk-parse-pat-source` lifts a real Haskell pattern out of
+  `case _ of <pat> -> 0`, letting tests drive against parser output.
+  31 new tests in `lib/haskell/tests/match.sx` cover atomic
+  patterns, success/failure for each con/tuple/list shape, nested
+  `Just (Just x)`, cons-vs-empty, `as` over con / wildcard /
+  failing-sub, `~` lazy, plus four parser-driven cases (`Just x`,
+  `x : xs`, `(a, b)`, `n@(Just x)`). 281/281 green.
+
+- **2026-04-24** — Phase 2: runtime constructor registry
+  (`lib/haskell/runtime.sx`). A mutable dict `hk-constructors` keyed
+  by constructor name, each entry carrying arity and owning type.
+  `hk-register-data!` walks a `:data` AST and registers every
+  `:con-def` with its arity (= number of field types) and the type
+  name; `hk-register-newtype!` does the one-constructor variant;
+  `hk-register-decls!` / `hk-register-program!` filter a decls list
+  (or a `:program` / `:module` AST) and call the appropriate
+  registrar. `hk-load-source!` composes it with `hk-core`
+  (tokenize → layout → parse → desugar → register). Pre-registers
+  five built-ins tied to Haskell syntactic forms: `True` / `False`
+  (Bool), `[]` and `:` (List), `()` (Unit) — everything else comes
+  from user declarations or the eventual Prelude. Query helpers:
+  `hk-is-con?`, `hk-con-arity`, `hk-con-type`, `hk-con-names`. 24
+  new tests in `lib/haskell/tests/runtime.sx` cover each built-in
+  (arity + type), unknown-name probes, registration of `MyBool` /
+  `Maybe` / `Either` / recursive `Tree` / `newtype Age`, multi-data
+  programs, a module-header body, ignoring non-data decls, and
+  last-wins re-registration. 250/250 green.
+
+- **2026-04-24** — Phase 2 kicks off with `lib/haskell/desugar.sx` — a
+  tree-walking rewriter that eliminates the three surface-only forms
+  produced by the parser, leaving a smaller core AST for the evaluator:
+  - `:where BODY DECLS` → `:let DECLS BODY`
+  - `:guarded ((:guard C1 E1) (:guard C2 E2) …)` → right-folded
+    `(:if C1 E1 (:if C2 E2 … (:app (:var "error") (:string "…"))))`
+  - `:list-comp E QUALS` → Haskell 98 §3.11 translation:
+    empty quals → `(:list (E))`, `:q-guard` → `(:if … (:list (E)) (:list ()))`,
+    `:q-gen PAT SRC` → `(concatMap (\PAT -> …) SRC)`, `:q-let BINDS` →
+    `(:let BINDS …)`. Nested generators compile to nested concatMap.
+  Every other expression, decl, pattern, and type node is recursed
+  into and passed through unchanged. Public entries `hk-desugar`,
+  `hk-core` (tokenize → layout → parse → desugar on a module), and
+  `hk-core-expr` (the same for an expression). 15 new tests in
+  `lib/haskell/tests/desugar.sx` cover two- and three-way guards,
+  case-alt guards, single/multi-binding `where`, guards + `where`
+  combined, the four list-comprehension cases (single-gen, gen +
+  filter, gen + let, nested gens), and pass-through for literals,
+  lambdas, simple fun-clauses, `data` decls, and a module header
+  wrapping a guarded function. 226/226 green.
+
+- **2026-04-24** — Phase 1 parser is now complete. This iteration adds
+  operator sections and list comprehensions, the two remaining
+  aexp-level forms, plus ticks the “AST design” item (the keyword-
+  tagged list shape has accumulated a full HsSyn-level surface).
+  Changes:
+  - `hk-parse-infix` now bails on `op )` without consuming the op, so
+    the paren parser can claim it as a left section.
+  - `hk-parse-parens` rewritten to recognise five new forms:
+    `()` (unit), `(op)` → `(:var OP)`, `(op e)` → `(:sect-right OP E)`
+    (excluded for `-` so that `(- 5)` stays `(:neg 5)`), `(e op)` →
+    `(:sect-left OP E)`, plus regular parens and tuples. Works for
+    varsym, consym, reservedop `:`, and backtick-quoted varids.
+  - `hk-section-op-info` inspects the current token and returns a
+    `{:name :len}` dict, so the same logic handles 1-token ops and
+    3-token backtick ops uniformly.
+  - `hk-parse-list-lit` now recognises a `|` after the first element
+    and dispatches to `hk-parse-qual` per qualifier (comma-separated),
+    producing `(:list-comp EXPR QUALS)`. Qualifiers are:
+    `(:q-gen PAT EXPR)` when a paren-balanced lookahead
+    (`hk-comp-qual-is-gen?`) finds `<-` before the next `,`/`]`,
+    `(:q-let BINDS)` for `let …`, and `(:q-guard EXPR)` otherwise.
+  - `hk-parse-comp-let` accepts `]` or `,` as an implicit block close
+    (single-line comprehensions never see layout's vrbrace before the
+    qualifier terminator arrives); explicit `{ }` still closes
+    strictly.
+  22 new tests in `lib/haskell/tests/parser-sect-comp.sx` cover
+  op-references (inc. `(-)`, `(:)`, backtick), right sections (inc.
+  backtick), left sections, the `(- 5)` → `:neg` corner, plain parens
+  and tuples, six comprehension shapes (simple, filter, let,
+  nested-generators, constructor pattern bind, tuple pattern bind,
+  and a three-qualifier mix). 211/211 green.
+
+- **2026-04-24** — Phase 1: module header + imports. Added
+  `hk-parse-module-header`, `hk-parse-import`, plus shared helpers for
+  import/export entity lists (`hk-parse-ent`, `hk-parse-ent-member`,
+  `hk-parse-ent-list`). New AST:
+  - `(:module NAME EXPORTS IMPORTS DECLS)` — NAME `nil` means no header,
+    EXPORTS `nil` means no export list (distinct from empty `()`)
+  - `(:import QUALIFIED NAME AS SPEC)` — QUALIFIED bool, AS alias or nil,
+    SPEC nil / `(:spec-items ENTS)` / `(:spec-hiding ENTS)`
+  - Entity refs: `:ent-var`, `:ent-all` (`Tycon(..)`), `:ent-with`
+    (`Tycon(m1, m2, …)`), `:ent-module` (exports only).
+  `hk-parse-program` now dispatches on the leading token: `module`
+  keyword → full header-plus-body parse (consuming the `where` layout
+  brace around the module body); otherwise collect any leading
+  `import` decls and then remaining decls with the existing logic.
+  The outer shell is `(:module …)` as soon as any header or import is
+  present, and stays as `(:program DECLS)` otherwise — preserving every
+  previous test expectation untouched. Handles operator exports `((+:))`,
+  dotted module names (`Data.Map`), and the Haskell-98 context-sensitive
+  keywords `qualified`/`as`/`hiding` (all lexed as ordinary varids and
+  matched only in import position). 16 new tests in
+  `lib/haskell/tests/parser-module.sx` covering simple/exports/empty
+  headers, dotted names, operator exports, `module Foo` exports,
+  qualified/aliased/items/hiding imports, and a headerless-with-imports
+  file. 189/189 green.
+
+- **2026-04-24** — Phase 1: guards + where clauses. Factored a single
+  `hk-parse-rhs sep` that all body-producing sites now share: it reads
+  a plain `sep expr` body or a chain of `| cond sep expr` guards, then
+  — regardless of which form — looks for an optional `where` block and
+  wraps accordingly. AST additions:
+  - `:guarded GUARDS` where each GUARD is `:guard COND EXPR`
+  - `:where BODY DECLS` where BODY is a plain expr or a `:guarded`
+  Both can nest (guards inside where). `hk-parse-alt` now routes through
+  `hk-parse-rhs "->"`, `hk-parse-fun-clause` and `hk-parse-bind` through
+  `hk-parse-rhs "="`. `hk-parse-where-decls` reuses `hk-parse-decl` so
+  where-blocks accept any decl form (signatures, fixity, nested funs).
+  As a side effect, `hk-parse-bind` now also picks up the Haskell-native
+  `let f x = …` funclause shorthand: a varid followed by one or more
+  apats produces `(:fun-clause NAME APATS BODY)` instead of a
+  `(:bind (:p-var …) …)` — keeping the simple `let x = e` shape
+  unchanged for existing tests. 11 new tests in
+  `lib/haskell/tests/parser-guards-where.sx` cover two- and three-way
+  guards, mixed guarded + equality clauses, single- and multi-binding
+  where blocks, guards plus where, case-alt guards, case-alt where,
+  let with funclause shorthand, let with guards, and a where containing
+  a type signature alongside a fun-clause. 173/173 green.
+
+- **2026-04-24** — Phase 1: top-level decls. Refactored `hk-parse-expr` into a
+  `hk-parser tokens mode` with `:expr` / `:module` dispatch so the big lexical
+  state is shared (peek/advance/pat/expr helpers all reachable); added public
+  wrappers `hk-parse-expr`, `hk-parse-module`, and source-level entry
+  `hk-parse-top`. New type parser (`hk-parse-type` / `hk-parse-btype` /
+  `hk-parse-atype`): type variables (`:t-var`), type constructors (`:t-con`),
+  type application (`:t-app`, left-assoc), right-associative function arrow
+  (`:t-fun`), unit/tuples (`:t-tuple`), and lists (`:t-list`). New decl parser
+  (`hk-parse-decl` / `hk-parse-program`) producing a `(:program DECLS)` shell:
+  - `:type-sig NAMES TYPE` — comma-separated multi-name support
+  - `:fun-clause NAME APATS BODY` — patterns for args, body via existing expr
+  - `:pat-bind PAT BODY` — top-level pattern bindings like `(a, b) = pair`
+  - `:data NAME TVARS CONS` with `:con-def CNAME FIELDS` for nullary and
+    multi-arg constructors, including recursive references
+  - `:type-syn NAME TVARS TYPE`, `:newtype NAME TVARS CNAME FIELD`
+  - `:fixity ASSOC PREC OPS` — assoc one of `"l"`/`"r"`/`"n"`, default prec 9,
+    comma-separated operator names, including backtick-quoted varids.
+  Sig vs fun-clause disambiguated by a paren-balanced top-level scan for
+  `::` before the next `;`/`}` (`hk-has-top-dcolon?`). 24 new tests in
+  `lib/haskell/tests/parser-decls.sx` cover all decl forms, signatures with
+  application / tuples / lists / right-assoc arrows, nullary and recursive
+  data types, multi-clause functions, and a mixed program with data + type-
+  synonym + signature + two function clauses. Not yet: guards, where
+  clauses, module header, imports, deriving, contexts, GADTs. 162/162 green.
+
+- **2026-04-24** — Phase 1: full patterns. Added `as` patterns
+  (`name@apat` → `(:p-as NAME PAT)`), lazy patterns (`~apat` →
+  `(:p-lazy PAT)`), negative literal patterns (`-N` / `-F` resolving
+  eagerly in the parser so downstream passes see a plain `(:p-int -1)`),
+  and infix constructor patterns via a right-associative single-band
+  layer on top of `hk-parse-pat-lhs` for any `consym` or reservedop `:`
+  (so `x : xs` parses as `(:p-con ":" [x, xs])`, `a :+: b` likewise).
+  Extended `hk-apat-start?` with `-` and `~` so the pattern-argument
+  loops in lambdas and constructor applications pick these up.
+  Lambdas now parse apat parameters instead of bare varids — so the
+  `:lambda` AST is `(:lambda APATS BODY)` with apats as pattern nodes.
+  `hk-parse-bind` became a plain `pat = expr` form, so `:bind` now has
+  a pattern LHS throughout (simple `x = 1` → `(:bind (:p-var "x") …)`);
+  this picks up `let (x, y) = pair in …` and `let Just x = m in x`
+  automatically, and flows through `do`-notation lets. Eight existing
+  tests updated to the pattern-flavoured AST. Also fixed a pragmatic
+  layout issue that surfaced in multi-line `let`s: when a layout-indent
+  would emit a spurious `;` just before an `in` token (because the
+  let block had already been closed by dedent), `hk-peek-next-reserved`
+  now lets the layout pass skip that indent and leave closing to the
+  existing `in` handler. 18 new tests in
+  `lib/haskell/tests/parser-patterns.sx` cover every pattern variant,
+  lambda with mixed apats, let pattern-bindings (tuple / constructor /
+  cons), and do-bind with a tuple pattern. 138/138 green.
+
+- **2026-04-24** — Phase 1: `case … of` and `do`-notation parsers. Added `hk-parse-case`
+  / `hk-parse-alt`, `hk-parse-do` / `hk-parse-do-stmt` / `hk-parse-do-let`, plus the
+  minimal pattern language needed to make arms and binds meaningful:
+  `hk-parse-apat` (var, wildcard `_`, int/float/string/char literal, 0-arity
+  conid/qconid, paren+tuple, list) and `hk-parse-pat` (conid applied to
+  apats greedily). AST nodes: `:case SCRUT ALTS`, `:alt PAT BODY`, `:do STMTS`
+  with stmts `:do-expr E` / `:do-bind PAT E` / `:do-let BINDS`, and pattern
+  tags `:p-wild` / `:p-int` / `:p-float` / `:p-string` / `:p-char` / `:p-var`
+  / `:p-con NAME ARGS` / `:p-tuple` / `:p-list`. `do`-stmts disambiguate
+  `pat <- e` vs bare expression with a forward paren/bracket/brace-balanced
+  scan for `<-` before the next `;`/`}` — no backtracking, no AST rewrite.
+  `case` and `do` accept both implicit (`vlbrace`/`vsemi`/`vrbrace`) and
+  explicit braces. Added to `hk-parse-lexp` so they participate fully in
+  operator-precedence expressions. 19 new tests in
+  `lib/haskell/tests/parser-case-do.sx` cover every pattern variant,
+  explicit-brace `case`, expression scrutinees, do with bind/let/expr,
+  multi-binding `let` in `do`, constructor patterns in binds, and
+  `case`/`do` nested inside `let` and lambda. The full pattern item (as
+  patterns, negative literals, `~` lazy, lambda/let pattern extension)
+  remains a separate sub-item. 119/119 green.
+
+- **2026-04-24** — Phase 1: expression parser (`lib/haskell/parser.sx`, ~380 lines).
+  Pratt-style precedence climbing against a Haskell-98-default op table (24
+  operators across precedence 0–9, left/right/non assoc, default infixl 9 for
+  anything unlisted). Supports literals (int/float/string/char), varid/conid
+  (qualified variants folded into `:var` / `:con`), parens / unit / tuples,
+  list literals, ranges `[a..b]` and `[a,b..c]`, left-associative application,
+  unary `-`, backtick operators (`x \`mod\` 3`), lambdas, `if-then-else`, and
+  `let … in` consuming both virtual and explicit braces. AST uses keyword
+  tags (`:var`, `:op`, `:lambda`, `:let`, `:bind`, `:tuple`, `:range`,
+  `:range-step`, `:app`, `:neg`, `:if`, `:list`, `:int`, `:float`, `:string`,
+  `:char`, `:con`). The parser skips a leading `vlbrace` / `lbrace` so it can
+  be called on full post-layout output, and uses a `raise`-based error channel
+  with location-lite messages. 42 new tests in `lib/haskell/tests/parser-expr.sx`
+  cover literals, identifiers, parens/tuple/unit, list + range, app associativity,
+  operator precedence (mul over add, cons right-assoc, function-composition
+  right-assoc, `$` lowest), backtick ops, unary `-`, lambda multi-param,
+  `if` with infix condition, single- and multi-binding `let` (both implicit
+  and explicit braces), plus a few mixed nestings. 100/100 green.
+
+- **2026-04-24** — Phase 1: layout algorithm (`lib/haskell/layout.sx`, ~260 lines)
+  implementing Haskell 98 §10.3. Two-pass design: a pre-pass augments the raw
+  token stream with explicit `layout-open` / `layout-indent` markers (suppressing
+  `<n>` when `{n}` already applies, per note 3), then an L pass consumes the
+  augmented stream against a stack of implicit/explicit layout contexts and
+  emits `vlbrace` / `vsemi` / `vrbrace` tokens; newlines are dropped. Supports
+  the initial module-level implicit open (skipped when the first token is
+  `module` or `{`), the four layout keywords (`let`/`where`/`do`/`of`), explicit
+  braces disabling layout, dedent closing nested implicit blocks while also
+  emitting `vsemi` at the enclosing level, and the pragmatic single-line
+  `let … in` rule (emit `}` when `in` meets an implicit let). 15 new tests
+  in `lib/haskell/tests/layout.sx` cover module-start, do/let/where/case/of,
+  explicit braces, multi-level dedent, line continuation, and EOF close-down.
+  Shared test helpers moved to `lib/haskell/testlib.sx` so both test files
+  can share one `hk-test`. `test.sh` preloads tokenizer + layout + testlib.
+  58/58 green.
+
 - **2026-04-24** — Phase 1: Haskell 98 tokenizer (`lib/haskell/tokenizer.sx`, 490 lines)
   covering idents (lower/upper/qvarid/qconid), 23 reserved words, 11 reserved ops,
   varsym/consym operator chains, integer/hex/octal/float literals incl. exponent

plans/hs-blockers-drain.md

@@ -1,96 +0,0 @@
-# HS conformance — blockers drain
-
-Goal: take hyperscript conformance from **1277/1496 (85.4%)** to **1496/1496 (100%)** by clearing the blocked clusters and the design-done Bucket E subsystems.
-
-This plan exists because the per-iteration `loops/hs` agent can't fit these into its 30-min budget — they need dedicated multi-commit sit-downs. Track progress here; refer to `plans/hs-conformance-to-100.md` for the canonical cluster ledger.
-
-## Current state (2026-04-25)
-
-- Loop running in `/root/rose-ash-loops/hs` (branch `loops/hs`)
-- sx-tree MCP **fixed** (was a session-stale binary issue — restart of claude in the tmux window picked it up). Loop hinted to retry **#32**, **#29** first.
-- Recent loop progress: ~1 commit/6h — easy wins drained, what's left needs focused attention.
-
-## Remaining work
-
-### Bucket-A/B/C blockers (small, in-place fixes)
-
-| # | Cluster | Tests | Effort | Blocker | Fix sketch |
-|---|---------|------:|--------|---------|------------|
-| **17** | `tell` semantics | +3 | ~1h | Implicit-default-target ambiguity. `bare add .bar` inside `tell X` should target `X` but explicit `to me` must reach the original element. | Add `beingTold` symbol distinct from `me`; bare commands compile to `beingTold-or-me`; explicit `me` always the original. |
-| **22** | window global fn fallback | +2-4 | ~1h | `foo()` where `foo` isn't SX-defined needs to fall back to `(host-global "foo")`. Three attempts failed: guard (host-level error not catchable), `env-has?` (not in HS kernel), `hs-win-call` (NativeFn not callable from CALL). | Add `symbol-bound?` predicate to HS kernel **OR** a host-call-fn primitive with arity-agnostic dispatch. |
-| **29** | `hyperscript:before:init` / `:after:init` / `:parse-error` events | +4-6 | ~30m (post sx-tree fix) | Was sx-tree MCP outage. Now unblocked — loop should retry. 4 of 6 tests need stricter parser error-rejection (out of scope; mark partial). | Edit `integration.sx` to fire DOM events at activation boundaries. |
-
-### Bucket D — medium features
-
-| # | Cluster | Tests | Effort | Status |
-|---|---------|------:|--------|--------|
-| **31** | runtime null-safety error reporting | **+15-18** | **2-4h** | **THIS SESSION'S TARGET.** Plan node fully spec'd: 5 pieces of work. |
-| **32** | MutationObserver mock + `on mutation` | +10-15 | ~2h | Was sx-tree-blocked. Now unblocked — loop hinted to retry. Multi-file: parser, compiler, runtime, runner mock, generator skip-list. |
-| **33** | cookie API | +2 (remaining) | ~30m | Partial done (+3). Remaining 2 need `hs-method-call` runtime fallback for unknown methods + `hs-for-each` recognising host-array/proxy collections. |
-| 34 | event modifier DSL | +6-8 | ~1-2h | `elsewhere`, `every`, count filters (`once`/`twice`/`3 times`/ranges), `from elsewhere`. Pending. |
-| 35 | namespaced `def` | +3 | ~30m | Pending. |
-
-### Bucket E — subsystems (design docs landed, multi-commit each)
-
-Each has a design doc with a step-by-step checklist. These are 1-2 days of focused work each, not loop-fits.
-
-| # | Subsystem | Tests | Design doc | Branch |
-|---|-----------|------:|------------|--------|
-| 36 | WebSocket + `socket` + RPC Proxy | +12-16 | `plans/designs/e36-websocket.md` | `worktree-agent-a9daf73703f520257` |
-| 37 | Tokenizer-as-API | +16-17 | `plans/designs/e37-tokenizer-api.md` | `worktree-agent-a6bb61d59cc0be8b4` |
-| 38 | SourceInfo API | +4 | `plans/designs/e38-sourceinfo.md` | `agent-e38-sourceinfo` |
-| 39 | WebWorker plugin (parser-only stub) | +1 | `plans/designs/e39-webworker.md` | `hs-design-e39-webworker` |
-| 40 | Real Fetch / non-2xx / before-fetch | +7 | `plans/designs/e40-real-fetch.md` | `worktree-agent-a94612a4283eaa5e0` |
-
-### Bucket F — generator translation gaps
-
-~25 tests SKIP'd because `tests/playwright/generate-sx-tests.py` bails with `return None`. Single dedicated generator-repair sit-down once Bucket D is drained. ~half-day.
-
-## Order of attack
-
-In approximate cost-per-test order:
-
-1. **Loop self-heal** (no human work) — wait for #29, #32 to land via the running loop ⏱️ ~next 1-2 hours
-2. **#31 null-safety** — biggest scoped single win, dedicated worktree agent (this session)
-3. **#33 cookie API remainder** — quick partial completion
-4. **#17 / #22 / #34 / #35** — small fiddly fixes, one sit-down each
-5. **Bucket E** — pick one subsystem at a time. **#39 (WebWorker stub) first** — single commit, smallest. Then **#38 (SourceInfo)** — 4 commits. Then the bigger three (#36, #37, #40).
-6. **Bucket F** — generator repair sweep at the end.
-
-Estimated total to 100%: ~10-15 days of focused work, parallelisable across branches.
-
-## Cluster #31 spec (full detail)
-
-The plan note from `hs-conformance-to-100.md`:
-
-> 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put.
-
-**Required pieces:**
-
-1. **Generator-side `eval-hs-error` helper + recognizer** for `expect(await error("HS")).toBe("MSG")` blocks. In `tests/playwright/generate-sx-tests.py`.
-2. **Runtime helpers** in `lib/hyperscript/runtime.sx`:
-   - `hs-null-error!` raising `'<sel>' is null`
-   - `hs-named-target` — wraps a query result with the original selector source
-   - `hs-named-target-list` — same for list results
-3. **Compiler patches at every target-position `(query SEL)` emit** — wrap in named-target carrying the original selector source. ~17 command emit paths in `lib/hyperscript/compiler.sx`:
-   add, remove, hide, show, measure, settle, trigger, send, set, default, increment, decrement, put, toggle, transition, append, take.
-4. **Function-call null-check** at bare `(name)`, `hs-method-call`, and `host-get` chains, deriving the leftmost-uncalled-name (`'x'` / `'x.y'`) from the parse tree.
-5. **Possessive-base null-check** (`set x's y to true` → `'x' is null`).
-
-**Files in scope:**
-- `lib/hyperscript/runtime.sx` (new helpers)
-- `lib/hyperscript/compiler.sx` (~17 emit-path edits)
-- `tests/playwright/generate-sx-tests.py` (test recognizer)
-- `tests/hs-run-filtered.js` (if mock helpers needed)
-- `shared/static/wasm/sx/hs-runtime.sx` + `hs-compiler.sx` (WASM staging copies)
-
-**Approach:** target-named pieces incrementally — runtime helpers first (no compiler change), then compiler emit paths in batches (group similar commands), then function-call/possessive at the end. Each batch is one commit if it lands +N tests; mark partial if it only unlocks part.
-
-**Watch for:** smoke-range regressions (tests flipping pass→fail). Each commit: rerun smoke 0-195 and the `runtimeErrors` suite.
-
-## Notes for future sessions
-
-- `plans/hs-conformance-to-100.md` is the canonical cluster ledger — update it on every commit.
-- `plans/hs-conformance-scoreboard.md` is the live tally — bump `Merged:` and the bucket roll-up.
-- Loop has scope rule "never edit `spec/evaluator.sx` or broader SX kernel" — most fixes here stay in `lib/hyperscript/**`, `tests/`, generator. If a fix needs kernel work, surface to the user; don't merge silently.
-- Cluster #22's `symbol-bound?` predicate would be a kernel addition — that's a real cross-boundary scope expansion.

plans/hs-conformance-scoreboard.md

@@ -4,10 +4,10 @@ Live tally for `plans/hs-conformance-to-100.md`. Update after every cluster comm
 
 ```
 Baseline:   1213/1496 (81.1%)
-Merged:     1303/1496 (87.1%)   delta +90
+Merged:     1277/1496 (85.4%)   delta +64
 Worktree:   all landed
 Target:     1496/1496 (100.0%)
-Remaining:  ~194 tests (clusters 17/29(partial)/31 blocked; 33/34 partial)
+Remaining:  ~219 tests (cluster 29 blocked on sx-tree MCP outage + parser scope)
 ```
 
 ## Cluster ledger
@@ -42,7 +42,7 @@ Remaining:  ~194 tests (clusters 17/29(partial)/31 blocked; 33/34 partial)
 | 19 | `pick` regex + indices | done | +13 | 4be90bf2 |
 | 20 | `repeat` property for-loops + where | done | +3 | c932ad59 |
 | 21 | `possessiveExpression` property access via its | done | +1 | f0c41278 |
-| 22 | window global fn fallback | done | +1 | d31565d5 |
+| 22 | window global fn fallback | blocked | — | — |
 | 23 | `me symbol works in from expressions` | done | +1 | 0d38a75b |
 | 24 | `properly interpolates values 2` | done | +1 | cb37259d |
 | 25 | parenthesized commands and features | done | +1 | d7a88d85 |
@@ -54,18 +54,18 @@ Remaining:  ~194 tests (clusters 17/29(partial)/31 blocked; 33/34 partial)
 | 26 | resize observer mock + `on resize` | done | +3 | 304a52d2 |
 | 27 | intersection observer mock + `on intersection` | done | +3 | 0c31dd27 |
 | 28 | `ask`/`answer` + prompt/confirm mock | done | +4 | 6c1da921 |
-| 29 | `hyperscript:before:init` / `:after:init` / `:parse-error` | partial | +2 | e01a3baa |
+| 29 | `hyperscript:before:init` / `:after:init` / `:parse-error` | blocked | — | — |
 | 30 | `logAll` config | done | +1 | 64bcefff |
 
 ### Bucket D — medium features
 
 | # | Cluster | Status | Δ |
 |---|---------|--------|---|
-| 31 | runtime null-safety error reporting | blocked | — |
-| 32 | MutationObserver mock + `on mutation` | done | +7 |
-| 33 | cookie API | partial | +4 |
-| 34 | event modifier DSL | partial | +7 |
-| 35 | namespaced `def` | done | +3 |
+| 31 | runtime null-safety error reporting | pending | (+15–18 est) |
+| 32 | MutationObserver mock + `on mutation` | pending | (+10–15 est) |
+| 33 | cookie API | pending | (+5 est) |
+| 34 | event modifier DSL | pending | (+6–8 est) |
+| 35 | namespaced `def` | pending | (+3 est) |
 
 ### Bucket E — subsystems (design docs landed, pending review + implementation)
 
@@ -86,9 +86,9 @@ Defer until A–D drain. Estimated ~25 recoverable tests.
 | Bucket | Done | Partial | In-prog | Pending | Blocked | Design-done | Total |
 |--------|-----:|--------:|--------:|--------:|--------:|------------:|------:|
 | A      | 12   | 4       | 0       | 0       | 1       | —           | 17    |
-| B      | 7    | 0       | 0       | 0       | 0       | —           | 7     |
-| C      | 4    | 1       | 0       | 0       | 0       | —           | 5     |
-| D      | 2    | 2       | 0       | 0       | 1       | —           | 5     |
+| B      | 6    | 0       | 0       | 0       | 1       | —           | 7     |
+| C      | 4    | 0       | 0       | 0       | 1       | —           | 5     |
+| D      | 0    | 0       | 0       | 5       | 0       | —           | 5     |
 | E      | 0    | 0       | 0       | 0       | 0       | 5           | 5     |
 | F      | —    | —       | —       | ~10     | —       | —           | ~10   |
 

plans/hs-conformance-to-100.md

@@ -69,7 +69,7 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
 
 10. **[done (+1)] `swap` variable ↔ property** — `swap / can swap a variable with a property` (1 test). Swap command doesn't handle mixed var/prop targets. Expected: +1.
 
-11. **[done (+4)] `hide` strategy** — `hide / can configure hidden as default`, `can hide with custom strategy`, `can set default to custom strategy`, `hide element then show element retains original display` (4 tests). Strategy config plumbing. Expected: +3-4.
+11. **[done (+3) — partial, `hide element then show element retains original display` remains; needs `on click N` count-filtered event handlers, out of scope for this cluster] `hide` strategy** — `hide / can configure hidden as default`, `can hide with custom strategy`, `can set default to custom strategy`, `hide element then show element retains original display` (4 tests). Strategy config plumbing. Expected: +3-4.
 
 12. **[done (+2)] `show` multi-element + display retention** — `show / can show multiple elements with inline-block`, `can filter over a set of elements using the its symbol` (2 tests). Expected: +2.
 
@@ -93,7 +93,7 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
 
 21. **[done (+1)] `possessiveExpression` property access via its** — `possessive / can access its properties` (1 test, Expected `foo` got ``). Expected: +1.
 
-22. **[done (+1)] window global fn fallback** — `regressions / can invoke functions w/ numbers in name` + `can refer to function in init blocks`. Added `host-call-fn` FFI primitive (commit 337c8265), `hs-win-call` runtime helper, simplified compiler emit (direct hs-win-call, no guard), `def` now also registers fn on `window[name]`. Generator: fixed `\"` escaping in hs-compile string literals. Expected: +2-4.
+22. **[blocked: tried three compile-time emits — (1) guard (can't catch Undefined symbol since it's a host-level error, not an SX raise), (2) env-has? (primitive not loaded in HS kernel — `Unhandled exception: "env-has?"`), and (3) hs-win-call runtime helper (works when reached but SX can't CALL a host-handle function directly — `Not callable: {:__host_handle N}` because NativeFn is not callable here). Needs either a host-call-fn primitive with arity-agnostic dispatch OR a symbol-bound? predicate in the HS kernel.] window global fn fallback** — `regressions / can invoke functions w/ numbers in name` + unlocks several others. When calling `foo()` where `foo` isn't SX-defined, fall back to `(host-global "foo")`. Design decision: either compile-time emit `(or foo (host-global "foo"))` via a helper, or add runtime lookup in the dispatch path. Expected: +2-4.
 
 23. **[done (+1)] `me symbol works in from expressions`** — `regressions` (1 test, Expected `Foo`). Check `from` expression compilation. Expected: +1.
 
@@ -109,21 +109,21 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
 
 28. **[done (+4)] `ask`/`answer` + prompt/confirm mock** — `askAnswer` 4 tests. **Requires test-name-keyed mock**: first test wants `confirm → true`, second `confirm → false`, third `prompt → "Alice"`, fourth `prompt → null`. Keyed via `_current-test-name` in the runner. Expected: +4.
 
-29. **[done (+2) — partial, 4 parser-error tests remain (basic parse error messages, parse-error event, EOF newline crash, evaluate-api-first-error). All require stricter parser error-rejection — `add - to` currently parses silently to `(set! nil (hs-add-to! (- 0 nil) nil))`, `on click blargh end on mouseenter also_bad` parses silently to `(do (hs-on me "click" (fn (event) blargh)) (hs-on me "mouseenter" (fn (event) also_bad)))`. Plus emit-error-collection runtime + hyperscript:parse-error event with detail.errors. Larger than a single cluster budget; recommend bucket-D plan-first.] `hyperscript:before:init` / `:after:init` / `:parse-error` events** — 6 tests in `bootstrap` + `parser`. Fire DOM events at activation boundaries. Expected: +4-6.
+29. **[blocked: sx-tree MCP tools returning Yojson Type_error on every file op. Can't edit integration.sx to add before:init/after:init dispatch. Also 4 of the 6 tests fundamentally require stricter parser error-rejection (add - to currently succeeds as SX expression; on click blargh end accepts blargh as symbol), which is larger than a single cluster budget.] `hyperscript:before:init` / `:after:init` / `:parse-error` events** — 6 tests in `bootstrap` + `parser`. Fire DOM events at activation boundaries. Expected: +4-6.
 
 30. **[done (+1)] `logAll` config** — 1 test. Global config that console.log's each command. Expected: +1.
 
 ### Bucket D: medium features (bigger commits, plan-first)
 
-31. **[blocked: Bucket-D plan-first scope, doesn't fit one cluster budget. All 18 tests are SKIP (untranslated) — generator has no `error("HS")` helper. Required pieces: (a) generator-side `eval-hs-error` helper + recognizer for `expect(await error("HS")).toBe("MSG")` blocks; (b) runtime helpers `hs-null-error!` / `hs-named-target` / `hs-named-target-list` raising `'<sel>' is null`; (c) compiler patches at every target-position `(query SEL)` emit to wrap in named-target carrying the original selector source — that's ~17 command emit paths (add, remove, hide, show, measure, settle, trigger, send, set, default, increment, decrement, put, toggle, transition, append, take); (d) function-call null-check at bare `(name)`, `hs-method-call`, and `host-get` chains, deriving the leftmost-uncalled-name `'x'` / `'x.y'` from the parse tree; (e) possessive-base null-check (`set x's y to true` → `'x' is null`). Each piece is straightforward in isolation but the cross-cutting compiler change touches every emit path and needs a coordinated design pass. Recommend a dedicated design doc + multi-commit worktree like buckets E36-E40.] runtime null-safety error reporting** — 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put. Expected: +15-18.
+31. **[pending] runtime null-safety error reporting** — 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put. Expected: +15-18.
 
-32. **[done (+7)] MutationObserver mock + `on mutation` dispatch** — 7 tests in `on`. Add MO mock to runner. Compile `on mutation [of attribute/childList/attribute-specific]`. Expected: +10-15.
+32. **[pending] MutationObserver mock + `on mutation` dispatch** — 15 tests in `on`. Add MO mock to runner. Compile `on mutation [of attribute/childList/attribute-specific]`. Expected: +10-15.
 
-33. **[done (+4) — partial, 1 test remains: `iterate cookies values work` needs `hs-for-each` to recognise host-array/proxy collections (currently `(list? collection)` returns false for the JS Proxy so the loop body never runs). Out of scope.] cookie API** — 5 tests in `expressions/cookies`. `document.cookie` mock in runner + `the cookies` + `set the xxx cookie` keywords. Expected: +5.
+33. **[pending] cookie API** — 5 tests in `expressions/cookies`. `document.cookie` mock in runner + `the cookies` + `set the xxx cookie` keywords. Expected: +5.
 
-34. **[done (+7) — partial, 1 test remains: `every` keyword multi-handler-execute test needs handler-queue semantics where `wait for X` doesn't block subsequent invocations of the same handler — current `hs-on-every` shares the same dom-listen plumbing as `hs-on` and queues events implicitly via JS event loop, so the third synthetic click waits for the prior handler's `wait for customEvent` to settle. Out of single-cluster scope.] event modifier DSL** — 8 tests in `on`. `elsewhere`, `every`, `first click`, count filters (`once / twice / 3 times`, ranges), `from elsewhere`. Expected: +6-8.
+34. **[pending] event modifier DSL** — 8 tests in `on`. `elsewhere`, `every`, `first click`, count filters (`once / twice / 3 times`, ranges), `from elsewhere`. Expected: +6-8.
 
-35. **[done (+3)] namespaced `def`** — 3 tests. `def ns.foo() ...` creates `ns.foo`. Expected: +3.
+35. **[pending] namespaced `def`** — 3 tests. `def ns.foo() ...` creates `ns.foo`. Expected: +3.
 
 ### Bucket E: subsystems (DO NOT LOOP — human-driven)
 
@@ -177,39 +177,6 @@ Many tests are `SKIP (untranslated)` because `tests/playwright/generate-sx-tests
 
 (Reverse chronological — newest at top.)
 
-### 2026-04-25 — Bucket F: in-expression filter semantics (+1)
-- **67a5f137** — `HS: in-expression filter semantics (+1 test)`. `1 in [1, 2, 3]` was returning boolean `true` instead of the filtered list `(list 1)`. Root cause: `in?` compiled to `hs-contains?` which returns boolean for scalar items. Fix: (a) `runtime.sx` adds `hs-in?` returning filtered list for all cases, plus `hs-in-bool?` which wraps with `(not (hs-falsy? ...))` for boolean contexts; (b) `compiler.sx` changes `in?` clause to emit `(hs-in? collection item)` and adds new `in-bool?` clause emitting `(hs-in-bool? collection item)`; (c) `parser.sx` changes `is in` and `am in` comparison forms to produce `in-bool?` so those stay boolean. Suite hs-upstream-expressions/in: 8/9 → 9/9. Smoke 0-195: 173/195 unchanged.
-
-### 2026-04-25 — cluster 22 window global fn fallback (+1)
-- **d31565d5** — `HS cluster 22: simplify win-call emit + def→window + init-blocks test (+1)`. Two-part change building on 337c8265 (host-call-fn FFI + hs-win-call runtime). (a) `compiler.sx` removes the guard wrapper from bare-call and method-call `hs-win-call` emit paths — direct `(hs-win-call name (list args))` is sufficient since hs-win-call returns nil for unknown names; `def` compilation now also emits `(host-set! (host-global "window") name fn)` so every HS-defined function is reachable via window lookup. (b) `generate-sx-tests.py` fixes a quoting bug: `\"here\"` was being embedded as three SX nodes (`""` + symbol + `""`) instead of a single escaped-quote string; fixed with `\\\"` escaping. Hand-rolled deftest for `can refer to function in init blocks` now passes. Suite hs-upstream-core/regressions: 13/16 → 14/16. Smoke 0-195: 172/195 → 173/195.
-
-### 2026-04-25 — cluster 11/33 followups: hide strategy + cookie clear (+2)
-- **5ff2b706** — `HS: cluster 11/33 followups (+2 tests)`. Three orthogonal fixes that pick up tests now unblocked by earlier work. (a) `parser.sx` `parse-hide-cmd`/`parse-show-cmd`: added `on` to the keyword set that flips the implicit-`me` target. Previously `on click 1 hide on click 2 show` silently parsed as `(hs-hide! nil ...)` because `parse-expr` started consuming `on` and returned nil; now hide/show recognise a sibling feature and default to `me`. (b) `runtime.sx` `hs-method-call` fallback for non-built-in methods: SX-callables (lambdas) call via `apply`, JS-native functions (e.g. `cookies.clear`) dispatch via `(apply host-call (cons obj (cons method args)))` so the native receives the args list. (c) Generator `hs-cleanup!` body wrapped in `begin` (fn body evaluates only the last expr) and now resets `hs-set-default-hide-strategy! nil` + `hs-set-log-all! false` between tests — the prior `can set default to custom strategy` cluster-11 test had been leaking `_hs-default-hide-strategy` into the rest of the suite, breaking `hide element then show element retains original display`. New cluster-33 hand-roll for `basic clear cookie values work` exercises the method-call fallback. Suite hs-upstream-hide: 15/16 → 16/16. Suite hs-upstream-expressions/cookies: 3/5 → 4/5. Smoke 0-195 unchanged at 172/195.
-
-### 2026-04-25 — cluster 35 namespaced def + script-tag globals (+3)
-- **122053ed** — `HS: namespaced def + script-tag global functions (+3 tests)`. Two-part change: (a) `runtime.sx` `hs-method-call` gains a fallback for unknown methods — `(let ((fn-val (host-get obj method))) (if (callable? fn-val) (apply fn-val args) nil))`. This lets `utils.foo()` dispatch through `(host-get utils "foo")` when `utils` is an SX dict whose `foo` is an SX lambda. (b) Generator hand-rolls 3 deftests since the SX runtime has no `<script type='text/hyperscript'>` tag boot. For `is called synchronously` / `can call asynchronously`: `(eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def foo() ... end")))))` registers the function in the global eval env (eval-expr-cek processes `(define foo (fn ...))` at top scope), then a click div is built via dom-set-attr + hs-boot-subtree!. For `functions can be namespaced`: define `utils` as a dict, register `__utils_foo` as a fresh-named global def, then `(host-set! utils "foo" __utils_foo)` populates the dict; click handler `call utils.foo()` compiles to `(hs-method-call utils "foo")` which now dispatches through the new runtime fallback. Skip-list cleared of the 3 def entries. Suite hs-upstream-def: 24/27 → 27/27. Smoke 0-195 unchanged at 172/195.
-
-### 2026-04-25 — cluster 34 elsewhere / from-elsewhere modifier (+2)
-- **3044a168** — `HS: elsewhere / from elsewhere modifier (+2 tests)`. Three-part change: (a) `parser.sx` `parse-on-feat` parses an optional `elsewhere` (or `from elsewhere`) modifier between event-name and source. The `from elsewhere` variant uses a one-token lookahead so plain `from #target` keeps parsing as a source expression. Emits `:elsewhere true` part. (b) `compiler.sx` `scan-on` threads `elsewhere?` (10th param) through every recursive call + new `:elsewhere` cond branch. The dispatch case becomes a 3-way `cond` over target: elsewhere → `(dom-body)` (listener attaches to body and bubble sees every click), source → from-source, default → `me`. The `compiled-body` build is wrapped with `(when (not (host-call me "contains" (host-get event "target"))) BODY)` so handlers fire only on outside-of-`me` clicks. (c) Generator drops `supports "elsewhere" modifier` and `supports "from elsewhere" modifier` from `SKIP_TEST_NAMES`. Suite hs-upstream-on: 48/70 → 50/70. Smoke 0-195 unchanged at 172/195.
-
-### 2026-04-25 — cluster 34 count-filtered events + first modifier (+5 partial)
-- **19c97989** — `HS: count-filtered events + first modifier (+5 tests)`. Three-part change: (a) `parser.sx` `parse-on-feat` accepts `first` keyword before event-name (sets `cnt-min/max=1`), then optionally parses a count expression after event-name: bare number = exact count, `N to M` = inclusive range, `N and on` = unbounded above. Number tokens coerced via `parse-number`. New parts entry `:count-filter {"min" N "max" M-or--1}`. (b) `compiler.sx` `scan-on` gains a 9th `count-filter-info` param threaded through every recursive call + a new `:count-filter` cond branch. The handler binding now wraps the `(fn (event) BODY)` in `(let ((__hs-count 0)) (fn (event) (begin (set! __hs-count (+ __hs-count 1)) (when COUNT-CHECK BODY))))` when count info is present. Each `on EVENT N ...` clause produces its own closure-captured counter, so `on click 1` / `on click 2` / `on click 3` fire on their respective Nth click (mix-ranges test). (c) Generator drops 5 entries from `SKIP_TEST_NAMES` — `can filter events based on count`/`...count range`/`...unbounded count range`/`can mix ranges`/`on first click fires only once`. Suite hs-upstream-on: 43/70 → 48/70. Smoke 0-195 unchanged at 172/195. Remaining cluster-34 work (`elsewhere`/`from elsewhere`/`every`-keyword multi-handler) is independent from count filters and would need a separate iteration.
-
-### 2026-04-25 — cluster 29 hyperscript init events (+2 partial)
-- **e01a3baa** — `HS: hyperscript:before:init / :after:init events (+2 tests)`. `integration.sx` `hs-activate!` now wraps the activation block in `(when (dom-dispatch el "hyperscript:before:init" nil) ...)` — `dom-dispatch` builds a CustomEvent with `bubbles:true`, the mock El's `cancelable` defaults to true, `dispatchEvent` returns `!ev.defaultPrevented`, so `when` skips the activate body if a listener called `preventDefault()`. After activation completes successfully it dispatches `hyperscript:after:init`. Generator (`tests/playwright/generate-sx-tests.py`) gains two hand-rolled deftests: `fires hyperscript:before:init and hyperscript:after:init` builds a wa container, attaches listeners that append to a captured `events` list, sets innerHTML to a div with `_=`, calls `hs-boot-subtree!`, asserts the events list. `hyperscript:before:init can cancel initialization` attaches a preventDefault listener and asserts `data-hyperscript-powered` is absent on the inner div after boot. Suite hs-upstream-core/bootstrap: 20/26 → 22/26. Smoke 0-195: 170 → 172. Remaining 4 cluster-29 tests (basic parse error messages, parse-error event, EOF newline, eval-API throws on first error) all need stricter parser error-rejection plus a parse-error collector — recommend bucket-D plan-first multi-commit, not a single iteration.
-
-### 2026-04-25 — cluster 32 MutationObserver mock + on mutation dispatch (+7)
-- **13e02542** — `HS: MutationObserver mock + on mutation dispatch (+7 tests)`. Five-part change: (a) `parser.sx` `parse-on-feat` now consumes `of <FILTER>` after `mutation` event-name. FILTER is one of `attributes`/`childList`/`characterData` (ident tokens) or one or more `@name` attr-tokens chained by `or`. Emits `:of-filter {"type" T "attrs" L?}` part. (b) `compiler.sx` `scan-on` threads new `of-filter-info` param; the dispatch case becomes a `cond` over `event-name` — for `"mutation"` it emits `(do on-call (hs-on-mutation-attach! target MODE ATTRS))` where ATTRS is `(cons 'list attr-list)` so the list survives compile→eval. (c) `runtime.sx` `hs-on-mutation-attach!` builds a config dict (`attributes`/`childList`/`characterData`/`subtree`/`attributeFilter`) matched to mode, constructs a real `MutationObserver(cb)`, calls `mo.observe(target, opts)`, and the cb dispatches a `"mutation"` event on target. (d) `tests/hs-run-filtered.js` replaces the no-op MO with `HsMutationObserver` (global registry, decodes SX-list `attributeFilter`); prototype hooks on `El.setAttribute/appendChild/removeChild/_setInnerHTML` fire matching observers synchronously, with `__hsMutationActive` re-entry guard so handlers that mutate the DOM don't infinite-loop. Per-test reset clears registry + flag. (e) `generate-sx-tests.py` drops 7 mutation entries from `SKIP_TEST_NAMES` and adds two body patterns: `evaluate(() => document.querySelector(SEL).setAttribute(N,V))` → `(dom-set-attr ...)`, and `evaluate(() => document.querySelector(SEL).appendChild(document.createElement(T)))` → `(dom-append … (dom-create-element …))`. Suite hs-upstream-on: 36/70 → 43/70. Smoke 0-195 unchanged at 170/195.
-
-### 2026-04-25 — cluster 33 cookie API (partial +3)
-- No `.sx` edits needed — `set cookies.foo to 'bar'` already compiles to `(dom-set-prop cookies "foo" "bar")` which becomes `(host-set! cookies "foo" "bar")` once the `dom` module is loaded, and `cookies.foo` becomes `(host-get cookies "foo")`. So a JS-only Proxy + Python generator change does the trick. Two parts: (a) `tests/hs-run-filtered.js` adds a per-test `__hsCookieStore` Map, a `globalThis.cookies` Proxy with `length`/`clear`/named-key get traps and a set trap that writes the store, and a `Object.defineProperty(document, 'cookie', …)` getter/setter that reads and writes the same store (so the upstream `length is 0` test's pre-clear loop over `document.cookie` works). Per-test reset clears the store. (b) `tests/playwright/generate-sx-tests.py` declares `(define cookies (host-global "cookies"))` in the test header and emits hand-rolled deftests for the three tractable tests (`basic set`, `update`, `length is 0`). Suite hs-upstream-expressions/cookies: 0/5 → 3/5. Smoke 0-195 unchanged at 170/195. Remaining `basic clear` and `iterate` tests need runtime.sx edits (hs-method-call fallback + hs-for-each host-array recognition) — out of scope for a JS-only iteration.
-
-### 2026-04-25 — cluster 32 MutationObserver mock + on mutation dispatch (blocked)
-- Two issues conspire: (1) `loops/hs` worktree has no pre-built sx-tree binary so MCP tools aren't loaded, and the block-sx-edit hook prevents raw `Edit`/`Read`/`Write` on `.sx` files. Built `hosts/ocaml/_build/default/bin/mcp_tree.exe` via `dune build` this iteration but tools don't surface mid-session. (2) Cluster scope is genuinely big: parser must learn `on mutation of <filter>` (currently drops body after `of` — verified via compile dump: `on mutation of attributes put "Mutated" into me` → `(hs-on me "mutation" (fn (event) nil))`), compiler needs `:of-filter` plumbing similar to intersection's `:having`, runtime needs `hs-on-mutation-attach!`, JS runner mock needs a real MutationObserver (currently no-op `class{observe(){}disconnect(){}}` at hs-run-filtered.js:348) plus `setAttribute`/`appendChild` instrumentation, and 7 entries removed from `SKIP_TEST_NAMES`. Recommended next step: dedicated worktree where sx-tree loads at session start, multi-commit shape (parser → compiler+attach → mock+runner → generator skip-list).
-
-### 2026-04-25 — cluster 31 runtime null-safety error reporting (blocked)
-- All 18 tests are `SKIP (untranslated)` — generator has no `error("HS")` helper at all. Inspected representative compile outputs: `add .foo to #doesntExist` → `(for-each ... (hs-query-all "#doesntExist"))` (silently no-ops on empty list, no error); `hide #doesntExist` → `(hs-hide! (hs-query-all "#doesntExist") "display")` (likewise); `put 'foo' into #doesntExist` → `(hs-set-inner-html! (hs-query-first "#doesntExist") "foo")` (passes nil through); `x()` → `(x)` (raises `Undefined symbol: x`, wrong format); `x.y.z()` → `(hs-method-call (host-get x "y") "z")`. Implementing this requires generator helper + 17 compiler emit-path patches + function-call/method-call/possessive-base null guards + new `hs-named-target`/`hs-named-target-list` runtime — too many surfaces for a single-iteration commit. Bucket D explicitly says "plan-first" — recommended path is a dedicated design doc and multi-commit worktree like E36-E40, not a loop iteration.
-
 ### 2026-04-24 — cluster 29 hyperscript:before:init / :after:init / :parse-error (blocked)
 - **2b486976** — `HS-plan: mark cluster 29 blocked`. sx-tree MCP file ops returning `Yojson__Safe.Util.Type_error("Expected string, got null")` on every file-based call (sx_read_subtree, sx_find_all, sx_replace_by_pattern, sx_summarise, sx_pretty_print, sx_write_file). Only in-memory ops work (sx_eval, sx_build, sx_env). Without sx-tree I can't edit integration.sx to add before:init/after:init dispatch on hs-activate!. Investigated the 6 tests: 2 bootstrap (before/after init) need dispatchEvent wrapping activate; 4 parser tests require stricter parser error-rejection — `add - to` currently parses silently to `(set! nil (hs-add-to! (- 0 nil) nil))`, `on click blargh end on mouseenter also_bad` parses silently to `(do (hs-on me "click" (fn (event) blargh)) (hs-on me "mouseenter" (fn (event) also_bad)))`. Fundamental parser refactor is out of single-cluster budget regardless of sx-tree availability.
 

shared/static/wasm/sx/hs-compiler.sx

@@ -164,16 +164,13 @@
                   every?
                   catch-info
                   finally-info
-                  having-info
-                  of-filter-info
-                  count-filter-info
-                  elsewhere?)
+                  having-info)
                 (cond
                   ((<= (len items) 1)
                     (let
                       ((body (if (> (len items) 0) (first items) nil)))
                       (let
-                        ((target (cond (elsewhere? (list (quote dom-body))) (source (hs-to-sx source)) (true (quote me)))))
+                        ((target (if source (hs-to-sx source) (quote me))))
                         (let
                           ((event-refs (if (and (list? body) (= (first body) (quote do))) (filter (fn (x) (and (list? x) (= (first x) (quote ref)))) (rest body)) (list))))
                           (let
@@ -181,51 +178,30 @@
                             (let
                               ((raw-compiled (hs-to-sx stripped-body)))
                               (let
-                                ((compiled-body (let ((base (if (> (len event-refs) 0) (let ((bindings (map (fn (r) (let ((name (nth r 1))) (list (make-symbol name) (list (quote host-get) (list (quote host-get) (quote event) "detail") name)))) event-refs))) (list (quote let) bindings raw-compiled)) raw-compiled))) (if elsewhere? (list (quote when) (list (quote not) (list (quote host-call) (quote me) "contains" (list (quote host-get) (quote event) "target"))) base) base))))
+                                ((compiled-body (if (> (len event-refs) 0) (let ((bindings (map (fn (r) (let ((name (nth r 1))) (list (make-symbol name) (list (quote host-get) (list (quote host-get) (quote event) "detail") name)))) event-refs))) (list (quote let) bindings raw-compiled)) raw-compiled)))
                                 (let
                                   ((wrapped-body (if catch-info (let ((var (make-symbol (nth catch-info 0))) (catch-body (hs-to-sx (nth catch-info 1)))) (if finally-info (list (quote do) (list (quote guard) (list var (list true catch-body)) compiled-body) (hs-to-sx finally-info)) (list (quote guard) (list var (list true catch-body)) compiled-body))) (if finally-info (list (quote do) compiled-body (hs-to-sx finally-info)) compiled-body))))
                                   (let
-                                    ((handler (let ((uses-the-result? (fn (expr) (cond ((= expr (quote the-result)) true) ((list? expr) (some (fn (x) (uses-the-result? x)) expr)) (true false))))) (let ((base-handler (list (quote fn) (list (quote event)) (if (uses-the-result? wrapped-body) (list (quote let) (list (list (quote the-result) nil)) wrapped-body) wrapped-body)))) (if count-filter-info (let ((mn (get count-filter-info "min")) (mx (get count-filter-info "max"))) (list (quote let) (list (list (quote __hs-count) 0)) (list (quote fn) (list (quote event)) (list (quote begin) (list (quote set!) (quote __hs-count) (list (quote +) (quote __hs-count) 1)) (list (quote when) (if (= mx -1) (list (quote >=) (quote __hs-count) mn) (list (quote and) (list (quote >=) (quote __hs-count) mn) (list (quote <=) (quote __hs-count) mx))) (nth base-handler 2)))))) base-handler)))))
+                                    ((handler (let ((uses-the-result? (fn (expr) (cond ((= expr (quote the-result)) true) ((list? expr) (some (fn (x) (uses-the-result? x)) expr)) (true false))))) (list (quote fn) (list (quote event)) (if (uses-the-result? wrapped-body) (list (quote let) (list (list (quote the-result) nil)) wrapped-body) wrapped-body)))))
                                     (let
                                       ((on-call (if every? (list (quote hs-on-every) target event-name handler) (list (quote hs-on) target event-name handler))))
-                                      (cond
-                                        ((= event-name "mutation")
+                                      (if
+                                        (= event-name "intersection")
+                                        (list
+                                          (quote do)
+                                          on-call
                                           (list
-                                            (quote do)
-                                            on-call
-                                            (list
-                                              (quote hs-on-mutation-attach!)
-                                              target
-                                              (if
-                                                of-filter-info
-                                                (get of-filter-info "type")
-                                                "any")
-                                              (if
-                                                of-filter-info
-                                                (let
-                                                  ((a (get of-filter-info "attrs")))
-                                                  (if
-                                                    a
-                                                    (cons (quote list) a)
-                                                    nil))
-                                                nil))))
-                                        ((= event-name "intersection")
-                                          (list
-                                            (quote do)
-                                            on-call
-                                            (list
-                                              (quote
-                                                hs-on-intersection-attach!)
-                                              target
-                                              (if
-                                                having-info
-                                                (get having-info "margin")
-                                                nil)
-                                              (if
-                                                having-info
-                                                (get having-info "threshold")
-                                                nil))))
-                                        (true on-call))))))))))))
+                                            (quote hs-on-intersection-attach!)
+                                            target
+                                            (if
+                                              having-info
+                                              (get having-info "margin")
+                                              nil)
+                                            (if
+                                              having-info
+                                              (get having-info "threshold")
+                                              nil)))
+                                        on-call)))))))))))
                   ((= (first items) :from)
                     (scan-on
                       (rest (rest items))
@@ -234,10 +210,7 @@
                       every?
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :filter)
                     (scan-on
                       (rest (rest items))
@@ -246,10 +219,7 @@
                       every?
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :every)
                     (scan-on
                       (rest (rest items))
@@ -258,10 +228,7 @@
                       true
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :catch)
                     (scan-on
                       (rest (rest items))
@@ -270,10 +237,7 @@
                       every?
                       (nth items 1)
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :finally)
                     (scan-on
                       (rest (rest items))
@@ -282,10 +246,7 @@
                       every?
                       catch-info
                       (nth items 1)
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
+                      having-info))
                   ((= (first items) :having)
                     (scan-on
                       (rest (rest items))
@@ -294,45 +255,6 @@
                       every?
                       catch-info
                       finally-info
-                      (nth items 1)
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?))
-                  ((= (first items) :of-filter)
-                    (scan-on
-                      (rest (rest items))
-                      source
-                      filter
-                      every?
-                      catch-info
-                      finally-info
-                      having-info
-                      (nth items 1)
-                      count-filter-info
-                      elsewhere?))
-                  ((= (first items) :count-filter)
-                    (scan-on
-                      (rest (rest items))
-                      source
-                      filter
-                      every?
-                      catch-info
-                      finally-info
-                      having-info
-                      of-filter-info
-                      (nth items 1)
-                      elsewhere?))
-                  ((= (first items) :elsewhere)
-                    (scan-on
-                      (rest (rest items))
-                      source
-                      filter
-                      every?
-                      catch-info
-                      finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
                       (nth items 1)))
                   (true
                     (scan-on
@@ -342,11 +264,8 @@
                       every?
                       catch-info
                       finally-info
-                      having-info
-                      of-filter-info
-                      count-filter-info
-                      elsewhere?)))))
-            (scan-on (rest parts) nil nil false nil nil nil nil nil false)))))
+                      having-info)))))
+            (scan-on (rest parts) nil nil false nil nil nil)))))
     (define
       emit-send
       (fn
@@ -1058,17 +977,9 @@
                       (cons
                         (quote hs-method-call)
                         (cons obj (cons method args))))
-                    (if
-                      (and
-                        (list? dot-node)
-                        (= (first dot-node) (quote ref)))
-                      (list
-                        (quote hs-win-call)
-                        (nth dot-node 1)
-                        (cons (quote list) args))
-                      (cons
-                        (quote hs-method-call)
-                        (cons (hs-to-sx dot-node) args))))))
+                    (cons
+                      (quote hs-method-call)
+                      (cons (hs-to-sx dot-node) args)))))
               ((= head (quote string-postfix))
                 (list (quote str) (hs-to-sx (nth ast 1)) (nth ast 2)))
               ((= head (quote block-literal))
@@ -1238,12 +1149,7 @@
                 (list (quote hs-coerce) (hs-to-sx (nth ast 1)) (nth ast 2)))
               ((= head (quote in?))
                 (list
-                  (quote hs-in?)
-                  (hs-to-sx (nth ast 2))
-                  (hs-to-sx (nth ast 1))))
-              ((= head (quote in-bool?))
-                (list
-                  (quote hs-in-bool?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 2))
                   (hs-to-sx (nth ast 1))))
               ((= head (quote of))
@@ -1727,19 +1633,7 @@
                               body)))
                         (nth compiled (- (len compiled) 1))
                         (rest (reverse compiled)))
-                      (let
-                        ((defs (filter (fn (c) (and (list? c) (> (len c) 0) (= (first c) (quote define)))) compiled))
-                          (non-defs
-                            (filter
-                              (fn
-                                (c)
-                                (not
-                                  (and
-                                    (list? c)
-                                    (> (len c) 0)
-                                    (= (first c) (quote define)))))
-                              compiled)))
-                        (cons (quote do) (append defs non-defs)))))))
+                      (cons (quote do) compiled)))))
               ((= head (quote wait)) (list (quote hs-wait) (nth ast 1)))
               ((= head (quote wait-for)) (emit-wait-for ast))
               ((= head (quote log))
@@ -1847,13 +1741,7 @@
                         (make-symbol raw-fn)
                         (hs-to-sx raw-fn)))
                     (args (map hs-to-sx (rest (rest ast)))))
-                  (if
-                    (and (list? raw-fn) (= (first raw-fn) (quote ref)))
-                    (list
-                      (quote hs-win-call)
-                      (nth raw-fn 1)
-                      (cons (quote list) args))
-                    (cons fn-expr args))))
+                  (cons fn-expr args)))
               ((= head (quote return))
                 (let
                   ((val (nth ast 1)))
@@ -2041,39 +1929,26 @@
                     (quote define)
                     (make-symbol (nth ast 1))
                     (list
-                      (quote let)
+                      (quote fn)
+                      params
                       (list
+                        (quote guard)
                         (list
-                          (quote _hs-def-val)
+                          (quote _e)
                           (list
-                            (quote fn)
-                            params
+                            (quote true)
                             (list
-                              (quote guard)
+                              (quote if)
                               (list
-                                (quote _e)
+                                (quote and)
+                                (list (quote list?) (quote _e))
                                 (list
-                                  (quote true)
-                                  (list
-                                    (quote if)
-                                    (list
-                                      (quote and)
-                                      (list (quote list?) (quote _e))
-                                      (list
-                                        (quote =)
-                                        (list (quote first) (quote _e))
-                                        "hs-return"))
-                                    (list (quote nth) (quote _e) 1)
-                                    (list (quote raise) (quote _e)))))
-                              body))))
-                      (list
-                        (quote do)
-                        (list
-                          (quote host-set!)
-                          (list (quote host-global) "window")
-                          (nth ast 1)
-                          (quote _hs-def-val))
-                        (quote _hs-def-val))))))
+                                  (quote =)
+                                  (list (quote first) (quote _e))
+                                  "hs-return"))
+                              (list (quote nth) (quote _e) 1)
+                              (list (quote raise) (quote _e)))))
+                        body)))))
               ((= head (quote behavior)) (emit-behavior ast))
               ((= head (quote sx-eval))
                 (let
@@ -2123,7 +1998,7 @@
                     (hs-to-sx (nth ast 1)))))
               ((= head (quote in?))
                 (list
-                  (quote hs-in?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 2))
                   (hs-to-sx (nth ast 1))))
               ((= head (quote type-check))

shared/static/wasm/sx/hs-integration.sx

@@ -80,14 +80,11 @@
       ((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
       (when
         (and src (not (= src prev)))
-        (when
-          (dom-dispatch el "hyperscript:before:init" nil)
-          (hs-log-event! "hyperscript:init")
-          (dom-set-data el "hs-script" src)
-          (dom-set-data el "hs-active" true)
-          (dom-set-attr el "data-hyperscript-powered" "true")
-          (let ((handler (hs-handler src))) (handler el))
-          (dom-dispatch el "hyperscript:after:init" nil))))))
+        (hs-log-event! "hyperscript:init")
+        (dom-set-data el "hs-script" src)
+        (dom-set-data el "hs-active" true)
+        (dom-set-attr el "data-hyperscript-powered" "true")
+        (let ((handler (hs-handler src))) (handler el))))))
 
 ;; ── Boot: scan entire document ──────────────────────────────────
 ;; Called once at page load. Finds all elements with _ attribute,

shared/static/wasm/sx/hs-parser.sx

@@ -495,8 +495,7 @@
                             (quote and)
                             (list (quote >=) left lo)
                             (list (quote <=) left hi)))))
-                    ((match-kw "in")
-                      (list (quote in-bool?) left (parse-expr)))
+                    ((match-kw "in") (list (quote in?) left (parse-expr)))
                     ((match-kw "really")
                       (do
                         (match-kw "equal")
@@ -572,8 +571,7 @@
                           (let
                             ((right (parse-expr)))
                             (list (quote not) (list (quote =) left right))))))
-                    ((match-kw "in")
-                      (list (quote in-bool?) left (parse-expr)))
+                    ((match-kw "in") (list (quote in?) left (parse-expr)))
                     ((match-kw "empty") (list (quote empty?) left))
                     ((match-kw "between")
                       (let
@@ -1557,7 +1555,7 @@
         (fn
           ()
           (let
-            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show") (= (tp-val) "on"))) (list (quote me))) (true (parse-expr)))))
+            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show"))) (list (quote me))) (true (parse-expr)))))
             (let
               ((strategy (if (match-kw "with") (if (at-end?) "display" (let ((s (tp-val))) (do (adv!) (cond ((at-end?) s) ((= (tp-type) "colon") (do (adv!) (let ((v (tp-val))) (do (adv!) (str s ":" v))))) ((= (tp-type) "local") (let ((v (tp-val))) (do (adv!) (str s ":" v)))) (true s))))) "display")))
               (let
@@ -1568,7 +1566,7 @@
         (fn
           ()
           (let
-            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show") (= (tp-val) "on"))) (list (quote me))) (true (parse-expr)))))
+            ((tgt (cond ((at-end?) (list (quote me))) ((and (= (tp-type) "keyword") (or (= (tp-val) "then") (= (tp-val) "end") (= (tp-val) "with") (= (tp-val) "when") (= (tp-val) "add") (= (tp-val) "remove") (= (tp-val) "set") (= (tp-val) "put") (= (tp-val) "toggle") (= (tp-val) "hide") (= (tp-val) "show"))) (list (quote me))) (true (parse-expr)))))
             (let
               ((strategy (if (match-kw "with") (if (at-end?) "display" (let ((s (tp-val))) (do (adv!) (cond ((at-end?) s) ((= (tp-type) "colon") (do (adv!) (let ((v (tp-val))) (do (adv!) (str s ":" v))))) ((= (tp-type) "local") (let ((v (tp-val))) (do (adv!) (str s ":" v)))) (true s))))) "display")))
               (let
@@ -2603,77 +2601,63 @@
         (fn
           ()
           (let
-            ((every? (match-kw "every")) (first? (match-kw "first")))
+            ((every? (match-kw "every")))
             (let
               ((event-name (parse-compound-event-name)))
               (let
-                ((count-filter (let ((mn nil) (mx nil)) (when first? (do (set! mn 1) (set! mx 1))) (when (= (tp-type) "number") (let ((n (parse-number (tp-val)))) (do (adv!) (set! mn n) (cond ((match-kw "to") (cond ((= (tp-type) "number") (let ((mv (parse-number (tp-val)))) (do (adv!) (set! mx mv)))) (true (set! mx n)))) ((match-kw "and") (cond ((match-kw "on") (set! mx -1)) (true (set! mx n)))) (true (set! mx n)))))) (if mn (dict "min" mn "max" mx) nil))))
+                ((flt (if (= (tp-type) "bracket-open") (do (adv!) (let ((f (parse-expr))) (if (= (tp-type) "bracket-close") (adv!) nil) f)) nil)))
                 (let
-                  ((of-filter (when (and (= event-name "mutation") (match-kw "of")) (cond ((and (= (tp-type) "ident") (or (= (tp-val) "attributes") (= (tp-val) "childList") (= (tp-val) "characterData"))) (let ((nm (tp-val))) (do (adv!) (dict "type" nm)))) ((= (tp-type) "attr") (let ((attrs (list (tp-val)))) (do (adv!) (define collect-or! (fn () (when (match-kw "or") (cond ((= (tp-type) "attr") (do (set! attrs (append attrs (list (tp-val)))) (adv!) (collect-or!))) (true (set! p (- p 1))))))) (collect-or!) (dict "type" "attrs" "attrs" attrs)))) (true nil)))))
+                  ((source (if (match-kw "from") (parse-expr) nil)))
                   (let
-                    ((flt (if (= (tp-type) "bracket-open") (do (adv!) (let ((f (parse-expr))) (if (= (tp-type) "bracket-close") (adv!) nil) f)) nil)))
+                    ((h-margin nil) (h-threshold nil))
+                    (define
+                      consume-having!
+                      (fn
+                        ()
+                        (cond
+                          ((and (= (tp-type) "ident") (= (tp-val) "having"))
+                            (do
+                              (adv!)
+                              (cond
+                                ((and (= (tp-type) "ident") (= (tp-val) "margin"))
+                                  (do
+                                    (adv!)
+                                    (set! h-margin (parse-expr))
+                                    (consume-having!)))
+                                ((and (= (tp-type) "ident") (= (tp-val) "threshold"))
+                                  (do
+                                    (adv!)
+                                    (set! h-threshold (parse-expr))
+                                    (consume-having!)))
+                                (true nil))))
+                          (true nil))))
+                    (consume-having!)
                     (let
-                      ((elsewhere? (cond ((match-kw "elsewhere") true) ((and (= (tp-type) "keyword") (= (tp-val) "from") (let ((nxt (if (< (+ p 1) tok-len) (nth tokens (+ p 1)) nil))) (and nxt (= (get nxt "type") "keyword") (= (get nxt "value") "elsewhere")))) (do (adv!) (adv!) true)) (true false)))
-                        (source (if (match-kw "from") (parse-expr) nil)))
+                      ((having (if (or h-margin h-threshold) (dict "margin" h-margin "threshold" h-threshold) nil)))
                       (let
-                        ((h-margin nil) (h-threshold nil))
-                        (define
-                          consume-having!
-                          (fn
-                            ()
-                            (cond
-                              ((and (= (tp-type) "ident") (= (tp-val) "having"))
-                                (do
-                                  (adv!)
-                                  (cond
-                                    ((and (= (tp-type) "ident") (= (tp-val) "margin"))
-                                      (do
-                                        (adv!)
-                                        (set! h-margin (parse-expr))
-                                        (consume-having!)))
-                                    ((and (= (tp-type) "ident") (= (tp-val) "threshold"))
-                                      (do
-                                        (adv!)
-                                        (set! h-threshold (parse-expr))
-                                        (consume-having!)))
-                                    (true nil))))
-                              (true nil))))
-                        (consume-having!)
+                        ((body (parse-cmd-list)))
                         (let
-                          ((having (if (or h-margin h-threshold) (dict "margin" h-margin "threshold" h-threshold) nil)))
+                          ((catch-clause (if (match-kw "catch") (let ((var (let ((v (tp-val))) (adv!) v)) (handler (parse-cmd-list))) (list var handler)) nil))
+                            (finally-clause
+                              (if (match-kw "finally") (parse-cmd-list) nil)))
+                          (match-kw "end")
                           (let
-                            ((body (parse-cmd-list)))
+                            ((parts (list (quote on) event-name)))
                             (let
-                              ((catch-clause (if (match-kw "catch") (let ((var (let ((v (tp-val))) (adv!) v)) (handler (parse-cmd-list))) (list var handler)) nil))
-                                (finally-clause
-                                  (if
-                                    (match-kw "finally")
-                                    (parse-cmd-list)
-                                    nil)))
-                              (match-kw "end")
+                              ((parts (if every? (append parts (list :every true)) parts)))
                               (let
-                                ((parts (list (quote on) event-name)))
+                                ((parts (if flt (append parts (list :filter flt)) parts)))
                                 (let
-                                  ((parts (if every? (append parts (list :every true)) parts)))
+                                  ((parts (if source (append parts (list :from source)) parts)))
                                   (let
-                                    ((parts (if flt (append parts (list :filter flt)) parts)))
+                                    ((parts (if having (append parts (list :having having)) parts)))
                                     (let
-                                      ((parts (if elsewhere? (append parts (list :elsewhere true)) parts)))
+                                      ((parts (if catch-clause (append parts (list :catch catch-clause)) parts)))
                                       (let
-                                        ((parts (if source (append parts (list :from source)) parts)))
+                                        ((parts (if finally-clause (append parts (list :finally finally-clause)) parts)))
                                         (let
-                                          ((parts (if count-filter (append parts (list :count-filter count-filter)) parts)))
-                                          (let
-                                            ((parts (if of-filter (append parts (list :of-filter of-filter)) parts)))
-                                            (let
-                                              ((parts (if having (append parts (list :having having)) parts)))
-                                              (let
-                                                ((parts (if catch-clause (append parts (list :catch catch-clause)) parts)))
-                                                (let
-                                                  ((parts (if finally-clause (append parts (list :finally finally-clause)) parts)))
-                                                  (let
-                                                    ((parts (append parts (list body))))
-                                                    parts)))))))))))))))))))))))
+                                          ((parts (append parts (list body))))
+                                          parts))))))))))))))))))
       (define
         parse-init-feat
         (fn
@@ -2749,7 +2733,6 @@
               ((= val "behavior") (do (adv!) (parse-behavior-feat)))
               ((= val "live") (do (adv!) (parse-live-feat)))
               ((= val "when") (do (adv!) (parse-when-feat)))
-              ((= val "worker") (error "worker plugin is not installed — see https://hyperscript.org/features/worker"))
               (true (parse-cmd-list))))))
       (define
         coll-feats

shared/static/wasm/sx/hs-runtime.sx

@@ -82,36 +82,14 @@
           observer)))))
 
 ;; Wait for CSS transitions/animations to settle on an element.
-(define
-  hs-on-mutation-attach!
-  (fn
-    (target mode attr-list)
-    (let
-      ((cfg-attributes (or (= mode "any") (= mode "attributes") (= mode "attrs")))
-        (cfg-childList (or (= mode "any") (= mode "childList")))
-        (cfg-characterData (or (= mode "any") (= mode "characterData"))))
-      (let
-        ((opts (dict "attributes" cfg-attributes "childList" cfg-childList "characterData" cfg-characterData "subtree" true)))
-        (when
-          (and (= mode "attrs") attr-list)
-          (dict-set! opts "attributeFilter" attr-list))
-        (let
-          ((cb (fn (records observer) (dom-dispatch target "mutation" (dict "records" records)))))
-          (let
-            ((observer (host-new "MutationObserver" cb)))
-            (host-call observer "observe" target opts)
-            observer))))))
+(define hs-init (fn (thunk) (thunk)))
 
 ;; ── Class manipulation ──────────────────────────────────────────
 
 ;; Toggle a single class on an element.
-(define hs-init (fn (thunk) (thunk)))
-
-;; Toggle between two classes — exactly one is active at a time.
 (define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
 
-;; Take a class from siblings — add to target, remove from others.
-;; (hs-take! target cls) — like radio button class behavior
+;; Toggle between two classes — exactly one is active at a time.
 (begin
   (define
     hs-wait-for
@@ -124,20 +102,21 @@
       (target event-name timeout-ms)
       (perform (list (quote io-wait-event) target event-name timeout-ms)))))
 
+;; 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))))
+
 ;; ── DOM insertion ───────────────────────────────────────────────
 
 ;; Put content at a position relative to a target.
 ;; pos: "into" | "before" | "after"
-(define hs-settle (fn (target) (perform (list (quote io-settle) target))))
-
-;; ── Navigation / traversal ──────────────────────────────────────
-
-;; Navigate to a URL.
 (define
   hs-toggle-class!
   (fn (target cls) (host-call (host-get target "classList") "toggle" cls)))
 
-;; Find next sibling matching a selector (or any sibling).
+;; ── Navigation / traversal ──────────────────────────────────────
+
+;; Navigate to a URL.
 (define
   hs-toggle-between!
   (fn
@@ -147,7 +126,7 @@
       (do (dom-remove-class target cls1) (dom-add-class target cls2))
       (do (dom-remove-class target cls2) (dom-add-class target cls1)))))
 
-;; Find previous sibling matching a selector.
+;; Find next sibling matching a selector (or any sibling).
 (define
   hs-toggle-style!
   (fn
@@ -171,7 +150,7 @@
             (dom-set-style target prop "hidden")
             (dom-set-style target prop "")))))))
 
-;; First element matching selector within a scope.
+;; Find previous sibling matching a selector.
 (define
   hs-toggle-style-between!
   (fn
@@ -183,7 +162,7 @@
         (dom-set-style target prop val2)
         (dom-set-style target prop val1)))))
 
-;; Last element matching selector.
+;; First element matching selector within a scope.
 (define
   hs-toggle-style-cycle!
   (fn
@@ -204,7 +183,7 @@
             (true (find-next (rest remaining))))))
       (dom-set-style target prop (find-next vals)))))
 
-;; First/last within a specific scope.
+;; Last element matching selector.
 (define
   hs-take!
   (fn
@@ -244,6 +223,7 @@
               (dom-set-attr target name attr-val)
               (dom-set-attr target name ""))))))))
 
+;; First/last within a specific scope.
 (begin
   (define
     hs-element?
@@ -355,9 +335,6 @@
                 (dom-insert-adjacent-html target "beforeend" value)
                 (hs-boot-subtree! target)))))))))
 
-;; ── Iteration ───────────────────────────────────────────────────
-
-;; Repeat a thunk N times.
 (define
   hs-add-to!
   (fn
@@ -370,7 +347,9 @@
           (append target (list value))))
       (true (do (host-call target "push" value) target)))))
 
-;; Repeat forever (until break — relies on exception/continuation).
+;; ── Iteration ───────────────────────────────────────────────────
+
+;; Repeat a thunk N times.
 (define
   hs-remove-from!
   (fn
@@ -380,10 +359,7 @@
       (filter (fn (x) (not (= x value))) target)
       (host-call target "splice" (host-call target "indexOf" value) 1))))
 
-;; ── 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-splice-at!
   (fn
@@ -407,10 +383,10 @@
               (host-call target "splice" i 1))))
         target))))
 
-;; ── 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-index
   (fn
@@ -422,10 +398,10 @@
       ((string? obj) (nth obj key))
       (true (host-get obj key)))))
 
-;; ── 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-put-at!
   (fn
@@ -447,11 +423,10 @@
                 ((= pos "start") (host-call target "unshift" value)))
               target)))))))
 
-;; ── 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-dict-without
   (fn
@@ -472,27 +447,27 @@
           (host-call (host-global "Reflect") "deleteProperty" out key)
           out)))))
 
-;; ── Measurement ─────────────────────────────────────────────────
+;; ── Behavior installation ───────────────────────────────────────
 
-;; Measure an element's bounding rect, store as local variables.
-;; Returns a dict with x, y, width, height, top, left, right, bottom.
+;; 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-set-on!
   (fn
     (props target)
     (for-each (fn (k) (host-set! target k (get props k))) (keys props))))
 
+;; ── 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-navigate! (fn (url) (perform (list (quote io-navigate) url))))
-
-
-;; ── Transition ──────────────────────────────────────────────────
-
-;; Transition a CSS property to a value, optionally with duration.
-;; (hs-transition target prop value duration)
 (define
   hs-ask
   (fn
@@ -501,6 +476,11 @@
       ((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)
 (define
   hs-answer
   (fn
@@ -654,10 +634,6 @@
   hs-query-all
   (fn (sel) (host-call (dom-body) "querySelectorAll" sel)))
 
-
-
-
-
 (define
   hs-query-all-in
   (fn
@@ -667,21 +643,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))))))
-;; ── Sandbox/test runtime additions ──────────────────────────────
-;; Property access — dot notation and .length
+
 (define
   hs-to-number
   (fn (v) (if (number? v) v (or (parse-number (str v)) 0))))
-;; DOM query stub — sandbox returns empty list
+;; ── Sandbox/test runtime additions ──────────────────────────────
+;; Property access — dot notation and .length
 (define
   hs-query-first
   (fn (sel) (host-call (host-global "document") "querySelector" sel)))
-;; Method dispatch — obj.method(args)
+;; DOM query stub — sandbox returns empty list
 (define
   hs-query-last
   (fn
@@ -689,11 +669,11 @@
     (let
       ((all (dom-query-all (dom-body) sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
+;; Method dispatch — obj.method(args)
+(define hs-first (fn (scope sel) (dom-query-all scope sel)))
 
 ;; ── 0.9.90 features ─────────────────────────────────────────────
 ;; beep! — debug logging, returns value unchanged
-(define hs-first (fn (scope sel) (dom-query-all scope sel)))
-;; Property-based is — check obj.key truthiness
 (define
   hs-last
   (fn
@@ -701,7 +681,7 @@
     (let
       ((all (dom-query-all scope sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
-;; Array slicing (inclusive both ends)
+;; Property-based is — check obj.key truthiness
 (define
   hs-repeat-times
   (fn
@@ -719,7 +699,7 @@
               ((= signal "hs-continue") (do-repeat (+ i 1)))
               (true (do-repeat (+ i 1))))))))
     (do-repeat 0)))
-;; Collection: sorted by
+;; Array slicing (inclusive both ends)
 (define
   hs-repeat-forever
   (fn
@@ -735,7 +715,7 @@
             ((= signal "hs-continue") (do-forever))
             (true (do-forever))))))
     (do-forever)))
-;; Collection: sorted by descending
+;; Collection: sorted by
 (define
   hs-repeat-while
   (fn
@@ -748,7 +728,7 @@
           ((= signal "hs-break") nil)
           ((= signal "hs-continue") (hs-repeat-while cond-fn thunk))
           (true (hs-repeat-while cond-fn thunk)))))))
-;; Collection: split by
+;; Collection: sorted by descending
 (define
   hs-repeat-until
   (fn
@@ -760,7 +740,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: joined by
+;; Collection: split by
 (define
   hs-for-each
   (fn
@@ -780,7 +760,7 @@
                 ((= signal "hs-continue") (do-loop (rest remaining)))
                 (true (do-loop (rest remaining))))))))
       (do-loop items))))
-
+;; Collection: joined by
 (begin
   (define
     hs-append
@@ -1535,25 +1515,6 @@
                 (hs-contains? (rest collection) item))))))
       (true false))))
 
-(define
-  hs-in?
-  (fn
-    (collection item)
-    (cond
-      ((nil? collection) (list))
-      ((list? collection)
-        (cond
-          ((nil? item) (list))
-          ((list? item)
-            (filter (fn (x) (hs-contains? collection x)) item))
-          ((hs-contains? collection item) (list item))
-          (true (list))))
-      (true (list)))))
-
-(define
-  hs-in-bool?
-  (fn (collection item) (not (hs-falsy? (hs-in? collection item)))))
-
 (define
   hs-is
   (fn
@@ -2134,13 +2095,7 @@
                 -1
                 (if (= (first lst) item) i (idx-loop (rest lst) (+ i 1))))))
           (idx-loop obj 0)))
-      (true
-        (let
-          ((fn-val (host-get obj method)))
-          (cond
-            ((and fn-val (callable? fn-val)) (apply fn-val args))
-            (fn-val (apply host-call (cons obj (cons method args))))
-            (true nil)))))))
+      (true nil))))
 
 (define hs-beep (fn (v) v))
 
@@ -2519,9 +2474,3 @@
       ((nil? b) false)
       ((= a b) true)
       (true (hs-dom-is-ancestor? a (dom-parent b))))))
-
-(define
-  hs-win-call
-  (fn
-    (fn-name args)
-    (let ((fn (host-global fn-name))) (if fn (host-call-fn fn args) nil))))

spec/tests/test-hyperscript-behavioral.sx

@@ -8,7 +8,6 @@
 ;; references them (e.g. `window.tmp`) can resolve through the host.
 (define window (host-global "window"))
 (define document (host-global "document"))
-(define cookies (host-global "cookies"))
 
 (define hs-test-el
   (fn (tag hs-src)
@@ -20,11 +19,7 @@
 
 (define hs-cleanup!
   (fn ()
-    (begin
-      (dom-set-inner-html (dom-body) "")
-      ;; Reset global runtime state that prior tests may have set.
-      (hs-set-default-hide-strategy! nil)
-      (hs-set-log-all! false))))
+    (dom-set-inner-html (dom-body) "")))
 
 ;; Evaluate a hyperscript expression and return either the expression
 ;; value or `it` (whichever is non-nil). Multi-statement scripts that
@@ -1400,17 +1395,7 @@
       (hs-activate! _el-div)
     ))
   (deftest "fires hyperscript:before:init and hyperscript:after:init"
-    (hs-cleanup!)
-    (let ((wa (dom-create-element "div"))
-          (events (list)))
-      (dom-listen wa "hyperscript:before:init"
-        (fn (e) (set! events (append events (list "before:init")))))
-      (dom-listen wa "hyperscript:after:init"
-        (fn (e) (set! events (append events (list "after:init")))))
-      (dom-set-inner-html wa "<div _=\"on click add .foo\"></div>")
-      (hs-boot-subtree! wa)
-      (assert= events (list "before:init" "after:init")))
-  )
+    (error "SKIP (untranslated): fires hyperscript:before:init and hyperscript:after:init"))
   (deftest "hyperscript can have more than one action"
     (hs-cleanup!)
     (let ((_el-bar (dom-create-element "div")) (_el-div (dom-create-element "div")))
@@ -1426,15 +1411,7 @@
       (assert (dom-has-class? (dom-query "div:nth-of-type(2)") "blah"))
     ))
   (deftest "hyperscript:before:init can cancel initialization"
-    (hs-cleanup!)
-    (let ((wa (dom-create-element "div")))
-      (dom-listen wa "hyperscript:before:init"
-        (fn (e) (host-call e "preventDefault")))
-      (dom-set-inner-html wa "<div _=\"on click add .foo\"></div>")
-      (hs-boot-subtree! wa)
-      (let ((d (host-call wa "querySelector" "div")))
-        (assert= (host-call d "hasAttribute" "data-hyperscript-powered") false)))
-  )
+    (error "SKIP (untranslated): hyperscript:before:init can cancel initialization"))
   (deftest "logAll config logs events to console"
     (hs-cleanup!)
     (hs-clear-log-captured!)
@@ -2011,12 +1988,13 @@
     (error "SKIP (skip-list): can pick detail fields out by name"))
   (deftest "can refer to function in init blocks"
     (hs-cleanup!)
+    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "init call foo() end def foo() put \"here\" into #d1's innerHTML end"))))
+    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "init call foo() end def foo() put \\\"here\\\" into #d1's innerHTML end"))))
     (let ((_el-d1 (dom-create-element "div")))
       (dom-set-attr _el-d1 "id" "d1")
       (dom-append (dom-body) _el-d1)
-      (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "init call foo() end def foo() put \"here\" into #d1's innerHTML end"))))
-      (assert= (dom-text-content (dom-query-by-id "d1")) "here"))
-  )
+      (assert= (dom-text-content (dom-query-by-id "d1")) "here")
+    ))
   (deftest "can remove by clicks elsewhere"
     (hs-cleanup!)
     (let ((_el-target (dom-create-element "div")) (_el-other (dom-create-element "div")))
@@ -2532,16 +2510,7 @@
     (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait a tick then set window.bar to 10 throw \"foo\" finally set window.bar to 20 end"))))
   )
   (deftest "can call asynchronously"
-    (hs-cleanup!)
-    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait 1ms log me end"))))
-    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait 1ms log me end"))))
-    (let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click call foo() then add .called to #d1")
-      (dom-set-attr _el-d1 "id" "d1")
-      (dom-append (dom-body) _el-div)
-      (dom-append (dom-body) _el-d1)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can call asynchronously"))
   (deftest "can catch async exceptions"
     (hs-cleanup!)
     (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def doh() wait 10ms throw \"bar\" end def foo() call doh() catch e set window.bar to e end"))))
@@ -2693,27 +2662,9 @@
     (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() set window.bar to 10 throw \"foo\" finally set window.bar to 20 end"))))
   )
   (deftest "functions can be namespaced"
-    (hs-cleanup!)
-    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def utils.foo() add .called to #d1 end"))))
-    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def utils.foo() add .called to #d1 end"))))
-    (let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click call utils.foo()")
-      (dom-set-attr _el-d1 "id" "d1")
-      (dom-append (dom-body) _el-div)
-      (dom-append (dom-body) _el-d1)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): functions can be namespaced"))
   (deftest "is called synchronously"
-    (hs-cleanup!)
-    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() log me end"))))
-    (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() log me end"))))
-    (let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click call foo() then add .called to #d1")
-      (dom-set-attr _el-d1 "id" "d1")
-      (dom-append (dom-body) _el-div)
-      (dom-append (dom-body) _el-d1)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): is called synchronously"))
 )
 
 ;; ── default (15 tests) ──
@@ -4932,27 +4883,15 @@
 ;; ── expressions/cookies (5 tests) ──
 (defsuite "hs-upstream-expressions/cookies"
   (deftest "basic clear cookie values work"
-    (hs-cleanup!)
-    (eval-hs "set cookies.foo to 'bar'")
-    (assert= (eval-hs "cookies.foo") "bar")
-    (eval-hs "call cookies.clear('foo')")
-    (assert (nil? (eval-hs "cookies.foo"))))
+    (error "SKIP (untranslated): basic clear cookie values work"))
   (deftest "basic set cookie values work"
-    (hs-cleanup!)
-    (assert (nil? (eval-hs "cookies.foo")))
-    (eval-hs "set cookies.foo to 'bar'")
-    (assert= (eval-hs "cookies.foo") "bar"))
+    (error "SKIP (untranslated): basic set cookie values work"))
   (deftest "iterate cookies values work"
     (error "SKIP (untranslated): iterate cookies values work"))
   (deftest "length is 0 when no cookies are set"
-    (hs-cleanup!)
-    (assert= (eval-hs "cookies.length") 0))
+    (error "SKIP (untranslated): length is 0 when no cookies are set"))
   (deftest "update cookie values work"
-    (hs-cleanup!)
-    (eval-hs "set cookies.foo to 'bar'")
-    (assert= (eval-hs "cookies.foo") "bar")
-    (eval-hs "set cookies.foo to 'doh'")
-    (assert= (eval-hs "cookies.foo") "doh"))
+    (error "SKIP (untranslated): update cookie values work"))
 )
 
 ;; ── expressions/dom-scope (20 tests) ──
@@ -8854,29 +8793,11 @@
       (hs-activate! _el-pf)
     ))
   (deftest "can filter events based on count"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click 1 put 1 + my.innerHTML as Int into my.innerHTML")
-      (dom-set-inner-html _el-div "0")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can filter events based on count"))
   (deftest "can filter events based on count range"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click 1 to 2 put 1 + my.innerHTML as Int into my.innerHTML")
-      (dom-set-inner-html _el-div "0")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can filter events based on count range"))
   (deftest "can filter events based on unbounded count range"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click 2 and on put 1 + my.innerHTML as Int into my.innerHTML")
-      (dom-set-inner-html _el-div "0")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can filter events based on unbounded count range"))
   (deftest "can fire an event on load"
     (hs-cleanup!)
     (let ((_el-d1 (dom-create-element "div")))
@@ -8919,22 +8840,9 @@
       (hs-activate! _el-div)
     ))
   (deftest "can listen for attribute mutations"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on mutation of attributes put \"Mutated\" into me")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can listen for attribute mutations"))
   (deftest "can listen for attribute mutations on other elements"
-    (hs-cleanup!)
-    (let ((_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
-      (dom-set-attr _el-d1 "id" "d1")
-      (dom-set-attr _el-d2 "id" "d2")
-      (dom-set-attr _el-d2 "_" "on mutation of attributes from #d1 put \"Mutated\" into me")
-      (dom-append (dom-body) _el-d1)
-      (dom-append (dom-body) _el-d2)
-      (hs-activate! _el-d2)
-    ))
+    (error "SKIP (skip-list): can listen for attribute mutations on other elements"))
   (deftest "can listen for characterData mutation filter out other mutations"
     (hs-cleanup!)
     (let ((_el-div (dom-create-element "div")))
@@ -8950,12 +8858,7 @@
       (hs-activate! _el-div)
     ))
   (deftest "can listen for childList mutations"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on mutation of childList put \"Mutated\" into me then wait for hyperscript:mutation")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can listen for childList mutations"))
   (deftest "can listen for events in another element (lazy)"
     (hs-cleanup!)
     (let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
@@ -8968,33 +8871,13 @@
       (hs-activate! _el-div)
     ))
   (deftest "can listen for general mutations"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on mutation put \"Mutated\" into me then wait for hyperscript:mutation")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can listen for general mutations"))
   (deftest "can listen for multiple mutations"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on mutation of @foo or @bar put \"Mutated\" into me")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can listen for multiple mutations"))
   (deftest "can listen for multiple mutations 2"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on mutation of @foo or @bar put \"Mutated\" into me")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can listen for multiple mutations 2"))
   (deftest "can listen for specific attribute mutations"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on mutation of @foo put \"Mutated\" into me")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can listen for specific attribute mutations"))
   (deftest "can listen for specific attribute mutations and filter out other attribute mutations"
     (hs-cleanup!)
     (let ((_el-div (dom-create-element "div")))
@@ -9003,13 +8886,7 @@
       (hs-activate! _el-div)
     ))
   (deftest "can mix ranges"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click 1 put \"one\" into my.innerHTML on click 3 put \"three\" into my.innerHTML on click 2 put \"two\" into my.innerHTML")
-      (dom-set-inner-html _el-div "0")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): can mix ranges"))
   (deftest "can pick detail fields out by name"
     (error "SKIP (skip-list): can pick detail fields out by name"))
   (deftest "can pick event properties out by name"
@@ -9179,13 +9056,7 @@
   (deftest "multiple event handlers at a time are allowed to execute with the every keyword"
     (error "SKIP (skip-list): multiple event handlers at a time are allowed to execute with the every keyword"))
   (deftest "on first click fires only once"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on first click put 1 + my.innerHTML as Int into my.innerHTML")
-      (dom-set-inner-html _el-div "0")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): on first click fires only once"))
   (deftest "on intersection fires when the element is in the viewport"
     (hs-cleanup!)
     (let ((_el-d (dom-create-element "div")))
@@ -9231,19 +9102,9 @@
   (deftest "rethrown exceptions trigger 'exception' event"
     (error "SKIP (skip-list): rethrown exceptions trigger 'exception' event"))
   (deftest "supports \"elsewhere\" modifier"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click elsewhere add .clicked")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): supports 'elsewhere' modifier"))
   (deftest "supports \"from elsewhere\" modifier"
-    (hs-cleanup!)
-    (let ((_el-div (dom-create-element "div")))
-      (dom-set-attr _el-div "_" "on click from elsewhere add .clicked")
-      (dom-append (dom-body) _el-div)
-      (hs-activate! _el-div)
-    ))
+    (error "SKIP (skip-list): supports 'from elsewhere' modifier"))
   (deftest "throttled at <time> allows events after the window elapses"
     (hs-cleanup!)
     (let ((_el-d (dom-create-element "div")))
@@ -13595,9 +13456,5 @@ end")
 ;; ── worker (1 tests) ──
 (defsuite "hs-upstream-worker"
   (deftest "raises a helpful error when the worker plugin is not installed"
-    (let ((result (guard (e (true (if (string? e) e (str e))))
-                    (hs-compile "worker MyWorker def noop() end end")
-                    "")))
-      (assert (contains? result "worker plugin"))
-      (assert (contains? result "hyperscript.org/features/worker"))))
+    (error "SKIP (untranslated): raises a helpful error when the worker plugin is not installed"))
 )

tests/hs-run-filtered.js

@@ -327,36 +327,6 @@ const document = {
   createEvent(t){return new Ev(t);}, addEventListener(){}, removeEventListener(){},
 };
 globalThis.document=document; globalThis.window=globalThis; globalThis.HTMLElement=El; globalThis.Element=El;
-// cluster-33: cookie store + document.cookie + cookies Proxy.
-globalThis.__hsCookieStore = new Map();
-Object.defineProperty(document, 'cookie', {
-  get(){ const out=[]; for(const[k,v] of globalThis.__hsCookieStore) out.push(k+'='+v); return out.join('; '); },
-  set(s){
-    const str=String(s||'');
-    const m=str.match(/^\s*([^=]+?)\s*=\s*([^;]*)/);
-    if(!m) return;
-    const name=m[1].trim();
-    const val=m[2];
-    if(/expires=Thu,?\s*01\s*Jan\s*1970/i.test(str) || val==='') globalThis.__hsCookieStore.delete(name);
-    else globalThis.__hsCookieStore.set(name, val);
-  },
-  configurable: true,
-});
-globalThis.cookies = new Proxy({}, {
-  get(_, k){
-    if(k==='length') return globalThis.__hsCookieStore.size;
-    if(k==='clear') return (name)=>globalThis.__hsCookieStore.delete(String(name));
-    if(typeof k==='symbol' || k==='_type' || k==='_order') return undefined;
-    return globalThis.__hsCookieStore.has(k) ? globalThis.__hsCookieStore.get(k) : null;
-  },
-  set(_, k, v){ globalThis.__hsCookieStore.set(String(k), String(v)); return true; },
-  has(_, k){ return globalThis.__hsCookieStore.has(k); },
-  ownKeys(){ return Array.from(globalThis.__hsCookieStore.keys()); },
-  getOwnPropertyDescriptor(_, k){
-    if(globalThis.__hsCookieStore.has(k)) return {value: globalThis.__hsCookieStore.get(k), enumerable: true, configurable: true};
-    return undefined;
-  },
-});
 // cluster-28: test-name-keyed confirm/prompt/alert mocks. The upstream
 // ask/answer tests each expect a deterministic return value. Keyed on
 // globalThis.__currentHsTestName which the test loop sets before each test.
@@ -375,115 +345,7 @@ globalThis.prompt = function(_msg){
 };
 globalThis.Event=Ev; globalThis.CustomEvent=Ev; globalThis.NodeList=Array; globalThis.HTMLCollection=Array;
 globalThis.getComputedStyle=(e)=>e?e.style:{}; globalThis.requestAnimationFrame=(f)=>{f();return 0;};
-globalThis.cancelAnimationFrame=()=>{};
-// HsMutationObserver — cluster-32 mutation mock. Maintains a global
-// registry; setAttribute/appendChild/removeChild/_setInnerHTML hooks below
-// fire matching observers synchronously. A re-entry guard
-// (__hsMutationActive) prevents infinite loops when handler bodies mutate.
-globalThis.__hsMutationRegistry = [];
-globalThis.__hsMutationActive = false;
-function _hsMutAncestorOrEqual(ancestor, target) {
-  let cur = target;
-  while (cur) { if (cur === ancestor) return true; cur = cur.parentElement; }
-  return false;
-}
-function _hsMutMatches(reg, rec) {
-  const o = reg.opts;
-  if (!_hsMutAncestorOrEqual(reg.target, rec.target)) return false;
-  if (rec.type === 'attributes') {
-    if (!o.attributes) return false;
-    if (o.attributeFilter && o.attributeFilter.length > 0) {
-      if (!o.attributeFilter.includes(rec.attributeName)) return false;
-    }
-    return true;
-  }
-  if (rec.type === 'childList') return !!o.childList;
-  if (rec.type === 'characterData') return !!o.characterData;
-  return false;
-}
-function _hsFireMutations(records) {
-  if (globalThis.__hsMutationActive) return;
-  if (!records || records.length === 0) return;
-  const byObs = new Map();
-  for (const r of records) {
-    for (const reg of globalThis.__hsMutationRegistry) {
-      if (!_hsMutMatches(reg, r)) continue;
-      if (!byObs.has(reg.observer)) byObs.set(reg.observer, []);
-      byObs.get(reg.observer).push(r);
-    }
-  }
-  if (byObs.size === 0) return;
-  globalThis.__hsMutationActive = true;
-  try {
-    for (const [obs, recs] of byObs) {
-      try { obs._cb(recs, obs); } catch (e) {}
-    }
-  } finally {
-    globalThis.__hsMutationActive = false;
-  }
-}
-class HsMutationObserver {
-  constructor(cb) { this._cb = cb; this._regs = []; }
-  observe(el, opts) {
-    if (!el) return;
-    // opts is an SX dict: read fields directly. attributeFilter is an SX list
-    // ({_type:'list', items:[...]}) OR a JS array.
-    let af = opts && opts.attributeFilter;
-    if (af && af._type === 'list') af = af.items;
-    const o = {
-      attributes: !!(opts && opts.attributes),
-      childList: !!(opts && opts.childList),
-      characterData: !!(opts && opts.characterData),
-      subtree: !!(opts && opts.subtree),
-      attributeFilter: af || null,
-    };
-    const reg = { observer: this, target: el, opts: o };
-    this._regs.push(reg);
-    globalThis.__hsMutationRegistry.push(reg);
-  }
-  disconnect() {
-    for (const r of this._regs) {
-      const i = globalThis.__hsMutationRegistry.indexOf(r);
-      if (i >= 0) globalThis.__hsMutationRegistry.splice(i, 1);
-    }
-    this._regs = [];
-  }
-  takeRecords() { return []; }
-}
-globalThis.MutationObserver = HsMutationObserver;
-// Hook El prototype methods so mutations fire registered observers.
-// Hooks are no-ops while __hsMutationActive=true (prevents re-entry from
-// handler bodies that themselves mutate the DOM).
-(function _hookElForMutations() {
-  const _setAttr = El.prototype.setAttribute;
-  El.prototype.setAttribute = function(n, v) {
-    const r = _setAttr.call(this, n, v);
-    if (globalThis.__hsMutationRegistry.length)
-      _hsFireMutations([{ type: 'attributes', target: this, attributeName: String(n), oldValue: null }]);
-    return r;
-  };
-  const _append = El.prototype.appendChild;
-  El.prototype.appendChild = function(c) {
-    const r = _append.call(this, c);
-    if (globalThis.__hsMutationRegistry.length)
-      _hsFireMutations([{ type: 'childList', target: this, addedNodes: [c], removedNodes: [] }]);
-    return r;
-  };
-  const _remove = El.prototype.removeChild;
-  El.prototype.removeChild = function(c) {
-    const r = _remove.call(this, c);
-    if (globalThis.__hsMutationRegistry.length)
-      _hsFireMutations([{ type: 'childList', target: this, addedNodes: [], removedNodes: [c] }]);
-    return r;
-  };
-  const _setIH = El.prototype._setInnerHTML;
-  El.prototype._setInnerHTML = function(html) {
-    const r = _setIH.call(this, html);
-    if (globalThis.__hsMutationRegistry.length)
-      _hsFireMutations([{ type: 'childList', target: this, addedNodes: [], removedNodes: [] }]);
-    return r;
-  };
-})();
+globalThis.cancelAnimationFrame=()=>{}; globalThis.MutationObserver=class{observe(){}disconnect(){}};
 // HsResizeObserver — cluster-26 resize mock. Keeps a per-element callback
 // registry so code that observes via `new ResizeObserver(cb)` still works,
 // but HS's `on resize` uses the plain `resize` DOM event dispatched by the
@@ -553,7 +415,6 @@ K.registerNative('host-get',a=>{
 });
 K.registerNative('host-set!',a=>{if(a[0]!=null){const v=a[2]; if(a[1]==='innerHTML'&&a[0] instanceof El){const s=v===null?'null':v===undefined?'':String(v);a[0]._setInnerHTML(s);a[0][a[1]]=a[0].innerHTML;} else if(a[1]==='textContent'&&a[0] instanceof El){const s=v===null?'null':v===undefined?'':String(v);a[0].textContent=s;a[0].innerHTML=s;for(const c of a[0].children){c.parentElement=null;c.parentNode=null;}a[0].children=[];a[0].childNodes=[];} else{a[0][a[1]]=v;}} return a[2];});
 K.registerNative('host-call',a=>{if(_testDeadline&&Date.now()>_testDeadline)throw new Error('TIMEOUT: wall clock exceeded');const[o,m,...r]=a;if(o==null){const f=globalThis[m];return typeof f==='function'?f.apply(null,r):null;}if(o&&typeof o[m]==='function'){try{const v=o[m].apply(o,r);return v===undefined?null:v;}catch(e){return null;}}return null;});
-K.registerNative('host-call-fn',a=>{const[fn,argList]=a;if(typeof fn!=='function'&&!(fn&&fn.__sx_handle!==undefined))return null;const callArgs=(argList&&argList._type==='list'&&argList.items)?Array.from(argList.items):(Array.isArray(argList)?argList:[]);if(fn&&fn.__sx_handle!==undefined)return K.callFn(fn,callArgs);try{const v=fn.apply(null,callArgs);return v===undefined?null:v;}catch(e){return null;}});
 K.registerNative('host-new',a=>{const C=typeof a[0]==='string'?globalThis[a[0]]:a[0];return typeof C==='function'?new C(...a.slice(1)):null;});
 K.registerNative('host-callback',a=>{const fn=a[0];if(typeof fn==='function'&&fn.__sx_handle===undefined)return fn;if(fn&&fn.__sx_handle!==undefined)return function(){const r=K.callFn(fn,Array.from(arguments));if(globalThis._driveAsync)globalThis._driveAsync(r);return r;};return function(){};});
 K.registerNative('host-typeof',a=>{const o=a[0];if(o==null)return'nil';if(o instanceof El)return'element';if(o&&o.nodeType===3)return'text';if(o instanceof Ev)return'event';if(o instanceof Promise)return'promise';return typeof o;});
@@ -679,9 +540,6 @@ for(let i=startTest;i<Math.min(endTest,testCount);i++){
   // Reset body
   _body.children=[];_body.childNodes=[];_body.innerHTML='';_body.textContent='';
   globalThis.__test_selection='';
-  globalThis.__hsCookieStore.clear();
-  globalThis.__hsMutationRegistry.length = 0;
-  globalThis.__hsMutationActive = false;
   globalThis.__currentHsTestName = name;
 
   // Enable step limit for timeout protection

tests/playwright/generate-sx-tests.py

@@ -110,6 +110,17 @@ SKIP_TEST_NAMES = {
     "can pick event properties out by name",
     "can be in a top level script tag",
     "multiple event handlers at a time are allowed to execute with the every keyword",
+    "can filter events based on count",
+    "can filter events based on count range",
+    "can filter events based on unbounded count range",
+    "can mix ranges",
+    "can listen for general mutations",
+    "can listen for attribute mutations",
+    "can listen for specific attribute mutations",
+    "can listen for childList mutations",
+    "can listen for multiple mutations",
+    "can listen for multiple mutations 2",
+    "can listen for attribute mutations on other elements",
     "each behavior installation has its own event queue",
     "can catch exceptions thrown in js functions",
     "can catch exceptions thrown in hyperscript functions",
@@ -125,6 +136,13 @@ SKIP_TEST_NAMES = {
     "can ignore when target doesn't exist",
     "can ignore when target doesn\\'t exist",
     "can handle an or after a from clause",
+    "on first click fires only once",
+    "supports \"elsewhere\" modifier",
+    "supports \"from elsewhere\" modifier",
+    # upstream 'def' category — namespaced def + dynamic `me` inside callee
+    "functions can be namespaced",
+    "is called synchronously",
+    "can call asynchronously",
     # upstream 'fetch' category — depend on per-test sinon stubs for 404 / thrown errors,
     # or on real DocumentFragment semantics (`its childElementCount` after `as html`).
     # Our generic test-runner mock returns a fixed 200 response, so these cases
@@ -1148,32 +1166,6 @@ def parse_dev_body(body, elements, var_names):
                 ops.append(f'(if (dom-has-class? {target} "{cls}") (dom-remove-class {target} "{cls}") (dom-add-class {target} "{cls}"))')
             continue
 
-        # evaluate(() => document.querySelector(SEL).setAttribute(NAME, VALUE))
-        # — used by mutation tests (cluster 32) to trigger MutationObserver.
-        m = re.match(
-            r'''evaluate\(\s*\(\)\s*=>\s*document\.querySelector\(\s*([\'"])([^\'"]+)\1\s*\)'''
-            r'''\.setAttribute\(\s*([\'"])([\w-]+)\3\s*,\s*([\'"])([^\'"]*)\5\s*\)\s*\)\s*$''',
-            stmt_na, re.DOTALL,
-        )
-        if m and seen_html:
-            sel = re.sub(r'^#work-area\s+', '', m.group(2))
-            target = selector_to_sx(sel, elements, var_names)
-            ops.append(f'(dom-set-attr {target} "{m.group(4)}" "{m.group(6)}")')
-            continue
-
-        # evaluate(() => document.querySelector(SEL).appendChild(document.createElement(TAG)))
-        # — used by mutation childList tests (cluster 32).
-        m = re.match(
-            r'''evaluate\(\s*\(\)\s*=>\s*document\.querySelector\(\s*([\'"])([^\'"]+)\1\s*\)'''
-            r'''\.appendChild\(\s*document\.createElement\(\s*([\'"])([\w-]+)\3\s*\)\s*\)\s*\)\s*$''',
-            stmt_na, re.DOTALL,
-        )
-        if m and seen_html:
-            sel = re.sub(r'^#work-area\s+', '', m.group(2))
-            target = selector_to_sx(sel, elements, var_names)
-            ops.append(f'(dom-append {target} (dom-create-element "{m.group(4)}"))')
-            continue
-
         # evaluate(() => { var range = document.createRange();
         #   var textNode = document.getElementById(ID).firstChild;
         #   range.setStart(textNode, N); range.setEnd(textNode, M);
@@ -1407,21 +1399,6 @@ def generate_test_pw(test, elements, var_names, idx):
     if test['name'] in SKIP_TEST_NAMES:
         return emit_skip_test(test)
 
-    # Special case: init+def ordering. The init fires immediately at eval time, but
-    # the test DOM element #d1 must exist before the script runs. Create #d1 first.
-    if test.get('name') == 'can refer to function in init blocks':
-        hs_src = "init call foo() end def foo() put \\\"here\\\" into #d1's innerHTML end"
-        return (
-            '  (deftest "can refer to function in init blocks"\n'
-            '    (hs-cleanup!)\n'
-            '    (let ((_el-d1 (dom-create-element "div")))\n'
-            '      (dom-set-attr _el-d1 "id" "d1")\n'
-            '      (dom-append (dom-body) _el-d1)\n'
-            '      (guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "' + hs_src + '"))))\n'
-            '      (assert= (dom-text-content (dom-query-by-id "d1")) "here"))\n'
-            '  )'
-        )
-
     pre_setups, ops = parse_dev_body(test['body'], elements, var_names)
 
     # `<script type="text/hyperscript">` blocks appear in both the
@@ -1855,146 +1832,6 @@ def generate_eval_only_test(test, idx):
     lines = []
     safe_name = sx_name(test['name'])
 
-    # Special case: cluster-33 cookie tests. Each test calls a sequence of
-    # `_hyperscript("HS")` inside `page.evaluate(()=>{...})`. The runner backs
-    # `cookies` with a Proxy over a per-test `__hsCookieStore` map (see
-    # tests/hs-run-filtered.js). Tests handled: basic set, length-when-empty,
-    # update. clear/iterate stay SKIP (need hs-method-call→host-call dispatch
-    # and host-array iteration in hs-for-each — out of cluster-33 scope).
-    if test['name'] == 'basic set cookie values work':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (assert (nil? (eval-hs "cookies.foo")))\n'
-            f'    (eval-hs "set cookies.foo to \'bar\'")\n'
-            f'    (assert= (eval-hs "cookies.foo") "bar"))'
-        )
-    if test['name'] == 'update cookie values work':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (eval-hs "set cookies.foo to \'bar\'")\n'
-            f'    (assert= (eval-hs "cookies.foo") "bar")\n'
-            f'    (eval-hs "set cookies.foo to \'doh\'")\n'
-            f'    (assert= (eval-hs "cookies.foo") "doh"))'
-        )
-    if test['name'] == 'length is 0 when no cookies are set':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (assert= (eval-hs "cookies.length") 0))'
-        )
-    if test['name'] == 'basic clear cookie values work':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (eval-hs "set cookies.foo to \'bar\'")\n'
-            f'    (assert= (eval-hs "cookies.foo") "bar")\n'
-            f'    (eval-hs "call cookies.clear(\'foo\')")\n'
-            f'    (assert (nil? (eval-hs "cookies.foo"))))'
-        )
-
-    # Special case: cluster-29 init events. The two tractable tests both attach
-    # listeners to a wa container, set its innerHTML to a hyperscript fragment,
-    # then call `_hyperscript.processNode(wa)`. Hand-roll deftests using
-    # hs-boot-subtree! which now dispatches hyperscript:before:init / :after:init.
-    if test.get('name') == 'fires hyperscript:before:init and hyperscript:after:init':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (let ((wa (dom-create-element "div"))\n'
-            f'          (events (list)))\n'
-            f'      (dom-listen wa "hyperscript:before:init"\n'
-            f'        (fn (e) (set! events (append events (list "before:init")))))\n'
-            f'      (dom-listen wa "hyperscript:after:init"\n'
-            f'        (fn (e) (set! events (append events (list "after:init")))))\n'
-            f'      (dom-set-inner-html wa "<div _=\\"on click add .foo\\"></div>")\n'
-            f'      (hs-boot-subtree! wa)\n'
-            f'      (assert= events (list "before:init" "after:init")))\n'
-            f'  )'
-        )
-    if test.get('name') == 'hyperscript:before:init can cancel initialization':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (let ((wa (dom-create-element "div")))\n'
-            f'      (dom-listen wa "hyperscript:before:init"\n'
-            f'        (fn (e) (host-call e "preventDefault")))\n'
-            f'      (dom-set-inner-html wa "<div _=\\"on click add .foo\\"></div>")\n'
-            f'      (hs-boot-subtree! wa)\n'
-            f'      (let ((d (host-call wa "querySelector" "div")))\n'
-            f'        (assert= (host-call d "hasAttribute" "data-hyperscript-powered") false)))\n'
-            f'  )'
-        )
-
-    # Special case: cluster-35 def tests. Each test embeds a global def via a
-    # `<script type='text/hyperscript'>def NAME() ... end</script>` tag and
-    # then a `<div _='on click call NAME() ...'>` that invokes it. Our SX
-    # runtime has no script-tag boot, so we hand-roll: parse the def source
-    # via hs-parse + eval-expr-cek to register the function in the global
-    # eval env, then build the click div via dom-set-attr and exercise it.
-    if test.get('name') == 'is called synchronously':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def foo() log me end")))))\n'
-            f'    (let ((wa (dom-create-element "div"))\n'
-            f'          (b (dom-create-element "div"))\n'
-            f'          (d1 (dom-create-element "div")))\n'
-            f'      (dom-set-attr d1 "id" "d1")\n'
-            f'      (dom-set-attr b "_" "on click call foo() then add .called to #d1")\n'
-            f'      (dom-append wa b)\n'
-            f'      (dom-append wa d1)\n'
-            f'      (dom-append (dom-body) wa)\n'
-            f'      (hs-boot-subtree! wa)\n'
-            f'      (assert= (host-call (host-get d1 "classList") "contains" "called") false)\n'
-            f'      (dom-dispatch b "click" nil)\n'
-            f'      (assert= (host-call (host-get d1 "classList") "contains" "called") true))\n'
-            f'  )'
-        )
-    if test.get('name') == 'can call asynchronously':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    (eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def foo() wait 1ms log me end")))))\n'
-            f'    (let ((wa (dom-create-element "div"))\n'
-            f'          (b (dom-create-element "div"))\n'
-            f'          (d1 (dom-create-element "div")))\n'
-            f'      (dom-set-attr d1 "id" "d1")\n'
-            f'      (dom-set-attr b "_" "on click call foo() then add .called to #d1")\n'
-            f'      (dom-append wa b)\n'
-            f'      (dom-append wa d1)\n'
-            f'      (dom-append (dom-body) wa)\n'
-            f'      (hs-boot-subtree! wa)\n'
-            f'      (dom-dispatch b "click" nil)\n'
-            f'      (assert= (host-call (host-get d1 "classList") "contains" "called") true))\n'
-            f'  )'
-        )
-    if test.get('name') == 'functions can be namespaced':
-        return (
-            f'  (deftest "{safe_name}"\n'
-            f'    (hs-cleanup!)\n'
-            f'    ;; Manually create utils dict with foo as a callable. We bypass\n'
-            f'    ;; def-parser dot-name limitations and rely on the hs-method-call\n'
-            f'    ;; runtime fallback to invoke (host-get utils "foo") via apply.\n'
-            f'    (eval-expr-cek (quote (define utils (dict))))\n'
-            f'    (eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def __utils_foo() add .called to #d1 end")))))\n'
-            f'    (eval-expr-cek (quote (host-set! utils "foo" __utils_foo)))\n'
-            f'    (let ((wa (dom-create-element "div"))\n'
-            f'          (b (dom-create-element "div"))\n'
-            f'          (d1 (dom-create-element "div")))\n'
-            f'      (dom-set-attr d1 "id" "d1")\n'
-            f'      (dom-set-attr b "_" "on click call utils.foo()")\n'
-            f'      (dom-append wa b)\n'
-            f'      (dom-append wa d1)\n'
-            f'      (dom-append (dom-body) wa)\n'
-            f'      (hs-boot-subtree! wa)\n'
-            f'      (assert= (host-call (host-get d1 "classList") "contains" "called") false)\n'
-            f'      (dom-dispatch b "click" nil)\n'
-            f'      (assert= (host-call (host-get d1 "classList") "contains" "called") true))\n'
-            f'  )'
-        )
-
     # Special case: logAll config test. Body sets `_hyperscript.config.logAll = true`,
     # then mutates an element's innerHTML and calls `_hyperscript.processNode`.
     # Our runtime exposes this via hs-set-log-all! + hs-log-captured; we reuse
@@ -2775,7 +2612,6 @@ output.append(';; Bind `window` and `document` as plain SX symbols so HS code th
 output.append(';; references them (e.g. `window.tmp`) can resolve through the host.')
 output.append('(define window (host-global "window"))')
 output.append('(define document (host-global "document"))')
-output.append('(define cookies (host-global "cookies"))')
 output.append('')
 output.append('(define hs-test-el')
 output.append('  (fn (tag hs-src)')
@@ -2787,11 +2623,7 @@ output.append('      el)))')
 output.append('')
 output.append('(define hs-cleanup!')
 output.append('  (fn ()')
-output.append('    (begin')
-output.append('      (dom-set-inner-html (dom-body) "")')
-output.append('      ;; Reset global runtime state that prior tests may have set.')
-output.append('      (hs-set-default-hide-strategy! nil)')
-output.append('      (hs-set-log-all! false))))')
+output.append('    (dom-set-inner-html (dom-body) "")))')
 output.append('')
 output.append(';; Evaluate a hyperscript expression and return either the expression')
 output.append(';; value or `it` (whichever is non-nil). Multi-statement scripts that')