merge: architecture → loops/tcl — R7RS, JIT, env-as-value

Resolved conflicts in hosts/ocaml/lib/sx_primitives.ml:
- Took architecture's make-regexp/regexp-* primitives (Tcl runtime depends on them)
- Took architecture's Integer typing for clock-seconds/milliseconds/format
- Kept Phase 4 env-lookup/env-extend additions

Tcl: 342/342 tests passing.

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

hosts/javascript/platform.py

@@ -2771,8 +2771,8 @@ PLATFORM_DOM_JS = """
     // If lambda takes 0 params, call without event arg (convenience for on-click handlers)
     var wrapped = isLambda(handler)
       ? (lambdaParams(handler).length === 0
-        ? function(e) { try { cekCall(handler, NIL); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } }
-        : function(e) { try { cekCall(handler, [e]); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } })
+        ? function(e) { try { var r = cekCall(handler, NIL); if (globalThis._driveAsync) globalThis._driveAsync(r); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } }
+        : function(e) { try { var r = cekCall(handler, [e]); if (globalThis._driveAsync) globalThis._driveAsync(r); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } })
       : handler;
     if (name === "click") logInfo("domListen: click on <" + (el.tagName||"?").toLowerCase() + "> text=" + (el.textContent||"").substring(0,20) + " isLambda=" + isLambda(handler));
     var passiveEvents = { touchstart: 1, touchmove: 1, wheel: 1, scroll: 1 };

hosts/ocaml/bin/mcp_tree.ml

@@ -1892,8 +1892,34 @@ let handle_sx_harness_eval args =
     let file = args |> member "file" |> to_string_option in
     let setup_str = args |> member "setup" |> to_string_option in
     let files_json = try args |> member "files" with _ -> `Null in
+    let host_stubs = match args |> member "host_stubs" with `Bool b -> b | _ -> false in
     let e = !env in
     let warnings = ref [] in
+    (* Inject stub host primitives so files using host-get/host-new/etc. can load *)
+    if host_stubs then begin
+      let stubs = {|
+        (define host-global (fn (&rest _) nil))
+        (define host-get (fn (&rest _) nil))
+        (define host-set! (fn (obj k v) v))
+        (define host-call (fn (&rest _) nil))
+        (define host-new (fn (&rest _) (dict)))
+        (define host-callback (fn (f) f))
+        (define host-typeof (fn (&rest _) "string"))
+        (define hs-ref-eq (fn (a b) (identical? a b)))
+        (define host-call-fn (fn (&rest _) nil))
+        (define host-iter? (fn (&rest _) false))
+        (define host-to-list (fn (&rest _) (list)))
+        (define host-await (fn (&rest _) nil))
+        (define host-new-function (fn (&rest _) nil))
+        (define load-library! (fn (&rest _) false))
+      |} in
+      let stub_exprs = Sx_parser.parse_all stubs in
+      List.iter (fun expr ->
+        try ignore (Sx_ref.eval_expr expr (Env e))
+        with exn ->
+          warnings := Printf.sprintf "Stub warning: %s" (Printexc.to_string exn) :: !warnings
+      ) stub_exprs
+    end;
     (* Collect all files to load *)
     let all_files = match files_json with
       | `List items ->
@@ -3018,7 +3044,8 @@ let tool_definitions = `List [
      ("mock", `Assoc [("type", `String "string"); ("description", `String "Optional mock platform overrides as SX dict, e.g. {:fetch (fn (url) {:status 200})}")]);
      ("file", `Assoc [("type", `String "string"); ("description", `String "Optional .sx file to load for definitions")]);
      ("files", `Assoc [("type", `String "array"); ("items", `Assoc [("type", `String "string")]); ("description", `String "Multiple .sx files to load in order")]);
-     ("setup", `Assoc [("type", `String "string"); ("description", `String "SX setup expression to run before main evaluation")])]
+     ("setup", `Assoc [("type", `String "string"); ("description", `String "SX setup expression to run before main evaluation")]);
+     ("host_stubs", `Assoc [("type", `String "boolean"); ("description", `String "If true, inject nil-returning stubs for host-get/host-set!/host-call/host-new/etc. so files that use host primitives can load in the harness")])]
     ["expr"];
   tool "sx_nav" "Manage sx-docs navigation and articles. Modes: list (all nav items with status), check (validate consistency), add (create article + nav entry), delete (remove nav entry + page fn), move (move entry between sections, rewriting hrefs)."
     [("mode", `Assoc [("type", `String "string"); ("description", `String "Mode: list, check, add, delete, or move")]);

hosts/ocaml/bin/sx_server.ml

@@ -703,6 +703,11 @@ let setup_evaluator_bridge env =
     | [expr; e] -> Sx_ref.eval_expr expr (Env (Sx_runtime.unwrap_env e))
     | [expr] -> Sx_ref.eval_expr expr (Env env)
     | _ -> raise (Eval_error "eval-expr: expected (expr env?)"));
+  (* eval-in-env: (env expr) → result.  Evaluates expr in the given env. *)
+  Sx_primitives.register "eval-in-env" (fun args ->
+    match args with
+    | [e; expr] -> Sx_ref.eval_expr expr e
+    | _ -> raise (Eval_error "eval-in-env: (env expr)"));
   bind "trampoline" (fun args ->
     match args with
     | [v] ->
@@ -764,7 +769,13 @@ let setup_evaluator_bridge env =
     | _ -> raise (Eval_error "register-special-form!: expected (name handler)"));
   ignore (env_bind env "*custom-special-forms*" Sx_ref.custom_special_forms);
   ignore (Sx_ref.register_special_form (String "<>") (NativeFn ("<>", fun args ->
-    List (List.map (fun a -> Sx_ref.eval_expr a (Env env)) args))))
+    List (List.map (fun a -> Sx_ref.eval_expr a (Env env)) args))));
+  (* current-env: special form — returns current lexical env as a first-class value *)
+  ignore (Sx_ref.register_special_form (String "current-env")
+    (NativeFn ("current-env", fun args ->
+      match args with
+      | [_arg_list; env_val] -> env_val
+      | _ -> Nil)))
 
 (* ---- Type predicates and introspection ---- *)
 let setup_introspection env =
@@ -950,7 +961,24 @@ let setup_env_operations env =
   bind "env-has?" (fun args -> match args with [e; String k] -> Bool (Sx_types.env_has (uw e) k) | [e; Keyword k] -> Bool (Sx_types.env_has (uw e) k) | _ -> raise (Eval_error "env-has?: expected env and string"));
   bind "env-bind!" (fun args -> match args with [e; String k; v] -> Sx_types.env_bind (uw e) k v | [e; Keyword k; v] -> Sx_types.env_bind (uw e) k v | _ -> raise (Eval_error "env-bind!: expected env, key, value"));
   bind "env-set!" (fun args -> match args with [e; String k; v] -> Sx_types.env_set (uw e) k v | [e; Keyword k; v] -> Sx_types.env_set (uw e) k v | _ -> raise (Eval_error "env-set!: expected env, key, value"));
-  bind "env-extend" (fun args -> match args with [e] -> Env (Sx_types.env_extend (uw e)) | _ -> raise (Eval_error "env-extend: expected env"));
+  bind "env-extend" (fun args ->
+    match args with
+    | e :: pairs ->
+      let child = Sx_types.env_extend (uw e) in
+      let rec go = function
+        | [] -> ()
+        | k :: v :: rest ->
+          ignore (Sx_types.env_bind child (Sx_runtime.value_to_str k) v); go rest
+        | [_] -> raise (Eval_error "env-extend: odd number of key-val pairs") in
+      go pairs; Env child
+    | _ -> raise (Eval_error "env-extend: expected env"));
+  bind "env-lookup" (fun args ->
+    match args with
+    | [e; key] ->
+      let k = Sx_runtime.value_to_str key in
+      let raw = uw e in
+      if Sx_types.env_has raw k then Sx_types.env_get raw k else Nil
+    | _ -> raise (Eval_error "env-lookup: (env key)"));
   bind "env-merge" (fun args -> match args with [a; b] -> Sx_runtime.env_merge a b | _ -> raise (Eval_error "env-merge: expected 2 envs"))
 
 (* ---- Strict mode (gradual type system support) ---- *)

hosts/ocaml/lib/dune

@@ -1,4 +1,4 @@
 (library
  (name sx)
  (wrapped false)
- (libraries re re.pcre))
+ (libraries re re.pcre unix))

hosts/ocaml/lib/sx_primitives.ml

@@ -3000,4 +3000,174 @@ let () =
       List.iteri (fun i c -> Bytes.set b i c) bytes_list;
       SxBytevector b
     | [Nil] -> SxBytevector (Bytes.create 0)
-    | _ -> raise (Eval_error "list->bytevector: expected list"))
+    | _ -> raise (Eval_error "list->bytevector: expected list"));
+
+  (* === File I/O === *)
+  register "file-read" (fun args ->
+    match args with
+    | [String path] ->
+      (try
+        let ic = open_in path in
+        let n = in_channel_length ic in
+        let s = Bytes.create n in
+        really_input ic s 0 n;
+        close_in ic;
+        String (Bytes.to_string s)
+      with Sys_error msg -> raise (Eval_error ("file-read: " ^ msg)))
+    | _ -> raise (Eval_error "file-read: (path)"));
+
+  register "file-write" (fun args ->
+    match args with
+    | [String path; String content] ->
+      (try
+        let oc = open_out path in
+        output_string oc content;
+        close_out oc;
+        Nil
+      with Sys_error msg -> raise (Eval_error ("file-write: " ^ msg)))
+    | _ -> raise (Eval_error "file-write: (path content)"));
+
+  register "file-append" (fun args ->
+    match args with
+    | [String path; String content] ->
+      (try
+        let oc = open_out_gen [Open_append; Open_creat; Open_wronly; Open_text] 0o644 path in
+        output_string oc content;
+        close_out oc;
+        Nil
+      with Sys_error msg -> raise (Eval_error ("file-append: " ^ msg)))
+    | _ -> raise (Eval_error "file-append: (path content)"));
+
+  register "file-exists?" (fun args ->
+    match args with
+    | [String path] -> Bool (Sys.file_exists path)
+    | _ -> raise (Eval_error "file-exists?: (path)"));
+
+  register "file-glob" (fun args ->
+    let glob_match pat str =
+      let pn = String.length pat and sn = String.length str in
+      let rec go pi si =
+        if pi = pn then si = sn
+        else match pat.[pi] with
+          | '*' ->
+            let rec try_from i = i <= sn && (go (pi+1) i || try_from (i+1)) in
+            try_from si
+          | '?' -> si < sn && go (pi+1) (si+1)
+          | '[' ->
+            let pi' = ref (pi+1) in
+            let negate = !pi' < pn && pat.[!pi'] = '^' in
+            if negate then incr pi';
+            let matched = ref false in
+            while !pi' < pn && pat.[!pi'] <> ']' do
+              let c1 = pat.[!pi'] in
+              incr pi';
+              if !pi' + 1 < pn && pat.[!pi'] = '-' then begin
+                let c2 = pat.[!pi' + 1] in
+                pi' := !pi' + 2;
+                if si < sn && str.[si] >= c1 && str.[si] <= c2 then matched := true
+              end else if si < sn && str.[si] = c1 then matched := true
+            done;
+            if !pi' < pn then incr pi';
+            ((!matched && not negate) || (not !matched && negate)) && go !pi' (si+1)
+          | c -> si < sn && str.[si] = c && go (pi+1) (si+1)
+      in go 0 0
+    in
+    let glob_paths pat =
+      let dir = Filename.dirname pat in
+      let base_pat = Filename.basename pat in
+      let dir' = if dir = "." && not (String.length pat > 1 && pat.[0] = '.') then "." else dir in
+      (try
+        let entries = Sys.readdir dir' in
+        Array.fold_left (fun acc entry ->
+          if glob_match base_pat entry then
+            let full = if dir' = "." then entry else Filename.concat dir' entry in
+            full :: acc
+          else acc
+        ) [] entries
+        |> List.sort String.compare
+      with Sys_error _ -> [])
+    in
+    match args with
+    | [String pat] -> List (List.map (fun s -> String s) (glob_paths pat))
+    | _ -> raise (Eval_error "file-glob: (pattern)"));
+
+  (* === Clock === *)
+  register "clock-seconds" (fun args ->
+    match args with
+    | [] -> Integer (int_of_float (Unix.gettimeofday ()))
+    | _ -> raise (Eval_error "clock-seconds: no args"));
+
+  register "clock-milliseconds" (fun args ->
+    match args with
+    | [] -> Integer (int_of_float (Unix.gettimeofday () *. 1000.0))
+    | _ -> raise (Eval_error "clock-milliseconds: no args"));
+
+  register "clock-format" (fun args ->
+    match args with
+    | [Integer t] | [Integer t; String _] ->
+      let fmt = (match args with [_; String f] -> f | _ -> "%a %b %e %H:%M:%S %Z %Y") in
+      let tm = Unix.gmtime (float_of_int t) in
+      let buf = Buffer.create 32 in
+      let n = String.length fmt in
+      let i = ref 0 in
+      while !i < n do
+        if fmt.[!i] = '%' && !i + 1 < n then begin
+          (match fmt.[!i + 1] with
+           | 'Y' -> Buffer.add_string buf (Printf.sprintf "%04d" (1900 + tm.Unix.tm_year))
+           | 'm' -> Buffer.add_string buf (Printf.sprintf "%02d" (tm.Unix.tm_mon + 1))
+           | 'd' -> Buffer.add_string buf (Printf.sprintf "%02d" tm.Unix.tm_mday)
+           | 'e' -> Buffer.add_string buf (Printf.sprintf "%2d"  tm.Unix.tm_mday)
+           | 'H' -> Buffer.add_string buf (Printf.sprintf "%02d" tm.Unix.tm_hour)
+           | 'M' -> Buffer.add_string buf (Printf.sprintf "%02d" tm.Unix.tm_min)
+           | 'S' -> Buffer.add_string buf (Printf.sprintf "%02d" tm.Unix.tm_sec)
+           | 'j' -> Buffer.add_string buf (Printf.sprintf "%03d" (tm.Unix.tm_yday + 1))
+           | 'Z' -> Buffer.add_string buf "UTC"
+           | 'a' -> let days = [|"Sun";"Mon";"Tue";"Wed";"Thu";"Fri";"Sat"|] in
+                    Buffer.add_string buf days.(tm.Unix.tm_wday)
+           | 'A' -> let days = [|"Sunday";"Monday";"Tuesday";"Wednesday";"Thursday";"Friday";"Saturday"|] in
+                    Buffer.add_string buf days.(tm.Unix.tm_wday)
+           | 'b' | 'h' -> let mons = [|"Jan";"Feb";"Mar";"Apr";"May";"Jun";"Jul";"Aug";"Sep";"Oct";"Nov";"Dec"|] in
+                    Buffer.add_string buf mons.(tm.Unix.tm_mon)
+           | 'B' -> let mons = [|"January";"February";"March";"April";"May";"June";"July";"August";"September";"October";"November";"December"|] in
+                    Buffer.add_string buf mons.(tm.Unix.tm_mon)
+           | c -> Buffer.add_char buf '%'; Buffer.add_char buf c);
+          i := !i + 2
+        end else begin
+          Buffer.add_char buf fmt.[!i];
+          incr i
+        end
+      done;
+      String (Buffer.contents buf)
+    | _ -> raise (Eval_error "clock-format: (seconds [format])"));
+
+  (* === Env-as-value (Phase 4) === *)
+
+  (* env-lookup: (env key) → value or nil.  Works on Env, Dict, or Nil. *)
+  register "env-lookup" (fun args ->
+    let unwrap = function
+      | Env e -> e
+      | Nil -> make_env ()
+      | _ -> raise (Eval_error "env-lookup: first arg must be an environment") in
+    match args with
+    | [env_val; key] ->
+      let e = unwrap env_val in
+      let k = value_to_string key in
+      if env_has e k then env_get e k else Nil
+    | _ -> raise (Eval_error "env-lookup: (env key)"));
+
+  (* env-extend: (env [key val ...]) → new child env with optional bindings. *)
+  register "env-extend" (fun args ->
+    match args with
+    | [] -> raise (Eval_error "env-extend: requires at least one arg")
+    | env_val :: pairs ->
+      let parent_env = match env_val with
+        | Env e -> e
+        | Nil -> make_env ()
+        | _ -> raise (Eval_error "env-extend: first arg must be an environment") in
+      let child = env_extend parent_env in
+      let rec add_bindings = function
+        | [] -> ()
+        | k :: v :: rest -> ignore (env_bind child (value_to_string k) v); add_bindings rest
+        | [_] -> raise (Eval_error "env-extend: odd number of key-val pairs") in
+      add_bindings pairs;
+      Env child)

hosts/ocaml/lib/sx_runtime.ml

@@ -539,3 +539,4 @@ let jit_try_call f args =
       (match hook f arg_list with Some result -> incr _jit_hit; result | None -> incr _jit_miss; _jit_skip_sentinel)
     | _ -> incr _jit_skip; _jit_skip_sentinel
 
+

lib/apl/conformance.sh

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

lib/apl/parser.sx

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

lib/apl/scoreboard.json

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

lib/apl/scoreboard.md

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

lib/apl/test.sh

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

lib/apl/tests/dfn.sx

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

lib/apl/tests/eval-ops.sx

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

lib/apl/tests/idioms.sx

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

lib/apl/tests/operators.sx

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

lib/apl/tests/parse.sx

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

lib/apl/tests/pipeline.sx

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

lib/apl/tests/programs-e2e.sx

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

lib/apl/tests/programs.sx

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

lib/apl/tests/programs/life.apl

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

lib/apl/tests/programs/mandelbrot.apl

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

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

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

lib/apl/tests/programs/primes.apl

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

lib/apl/tests/programs/quicksort.apl

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

lib/apl/tests/scalar.sx

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

lib/apl/tests/structural.sx

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

lib/apl/tests/system.sx

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

lib/apl/tests/tradfn.sx

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

lib/apl/tests/valence.sx

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

lib/apl/tokenizer.sx

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

lib/apl/transpile.sx

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

lib/fiber.sx

@@ -0,0 +1,44 @@
+; lib/fiber.sx — pure SX fiber library using call/cc
+;
+; A fiber is a cooperative coroutine with true suspension (no eager
+; pre-execution). Each fiber is a dict {:resume fn :done? fn}.
+;
+; make-fiber body   → fiber dict
+;   body = (fn (yield init-val) ...)  — body receives yield + first resume val
+;   yield = (fn (val) ...)            — suspends fiber, returns val to resumer
+;
+; fiber-resume f v  → next yielded value, or nil when body returns
+; fiber-done? f     → true after body has returned
+
+(define make-fiber
+  (fn (body)
+    (let
+      ((resume-k nil)
+        (caller-k nil)
+        (done false))
+      (let
+        ((yield
+            (fn (val)
+              (call/cc
+                (fn (k)
+                  (set! resume-k k)
+                  (caller-k val))))))
+        {:resume
+         (fn (val)
+           (if
+             done
+             nil
+             (call/cc
+               (fn (k)
+                 (set! caller-k k)
+                 (if
+                   (nil? resume-k)
+                   (begin
+                     (body yield val)
+                     (set! done true)
+                     (k nil))
+                   (resume-k val))))))
+         :done? (fn () done)}))))
+
+(define fiber-resume (fn (f v) ((get f :resume) v)))
+(define fiber-done?  (fn (f) ((get f :done?))))

lib/haskell/conformance.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# lib/haskell/conformance.sh — run the 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 collatz palindrome maybe fizzbuzz anagram roman binary either primes zipwith matrix wordcount powers)
+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 6 (prelude extras + 18 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/infer.sx

@@ -0,0 +1,658 @@
+;; infer.sx — Hindley-Milner Algorithm W for Haskell-on-SX (Phase 4).
+;;
+;; Types: TVar, TCon, TArr, TApp, TTuple, TScheme
+;; Substitution: apply, compose, restrict
+;; Unification (with occurs check)
+;; Instantiation + generalization (let-polymorphism)
+;; Algorithm W for: literals, var, con, lambda, app, let, if, op, tuple, list
+
+;; ─── Type constructors ────────────────────────────────────────────────────────
+
+(define hk-tvar (fn (n) (list "TVar" n)))
+(define hk-tcon (fn (s) (list "TCon" s)))
+(define hk-tarr (fn (a b) (list "TArr" a b)))
+(define hk-tapp (fn (a b) (list "TApp" a b)))
+(define hk-ttuple (fn (ts) (list "TTuple" ts)))
+(define hk-tscheme (fn (vs t) (list "TScheme" vs t)))
+
+(define hk-tvar? (fn (t) (and (list? t) (not (empty? t)) (= (first t) "TVar"))))
+(define hk-tcon? (fn (t) (and (list? t) (not (empty? t)) (= (first t) "TCon"))))
+(define hk-tarr? (fn (t) (and (list? t) (not (empty? t)) (= (first t) "TArr"))))
+(define hk-tapp? (fn (t) (and (list? t) (not (empty? t)) (= (first t) "TApp"))))
+(define hk-ttuple? (fn (t) (and (list? t) (not (empty? t)) (= (first t) "TTuple"))))
+(define hk-tscheme? (fn (t) (and (list? t) (not (empty? t)) (= (first t) "TScheme"))))
+
+(define hk-tvar-name (fn (t) (nth t 1)))
+(define hk-tcon-name (fn (t) (nth t 1)))
+(define hk-tarr-t1 (fn (t) (nth t 1)))
+(define hk-tarr-t2 (fn (t) (nth t 2)))
+(define hk-tapp-t1 (fn (t) (nth t 1)))
+(define hk-tapp-t2 (fn (t) (nth t 2)))
+(define hk-ttuple-ts (fn (t) (nth t 1)))
+(define hk-tscheme-vs (fn (t) (nth t 1)))
+(define hk-tscheme-type (fn (t) (nth t 2)))
+
+(define hk-t-int    (hk-tcon "Int"))
+(define hk-t-bool   (hk-tcon "Bool"))
+(define hk-t-string (hk-tcon "String"))
+(define hk-t-char   (hk-tcon "Char"))
+(define hk-t-float  (hk-tcon "Float"))
+(define hk-t-list (fn (t) (hk-tapp (hk-tcon "[]") t)))
+
+;; ─── Type formatter ──────────────────────────────────────────────────────────
+
+(define
+  hk-type->str
+  (fn
+    (t)
+    (cond
+      ((hk-tvar? t)   (hk-tvar-name t))
+      ((hk-tcon? t)   (hk-tcon-name t))
+      ((hk-tarr? t)
+       (let ((s1 (if (hk-tarr? (hk-tarr-t1 t))
+                   (str "(" (hk-type->str (hk-tarr-t1 t)) ")")
+                   (hk-type->str (hk-tarr-t1 t)))))
+         (str s1 " -> " (hk-type->str (hk-tarr-t2 t)))))
+      ((hk-tapp? t)
+       (let ((h (hk-tapp-t1 t)))
+         (cond
+           ((and (hk-tcon? h) (= (hk-tcon-name h) "[]"))
+            (str "[" (hk-type->str (hk-tapp-t2 t)) "]"))
+           (:else
+            (str "(" (hk-type->str h) " " (hk-type->str (hk-tapp-t2 t)) ")")))))
+      ((hk-ttuple? t)
+       (str "(" (join ", " (map hk-type->str (hk-ttuple-ts t))) ")"))
+      ((hk-tscheme? t)
+       (str "forall " (join " " (hk-tscheme-vs t)) ". " (hk-type->str (hk-tscheme-type t))))
+      (:else "<?>"))))
+
+;; ─── Fresh variable counter ───────────────────────────────────────────────────
+
+(define hk-fresh-ctr 0)
+(define hk-fresh (fn () (set! hk-fresh-ctr (+ hk-fresh-ctr 1)) (hk-tvar (str "t" hk-fresh-ctr))))
+(define hk-reset-fresh (fn () (set! hk-fresh-ctr 0)))
+
+;; ─── Utilities ───────────────────────────────────────────────────────────────
+
+(define hk-infer-member? (fn (x lst) (some (fn (y) (= x y)) lst)))
+
+(define
+  hk-nub
+  (fn (lst)
+    (reduce (fn (acc x) (if (hk-infer-member? x acc) acc (append acc (list x)))) (list) lst)))
+
+;; ─── Free type variables ──────────────────────────────────────────────────────
+
+(define
+  hk-ftv
+  (fn
+    (t)
+    (cond
+      ((hk-tvar? t)    (list (hk-tvar-name t)))
+      ((hk-tcon? t)    (list))
+      ((hk-tarr? t)    (append (hk-ftv (hk-tarr-t1 t)) (hk-ftv (hk-tarr-t2 t))))
+      ((hk-tapp? t)    (append (hk-ftv (hk-tapp-t1 t)) (hk-ftv (hk-tapp-t2 t))))
+      ((hk-ttuple? t)  (reduce append (list) (map hk-ftv (hk-ttuple-ts t))))
+      ((hk-tscheme? t)
+       (filter
+         (fn (v) (not (hk-infer-member? v (hk-tscheme-vs t))))
+         (hk-ftv (hk-tscheme-type t))))
+      (:else (list)))))
+
+(define
+  hk-ftv-env
+  (fn (env)
+    (reduce (fn (acc k) (append acc (hk-ftv (get env k)))) (list) (keys env))))
+
+;; ─── Substitution ─────────────────────────────────────────────────────────────
+
+(define hk-subst-empty (dict))
+
+(define
+  hk-subst-restrict
+  (fn
+    (s exclude)
+    (let ((r (dict)))
+      (for-each
+        (fn (k)
+          (when (not (hk-infer-member? k exclude))
+            (dict-set! r k (get s k))))
+        (keys s))
+      r)))
+
+(define
+  hk-subst-apply
+  (fn
+    (s t)
+    (cond
+      ((hk-tvar? t)
+       (let ((v (get s (hk-tvar-name t))))
+         (if (nil? v) t (hk-subst-apply s v))))
+      ((hk-tarr? t)
+       (hk-tarr (hk-subst-apply s (hk-tarr-t1 t))
+                (hk-subst-apply s (hk-tarr-t2 t))))
+      ((hk-tapp? t)
+       (hk-tapp (hk-subst-apply s (hk-tapp-t1 t))
+                (hk-subst-apply s (hk-tapp-t2 t))))
+      ((hk-ttuple? t)
+       (hk-ttuple (map (fn (u) (hk-subst-apply s u)) (hk-ttuple-ts t))))
+      ((hk-tscheme? t)
+       (let ((s2 (hk-subst-restrict s (hk-tscheme-vs t))))
+         (hk-tscheme (hk-tscheme-vs t)
+                     (hk-subst-apply s2 (hk-tscheme-type t)))))
+      (:else t))))
+
+(define
+  hk-subst-compose
+  (fn
+    (s2 s1)
+    (let ((r (hk-dict-copy s2)))
+      (for-each
+        (fn (k)
+          (when (nil? (get r k))
+            (dict-set! r k (hk-subst-apply s2 (get s1 k)))))
+        (keys s1))
+      r)))
+
+(define
+  hk-env-apply-subst
+  (fn
+    (s env)
+    (let ((r (dict)))
+      (for-each (fn (k) (dict-set! r k (hk-subst-apply s (get env k)))) (keys env))
+      r)))
+
+;; ─── Unification ─────────────────────────────────────────────────────────────
+
+(define
+  hk-bind-var
+  (fn
+    (v t)
+    (cond
+      ((and (hk-tvar? t) (= (hk-tvar-name t) v))
+       hk-subst-empty)
+      ((hk-infer-member? v (hk-ftv t))
+       (raise (str "Occurs check failed: " v " in " (hk-type->str t))))
+      (:else
+       (let ((s (dict)))
+         (dict-set! s v t)
+         s)))))
+
+(define
+  hk-zip-unify
+  (fn
+    (ts1 ts2 acc)
+    (if (or (empty? ts1) (empty? ts2))
+      acc
+      (let ((s (hk-unify (hk-subst-apply acc (first ts1))
+                         (hk-subst-apply acc (first ts2)))))
+        (hk-zip-unify (rest ts1) (rest ts2) (hk-subst-compose s acc))))))
+
+(define
+  hk-unify
+  (fn
+    (t1 t2)
+    (cond
+      ((and (hk-tvar? t1) (hk-tvar? t2) (= (hk-tvar-name t1) (hk-tvar-name t2)))
+       hk-subst-empty)
+      ((hk-tvar? t1) (hk-bind-var (hk-tvar-name t1) t2))
+      ((hk-tvar? t2) (hk-bind-var (hk-tvar-name t2) t1))
+      ((and (hk-tcon? t1) (hk-tcon? t2) (= (hk-tcon-name t1) (hk-tcon-name t2)))
+       hk-subst-empty)
+      ((and (hk-tarr? t1) (hk-tarr? t2))
+       (let ((s1 (hk-unify (hk-tarr-t1 t1) (hk-tarr-t1 t2))))
+         (let ((s2 (hk-unify (hk-subst-apply s1 (hk-tarr-t2 t1))
+                             (hk-subst-apply s1 (hk-tarr-t2 t2)))))
+           (hk-subst-compose s2 s1))))
+      ((and (hk-tapp? t1) (hk-tapp? t2))
+       (let ((s1 (hk-unify (hk-tapp-t1 t1) (hk-tapp-t1 t2))))
+         (let ((s2 (hk-unify (hk-subst-apply s1 (hk-tapp-t2 t1))
+                             (hk-subst-apply s1 (hk-tapp-t2 t2)))))
+           (hk-subst-compose s2 s1))))
+      ((and (hk-ttuple? t1) (hk-ttuple? t2)
+            (= (length (hk-ttuple-ts t1)) (length (hk-ttuple-ts t2))))
+       (hk-zip-unify (hk-ttuple-ts t1) (hk-ttuple-ts t2) hk-subst-empty))
+      (:else
+       (raise (str "Cannot unify " (hk-type->str t1) " with " (hk-type->str t2)))))))
+
+;; ─── Instantiation and generalization ────────────────────────────────────────
+
+(define
+  hk-instantiate
+  (fn
+    (t)
+    (if (not (hk-tscheme? t))
+      t
+      (let ((s (dict)))
+        (for-each (fn (v) (dict-set! s v (hk-fresh))) (hk-tscheme-vs t))
+        (hk-subst-apply s (hk-tscheme-type t))))))
+
+(define
+  hk-generalize
+  (fn
+    (env t)
+    (let ((free-t   (hk-nub (hk-ftv t)))
+          (free-env (hk-nub (hk-ftv-env env))))
+      (let ((bound (filter (fn (v) (not (hk-infer-member? v free-env))) free-t)))
+        (if (empty? bound)
+          t
+          (hk-tscheme bound t))))))
+
+;; ─── Pattern binding extraction ──────────────────────────────────────────────
+;; Returns a dict of name → type bindings introduced by matching pat against tv.
+
+(define
+  hk-w-pat
+  (fn
+    (pat tv)
+    (let ((tag (first pat)))
+      (cond
+        ((= tag "p-var")  (let ((d (dict))) (dict-set! d (nth pat 1) tv) d))
+        ((= tag "p-wild") (dict))
+        (:else            (dict))))))
+
+;; ─── Algorithm W ─────────────────────────────────────────────────────────────
+;; hk-w : env × expr → (list subst type)
+
+(define
+  hk-w-let
+  (fn
+    (env binds body)
+    ;; Infer types for each binding in order, generalising at each step.
+    (let
+      ((env2
+        (reduce
+          (fn
+            (cur-env b)
+            (let ((tag (first b)))
+              (cond
+                ;; Simple pattern binding: let x = expr
+                ((or (= tag "bind") (= tag "pat-bind"))
+                 (let ((pat  (nth b 1))
+                       (rhs  (nth b 2)))
+                   (let ((tv (hk-fresh)))
+                     (let ((r (hk-w cur-env rhs)))
+                       (let ((s1 (first r)) (t1 (nth r 1)))
+                         (let ((s2 (hk-unify (hk-subst-apply s1 tv) t1)))
+                           (let ((s (hk-subst-compose s2 s1)))
+                             (let ((t-gen (hk-generalize (hk-env-apply-subst s cur-env)
+                                                         (hk-subst-apply s t1))))
+                               (let ((bindings (hk-w-pat pat t-gen)))
+                                 (let ((r2 (hk-dict-copy cur-env)))
+                                   (for-each
+                                     (fn (k) (dict-set! r2 k (get bindings k)))
+                                     (keys bindings))
+                                   r2))))))))))
+                ;; Function clause: let f x y = expr
+                ((= tag "fun-clause")
+                 (let ((name (nth b 1))
+                       (pats (nth b 2))
+                       (body2 (nth b 3)))
+                   ;; Treat as: let name = lambda pats body2
+                   (let ((rhs (if (empty? pats)
+                                body2
+                                (list "lambda" pats body2))))
+                     (let ((tv (hk-fresh)))
+                       (let ((env-rec (hk-dict-copy cur-env)))
+                         (dict-set! env-rec name tv)
+                         (let ((r (hk-w env-rec rhs)))
+                           (let ((s1 (first r)) (t1 (nth r 1)))
+                             (let ((s2 (hk-unify (hk-subst-apply s1 tv) t1)))
+                               (let ((s (hk-subst-compose s2 s1)))
+                                 (let ((t-gen (hk-generalize
+                                                (hk-env-apply-subst s cur-env)
+                                                (hk-subst-apply s t1))))
+                                   (let ((r2 (hk-dict-copy cur-env)))
+                                     (dict-set! r2 name t-gen)
+                                     r2)))))))))))
+                (:else cur-env))))
+          env
+          binds)))
+      (hk-w env2 body))))
+
+(define
+  hk-w
+  (fn
+    (env expr)
+    (let ((tag (first expr)))
+      (cond
+        ;; Literals
+        ((= tag "int")    (list hk-subst-empty hk-t-int))
+        ((= tag "float")  (list hk-subst-empty hk-t-float))
+        ((= tag "string") (list hk-subst-empty hk-t-string))
+        ((= tag "char")   (list hk-subst-empty hk-t-char))
+
+        ;; Variable
+        ((= tag "var")
+         (let ((name (nth expr 1)))
+           (let ((scheme (get env name)))
+             (if (nil? scheme)
+               (raise (str "Unbound variable: " name))
+               (list hk-subst-empty (hk-instantiate scheme))))))
+
+        ;; Constructor (same lookup as var)
+        ((= tag "con")
+         (let ((name (nth expr 1)))
+           (let ((scheme (get env name)))
+             (if (nil? scheme)
+               (list hk-subst-empty (hk-fresh))
+               (list hk-subst-empty (hk-instantiate scheme))))))
+
+        ;; Unary negation
+        ((= tag "neg")
+         (let ((r (hk-w env (nth expr 1))))
+           (let ((s1 (first r)) (t1 (nth r 1)))
+             (let ((s2 (hk-unify t1 hk-t-int)))
+               (list (hk-subst-compose s2 s1) hk-t-int)))))
+
+        ;; Lambda: ("lambda" pats body)
+        ((= tag "lambda")
+         (let ((pats (nth expr 1))
+               (body (nth expr 2)))
+           (if (empty? pats)
+             (hk-w env body)
+             (let ((pat  (first pats))
+                   (rest (rest pats)))
+               (let ((tv (hk-fresh)))
+                 (let ((bindings (hk-w-pat pat tv)))
+                   (let ((env2 (hk-dict-copy env)))
+                     (for-each (fn (k) (dict-set! env2 k (get bindings k))) (keys bindings))
+                     (let ((inner (if (empty? rest)
+                                    body
+                                    (list "lambda" rest body))))
+                       (let ((r (hk-w env2 inner)))
+                         (let ((s1 (first r)) (t1 (nth r 1)))
+                           (list s1 (hk-tarr (hk-subst-apply s1 tv) t1))))))))))))
+
+        ;; Application: ("app" f x)
+        ((= tag "app")
+         (let ((tv (hk-fresh)))
+           (let ((r1 (hk-w env (nth expr 1))))
+             (let ((s1 (first r1)) (tf (nth r1 1)))
+               (let ((r2 (hk-w (hk-env-apply-subst s1 env) (nth expr 2))))
+                 (let ((s2 (first r2)) (tx (nth r2 1)))
+                   (let ((s3 (hk-unify (hk-subst-apply s2 tf) (hk-tarr tx tv))))
+                     (let ((s (hk-subst-compose s3 (hk-subst-compose s2 s1))))
+                       (list s (hk-subst-apply s3 tv))))))))))
+
+        ;; Let: ("let" binds body)
+        ((= tag "let")
+         (hk-w-let env (nth expr 1) (nth expr 2)))
+
+        ;; If: ("if" cond then else)
+        ((= tag "if")
+         (let ((r1 (hk-w env (nth expr 1))))
+           (let ((s1 (first r1)) (tc (nth r1 1)))
+             (let ((s2 (hk-unify tc hk-t-bool)))
+               (let ((s12 (hk-subst-compose s2 s1)))
+                 (let ((r2 (hk-w (hk-env-apply-subst s12 env) (nth expr 2))))
+                   (let ((s3 (first r2)) (tt (nth r2 1)))
+                     (let ((s123 (hk-subst-compose s3 s12)))
+                       (let ((r3 (hk-w (hk-env-apply-subst s123 env) (nth expr 3))))
+                         (let ((s4 (first r3)) (te (nth r3 1)))
+                           (let ((s5 (hk-unify (hk-subst-apply s4 tt) te)))
+                             (let ((s (hk-subst-compose s5 (hk-subst-compose s4 s123))))
+                               (list s (hk-subst-apply s5 te))))))))))))))
+
+        ;; Binary operator: ("op" op-name left right)
+        ;; Desugar to double application.
+        ((= tag "op")
+         (hk-w env
+               (list "app"
+                     (list "app" (list "var" (nth expr 1)) (nth expr 2))
+                     (nth expr 3))))
+
+        ;; Tuple: ("tuple" [e1 e2 ...])
+        ((= tag "tuple")
+         (let ((elems (nth expr 1)))
+           (let ((s-acc hk-subst-empty)
+                 (ts    (list)))
+             (for-each
+               (fn (e)
+                 (let ((r (hk-w (hk-env-apply-subst s-acc env) e)))
+                   (set! s-acc (hk-subst-compose (first r) s-acc))
+                   (set! ts    (append ts (list (nth r 1))))))
+               elems)
+             (list s-acc (hk-ttuple (map (fn (t) (hk-subst-apply s-acc t)) ts))))))
+
+        ;; List literal: ("list" [e1 e2 ...])
+        ((= tag "list")
+         (let ((elems (nth expr 1)))
+           (if (empty? elems)
+             (list hk-subst-empty (hk-t-list (hk-fresh)))
+             (let ((tv (hk-fresh)))
+               (let ((s-acc hk-subst-empty))
+                 (for-each
+                   (fn (e)
+                     (let ((r (hk-w (hk-env-apply-subst s-acc env) e)))
+                       (let ((s2 (first r)) (te (nth r 1)))
+                         (let ((s3 (hk-unify (hk-subst-apply s2 tv) te)))
+                           (set! s-acc (hk-subst-compose s3 (hk-subst-compose s2 s-acc)))))))
+                   elems)
+                 (list s-acc (hk-t-list (hk-subst-apply s-acc tv))))))))
+
+        ;; Location annotation: just delegate — position is for outer context.
+        ((= tag "loc")
+         (hk-w env (nth expr 3)))
+
+        (:else
+         (raise (str "hk-w: unhandled tag: " tag)))))))
+
+;; ─── Initial type environment ─────────────────────────────────────────────────
+;; Monomorphic numeric ops (no Num typeclass yet — upgraded in Phase 5).
+
+(define
+  hk-type-env0
+  (fn ()
+    (let ((env (dict)))
+      ;; Integer arithmetic
+      (for-each
+        (fn (op)
+          (dict-set! env op (hk-tarr hk-t-int (hk-tarr hk-t-int hk-t-int))))
+        (list "+" "-" "*" "div" "mod" "quot" "rem"))
+      ;; Integer comparison → Bool
+      (for-each
+        (fn (op)
+          (dict-set! env op (hk-tarr hk-t-int (hk-tarr hk-t-int hk-t-bool))))
+        (list "==" "/=" "<" "<=" ">" ">="))
+      ;; Boolean operators
+      (dict-set! env "&&" (hk-tarr hk-t-bool (hk-tarr hk-t-bool hk-t-bool)))
+      (dict-set! env "||" (hk-tarr hk-t-bool (hk-tarr hk-t-bool hk-t-bool)))
+      (dict-set! env "not" (hk-tarr hk-t-bool hk-t-bool))
+      ;; Constructors
+      (dict-set! env "True"  hk-t-bool)
+      (dict-set! env "False" hk-t-bool)
+      ;; Polymorphic list ops (using TScheme)
+      (let ((a (hk-tvar "a")))
+        (dict-set! env "head"  (hk-tscheme (list "a") (hk-tarr (hk-t-list a) a)))
+        (dict-set! env "tail"  (hk-tscheme (list "a") (hk-tarr (hk-t-list a) (hk-t-list a))))
+        (dict-set! env "null"  (hk-tscheme (list "a") (hk-tarr (hk-t-list a) hk-t-bool)))
+        (dict-set! env "length" (hk-tscheme (list "a") (hk-tarr (hk-t-list a) hk-t-int)))
+        (dict-set! env "reverse" (hk-tscheme (list "a") (hk-tarr (hk-t-list a) (hk-t-list a))))
+        (dict-set! env ":"
+          (hk-tscheme (list "a") (hk-tarr a (hk-tarr (hk-t-list a) (hk-t-list a))))))
+      ;; negate
+      (dict-set! env "negate" (hk-tarr hk-t-int hk-t-int))
+      (dict-set! env "abs"    (hk-tarr hk-t-int hk-t-int))
+      env)))
+
+;; ─── Expression brief printer ────────────────────────────────────────────────
+;; Produces a short human-readable label for an AST node used in error messages.
+
+(define
+  hk-expr->brief
+  (fn
+    (expr)
+    (cond
+      ((not (list? expr)) (str expr))
+      ((empty? expr)      "()")
+      (:else
+       (let ((tag (first expr)))
+         (cond
+           ((= tag "var")    (nth expr 1))
+           ((= tag "con")    (nth expr 1))
+           ((= tag "int")    (str (nth expr 1)))
+           ((= tag "float")  (str (nth expr 1)))
+           ((= tag "string") (str "\"" (nth expr 1) "\""))
+           ((= tag "char")   (str "'" (nth expr 1) "'"))
+           ((= tag "neg")    (str "(-" (hk-expr->brief (nth expr 1)) ")"))
+           ((= tag "app")
+            (str "(" (hk-expr->brief (nth expr 1))
+                 " " (hk-expr->brief (nth expr 2)) ")"))
+           ((= tag "op")
+            (str "(" (hk-expr->brief (nth expr 2))
+                 " " (nth expr 1)
+                 " " (hk-expr->brief (nth expr 3)) ")"))
+           ((= tag "lambda") "(\\ ...)")
+           ((= tag "let")    "(let ...)")
+           ((= tag "if")     "(if ...)")
+           ((= tag "tuple")  "(tuple ...)")
+           ((= tag "list")   "[...]")
+           ((= tag "loc")    (hk-expr->brief (nth expr 3)))
+           (:else            (str "(" tag " ..."))))))))
+
+;; ─── Loc-annotated inference ──────────────────────────────────────────────────
+;; ("loc" LINE COL INNER) node: hk-w catches any error and re-raises with
+;; "at LINE:COL: " prepended.  Emitted by the parser or test scaffolding.
+
+;; Extended hk-w handles "loc" — handled inline in the cond below.
+
+;; ─── Program-level inference ─────────────────────────────────────────────────
+;; hk-infer-decl : env × decl → ("ok" name type-str) | ("err" msg) | nil
+;;   Uses tagged results so callers don't need re-raise.
+
+(define
+  hk-infer-decl
+  (fn
+    (env decl)
+    (let
+      ((tag (first decl)))
+      (cond
+        ((= tag "fun-clause")
+          (let
+            ((name (nth decl 1)) (pats (nth decl 2)) (body (nth decl 3)))
+            (let
+              ((rhs (if (empty? pats) body (list "lambda" pats body))))
+              (guard
+                (e (#t (list "err" (str "in '" name "': " e))))
+                (begin
+                  (hk-reset-fresh)
+                  (let
+                    ((r (hk-w env rhs)))
+                    (let
+                      ((final-type (hk-subst-apply (first r) (nth r 1))))
+                      (list "ok" name (hk-type->str final-type) final-type))))))))
+        ((or (= tag "bind") (= tag "pat-bind"))
+          (let
+            ((pat (nth decl 1)) (body (nth decl 2)))
+            (let
+              ((label (if (and (list? pat) (= (first pat) "p-var")) (nth pat 1) "<binding>")))
+              (guard
+                (e (#t (list "err" (str "in '" label "': " e))))
+                (begin
+                  (hk-reset-fresh)
+                  (let
+                    ((r (hk-w env body)))
+                    (let
+                      ((final-type (hk-subst-apply (first r) (nth r 1))))
+                      (list "ok" label (hk-type->str final-type) final-type))))))))
+        (:else nil)))))
+
+;; hk-infer-prog : program-ast × env → list of ("ok" name type) | ("err" msg)
+
+(define
+  hk-ast-type
+  (fn
+    (ast)
+    (let
+      ((tag (first ast)))
+      (cond
+        ((= tag "t-con") (list "TCon" (nth ast 1)))
+        ((= tag "t-var") (list "TVar" (nth ast 1)))
+        ((= tag "t-fun")
+          (list "TArr" (hk-ast-type (nth ast 1)) (hk-ast-type (nth ast 2))))
+        ((= tag "t-app")
+          (list "TApp" (hk-ast-type (nth ast 1)) (hk-ast-type (nth ast 2))))
+        ((= tag "t-list")
+          (list "TApp" (list "TCon" "[]") (hk-ast-type (nth ast 1))))
+        ((= tag "t-tuple") (list "TTuple" (map hk-ast-type (nth ast 1))))
+        (:else (raise (str "unknown type node: " (first ast))))))))
+
+;; ─── Convenience ─────────────────────────────────────────────────────────────
+;; hk-infer-type : Haskell expression source → inferred type string
+
+(define
+  hk-collect-tvars
+  (fn
+    (t acc)
+    (cond
+      ((= (first t) "TVar")
+        (if
+          (some (fn (v) (= v (nth t 1))) acc)
+          acc
+          (begin (append! acc (nth t 1)) acc)))
+      ((= (first t) "TArr")
+        (hk-collect-tvars (nth t 2) (hk-collect-tvars (nth t 1) acc)))
+      ((= (first t) "TApp")
+        (hk-collect-tvars (nth t 2) (hk-collect-tvars (nth t 1) acc)))
+      ((= (first t) "TTuple")
+        (reduce (fn (a elem) (hk-collect-tvars elem a)) acc (nth t 1)))
+      (:else acc))))
+
+(define
+  hk-check-sig
+  (fn
+    (declared-ast inferred-type)
+    (let
+      ((declared (hk-ast-type declared-ast)))
+      (let
+        ((tvars (hk-collect-tvars declared (list))))
+        (let
+          ((scheme (if (empty? tvars) declared (list "TScheme" tvars declared))))
+          (let
+            ((inst (hk-instantiate scheme)))
+            (hk-unify inst inferred-type)))))))
+
+(define
+  hk-infer-prog
+  (fn
+    (prog env)
+    (let
+      ((decls (cond ((and (list? prog) (= (first prog) "program")) (nth prog 1)) ((and (list? prog) (= (first prog) "module")) (nth prog 3)) (:else (list))))
+        (results (list))
+        (sigs (dict)))
+      (for-each
+        (fn
+          (d)
+          (when
+            (= (first d) "type-sig")
+            (let
+              ((names (nth d 1)) (type-ast (nth d 2)))
+              (for-each (fn (n) (dict-set! sigs n type-ast)) names))))
+        decls)
+      (for-each
+        (fn
+          (d)
+          (let
+            ((r (hk-infer-decl env d)))
+            (when
+              (not (nil? r))
+              (let
+                ((checked (if (and (= (first r) "ok") (has-key? sigs (nth r 1))) (guard (e (true (list "err" (str "in '" (nth r 1) "': declared type mismatch: " e)))) (begin (hk-check-sig (get sigs (nth r 1)) (nth r 3)) r)) r)))
+                (append! results checked)
+                (when
+                  (= (first checked) "ok")
+                  (dict-set! env (nth checked 1) (nth checked 3)))))))
+        decls)
+      results)))
+
+(define
+  hk-infer-type
+  (fn
+    (src)
+    (hk-reset-fresh)
+    (let
+      ((ast (hk-core-expr src)) (env (hk-type-env0)))
+      (let
+        ((r (hk-w env ast)))
+        (hk-type->str (hk-subst-apply (first r) (nth r 1)))))))

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

@@ -1,507 +1,130 @@
-;; lib/haskell/runtime.sx — Haskell-on-SX runtime layer
+;; Haskell runtime: constructor registry.
 ;;
-;; Covers the Haskell primitives now reachable via SX spec:
-;;  1. Numeric type class helpers (Num / Integral / Fractional)
-;;  2. Rational numbers (dict-based: {:_rational true :num n :den d})
-;;  3. Lazy evaluation — hk-force for promises created by delay
-;;  4. Char utilities (Data.Char)
-;;  5. Data.Set wrappers
-;;  6. Data.List utilities
-;;  7. Maybe / Either ADTs
-;;  8. Tuples (lists, since list->vector unreliable in sx_server)
-;;  9. String helpers (words/lines/isPrefixOf/etc.)
-;; 10. Show helper
+;; 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.
 
-;; ===========================================================================
-;; 1. Numeric type class helpers
-;; ===========================================================================
+(define hk-constructors (dict))
 
-(define hk-is-integer? integer?)
-(define hk-is-float? float?)
-(define hk-is-num? number?)
-
-;; fromIntegral — coerce integer to Float
-(define (hk-to-float x) (exact->inexact x))
-
-;; truncate / round toward zero
-(define hk-to-integer truncate)
-(define hk-from-integer (fn (n) n))
-
-;; Haskell div: floor division (rounds toward -inf)
 (define
-  (hk-div a b)
-  (let
-    ((q (quotient a b)) (r (remainder a b)))
+  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
-      (and
-        (not (= r 0))
-        (or
-          (and (< a 0) (> b 0))
-          (and (> a 0) (< b 0))))
-      (- q 1)
-      q)))
-
-;; Haskell mod: result has same sign as divisor
-(define hk-mod modulo)
-
-;; Haskell rem: result has same sign as dividend
-(define hk-rem remainder)
-
-;; Haskell quot: truncation division
-(define hk-quot quotient)
-
-;; divMod and quotRem return pairs (lists)
-(define (hk-div-mod a b) (list (hk-div a b) (hk-mod a b)))
-(define (hk-quot-rem a b) (list (hk-quot a b) (hk-rem a b)))
-
-(define (hk-abs x) (if (< x 0) (- 0 x) x))
-(define
-  (hk-signum x)
-  (cond
-    ((> x 0) 1)
-    ((< x 0) -1)
-    (else 0)))
-
-(define hk-gcd gcd)
-(define hk-lcm lcm)
-
-(define (hk-even? n) (= (modulo n 2) 0))
-(define (hk-odd? n) (not (= (modulo n 2) 0)))
-
-;; ===========================================================================
-;; 2. Rational numbers (dict implementation — no built-in rational in sx_server)
-;; ===========================================================================
+      (has-key? hk-constructors name)
+      (get (get hk-constructors name) "arity")
+      nil)))
 
 (define
-  (hk-make-rational n d)
-  (let
-    ((g (gcd (hk-abs n) (hk-abs d))))
-    (if (< d 0) {:num (quotient (- 0 n) g) :den (quotient (- 0 d) g) :_rational true} {:num (quotient n g) :den (quotient d g) :_rational true})))
+  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-rational? x)
-  (and (dict? x) (not (= (get x :_rational) nil))))
-(define (hk-numerator r) (get r :num))
-(define (hk-denominator r) (get r :den))
-
-(define
-  (hk-rational-add r1 r2)
-  (hk-make-rational
-    (+
-      (* (hk-numerator r1) (hk-denominator r2))
-      (* (hk-numerator r2) (hk-denominator r1)))
-    (* (hk-denominator r1) (hk-denominator r2))))
-
-(define
-  (hk-rational-sub r1 r2)
-  (hk-make-rational
-    (-
-      (* (hk-numerator r1) (hk-denominator r2))
-      (* (hk-numerator r2) (hk-denominator r1)))
-    (* (hk-denominator r1) (hk-denominator r2))))
-
-(define
-  (hk-rational-mul r1 r2)
-  (hk-make-rational
-    (* (hk-numerator r1) (hk-numerator r2))
-    (* (hk-denominator r1) (hk-denominator r2))))
-
-(define
-  (hk-rational-div r1 r2)
-  (hk-make-rational
-    (* (hk-numerator r1) (hk-denominator r2))
-    (* (hk-denominator r1) (hk-numerator r2))))
-
-(define
-  (hk-rational-to-float r)
-  (exact->inexact (/ (hk-numerator r) (hk-denominator r))))
-
-(define (hk-show-rational r) (str (hk-numerator r) "%" (hk-denominator r)))
-
-;; ===========================================================================
-;; 3. Lazy evaluation — promises (created via SX delay)
-;; ===========================================================================
-
-(define
-  (hk-force p)
-  (if
-    (and (dict? p) (not (= (get p :_promise) nil)))
-    (if (get p :forced) (get p :value) ((get p :thunk)))
-    p))
-
-;; ===========================================================================
-;; 4. Char utilities (Data.Char)
-;; ===========================================================================
-
-(define hk-ord char->integer)
-(define hk-chr integer->char)
-
-;; Inline ASCII predicates — char-alphabetic?/char-numeric? unreliable in sx_server
-(define
-  (hk-is-alpha? c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (hk-is-digit? c)
-  (let ((n (char->integer c))) (and (>= n 48) (<= n 57))))
-
-(define
-  (hk-is-alnum? c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 48) (<= n 57))
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (hk-is-upper? c)
-  (let ((n (char->integer c))) (and (>= n 65) (<= n 90))))
-
-(define
-  (hk-is-lower? c)
-  (let ((n (char->integer c))) (and (>= n 97) (<= n 122))))
-
-(define
-  (hk-is-space? c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (= n 32)
-      (= n 9)
-      (= n 10)
-      (= n 13)
-      (= n 12)
-      (= n 11))))
-
-(define hk-to-upper char-upcase)
-(define hk-to-lower char-downcase)
-
-;; digitToInt: '0'-'9' → 0-9, 'a'-'f'/'A'-'F' → 10-15
-(define
-  (hk-digit-to-int c)
-  (let
-    ((n (char->integer c)))
+  hk-register-program!
+  (fn
+    (ast)
     (cond
-      ((and (>= n 48) (<= n 57)) (- n 48))
-      ((and (>= n 65) (<= n 70)) (- n 55))
-      ((and (>= n 97) (<= n 102)) (- n 87))
-      (else (error (str "hk-digit-to-int: not a hex digit: " c))))))
+      ((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))))
 
-;; intToDigit: 0-15 → char
+;; Convenience: source → AST → desugar → register.
 (define
-  (hk-int-to-digit n)
-  (cond
-    ((and (>= n 0) (<= n 9))
-      (integer->char (+ n 48)))
-    ((and (>= n 10) (<= n 15))
-      (integer->char (+ n 87)))
-    (else (error (str "hk-int-to-digit: out of range: " n)))))
+  hk-load-source!
+  (fn (src) (hk-register-program! (hk-core src))))
 
-;; ===========================================================================
-;; 5. Data.Set wrappers
-;; ===========================================================================
-
-(define (hk-set-empty) (make-set))
-(define hk-set? set?)
-(define hk-set-member? set-member?)
-
-(define (hk-set-insert x s) (begin (set-add! s x) s))
-
-(define (hk-set-delete x s) (begin (set-remove! s x) s))
-
-(define hk-set-union set-union)
-(define hk-set-intersection set-intersection)
-(define hk-set-difference set-difference)
-(define hk-set-from-list list->set)
-(define hk-set-to-list set->list)
-(define (hk-set-null? s) (= (len (set->list s)) 0))
-(define (hk-set-size s) (len (set->list s)))
-
-(define (hk-set-singleton x) (let ((s (make-set))) (set-add! s x) s))
-
-;; ===========================================================================
-;; 6. Data.List utilities
-;; ===========================================================================
-
-(define hk-head first)
-(define hk-tail rest)
-(define (hk-null? lst) (= (len lst) 0))
-(define hk-length len)
-
-(define
-  (hk-take n lst)
-  (if
-    (or (= n 0) (= (len lst) 0))
-    (list)
-    (cons (first lst) (hk-take (- n 1) (rest lst)))))
-
-(define
-  (hk-drop n lst)
-  (if
-    (or (= n 0) (= (len lst) 0))
-    lst
-    (hk-drop (- n 1) (rest lst))))
-
-(define
-  (hk-take-while pred lst)
-  (if
-    (or (= (len lst) 0) (not (pred (first lst))))
-    (list)
-    (cons (first lst) (hk-take-while pred (rest lst)))))
-
-(define
-  (hk-drop-while pred lst)
-  (if
-    (or (= (len lst) 0) (not (pred (first lst))))
-    lst
-    (hk-drop-while pred (rest lst))))
-
-(define
-  (hk-zip a b)
-  (if
-    (or (= (len a) 0) (= (len b) 0))
-    (list)
-    (cons (list (first a) (first b)) (hk-zip (rest a) (rest b)))))
-
-(define
-  (hk-zip-with f a b)
-  (if
-    (or (= (len a) 0) (= (len b) 0))
-    (list)
-    (cons (f (first a) (first b)) (hk-zip-with f (rest a) (rest b)))))
-
-(define
-  (hk-unzip pairs)
-  (list
-    (map (fn (p) (first p)) pairs)
-    (map (fn (p) (nth p 1)) pairs)))
-
-(define
-  (hk-elem x lst)
-  (cond
-    ((= (len lst) 0) false)
-    ((= x (first lst)) true)
-    (else (hk-elem x (rest lst)))))
-
-(define (hk-not-elem x lst) (not (hk-elem x lst)))
-
-(define
-  (hk-nub lst)
-  (letrec
-    ((go (fn (seen acc items) (if (= (len items) 0) (reverse acc) (let ((h (first items)) (t (rest items))) (if (hk-elem h seen) (go seen acc t) (go (cons h seen) (cons h acc) t)))))))
-    (go (list) (list) lst)))
-
-(define (hk-sum lst) (reduce + 0 lst))
-(define (hk-product lst) (reduce * 1 lst))
-
-(define
-  (hk-maximum lst)
-  (reduce (fn (a b) (if (> a b) a b)) (first lst) (rest lst)))
-
-(define
-  (hk-minimum lst)
-  (reduce (fn (a b) (if (< a b) a b)) (first lst) (rest lst)))
-
-(define (hk-concat lsts) (reduce append (list) lsts))
-
-(define (hk-concat-map f lst) (hk-concat (map f lst)))
-
-(define hk-sort sort)
-
-(define
-  (hk-span pred lst)
-  (list (hk-take-while pred lst) (hk-drop-while pred lst)))
-
-(define (hk-break pred lst) (hk-span (fn (x) (not (pred x))) lst))
-
-(define
-  (hk-foldl f acc lst)
-  (if
-    (= (len lst) 0)
-    acc
-    (hk-foldl f (f acc (first lst)) (rest lst))))
-
-(define
-  (hk-foldr f z lst)
-  (if
-    (= (len lst) 0)
-    z
-    (f (first lst) (hk-foldr f z (rest lst)))))
-
-(define
-  (hk-scanl f acc lst)
-  (if
-    (= (len lst) 0)
-    (list acc)
-    (cons acc (hk-scanl f (f acc (first lst)) (rest lst)))))
-
-(define
-  (hk-replicate n x)
-  (if (= n 0) (list) (cons x (hk-replicate (- n 1) x))))
-
-(define
-  (hk-intersperse sep lst)
-  (if
-    (or (= (len lst) 0) (= (len lst) 1))
-    lst
-    (cons (first lst) (cons sep (hk-intersperse sep (rest lst))))))
-
-;; ===========================================================================
-;; 7. Maybe / Either ADTs
-;; ===========================================================================
-
-(define hk-nothing {:_maybe true :_tag "nothing"})
-(define (hk-just x) {:_maybe true :value x :_tag "just"})
-(define (hk-is-nothing? m) (= (get m :_tag) "nothing"))
-(define (hk-is-just? m) (= (get m :_tag) "just"))
-(define (hk-from-just m) (get m :value))
-(define (hk-from-maybe def m) (if (hk-is-nothing? m) def (hk-from-just m)))
-(define
-  (hk-maybe def f m)
-  (if (hk-is-nothing? m) def (f (hk-from-just m))))
-
-(define (hk-left x) {:value x :_either true :_tag "left"})
-(define (hk-right x) {:value x :_either true :_tag "right"})
-(define (hk-is-left? e) (= (get e :_tag) "left"))
-(define (hk-is-right? e) (= (get e :_tag) "right"))
-(define (hk-from-left e) (get e :value))
-(define (hk-from-right e) (get e :value))
-(define
-  (hk-either f g e)
-  (if (hk-is-left? e) (f (hk-from-left e)) (g (hk-from-right e))))
-
-;; ===========================================================================
-;; 8. Tuples (lists — list->vector unreliable in sx_server)
-;; ===========================================================================
-
-(define (hk-pair a b) (list a b))
-(define hk-fst first)
-(define (hk-snd t) (nth t 1))
-
-(define (hk-triple a b c) (list a b c))
-(define hk-fst3 first)
-(define (hk-snd3 t) (nth t 1))
-(define (hk-thd3 t) (nth t 2))
-
-(define (hk-curry f) (fn (a) (fn (b) (f a b))))
-(define (hk-uncurry f) (fn (p) (f (hk-fst p) (hk-snd p))))
-
-;; ===========================================================================
-;; 9. String helpers (Data.List / Data.Char for strings)
-;; ===========================================================================
-
-;; words: split on whitespace
-(define
-  (hk-words s)
-  (letrec
-    ((slen (len s))
-      (skip-ws
-        (fn
-          (i)
-          (if
-            (>= i slen)
-            (list)
-            (let
-              ((c (substring s i (+ i 1))))
-              (if
-                (or (= c " ") (= c "\t") (= c "\n"))
-                (skip-ws (+ i 1))
-                (collect-word i (+ i 1)))))))
-      (collect-word
-        (fn
-          (start i)
-          (if
-            (>= i slen)
-            (list (substring s start i))
-            (let
-              ((c (substring s i (+ i 1))))
-              (if
-                (or (= c " ") (= c "\t") (= c "\n"))
-                (cons (substring s start i) (skip-ws (+ i 1)))
-                (collect-word start (+ i 1))))))))
-    (skip-ws 0)))
-
-;; unwords: join with spaces
-(define
-  (hk-unwords lst)
-  (if
-    (= (len lst) 0)
-    ""
-    (reduce (fn (a b) (str a " " b)) (first lst) (rest lst))))
-
-;; lines: split on newline
-(define
-  (hk-lines s)
-  (letrec
-    ((slen (len s))
-      (go
-        (fn
-          (start i acc)
-          (if
-            (>= i slen)
-            (reverse (cons (substring s start i) acc))
-            (if
-              (= (substring s i (+ i 1)) "\n")
-              (go
-                (+ i 1)
-                (+ i 1)
-                (cons (substring s start i) acc))
-              (go start (+ i 1) acc))))))
-    (if (= slen 0) (list) (go 0 0 (list)))))
-
-;; unlines: join, each with trailing newline
-(define (hk-unlines lst) (reduce (fn (a b) (str a b "\n")) "" lst))
-
-;; isPrefixOf
-(define
-  (hk-is-prefix-of pre s)
-  (and (<= (len pre) (len s)) (= pre (substring s 0 (len pre)))))
-
-;; isSuffixOf
-(define
-  (hk-is-suffix-of suf s)
-  (let
-    ((sl (len suf)) (tl (len s)))
-    (and (<= sl tl) (= suf (substring s (- tl sl) tl)))))
-
-;; isInfixOf — linear scan
-(define
-  (hk-is-infix-of pat s)
-  (let
-    ((plen (len pat)) (slen (len s)))
-    (letrec
-      ((go (fn (i) (if (> (+ i plen) slen) false (if (= pat (substring s i (+ i plen))) true (go (+ i 1)))))))
-      (if (= plen 0) true (go 0)))))
-
-;; ===========================================================================
-;; 10. Show helper
-;; ===========================================================================
-
-(define
-  (hk-show x)
-  (cond
-    ((= x nil) "Nothing")
-    ((= x true) "True")
-    ((= x false) "False")
-    ((hk-rational? x) (hk-show-rational x))
-    ((integer? x) (str x))
-    ((float? x) (str x))
-    ((= (type-of x) "string") (str "\"" x "\""))
-    ((= (type-of x) "char") (str "'" (str x) "'"))
-    ((list? x)
-      (str
-        "["
-        (if
-          (= (len x) 0)
-          ""
-          (reduce
-            (fn (a b) (str a "," (hk-show b)))
-            (hk-show (first x))
-            (rest x)))
-        "]"))
-    (else (str x))))
+;; ── 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,25 @@
+{
+  "date": "2026-05-06",
+  "total_pass": 156,
+  "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},
+    "collatz": {"pass": 11, "fail": 0},
+    "palindrome": {"pass": 8, "fail": 0},
+    "maybe": {"pass": 12, "fail": 0},
+    "fizzbuzz": {"pass": 12, "fail": 0},
+    "anagram": {"pass": 9, "fail": 0},
+    "roman": {"pass": 14, "fail": 0},
+    "binary": {"pass": 12, "fail": 0},
+    "either": {"pass": 12, "fail": 0},
+    "primes": {"pass": 12, "fail": 0},
+    "zipwith": {"pass": 9, "fail": 0},
+    "matrix": {"pass": 8, "fail": 0},
+    "wordcount": {"pass": 7, "fail": 0},
+    "powers": {"pass": 14, "fail": 0}
+  }
+}

lib/haskell/scoreboard.md

@@ -0,0 +1,25 @@
+# Haskell-on-SX Scoreboard
+
+Updated 2026-05-06 · Phase 6 (prelude extras + 18 programs)
+
+| Program | Tests | Status |
+|---------|-------|--------|
+| fib.hs | 2/2 | ✓ |
+| sieve.hs | 2/2 | ✓ |
+| quicksort.hs | 5/5 | ✓ |
+| nqueens.hs | 2/2 | ✓ |
+| calculator.hs | 5/5 | ✓ |
+| collatz.hs | 11/11 | ✓ |
+| palindrome.hs | 8/8 | ✓ |
+| maybe.hs | 12/12 | ✓ |
+| fizzbuzz.hs | 12/12 | ✓ |
+| anagram.hs | 9/9 | ✓ |
+| roman.hs | 14/14 | ✓ |
+| binary.hs | 12/12 | ✓ |
+| either.hs | 12/12 | ✓ |
+| primes.hs | 12/12 | ✓ |
+| zipwith.hs | 9/9 | ✓ |
+| matrix.hs | 8/8 | ✓ |
+| wordcount.hs | 7/7 | ✓ |
+| powers.hs | 14/14 | ✓ |
+| **Total** | **156/156** | **18/18 programs** |

lib/haskell/test.sh

@@ -14,7 +14,7 @@ cd "$(git rev-parse --show-toplevel)"
 SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
 if [ ! -x "$SX_SERVER" ]; then
   # Fall back to the main-repo build if we're in a worktree.
-  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
+  MAIN_ROOT=$(git worktree list | awk 'NR==1{print $1}')
   if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
     SX_SERVER="$MAIN_ROOT/$SX_SERVER"
   else
@@ -42,25 +42,35 @@ FAILED_FILES=()
 
 for FILE in "${FILES[@]}"; do
   [ -f "$FILE" ] || { echo "skip $FILE (not found)"; continue; }
+  # Load infer.sx only for infer/typecheck test files (it adds ~6s overhead).
+  INFER_LOAD=""
+  case "$FILE" in *infer*|*typecheck*) INFER_LOAD='(load "lib/haskell/infer.sx")' ;; esac
   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")
+$INFER_LOAD
+(load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
 (eval "(list hk-test-pass hk-test-fail)")
 EPOCHS
 
-  OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
+  OUTPUT=$(timeout 360 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
   rm -f "$TMPFILE"
 
   # Output format: either "(ok 3 (P F))" on one line (short result) or
   # "(ok-len 3 N)\n(P F)" where the value appears on the following 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 \
+    LINE=$(echo "$OUTPUT" | { grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' || true; } | tail -1 \
             | sed -E 's/^\(ok 3 //; s/\)$//')
   fi
   if [ -z "$LINE" ]; then
@@ -82,13 +92,20 @@ 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")
+$INFER_LOAD
+(load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
 (eval "(map (fn (f) (get f \"name\")) hk-test-fails)")
 EPOCHS
-    FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok 3 ' || true)
+    FAILS=$(timeout 360 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok 3 ' || true)
     rm -f "$TMPFILE2"
     echo "    $FAILS"
   elif [ "$VERBOSE" = "1" ]; then

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/class.sx

@@ -0,0 +1,60 @@
+;; class.sx — tests for class/instance parsing and evaluation.
+
+(define prog-class1 (hk-core "class MyEq a where\n  myEq :: a -> a -> Bool"))
+(define prog-inst1 (hk-core "instance MyEq Int where\n  myEq x y = x == y"))
+
+;; ─── class-decl AST ───────────────────────────────────────────────────────────
+(define cd1 (first (nth prog-class1 1)))
+(hk-test "class-decl tag" (first cd1) "class-decl")
+(hk-test "class-decl name" (nth cd1 1) "MyEq")
+(hk-test "class-decl tvar" (nth cd1 2) "a")
+(hk-test "class-decl methods" (len (nth cd1 3)) 1)
+
+;; ─── instance-decl AST ────────────────────────────────────────────────────────
+(define id1 (first (nth prog-inst1 1)))
+(hk-test "instance-decl tag" (first id1) "instance-decl")
+(hk-test "instance-decl class" (nth id1 1) "MyEq")
+(hk-test "instance-decl type tag" (first (nth id1 2)) "t-con")
+(hk-test "instance-decl type name" (nth (nth id1 2) 1) "Int")
+(hk-test "instance-decl method count" (len (nth id1 3)) 1)
+
+;; ─── eval: instance dict is built ────────────────────────────────────────────
+(define
+  prog-full
+  (hk-core
+    "class MyEq a where\n  myEq :: a -> a -> Bool\ninstance MyEq Int where\n  myEq x y = x == y"))
+(define env-full (hk-eval-program prog-full))
+
+(hk-test "instance dict in env" (has-key? env-full "dictMyEq_Int") true)
+
+(hk-test
+  "instance dict has method"
+  (has-key? (get env-full "dictMyEq_Int") "myEq")
+  true)
+
+(hk-test
+  "dispatch: single-arg method works"
+  (hk-deep-force
+    (hk-run
+      "class Describable a where\n  describe :: a -> String\ninstance Describable Int where\n  describe x = \"an integer\"\nmain = describe 42"))
+  "an integer")
+
+(hk-test
+  "dispatch: second instance (Bool)"
+  (hk-deep-force
+    (hk-run
+      "class Describable a where\n  describe :: a -> String\ninstance Describable Bool where\n  describe x = \"a boolean\"\ninstance Describable Int where\n  describe x = \"an integer\"\nmain = describe True"))
+  "a boolean")
+
+(hk-test
+  "dispatch: error on unknown instance"
+  (guard
+    (e (true (>= (index-of e "No instance") 0)))
+    (begin
+      (hk-deep-force
+        (hk-run
+          "class Describable a where\n  describe :: a -> String\nmain = describe 42"))
+      false))
+  true)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/deriving.sx

@@ -0,0 +1,84 @@
+;; deriving.sx — tests for deriving (Eq, Show) on ADTs.
+
+;; ─── Show ────────────────────────────────────────────────────────────────────
+
+(hk-test
+  "deriving Show: nullary constructor"
+  (hk-deep-force
+    (hk-run "data Color = Red | Green | Blue deriving (Show)\nmain = show Red"))
+  "Red")
+
+(hk-test
+  "deriving Show: constructor with arg"
+  (hk-deep-force
+    (hk-run "data Wrapper = Wrap Int deriving (Show)\nmain = show (Wrap 42)"))
+  "(Wrap 42)")
+
+(hk-test
+  "deriving Show: nested constructors"
+  (hk-deep-force
+    (hk-run
+      "data Tree = Leaf | Node Int Tree Tree deriving (Show)\nmain = show (Node 1 Leaf Leaf)"))
+  "(Node 1 Leaf Leaf)")
+
+(hk-test
+  "deriving Show: second constructor"
+  (hk-deep-force
+    (hk-run
+      "data Color = Red | Green | Blue deriving (Show)\nmain = show Green"))
+  "Green")
+
+;; ─── Eq ──────────────────────────────────────────────────────────────────────
+
+(hk-test
+  "deriving Eq: same constructor"
+  (hk-deep-force
+    (hk-run
+      "data Color = Red | Green | Blue deriving (Eq)\nmain = show (Red == Red)"))
+  "True")
+
+(hk-test
+  "deriving Eq: different constructors"
+  (hk-deep-force
+    (hk-run
+      "data Color = Red | Green | Blue deriving (Eq)\nmain = show (Red == Blue)"))
+  "False")
+
+(hk-test
+  "deriving Eq: /= same"
+  (hk-deep-force
+    (hk-run
+      "data Color = Red | Green | Blue deriving (Eq)\nmain = show (Red /= Red)"))
+  "False")
+
+(hk-test
+  "deriving Eq: /= different"
+  (hk-deep-force
+    (hk-run
+      "data Color = Red | Green | Blue deriving (Eq)\nmain = show (Red /= Blue)"))
+  "True")
+
+;; ─── combined Eq + Show ───────────────────────────────────────────────────────
+
+(hk-test
+  "deriving Eq Show: combined in parens"
+  (hk-deep-force
+    (hk-run
+      "data Shape = Circle Int | Square Int deriving (Eq, Show)\nmain = show (Circle 5)"))
+  "(Circle 5)")
+
+(hk-test
+  "deriving Eq Show: eq on constructor with arg"
+  (hk-deep-force
+    (hk-run
+      "data Shape = Circle Int | Square Int deriving (Eq, Show)\nmain = show (Circle 3 == Circle 3)"))
+  "True")
+
+(hk-test
+  "deriving Eq Show: different constructors with args"
+  (hk-deep-force
+    (hk-run
+      "data Shape = Circle Int | Square Int deriving (Eq, Show)\nmain = show (Circle 3 == Square 3)"))
+  "False")
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

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/infer.sx

@@ -0,0 +1,181 @@
+;; infer.sx tests — Algorithm W: literals, vars, lambdas, application, let,
+;; if, operators, tuples, lists, let-polymorphism.
+
+(define hk-t (fn (src expected)
+  (hk-test (str "infer: " src) (hk-infer-type src) expected)))
+
+;; ─── Literals ────────────────────────────────────────────────────────────────
+(hk-t "1"          "Int")
+(hk-t "3.14"       "Float")
+(hk-t "\"hello\""  "String")
+(hk-t "'x'"        "Char")
+(hk-t "True"       "Bool")
+(hk-t "False"      "Bool")
+
+;; ─── Arithmetic and boolean operators ────────────────────────────────────────
+(hk-t "1 + 2"      "Int")
+(hk-t "3 * 4"      "Int")
+(hk-t "10 - 3"     "Int")
+(hk-t "True && False" "Bool")
+(hk-t "True || False" "Bool")
+(hk-t "not True"   "Bool")
+(hk-t "1 == 1"     "Bool")
+(hk-t "1 < 2"      "Bool")
+
+;; ─── Lambda ───────────────────────────────────────────────────────────────────
+;; \x -> x   (identity)  should get t1 -> t1
+(hk-test "infer: identity lambda" (hk-infer-type "\\x -> x") "t1 -> t1")
+
+;; \x -> x + 1 : Int -> Int
+(hk-test "infer: lambda add" (hk-infer-type "\\x -> x + 1") "Int -> Int")
+
+;; \x -> not x : Bool -> Bool
+(hk-test "infer: lambda not" (hk-infer-type "\\x -> not x") "Bool -> Bool")
+
+;; \x y -> x + y : Int -> Int -> Int
+(hk-test "infer: two-arg lambda" (hk-infer-type "\\x -> \\y -> x + y") "Int -> Int -> Int")
+
+;; ─── Application ─────────────────────────────────────────────────────────────
+(hk-t "not True"    "Bool")
+(hk-t "negate 1"    "Int")
+
+;; ─── If-then-else ─────────────────────────────────────────────────────────────
+(hk-t "if True then 1 else 2"     "Int")
+(hk-t "if 1 == 2 then True else False" "Bool")
+
+;; ─── Let bindings ─────────────────────────────────────────────────────────────
+;; let x = 1 in x + 2
+(hk-t "let x = 1 in x + 2" "Int")
+
+;; let f x = x + 1 in f 5
+(hk-t "let f x = x + 1 in f 5" "Int")
+
+;; let-polymorphism: let id x = x in id 1
+(hk-t "let id x = x in id 1" "Int")
+
+;; ─── Tuples ───────────────────────────────────────────────────────────────────
+(hk-t "(1, True)"       "(Int, Bool)")
+(hk-t "(1, 2, 3)"       "(Int, Int, Int)")
+
+;; ─── Lists ───────────────────────────────────────────────────────────────────
+(hk-t "[1, 2, 3]"    "[Int]")
+(hk-t "[True, False]" "[Bool]")
+
+;; ─── Polymorphic list functions ───────────────────────────────────────────────
+(hk-t "length [1, 2, 3]"   "Int")
+(hk-t "null []"             "Bool")
+(hk-t "head [1, 2, 3]"     "Int")
+
+;; ─── hk-expr->brief ──────────────────────────────────────────────────────────
+(hk-test "brief var"    (hk-expr->brief (list "var" "x"))           "x")
+(hk-test "brief con"    (hk-expr->brief (list "con" "Just"))        "Just")
+(hk-test "brief int"    (hk-expr->brief (list "int" 42))            "42")
+(hk-test "brief app"    (hk-expr->brief (list "app" (list "var" "f") (list "var" "x"))) "(f x)")
+(hk-test "brief op"     (hk-expr->brief (list "op" "+" (list "int" 1) (list "int" 2))) "(1 + 2)")
+(hk-test "brief lambda" (hk-expr->brief (list "lambda" (list) (list "var" "x"))) "(\\ ...)")
+(hk-test "brief loc"    (hk-expr->brief (list "loc" 3 7 (list "var" "x"))) "x")
+
+;; ─── Type error messages ─────────────────────────────────────────────────────
+;; Helper: catch the error and check it contains a substring.
+(define hk-str-has? (fn (s sub) (>= (index-of s sub) 0)))
+
+(define hk-te
+  (fn (label src sub)
+    (hk-test label
+      (guard (e (#t (hk-str-has? e sub)))
+        (begin (hk-infer-type src) false))
+      true)))
+
+;; Unbound variable error includes the variable name.
+(hk-te "error unbound name" "foo + 1"    "foo")
+(hk-te "error unbound unk"  "unknown"    "unknown")
+
+;; Unification error mentions the conflicting types.
+(hk-te "error unify int-bool-1" "1 + True"  "Int")
+(hk-te "error unify int-bool-2" "1 + True"  "Bool")
+
+;; ─── Loc node: passes through to inner (position decorates outer context) ────
+(define hk-loc-err-msg
+  (fn ()
+    (guard (e (#t e))
+      (begin
+        (hk-reset-fresh)
+        (hk-w (hk-type-env0) (list "loc" 5 10 (list "var" "mystery")))
+        "no-error"))))
+(hk-test "loc passes through to var error"
+  (hk-str-has? (hk-loc-err-msg) "mystery")
+  true)
+
+;; ─── hk-infer-decl ───────────────────────────────────────────────────────────
+;; Returns ("ok" name type) | ("err" msg)
+(define hk-env0-t (hk-type-env0))
+
+(define prog1 (hk-core "f x = x + 1"))
+(define decl1 (first (nth prog1 1)))
+(define res1 (hk-infer-decl hk-env0-t decl1))
+(hk-test "decl result tag"  (first res1)    "ok")
+(hk-test "decl result name" (nth res1 1)    "f")
+(hk-test "decl result type" (nth res1 2)    "Int -> Int")
+
+;; Error decl: result is ("err" "in 'g': ...")
+(define prog2 (hk-core "g x = x + True"))
+(define decl2 (first (nth prog2 1)))
+(define res2 (hk-infer-decl hk-env0-t decl2))
+(hk-test "decl error tag"    (first res2)                  "err")
+(hk-test "decl error has g"  (hk-str-has? (nth res2 1) "g")   true)
+(hk-test "decl error has msg" (hk-str-has? (nth res2 1) "unify") true)
+
+;; ─── hk-infer-prog ───────────────────────────────────────────────────────────
+;; Returns list of ("ok"/"err" ...) tagged results.
+(define prog3 (hk-core "double x = x + x\ntwice f x = f (f x)"))
+(define results3 (hk-infer-prog prog3 hk-env0-t))
+;; results3 = (("ok" "double" "Int -> Int") ("ok" "twice" "..."))
+(hk-test "infer-prog count"  (len results3)               2)
+(hk-test "infer-prog double" (nth (nth results3 0) 2)     "Int -> Int")
+(hk-test "infer-prog twice"  (nth (nth results3 1) 2)     "(t3 -> t3) -> t3 -> t3")
+
+(hk-t "let id x = x in id 1" "Int")
+
+(hk-t "let id x = x in id True" "Bool")
+
+(hk-t "let id x = x in (id 1, id True)" "(Int, Bool)")
+
+(hk-t "let const x y = x in (const 1 True, const True 1)" "(Int, Bool)")
+
+(hk-t "let f x = x in let g y = f y in (g 1, g True)" "(Int, Bool)")
+
+(hk-t "let twice f x = f (f x) in twice (\x -> x + 1) 5" "Int")
+
+(hk-t "not (not True)" "Bool")
+
+(hk-t "negate (negate 1)" "Int")
+
+(hk-t "\\x -> \\y -> x && y" "Bool -> Bool -> Bool")
+
+(hk-t "\\x -> x == 1" "Int -> Bool")
+
+(hk-t "let x = True in if x then 1 else 0" "Int")
+
+(hk-t "let f x = not x in f True" "Bool")
+
+(hk-t "let f x = (x, x + 1) in f 5" "(Int, Int)")
+
+(hk-t "let x = 1 in let y = 2 in x + y" "Int")
+
+(hk-t "let f x = x + 1 in f (f 5)" "Int")
+
+(hk-t "if 1 < 2 then True else False" "Bool")
+
+(hk-t "if True then 1 + 1 else 2 + 2" "Int")
+
+(hk-t "(1 + 2, True && False)" "(Int, Bool)")
+
+(hk-t "(1 == 1, 2 < 3)" "(Bool, Bool)")
+
+(hk-t "length [True, False]" "Int")
+
+(hk-t "null [1]" "Bool")
+
+(hk-t "[True]" "[Bool]")
+
+{: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/io-input.sx

@@ -0,0 +1,85 @@
+;; io-input.sx — tests for getLine, getContents, readFile, writeFile.
+
+(hk-test
+  "getLine reads single line"
+  (hk-run-io-with-input "main = getLine >>= putStrLn" (list "hello"))
+  (list "hello"))
+
+(hk-test
+  "getLine reads two lines"
+  (hk-run-io-with-input
+    "main = do { line1 <- getLine; line2 <- getLine; putStrLn line1; putStrLn line2 }"
+    (list "first" "second"))
+  (list "first" "second"))
+
+(hk-test
+  "getLine bind in layout do"
+  (hk-run-io-with-input
+    "main = do\n  line <- getLine\n  putStrLn line"
+    (list "world"))
+  (list "world"))
+
+(hk-test
+  "getLine echo with prefix"
+  (hk-run-io-with-input
+    "main = do\n  line <- getLine\n  putStrLn (\"Got: \" ++ line)"
+    (list "test"))
+  (list "Got: test"))
+
+(hk-test
+  "getContents reads all lines joined"
+  (hk-run-io-with-input
+    "main = getContents >>= putStr"
+    (list "line1" "line2" "line3"))
+  (list "line1\nline2\nline3"))
+
+(hk-test
+  "getContents empty stdin"
+  (hk-run-io-with-input "main = getContents >>= putStr" (list))
+  (list ""))
+
+(hk-test
+  "readFile reads pre-loaded content"
+  (begin
+    (set! hk-vfs (dict))
+    (dict-set! hk-vfs "hello.txt" "Hello, World!")
+    (hk-run-io "main = readFile \"hello.txt\" >>= putStrLn"))
+  (list "Hello, World!"))
+
+(hk-test
+  "writeFile creates file"
+  (begin
+    (set! hk-vfs (dict))
+    (hk-run-io "main = writeFile \"out.txt\" \"written content\"")
+    (get hk-vfs "out.txt"))
+  "written content")
+
+(hk-test
+  "writeFile then readFile roundtrip"
+  (begin
+    (set! hk-vfs (dict))
+    (hk-run-io
+      "main = do { writeFile \"f.txt\" \"round trip\"; readFile \"f.txt\" >>= putStrLn }"))
+  (list "round trip"))
+
+(hk-test
+  "readFile error on missing file"
+  (guard
+    (e (true (>= (index-of e "file not found") 0)))
+    (begin
+      (set! hk-vfs (dict))
+      (hk-run-io "main = readFile \"no.txt\" >>= putStrLn")
+      false))
+  true)
+
+(hk-test
+  "getLine then writeFile combined"
+  (begin
+    (set! hk-vfs (dict))
+    (hk-run-io-with-input
+      "main = do\n  line <- getLine\n  writeFile \"cap.txt\" line"
+      (list "captured"))
+    (get hk-vfs "cap.txt"))
+  "captured")
+
+{: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/prelude-extra.sx

@@ -0,0 +1,234 @@
+;; prelude-extra.sx — tests for Phase 6 prelude additions:
+;; ord/isAlpha/isDigit/isSpace/isUpper/isLower/isAlphaNum/digitToInt
+;; words/lines/unwords/unlines/sort/nub/splitAt/span/break
+;; partition/intercalate/intersperse/isPrefixOf/isSuffixOf/isInfixOf
+
+;; ── ord ──────────────────────────────────────────────────────
+(hk-test "ord 'A'" (hk-eval-expr-source "ord 'A'") 65)
+(hk-test "ord 'a'" (hk-eval-expr-source "ord 'a'") 97)
+(hk-test "ord '0'" (hk-eval-expr-source "ord '0'") 48)
+
+;; ── isAlpha / isDigit / isSpace / isUpper / isLower ──────────
+(hk-test
+  "isAlpha 'a' True"
+  (hk-eval-expr-source "isAlpha 'a'")
+  (list "True"))
+(hk-test
+  "isAlpha 'Z' True"
+  (hk-eval-expr-source "isAlpha 'Z'")
+  (list "True"))
+(hk-test
+  "isAlpha '3' False"
+  (hk-eval-expr-source "isAlpha '3'")
+  (list "False"))
+(hk-test
+  "isDigit '5' True"
+  (hk-eval-expr-source "isDigit '5'")
+  (list "True"))
+(hk-test
+  "isDigit 'a' False"
+  (hk-eval-expr-source "isDigit 'a'")
+  (list "False"))
+(hk-test
+  "isSpace ' ' True"
+  (hk-eval-expr-source "isSpace ' '")
+  (list "True"))
+(hk-test
+  "isSpace 'x' False"
+  (hk-eval-expr-source "isSpace 'x'")
+  (list "False"))
+(hk-test
+  "isUpper 'A' True"
+  (hk-eval-expr-source "isUpper 'A'")
+  (list "True"))
+(hk-test
+  "isUpper 'a' False"
+  (hk-eval-expr-source "isUpper 'a'")
+  (list "False"))
+(hk-test
+  "isLower 'z' True"
+  (hk-eval-expr-source "isLower 'z'")
+  (list "True"))
+(hk-test
+  "isLower 'Z' False"
+  (hk-eval-expr-source "isLower 'Z'")
+  (list "False"))
+(hk-test
+  "isAlphaNum '3' True"
+  (hk-eval-expr-source "isAlphaNum '3'")
+  (list "True"))
+(hk-test
+  "isAlphaNum 'b' True"
+  (hk-eval-expr-source "isAlphaNum 'b'")
+  (list "True"))
+(hk-test
+  "isAlphaNum '!' False"
+  (hk-eval-expr-source "isAlphaNum '!'")
+  (list "False"))
+
+;; ── digitToInt ───────────────────────────────────────────────
+(hk-test "digitToInt '0'" (hk-eval-expr-source "digitToInt '0'") 0)
+(hk-test "digitToInt '7'" (hk-eval-expr-source "digitToInt '7'") 7)
+(hk-test "digitToInt '9'" (hk-eval-expr-source "digitToInt '9'") 9)
+
+;; ── words ────────────────────────────────────────────────────
+(hk-test
+  "words single"
+  (hk-deep-force (hk-eval-expr-source "words \"hello\""))
+  (list ":" "hello" (list "[]")))
+
+(hk-test
+  "words two"
+  (hk-deep-force (hk-eval-expr-source "words \"hello world\""))
+  (list ":" "hello" (list ":" "world" (list "[]"))))
+
+(hk-test
+  "words leading/trailing spaces"
+  (hk-deep-force (hk-eval-expr-source "words \"  foo  bar  \""))
+  (list ":" "foo" (list ":" "bar" (list "[]"))))
+
+(hk-test
+  "words empty string"
+  (hk-deep-force (hk-eval-expr-source "words \"\""))
+  (list "[]"))
+
+;; ── lines ────────────────────────────────────────────────────
+(hk-test
+  "lines single no newline"
+  (hk-deep-force (hk-eval-expr-source "lines \"hello\""))
+  (list ":" "hello" (list "[]")))
+
+(hk-test
+  "lines two lines"
+  (hk-deep-force (hk-eval-expr-source "lines \"a\\nb\""))
+  (list ":" "a" (list ":" "b" (list "[]"))))
+
+(hk-test
+  "lines trailing newline"
+  (hk-deep-force (hk-eval-expr-source "lines \"a\\n\""))
+  (list ":" "a" (list "[]")))
+
+(hk-test
+  "lines empty string"
+  (hk-deep-force (hk-eval-expr-source "lines \"\""))
+  (list "[]"))
+
+;; ── unwords / unlines ────────────────────────────────────────
+(hk-test
+  "unwords two"
+  (hk-eval-expr-source "unwords [\"hello\", \"world\"]")
+  "hello world")
+
+(hk-test "unwords empty" (hk-eval-expr-source "unwords []") "")
+
+(hk-test "unlines two" (hk-eval-expr-source "unlines [\"a\", \"b\"]") "a\nb\n")
+
+;; ── sort / nub ───────────────────────────────────────────────
+(hk-test
+  "sort ascending"
+  (hk-deep-force (hk-eval-expr-source "sort [3,1,2]"))
+  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
+
+(hk-test
+  "sort already sorted"
+  (hk-deep-force (hk-eval-expr-source "sort [1,2,3]"))
+  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
+
+(hk-test
+  "nub removes duplicates"
+  (hk-deep-force (hk-eval-expr-source "nub [1,2,1,3,2]"))
+  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
+
+(hk-test
+  "nub no duplicates unchanged"
+  (hk-deep-force (hk-eval-expr-source "nub [1,2,3]"))
+  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
+
+;; ── splitAt ──────────────────────────────────────────────────
+(hk-test
+  "splitAt 2"
+  (hk-deep-force (hk-eval-expr-source "splitAt 2 [1,2,3,4]"))
+  (list
+    "Tuple"
+    (list ":" 1 (list ":" 2 (list "[]")))
+    (list ":" 3 (list ":" 4 (list "[]")))))
+
+(hk-test
+  "splitAt 0"
+  (hk-deep-force (hk-eval-expr-source "splitAt 0 [1,2,3]"))
+  (list
+    "Tuple"
+    (list "[]")
+    (list ":" 1 (list ":" 2 (list ":" 3 (list "[]"))))))
+
+;; ── span / break ─────────────────────────────────────────────
+(hk-test
+  "span digits"
+  (hk-deep-force (hk-eval-expr-source "span (\\x -> x < 3) [1,2,3,4]"))
+  (list
+    "Tuple"
+    (list ":" 1 (list ":" 2 (list "[]")))
+    (list ":" 3 (list ":" 4 (list "[]")))))
+
+(hk-test
+  "break digits"
+  (hk-deep-force (hk-eval-expr-source "break (\\x -> x >= 3) [1,2,3,4]"))
+  (list
+    "Tuple"
+    (list ":" 1 (list ":" 2 (list "[]")))
+    (list ":" 3 (list ":" 4 (list "[]")))))
+
+;; ── partition ────────────────────────────────────────────────
+(hk-test
+  "partition even/odd"
+  (hk-deep-force
+    (hk-eval-expr-source "partition (\\x -> x `mod` 2 == 0) [1,2,3,4,5]"))
+  (list
+    "Tuple"
+    (list ":" 2 (list ":" 4 (list "[]")))
+    (list ":" 1 (list ":" 3 (list ":" 5 (list "[]"))))))
+
+;; ── intercalate / intersperse ────────────────────────────────
+(hk-test
+  "intercalate"
+  (hk-eval-expr-source "intercalate \", \" [\"a\", \"b\", \"c\"]")
+  "a, b, c")
+
+(hk-test
+  "intersperse"
+  (hk-deep-force (hk-eval-expr-source "intersperse 0 [1,2,3]"))
+  (list
+    ":"
+    1
+    (list
+      ":"
+      0
+      (list ":" 2 (list ":" 0 (list ":" 3 (list "[]")))))))
+
+;; ── isPrefixOf / isSuffixOf / isInfixOf ──────────────────────
+(hk-test
+  "isPrefixOf True"
+  (hk-deep-force (hk-eval-expr-source "isPrefixOf [1,2] [1,2,3]"))
+  (list "True"))
+
+(hk-test
+  "isPrefixOf False"
+  (hk-deep-force (hk-eval-expr-source "isPrefixOf [2,3] [1,2,3]"))
+  (list "False"))
+
+(hk-test
+  "isSuffixOf True"
+  (hk-deep-force (hk-eval-expr-source "isSuffixOf [2,3] [1,2,3]"))
+  (list "True"))
+
+(hk-test
+  "isInfixOf True"
+  (hk-deep-force (hk-eval-expr-source "isInfixOf [2,3] [1,2,3,4]"))
+  (list "True"))
+
+(hk-test
+  "isInfixOf False"
+  (hk-deep-force (hk-eval-expr-source "isInfixOf [5,6] [1,2,3,4]"))
+  (list "False"))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-anagram.sx

@@ -0,0 +1,70 @@
+;; anagram.hs — anagram detection using sort.
+
+(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-ana-src
+  "isAnagram xs ys = sort xs == sort ys\n\nhasAnagram needle haystack = any (isAnagram needle) haystack\n")
+
+(hk-test
+  "isAnagram [1,2,3] [3,2,1] True"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [1,2,3] [3,2,1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isAnagram [1,2,3] [1,2,4] False"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [1,2,3] [1,2,4]\n") "r")
+  (list "False"))
+
+(hk-test
+  "isAnagram [] [] True"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [] []\n") "r")
+  (list "True"))
+
+(hk-test
+  "isAnagram [1] [1] True"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [1] [1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isAnagram [1,2] [2,1] True"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [1,2] [2,1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isAnagram [1,1,2] [2,1,1] True"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [1,1,2] [2,1,1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isAnagram [1,2] [1,2,3] False"
+  (hk-prog-val (str hk-ana-src "r = isAnagram [1,2] [1,2,3]\n") "r")
+  (list "False"))
+
+(hk-test
+  "hasAnagram [1,2] [[3,4],[2,1],[5,6]] True"
+  (hk-prog-val
+    (str hk-ana-src "r = hasAnagram [1,2] [[3,4],[2,1],[5,6]]\n")
+    "r")
+  (list "True"))
+
+(hk-test
+  "hasAnagram [1,2] [[3,4],[5,6]] False"
+  (hk-prog-val (str hk-ana-src "r = hasAnagram [1,2] [[3,4],[5,6]]\n") "r")
+  (list "False"))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-binary.sx

@@ -0,0 +1,83 @@
+;; binary.hs — integer binary representation using explicit recursion.
+
+(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-bin-src
+  "toBits 0 = []\ntoBits n = (n `mod` 2) : toBits (n `div` 2)\n\ntoBin 0 = [0]\ntoBin n = reverse (toBits n)\n\naddBit acc b = acc * 2 + b\nfromBin bits = foldl addBit 0 bits\n\nnumBits 0 = 1\nnumBits n = length (toBits n)\n")
+
+(hk-test
+  "toBin 0 = [0]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 0\n") "r"))
+  (list 0))
+
+(hk-test
+  "toBin 1 = [1]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 1\n") "r"))
+  (list 1))
+
+(hk-test
+  "toBin 2 = [1,0]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 2\n") "r"))
+  (list 1 0))
+
+(hk-test
+  "toBin 3 = [1,1]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 3\n") "r"))
+  (list 1 1))
+
+(hk-test
+  "toBin 4 = [1,0,0]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 4\n") "r"))
+  (list 1 0 0))
+
+(hk-test
+  "toBin 7 = [1,1,1]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 7\n") "r"))
+  (list 1 1 1))
+
+(hk-test
+  "toBin 8 = [1,0,0,0]"
+  (hk-as-list (hk-prog-val (str hk-bin-src "r = toBin 8\n") "r"))
+  (list 1 0 0 0))
+
+(hk-test
+  "fromBin [0] = 0"
+  (hk-prog-val (str hk-bin-src "r = fromBin [0]\n") "r")
+  0)
+
+(hk-test
+  "fromBin [1] = 1"
+  (hk-prog-val (str hk-bin-src "r = fromBin [1]\n") "r")
+  1)
+
+(hk-test
+  "fromBin [1,0,1] = 5"
+  (hk-prog-val (str hk-bin-src "r = fromBin [1,0,1]\n") "r")
+  5)
+
+(hk-test
+  "fromBin [1,1,1] = 7"
+  (hk-prog-val (str hk-bin-src "r = fromBin [1,1,1]\n") "r")
+  7)
+
+(hk-test
+  "roundtrip: fromBin (toBin 13) = 13"
+  (hk-prog-val (str hk-bin-src "r = fromBin (toBin 13)\n") "r")
+  13)
+
+{: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-collatz.sx

@@ -0,0 +1,83 @@
+;; collatz.hs — Collatz (3n+1) sequences.
+
+(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-col-src
+  "collatz 1 = [1]\ncollatz n = if n `mod` 2 == 0\n            then n : collatz (n `div` 2)\n            else n : collatz (3 * n + 1)\ncollatzLen n = length (collatz n)\n")
+
+(hk-test
+  "collatz 1 = [1]"
+  (hk-as-list (hk-prog-val (str hk-col-src "r = collatz 1\n") "r"))
+  (list 1))
+
+(hk-test
+  "collatz 2 = [2,1]"
+  (hk-as-list (hk-prog-val (str hk-col-src "r = collatz 2\n") "r"))
+  (list 2 1))
+
+(hk-test
+  "collatz 4 = [4,2,1]"
+  (hk-as-list (hk-prog-val (str hk-col-src "r = collatz 4\n") "r"))
+  (list 4 2 1))
+
+(hk-test
+  "collatz 6 starts 6,3,10"
+  (hk-as-list (hk-prog-val (str hk-col-src "r = take 3 (collatz 6)\n") "r"))
+  (list 6 3 10))
+
+(hk-test
+  "collatz 8 = [8,4,2,1]"
+  (hk-as-list (hk-prog-val (str hk-col-src "r = collatz 8\n") "r"))
+  (list 8 4 2 1))
+
+(hk-test
+  "collatzLen 1 = 1"
+  (hk-prog-val (str hk-col-src "r = collatzLen 1\n") "r")
+  1)
+
+(hk-test
+  "collatzLen 2 = 2"
+  (hk-prog-val (str hk-col-src "r = collatzLen 2\n") "r")
+  2)
+
+(hk-test
+  "collatzLen 4 = 3"
+  (hk-prog-val (str hk-col-src "r = collatzLen 4\n") "r")
+  3)
+
+(hk-test
+  "collatzLen 8 = 4"
+  (hk-prog-val (str hk-col-src "r = collatzLen 8\n") "r")
+  4)
+
+(hk-test
+  "collatzLen 16 = 5"
+  (hk-prog-val (str hk-col-src "r = collatzLen 16\n") "r")
+  5)
+
+(hk-test
+  "collatz last is always 1"
+  (hk-prog-val (str hk-col-src "r = last (collatz 27)\n") "r")
+  1)
+
+(hk-test
+  "collatz 3 = [3,10,5,16,8,4,2,1]"
+  (hk-as-list (hk-prog-val (str hk-col-src "r = collatz 3\n") "r"))
+  (list 3 10 5 16 8 4 2 1))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-either.sx

@@ -0,0 +1,83 @@
+;; either.hs — Either ADT operations via pattern matching.
+
+(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-either-src
+  "safeDiv _ 0 = Left \"divide by zero\"\nsafeDiv x y = Right (x `div` y)\n\nfromRight _ (Right x) = x\nfromRight def (Left _) = def\n\nfromLeft (Left x) _ = x\nfromLeft _ def = def\n\nisRight (Right _) = True\nisRight (Left _) = False\n\nisLeft (Left _) = True\nisLeft (Right _) = False\n\nmapRight _ (Left e) = Left e\nmapRight f (Right x) = Right (f x)\n\ndouble x = x * 2\n")
+
+(hk-test
+  "safeDiv 10 2 = Right 5"
+  (hk-prog-val (str hk-either-src "r = safeDiv 10 2\n") "r")
+  (list "Right" 5))
+
+(hk-test
+  "safeDiv 7 0 = Left msg"
+  (hk-prog-val (str hk-either-src "r = safeDiv 7 0\n") "r")
+  (list "Left" "divide by zero"))
+
+(hk-test
+  "fromRight 0 (Right 42) = 42"
+  (hk-prog-val (str hk-either-src "r = fromRight 0 (Right 42)\n") "r")
+  42)
+
+(hk-test
+  "fromRight 0 (Left msg) = 0"
+  (hk-prog-val (str hk-either-src "r = fromRight 0 (Left \"err\")\n") "r")
+  0)
+
+(hk-test
+  "isRight (Right 1) = True"
+  (hk-prog-val (str hk-either-src "r = isRight (Right 1)\n") "r")
+  (list "True"))
+
+(hk-test
+  "isRight (Left x) = False"
+  (hk-prog-val (str hk-either-src "r = isRight (Left \"x\")\n") "r")
+  (list "False"))
+
+(hk-test
+  "isLeft (Left x) = True"
+  (hk-prog-val (str hk-either-src "r = isLeft (Left \"x\")\n") "r")
+  (list "True"))
+
+(hk-test
+  "isLeft (Right x) = False"
+  (hk-prog-val (str hk-either-src "r = isLeft (Right 1)\n") "r")
+  (list "False"))
+
+(hk-test
+  "mapRight double (Right 5) = Right 10"
+  (hk-prog-val (str hk-either-src "r = mapRight double (Right 5)\n") "r")
+  (list "Right" 10))
+
+(hk-test
+  "mapRight double (Left e) = Left e"
+  (hk-prog-val (str hk-either-src "r = mapRight double (Left \"err\")\n") "r")
+  (list "Left" "err"))
+
+(hk-test
+  "chain safeDiv results"
+  (hk-prog-val (str hk-either-src "r = fromRight (-1) (safeDiv 20 4)\n") "r")
+  5)
+
+(hk-test
+  "chain safeDiv error"
+  (hk-prog-val (str hk-either-src "r = fromRight (-1) (safeDiv 20 0)\n") "r")
+  -1)
+
+{: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-fizzbuzz.sx

@@ -0,0 +1,84 @@
+;; fizzbuzz.hs — classic FizzBuzz with guards.
+
+(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-fb-src
+  "fizzbuzz n\n  | n `mod` 15 == 0 = \"FizzBuzz\"\n  | n `mod` 3  == 0 = \"Fizz\"\n  | n `mod` 5  == 0 = \"Buzz\"\n  | otherwise       = \"Other\"\n")
+
+(hk-test
+  "fizzbuzz 1 = Other"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 1\n") "r")
+  "Other")
+
+(hk-test
+  "fizzbuzz 3 = Fizz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 3\n") "r")
+  "Fizz")
+
+(hk-test
+  "fizzbuzz 5 = Buzz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 5\n") "r")
+  "Buzz")
+
+(hk-test
+  "fizzbuzz 15 = FizzBuzz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 15\n") "r")
+  "FizzBuzz")
+
+(hk-test
+  "fizzbuzz 30 = FizzBuzz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 30\n") "r")
+  "FizzBuzz")
+
+(hk-test
+  "fizzbuzz 6 = Fizz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 6\n") "r")
+  "Fizz")
+
+(hk-test
+  "fizzbuzz 10 = Buzz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 10\n") "r")
+  "Buzz")
+
+(hk-test
+  "fizzbuzz 7 = Other"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 7\n") "r")
+  "Other")
+
+(hk-test
+  "fizzbuzz 9 = Fizz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 9\n") "r")
+  "Fizz")
+
+(hk-test
+  "fizzbuzz 25 = Buzz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 25\n") "r")
+  "Buzz")
+
+(hk-test
+  "map fizzbuzz [1..5] starts Other"
+  (hk-as-list
+    (hk-prog-val (str hk-fb-src "r = map fizzbuzz [1,2,3,4,5]\n") "r"))
+  (list "Other" "Other" "Fizz" "Other" "Buzz"))
+
+(hk-test
+  "fizzbuzz 45 = FizzBuzz"
+  (hk-prog-val (str hk-fb-src "r = fizzbuzz 45\n") "r")
+  "FizzBuzz")
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-io.sx

@@ -0,0 +1,49 @@
+;; program-io.sx — tests for real IO monad (putStrLn, print, putStr).
+
+(hk-test
+  "putStrLn single line"
+  (hk-run-io "main = putStrLn \"hello\"")
+  (list "hello"))
+
+(hk-test
+  "putStrLn two lines via do"
+  (hk-run-io "main = do { putStrLn \"a\"; putStrLn \"b\" }")
+  (list "a" "b"))
+
+(hk-test "print Int" (hk-run-io "main = print 42") (list "42"))
+
+(hk-test "print Bool True" (hk-run-io "main = print True") (list "True"))
+
+(hk-test
+  "putStr collects string"
+  (hk-run-io "main = putStr \"hello\"")
+  (list "hello"))
+
+(hk-test
+  "do with let then putStrLn"
+  (hk-run-io "main = do\n  let s = \"world\"\n  putStrLn s")
+  (list "world"))
+
+(hk-test
+  "do sequence three lines"
+  (hk-run-io "main = do { putStrLn \"1\"; putStrLn \"2\"; putStrLn \"3\" }")
+  (list "1" "2" "3"))
+
+(hk-test
+  "print computed value"
+  (hk-run-io "main = print (6 * 7)")
+  (list "42"))
+
+(hk-test
+  "putStrLn returns IO unit"
+  (hk-deep-force (hk-run "main = putStrLn \"hi\""))
+  (list "IO" (list "Tuple")))
+
+(hk-test
+  "hk-run-io resets between calls"
+  (begin
+    (hk-run-io "main = putStrLn \"first\"")
+    (hk-run-io "main = putStrLn \"second\""))
+  (list "second"))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-matrix.sx

@@ -0,0 +1,84 @@
+;; matrix.hs — transpose and 2D list operations.
+
+(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-mat-src
+  "transpose [] = []\ntranspose ([] : _) = []\ntranspose xss = map head xss : transpose (map tail xss)\n\nmatAdd xss yss = zipWith (zipWith (+)) xss yss\n\ndiagonal [] = []\ndiagonal xss = head (head xss) : diagonal (map tail (tail xss))\n\nrowSum = map sum\ncolSum xss = map sum (transpose xss)\n")
+
+(hk-test
+  "transpose 2x2"
+  (hk-deep-force
+    (hk-prog-val (str hk-mat-src "r = transpose [[1,2],[3,4]]\n") "r"))
+  (list
+    ":"
+    (list ":" 1 (list ":" 3 (list "[]")))
+    (list ":" (list ":" 2 (list ":" 4 (list "[]"))) (list "[]"))))
+
+(hk-test
+  "transpose 1x3"
+  (hk-deep-force
+    (hk-prog-val (str hk-mat-src "r = transpose [[1,2,3]]\n") "r"))
+  (list
+    ":"
+    (list ":" 1 (list "[]"))
+    (list
+      ":"
+      (list ":" 2 (list "[]"))
+      (list ":" (list ":" 3 (list "[]")) (list "[]")))))
+
+(hk-test
+  "transpose empty = []"
+  (hk-as-list (hk-prog-val (str hk-mat-src "r = transpose []\n") "r"))
+  (list))
+
+(hk-test
+  "rowSum [[1,2],[3,4]] = [3,7]"
+  (hk-as-list (hk-prog-val (str hk-mat-src "r = rowSum [[1,2],[3,4]]\n") "r"))
+  (list 3 7))
+
+(hk-test
+  "colSum [[1,2],[3,4]] = [4,6]"
+  (hk-as-list (hk-prog-val (str hk-mat-src "r = colSum [[1,2],[3,4]]\n") "r"))
+  (list 4 6))
+
+(hk-test
+  "matAdd [[1,2],[3,4]] [[5,6],[7,8]] = [[6,8],[10,12]]"
+  (hk-deep-force
+    (hk-prog-val
+      (str hk-mat-src "r = matAdd [[1,2],[3,4]] [[5,6],[7,8]]\n")
+      "r"))
+  (list
+    ":"
+    (list ":" 6 (list ":" 8 (list "[]")))
+    (list ":" (list ":" 10 (list ":" 12 (list "[]"))) (list "[]"))))
+
+(hk-test
+  "diagonal [[1,2],[3,4]] = [1,4]"
+  (hk-as-list
+    (hk-prog-val (str hk-mat-src "r = diagonal [[1,2],[3,4]]\n") "r"))
+  (list 1 4))
+
+(hk-test
+  "diagonal 3x3"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-mat-src "r = diagonal [[1,2,3],[4,5,6],[7,8,9]]\n")
+      "r"))
+  (list 1 5 9))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-maybe.sx

@@ -0,0 +1,83 @@
+;; maybe.hs — safe operations returning Maybe values.
+
+(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-maybe-src
+  "safeDiv _ 0 = Nothing\nsafeDiv x y = Just (x `div` y)\n\nsafeHead [] = Nothing\nsafeHead (x:_) = Just x\n\nfromMaybeZero Nothing = 0\nfromMaybeZero (Just x) = x\n\nmapMaybe _ Nothing = Nothing\nmapMaybe f (Just x) = Just (f x)\n\ndouble x = x * 2\n")
+
+(hk-test
+  "safeDiv 10 2 = Just 5"
+  (hk-prog-val (str hk-maybe-src "r = safeDiv 10 2\n") "r")
+  (list "Just" 5))
+
+(hk-test
+  "safeDiv 7 0 = Nothing"
+  (hk-prog-val (str hk-maybe-src "r = safeDiv 7 0\n") "r")
+  (list "Nothing"))
+
+(hk-test
+  "safeHead [1,2,3] = Just 1"
+  (hk-prog-val (str hk-maybe-src "r = safeHead [1,2,3]\n") "r")
+  (list "Just" 1))
+
+(hk-test
+  "safeHead [] = Nothing"
+  (hk-prog-val (str hk-maybe-src "r = safeHead []\n") "r")
+  (list "Nothing"))
+
+(hk-test
+  "fromMaybeZero Nothing = 0"
+  (hk-prog-val (str hk-maybe-src "r = fromMaybeZero Nothing\n") "r")
+  0)
+
+(hk-test
+  "fromMaybeZero (Just 42) = 42"
+  (hk-prog-val (str hk-maybe-src "r = fromMaybeZero (Just 42)\n") "r")
+  42)
+
+(hk-test
+  "mapMaybe double Nothing = Nothing"
+  (hk-prog-val (str hk-maybe-src "r = mapMaybe double Nothing\n") "r")
+  (list "Nothing"))
+
+(hk-test
+  "mapMaybe double (Just 5) = Just 10"
+  (hk-prog-val (str hk-maybe-src "r = mapMaybe double (Just 5)\n") "r")
+  (list "Just" 10))
+
+(hk-test
+  "chain: fromMaybeZero (safeDiv 10 2) = 5"
+  (hk-prog-val (str hk-maybe-src "r = fromMaybeZero (safeDiv 10 2)\n") "r")
+  5)
+
+(hk-test
+  "chain: fromMaybeZero (safeDiv 10 0) = 0"
+  (hk-prog-val (str hk-maybe-src "r = fromMaybeZero (safeDiv 10 0)\n") "r")
+  0)
+
+(hk-test
+  "safeDiv 100 5 = Just 20"
+  (hk-prog-val (str hk-maybe-src "r = safeDiv 100 5\n") "r")
+  (list "Just" 20))
+
+(hk-test
+  "mapMaybe double (safeDiv 6 2) = Just 6"
+  (hk-prog-val (str hk-maybe-src "r = mapMaybe double (safeDiv 6 2)\n") "r")
+  (list "Just" 6))
+
+{: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-palindrome.sx

@@ -0,0 +1,86 @@
+;; palindrome.hs — palindrome check via reverse comparison.
+
+(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-pal-src "isPalindrome xs = xs == reverse xs\n")
+
+(hk-test
+  "isPalindrome empty"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome []\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome single"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome [1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome [1,2,1] True"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome [1,2,1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome [1,2,3] False"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome [1,2,3]\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPalindrome [1,2,2,1] True"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome [1,2,2,1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome [1,2,3,4] False"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome [1,2,3,4]\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPalindrome five odd True"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome [1,2,3,2,1]\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome racecar True"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome \"racecar\"\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome hello False"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome \"hello\"\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPalindrome a True"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome \"a\"\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPalindrome madam True"
+  (hk-prog-val (str hk-pal-src "r = isPalindrome \"madam\"\n") "r")
+  (list "True"))
+
+(hk-test
+  "not-palindrome via map"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-pal-src "r = filter isPalindrome [[1],[1,2],[1,2,1],[2,3]]\n")
+      "r"))
+  (list
+    (list ":" 1 (list "[]"))
+    (list ":" 1 (list ":" 2 (list ":" 1 (list "[]"))))))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-powers.sx

@@ -0,0 +1,78 @@
+;; powers.hs — integer exponentiation and powers-of-2 checks.
+
+(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-pow-src
+  "pow _ 0 = 1\npow base n = base * pow base (n - 1)\n\npowers base k = map (pow base) [0..k]\n\nisPowerOf2 n\n  | n <= 0    = False\n  | n == 1    = True\n  | otherwise = n `mod` 2 == 0 && isPowerOf2 (n `div` 2)\n\nlog2 1 = 0\nlog2 n = 1 + log2 (n `div` 2)\n")
+
+(hk-test "pow 2 0 = 1" (hk-prog-val (str hk-pow-src "r = pow 2 0\n") "r") 1)
+
+(hk-test "pow 2 1 = 2" (hk-prog-val (str hk-pow-src "r = pow 2 1\n") "r") 2)
+
+(hk-test
+  "pow 2 8 = 256"
+  (hk-prog-val (str hk-pow-src "r = pow 2 8\n") "r")
+  256)
+
+(hk-test "pow 3 4 = 81" (hk-prog-val (str hk-pow-src "r = pow 3 4\n") "r") 81)
+
+(hk-test
+  "pow 10 3 = 1000"
+  (hk-prog-val (str hk-pow-src "r = pow 10 3\n") "r")
+  1000)
+
+(hk-test
+  "powers 2 4 = [1,2,4,8,16]"
+  (hk-as-list (hk-prog-val (str hk-pow-src "r = powers 2 4\n") "r"))
+  (list 1 2 4 8 16))
+
+(hk-test
+  "powers 3 3 = [1,3,9,27]"
+  (hk-as-list (hk-prog-val (str hk-pow-src "r = powers 3 3\n") "r"))
+  (list 1 3 9 27))
+
+(hk-test
+  "isPowerOf2 1 = True"
+  (hk-prog-val (str hk-pow-src "r = isPowerOf2 1\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPowerOf2 8 = True"
+  (hk-prog-val (str hk-pow-src "r = isPowerOf2 8\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPowerOf2 6 = False"
+  (hk-prog-val (str hk-pow-src "r = isPowerOf2 6\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPowerOf2 0 = False"
+  (hk-prog-val (str hk-pow-src "r = isPowerOf2 0\n") "r")
+  (list "False"))
+
+(hk-test "log2 1 = 0" (hk-prog-val (str hk-pow-src "r = log2 1\n") "r") 0)
+
+(hk-test "log2 8 = 3" (hk-prog-val (str hk-pow-src "r = log2 8\n") "r") 3)
+
+(hk-test
+  "log2 1024 = 10"
+  (hk-prog-val (str hk-pow-src "r = log2 1024\n") "r")
+  10)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-primes.sx

@@ -0,0 +1,83 @@
+;; primes.hs — primality testing via trial division with where clauses.
+
+(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-primes-src
+  "isPrime n\n  | n < 2    = False\n  | n == 2   = True\n  | otherwise = all notDiv [2..n-1]\n  where notDiv d = n `mod` d /= 0\n\nprimes20 = filter isPrime [2..20]\n\nnextPrime n = head (filter isPrime [n+1..])\n\ncountPrimes lo hi = length (filter isPrime [lo..hi])\n")
+
+(hk-test
+  "isPrime 2 = True"
+  (hk-prog-val (str hk-primes-src "r = isPrime 2\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPrime 3 = True"
+  (hk-prog-val (str hk-primes-src "r = isPrime 3\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPrime 4 = False"
+  (hk-prog-val (str hk-primes-src "r = isPrime 4\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPrime 5 = True"
+  (hk-prog-val (str hk-primes-src "r = isPrime 5\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPrime 1 = False"
+  (hk-prog-val (str hk-primes-src "r = isPrime 1\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPrime 0 = False"
+  (hk-prog-val (str hk-primes-src "r = isPrime 0\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPrime 7 = True"
+  (hk-prog-val (str hk-primes-src "r = isPrime 7\n") "r")
+  (list "True"))
+
+(hk-test
+  "isPrime 9 = False"
+  (hk-prog-val (str hk-primes-src "r = isPrime 9\n") "r")
+  (list "False"))
+
+(hk-test
+  "isPrime 11 = True"
+  (hk-prog-val (str hk-primes-src "r = isPrime 11\n") "r")
+  (list "True"))
+
+(hk-test
+  "primes20 = [2,3,5,7,11,13,17,19]"
+  (hk-as-list (hk-prog-val (str hk-primes-src "r = primes20\n") "r"))
+  (list 2 3 5 7 11 13 17 19))
+
+(hk-test
+  "countPrimes 1 10 = 4"
+  (hk-prog-val (str hk-primes-src "r = countPrimes 1 10\n") "r")
+  4)
+
+(hk-test
+  "nextPrime 10 = 11"
+  (hk-prog-val (str hk-primes-src "r = nextPrime 10\n") "r")
+  11)
+
+{: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-roman.sx

@@ -0,0 +1,83 @@
+;; roman.hs — convert integers to Roman numerals with guards + ++.
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define
+  hk-rom-src
+  "toRoman 0 = \"\"\ntoRoman n\n  | n >= 1000 = \"M\"  ++ toRoman (n - 1000)\n  | n >= 900  = \"CM\" ++ toRoman (n - 900)\n  | n >= 500  = \"D\"  ++ toRoman (n - 500)\n  | n >= 400  = \"CD\" ++ toRoman (n - 400)\n  | n >= 100  = \"C\"  ++ toRoman (n - 100)\n  | n >= 90   = \"XC\" ++ toRoman (n - 90)\n  | n >= 50   = \"L\"  ++ toRoman (n - 50)\n  | n >= 40   = \"XL\" ++ toRoman (n - 40)\n  | n >= 10   = \"X\"  ++ toRoman (n - 10)\n  | n >= 9    = \"IX\" ++ toRoman (n - 9)\n  | n >= 5    = \"V\"  ++ toRoman (n - 5)\n  | n >= 4    = \"IV\" ++ toRoman (n - 4)\n  | otherwise = \"I\"  ++ toRoman (n - 1)\n")
+
+(hk-test
+  "toRoman 1 = I"
+  (hk-prog-val (str hk-rom-src "r = toRoman 1\n") "r")
+  "I")
+
+(hk-test
+  "toRoman 4 = IV"
+  (hk-prog-val (str hk-rom-src "r = toRoman 4\n") "r")
+  "IV")
+
+(hk-test
+  "toRoman 5 = V"
+  (hk-prog-val (str hk-rom-src "r = toRoman 5\n") "r")
+  "V")
+
+(hk-test
+  "toRoman 9 = IX"
+  (hk-prog-val (str hk-rom-src "r = toRoman 9\n") "r")
+  "IX")
+
+(hk-test
+  "toRoman 10 = X"
+  (hk-prog-val (str hk-rom-src "r = toRoman 10\n") "r")
+  "X")
+
+(hk-test
+  "toRoman 14 = XIV"
+  (hk-prog-val (str hk-rom-src "r = toRoman 14\n") "r")
+  "XIV")
+
+(hk-test
+  "toRoman 40 = XL"
+  (hk-prog-val (str hk-rom-src "r = toRoman 40\n") "r")
+  "XL")
+
+(hk-test
+  "toRoman 50 = L"
+  (hk-prog-val (str hk-rom-src "r = toRoman 50\n") "r")
+  "L")
+
+(hk-test
+  "toRoman 90 = XC"
+  (hk-prog-val (str hk-rom-src "r = toRoman 90\n") "r")
+  "XC")
+
+(hk-test
+  "toRoman 100 = C"
+  (hk-prog-val (str hk-rom-src "r = toRoman 100\n") "r")
+  "C")
+
+(hk-test
+  "toRoman 400 = CD"
+  (hk-prog-val (str hk-rom-src "r = toRoman 400\n") "r")
+  "CD")
+
+(hk-test
+  "toRoman 1000 = M"
+  (hk-prog-val (str hk-rom-src "r = toRoman 1000\n") "r")
+  "M")
+
+(hk-test
+  "toRoman 1994 = MCMXCIV"
+  (hk-prog-val (str hk-rom-src "r = toRoman 1994\n") "r")
+  "MCMXCIV")
+
+(hk-test
+  "toRoman 58 = LVIII"
+  (hk-prog-val (str hk-rom-src "r = toRoman 58\n") "r")
+  "LVIII")
+
+{: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/program-wordcount.sx

@@ -0,0 +1,74 @@
+;; wordcount.hs — word and line counting via string splitting.
+
+(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-wc-src
+  "wordCount s = length (words s)\nlineCount s = length (lines s)\ncharCount = length\n\nlongestWord s = foldl longer \"\" (words s)\n  where longer a b = if length a >= length b then a else b\n\nshortestWord s = foldl shorter (head (words s)) (words s)\n  where shorter a b = if length a <= length b then a else b\n\nuniqueWords s = nub (words s)\n")
+
+(hk-test
+  "wordCount single word"
+  (hk-prog-val (str hk-wc-src "r = wordCount \"hello\"\n") "r")
+  1)
+
+(hk-test
+  "wordCount two words"
+  (hk-prog-val (str hk-wc-src "r = wordCount \"hello world\"\n") "r")
+  2)
+
+(hk-test
+  "wordCount with extra spaces"
+  (hk-prog-val (str hk-wc-src "r = wordCount \"  foo  bar  \"\n") "r")
+  2)
+
+(hk-test
+  "wordCount empty = 0"
+  (hk-prog-val (str hk-wc-src "r = wordCount \"\"\n") "r")
+  0)
+
+(hk-test
+  "lineCount one line"
+  (hk-prog-val (str hk-wc-src "r = lineCount \"hello\"\n") "r")
+  1)
+
+(hk-test
+  "lineCount two lines"
+  (hk-prog-val (str hk-wc-src "r = lineCount \"a\\nb\"\n") "r")
+  2)
+
+(hk-test
+  "charCount \"hello\" = 5"
+  (hk-prog-val (str hk-wc-src "r = charCount \"hello\"\n") "r")
+  5)
+
+(hk-test
+  "charCount empty = 0"
+  (hk-prog-val (str hk-wc-src "r = charCount \"\"\n") "r")
+  0)
+
+(hk-test
+  "longestWord picks longest"
+  (hk-prog-val (str hk-wc-src "r = longestWord \"a bb ccc\"\n") "r")
+  "ccc")
+
+(hk-test
+  "uniqueWords removes duplicates"
+  (hk-as-list
+    (hk-prog-val (str hk-wc-src "r = uniqueWords \"a b a c b\"\n") "r"))
+  (list "a" "b" "c"))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/program-zipwith.sx

@@ -0,0 +1,74 @@
+;; zipwith.hs — zip, zipWith, unzip operations.
+
+(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-zip-src
+  "addPair (x, y) = x + y\npairSum xs ys = map addPair (zip xs ys)\n\nscaleBy k xs = map (\\x -> x * k) xs\n\ndotProduct xs ys = sum (zipWith (*) xs ys)\n\nzipIndex xs = zip [0..length xs - 1] xs\n")
+
+(hk-test
+  "zip two lists"
+  (hk-as-list (hk-prog-val (str hk-zip-src "r = zip [1,2,3] [4,5,6]\n") "r"))
+  (list (list "Tuple" 1 4) (list "Tuple" 2 5) (list "Tuple" 3 6)))
+
+(hk-test
+  "zip unequal lengths — shorter wins"
+  (hk-as-list (hk-prog-val (str hk-zip-src "r = zip [1,2] [10,20,30]\n") "r"))
+  (list (list "Tuple" 1 10) (list "Tuple" 2 20)))
+
+(hk-test
+  "zipWith (+)"
+  (hk-as-list
+    (hk-prog-val (str hk-zip-src "r = zipWith (+) [1,2,3] [10,20,30]\n") "r"))
+  (list 11 22 33))
+
+(hk-test
+  "zipWith (*)"
+  (hk-as-list
+    (hk-prog-val (str hk-zip-src "r = zipWith (*) [2,3,4] [10,10,10]\n") "r"))
+  (list 20 30 40))
+
+(hk-test
+  "dotProduct [1,2,3] [4,5,6] = 32"
+  (hk-prog-val (str hk-zip-src "r = dotProduct [1,2,3] [4,5,6]\n") "r")
+  32)
+
+(hk-test
+  "dotProduct unit vectors = 0"
+  (hk-prog-val (str hk-zip-src "r = dotProduct [1,0] [0,1]\n") "r")
+  0)
+
+(hk-test
+  "pairSum adds element-wise"
+  (hk-as-list
+    (hk-prog-val (str hk-zip-src "r = pairSum [1,2,3] [4,5,6]\n") "r"))
+  (list 5 7 9))
+
+(hk-test
+  "unzip separates pairs"
+  (hk-prog-val (str hk-zip-src "r = unzip [(1,2),(3,4),(5,6)]\n") "r")
+  (list
+    "Tuple"
+    (list ":" 1 (list ":" 3 (list ":" 5 (list "[]"))))
+    (list ":" 2 (list ":" 4 (list ":" 6 (list "[]"))))))
+
+(hk-test
+  "zip empty = []"
+  (hk-as-list (hk-prog-val (str hk-zip-src "r = zip [] [1,2,3]\n") "r"))
+  (list))
+
+{: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

@@ -1,451 +1,127 @@
-;; lib/haskell/tests/runtime.sx — smoke-tests for lib/haskell/runtime.sx
-;;
-;; Uses the same hk-test framework as tests/parse.sx.
-;; Loaded by test.sh after: tokenizer.sx + runtime.sx are pre-loaded.
+;; 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).
 
-;; ---------------------------------------------------------------------------
-;; Test framework boilerplate (mirrors parse.sx)
-;; ---------------------------------------------------------------------------
+;; ── 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)
 
-(define hk-test-pass 0)
-(define hk-test-fail 0)
-(define hk-test-fails (list))
+(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")
 
-(define
-  (hk-test name actual expected)
-  (if
-    (= 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}))))
+;; ── 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)
 
-;; ---------------------------------------------------------------------------
-;; 1. Numeric type class helpers
-;; ---------------------------------------------------------------------------
-
-(hk-test "is-integer? int" (hk-is-integer? 42) true)
-(hk-test "is-integer? float" (hk-is-integer? 1.5) false)
-(hk-test "is-float? float" (hk-is-float? 3.14) true)
-(hk-test "is-float? int" (hk-is-float? 3) false)
-(hk-test "is-num? int" (hk-is-num? 10) true)
-(hk-test "is-num? float" (hk-is-num? 1) true)
-
-(hk-test "to-float" (hk-to-float 5) 5)
-(hk-test "to-integer trunc" (hk-to-integer 3.7) 3)
-
-(hk-test "div pos pos" (hk-div 7 2) 3)
-(hk-test "div neg pos" (hk-div -7 2) -4)
-(hk-test "div pos neg" (hk-div 7 -2) -4)
-(hk-test "div neg neg" (hk-div -7 -2) 3)
-(hk-test "div exact" (hk-div 6 2) 3)
-
-(hk-test "mod pos pos" (hk-mod 10 3) 1)
-(hk-test "mod neg pos" (hk-mod -7 3) 2)
-(hk-test "rem pos pos" (hk-rem 10 3) 1)
-(hk-test "rem neg pos" (hk-rem -7 3) -1)
-
-(hk-test "abs pos" (hk-abs 5) 5)
-(hk-test "abs neg" (hk-abs -5) 5)
-(hk-test "signum pos" (hk-signum 42) 1)
-(hk-test "signum neg" (hk-signum -7) -1)
-(hk-test "signum zero" (hk-signum 0) 0)
-
-(hk-test "gcd" (hk-gcd 12 8) 4)
-(hk-test "lcm" (hk-lcm 4 6) 12)
-(hk-test "even?" (hk-even? 4) true)
-(hk-test "even? odd" (hk-even? 3) false)
-(hk-test "odd?" (hk-odd? 7) true)
-
-;; ---------------------------------------------------------------------------
-;; 2. Rational numbers
-;; ---------------------------------------------------------------------------
-
-(let
-  ((r (hk-make-rational 1 2)))
+;; ── data MyBool = Yes | No ──
+(hk-test
+  "register simple data"
   (do
-    (hk-test "rational?" (hk-rational? r) true)
-    (hk-test "numerator" (hk-numerator r) 1)
-    (hk-test "denominator" (hk-denominator r) 2)))
+    (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"))
 
-(let
-  ((r (hk-make-rational 2 4)))
+;; ── data Maybe a = Nothing | Just a ──
+(hk-test
+  "register Maybe"
   (do
-    (hk-test "rat normalise num" (hk-numerator r) 1)
-    (hk-test "rat normalise den" (hk-denominator r) 2)))
+    (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"))
 
-(let
-  ((sum (hk-rational-add (hk-make-rational 1 2) (hk-make-rational 1 3))))
+;; ── data Either a b = Left a | Right b ──
+(hk-test
+  "register Either"
   (do
-    (hk-test "rat-add num" (hk-numerator sum) 5)
-    (hk-test "rat-add den" (hk-denominator sum) 6)))
+    (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
-  "rat-to-float"
-  (hk-rational-to-float (hk-make-rational 1 2))
-  0.5)
-(hk-test "rational? int" (hk-rational? 42) false)
-
-;; ---------------------------------------------------------------------------
-;; 3. Lazy evaluation (promises via SX delay)
-;; ---------------------------------------------------------------------------
-
-(let
-  ((p (delay 42)))
-  (hk-test "force promise" (hk-force p) 42))
-
-(hk-test "force non-promise" (hk-force 99) 99)
-
-;; ---------------------------------------------------------------------------
-;; 4. Char utilities — compare via hk-ord to avoid = on char type
-;; ---------------------------------------------------------------------------
-
-(hk-test "ord A" (hk-ord (integer->char 65)) 65)
-(hk-test "chr 65" (hk-ord (hk-chr 65)) 65)
-(hk-test "is-alpha? A" (hk-is-alpha? (integer->char 65)) true)
-(hk-test "is-alpha? 0" (hk-is-alpha? (integer->char 48)) false)
-(hk-test "is-digit? 5" (hk-is-digit? (integer->char 53)) true)
-(hk-test "is-digit? A" (hk-is-digit? (integer->char 65)) false)
-(hk-test "is-upper? A" (hk-is-upper? (integer->char 65)) true)
-(hk-test "is-upper? a" (hk-is-upper? (integer->char 97)) false)
-(hk-test "is-lower? a" (hk-is-lower? (integer->char 97)) true)
-(hk-test "is-space? spc" (hk-is-space? (integer->char 32)) true)
-(hk-test "is-space? A" (hk-is-space? (integer->char 65)) false)
-(hk-test
-  "to-upper a"
-  (hk-ord (hk-to-upper (integer->char 97)))
-  65)
-(hk-test
-  "to-lower A"
-  (hk-ord (hk-to-lower (integer->char 65)))
-  97)
-(hk-test
-  "digit-to-int 0"
-  (hk-digit-to-int (integer->char 48))
-  0)
-(hk-test
-  "digit-to-int 9"
-  (hk-digit-to-int (integer->char 57))
-  9)
-(hk-test
-  "digit-to-int a"
-  (hk-digit-to-int (integer->char 97))
-  10)
-(hk-test
-  "digit-to-int F"
-  (hk-digit-to-int (integer->char 70))
-  15)
-(hk-test "int-to-digit 0" (hk-ord (hk-int-to-digit 0)) 48)
-(hk-test "int-to-digit 10" (hk-ord (hk-int-to-digit 10)) 97)
-
-;; ---------------------------------------------------------------------------
-;; 5. Data.Set
-;; ---------------------------------------------------------------------------
-
-(hk-test "set-empty is set?" (hk-set? (hk-set-empty)) true)
-(hk-test "set-null? empty" (hk-set-null? (hk-set-empty)) true)
-
-(let
-  ((s (hk-set-singleton 42)))
+  "register recursive Tree"
   (do
-    (hk-test "singleton member" (hk-set-member? 42 s) true)
-    (hk-test "singleton size" (hk-set-size s) 1)))
+    (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"))
 
-(let
-  ((s (hk-set-from-list (list 1 2 3))))
+;; ── newtype ──
+(hk-test
+  "register newtype"
   (do
-    (hk-test "from-list member" (hk-set-member? 2 s) true)
-    (hk-test "from-list absent" (hk-set-member? 9 s) false)
-    (hk-test "from-list size" (hk-set-size s) 3)))
+    (hk-load-source! "newtype Age = MkAge Int")
+    (list
+      (hk-con-arity "MkAge")
+      (hk-con-type "MkAge")))
+  (list 1 "Age"))
 
-;; ---------------------------------------------------------------------------
-;; 6. Data.List
-;; ---------------------------------------------------------------------------
+;; ── 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"))
 
-(hk-test "head" (hk-head (list 1 2 3)) 1)
+;; ── Inside a module header ──
 (hk-test
-  "tail length"
-  (len (hk-tail (list 1 2 3)))
-  2)
-(hk-test "null? empty" (hk-null? (list)) true)
-(hk-test "null? non-empty" (hk-null? (list 1)) false)
-(hk-test
-  "length"
-  (hk-length (list 1 2 3))
-  3)
+  "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
-  "take 2"
-  (hk-take 2 (list 1 2 3))
-  (list 1 2))
-(hk-test "take 0" (hk-take 0 (list 1 2)) (list))
-(hk-test
-  "take overflow"
-  (hk-take 5 (list 1 2))
-  (list 1 2))
-(hk-test
-  "drop 1"
-  (hk-drop 1 (list 1 2 3))
-  (list 2 3))
-(hk-test
-  "drop 0"
-  (hk-drop 0 (list 1 2))
-  (list 1 2))
-
-(hk-test
-  "take-while"
-  (hk-take-while
-    (fn (x) (< x 3))
-    (list 1 2 3 4))
-  (list 1 2))
-(hk-test
-  "drop-while"
-  (hk-drop-while
-    (fn (x) (< x 3))
-    (list 1 2 3 4))
-  (list 3 4))
-
-(hk-test
-  "zip"
-  (hk-zip (list 1 2) (list 3 4))
-  (list (list 1 3) (list 2 4)))
-(hk-test
-  "zip uneven"
-  (hk-zip
-    (list 1 2 3)
-    (list 4 5))
-  (list (list 1 4) (list 2 5)))
-
-(hk-test
-  "zip-with +"
-  (hk-zip-with
-    +
-    (list 1 2 3)
-    (list 10 20 30))
-  (list 11 22 33))
-
-(hk-test
-  "unzip fst"
-  (first
-    (hk-unzip
-      (list (list 1 3) (list 2 4))))
-  (list 1 2))
-(hk-test
-  "unzip snd"
-  (nth
-    (hk-unzip
-      (list (list 1 3) (list 2 4)))
-    1)
-  (list 3 4))
-
-(hk-test
-  "elem hit"
-  (hk-elem 2 (list 1 2 3))
-  true)
-(hk-test
-  "elem miss"
-  (hk-elem 9 (list 1 2 3))
+  "program with only fun-decl leaves registry unchanged for that name"
+  (do
+    (hk-load-source! "myFunctionNotACon x = x + 1")
+    (hk-is-con? "myFunctionNotACon"))
   false)
-(hk-test
-  "not-elem"
-  (hk-not-elem 9 (list 1 2 3))
-  true)
 
+;; ── Re-registering overwrites (last wins) ──
 (hk-test
-  "nub"
-  (hk-nub (list 1 2 1 3 2))
-  (list 1 2 3))
+  "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)
 
-(hk-test
-  "sum"
-  (hk-sum (list 1 2 3 4))
-  10)
-(hk-test
-  "product"
-  (hk-product (list 1 2 3 4))
-  24)
-(hk-test
-  "maximum"
-  (hk-maximum (list 3 1 4 1 5))
-  5)
-(hk-test
-  "minimum"
-  (hk-minimum (list 3 1 4 1 5))
-  1)
-
-(hk-test
-  "concat"
-  (hk-concat
-    (list (list 1 2) (list 3 4)))
-  (list 1 2 3 4))
-(hk-test
-  "concat-map"
-  (hk-concat-map
-    (fn (x) (list x (* x x)))
-    (list 1 2 3))
-  (list 1 1 2 4 3 9))
-
-(hk-test
-  "sort"
-  (hk-sort (list 3 1 4 1 5))
-  (list 1 1 3 4 5))
-(hk-test
-  "replicate"
-  (hk-replicate 3 0)
-  (list 0 0 0))
-(hk-test "replicate 0" (hk-replicate 0 99) (list))
-
-(hk-test
-  "intersperse"
-  (hk-intersperse 0 (list 1 2 3))
-  (list 1 0 2 0 3))
-(hk-test
-  "intersperse 1"
-  (hk-intersperse 0 (list 1))
-  (list 1))
-(hk-test "intersperse empty" (hk-intersperse 0 (list)) (list))
-
-(hk-test
-  "span"
-  (hk-span
-    (fn (x) (< x 3))
-    (list 1 2 3 4))
-  (list (list 1 2) (list 3 4)))
-(hk-test
-  "break"
-  (hk-break
-    (fn (x) (>= x 3))
-    (list 1 2 3 4))
-  (list (list 1 2) (list 3 4)))
-
-(hk-test
-  "foldl"
-  (hk-foldl
-    (fn (a b) (- a b))
-    10
-    (list 1 2 3))
-  4)
-(hk-test
-  "foldr"
-  (hk-foldr cons (list) (list 1 2 3))
-  (list 1 2 3))
-
-(hk-test
-  "scanl"
-  (hk-scanl + 0 (list 1 2 3))
-  (list 0 1 3 6))
-
-;; ---------------------------------------------------------------------------
-;; 7. Maybe / Either
-;; ---------------------------------------------------------------------------
-
-(hk-test "nothing is-nothing?" (hk-is-nothing? hk-nothing) true)
-(hk-test "nothing is-just?" (hk-is-just? hk-nothing) false)
-(hk-test "just is-just?" (hk-is-just? (hk-just 42)) true)
-(hk-test "just is-nothing?" (hk-is-nothing? (hk-just 42)) false)
-(hk-test "from-just" (hk-from-just (hk-just 99)) 99)
-(hk-test
-  "from-maybe nothing"
-  (hk-from-maybe 0 hk-nothing)
-  0)
-(hk-test
-  "from-maybe just"
-  (hk-from-maybe 0 (hk-just 42))
-  42)
-(hk-test
-  "maybe nothing"
-  (hk-maybe 0 (fn (x) (* x 2)) hk-nothing)
-  0)
-(hk-test
-  "maybe just"
-  (hk-maybe 0 (fn (x) (* x 2)) (hk-just 5))
-  10)
-
-(hk-test "left is-left?" (hk-is-left? (hk-left "e")) true)
-(hk-test "right is-right?" (hk-is-right? (hk-right 42)) true)
-(hk-test "from-right" (hk-from-right (hk-right 7)) 7)
-(hk-test
-  "either left"
-  (hk-either (fn (x) (str "L" x)) (fn (x) (str "R" x)) (hk-left "err"))
-  "Lerr")
-(hk-test
-  "either right"
-  (hk-either
-    (fn (x) (str "L" x))
-    (fn (x) (str "R" x))
-    (hk-right 42))
-  "R42")
-
-;; ---------------------------------------------------------------------------
-;; 8. Tuples
-;; ---------------------------------------------------------------------------
-
-(hk-test "pair" (hk-pair 1 2) (list 1 2))
-(hk-test "fst" (hk-fst (hk-pair 3 4)) 3)
-(hk-test "snd" (hk-snd (hk-pair 3 4)) 4)
-(hk-test
-  "triple"
-  (hk-triple 1 2 3)
-  (list 1 2 3))
-(hk-test
-  "fst3"
-  (hk-fst3 (hk-triple 7 8 9))
-  7)
-(hk-test
-  "thd3"
-  (hk-thd3 (hk-triple 7 8 9))
-  9)
-
-(hk-test "curry" ((hk-curry +) 3 4) 7)
-(hk-test
-  "uncurry"
-  ((hk-uncurry (fn (a b) (* a b))) (list 3 4))
-  12)
-
-;; ---------------------------------------------------------------------------
-;; 9. String helpers
-;; ---------------------------------------------------------------------------
-
-(hk-test "words" (hk-words "hello world") (list "hello" "world"))
-(hk-test "words leading ws" (hk-words "  foo bar") (list "foo" "bar"))
-(hk-test "words empty" (hk-words "") (list))
-(hk-test "unwords" (hk-unwords (list "a" "b" "c")) "a b c")
-(hk-test "unwords single" (hk-unwords (list "x")) "x")
-
-(hk-test "lines" (hk-lines "a\nb\nc") (list "a" "b" "c"))
-(hk-test "lines single" (hk-lines "hello") (list "hello"))
-(hk-test "unlines" (hk-unlines (list "a" "b")) "a\nb\n")
-
-(hk-test "is-prefix-of yes" (hk-is-prefix-of "he" "hello") true)
-(hk-test "is-prefix-of no" (hk-is-prefix-of "wo" "hello") false)
-(hk-test "is-prefix-of eq" (hk-is-prefix-of "hi" "hi") true)
-(hk-test "is-prefix-of empty" (hk-is-prefix-of "" "hi") true)
-
-(hk-test "is-suffix-of yes" (hk-is-suffix-of "lo" "hello") true)
-(hk-test "is-suffix-of no" (hk-is-suffix-of "he" "hello") false)
-(hk-test "is-suffix-of empty" (hk-is-suffix-of "" "hi") true)
-
-(hk-test "is-infix-of yes" (hk-is-infix-of "ell" "hello") true)
-(hk-test "is-infix-of no" (hk-is-infix-of "xyz" "hello") false)
-(hk-test "is-infix-of empty" (hk-is-infix-of "" "hello") true)
-
-;; ---------------------------------------------------------------------------
-;; 10. Show
-;; ---------------------------------------------------------------------------
-
-(hk-test "show nil" (hk-show nil) "Nothing")
-(hk-test "show true" (hk-show true) "True")
-(hk-test "show false" (hk-show false) "False")
-(hk-test "show int" (hk-show 42) "42")
-(hk-test "show string" (hk-show "hi") "\"hi\"")
-(hk-test
-  "show list"
-  (hk-show (list 1 2 3))
-  "[1,2,3]")
-(hk-test "show empty list" (hk-show (list)) "[]")
-
-;; ---------------------------------------------------------------------------
-;; Summary (required by test.sh — last expression is the return value)
-;; ---------------------------------------------------------------------------
-
-(list hk-test-pass hk-test-fail)
+{: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/haskell/tests/stdlib.sx

@@ -0,0 +1,151 @@
+;; stdlib.sx — tests for standard-library functions added in Phase 5:
+;; Eq/Ord, Show, Num, Functor, Monad, Applicative, plus common Prelude.
+
+(define
+  hk-t
+  (fn
+    (lbl src expected)
+    (hk-test lbl (hk-deep-force (hk-run src)) expected)))
+
+(define
+  hk-ts
+  (fn
+    (lbl src expected)
+    (hk-test
+      lbl
+      (hk-deep-force (hk-run (str "main = show (" src ")")))
+      expected)))
+
+;; ── Ord ──────────────────────────────────────────────────────
+(hk-test
+  "compare lt"
+  (hk-deep-force (hk-run "main = compare 1 2"))
+  (list "LT"))
+(hk-test
+  "compare eq"
+  (hk-deep-force (hk-run "main = compare 3 3"))
+  (list "EQ"))
+(hk-test
+  "compare gt"
+  (hk-deep-force (hk-run "main = compare 9 5"))
+  (list "GT"))
+(hk-test "min" (hk-deep-force (hk-run "main = min 3 5")) 3)
+(hk-test "max" (hk-deep-force (hk-run "main = max 3 5")) 5)
+
+;; ── Show ─────────────────────────────────────────────────────
+(hk-ts "show int" "42" "42")
+(hk-ts "show neg" "negate 7" "-7")
+(hk-ts "show bool T" "True" "True")
+(hk-ts "show bool F" "False" "False")
+(hk-ts "show list" "[1,2,3]" "[1, 2, 3]")
+(hk-ts "show Just" "Just 5" "(Just 5)")
+(hk-ts "show Nothing" "Nothing" "Nothing")
+(hk-ts "show LT" "LT" "LT")
+(hk-ts "show tuple" "(1, True)" "(1, True)")
+
+;; ── Num extras ───────────────────────────────────────────────
+(hk-test "signum pos" (hk-deep-force (hk-run "main = signum 5")) 1)
+(hk-test
+  "signum neg"
+  (hk-deep-force (hk-run "main = signum (negate 3)"))
+  (- 0 1))
+(hk-test "signum zero" (hk-deep-force (hk-run "main = signum 0")) 0)
+(hk-test "fromIntegral" (hk-deep-force (hk-run "main = fromIntegral 7")) 7)
+
+;; ── foldr / foldl ────────────────────────────────────────────
+(hk-test "foldr sum" (hk-deep-force (hk-run "main = foldr (+) 0 [1,2,3]")) 6)
+(hk-test "foldl sum" (hk-deep-force (hk-run "main = foldl (+) 0 [1,2,3]")) 6)
+(hk-test "foldl1" (hk-deep-force (hk-run "main = foldl1 (+) [1,2,3,4]")) 10)
+(hk-test
+  "foldr cons"
+  (hk-deep-force (hk-run "main = show (foldr (:) [] [1,2,3])"))
+  "[1, 2, 3]")
+
+;; ── List ops ─────────────────────────────────────────────────
+(hk-test
+  "reverse"
+  (hk-deep-force (hk-run "main = show (reverse [1,2,3])"))
+  "[3, 2, 1]")
+(hk-test "null []" (hk-deep-force (hk-run "main = null []")) (list "True"))
+(hk-test
+  "null xs"
+  (hk-deep-force (hk-run "main = null [1]"))
+  (list "False"))
+(hk-test
+  "elem yes"
+  (hk-deep-force (hk-run "main = elem 2 [1,2,3]"))
+  (list "True"))
+(hk-test
+  "elem no"
+  (hk-deep-force (hk-run "main = elem 9 [1,2,3]"))
+  (list "False"))
+(hk-test
+  "zip"
+  (hk-deep-force (hk-run "main = show (zip [1,2] [3,4])"))
+  "[(1, 3), (2, 4)]")
+(hk-test "sum" (hk-deep-force (hk-run "main = sum [1,2,3,4,5]")) 15)
+(hk-test "product" (hk-deep-force (hk-run "main = product [1,2,3,4]")) 24)
+(hk-test "maximum" (hk-deep-force (hk-run "main = maximum [3,1,9,2]")) 9)
+(hk-test "minimum" (hk-deep-force (hk-run "main = minimum [3,1,9,2]")) 1)
+(hk-test
+  "any yes"
+  (hk-deep-force (hk-run "main = any (\\x -> x > 3) [1,2,5]"))
+  (list "True"))
+(hk-test
+  "any no"
+  (hk-deep-force (hk-run "main = any (\\x -> x > 9) [1,2,5]"))
+  (list "False"))
+(hk-test
+  "all yes"
+  (hk-deep-force (hk-run "main = all (\\x -> x > 0) [1,2,5]"))
+  (list "True"))
+(hk-test
+  "all no"
+  (hk-deep-force (hk-run "main = all (\\x -> x > 3) [1,2,5]"))
+  (list "False"))
+
+;; ── Higher-order ─────────────────────────────────────────────
+(hk-test "flip" (hk-deep-force (hk-run "main = flip (-) 3 10")) 7)
+(hk-test "const" (hk-deep-force (hk-run "main = const 42 True")) 42)
+
+;; ── Functor ──────────────────────────────────────────────────
+(hk-test
+  "fmap list"
+  (hk-deep-force (hk-run "main = show (fmap (+1) [1,2,3])"))
+  "[2, 3, 4]")
+
+;; ── Monad / Applicative ──────────────────────────────────────
+(hk-test "return" (hk-deep-force (hk-run "main = return 7")) (list "IO" 7))
+(hk-test "pure" (hk-deep-force (hk-run "main = pure 7")) (list "IO" 7))
+(hk-test
+  "when T"
+  (hk-deep-force (hk-run "main = when True (return 1)"))
+  (list "IO" 1))
+(hk-test
+  "when F"
+  (hk-deep-force (hk-run "main = when False (return 1)"))
+  (list "IO" (list "()")))
+(hk-test
+  "unless F"
+  (hk-deep-force (hk-run "main = unless False (return 2)"))
+  (list "IO" 2))
+
+;; ── lookup / maybe / either ─────────────────────────────────
+(hk-test
+  "lookup hit"
+  (hk-deep-force (hk-run "main = show (lookup 2 [(1,10),(2,20)])"))
+  "(Just 20)")
+(hk-test
+  "lookup miss"
+  (hk-deep-force (hk-run "main = show (lookup 9 [(1,10)])"))
+  "Nothing")
+(hk-test
+  "maybe def"
+  (hk-deep-force (hk-run "main = maybe 0 (+1) Nothing"))
+  0)
+(hk-test
+  "maybe just"
+  (hk-deep-force (hk-run "main = maybe 0 (+1) (Just 5)"))
+  6)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/typecheck.sx

@@ -0,0 +1,82 @@
+;; typecheck.sx — tests for hk-typecheck / hk-run-typed.
+;; Verifies that untypeable programs are rejected and well-typed programs pass.
+
+(define hk-str-has? (fn (s sub) (>= (index-of s sub) 0)))
+
+;; Helper: expect a type error containing `sub`
+(define
+  hk-tc-err
+  (fn
+    (label src sub)
+    (hk-test
+      label
+      (guard
+        (e (#t (hk-str-has? e sub)))
+        (begin (hk-run-typed src) false))
+      true)))
+
+;; ─── Valid programs pass through ─────────────────────────────────────────────
+(hk-test "typed ok: simple arithmetic" (hk-run-typed "main = 1 + 2") 3)
+
+(hk-test "typed ok: boolean" (hk-run-typed "main = True") (list "True"))
+
+(hk-test "typed ok: let binding" (hk-run-typed "main = let x = 1 in x + 2") 3)
+
+(hk-test
+  "typed ok: two independent fns"
+  (hk-run-typed "f x = x + 1\nmain = f 5")
+  6)
+
+;; ─── Untypeable programs are rejected ────────────────────────────────────────
+;; Adding Int and Bool is a unification failure.
+(hk-tc-err "reject: Int + Bool mentions Int" "main = 1 + True" "Int")
+(hk-tc-err "reject: Int + Bool mentions Bool" "main = 1 + True" "Bool")
+
+;; Condition of if must be Bool.
+(hk-tc-err "reject: if non-bool condition" "main = if 1 then 2 else 3" "Bool")
+
+;; Unbound variable.
+(hk-tc-err "reject: unbound variable" "main = unknownVar + 1" "unknownVar")
+
+;; Function body type error: applying non-function.
+(hk-tc-err "reject: apply non-function" "f x = 1 x" "Int")
+
+(define prog-sig1 (hk-core "f :: Int -> Int\nf x = x + 1"))
+
+(define prog-sig2 (hk-core "f :: Bool -> Bool\nf x = x + 1"))
+
+(define prog-sig3 (hk-core "id :: a -> a\nid x = x"))
+
+(hk-test
+  "sig ok: Int->Int accepted"
+  (first (nth (hk-infer-prog prog-sig1 (hk-type-env0)) 0))
+  "ok")
+
+(hk-test
+  "sig fail: Bool->Bool rejected"
+  (first (nth (hk-infer-prog prog-sig2 (hk-type-env0)) 0))
+  "err")
+
+(hk-test
+  "sig fail: error mentions mismatch"
+  (hk-str-has?
+    (nth (nth (hk-infer-prog prog-sig2 (hk-type-env0)) 0) 1)
+    "mismatch")
+  true)
+
+(hk-test
+  "sig ok: polymorphic a->a accepted"
+  (first (nth (hk-infer-prog prog-sig3 (hk-type-env0)) 0))
+  "ok")
+
+(hk-tc-err
+  "run-typed sig fail: Bool declared, Int inferred"
+  "main :: Bool\nmain = 1 + 2"
+  "mismatch")
+
+(hk-test
+  "run-typed sig ok: Int declared matches"
+  (hk-run-typed "main :: Int\nmain = 1 + 2")
+  3)
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/hyperscript/integration.sx

@@ -19,6 +19,7 @@
       (define
         reserved
         (list
+          (quote beingTold)
           (quote me)
           (quote it)
           (quote event)
@@ -65,7 +66,10 @@
                   (list (quote me))
                   (list
                     (quote let)
-                    (list (list (quote it) nil) (list (quote event) nil))
+                    (list
+                      (list (quote beingTold) (quote me))
+                      (list (quote it) nil)
+                      (list (quote event) nil))
                     guarded))))))))))
 
 ;; ── Activate a single element ───────────────────────────────────
@@ -73,23 +77,82 @@
 ;; Marks the element to avoid double-activation.
 
 (define
-  hs-activate!
+  hs-register-scripts!
   (fn
-    (el)
-    (let
-      ((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
-      (when
-        (and src (not (= src prev)))
-        (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))))))
+    ()
+    (for-each
+      (fn
+        (script)
+        (when
+          (not (dom-get-data script "hs-script-loaded"))
+          (let
+            ((src (host-get script "innerHTML")))
+            (guard
+              (_e (true nil))
+              (let
+                ((handler (eval-expr-cek (hs-to-sx-from-source src))))
+                (handler (dom-body)))))))
+      (hs-query-all "script[type=text/hyperscript]"))))
 
 ;; ── Boot: scan entire document ──────────────────────────────────
 ;; Called once at page load. Finds all elements with _ attribute,
 ;; compiles their hyperscript, and activates them.
 
+(define
+  hs-scripting-disabled?
+  (fn
+    (el)
+    (if
+      (= el nil)
+      false
+      (if
+        (dom-get-attr el "disable-scripting")
+        true
+        (hs-scripting-disabled? (dom-parent el))))))
+
+;; ── Boot subtree: for dynamic content ───────────────────────────
+;; Called after HTMX swaps or dynamic DOM insertion.
+;; Only activates elements within the given root.
+
+(define
+  hs-activate!
+  (fn
+    (el)
+    (do
+      (hs-register-scripts!)
+      (let
+        ((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
+        (when
+          (and src (not (= src prev)) (not (hs-scripting-disabled? el)))
+          (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")
+            (host-set! (host-global "window") "__hs_current_me" el)
+            (guard
+              (_e
+                (true
+                  (do
+                    (dom-dispatch el "hyperscript:parse-error" {:errors (list _e)})
+                    nil)))
+              (let
+                ((handler (hs-handler src)))
+                (let
+                  ((el-type (dom-get-attr el "type"))
+                    (comp-name (dom-get-attr el "component")))
+                  (let
+                    ((safe-handler (fn (e) (host-call-fn handler (list e)))))
+                    (if
+                      (= el-type "text/hyperscript-template")
+                      (for-each
+                        safe-handler
+                        (hs-query-all (or comp-name "")))
+                      (safe-handler el))))))
+            (host-set! (host-global "window") "__hs_current_me" nil)
+            (dom-dispatch el "hyperscript:after:init" nil)))))))
+
 (define
   hs-deactivate!
   (fn
@@ -101,10 +164,6 @@
       (dom-set-data el "hs-active" false)
       (dom-set-data el "hs-script" nil))))
 
-;; ── Boot subtree: for dynamic content ───────────────────────────
-;; Called after HTMX swaps or dynamic DOM insertion.
-;; Only activates elements within the given root.
-
 (define
   hs-boot!
   (fn

lib/hyperscript/tokenizer.sx

@@ -28,6 +28,27 @@
 
 (define hs-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
 
+(define
+  hs-hex-digit?
+  (fn
+    (c)
+    (or
+      (and (>= c "0") (<= c "9"))
+      (and (>= c "a") (<= c "f"))
+      (and (>= c "A") (<= c "F")))))
+
+(define
+  hs-hex-val
+  (fn
+    (c)
+    (let
+      ((code (char-code c)))
+      (cond
+        ((and (>= code 48) (<= code 57))  (- code 48))
+        ((and (>= code 65) (<= code 70))  (- code 55))
+        ((and (>= code 97) (<= code 102)) (- code 87))
+        (true 0)))))
+
 ;; ── Keyword set ───────────────────────────────────────────────────
 
 (define
@@ -110,6 +131,7 @@
     "append"
     "settle"
     "transition"
+    "view"
     "over"
     "closest"
     "next"
@@ -187,7 +209,8 @@
     "using"
     "giving"
     "ask"
-    "answer"))
+    "answer"
+    "bind"))
 
 (define hs-keyword? (fn (word) (some (fn (k) (= k word)) hs-keywords)))
 
@@ -235,10 +258,15 @@
         read-number
         (fn
           (start)
-          (when
-            (and (< pos src-len) (hs-digit? (hs-cur)))
-            (hs-advance! 1)
-            (read-number start))
+          (define
+            read-int
+            (fn
+              ()
+              (when
+                (and (< pos src-len) (hs-digit? (hs-cur)))
+                (hs-advance! 1)
+                (read-int))))
+          (read-int)
           (when
             (and
               (< pos src-len)
@@ -246,15 +274,7 @@
               (< (+ pos 1) src-len)
               (hs-digit? (hs-peek 1)))
             (hs-advance! 1)
-            (define
-              read-frac
-              (fn
-                ()
-                (when
-                  (and (< pos src-len) (hs-digit? (hs-cur)))
-                  (hs-advance! 1)
-                  (read-frac))))
-            (read-frac))
+            (read-int))
           (do
             (when
               (and
@@ -272,15 +292,7 @@
                   (< pos src-len)
                   (or (= (hs-cur) "+") (= (hs-cur) "-")))
                 (hs-advance! 1))
-              (define
-                read-exp-digits
-                (fn
-                  ()
-                  (when
-                    (and (< pos src-len) (hs-digit? (hs-cur)))
-                    (hs-advance! 1)
-                    (read-exp-digits))))
-              (read-exp-digits))
+              (read-int))
             (let
               ((num-end pos))
               (when
@@ -308,7 +320,7 @@
                 ()
                 (cond
                   (>= pos src-len)
-                  nil
+                  (error "Unterminated string")
                   (= (hs-cur) "\\")
                   (do
                     (hs-advance! 1)
@@ -318,15 +330,47 @@
                         ((ch (hs-cur)))
                         (cond
                           (= ch "n")
-                          (append! chars "\n")
+                          (do (append! chars "\n") (hs-advance! 1))
                           (= ch "t")
-                          (append! chars "\t")
+                          (do (append! chars "\t") (hs-advance! 1))
+                          (= ch "r")
+                          (do (append! chars "\r") (hs-advance! 1))
+                          (= ch "b")
+                          (do
+                            (append! chars (char-from-code 8))
+                            (hs-advance! 1))
+                          (= ch "f")
+                          (do
+                            (append! chars (char-from-code 12))
+                            (hs-advance! 1))
+                          (= ch "v")
+                          (do
+                            (append! chars (char-from-code 11))
+                            (hs-advance! 1))
                           (= ch "\\")
-                          (append! chars "\\")
+                          (do (append! chars "\\") (hs-advance! 1))
                           (= ch quote-char)
-                          (append! chars quote-char)
-                          :else (do (append! chars "\\") (append! chars ch)))
-                        (hs-advance! 1)))
+                          (do (append! chars quote-char) (hs-advance! 1))
+                          (= ch "x")
+                          (do
+                            (hs-advance! 1)
+                            (if
+                              (and
+                                (< (+ pos 1) src-len)
+                                (hs-hex-digit? (hs-cur))
+                                (hs-hex-digit? (hs-peek 1)))
+                              (let
+                                ((d1 (hs-hex-val (hs-cur)))
+                                  (d2 (hs-hex-val (hs-peek 1))))
+                                (append!
+                                  chars
+                                  (char-from-code (+ (* d1 16) d2)))
+                                (hs-advance! 2))
+                              (error "Invalid hexadecimal escape: \\x")))
+                          :else (do
+                            (append! chars "\\")
+                            (append! chars ch)
+                            (hs-advance! 1)))))
                     (loop))
                   (= (hs-cur) quote-char)
                   (hs-advance! 1)
@@ -413,27 +457,68 @@
         read-class-name
         (fn
           (start)
-          (when
-            (and
-              (< pos src-len)
-              (or
-                (hs-ident-char? (hs-cur))
-                (= (hs-cur) ":")
-                (= (hs-cur) "[")
-                (= (hs-cur) "]")))
-            (hs-advance! 1)
-            (read-class-name start))
-          (slice src start pos)))
+          (define
+            build-name
+            (fn
+              (acc depth)
+              (cond
+                ((and (< pos src-len) (= (hs-cur) "\\") (< (+ pos 1) src-len))
+                  (do
+                    (hs-advance! 1)
+                    (let
+                      ((c (hs-cur)))
+                      (hs-advance! 1)
+                      (build-name (str acc c) depth))))
+                ((and (< pos src-len) (= (hs-cur) "["))
+                  (do
+                    (let
+                      ((c (hs-cur)))
+                      (hs-advance! 1)
+                      (build-name (str acc c) (+ depth 1)))))
+                ((and (< pos src-len) (= (hs-cur) "]"))
+                  (do
+                    (let
+                      ((c (hs-cur)))
+                      (hs-advance! 1)
+                      (build-name
+                        (str acc c)
+                        (if (> depth 0) (- depth 1) 0)))))
+                ((and (< pos src-len) (> depth 0) (or (= (hs-cur) "(") (= (hs-cur) ")")))
+                  (do
+                    (let
+                      ((c (hs-cur)))
+                      (hs-advance! 1)
+                      (build-name (str acc c) depth))))
+                ((and (< pos src-len) (or (hs-ident-char? (hs-cur)) (= (hs-cur) ":") (= (hs-cur) "&")))
+                  (do
+                    (let
+                      ((c (hs-cur)))
+                      (hs-advance! 1)
+                      (build-name (str acc c) depth))))
+                (true acc))))
+          (build-name "" 0)))
       (define
         hs-emit!
         (fn
           (type value start)
-          (append! tokens (hs-make-token type value start))))
+          (let
+            ((tok (hs-make-token type value start))
+              (end-pos
+                (max pos (+ start (if (nil? value) 0 (len (str value)))))))
+            (do
+              (dict-set! tok "end" end-pos)
+              (dict-set! tok "line" (len (split (slice src 0 start) "\n")))
+              (append! tokens tok)))))
       (define
         scan!
         (fn
           ()
-          (skip-ws!)
+          (let
+            ((ws-start pos))
+            (skip-ws!)
+            (when
+              (and (> (len tokens) 0) (> pos ws-start))
+              (hs-emit! "whitespace" (slice src ws-start pos) ws-start)))
           (when
             (< pos src-len)
             (let
@@ -453,10 +538,26 @@
                     (= (hs-peek 1) "#")
                     (= (hs-peek 1) "[")
                     (= (hs-peek 1) "*")
-                    (= (hs-peek 1) ":")))
+                    (= (hs-peek 1) ":")
+                    (= (hs-peek 1) "$")))
                 (do (hs-emit! "selector" (read-selector) start) (scan!))
                 (and (= ch ".") (< (+ pos 1) src-len) (= (hs-peek 1) "."))
                 (do (hs-emit! "op" ".." start) (hs-advance! 2) (scan!))
+                (and
+                  (= ch ".")
+                  (< (+ pos 1) src-len)
+                  (or
+                    (hs-letter? (hs-peek 1))
+                    (= (hs-peek 1) "-")
+                    (= (hs-peek 1) "_"))
+                  (> (len tokens) 0)
+                  (let
+                    ((lt (dict-get (nth tokens (- (len tokens) 1)) :type)))
+                    (or
+                      (= lt "paren-close")
+                      (= lt "brace-close")
+                      (= lt "bracket-close"))))
+                (do (hs-emit! "dot" "." start) (hs-advance! 1) (scan!))
                 (and
                   (= ch ".")
                   (< (+ pos 1) src-len)
@@ -468,6 +569,18 @@
                   (hs-advance! 1)
                   (hs-emit! "class" (read-class-name pos) start)
                   (scan!))
+                (and
+                  (= ch "#")
+                  (< (+ pos 1) src-len)
+                  (hs-ident-start? (hs-peek 1))
+                  (> (len tokens) 0)
+                  (let
+                    ((lt (dict-get (nth tokens (- (len tokens) 1)) :type)))
+                    (or
+                      (= lt "paren-close")
+                      (= lt "brace-close")
+                      (= lt "bracket-close"))))
+                (do (hs-emit! "op" "#" start) (hs-advance! 1) (scan!))
                 (and
                   (= ch "#")
                   (< (+ pos 1) src-len)
@@ -536,10 +649,12 @@
                 (do
                   (let
                     ((word (read-ident start)))
-                    (hs-emit!
-                      (if (hs-keyword? word) "keyword" "ident")
-                      word
-                      start))
+                    (let
+                      ((full-word (if (and (< pos src-len) (= (hs-cur) "'") (< (+ pos 1) src-len) (hs-letter? (hs-peek 1)) (not (and (= (hs-peek 1) "s") (or (>= (+ pos 2) src-len) (not (hs-ident-char? (hs-peek 2))))))) (do (hs-advance! 1) (str word "'" (read-ident pos))) word)))
+                      (hs-emit!
+                        (if (hs-keyword? full-word) "keyword" "ident")
+                        full-word
+                        start)))
                   (scan!))
                 (and
                   (or (= ch "=") (= ch "!") (= ch "<") (= ch ">"))
@@ -620,7 +735,82 @@
                 (do (hs-emit! "colon" ":" start) (hs-advance! 1) (scan!))
                 (= ch "|")
                 (do (hs-emit! "op" "|" start) (hs-advance! 1) (scan!))
+                (= ch "&")
+                (do (hs-emit! "op" "&" start) (hs-advance! 1) (scan!))
+                (= ch "#")
+                (do (hs-emit! "op" "#" start) (hs-advance! 1) (scan!))
+                (= ch "?")
+                (do (hs-emit! "op" "?" start) (hs-advance! 1) (scan!))
+                (= ch ";")
+                (do (hs-emit! "op" ";" start) (hs-advance! 1) (scan!))
                 :else (do (hs-advance! 1) (scan!)))))))
       (scan!)
       (hs-emit! "eof" nil pos)
+      tokens)))
+
+;; ── Template-mode tokenizer (E37 API) ────────────────────────────────
+;; Used by hs-tokens-of when :template flag is set.
+;; Emits outer " chars as single STRING tokens; ${ ... } as $ { <inner-tokens> };
+;; inner content is tokenized with the regular hs-tokenize.
+
+(define
+  hs-tokenize-template
+  (fn
+    (src)
+    (let
+      ((tokens (list)) (pos 0) (src-len (len src)))
+      (define t-cur (fn () (if (< pos src-len) (nth src pos) nil)))
+      (define t-peek (fn (n) (if (< (+ pos n) src-len) (nth src (+ pos n)) nil)))
+      (define t-advance! (fn (n) (set! pos (+ pos n))))
+      (define t-emit! (fn (type value) (append! tokens (hs-make-token type value pos))))
+      (define
+        scan-to-close!
+        (fn
+          (depth)
+          (when
+            (and (< pos src-len) (> depth 0))
+            (cond
+              (= (t-cur) "{")
+              (do (t-advance! 1) (scan-to-close! (+ depth 1)))
+              (= (t-cur) "}")
+              (when (> (- depth 1) 0) (t-advance! 1) (scan-to-close! (- depth 1)))
+              :else (do (t-advance! 1) (scan-to-close! depth))))))
+      (define
+        scan-template!
+        (fn
+          ()
+          (when
+            (< pos src-len)
+            (let
+              ((ch (t-cur)))
+              (cond
+                (= ch "\"")
+                (do (t-emit! "string" "\"") (t-advance! 1) (scan-template!))
+                (and (= ch "$") (= (t-peek 1) "{"))
+                (do
+                  (t-emit! "op" "$")
+                  (t-advance! 1)
+                  (t-emit! "brace-open" "{")
+                  (t-advance! 1)
+                  (let
+                    ((inner-start pos))
+                    (scan-to-close! 1)
+                    (let
+                      ((inner-src (slice src inner-start pos))
+                       (inner-toks (hs-tokenize inner-src)))
+                      (for-each
+                        (fn (tok)
+                          (when (not (= (get tok "type") "eof"))
+                            (append! tokens tok)))
+                        inner-toks))
+                    (t-emit! "brace-close" "}")
+                    (when (< pos src-len) (t-advance! 1)))
+                  (scan-template!))
+                (= ch "$")
+                (do (t-emit! "op" "$") (t-advance! 1) (scan-template!))
+                (hs-ws? ch)
+                (do (t-advance! 1) (scan-template!))
+                :else (do (t-advance! 1) (scan-template!)))))))
+      (scan-template!)
+      (t-emit! "eof" nil)
       tokens)))

lib/prolog/scoreboard.json

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

lib/prolog/scoreboard.md

@@ -1,7 +1,7 @@
 # Prolog scoreboard
 
 **590 / 590 passing** (0 failure(s)).
-Generated 2026-05-06T08:29:09+00:00.
+Generated 2026-05-06T12:17:46+00:00.
 
 | Suite | Passed | Total | Status |
 |-------|--------|-------|--------|