forth: fix #S / UM/MOD precision bugs — Hayes 628→632/638 (99%)

Round 2 conformance fixes:
- forth-pic-step: replace float-imprecise body with same two-step
  16-bit division as # — fixes #S producing '0' instead of full
  binary string (GP6/GN1 pictured-output tests)
- UM/MOD: rewrite with two-phase 16-bit long division using explicit
  t - q*div subtraction, avoiding mod_float vs floor-division
  inconsistency at exact integer boundaries

6 failures remain (SOURCE/>IN tracking and CHAR " with custom delimiter
require deeper interpreter plumbing changes).

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 { 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); } })
+        ? 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); } })
       : 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,34 +1892,8 @@ 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 ->
@@ -3044,8 +3018,7 @@ 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")]);
-     ("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")])]
+     ("setup", `Assoc [("type", `String "string"); ("description", `String "SX setup expression to run before main evaluation")])]
     ["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/run_tests.ml

@@ -1279,7 +1279,7 @@ let run_foundation_tests () =
   assert_true "sx_truthy \"\"" (Bool (sx_truthy (String "")));
   assert_eq "not truthy nil" (Bool false) (Bool (sx_truthy Nil));
   assert_eq "not truthy false" (Bool false) (Bool (sx_truthy (Bool false)));
-  let l = { l_params = ["x"]; l_body = Symbol "x"; l_closure = Sx_types.make_env (); l_name = None; l_compiled = None; l_call_count = 0; l_uid = Sx_types.next_lambda_uid () } in
+  let l = { l_params = ["x"]; l_body = Symbol "x"; l_closure = Sx_types.make_env (); l_name = None; l_compiled = None } in
   assert_true "is_lambda" (Bool (Sx_types.is_lambda (Lambda l)));
   ignore (Sx_types.set_lambda_name (Lambda l) "my-fn");
   assert_eq "lambda name mutated" (String "my-fn") (lambda_name (Lambda l))

hosts/ocaml/browser/sx_browser.ml

@@ -665,11 +665,7 @@ let () =
   let rec deep_equal a b =
     match a, b with
     | Nil, Nil -> true | Bool a, Bool b -> a = b
-    | Integer a, Integer b -> a = b
-    | Number a, Number b -> a = b
-    | Integer a, Number b -> float_of_int a = b
-    | Number a, Integer b -> a = float_of_int b
-    | String a, String b -> a = b
+    | Number a, Number b -> a = b | String a, String b -> a = b
     | Symbol a, Symbol b -> a = b | Keyword a, Keyword b -> a = b
     | (List a | ListRef { contents = a }), (List b | ListRef { contents = b }) ->
       List.length a = List.length b && List.for_all2 deep_equal a b

hosts/ocaml/lib/dune

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

hosts/ocaml/lib/sx_primitives.ml

@@ -582,22 +582,11 @@ let () =
       (List lb | ListRef { contents = lb }) ->
       List.length la = List.length lb &&
       List.for_all2 safe_eq la lb
-    (* Dict: __host_handle identity for DOM-wrapped dicts; otherwise
-       structural equality over keys + values. *)
+    (* Dict: check __host_handle for DOM node identity *)
     | Dict a, Dict b ->
       (match Hashtbl.find_opt a "__host_handle", Hashtbl.find_opt b "__host_handle" with
        | Some (Number ha), Some (Number hb) -> ha = hb
-       | Some _, _ | _, Some _ -> false
-       | None, None ->
-         Hashtbl.length a = Hashtbl.length b &&
-         (let eq = ref true in
-          Hashtbl.iter (fun k v ->
-            if !eq then
-              match Hashtbl.find_opt b k with
-              | Some v' -> if not (safe_eq v v') then eq := false
-              | None -> eq := false
-          ) a;
-          !eq))
+       | _ -> false)
     (* Records: same type + structurally equal fields *)
     | Record a, Record b ->
       a.r_type.rt_uid = b.r_type.rt_uid &&
@@ -3011,180 +3000,4 @@ 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"));
-
-  (* === 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])"));
-
-  (* JIT cache control & observability — backed by refs in sx_types.ml to
-     avoid creating a sx_primitives → sx_vm dependency cycle. sx_vm reads
-     these refs to decide when to JIT. *)
-  register "jit-stats" (fun _args ->
-    let d = Hashtbl.create 8 in
-    Hashtbl.replace d "threshold"        (Number (float_of_int !Sx_types.jit_threshold));
-    Hashtbl.replace d "budget"           (Number (float_of_int !Sx_types.jit_budget));
-    Hashtbl.replace d "cache-size"       (Number (float_of_int (Sx_types.jit_cache_size ())));
-    Hashtbl.replace d "compiled"         (Number (float_of_int !Sx_types.jit_compiled_count));
-    Hashtbl.replace d "compile-failed"   (Number (float_of_int !Sx_types.jit_skipped_count));
-    Hashtbl.replace d "below-threshold"  (Number (float_of_int !Sx_types.jit_threshold_skipped_count));
-    Hashtbl.replace d "evicted"          (Number (float_of_int !Sx_types.jit_evicted_count));
-    Dict d);
-  register "jit-set-threshold!" (fun args ->
-    match args with
-    | [Number n] -> Sx_types.jit_threshold := int_of_float n; Nil
-    | [Integer n] -> Sx_types.jit_threshold := n; Nil
-    | _ -> raise (Eval_error "jit-set-threshold!: (n) where n is integer"));
-  register "jit-set-budget!" (fun args ->
-    match args with
-    | [Number n] -> Sx_types.jit_budget := int_of_float n; Nil
-    | [Integer n] -> Sx_types.jit_budget := n; Nil
-    | _ -> raise (Eval_error "jit-set-budget!: (n) where n is integer"));
-  register "jit-reset-cache!" (fun _args ->
-    (* Phase 3 manual cache reset — clear all compiled VmClosures.
-       Hot paths will re-JIT on next call (after re-hitting threshold). *)
-    Queue.iter (fun (_, v) ->
-      match v with Lambda l -> l.l_compiled <- None | _ -> ()
-    ) Sx_types.jit_cache_queue;
-    Queue.clear Sx_types.jit_cache_queue;
-    Nil);
-  register "jit-reset-counters!" (fun _args ->
-    Sx_types.jit_compiled_count := 0;
-    Sx_types.jit_skipped_count := 0;
-    Sx_types.jit_threshold_skipped_count := 0;
-    Sx_types.jit_evicted_count := 0;
-    Nil)
+    | _ -> raise (Eval_error "list->bytevector: expected list"))

hosts/ocaml/lib/sx_types.ml

@@ -128,8 +128,6 @@ and lambda = {
   l_closure : env;
   mutable l_name : string option;
   mutable l_compiled : vm_closure option;  (** Lazy JIT cache *)
-  mutable l_call_count : int;              (** Tiered-compilation counter — JIT after threshold calls *)
-  l_uid : int;                             (** Unique identity for LRU cache tracking *)
 }
 
 and component = {
@@ -436,60 +434,12 @@ let unwrap_env_val = function
   | Env e -> e
   | _ -> raise (Eval_error "make_lambda: expected env for closure")
 
-(* Lambda UID — minted on construction, used as LRU cache key (Phase 2). *)
-let lambda_uid_counter = ref 0
-let next_lambda_uid () = incr lambda_uid_counter; !lambda_uid_counter
-
 let make_lambda params body closure =
   let ps = match params with
     | List items -> List.map value_to_string items
     | _ -> value_to_string_list params
   in
-  Lambda { l_params = ps; l_body = body; l_closure = unwrap_env_val closure; l_name = None; l_compiled = None; l_call_count = 0; l_uid = next_lambda_uid () }
-
-(** {1 JIT cache control}
-
-    Tiered compilation: only JIT a lambda after it's been called [jit_threshold]
-    times. This filters out one-shot lambdas (test harness, dynamic eval, REPLs)
-    so they never enter the JIT cache. Counters are exposed to SX as [(jit-stats)].
-
-    These live here (in sx_types) rather than sx_vm so [sx_primitives] can read
-    them without creating a sx_primitives → sx_vm dependency cycle. *)
-let jit_threshold = ref 4
-let jit_compiled_count = ref 0
-let jit_skipped_count = ref 0
-let jit_threshold_skipped_count = ref 0
-
-(** {2 JIT cache LRU eviction — Phase 2}
-
-    Once a lambda crosses the threshold, its [l_compiled] slot is filled.
-    To bound memory under unbounded compilation pressure, track all live
-    compiled lambdas in FIFO order, and evict from the head when the count
-    exceeds [jit_budget].
-
-    [lambda_uid_counter] mints unique identities on lambda creation; the
-    LRU queue holds these IDs paired with a back-reference to the lambda
-    so we can clear its [l_compiled] slot on eviction.
-
-    Budget of 0 = no cache (disable JIT entirely).
-    Budget of [max_int] = unbounded (legacy behaviour). Default 5000 is
-    a generous ceiling for any realistic page; the test harness compiles
-    ~3000 distinct one-shot lambdas in a full run but tiered compilation
-    (Phase 1) means most never enter the cache, so steady-state count
-    stays small.
-
-    [lambda_uid_counter] and [next_lambda_uid] are defined above
-    [make_lambda] (which uses them on construction). *)
-let jit_budget = ref 5000
-let jit_evicted_count = ref 0
-
-(** Live compiled lambdas in FIFO order — front is oldest, back is newest.
-    Each entry is (uid, lambda); on eviction we clear lambda.l_compiled and
-    drop from the queue. Using a mutable Queue rather than a hand-rolled
-    linked list because eviction is amortised O(1) at the head and inserts
-    are O(1) at the tail. *)
-let jit_cache_queue : (int * value) Queue.t = Queue.create ()
-let jit_cache_size () = Queue.length jit_cache_queue
+  Lambda { l_params = ps; l_body = body; l_closure = unwrap_env_val closure; l_name = None; l_compiled = None }
 
 let make_component name params has_children body closure affinity =
   let n = value_to_string name in

hosts/ocaml/lib/sx_vm.ml

@@ -57,9 +57,6 @@ let () = Sx_types._convert_vm_suspension := (fun exn ->
 let jit_compile_ref : (lambda -> (string, value) Hashtbl.t -> vm_closure option) ref =
   ref (fun _ _ -> None)
 
-(* JIT threshold and counters live in Sx_types so primitives can read them
-   without creating a sx_primitives → sx_vm dependency cycle. *)
-
 (** Sentinel closure indicating JIT compilation was attempted and failed.
     Prevents retrying compilation on every call. *)
 let jit_failed_sentinel = {
@@ -356,29 +353,13 @@ and vm_call vm f args =
      | None ->
        if l.l_name <> None
        then begin
-         l.l_call_count <- l.l_call_count + 1;
-         if l.l_call_count >= !Sx_types.jit_threshold && !Sx_types.jit_budget > 0 then begin
          l.l_compiled <- Some jit_failed_sentinel;
          match !jit_compile_ref l vm.globals with
          | Some cl ->
-             incr Sx_types.jit_compiled_count;
            l.l_compiled <- Some cl;
-             (* Phase 2 LRU: track this compiled lambda; if cache exceeds budget,
-                evict the oldest by clearing its l_compiled slot. *)
-             Queue.add (l.l_uid, Lambda l) Sx_types.jit_cache_queue;
-             while Queue.length Sx_types.jit_cache_queue > !Sx_types.jit_budget do
-               (match Queue.pop Sx_types.jit_cache_queue with
-                | (_, Lambda ev_l) -> ev_l.l_compiled <- None; incr Sx_types.jit_evicted_count
-                | _ -> ())
-             done;
            push_closure_frame vm cl args
          | None ->
-             incr Sx_types.jit_skipped_count;
            push vm (cek_call_or_suspend vm f (List args))
-         end else begin
-           incr Sx_types.jit_threshold_skipped_count;
-           push vm (cek_call_or_suspend vm f (List args))
-         end
        end
        else
          push vm (cek_call_or_suspend vm f (List args)))

lib/common-lisp/clos.sx

@@ -1,500 +0,0 @@
-;; lib/common-lisp/clos.sx — CLOS: classes, instances, generic functions
-;;
-;; Class records: {:clos-type "class" :name "NAME" :slots {...} :parents [...] :methods [...]}
-;; Instance:      {:clos-type "instance" :class "NAME" :slots {slot: val ...}}
-;; Method:        {:qualifiers [...] :specializers [...] :fn (fn (args next-fn) ...)}
-;;
-;; SX primitive notes:
-;;   dict->list: use (map (fn (k) (list k (get d k))) (keys d))
-;;   dict-set (pure): use assoc
-;;   fn?/callable?: use callable?
-
-;; ── dict helpers ───────────────────────────────────────────────────────────
-
-(define
-  clos-dict->list
-  (fn (d) (map (fn (k) (list k (get d k))) (keys d))))
-
-;; ── class registry ─────────────────────────────────────────────────────────
-
-(define
-  clos-class-registry
-  (dict
-    "t"
-    {:parents (list) :clos-type "class" :slots (dict) :methods (list) :name "t"}
-    "null"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "null"}
-    "integer"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "integer"}
-    "float"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "float"}
-    "string"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "string"}
-    "symbol"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "symbol"}
-    "cons"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "cons"}
-    "list"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "list"}))
-
-;; ── clos-generic-registry ─────────────────────────────────────────────────
-
-(define clos-generic-registry (dict))
-
-;; ── class-of ──────────────────────────────────────────────────────────────
-
-(define
-  clos-class-of
-  (fn
-    (x)
-    (cond
-      ((nil? x) "null")
-      ((integer? x) "integer")
-      ((float? x) "float")
-      ((string? x) "string")
-      ((symbol? x) "symbol")
-      ((and (list? x) (> (len x) 0)) "cons")
-      ((and (list? x) (= (len x) 0)) "null")
-      ((and (dict? x) (= (get x "clos-type") "instance")) (get x "class"))
-      (:else "t"))))
-
-;; ── subclass-of? ──────────────────────────────────────────────────────────
-;;
-;; Captures clos-class-registry at define time to avoid free-variable issues.
-
-(define
-  clos-subclass-of?
-  (let
-    ((registry clos-class-registry))
-    (fn
-      (class-name super-name)
-      (if
-        (= class-name super-name)
-        true
-        (let
-          ((rec (get registry class-name)))
-          (if
-            (nil? rec)
-            false
-            (some
-              (fn (p) (clos-subclass-of? p super-name))
-              (get rec "parents"))))))))
-
-;; ── instance-of? ──────────────────────────────────────────────────────────
-
-(define
-  clos-instance-of?
-  (fn (obj class-name) (clos-subclass-of? (clos-class-of obj) class-name)))
-
-;; ── defclass ──────────────────────────────────────────────────────────────
-;;
-;; slot-specs: list of dicts with keys: name initarg initform accessor reader writer
-;; Each missing key defaults to nil.
-
-(define clos-slot-spec (fn (spec) (if (string? spec) {:initform nil :initarg nil :reader nil :writer nil :accessor nil :name spec} spec)))
-
-(define
-  clos-defclass
-  (fn
-    (name parents slot-specs)
-    (let
-      ((slots (dict)))
-      (for-each
-        (fn
-          (pname)
-          (let
-            ((prec (get clos-class-registry pname)))
-            (when
-              (not (nil? prec))
-              (for-each
-                (fn
-                  (k)
-                  (when
-                    (nil? (get slots k))
-                    (dict-set! slots k (get (get prec "slots") k))))
-                (keys (get prec "slots"))))))
-        parents)
-      (for-each
-        (fn
-          (s)
-          (let
-            ((spec (clos-slot-spec s)))
-            (dict-set! slots (get spec "name") spec)))
-        slot-specs)
-      (let
-        ((class-rec {:parents parents :clos-type "class" :slots slots :methods (list) :name name}))
-        (dict-set! clos-class-registry name class-rec)
-        (clos-install-accessors-for name slots)
-        name))))
-
-;; ── accessor installation (forward-declared, defined after defmethod) ──────
-
-(define
-  clos-install-accessors-for
-  (fn
-    (class-name slots)
-    (for-each
-      (fn
-        (k)
-        (let
-          ((spec (get slots k)))
-          (let
-            ((reader (get spec "reader")))
-            (when
-              (not (nil? reader))
-              (clos-add-reader-method reader class-name k)))
-          (let
-            ((accessor (get spec "accessor")))
-            (when
-              (not (nil? accessor))
-              (clos-add-reader-method accessor class-name k)))))
-      (keys slots))))
-
-;; placeholder — real impl filled in after defmethod is defined
-(define clos-add-reader-method (fn (method-name class-name slot-name) nil))
-
-;; ── make-instance ─────────────────────────────────────────────────────────
-
-(define
-  clos-make-instance
-  (fn
-    (class-name &rest initargs)
-    (let
-      ((class-rec (get clos-class-registry class-name)))
-      (if
-        (nil? class-rec)
-        (error (str "No class named: " class-name))
-        (let
-          ((slots (dict)))
-          (for-each
-            (fn
-              (k)
-              (let
-                ((spec (get (get class-rec "slots") k)))
-                (let
-                  ((initform (get spec "initform")))
-                  (when
-                    (not (nil? initform))
-                    (dict-set!
-                      slots
-                      k
-                      (if (callable? initform) (initform) initform))))))
-            (keys (get class-rec "slots")))
-          (define
-            apply-args
-            (fn
-              (args)
-              (when
-                (>= (len args) 2)
-                (let
-                  ((key (str (first args))) (val (first (rest args))))
-                  (let
-                    ((skey (if (= (slice key 0 1) ":") (slice key 1 (len key)) key)))
-                    (let
-                      ((matched false))
-                      (for-each
-                        (fn
-                          (sk)
-                          (let
-                            ((spec (get (get class-rec "slots") sk)))
-                            (let
-                              ((ia (get spec "initarg")))
-                              (when
-                                (or
-                                  (= ia key)
-                                  (= ia (str ":" skey))
-                                  (= sk skey))
-                                (dict-set! slots sk val)
-                                (set! matched true)))))
-                        (keys (get class-rec "slots")))))
-                  (apply-args (rest (rest args)))))))
-          (apply-args initargs)
-          {:clos-type "instance" :slots slots :class class-name})))))
-
-;; ── slot-value ────────────────────────────────────────────────────────────
-
-(define
-  clos-slot-value
-  (fn
-    (instance slot-name)
-    (if
-      (and (dict? instance) (= (get instance "clos-type") "instance"))
-      (get (get instance "slots") slot-name)
-      (error (str "Not a CLOS instance: " (inspect instance))))))
-
-(define
-  clos-set-slot-value!
-  (fn
-    (instance slot-name value)
-    (if
-      (and (dict? instance) (= (get instance "clos-type") "instance"))
-      (dict-set! (get instance "slots") slot-name value)
-      (error (str "Not a CLOS instance: " (inspect instance))))))
-
-(define
-  clos-slot-boundp
-  (fn
-    (instance slot-name)
-    (and
-      (dict? instance)
-      (= (get instance "clos-type") "instance")
-      (not (nil? (get (get instance "slots") slot-name))))))
-
-;; ── find-class / change-class ─────────────────────────────────────────────
-
-(define clos-find-class (fn (name) (get clos-class-registry name)))
-
-(define
-  clos-change-class!
-  (fn
-    (instance new-class-name)
-    (if
-      (and (dict? instance) (= (get instance "clos-type") "instance"))
-      (dict-set! instance "class" new-class-name)
-      (error (str "Not a CLOS instance: " (inspect instance))))))
-
-;; ── defgeneric ────────────────────────────────────────────────────────────
-
-(define
-  clos-defgeneric
-  (fn
-    (name options)
-    (let
-      ((combination (or (get options "method-combination") "standard")))
-      (when
-        (nil? (get clos-generic-registry name))
-        (dict-set! clos-generic-registry name {:methods (list) :combination combination :name name}))
-      name)))
-
-;; ── defmethod ─────────────────────────────────────────────────────────────
-;;
-;; method-fn: (fn (args next-fn) body)
-;;   args = list of all call arguments
-;;   next-fn = (fn () next-method-result) or nil
-
-(define
-  clos-defmethod
-  (fn
-    (generic-name qualifiers specializers method-fn)
-    (when
-      (nil? (get clos-generic-registry generic-name))
-      (clos-defgeneric generic-name {}))
-    (let
-      ((grec (get clos-generic-registry generic-name))
-        (new-method {:fn method-fn :qualifiers qualifiers :specializers specializers}))
-      (let
-        ((kept (filter (fn (m) (not (and (= (get m "qualifiers") qualifiers) (= (get m "specializers") specializers)))) (get grec "methods"))))
-        (dict-set!
-          clos-generic-registry
-          generic-name
-          (assoc grec "methods" (append kept (list new-method))))
-        generic-name))))
-
-;; Now install the real accessor-method installer
-(set!
-  clos-add-reader-method
-  (fn
-    (method-name class-name slot-name)
-    (clos-defmethod
-      method-name
-      (list)
-      (list class-name)
-      (fn (args next-fn) (clos-slot-value (first args) slot-name)))))
-
-;; ── method specificity ─────────────────────────────────────────────────────
-
-(define
-  clos-method-matches?
-  (fn
-    (method args)
-    (let
-      ((specs (get method "specializers")))
-      (if
-        (> (len specs) (len args))
-        false
-        (define
-          check-all
-          (fn
-            (i)
-            (if
-              (>= i (len specs))
-              true
-              (let
-                ((spec (nth specs i)) (arg (nth args i)))
-                (if
-                  (= spec "t")
-                  (check-all (+ i 1))
-                  (if
-                    (clos-instance-of? arg spec)
-                    (check-all (+ i 1))
-                    false))))))
-        (check-all 0)))))
-
-;; Precedence distance: how far class-name is from spec-name up the hierarchy.
-(define
-  clos-specificity
-  (let
-    ((registry clos-class-registry))
-    (fn
-      (class-name spec-name)
-      (define
-        walk
-        (fn
-          (cn depth)
-          (if
-            (= cn spec-name)
-            depth
-            (let
-              ((rec (get registry cn)))
-              (if
-                (nil? rec)
-                nil
-                (let
-                  ((results (map (fn (p) (walk p (+ depth 1))) (get rec "parents"))))
-                  (let
-                    ((non-nil (filter (fn (x) (not (nil? x))) results)))
-                    (if
-                      (empty? non-nil)
-                      nil
-                      (reduce
-                        (fn (a b) (if (< a b) a b))
-                        (first non-nil)
-                        (rest non-nil))))))))))
-      (walk class-name 0))))
-
-(define
-  clos-method-more-specific?
-  (fn
-    (m1 m2 args)
-    (let
-      ((s1 (get m1 "specializers")) (s2 (get m2 "specializers")))
-      (define
-        cmp
-        (fn
-          (i)
-          (if
-            (>= i (len s1))
-            false
-            (let
-              ((c1 (clos-specificity (clos-class-of (nth args i)) (nth s1 i)))
-                (c2
-                  (clos-specificity (clos-class-of (nth args i)) (nth s2 i))))
-              (cond
-                ((and (nil? c1) (nil? c2)) (cmp (+ i 1)))
-                ((nil? c1) false)
-                ((nil? c2) true)
-                ((< c1 c2) true)
-                ((> c1 c2) false)
-                (:else (cmp (+ i 1))))))))
-      (cmp 0))))
-
-(define
-  clos-sort-methods
-  (fn
-    (methods args)
-    (define
-      insert
-      (fn
-        (m sorted)
-        (if
-          (empty? sorted)
-          (list m)
-          (if
-            (clos-method-more-specific? m (first sorted) args)
-            (cons m sorted)
-            (cons (first sorted) (insert m (rest sorted)))))))
-    (reduce (fn (acc m) (insert m acc)) (list) methods)))
-
-;; ── call-generic (standard method combination) ─────────────────────────────
-
-(define
-  clos-call-generic
-  (fn
-    (generic-name args)
-    (let
-      ((grec (get clos-generic-registry generic-name)))
-      (if
-        (nil? grec)
-        (error (str "No generic function: " generic-name))
-        (let
-          ((applicable (filter (fn (m) (clos-method-matches? m args)) (get grec "methods"))))
-          (if
-            (empty? applicable)
-            (error
-              (str
-                "No applicable method for "
-                generic-name
-                " with classes "
-                (inspect (map clos-class-of args))))
-            (let
-              ((primary (filter (fn (m) (empty? (get m "qualifiers"))) applicable))
-                (before
-                  (filter
-                    (fn (m) (= (get m "qualifiers") (list "before")))
-                    applicable))
-                (after
-                  (filter
-                    (fn (m) (= (get m "qualifiers") (list "after")))
-                    applicable))
-                (around
-                  (filter
-                    (fn (m) (= (get m "qualifiers") (list "around")))
-                    applicable)))
-              (let
-                ((sp (clos-sort-methods primary args))
-                  (sb (clos-sort-methods before args))
-                  (sa (clos-sort-methods after args))
-                  (sw (clos-sort-methods around args)))
-                (define
-                  make-primary-chain
-                  (fn
-                    (methods)
-                    (if
-                      (empty? methods)
-                      (fn
-                        ()
-                        (error (str "No next primary method: " generic-name)))
-                      (fn
-                        ()
-                        ((get (first methods) "fn")
-                          args
-                          (make-primary-chain (rest methods)))))))
-                (define
-                  make-around-chain
-                  (fn
-                    (around-methods inner-thunk)
-                    (if
-                      (empty? around-methods)
-                      inner-thunk
-                      (fn
-                        ()
-                        ((get (first around-methods) "fn")
-                          args
-                          (make-around-chain
-                            (rest around-methods)
-                            inner-thunk))))))
-                (for-each (fn (m) ((get m "fn") args (fn () nil))) sb)
-                (let
-                  ((primary-thunk (make-primary-chain sp)))
-                  (let
-                    ((result (if (empty? sw) (primary-thunk) ((make-around-chain sw primary-thunk)))))
-                    (for-each
-                      (fn (m) ((get m "fn") args (fn () nil)))
-                      (reverse sa))
-                    result))))))))))
-
-;; ── call-next-method / next-method-p ──────────────────────────────────────
-
-(define clos-call-next-method (fn (next-fn) (next-fn)))
-
-(define clos-next-method-p (fn (next-fn) (not (nil? next-fn))))
-
-;; ── with-slots ────────────────────────────────────────────────────────────
-
-(define
-  clos-with-slots
-  (fn
-    (instance slot-names body-fn)
-    (let
-      ((vals (map (fn (s) (clos-slot-value instance s)) slot-names)))
-      (apply body-fn vals))))

lib/common-lisp/conformance.sh

@@ -1,161 +0,0 @@
-#!/usr/bin/env bash
-# lib/common-lisp/conformance.sh — CL-on-SX conformance test runner
-#
-# Runs all Common Lisp test suites and writes scoreboard.json + scoreboard.md.
-#
-# Usage:
-#   bash lib/common-lisp/conformance.sh
-#   bash lib/common-lisp/conformance.sh -v
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-TOTAL_PASS=0; TOTAL_FAIL=0
-SUITE_NAMES=()
-SUITE_PASS=()
-SUITE_FAIL=()
-
-# run_suite NAME "file1 file2 ..." PASS_VAR FAIL_VAR FAILURES_VAR
-run_suite() {
-  local name="$1" load_files="$2" pass_var="$3" fail_var="$4" failures_var="$5"
-  local TMP; TMP=$(mktemp)
-  {
-    printf '(epoch 1)\n(load "spec/stdlib.sx")\n'
-    local i=2
-    for f in $load_files; do
-      printf '(epoch %d)\n(load "%s")\n' "$i" "$f"
-      i=$((i+1))
-    done
-    printf '(epoch 100)\n(eval "%s")\n' "$pass_var"
-    printf '(epoch 101)\n(eval "%s")\n' "$fail_var"
-  } > "$TMP"
-  local OUT; OUT=$(timeout 30 "$SX_SERVER" < "$TMP" 2>/dev/null)
-  rm -f "$TMP"
-  local P F
-  P=$(echo "$OUT" | grep -A1 "^(ok-len 100 " | tail -1 | tr -d ' ()' || true)
-  F=$(echo "$OUT" | grep -A1 "^(ok-len 101 " | tail -1 | tr -d ' ()' || true)
-  # Also try plain (ok 100 N) format
-  [ -z "$P" ] && P=$(echo "$OUT" | grep "^(ok 100 " | awk '{print $3}' | tr -d ')' || true)
-  [ -z "$F" ] && F=$(echo "$OUT" | grep "^(ok 101 " | awk '{print $3}' | tr -d ')' || true)
-  [ -z "$P" ] && P=0; [ -z "$F" ] && F=0
-  SUITE_NAMES+=("$name")
-  SUITE_PASS+=("$P")
-  SUITE_FAIL+=("$F")
-  TOTAL_PASS=$((TOTAL_PASS + P))
-  TOTAL_FAIL=$((TOTAL_FAIL + F))
-  if [ "$F" = "0" ] && [ "${P:-0}" -gt 0 ] 2>/dev/null; then
-    echo "  PASS  $name ($P tests)"
-  else
-    echo "  FAIL  $name ($P passed, $F failed)"
-  fi
-}
-
-echo "=== Common Lisp on SX — Conformance Run ==="
-echo ""
-
-run_suite "Phase 1: tokenizer/reader" \
-  "lib/common-lisp/reader.sx lib/common-lisp/tests/read.sx" \
-  "cl-test-pass" "cl-test-fail" "cl-test-fails"
-
-run_suite "Phase 1: parser/lambda-lists" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/tests/lambda.sx" \
-  "cl-test-pass" "cl-test-fail" "cl-test-fails"
-
-run_suite "Phase 2: evaluator" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/tests/eval.sx" \
-  "cl-test-pass" "cl-test-fail" "cl-test-fails"
-
-run_suite "Phase 3: condition system" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/conditions.sx" \
-  "passed" "failed" "failures"
-
-run_suite "Phase 3: restart-demo" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/programs/restart-demo.sx" \
-  "demo-passed" "demo-failed" "demo-failures"
-
-run_suite "Phase 3: parse-recover" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/programs/parse-recover.sx" \
-  "parse-passed" "parse-failed" "parse-failures"
-
-run_suite "Phase 3: interactive-debugger" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/programs/interactive-debugger.sx" \
-  "debugger-passed" "debugger-failed" "debugger-failures"
-
-run_suite "Phase 4: CLOS" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/clos.sx lib/common-lisp/tests/clos.sx" \
-  "passed" "failed" "failures"
-
-run_suite "Phase 4: geometry" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/clos.sx lib/common-lisp/tests/programs/geometry.sx" \
-  "geo-passed" "geo-failed" "geo-failures"
-
-run_suite "Phase 4: mop-trace" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/clos.sx lib/common-lisp/tests/programs/mop-trace.sx" \
-  "mop-passed" "mop-failed" "mop-failures"
-
-run_suite "Phase 5: macros+LOOP" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/loop.sx lib/common-lisp/tests/macros.sx" \
-  "macro-passed" "macro-failed" "macro-failures"
-
-run_suite "Phase 6: stdlib" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/tests/stdlib.sx" \
-  "stdlib-passed" "stdlib-failed" "stdlib-failures"
-
-echo ""
-echo "=== Total: $TOTAL_PASS passed, $TOTAL_FAIL failed ==="
-
-# ── write scoreboard.json ─────────────────────────────────────────────────
-
-SCORE_DIR="lib/common-lisp"
-JSON="$SCORE_DIR/scoreboard.json"
-{
-  printf '{\n'
-  printf '  "generated": "%s",\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
-  printf '  "suites": [\n'
-  first=true
-  for i in "${!SUITE_NAMES[@]}"; do
-    if [ "$first" = "true" ]; then first=false; else printf ',\n'; fi
-    printf '    {"name": "%s", "pass": %d, "fail": %d}' \
-      "${SUITE_NAMES[$i]}" "${SUITE_PASS[$i]}" "${SUITE_FAIL[$i]}"
-  done
-  printf '\n  ]\n'
-  printf '}\n'
-} > "$JSON"
-
-# ── write scoreboard.md ───────────────────────────────────────────────────
-
-MD="$SCORE_DIR/scoreboard.md"
-{
-  printf '# Common Lisp on SX — Scoreboard\n\n'
-  printf '_Generated: %s_\n\n' "$(date -u '+%Y-%m-%d %H:%M UTC')"
-  printf '| Suite | Pass | Fail | Status |\n'
-  printf '|-------|------|------|--------|\n'
-  for i in "${!SUITE_NAMES[@]}"; do
-    p="${SUITE_PASS[$i]}" f="${SUITE_FAIL[$i]}"
-    status=""
-    if [ "$f" = "0" ] && [ "${p:-0}" -gt 0 ] 2>/dev/null; then
-      status="pass"
-    else
-      status="FAIL"
-    fi
-    printf '| %s | %s | %s | %s |\n' "${SUITE_NAMES[$i]}" "$p" "$f" "$status"
-  done
-  printf '\n**Total: %d passed, %d failed**\n' "$TOTAL_PASS" "$TOTAL_FAIL"
-} > "$MD"
-
-echo ""
-echo "Scoreboard written to $JSON and $MD"
-
-[ "$TOTAL_FAIL" -eq 0 ]

lib/common-lisp/loop.sx

@@ -1,623 +0,0 @@
-;; lib/common-lisp/loop.sx — The LOOP macro for CL-on-SX
-;;
-;; Supported clauses:
-;;   for VAR in LIST             — iterate over list
-;;   for VAR across VECTOR       — alias for 'in'
-;;   for VAR from N              — numeric iteration (to/upto/below/downto/above/by)
-;;   for VAR = EXPR [then EXPR]  — general iteration
-;;   while COND                  — stop when false
-;;   until COND                  — stop when true
-;;   repeat N                    — repeat N times
-;;   collect EXPR [into VAR]
-;;   append EXPR [into VAR]
-;;   nconc EXPR [into VAR]
-;;   sum EXPR [into VAR]
-;;   count EXPR [into VAR]
-;;   maximize EXPR [into VAR]
-;;   minimize EXPR [into VAR]
-;;   do FORM...
-;;   when/if COND clause...
-;;   unless COND clause...
-;;   finally FORM...
-;;   always COND
-;;   never COND
-;;   thereis COND
-;;   named BLOCK-NAME
-;;
-;; Depends on: lib/common-lisp/runtime.sx, lib/common-lisp/eval.sx already loaded.
-;; Uses defmacro in the CL evaluator.
-
-;; ── LOOP expansion driver ─────────────────────────────────────────────────
-
-;; cl-loop-parse: analyse the flat LOOP clause list and build a Lisp form.
-;; Returns a (block NAME (let (...) (tagbody ...))) form.
-(define
-  cl-loop-parse
-  (fn
-    (clauses)
-    (define block-name nil)
-    (define with-bindings (list))
-    (define for-bindings (list))
-    (define test-forms (list))
-    (define repeat-var nil)
-    (define repeat-count nil)
-    (define body-forms (list))
-    (define accum-vars (dict))
-    (define accum-clauses (dict))
-    (define result-var nil)
-    (define finally-forms (list))
-    (define return-expr nil)
-    (define termination nil)
-    (define idx 0)
-    (define (lp-peek) (if (< idx (len clauses)) (nth clauses idx) nil))
-    (define
-      (next!)
-      (let ((v (lp-peek))) (do (set! idx (+ idx 1)) v)))
-    (define
-      (skip-if pred)
-      (if (and (not (nil? (lp-peek))) (pred (lp-peek))) (next!) nil))
-    (define (upcase-str s) (if (string? s) (upcase s) s))
-    (define (kw? s k) (= (upcase-str s) k))
-    (define
-      (make-accum-var!)
-      (if
-        (nil? result-var)
-        (do (set! result-var "#LOOP-RESULT") result-var)
-        result-var))
-    (define
-      (add-accum! type expr into-var)
-      (let
-        ((v (if (nil? into-var) (make-accum-var!) into-var)))
-        (if
-          (not (has-key? accum-vars v))
-          (do
-            (set!
-              accum-vars
-              (assoc
-                accum-vars
-                v
-                (cond
-                  ((= type ":sum") 0)
-                  ((= type ":count") 0)
-                  ((= type ":maximize") nil)
-                  ((= type ":minimize") nil)
-                  (:else (list)))))
-            (set! accum-clauses (assoc accum-clauses v type))))
-        (let
-          ((update (cond ((= type ":collect") (list "SETQ" v (list "APPEND" v (list "LIST" expr)))) ((= type ":append") (list "SETQ" v (list "APPEND" v expr))) ((= type ":nconc") (list "SETQ" v (list "NCONC" v expr))) ((= type ":sum") (list "SETQ" v (list "+" v expr))) ((= type ":count") (list "SETQ" v (list "+" v (list "IF" expr 1 0)))) ((= type ":maximize") (list "SETQ" v (list "IF" (list "OR" (list "NULL" v) (list ">" expr v)) expr v))) ((= type ":minimize") (list "SETQ" v (list "IF" (list "OR" (list "NULL" v) (list "<" expr v)) expr v))) (:else (list "SETQ" v (list "APPEND" v (list "LIST" expr)))))))
-          (set! body-forms (append body-forms (list update))))))
-    (define
-      (parse-clause!)
-      (let
-        ((tok (lp-peek)))
-        (if
-          (nil? tok)
-          nil
-          (do
-            (let
-              ((u (upcase-str tok)))
-              (cond
-                ((= u "NAMED")
-                  (do (next!) (set! block-name (next!)) (parse-clause!)))
-                ((= u "WITH")
-                  (do
-                    (next!)
-                    (let
-                      ((var (next!)))
-                      (skip-if (fn (s) (kw? s "=")))
-                      (let
-                        ((init (next!)))
-                        (set!
-                          with-bindings
-                          (append with-bindings (list (list var init))))
-                        (parse-clause!)))))
-                ((= u "FOR")
-                  (do
-                    (next!)
-                    (let
-                      ((var (next!)))
-                      (let
-                        ((kw2 (upcase-str (lp-peek))))
-                        (cond
-                          ((or (= kw2 "IN") (= kw2 "ACROSS"))
-                            (do
-                              (next!)
-                              (let
-                                ((lst-expr (next!))
-                                  (tail-var (str "#TAIL-" var)))
-                                (set!
-                                  for-bindings
-                                  (append for-bindings (list {:list lst-expr :tail tail-var :type ":list" :var var})))
-                                (parse-clause!))))
-                          ((= kw2 "=")
-                            (do
-                              (next!)
-                              (let
-                                ((init-expr (next!)))
-                                (let
-                                  ((then-expr (if (kw? (lp-peek) "THEN") (do (next!) (next!)) init-expr)))
-                                  (set!
-                                    for-bindings
-                                    (append for-bindings (list {:type ":general" :then then-expr :init init-expr :var var})))
-                                  (parse-clause!)))))
-                          ((or (= kw2 "FROM") (= kw2 "DOWNFROM") (= kw2 "UPFROM"))
-                            (do
-                              (next!)
-                              (let
-                                ((from-expr (next!))
-                                  (dir (if (= kw2 "DOWNFROM") ":down" ":up"))
-                                  (limit-expr nil)
-                                  (limit-type nil)
-                                  (step-expr 1))
-                                (let
-                                  ((lkw (upcase-str (lp-peek))))
-                                  (when
-                                    (or
-                                      (= lkw "TO")
-                                      (= lkw "UPTO")
-                                      (= lkw "BELOW")
-                                      (= lkw "DOWNTO")
-                                      (= lkw "ABOVE"))
-                                    (do
-                                      (next!)
-                                      (set! limit-type lkw)
-                                      (set! limit-expr (next!)))))
-                                (when
-                                  (kw? (lp-peek) "BY")
-                                  (do (next!) (set! step-expr (next!))))
-                                (set!
-                                  for-bindings
-                                  (append for-bindings (list {:dir dir :step step-expr :from from-expr :type ":numeric" :limit-type limit-type :var var :limit limit-expr})))
-                                (parse-clause!))))
-                          ((or (= kw2 "TO") (= kw2 "UPTO") (= kw2 "BELOW"))
-                            (do
-                              (next!)
-                              (let
-                                ((limit-expr (next!))
-                                  (step-expr 1))
-                                (when
-                                  (kw? (lp-peek) "BY")
-                                  (do (next!) (set! step-expr (next!))))
-                                (set!
-                                  for-bindings
-                                  (append for-bindings (list {:dir ":up" :step step-expr :from 0 :type ":numeric" :limit-type kw2 :var var :limit limit-expr})))
-                                (parse-clause!))))
-                          (:else (do (parse-clause!))))))))
-                ((= u "WHILE")
-                  (do
-                    (next!)
-                    (set! test-forms (append test-forms (list {:expr (next!) :type ":while"})))
-                    (parse-clause!)))
-                ((= u "UNTIL")
-                  (do
-                    (next!)
-                    (set! test-forms (append test-forms (list {:expr (next!) :type ":until"})))
-                    (parse-clause!)))
-                ((= u "REPEAT")
-                  (do
-                    (next!)
-                    (set! repeat-count (next!))
-                    (set! repeat-var "#REPEAT-COUNT")
-                    (parse-clause!)))
-                ((or (= u "COLLECT") (= u "COLLECTING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":collect" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "APPEND") (= u "APPENDING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":append" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "NCONC") (= u "NCONCING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":nconc" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "SUM") (= u "SUMMING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":sum" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "COUNT") (= u "COUNTING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":count" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "MAXIMIZE") (= u "MAXIMIZING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":maximize" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "MINIMIZE") (= u "MINIMIZING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":minimize" expr into-var)
-                      (parse-clause!))))
-                ((= u "DO")
-                  (do
-                    (next!)
-                    (define
-                      (loop-kw? s)
-                      (let
-                        ((us (upcase-str s)))
-                        (some
-                          (fn (k) (= us k))
-                          (list
-                            "FOR"
-                            "WITH"
-                            "WHILE"
-                            "UNTIL"
-                            "REPEAT"
-                            "COLLECT"
-                            "COLLECTING"
-                            "APPEND"
-                            "APPENDING"
-                            "NCONC"
-                            "NCONCING"
-                            "SUM"
-                            "SUMMING"
-                            "COUNT"
-                            "COUNTING"
-                            "MAXIMIZE"
-                            "MAXIMIZING"
-                            "MINIMIZE"
-                            "MINIMIZING"
-                            "DO"
-                            "WHEN"
-                            "IF"
-                            "UNLESS"
-                            "FINALLY"
-                            "ALWAYS"
-                            "NEVER"
-                            "THEREIS"
-                            "RETURN"
-                            "NAMED"))))
-                    (define
-                      (collect-do-forms!)
-                      (if
-                        (or (nil? (lp-peek)) (loop-kw? (lp-peek)))
-                        nil
-                        (do
-                          (set!
-                            body-forms
-                            (append body-forms (list (next!))))
-                          (collect-do-forms!))))
-                    (collect-do-forms!)
-                    (parse-clause!)))
-                ((or (= u "WHEN") (= u "IF"))
-                  (do
-                    (next!)
-                    (let
-                      ((cond-expr (next!))
-                       (body-start (len body-forms)))
-                      (parse-clause!)
-                      ;; wrap forms added since body-start in (WHEN cond ...)
-                      (when (> (len body-forms) body-start)
-                        (let ((added (list (nth body-forms body-start))))
-                          (set! body-forms
-                            (append
-                              (if (> body-start 0)
-                                (list (nth body-forms (- body-start 1)))
-                                (list))
-                              (list (list "WHEN" cond-expr (first added)))))
-                          nil)))))
-                ((= u "UNLESS")
-                  (do
-                    (next!)
-                    (let
-                      ((cond-expr (next!))
-                       (body-start (len body-forms)))
-                      (parse-clause!)
-                      (when (> (len body-forms) body-start)
-                        (let ((added (list (nth body-forms body-start))))
-                          (set! body-forms
-                            (append
-                              (if (> body-start 0)
-                                (list (nth body-forms (- body-start 1)))
-                                (list))
-                              (list (list "UNLESS" cond-expr (first added)))))
-                          nil)))))
-                ((= u "ALWAYS")
-                  (do (next!) (set! termination {:expr (next!) :type ":always"}) (parse-clause!)))
-                ((= u "NEVER")
-                  (do (next!) (set! termination {:expr (next!) :type ":never"}) (parse-clause!)))
-                ((= u "THEREIS")
-                  (do (next!) (set! termination {:expr (next!) :type ":thereis"}) (parse-clause!)))
-                ((= u "RETURN")
-                  (do (next!) (set! return-expr (next!)) (parse-clause!)))
-                ((= u "FINALLY")
-                  (do
-                    (next!)
-                    (define
-                      (collect-finally!)
-                      (if
-                        (nil? (lp-peek))
-                        nil
-                        (do
-                          (set!
-                            finally-forms
-                            (append finally-forms (list (next!))))
-                          (collect-finally!))))
-                    (collect-finally!)
-                    (parse-clause!)))
-                (:else
-                  (do
-                    (set! body-forms (append body-forms (list (next!))))
-                    (parse-clause!)))))))))
-    (parse-clause!)
-    (define let-bindings (list))
-    (for-each
-      (fn (wb) (set! let-bindings (append let-bindings (list wb))))
-      with-bindings)
-    (for-each
-      (fn
-        (v)
-        (set!
-          let-bindings
-          (append let-bindings (list (list v (get accum-vars v))))))
-      (keys accum-vars))
-    (when
-      (not (nil? repeat-var))
-      (set!
-        let-bindings
-        (append let-bindings (list (list repeat-var repeat-count)))))
-    (for-each
-      (fn
-        (fb)
-        (let
-          ((type (get fb "type")))
-          (cond
-            ((= type ":list")
-              (do
-                (set!
-                  let-bindings
-                  (append
-                    let-bindings
-                    (list (list (get fb "tail") (get fb "list")))
-                    (list
-                      (list
-                        (get fb "var")
-                        (list
-                          "IF"
-                          (list "CONSP" (get fb "tail"))
-                          (list "CAR" (get fb "tail"))
-                          nil)))))
-                nil))
-            ((= type ":numeric")
-              (set!
-                let-bindings
-                (append
-                  let-bindings
-                  (list (list (get fb "var") (get fb "from"))))))
-            ((= type ":general")
-              (set!
-                let-bindings
-                (append
-                  let-bindings
-                  (list (list (get fb "var") (get fb "init"))))))
-            (:else nil))))
-      for-bindings)
-    (define all-tests (list))
-    (when
-      (not (nil? repeat-var))
-      (set!
-        all-tests
-        (append
-          all-tests
-          (list
-            (list
-              "WHEN"
-              (list "<=" repeat-var 0)
-              (list "RETURN-FROM" block-name (if (nil? result-var) nil result-var))))))
-      (set!
-        body-forms
-        (append
-          (list (list "SETQ" repeat-var (list "-" repeat-var 1)))
-          body-forms)))
-    (for-each
-      (fn
-        (fb)
-        (when
-          (= (get fb "type") ":list")
-          (let
-            ((tvar (get fb "tail")) (var (get fb "var")))
-            (set!
-              all-tests
-              (append
-                all-tests
-                (list
-                  (list
-                    "WHEN"
-                    (list "NULL" tvar)
-                    (list
-                      "RETURN-FROM"
-                      block-name
-                      (if (nil? result-var) nil result-var))))))
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "SETQ" tvar (list "CDR" tvar))
-                  (list
-                    "SETQ"
-                    var
-                    (list "IF" (list "CONSP" tvar) (list "CAR" tvar) nil))))))))
-      for-bindings)
-    (for-each
-      (fn
-        (fb)
-        (when
-          (= (get fb "type") ":numeric")
-          (let
-            ((var (get fb "var"))
-              (dir (get fb "dir"))
-              (lim (get fb "limit"))
-              (ltype (get fb "limit-type"))
-              (step (get fb "step")))
-            (when
-              (not (nil? lim))
-              (let
-                ((test-op (cond ((or (= ltype "BELOW") (= ltype "ABOVE")) (if (= dir ":up") ">=" "<=")) ((or (= ltype "TO") (= ltype "UPTO")) ">") ((= ltype "DOWNTO") "<") (:else (if (= dir ":up") ">" "<")))))
-                (set!
-                  all-tests
-                  (append
-                    all-tests
-                    (list
-                      (list
-                        "WHEN"
-                        (list test-op var lim)
-                        (list
-                          "RETURN-FROM"
-                          block-name
-                          (if (nil? result-var) nil result-var))))))))
-            (let
-              ((step-op (if (or (= dir ":down") (= ltype "DOWNTO") (= ltype "ABOVE")) "-" "+")))
-              (set!
-                body-forms
-                (append
-                  body-forms
-                  (list (list "SETQ" var (list step-op var step)))))))))
-      for-bindings)
-    (for-each
-      (fn
-        (fb)
-        (when
-          (= (get fb "type") ":general")
-          (set!
-            body-forms
-            (append
-              body-forms
-              (list (list "SETQ" (get fb "var") (get fb "then")))))))
-      for-bindings)
-    (for-each
-      (fn
-        (t)
-        (let
-          ((type (get t "type")) (expr (get t "expr")))
-          (if
-            (= type ":while")
-            (set!
-              all-tests
-              (append
-                all-tests
-                (list
-                  (list
-                    "WHEN"
-                    (list "NOT" expr)
-                    (list
-                      "RETURN-FROM"
-                      block-name
-                      (if (nil? result-var) nil result-var))))))
-            (set!
-              all-tests
-              (append
-                all-tests
-                (list
-                  (list
-                    "WHEN"
-                    expr
-                    (list
-                      "RETURN-FROM"
-                      block-name
-                      (if (nil? result-var) nil result-var)))))))))
-      test-forms)
-    (when
-      (not (nil? termination))
-      (let
-        ((type (get termination "type")) (expr (get termination "expr")))
-        (cond
-          ((= type ":always")
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "UNLESS" expr (list "RETURN-FROM" block-name false)))))
-            (set! return-expr true))
-          ((= type ":never")
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "WHEN" expr (list "RETURN-FROM" block-name false)))))
-            (set! return-expr true))
-          ((= type ":thereis")
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "WHEN" expr (list "RETURN-FROM" block-name expr)))))))))
-    (define tag "#LOOP-START")
-    (define
-      inner-body
-      (append (list tag) all-tests body-forms (list (list "GO" tag))))
-    (define
-      result-form
-      (cond
-        ((not (nil? return-expr)) return-expr)
-        ((not (nil? result-var)) result-var)
-        (:else nil)))
-    (define
-      full-body
-      (if
-        (= (len let-bindings) 0)
-        (append
-          (list "PROGN")
-          (list (append (list "TAGBODY") inner-body))
-          finally-forms
-          (list result-form))
-        (list
-          "LET*"
-          let-bindings
-          (append (list "TAGBODY") inner-body)
-          (append (list "PROGN") finally-forms (list result-form)))))
-    (list "BLOCK" block-name full-body)))
-
-;; ── Install LOOP as a CL macro ────────────────────────────────────────────
-;;
-;; (loop ...) — the form arrives with head "LOOP" and rest = clauses.
-;; The macro fn receives the full form.
-
-(dict-set!
-  cl-macro-registry
-  "LOOP"
-  (fn (form env) (cl-loop-parse (rest form))))

lib/common-lisp/parser.sx

@@ -1,377 +0,0 @@
-;; Common Lisp reader — converts token stream to CL AST forms.
-;;
-;; Depends on: lib/common-lisp/reader.sx  (cl-tokenize)
-;;
-;; AST representation:
-;;   integer/float         → SX number (or {:cl-type "float"/:ratio ...})
-;;   string "hello"        → {:cl-type "string" :value "hello"}
-;;   symbol FOO            → SX string "FOO"  (upcase)
-;;   symbol NIL            → nil
-;;   symbol T              → true
-;;   :keyword              → {:cl-type "keyword" :name "FOO"}
-;;   #\char                → {:cl-type "char"    :value "a"}
-;;   #:uninterned          → {:cl-type "uninterned" :name "FOO"}
-;;   ratio 1/3             → {:cl-type "ratio"   :value "1/3"}
-;;   float 3.14            → {:cl-type "float"   :value "3.14"}
-;;   proper list (a b c)   → SX list (a b c)
-;;   dotted pair (a . b)   → {:cl-type "cons" :car a :cdr b}
-;;   vector #(a b)         → {:cl-type "vector" :elements (list a b)}
-;;   'x                    → ("QUOTE" x)
-;;   `x                    → ("QUASIQUOTE" x)
-;;   ,x                    → ("UNQUOTE" x)
-;;   ,@x                   → ("UNQUOTE-SPLICING" x)
-;;   #'x                   → ("FUNCTION" x)
-;;
-;; Public API:
-;;   (cl-read src)         — parse first form from string, return form
-;;   (cl-read-all src)     — parse all top-level forms, return list
-
-;; ── number conversion ─────────────────────────────────────────────
-
-(define
-  cl-hex-val
-  (fn
-    (c)
-    (let
-      ((o (cl-ord c)))
-      (cond
-        ((and (>= o 48) (<= o 57)) (- o 48))
-        ((and (>= o 65) (<= o 70)) (+ 10 (- o 65)))
-        ((and (>= o 97) (<= o 102)) (+ 10 (- o 97)))
-        (:else 0)))))
-
-(define
-  cl-parse-radix-str
-  (fn
-    (s radix start)
-    (let
-      ((n (string-length s)) (i start) (acc 0))
-      (define
-        loop
-        (fn
-          ()
-          (when
-            (< i n)
-            (do
-              (set! acc (+ (* acc radix) (cl-hex-val (substring s i (+ i 1)))))
-              (set! i (+ i 1))
-              (loop)))))
-      (loop)
-      acc)))
-
-(define
-  cl-convert-integer
-  (fn
-    (s)
-    (let
-      ((n (string-length s)) (neg false))
-      (cond
-        ((and (> n 2) (= (substring s 0 1) "#"))
-          (let
-            ((letter (downcase (substring s 1 2))))
-            (cond
-              ((= letter "x") (cl-parse-radix-str s 16 2))
-              ((= letter "b") (cl-parse-radix-str s 2 2))
-              ((= letter "o") (cl-parse-radix-str s 8 2))
-              (:else (parse-int s 0)))))
-        (:else (parse-int s 0))))))
-
-;; ── reader ────────────────────────────────────────────────────────
-
-;; Read one form from token list.
-;; Returns {:form F :rest remaining-toks} or {:form nil :rest toks :eof true}
-(define
-  cl-read-form
-  (fn
-    (toks)
-    (if
-      (not toks)
-      {:form nil :rest toks :eof true}
-      (let
-        ((tok (nth toks 0)) (nxt (rest toks)))
-        (let
-          ((type (get tok "type")) (val (get tok "value")))
-          (cond
-            ((= type "eof") {:form nil :rest toks :eof true})
-            ((= type "integer") {:form (cl-convert-integer val) :rest nxt})
-            ((= type "float") {:form {:cl-type "float" :value val} :rest nxt})
-            ((= type "ratio") {:form {:cl-type "ratio" :value val} :rest nxt})
-            ((= type "string") {:form {:cl-type "string" :value val} :rest nxt})
-            ((= type "char") {:form {:cl-type "char" :value val} :rest nxt})
-            ((= type "keyword") {:form {:cl-type "keyword" :name val} :rest nxt})
-            ((= type "uninterned") {:form {:cl-type "uninterned" :name val} :rest nxt})
-            ((= type "symbol")
-              (cond
-                ((= val "NIL") {:form nil :rest nxt})
-                ((= val "T") {:form true :rest nxt})
-                (:else {:form val :rest nxt})))
-            ;; list forms
-            ((= type "lparen") (cl-read-list nxt))
-            ((= type "hash-paren") (cl-read-vector nxt))
-            ;; reader macros that wrap the next form
-            ((= type "quote") (cl-read-wrap "QUOTE" nxt))
-            ((= type "backquote") (cl-read-wrap "QUASIQUOTE" nxt))
-            ((= type "comma") (cl-read-wrap "UNQUOTE" nxt))
-            ((= type "comma-at") (cl-read-wrap "UNQUOTE-SPLICING" nxt))
-            ((= type "hash-quote") (cl-read-wrap "FUNCTION" nxt))
-            ;; skip unrecognised tokens
-            (:else (cl-read-form nxt))))))))
-
-;; Wrap next form in a list: (name form)
-(define
-  cl-read-wrap
-  (fn
-    (name toks)
-    (let
-      ((inner (cl-read-form toks)))
-      {:form (list name (get inner "form")) :rest (get inner "rest")})))
-
-;; Read list forms until ')'; handles dotted pair (a . b)
-;; Called after consuming '('
-(define
-  cl-read-list
-  (fn
-    (toks)
-    (let
-      ((result (cl-read-list-items toks (list))))
-      {:form (get result "items") :rest (get result "rest")})))
-
-(define
-  cl-read-list-items
-  (fn
-    (toks acc)
-    (if
-      (not toks)
-      {:items acc :rest toks}
-      (let
-        ((tok (nth toks 0)))
-        (let
-          ((type (get tok "type")))
-          (cond
-            ((= type "eof") {:items acc :rest toks})
-            ((= type "rparen") {:items acc :rest (rest toks)})
-            ;; dotted pair: read one more form then expect ')'
-            ((= type "dot")
-              (let
-                ((cdr-result (cl-read-form (rest toks))))
-                (let
-                  ((cdr-form (get cdr-result "form"))
-                    (after-cdr (get cdr-result "rest")))
-                  ;; skip the closing ')'
-                  (let
-                    ((close (if after-cdr (nth after-cdr 0) nil)))
-                    (let
-                      ((remaining
-                          (if
-                            (and close (= (get close "type") "rparen"))
-                            (rest after-cdr)
-                            after-cdr)))
-                      ;; build dotted structure
-                      (let
-                        ((dotted (cl-build-dotted acc cdr-form)))
-                        {:items dotted :rest remaining}))))))
-            (:else
-              (let
-                ((item (cl-read-form toks)))
-                (cl-read-list-items
-                  (get item "rest")
-                  (concat acc (list (get item "form"))))))))))))
-
-;; Build dotted form: (a b . c) → ((DOTTED a b) . c) style
-;; In CL (a b c . d) means a proper dotted structure.
-;; We represent it as {:cl-type "cons" :car a :cdr (list->dotted b c d)}
-(define
-  cl-build-dotted
-  (fn
-    (head-items tail)
-    (if
-      (= (len head-items) 0)
-      tail
-      (if
-        (= (len head-items) 1)
-        {:cl-type "cons" :car (nth head-items 0) :cdr tail}
-        (let
-          ((last-item (nth head-items (- (len head-items) 1)))
-            (but-last (slice head-items 0 (- (len head-items) 1))))
-          {:cl-type "cons"
-            :car (cl-build-dotted but-last (list last-item))
-            :cdr tail})))))
-
-;; Read vector #(…) elements until ')'
-(define
-  cl-read-vector
-  (fn
-    (toks)
-    (let
-      ((result (cl-read-vector-items toks (list))))
-      {:form {:cl-type "vector" :elements (get result "items")} :rest (get result "rest")})))
-
-(define
-  cl-read-vector-items
-  (fn
-    (toks acc)
-    (if
-      (not toks)
-      {:items acc :rest toks}
-      (let
-        ((tok (nth toks 0)))
-        (let
-          ((type (get tok "type")))
-          (cond
-            ((= type "eof") {:items acc :rest toks})
-            ((= type "rparen") {:items acc :rest (rest toks)})
-            (:else
-              (let
-                ((item (cl-read-form toks)))
-                (cl-read-vector-items
-                  (get item "rest")
-                  (concat acc (list (get item "form"))))))))))))
-
-;; ── lambda-list parser ───────────────────────────────────────────
-;;
-;; (cl-parse-lambda-list forms) — parse a list of CL forms (already read)
-;; into a structured dict:
-;;   {:required (list sym ...)
-;;    :optional (list {:name N :default D :supplied S} ...)
-;;    :rest     nil | "SYM"
-;;    :key      (list {:name N :keyword K :default D :supplied S} ...)
-;;    :allow-other-keys false | true
-;;    :aux      (list {:name N :init I} ...)}
-;;
-;; Symbols arrive as SX strings (upcase). &-markers are strings like "&OPTIONAL".
-;; Key params: keyword is the upcase name string; caller uses it as :keyword.
-;; Supplied-p: nil when absent.
-
-(define
-  cl-parse-opt-spec
-  (fn
-    (spec)
-    (if
-      (list? spec)
-      {:name (nth spec 0)
-        :default (if (> (len spec) 1) (nth spec 1) nil)
-        :supplied (if (> (len spec) 2) (nth spec 2) nil)}
-      {:name spec :default nil :supplied nil})))
-
-(define
-  cl-parse-key-spec
-  (fn
-    (spec)
-    (if
-      (list? spec)
-      (let
-        ((first (nth spec 0)))
-        (if
-          (list? first)
-          ;; ((:keyword var) default supplied-p)
-          {:name (nth first 1)
-            :keyword (get first "name")
-            :default (if (> (len spec) 1) (nth spec 1) nil)
-            :supplied (if (> (len spec) 2) (nth spec 2) nil)}
-          ;; (var default supplied-p)
-          {:name first
-            :keyword first
-            :default (if (> (len spec) 1) (nth spec 1) nil)
-            :supplied (if (> (len spec) 2) (nth spec 2) nil)}))
-      {:name spec :keyword spec :default nil :supplied nil})))
-
-(define
-  cl-parse-aux-spec
-  (fn
-    (spec)
-    (if
-      (list? spec)
-      {:name (nth spec 0) :init (if (> (len spec) 1) (nth spec 1) nil)}
-      {:name spec :init nil})))
-
-(define
-  cl-parse-lambda-list
-  (fn
-    (forms)
-    (let
-      ((state "required")
-        (required (list))
-        (optional (list))
-        (rest-name nil)
-        (key (list))
-        (allow-other-keys false)
-        (aux (list)))
-
-      (define
-        scan
-        (fn
-          (items)
-          (when
-            (> (len items) 0)
-            (let
-              ((item (nth items 0)) (tail (rest items)))
-              (cond
-                ((= item "&OPTIONAL")
-                  (do (set! state "optional") (scan tail)))
-                ((= item "&REST")
-                  (do (set! state "rest") (scan tail)))
-                ((= item "&BODY")
-                  (do (set! state "rest") (scan tail)))
-                ((= item "&KEY")
-                  (do (set! state "key") (scan tail)))
-                ((= item "&AUX")
-                  (do (set! state "aux") (scan tail)))
-                ((= item "&ALLOW-OTHER-KEYS")
-                  (do (set! allow-other-keys true) (scan tail)))
-                ((= state "required")
-                  (do (append! required item) (scan tail)))
-                ((= state "optional")
-                  (do (append! optional (cl-parse-opt-spec item)) (scan tail)))
-                ((= state "rest")
-                  (do (set! rest-name item) (set! state "done") (scan tail)))
-                ((= state "key")
-                  (do (append! key (cl-parse-key-spec item)) (scan tail)))
-                ((= state "aux")
-                  (do (append! aux (cl-parse-aux-spec item)) (scan tail)))
-                (:else (scan tail)))))))
-
-      (scan forms)
-      {:required required
-        :optional optional
-        :rest rest-name
-        :key key
-        :allow-other-keys allow-other-keys
-        :aux aux})))
-
-;; Convenience: parse lambda list from a CL source string
-(define
-  cl-parse-lambda-list-str
-  (fn
-    (src)
-    (cl-parse-lambda-list (cl-read src))))
-
-;; ── public API ────────────────────────────────────────────────────
-
-(define
-  cl-read
-  (fn
-    (src)
-    (let
-      ((toks (cl-tokenize src)))
-      (get (cl-read-form toks) "form"))))
-
-(define
-  cl-read-all
-  (fn
-    (src)
-    (let
-      ((toks (cl-tokenize src)))
-      (define
-        loop
-        (fn
-          (toks acc)
-          (if
-            (or (not toks) (= (get (nth toks 0) "type") "eof"))
-            acc
-            (let
-              ((result (cl-read-form toks)))
-              (if
-                (get result "eof")
-                acc
-                (loop (get result "rest") (concat acc (list (get result "form")))))))))
-      (loop toks (list)))))

lib/common-lisp/reader.sx

@@ -1,381 +0,0 @@
-;; Common Lisp tokenizer
-;;
-;; Tokens: {:type T :value V :pos P}
-;;
-;; Types:
-;;   "symbol"      — FOO, PKG:SYM, PKG::SYM, T, NIL (upcase)
-;;   "keyword"     — :foo (value is upcase name without colon)
-;;   "integer"     — 42, -5, #xFF, #b1010, #o17 (string)
-;;   "float"       — 3.14, 1.0e10 (string)
-;;   "ratio"       — 1/3 (string "N/D")
-;;   "string"      — unescaped content
-;;   "char"        — single-character string
-;;   "lparen"  "rparen"  "quote"  "backquote"  "comma"  "comma-at"
-;;   "hash-quote"  — #'
-;;   "hash-paren"  — #(
-;;   "uninterned"  — #:foo (upcase name)
-;;   "dot"         — standalone . (dotted pair separator)
-;;   "eof"
-
-(define cl-make-tok (fn (type value pos) {:type type :value value :pos pos}))
-
-;; ── char ordinal table ────────────────────────────────────────────
-
-(define
-  cl-ord-table
-  (let
-    ((t (dict)) (i 0))
-    (define
-      cl-fill
-      (fn
-        ()
-        (when
-          (< i 128)
-          (do
-            (dict-set! t (char-from-code i) i)
-            (set! i (+ i 1))
-            (cl-fill)))))
-    (cl-fill)
-    t))
-
-(define cl-ord (fn (c) (or (get cl-ord-table c) 0)))
-
-;; ── character predicates ──────────────────────────────────────────
-
-(define cl-digit? (fn (c) (and (>= (cl-ord c) 48) (<= (cl-ord c) 57))))
-
-(define
-  cl-hex?
-  (fn
-    (c)
-    (or
-      (cl-digit? c)
-      (and (>= (cl-ord c) 65) (<= (cl-ord c) 70))
-      (and (>= (cl-ord c) 97) (<= (cl-ord c) 102)))))
-
-(define cl-octal? (fn (c) (and (>= (cl-ord c) 48) (<= (cl-ord c) 55))))
-
-(define cl-binary? (fn (c) (or (= c "0") (= c "1"))))
-
-(define cl-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
-
-(define
-  cl-alpha?
-  (fn
-    (c)
-    (or
-      (and (>= (cl-ord c) 65) (<= (cl-ord c) 90))
-      (and (>= (cl-ord c) 97) (<= (cl-ord c) 122)))))
-
-;; Characters that end a token (whitespace + terminating macro chars)
-(define
-  cl-terminating?
-  (fn
-    (c)
-    (or
-      (cl-ws? c)
-      (= c "(")
-      (= c ")")
-      (= c "\"")
-      (= c ";")
-      (= c "`")
-      (= c ","))))
-
-;; Symbol constituent: not terminating, not reader-special
-(define
-  cl-sym-char?
-  (fn
-    (c)
-    (not
-      (or
-        (cl-terminating? c)
-        (= c "#")
-        (= c "|")
-        (= c "\\")
-        (= c "'")))))
-
-;; ── named character table ─────────────────────────────────────────
-
-(define
-  cl-named-chars
-  {:space " "
-    :newline "\n"
-    :tab "\t"
-    :return "\r"
-    :backspace (char-from-code 8)
-    :rubout (char-from-code 127)
-    :delete (char-from-code 127)
-    :escape (char-from-code 27)
-    :altmode (char-from-code 27)
-    :null (char-from-code 0)
-    :nul (char-from-code 0)
-    :page (char-from-code 12)
-    :formfeed (char-from-code 12)})
-
-;; ── main tokenizer ────────────────────────────────────────────────
-
-(define
-  cl-tokenize
-  (fn
-    (src)
-    (let
-      ((pos 0) (n (string-length src)) (toks (list)))
-
-      (define at (fn () (if (< pos n) (substring src pos (+ pos 1)) nil)))
-      (define peek1 (fn () (if (< (+ pos 1) n) (substring src (+ pos 1) (+ pos 2)) nil)))
-      (define adv (fn () (set! pos (+ pos 1))))
-
-      ;; Advance while predicate holds; return substring from start to end
-      (define
-        read-while
-        (fn
-          (pred)
-          (let
-            ((start pos))
-            (define
-              rw-loop
-              (fn
-                ()
-                (when
-                  (and (at) (pred (at)))
-                  (do (adv) (rw-loop)))))
-            (rw-loop)
-            (substring src start pos))))
-
-      (define
-        skip-line
-        (fn
-          ()
-          (when
-            (and (at) (not (= (at) "\n")))
-            (do (adv) (skip-line)))))
-
-      (define
-        skip-block
-        (fn
-          (depth)
-          (when
-            (at)
-            (cond
-              ((and (= (at) "#") (= (peek1) "|"))
-                (do (adv) (adv) (skip-block (+ depth 1))))
-              ((and (= (at) "|") (= (peek1) "#"))
-                (do
-                  (adv)
-                  (adv)
-                  (when (> depth 1) (skip-block (- depth 1)))))
-              (:else (do (adv) (skip-block depth)))))))
-
-      ;; Read string literal — called with pos just past opening "
-      (define
-        read-str
-        (fn
-          (acc)
-          (if
-            (not (at))
-            acc
-            (cond
-              ((= (at) "\"") (do (adv) acc))
-              ((= (at) "\\")
-                (do
-                  (adv)
-                  (let
-                    ((e (at)))
-                    (adv)
-                    (read-str
-                      (str
-                        acc
-                        (cond
-                          ((= e "n") "\n")
-                          ((= e "t") "\t")
-                          ((= e "r") "\r")
-                          ((= e "\"") "\"")
-                          ((= e "\\") "\\")
-                          (:else e)))))))
-              (:else
-                (let
-                  ((c (at)))
-                  (adv)
-                  (read-str (str acc c))))))))
-
-      ;; Read #\ char literal — called with pos just past the backslash
-      (define
-        read-char-lit
-        (fn
-          ()
-          (let
-            ((first (at)))
-            (adv)
-            (let
-              ((rest (if (and (at) (cl-alpha? (at))) (read-while cl-alpha?) "")))
-              (if
-                (= rest "")
-                first
-                (let
-                  ((name (downcase (str first rest))))
-                  (or (get cl-named-chars name) first)))))))
-
-      ;; Number scanner — called with pos just past first digit(s).
-      ;; acc holds what was already consumed (first digit or sign+digit).
-      (define
-        scan-num
-        (fn
-          (p acc)
-          (let
-            ((more (read-while cl-digit?)))
-            (set! acc (str acc more))
-            (cond
-              ;; ratio N/D
-              ((and (at) (= (at) "/") (peek1) (cl-digit? (peek1)))
-                (do
-                  (adv)
-                  (let
-                    ((denom (read-while cl-digit?)))
-                    {:type "ratio" :value (str acc "/" denom) :pos p})))
-              ;; float: decimal point N.M[eE]
-              ((and (at) (= (at) ".") (peek1) (cl-digit? (peek1)))
-                (do
-                  (adv)
-                  (let
-                    ((frac (read-while cl-digit?)))
-                    (set! acc (str acc "." frac))
-                    (when
-                      (and (at) (or (= (at) "e") (= (at) "E")))
-                      (do
-                        (set! acc (str acc (at)))
-                        (adv)
-                        (when
-                          (and (at) (or (= (at) "+") (= (at) "-")))
-                          (do (set! acc (str acc (at))) (adv)))
-                        (set! acc (str acc (read-while cl-digit?)))))
-                    {:type "float" :value acc :pos p})))
-              ;; float: exponent only NeE
-              ((and (at) (or (= (at) "e") (= (at) "E")))
-                (do
-                  (set! acc (str acc (at)))
-                  (adv)
-                  (when
-                    (and (at) (or (= (at) "+") (= (at) "-")))
-                    (do (set! acc (str acc (at))) (adv)))
-                  (set! acc (str acc (read-while cl-digit?)))
-                  {:type "float" :value acc :pos p}))
-              (:else {:type "integer" :value acc :pos p})))))
-
-      (define
-        read-radix
-        (fn
-          (letter p)
-          (let
-            ((pred
-                (cond
-                  ((or (= letter "x") (= letter "X")) cl-hex?)
-                  ((or (= letter "b") (= letter "B")) cl-binary?)
-                  ((or (= letter "o") (= letter "O")) cl-octal?)
-                  (:else cl-digit?))))
-            {:type "integer"
-              :value (str "#" letter (read-while pred))
-              :pos p})))
-
-      (define emit (fn (tok) (append! toks tok)))
-
-      (define
-        scan
-        (fn
-          ()
-          (when
-            (< pos n)
-            (let
-              ((c (at)) (p pos))
-              (cond
-                ((cl-ws? c) (do (adv) (scan)))
-                ((= c ";") (do (adv) (skip-line) (scan)))
-                ((= c "(") (do (adv) (emit (cl-make-tok "lparen" "(" p)) (scan)))
-                ((= c ")") (do (adv) (emit (cl-make-tok "rparen" ")" p)) (scan)))
-                ((= c "'") (do (adv) (emit (cl-make-tok "quote" "'" p)) (scan)))
-                ((= c "`") (do (adv) (emit (cl-make-tok "backquote" "`" p)) (scan)))
-                ((= c ",")
-                  (do
-                    (adv)
-                    (if
-                      (= (at) "@")
-                      (do (adv) (emit (cl-make-tok "comma-at" ",@" p)))
-                      (emit (cl-make-tok "comma" "," p)))
-                    (scan)))
-                ((= c "\"")
-                  (do
-                    (adv)
-                    (emit (cl-make-tok "string" (read-str "") p))
-                    (scan)))
-                ;; :keyword
-                ((= c ":")
-                  (do
-                    (adv)
-                    (emit (cl-make-tok "keyword" (upcase (read-while cl-sym-char?)) p))
-                    (scan)))
-                ;; dispatch macro #
-                ((= c "#")
-                  (do
-                    (adv)
-                    (let
-                      ((d (at)))
-                      (cond
-                        ((= d "'") (do (adv) (emit (cl-make-tok "hash-quote" "#'" p)) (scan)))
-                        ((= d "(") (do (adv) (emit (cl-make-tok "hash-paren" "#(" p)) (scan)))
-                        ((= d ":")
-                          (do
-                            (adv)
-                            (emit
-                              (cl-make-tok "uninterned" (upcase (read-while cl-sym-char?)) p))
-                            (scan)))
-                        ((= d "|") (do (adv) (skip-block 1) (scan)))
-                        ((= d "\\")
-                          (do (adv) (emit (cl-make-tok "char" (read-char-lit) p)) (scan)))
-                        ((or (= d "x") (= d "X"))
-                          (do (adv) (emit (read-radix d p)) (scan)))
-                        ((or (= d "b") (= d "B"))
-                          (do (adv) (emit (read-radix d p)) (scan)))
-                        ((or (= d "o") (= d "O"))
-                          (do (adv) (emit (read-radix d p)) (scan)))
-                        (:else (scan))))))
-                ;; standalone dot, float .5, or symbol starting with dots
-                ((= c ".")
-                  (do
-                    (adv)
-                    (cond
-                      ((or (not (at)) (cl-terminating? (at)))
-                        (do (emit (cl-make-tok "dot" "." p)) (scan)))
-                      ((cl-digit? (at))
-                        (do
-                          (emit
-                            (cl-make-tok "float" (str "0." (read-while cl-digit?)) p))
-                          (scan)))
-                      (:else
-                        (do
-                          (emit
-                            (cl-make-tok "symbol" (upcase (str "." (read-while cl-sym-char?))) p))
-                          (scan))))))
-                ;; sign followed by digit → number
-                ((and (or (= c "+") (= c "-")) (peek1) (cl-digit? (peek1)))
-                  (do
-                    (adv)
-                    (let
-                      ((first-d (at)))
-                      (adv)
-                      (emit (scan-num p (str c first-d))))
-                    (scan)))
-                ;; decimal digit → number
-                ((cl-digit? c)
-                  (do
-                    (adv)
-                    (emit (scan-num p c))
-                    (scan)))
-                ;; symbol constituent (includes bare +, -, etc.)
-                ((cl-sym-char? c)
-                  (do
-                    (emit (cl-make-tok "symbol" (upcase (read-while cl-sym-char?)) p))
-                    (scan)))
-                (:else (do (adv) (scan))))))))
-
-      (scan)
-      (append! toks (cl-make-tok "eof" nil n))
-      toks)))

lib/common-lisp/runtime.sx

@@ -1,14 +1,18 @@
-;; lib/common-lisp/runtime.sx — CL built-ins + condition system on SX
+;; lib/common-lisp/runtime.sx — CL built-ins using SX spec primitives
 ;;
-;; Section 1-9:  Type predicates, arithmetic, characters, strings, gensym,
-;;               multiple values, sets, radix formatting, list utilities.
-;; Section 10:   Condition system (define-condition, signal/error/warn,
-;;               handler-bind, handler-case, restart-case, invoke-restart).
+;; Provides CL-specific wrappers and helpers. Deliberately thin: wherever
+;; an SX spec primitive already does the job, we alias it rather than
+;; reinventing it.
 ;;
 ;; Primitives used from spec:
 ;;   char/char->integer/integer->char/char-upcase/char-downcase
-;;   format   gensym   rational/rational?   make-set/set-member?/etc
-;;   modulo/remainder/quotient/gcd/lcm/expt   number->string
+;;   format   (Phase 21 — must be loaded before this file)
+;;   gensym   (Phase 12)
+;;   rational/rational?  (Phase 16)
+;;   make-set/set-member?/set-union/etc  (Phase 18)
+;;   open-input-string/read-char/etc  (Phase 14)
+;;   modulo/remainder/quotient/gcd/lcm/expt  (Phase 2 / Phase 15)
+;;   number->string with radix  (Phase 15)
 
 ;; ---------------------------------------------------------------------------
 ;; 1.  Type predicates
@@ -300,425 +304,3 @@
     ((or (cl-empty? plist) (cl-empty? (rest plist))) nil)
     ((equal? (first plist) key) (first (rest plist)))
     (else (cl-getf (rest (rest plist)) key))))
-
-;; ---------------------------------------------------------------------------
-;; 10.  Condition system (Phase 3)
-;;
-;; Condition objects:
-;;   {:cl-type "cl-condition" :class "NAME" :slots {slot-name val ...}}
-;;
-;; The built-in handler-bind / restart-case expect LITERAL handler specs in
-;; source (they operate on the raw AST), so we implement our own handler and
-;; restart stacks as mutable SX globals.
-;; ---------------------------------------------------------------------------
-
-;; ── condition class registry ───────────────────────────────────────────────
-;;
-;; Populated at load time with all ANSI standard condition types.
-;; Also mutated by cl-define-condition.
-
-(define
-  cl-condition-classes
-  (dict
-    "condition"
-    {:parents (list) :slots (list) :name "condition"}
-    "serious-condition"
-    {:parents (list "condition") :slots (list) :name "serious-condition"}
-    "error"
-    {:parents (list "serious-condition") :slots (list) :name "error"}
-    "warning"
-    {:parents (list "condition") :slots (list) :name "warning"}
-    "simple-condition"
-    {:parents (list "condition") :slots (list "format-control" "format-arguments") :name "simple-condition"}
-    "simple-error"
-    {:parents (list "error" "simple-condition") :slots (list "format-control" "format-arguments") :name "simple-error"}
-    "simple-warning"
-    {:parents (list "warning" "simple-condition") :slots (list "format-control" "format-arguments") :name "simple-warning"}
-    "type-error"
-    {:parents (list "error") :slots (list "datum" "expected-type") :name "type-error"}
-    "arithmetic-error"
-    {:parents (list "error") :slots (list "operation" "operands") :name "arithmetic-error"}
-    "division-by-zero"
-    {:parents (list "arithmetic-error") :slots (list) :name "division-by-zero"}
-    "cell-error"
-    {:parents (list "error") :slots (list "name") :name "cell-error"}
-    "unbound-variable"
-    {:parents (list "cell-error") :slots (list) :name "unbound-variable"}
-    "undefined-function"
-    {:parents (list "cell-error") :slots (list) :name "undefined-function"}
-    "program-error"
-    {:parents (list "error") :slots (list) :name "program-error"}
-    "storage-condition"
-    {:parents (list "serious-condition") :slots (list) :name "storage-condition"}))
-
-;; ── condition predicates ───────────────────────────────────────────────────
-
-(define
-  cl-condition?
-  (fn (x) (and (dict? x) (= (get x "cl-type") "cl-condition"))))
-
-;; cl-condition-of-type? walks the class hierarchy.
-;; We capture cl-condition-classes at define time via let to avoid
-;; free-variable scoping issues at call time.
-
-(define
-  cl-condition-of-type?
-  (let
-    ((classes cl-condition-classes))
-    (fn
-      (c type-name)
-      (if
-        (not (cl-condition? c))
-        false
-        (let
-          ((class-name (get c "class")))
-          (define
-            check
-            (fn
-              (n)
-              (if
-                (= n type-name)
-                true
-                (let
-                  ((entry (get classes n)))
-                  (if
-                    (nil? entry)
-                    false
-                    (some (fn (p) (check p)) (get entry "parents")))))))
-          (check class-name))))))
-
-;; ── condition constructors ─────────────────────────────────────────────────
-
-;; cl-define-condition registers a new condition class.
-;; name:       string (condition class name)
-;; parents:    list of strings (parent class names)
-;; slot-names: list of strings
-
-(define
-  cl-define-condition
-  (fn
-    (name parents slot-names)
-    (begin (dict-set! cl-condition-classes name {:parents parents :slots slot-names :name name}) name)))
-
-;; cl-make-condition constructs a condition object.
-;; Keyword args (alternating slot-name/value pairs) populate the slots dict.
-
-(define
-  cl-make-condition
-  (fn
-    (name &rest kw-args)
-    (let
-      ((slots (dict)))
-      (define
-        fill
-        (fn
-          (args)
-          (when
-            (>= (len args) 2)
-            (begin
-              (dict-set! slots (first args) (first (rest args)))
-              (fill (rest (rest args)))))))
-      (fill kw-args)
-      {:cl-type "cl-condition" :slots slots :class name})))
-
-;; ── condition accessors ────────────────────────────────────────────────────
-
-(define
-  cl-condition-slot
-  (fn
-    (c slot-name)
-    (if (cl-condition? c) (get (get c "slots") slot-name) nil)))
-
-(define
-  cl-condition-message
-  (fn
-    (c)
-    (if
-      (not (cl-condition? c))
-      (str c)
-      (let
-        ((slots (get c "slots")))
-        (or
-          (get slots "message")
-          (get slots "format-control")
-          (str "Condition: " (get c "class")))))))
-
-(define
-  cl-simple-condition-format-control
-  (fn (c) (cl-condition-slot c "format-control")))
-
-(define
-  cl-simple-condition-format-arguments
-  (fn (c) (cl-condition-slot c "format-arguments")))
-
-(define cl-type-error-datum (fn (c) (cl-condition-slot c "datum")))
-
-(define
-  cl-type-error-expected-type
-  (fn (c) (cl-condition-slot c "expected-type")))
-
-(define
-  cl-arithmetic-error-operation
-  (fn (c) (cl-condition-slot c "operation")))
-
-(define
-  cl-arithmetic-error-operands
-  (fn (c) (cl-condition-slot c "operands")))
-
-;; ── mutable handler + restart stacks ──────────────────────────────────────
-;;
-;; Handler entry: {:type "type-name" :fn (fn (condition) result)}
-;; Restart entry: {:name "restart-name" :fn (fn (&optional arg) result) :escape k}
-;;
-;; New handlers are prepended (checked first = most recent handler wins).
-
-(define cl-handler-stack (list))
-(define cl-restart-stack (list))
-
-(define
-  cl-push-handlers
-  (fn (entries) (set! cl-handler-stack (append entries cl-handler-stack))))
-
-(define
-  cl-pop-handlers
-  (fn
-    (n)
-    (set! cl-handler-stack (slice cl-handler-stack n (len cl-handler-stack)))))
-
-(define
-  cl-push-restarts
-  (fn (entries) (set! cl-restart-stack (append entries cl-restart-stack))))
-
-(define
-  cl-pop-restarts
-  (fn
-    (n)
-    (set! cl-restart-stack (slice cl-restart-stack n (len cl-restart-stack)))))
-
-;; ── *debugger-hook* + invoke-debugger ────────────────────────────────────
-;;
-;; cl-debugger-hook: called when an error propagates with no handler.
-;; Signature: (fn (condition hook) result). The hook arg is itself
-;; (so the hook can rebind it to nil to prevent recursion).
-;; nil = use default (re-raise as host error).
-
-(define cl-debugger-hook nil)
-
-(define cl-invoke-debugger
-  (fn (c)
-    (if (nil? cl-debugger-hook)
-      (error (str "Debugger: " (cl-condition-message c)))
-      (let ((hook cl-debugger-hook))
-        (set! cl-debugger-hook nil)
-        (let ((result (hook c hook)))
-          (set! cl-debugger-hook hook)
-          result)))))
-
-;; ── *break-on-signals* ────────────────────────────────────────────────────
-;;
-;; When set to a type name string, cl-signal invokes the debugger hook
-;; before walking handlers if the condition is of that type.
-;; nil = disabled (ANSI default).
-
-(define cl-break-on-signals nil)
-
-;; ── invoke-restart-interactively ──────────────────────────────────────────
-;;
-;; Like invoke-restart but calls the restart's fn with no arguments
-;; (real CL would prompt the user for each arg via :interactive).
-
-(define cl-invoke-restart-interactively
-  (fn (name)
-    (let ((entry (cl-find-restart-entry name cl-restart-stack)))
-      (if (nil? entry)
-        (error (str "No active restart: " name))
-        (let ((restart-fn (get entry "fn"))
-              (escape     (get entry "escape")))
-          (escape (restart-fn)))))))
-
-;; ── cl-signal (non-unwinding) ─────────────────────────────────────────────
-;;
-;; Walks cl-handler-stack; for each matching entry, calls the handler fn.
-;; Handlers return normally — signal continues to the next matching handler.
-
-(define
-  cl-signal-obj
-  (fn
-    (obj stack)
-    (if
-      (empty? stack)
-      nil
-      (let
-        ((entry (first stack)))
-        (if
-          (cl-condition-of-type? obj (get entry "type"))
-          (begin ((get entry "fn") obj) (cl-signal-obj obj (rest stack)))
-          (cl-signal-obj obj (rest stack)))))))
-
-(define cl-signal
-  (fn (c)
-    (let ((obj (if (cl-condition? c)
-                 c
-                 (cl-make-condition "simple-condition"
-                   "format-control" (str c)))))
-      ;; *break-on-signals*: invoke debugger hook when type matches
-      (when (and (not (nil? cl-break-on-signals))
-                 (cl-condition-of-type? obj cl-break-on-signals))
-        (cl-invoke-debugger obj))
-      (cl-signal-obj obj cl-handler-stack))))
-
-;; ── cl-error ───────────────────────────────────────────────────────────────
-;;
-;; Signals an error. If no handler catches it, raises a host-level error.
-
-(define
-  cl-error
-  (fn
-    (c &rest args)
-    (let
-      ((obj (cond ((cl-condition? c) c) ((string? c) (cl-make-condition "simple-error" "format-control" c "format-arguments" args)) (:else (cl-make-condition "simple-error" "format-control" (str c))))))
-      (cl-signal-obj obj cl-handler-stack)
-      (cl-invoke-debugger obj))))
-
-;; ── cl-warn ────────────────────────────────────────────────────────────────
-
-(define
-  cl-warn
-  (fn
-    (c &rest args)
-    (let
-      ((obj (cond ((cl-condition? c) c) ((string? c) (cl-make-condition "simple-warning" "format-control" c "format-arguments" args)) (:else (cl-make-condition "simple-warning" "format-control" (str c))))))
-      (cl-signal-obj obj cl-handler-stack))))
-
-;; ── cl-handler-bind (non-unwinding) ───────────────────────────────────────
-;;
-;; bindings: list of (type-name handler-fn) pairs
-;; thunk:    (fn () body)
-
-(define
-  cl-handler-bind
-  (fn
-    (bindings thunk)
-    (let
-      ((entries (map (fn (b) {:fn (first (rest b)) :type (first b)}) bindings)))
-      (begin
-        (cl-push-handlers entries)
-        (let
-          ((result (thunk)))
-          (begin (cl-pop-handlers (len entries)) result))))))
-
-;; ── cl-handler-case (unwinding) ───────────────────────────────────────────
-;;
-;; thunk: (fn () body)
-;; cases: list of (type-name handler-fn) pairs
-;;
-;; Uses call/cc for the escape continuation.
-
-(define
-  cl-handler-case
-  (fn
-    (thunk &rest cases)
-    (call/cc
-      (fn
-        (escape)
-        (let
-          ((entries (map (fn (c) {:fn (fn (x) (escape ((first (rest c)) x))) :type (first c)}) cases)))
-          (begin
-            (cl-push-handlers entries)
-            (let
-              ((result (thunk)))
-              (begin (cl-pop-handlers (len entries)) result))))))))
-
-;; ── cl-restart-case ────────────────────────────────────────────────────────
-;;
-;; thunk:    (fn () body)
-;; restarts: list of (name params body-fn) triples
-;;   body-fn is (fn () val) or (fn (arg) val)
-
-(define
-  cl-restart-case
-  (fn
-    (thunk &rest restarts)
-    (call/cc
-      (fn
-        (escape)
-        (let
-          ((entries (map (fn (r) {:fn (first (rest (rest r))) :escape escape :name (first r)}) restarts)))
-          (begin
-            (cl-push-restarts entries)
-            (let
-              ((result (thunk)))
-              (begin (cl-pop-restarts (len entries)) result))))))))
-
-;; ── cl-with-simple-restart ─────────────────────────────────────────────────
-
-(define
-  cl-with-simple-restart
-  (fn
-    (name description thunk)
-    (cl-restart-case thunk (list name (list) (fn () nil)))))
-
-;; ── find-restart / invoke-restart / compute-restarts ──────────────────────
-
-(define
-  cl-find-restart-entry
-  (fn
-    (name stack)
-    (if
-      (empty? stack)
-      nil
-      (let
-        ((entry (first stack)))
-        (if
-          (= (get entry "name") name)
-          entry
-          (cl-find-restart-entry name (rest stack)))))))
-
-(define
-  cl-find-restart
-  (fn (name) (cl-find-restart-entry name cl-restart-stack)))
-
-(define
-  cl-invoke-restart
-  (fn
-    (name &rest args)
-    (let
-      ((entry (cl-find-restart-entry name cl-restart-stack)))
-      (if
-        (nil? entry)
-        (error (str "No active restart: " name))
-        (let
-          ((restart-fn (get entry "fn")) (escape (get entry "escape")))
-          (escape
-            (if (empty? args) (restart-fn) (restart-fn (first args)))))))))
-
-(define
-  cl-compute-restarts
-  (fn () (map (fn (e) (get e "name")) cl-restart-stack)))
-
-;; ── with-condition-restarts (stub — association is advisory) ──────────────
-
-(define cl-with-condition-restarts (fn (c restarts thunk) (thunk)))
-
-;; ── cl-cerror ──────────────────────────────────────────────────────────────
-;;
-;; Signals a continuable error. The "continue" restart is established;
-;; invoke-restart "continue" to proceed past the error.
-
-
-
-;; ── cl-cerror ──────────────────────────────────────────────────────────────
-;;
-;; Signals a continuable error. The "continue" restart is established;
-;; invoke-restart "continue" to proceed past the error.
-
-(define cl-cerror
-  (fn (continue-string c &rest args)
-    (let ((obj (if (cl-condition? c)
-                 c
-                 (cl-make-condition "simple-error"
-                   "format-control" (str c)
-                   "format-arguments" args))))
-      (cl-restart-case
-        (fn () (cl-signal-obj obj cl-handler-stack))
-        (list "continue" (list) (fn () nil))))))

lib/common-lisp/scoreboard.json

@@ -1,19 +0,0 @@
-{
-  "generated": "2026-05-05T12:35:09Z",
-  "total_pass": 518,
-  "total_fail": 0,
-  "suites": [
-    {"name": "Phase 1: tokenizer/reader", "pass": 79, "fail": 0},
-    {"name": "Phase 1: parser/lambda-lists", "pass": 31, "fail": 0},
-    {"name": "Phase 2: evaluator", "pass": 182, "fail": 0},
-    {"name": "Phase 3: condition system", "pass": 59, "fail": 0},
-    {"name": "Phase 3: restart-demo", "pass": 7, "fail": 0},
-    {"name": "Phase 3: parse-recover", "pass": 6, "fail": 0},
-    {"name": "Phase 3: interactive-debugger", "pass": 7, "fail": 0},
-    {"name": "Phase 4: CLOS", "pass": 41, "fail": 0},
-    {"name": "Phase 4: geometry", "pass": 12, "fail": 0},
-    {"name": "Phase 4: mop-trace", "pass": 13, "fail": 0},
-    {"name": "Phase 5: macros+LOOP", "pass": 27, "fail": 0},
-    {"name": "Phase 6: stdlib", "pass": 54, "fail": 0}
-  ]
-}

lib/common-lisp/scoreboard.md

@@ -1,20 +0,0 @@
-# Common Lisp on SX — Scoreboard
-
-_Generated: 2026-05-05 12:35 UTC_
-
-| Suite | Pass | Fail | Status |
-|-------|------|------|--------|
-| Phase 1: tokenizer/reader | 79 | 0 | pass |
-| Phase 1: parser/lambda-lists | 31 | 0 | pass |
-| Phase 2: evaluator | 182 | 0 | pass |
-| Phase 3: condition system | 59 | 0 | pass |
-| Phase 3: restart-demo | 7 | 0 | pass |
-| Phase 3: parse-recover | 6 | 0 | pass |
-| Phase 3: interactive-debugger | 7 | 0 | pass |
-| Phase 4: CLOS | 41 | 0 | pass |
-| Phase 4: geometry | 12 | 0 | pass |
-| Phase 4: mop-trace | 13 | 0 | pass |
-| Phase 5: macros+LOOP | 27 | 0 | pass |
-| Phase 6: stdlib | 54 | 0 | pass |
-
-**Total: 518 passed, 0 failed**

lib/common-lisp/test.sh

@@ -292,147 +292,6 @@ check 113 "cl-format-decimal 42"   '"42"'
 check 114 "n->s base 16"           '"1f"'
 check 115 "s->n base 16"           "31"
 
-# ── Phase 2: condition system unit tests ─────────────────────────────────────
-# Load runtime.sx then conditions.sx; query the passed/failed/failures globals.
-UNIT_FILE=$(mktemp); trap "rm -f $UNIT_FILE" EXIT
-cat > "$UNIT_FILE" << 'UNIT'
-(epoch 1)
-(load "spec/stdlib.sx")
-(epoch 2)
-(load "lib/common-lisp/runtime.sx")
-(epoch 3)
-(load "lib/common-lisp/tests/conditions.sx")
-(epoch 4)
-(eval "passed")
-(epoch 5)
-(eval "failed")
-(epoch 6)
-(eval "failures")
-UNIT
-
-UNIT_OUT=$(timeout 30 "$SX_SERVER" < "$UNIT_FILE" 2>/dev/null)
-
-# extract passed/failed counts from ok-len lines
-UNIT_PASSED=$(echo "$UNIT_OUT" | grep -A1 "^(ok-len 4 " | tail -1 || true)
-UNIT_FAILED=$(echo "$UNIT_OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-UNIT_ERRS=$(echo "$UNIT_OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-# fallback: try plain ok lines
-[ -z "$UNIT_PASSED" ] && UNIT_PASSED=$(echo "$UNIT_OUT" | grep "^(ok 4 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$UNIT_FAILED" ] && UNIT_FAILED=$(echo "$UNIT_OUT" | grep "^(ok 5 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$UNIT_PASSED" ] && UNIT_PASSED=0
-[ -z "$UNIT_FAILED" ] && UNIT_FAILED=0
-
-if [ "$UNIT_FAILED" = "0" ] && [ "$UNIT_PASSED" -gt 0 ] 2>/dev/null; then
-  PASS=$((PASS + UNIT_PASSED))
-  [ "$VERBOSE" = "-v" ] && echo "  ok condition tests ($UNIT_PASSED)"
-else
-  FAIL=$((FAIL + 1))
-  ERRORS+="  FAIL [condition tests] (${UNIT_PASSED} passed, ${UNIT_FAILED} failed) ${UNIT_ERRS}
-"
-fi
-
-# ── Phase 3: classic program tests ───────────────────────────────────────────
-run_program_suite() {
-  local prog="$1" pass_var="$2" fail_var="$3" failures_var="$4"
-  local PROG_FILE=$(mktemp)
-  printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/runtime.sx")\n(epoch 3)\n(load "%s")\n(epoch 4)\n(eval "%s")\n(epoch 5)\n(eval "%s")\n(epoch 6)\n(eval "%s")\n' \
-    "$prog" "$pass_var" "$fail_var" "$failures_var" > "$PROG_FILE"
-  local OUT; OUT=$(timeout 20 "$SX_SERVER" < "$PROG_FILE" 2>/dev/null)
-  rm -f "$PROG_FILE"
-  local P F
-  P=$(echo "$OUT" | grep -A1 "^(ok-len 4 " | tail -1 || true)
-  F=$(echo "$OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-  local ERRS; ERRS=$(echo "$OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-  [ -z "$P" ] && P=0; [ -z "$F" ] && F=0
-  if [ "$F" = "0" ] && [ "$P" -gt 0 ] 2>/dev/null; then
-    PASS=$((PASS + P))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $prog ($P)"
-  else
-    FAIL=$((FAIL + 1))
-    ERRORS+="  FAIL [$prog] (${P} passed, ${F} failed) ${ERRS}
-"
-  fi
-}
-
-run_program_suite \
-  "lib/common-lisp/tests/programs/restart-demo.sx" \
-  "demo-passed" "demo-failed" "demo-failures"
-
-run_program_suite \
-  "lib/common-lisp/tests/programs/parse-recover.sx" \
-  "parse-passed" "parse-failed" "parse-failures"
-
-run_program_suite \
-  "lib/common-lisp/tests/programs/interactive-debugger.sx" \
-  "debugger-passed" "debugger-failed" "debugger-failures"
-
-# ── Phase 4: CLOS unit tests ─────────────────────────────────────────────────
-CLOS_FILE=$(mktemp); trap "rm -f $CLOS_FILE" EXIT
-printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/runtime.sx")\n(epoch 3)\n(load "lib/common-lisp/clos.sx")\n(epoch 4)\n(load "lib/common-lisp/tests/clos.sx")\n(epoch 5)\n(eval "passed")\n(epoch 6)\n(eval "failed")\n(epoch 7)\n(eval "failures")\n' > "$CLOS_FILE"
-CLOS_OUT=$(timeout 30 "$SX_SERVER" < "$CLOS_FILE" 2>/dev/null)
-rm -f "$CLOS_FILE"
-CLOS_PASSED=$(echo "$CLOS_OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-CLOS_FAILED=$(echo "$CLOS_OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-[ -z "$CLOS_PASSED" ] && CLOS_PASSED=$(echo "$CLOS_OUT" | grep "^(ok 5 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$CLOS_FAILED" ] && CLOS_FAILED=$(echo "$CLOS_OUT" | grep "^(ok 6 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$CLOS_PASSED" ] && CLOS_PASSED=0; [ -z "$CLOS_FAILED" ] && CLOS_FAILED=0
-if [ "$CLOS_FAILED" = "0" ] && [ "$CLOS_PASSED" -gt 0 ] 2>/dev/null; then
-  PASS=$((PASS + CLOS_PASSED))
-  [ "$VERBOSE" = "-v" ] && echo "  ok CLOS unit tests ($CLOS_PASSED)"
-else
-  FAIL=$((FAIL + 1))
-  ERRORS+="  FAIL [CLOS unit tests] (${CLOS_PASSED} passed, ${CLOS_FAILED} failed)
-"
-fi
-
-# ── Phase 4: CLOS classic programs ───────────────────────────────────────────
-run_clos_suite() {
-  local prog="$1" pass_var="$2" fail_var="$3" failures_var="$4"
-  local PROG_FILE=$(mktemp)
-  printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/runtime.sx")\n(epoch 3)\n(load "lib/common-lisp/clos.sx")\n(epoch 4)\n(load "%s")\n(epoch 5)\n(eval "%s")\n(epoch 6)\n(eval "%s")\n(epoch 7)\n(eval "%s")\n' \
-    "$prog" "$pass_var" "$fail_var" "$failures_var" > "$PROG_FILE"
-  local OUT; OUT=$(timeout 20 "$SX_SERVER" < "$PROG_FILE" 2>/dev/null)
-  rm -f "$PROG_FILE"
-  local P F
-  P=$(echo "$OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-  F=$(echo "$OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-  local ERRS; ERRS=$(echo "$OUT" | grep -A1 "^(ok-len 7 " | tail -1 || true)
-  [ -z "$P" ] && P=0; [ -z "$F" ] && F=0
-  if [ "$F" = "0" ] && [ "$P" -gt 0 ] 2>/dev/null; then
-    PASS=$((PASS + P))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $prog ($P)"
-  else
-    FAIL=$((FAIL + 1))
-    ERRORS+="  FAIL [$prog] (${P} passed, ${F} failed) ${ERRS}
-"
-  fi
-}
-
-run_clos_suite \
-  "lib/common-lisp/tests/programs/geometry.sx" \
-  "geo-passed" "geo-failed" "geo-failures"
-
-run_clos_suite \
-  "lib/common-lisp/tests/programs/mop-trace.sx" \
-  "mop-passed" "mop-failed" "mop-failures"
-
-# ── Phase 5: macros + LOOP ───────────────────────────────────────────────────
-MACRO_FILE=$(mktemp); trap "rm -f $MACRO_FILE" EXIT
-printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/reader.sx")\n(epoch 3)\n(load "lib/common-lisp/parser.sx")\n(epoch 4)\n(load "lib/common-lisp/eval.sx")\n(epoch 5)\n(load "lib/common-lisp/loop.sx")\n(epoch 6)\n(load "lib/common-lisp/tests/macros.sx")\n(epoch 7)\n(eval "macro-passed")\n(epoch 8)\n(eval "macro-failed")\n(epoch 9)\n(eval "macro-failures")\n' > "$MACRO_FILE"
-MACRO_OUT=$(timeout 60 "$SX_SERVER" < "$MACRO_FILE" 2>/dev/null)
-rm -f "$MACRO_FILE"
-MACRO_PASSED=$(echo "$MACRO_OUT" | grep -A1 "^(ok-len 7 " | tail -1 || true)
-MACRO_FAILED=$(echo "$MACRO_OUT" | grep -A1 "^(ok-len 8 " | tail -1 || true)
-[ -z "$MACRO_PASSED" ] && MACRO_PASSED=0; [ -z "$MACRO_FAILED" ] && MACRO_FAILED=0
-if [ "$MACRO_FAILED" = "0" ] && [ "$MACRO_PASSED" -gt 0 ] 2>/dev/null; then
-  PASS=$((PASS + MACRO_PASSED))
-  [ "$VERBOSE" = "-v" ] && echo "  ok Phase 5 macros+LOOP ($MACRO_PASSED)"
-else
-  FAIL=$((FAIL + 1))
-  ERRORS+="  FAIL [Phase 5 macros+LOOP] (${MACRO_PASSED} passed, ${MACRO_FAILED} failed)
-"
-fi
-
 TOTAL=$((PASS+FAIL))
 if [ $FAIL -eq 0 ]; then
   echo "ok $PASS/$TOTAL lib/common-lisp tests passed"

lib/common-lisp/tests/clos.sx

@@ -1,334 +0,0 @@
-;; lib/common-lisp/tests/clos.sx — CLOS test suite
-;;
-;; Loaded after: spec/stdlib.sx, lib/common-lisp/runtime.sx, lib/common-lisp/clos.sx
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  assert-equal
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  assert-true
-  (fn
-    (label got)
-    (if
-      got
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str "FAIL [" label "]: expected true, got " (inspect got)))))))))
-
-(define
-  assert-nil
-  (fn
-    (label got)
-    (if
-      (nil? got)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list (str "FAIL [" label "]: expected nil, got " (inspect got)))))))))
-
-;; ── 1. class-of for built-in types ────────────────────────────────────────
-
-(assert-equal "class-of integer" (clos-class-of 42) "integer")
-(assert-equal "class-of float" (clos-class-of 3.14) "float")
-(assert-equal "class-of string" (clos-class-of "hi") "string")
-(assert-equal "class-of nil" (clos-class-of nil) "null")
-(assert-equal "class-of list" (clos-class-of (list 1)) "cons")
-(assert-equal "class-of empty" (clos-class-of (list)) "null")
-
-;; ── 2. subclass-of? ───────────────────────────────────────────────────────
-
-(assert-true "integer subclass-of t" (clos-subclass-of? "integer" "t"))
-(assert-true "float subclass-of t" (clos-subclass-of? "float" "t"))
-(assert-true "t subclass-of t" (clos-subclass-of? "t" "t"))
-(assert-equal
-  "integer not subclass-of float"
-  (clos-subclass-of? "integer" "float")
-  false)
-
-;; ── 3. defclass + make-instance ───────────────────────────────────────────
-
-(clos-defclass "point" (list "t") (list {:initform 0 :initarg ":x" :reader nil :writer nil :accessor "point-x" :name "x"} {:initform 0 :initarg ":y" :reader nil :writer nil :accessor "point-y" :name "y"}))
-
-(let
-  ((p (clos-make-instance "point" ":x" 3 ":y" 4)))
-  (begin
-    (assert-equal "make-instance slot x" (clos-slot-value p "x") 3)
-    (assert-equal "make-instance slot y" (clos-slot-value p "y") 4)
-    (assert-equal "class-of instance" (clos-class-of p) "point")
-    (assert-true "instance-of? point" (clos-instance-of? p "point"))
-    (assert-true "instance-of? t" (clos-instance-of? p "t"))
-    (assert-equal "instance-of? string" (clos-instance-of? p "string") false)))
-
-;; initform defaults
-(let
-  ((p0 (clos-make-instance "point")))
-  (begin
-    (assert-equal "initform default x=0" (clos-slot-value p0 "x") 0)
-    (assert-equal "initform default y=0" (clos-slot-value p0 "y") 0)))
-
-;; ── 4. slot-value / set-slot-value! ──────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 10 ":y" 20)))
-  (begin
-    (clos-set-slot-value! p "x" 99)
-    (assert-equal "set-slot-value! x" (clos-slot-value p "x") 99)
-    (assert-equal "slot-value y unchanged" (clos-slot-value p "y") 20)))
-
-;; ── 5. slot-boundp ────────────────────────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 5)))
-  (begin
-    (assert-true "slot-boundp x" (clos-slot-boundp p "x"))
-    (assert-true "slot-boundp y (initform 0)" (clos-slot-boundp p "y"))))
-
-;; ── 6. find-class ─────────────────────────────────────────────────────────
-
-(assert-equal
-  "find-class point"
-  (get (clos-find-class "point") "name")
-  "point")
-(assert-nil "find-class missing" (clos-find-class "no-such-class"))
-
-;; ── 7. inheritance ────────────────────────────────────────────────────────
-
-(clos-defclass "colored-point" (list "point") (list {:initform "white" :initarg ":color" :reader nil :writer nil :accessor nil :name "color"}))
-
-(let
-  ((cp (clos-make-instance "colored-point" ":x" 1 ":y" 2 ":color" "red")))
-  (begin
-    (assert-equal "inherited slot x" (clos-slot-value cp "x") 1)
-    (assert-equal "inherited slot y" (clos-slot-value cp "y") 2)
-    (assert-equal "own slot color" (clos-slot-value cp "color") "red")
-    (assert-true
-      "instance-of? colored-point"
-      (clos-instance-of? cp "colored-point"))
-    (assert-true "instance-of? point (parent)" (clos-instance-of? cp "point"))
-    (assert-true "instance-of? t (root)" (clos-instance-of? cp "t"))))
-
-;; ── 8. defgeneric + primary method ───────────────────────────────────────
-
-(clos-defgeneric "describe-obj" {})
-
-(clos-defmethod
-  "describe-obj"
-  (list)
-  (list "point")
-  (fn
-    (args next-fn)
-    (let
-      ((p (first args)))
-      (str "(" (clos-slot-value p "x") "," (clos-slot-value p "y") ")"))))
-
-(clos-defmethod
-  "describe-obj"
-  (list)
-  (list "t")
-  (fn (args next-fn) (str "object:" (inspect (first args)))))
-
-(let
-  ((p (clos-make-instance "point" ":x" 3 ":y" 4)))
-  (begin
-    (assert-equal
-      "primary method for point"
-      (clos-call-generic "describe-obj" (list p))
-      "(3,4)")
-    (assert-equal
-      "fallback t method"
-      (clos-call-generic "describe-obj" (list 42))
-      "object:42")))
-
-;; ── 9. method inheritance + specificity ───────────────────────────────────
-
-(clos-defmethod
-  "describe-obj"
-  (list)
-  (list "colored-point")
-  (fn
-    (args next-fn)
-    (let
-      ((cp (first args)))
-      (str
-        (clos-slot-value cp "color")
-        "@("
-        (clos-slot-value cp "x")
-        ","
-        (clos-slot-value cp "y")
-        ")"))))
-
-(let
-  ((cp (clos-make-instance "colored-point" ":x" 5 ":y" 6 ":color" "blue")))
-  (assert-equal
-    "most specific method wins"
-    (clos-call-generic "describe-obj" (list cp))
-    "blue@(5,6)"))
-
-;; ── 10. :before / :after / :around qualifiers ─────────────────────────────
-
-(clos-defgeneric "logged-action" {})
-
-(clos-defmethod
-  "logged-action"
-  (list "before")
-  (list "t")
-  (fn (args next-fn) (set! action-log (append action-log (list "before")))))
-
-(clos-defmethod
-  "logged-action"
-  (list)
-  (list "t")
-  (fn
-    (args next-fn)
-    (set! action-log (append action-log (list "primary")))
-    "result"))
-
-(clos-defmethod
-  "logged-action"
-  (list "after")
-  (list "t")
-  (fn (args next-fn) (set! action-log (append action-log (list "after")))))
-
-(define action-log (list))
-(clos-call-generic "logged-action" (list 1))
-(assert-equal
-  ":before/:after order"
-  action-log
-  (list "before" "primary" "after"))
-
-;; :around
-(define around-log (list))
-
-(clos-defgeneric "wrapped-action" {})
-
-(clos-defmethod
-  "wrapped-action"
-  (list "around")
-  (list "t")
-  (fn
-    (args next-fn)
-    (set! around-log (append around-log (list "around-enter")))
-    (let
-      ((r (next-fn)))
-      (set! around-log (append around-log (list "around-exit")))
-      r)))
-
-(clos-defmethod
-  "wrapped-action"
-  (list)
-  (list "t")
-  (fn
-    (args next-fn)
-    (set! around-log (append around-log (list "primary")))
-    42))
-
-(let
-  ((r (clos-call-generic "wrapped-action" (list nil))))
-  (begin
-    (assert-equal ":around result" r 42)
-    (assert-equal
-      ":around log"
-      around-log
-      (list "around-enter" "primary" "around-exit"))))
-
-;; ── 11. call-next-method ─────────────────────────────────────────────────
-
-(clos-defgeneric "chain-test" {})
-
-(clos-defmethod
-  "chain-test"
-  (list)
-  (list "colored-point")
-  (fn (args next-fn) (str "colored:" (clos-call-next-method next-fn))))
-
-(clos-defmethod
-  "chain-test"
-  (list)
-  (list "point")
-  (fn (args next-fn) "point-base"))
-
-(let
-  ((cp (clos-make-instance "colored-point" ":x" 0 ":y" 0 ":color" "green")))
-  (assert-equal
-    "call-next-method chains"
-    (clos-call-generic "chain-test" (list cp))
-    "colored:point-base"))
-
-;; ── 12. accessor methods ──────────────────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 7 ":y" 8)))
-  (begin
-    (assert-equal
-      "accessor point-x"
-      (clos-call-generic "point-x" (list p))
-      7)
-    (assert-equal
-      "accessor point-y"
-      (clos-call-generic "point-y" (list p))
-      8)))
-
-;; ── 13. with-slots ────────────────────────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 3 ":y" 4)))
-  (assert-equal
-    "with-slots"
-    (clos-with-slots p (list "x" "y") (fn (x y) (* x y)))
-    12))
-
-;; ── 14. change-class ─────────────────────────────────────────────────────
-
-(clos-defclass "special-point" (list "point") (list {:initform "" :initarg ":label" :reader nil :writer nil :accessor nil :name "label"}))
-
-(let
-  ((p (clos-make-instance "point" ":x" 1 ":y" 2)))
-  (begin
-    (clos-change-class! p "special-point")
-    (assert-equal
-      "change-class updates class"
-      (clos-class-of p)
-      "special-point")))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(if
-  (= failed 0)
-  (print (str "ok " passed "/" (+ passed failed) " CLOS tests passed"))
-  (begin
-    (for-each (fn (f) (print f)) failures)
-    (print
-      (str "FAIL " passed "/" (+ passed failed) " passed, " failed " failed"))))

lib/common-lisp/tests/conditions.sx

@@ -1,478 +0,0 @@
-;; lib/common-lisp/tests/conditions.sx — Phase 3 condition system tests
-;;
-;; Loaded by lib/common-lisp/test.sh after:
-;;   (load "spec/stdlib.sx")
-;;   (load "lib/common-lisp/runtime.sx")
-;;
-;; Each test resets the handler/restart stacks to ensure isolation.
-
-(define
-  reset-stacks!
-  (fn () (set! cl-handler-stack (list)) (set! cl-restart-stack (list))))
-
-;; ── helpers ────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  assert-equal
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  assert-true
-  (fn
-    (label got)
-    (if
-      got
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str "FAIL [" label "]: expected true, got " (inspect got)))))))))
-
-(define
-  assert-nil
-  (fn
-    (label got)
-    (if
-      (nil? got)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list (str "FAIL [" label "]: expected nil, got " (inspect got)))))))))
-
-;; ── 1. condition predicates ────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((c (cl-make-condition "simple-error" "format-control" "oops")))
-  (begin
-    (assert-true "cl-condition? on condition" (cl-condition? c))
-    (assert-equal "cl-condition? on string" (cl-condition? "hello") false)
-    (assert-equal "cl-condition? on number" (cl-condition? 42) false)
-    (assert-equal "cl-condition? on nil" (cl-condition? nil) false)))
-
-;; ── 2. cl-make-condition + slot access ────────────────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((c (cl-make-condition "simple-error" "format-control" "msg" "format-arguments" (list 1 2))))
-  (begin
-    (assert-equal "class field" (get c "class") "simple-error")
-    (assert-equal "cl-type field" (get c "cl-type") "cl-condition")
-    (assert-equal
-      "format-control slot"
-      (cl-condition-slot c "format-control")
-      "msg")
-    (assert-equal
-      "format-arguments slot"
-      (cl-condition-slot c "format-arguments")
-      (list 1 2))
-    (assert-nil "missing slot is nil" (cl-condition-slot c "no-such-slot"))
-    (assert-equal "condition-message" (cl-condition-message c) "msg")))
-
-;; ── 3. cl-condition-of-type? — hierarchy walking ─────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((se (cl-make-condition "simple-error" "format-control" "x"))
-    (w (cl-make-condition "simple-warning" "format-control" "y"))
-    (te
-      (cl-make-condition
-        "type-error"
-        "datum"
-        5
-        "expected-type"
-        "string"))
-    (dz (cl-make-condition "division-by-zero")))
-  (begin
-    (assert-true
-      "se isa simple-error"
-      (cl-condition-of-type? se "simple-error"))
-    (assert-true "se isa error" (cl-condition-of-type? se "error"))
-    (assert-true
-      "se isa serious-condition"
-      (cl-condition-of-type? se "serious-condition"))
-    (assert-true "se isa condition" (cl-condition-of-type? se "condition"))
-    (assert-equal
-      "se not isa warning"
-      (cl-condition-of-type? se "warning")
-      false)
-    (assert-true
-      "w isa simple-warning"
-      (cl-condition-of-type? w "simple-warning"))
-    (assert-true "w isa warning" (cl-condition-of-type? w "warning"))
-    (assert-true "w isa condition" (cl-condition-of-type? w "condition"))
-    (assert-equal "w not isa error" (cl-condition-of-type? w "error") false)
-    (assert-true "te isa type-error" (cl-condition-of-type? te "type-error"))
-    (assert-true "te isa error" (cl-condition-of-type? te "error"))
-    (assert-true
-      "dz isa division-by-zero"
-      (cl-condition-of-type? dz "division-by-zero"))
-    (assert-true
-      "dz isa arithmetic-error"
-      (cl-condition-of-type? dz "arithmetic-error"))
-    (assert-true "dz isa error" (cl-condition-of-type? dz "error"))
-    (assert-equal
-      "non-condition not isa anything"
-      (cl-condition-of-type? 42 "error")
-      false)))
-
-;; ── 4. cl-define-condition ────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(begin
-  (cl-define-condition "my-app-error" (list "error") (list "code" "detail"))
-  (let
-    ((c (cl-make-condition "my-app-error" "code" 404 "detail" "not found")))
-    (begin
-      (assert-true "user condition: cl-condition?" (cl-condition? c))
-      (assert-true
-        "user condition isa my-app-error"
-        (cl-condition-of-type? c "my-app-error"))
-      (assert-true
-        "user condition isa error"
-        (cl-condition-of-type? c "error"))
-      (assert-true
-        "user condition isa condition"
-        (cl-condition-of-type? c "condition"))
-      (assert-equal
-        "user condition slot code"
-        (cl-condition-slot c "code")
-        404)
-      (assert-equal
-        "user condition slot detail"
-        (cl-condition-slot c "detail")
-        "not found"))))
-
-;; ── 5. cl-handler-bind (non-unwinding) ───────────────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((log (list)))
-  (begin
-    (cl-handler-bind
-      (list
-        (list
-          "error"
-          (fn (c) (set! log (append log (list (cl-condition-message c)))))))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "oops"))))
-    (assert-equal "handler-bind: handler fired" log (list "oops"))))
-
-(reset-stacks!)
-
-;; Non-unwinding: body continues after signal
-(let
-  ((body-ran false))
-  (begin
-    (cl-handler-bind
-      (list (list "error" (fn (c) nil)))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "x"))
-        (set! body-ran true)))
-    (assert-true "handler-bind: body continues after signal" body-ran)))
-
-(reset-stacks!)
-
-;; Type filtering: warning handler does not fire for error
-(let
-  ((w-fired false))
-  (begin
-    (cl-handler-bind
-      (list (list "warning" (fn (c) (set! w-fired true))))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "e"))))
-    (assert-equal
-      "handler-bind: type filter (warning ignores error)"
-      w-fired
-      false)))
-
-(reset-stacks!)
-
-;; Multiple handlers: both matching handlers fire
-(let
-  ((log (list)))
-  (begin
-    (cl-handler-bind
-      (list
-        (list "error" (fn (c) (set! log (append log (list "e1")))))
-        (list "condition" (fn (c) (set! log (append log (list "e2"))))))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "x"))))
-    (assert-equal "handler-bind: both handlers fire" log (list "e1" "e2"))))
-
-(reset-stacks!)
-
-;; ── 6. cl-handler-case (unwinding) ───────────────────────────────────────
-
-;; Catches error, returns handler result
-(let
-  ((result (cl-handler-case (fn () (cl-error "boom") 99) (list "error" (fn (c) (str "caught: " (cl-condition-message c)))))))
-  (assert-equal "handler-case: catches error" result "caught: boom"))
-
-(reset-stacks!)
-
-;; Returns body result when no signal
-(let
-  ((result (cl-handler-case (fn () 42) (list "error" (fn (c) -1)))))
-  (assert-equal "handler-case: body result" result 42))
-
-(reset-stacks!)
-
-;; Only first matching handler runs (unwinding)
-(let
-  ((result (cl-handler-case (fn () (cl-error "x")) (list "simple-error" (fn (c) "simple")) (list "error" (fn (c) "error")))))
-  (assert-equal "handler-case: most specific wins" result "simple"))
-
-(reset-stacks!)
-
-;; ── 7. cl-warn ────────────────────────────────────────────────────────────
-
-(let
-  ((warned false))
-  (begin
-    (cl-handler-bind
-      (list (list "warning" (fn (c) (set! warned true))))
-      (fn () (cl-warn "be careful")))
-    (assert-true "cl-warn: fires warning handler" warned)))
-
-(reset-stacks!)
-
-;; Warn with condition object
-(let
-  ((msg ""))
-  (begin
-    (cl-handler-bind
-      (list (list "warning" (fn (c) (set! msg (cl-condition-message c)))))
-      (fn
-        ()
-        (cl-warn
-          (cl-make-condition "simple-warning" "format-control" "take care"))))
-    (assert-equal "cl-warn: condition object" msg "take care")))
-
-(reset-stacks!)
-
-;; ── 8. cl-restart-case + cl-invoke-restart ───────────────────────────────
-
-;; Basic restart invocation
-(let
-  ((result (cl-restart-case (fn () (cl-invoke-restart "use-zero")) (list "use-zero" (list) (fn () 0)))))
-  (assert-equal "restart-case: invoke-restart use-zero" result 0))
-
-(reset-stacks!)
-
-;; Restart with argument
-(let
-  ((result (cl-restart-case (fn () (cl-invoke-restart "use-value" 77)) (list "use-value" (list "v") (fn (v) v)))))
-  (assert-equal "restart-case: invoke-restart with arg" result 77))
-
-(reset-stacks!)
-
-;; Body returns normally when restart not invoked
-(let
-  ((result (cl-restart-case (fn () 42) (list "never-used" (list) (fn () -1)))))
-  (assert-equal "restart-case: body result" result 42))
-
-(reset-stacks!)
-
-;; ── 9. cl-with-simple-restart ─────────────────────────────────────────────
-
-(let
-  ((result (cl-with-simple-restart "skip" "Skip this step" (fn () (cl-invoke-restart "skip") 99))))
-  (assert-nil "with-simple-restart: invoke returns nil" result))
-
-(reset-stacks!)
-
-;; ── 10. cl-find-restart ───────────────────────────────────────────────────
-
-(let
-  ((found (cl-restart-case (fn () (cl-find-restart "retry")) (list "retry" (list) (fn () nil)))))
-  (assert-true "find-restart: finds active restart" (not (nil? found))))
-
-(reset-stacks!)
-
-(let
-  ((not-found (cl-restart-case (fn () (cl-find-restart "nonexistent")) (list "retry" (list) (fn () nil)))))
-  (assert-nil "find-restart: nil for inactive restart" not-found))
-
-(reset-stacks!)
-
-;; ── 11. cl-compute-restarts ───────────────────────────────────────────────
-
-(let
-  ((names (cl-restart-case (fn () (cl-restart-case (fn () (cl-compute-restarts)) (list "inner" (list) (fn () nil)))) (list "outer" (list) (fn () nil)))))
-  (assert-equal
-    "compute-restarts: both restarts"
-    names
-    (list "inner" "outer")))
-
-(reset-stacks!)
-
-;; ── 12. handler-bind + restart-case interop ───────────────────────────────
-
-;; Classic CL pattern: error handler invokes a restart
-(let
-  ((result (cl-restart-case (fn () (cl-handler-bind (list (list "error" (fn (c) (cl-invoke-restart "use-zero")))) (fn () (cl-error "divide by zero")))) (list "use-zero" (list) (fn () 0)))))
-  (assert-equal "interop: handler invokes restart" result 0))
-
-(reset-stacks!)
-
-;; ── 13. cl-cerror ─────────────────────────────────────────────────────────
-
-;; When "continue" restart is invoked, cerror returns nil
-(let
-  ((result (cl-restart-case (fn () (cl-cerror "continue anyway" "something bad") 42) (list "continue" (list) (fn () "resumed")))))
-  (assert-true
-    "cerror: returns"
-    (or (nil? result) (= result 42) (= result "resumed"))))
-
-(reset-stacks!)
-
-;; ── 14. slot accessor helpers ─────────────────────────────────────────────
-
-(let
-  ((c (cl-make-condition "simple-error" "format-control" "msg" "format-arguments" (list 1 2))))
-  (begin
-    (assert-equal
-      "simple-condition-format-control"
-      (cl-simple-condition-format-control c)
-      "msg")
-    (assert-equal
-      "simple-condition-format-arguments"
-      (cl-simple-condition-format-arguments c)
-      (list 1 2))))
-
-(let
-  ((c (cl-make-condition "type-error" "datum" 42 "expected-type" "string")))
-  (begin
-    (assert-equal "type-error-datum" (cl-type-error-datum c) 42)
-    (assert-equal
-      "type-error-expected-type"
-      (cl-type-error-expected-type c)
-      "string")))
-
-(let
-  ((c (cl-make-condition "arithmetic-error" "operation" "/" "operands" (list 1 0))))
-  (begin
-    (assert-equal
-      "arithmetic-error-operation"
-      (cl-arithmetic-error-operation c)
-      "/")
-    (assert-equal
-      "arithmetic-error-operands"
-      (cl-arithmetic-error-operands c)
-      (list 1 0))))
-
-
-;; ── 15. *debugger-hook* ───────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(let ((received nil))
-  (begin
-    (set! cl-debugger-hook
-      (fn (c h)
-        (set! received (cl-condition-message c))
-        (cl-invoke-restart "escape")))
-    (cl-restart-case
-      (fn () (cl-error "debugger test"))
-      (list "escape" (list) (fn () nil)))
-    (set! cl-debugger-hook nil)
-    (assert-equal "debugger-hook receives condition"  received  "debugger test")))
-
-(reset-stacks!)
-
-;; ── 16. *break-on-signals* ────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(let ((triggered false))
-  (begin
-    (set! cl-break-on-signals "error")
-    (set! cl-debugger-hook
-      (fn (c h)
-        (set! triggered true)
-        (cl-invoke-restart "abort")))
-    (cl-restart-case
-      (fn ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "x")))
-      (list "abort" (list) (fn () nil)))
-    (set! cl-break-on-signals nil)
-    (set! cl-debugger-hook nil)
-    (assert-true "break-on-signals fires hook"  triggered)))
-
-(reset-stacks!)
-
-;; break-on-signals: non-matching type does NOT fire hook
-(let ((triggered false))
-  (begin
-    (set! cl-break-on-signals "error")
-    (set! cl-debugger-hook
-      (fn (c h) (set! triggered true) nil))
-    (cl-handler-bind
-      (list (list "warning" (fn (c) nil)))
-      (fn ()
-        (cl-signal (cl-make-condition "simple-warning" "format-control" "w"))))
-    (set! cl-break-on-signals nil)
-    (set! cl-debugger-hook nil)
-    (assert-equal "break-on-signals: type mismatch not triggered"  triggered  false)))
-
-(reset-stacks!)
-
-;; ── 17. cl-invoke-restart-interactively ──────────────────────────────────
-
-(let ((result
-        (cl-restart-case
-          (fn () (cl-invoke-restart-interactively "use-default"))
-          (list "use-default" (list) (fn () 99)))))
-  (assert-equal "invoke-restart-interactively: returns restart value"  result  99))
-
-(reset-stacks!)
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(if
-  (= failed 0)
-  (print (str "ok " passed "/" (+ passed failed) " condition tests passed"))
-  (begin
-    (for-each (fn (f) (print f)) failures)
-    (print
-      (str "FAIL " passed "/" (+ passed failed) " passed, " failed " failed"))))

lib/common-lisp/tests/eval.sx

@@ -1,466 +0,0 @@
-;; CL evaluator tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-(define
-  cl-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) (cl-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
-              chk
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (cl-deep= (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (chk)))))
-            (chk)
-            ok)))
-      (:else false))))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (cl-deep= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; Convenience: evaluate CL string with fresh env each time
-(define ev (fn (src) (cl-eval-str src (cl-make-env))))
-(define evall (fn (src) (cl-eval-all-str src (cl-make-env))))
-
-;; ── self-evaluating literals ──────────────────────────────────────
-
-(cl-test "lit: nil" (ev "nil") nil)
-(cl-test "lit: t" (ev "t") true)
-(cl-test "lit: integer" (ev "42") 42)
-(cl-test "lit: negative" (ev "-7") -7)
-(cl-test "lit: zero" (ev "0") 0)
-(cl-test "lit: string" (ev "\"hello\"") "hello")
-(cl-test "lit: empty string" (ev "\"\"") "")
-(cl-test "lit: keyword type" (get (ev ":foo") "cl-type") "keyword")
-(cl-test "lit: keyword name" (get (ev ":foo") "name") "FOO")
-(cl-test "lit: float type" (get (ev "3.14") "cl-type") "float")
-
-;; ── QUOTE ─────────────────────────────────────────────────────────
-
-(cl-test "quote: symbol" (ev "'x") "X")
-(cl-test "quote: list" (ev "'(a b c)") (list "A" "B" "C"))
-(cl-test "quote: nil" (ev "'nil") nil)
-(cl-test "quote: integer" (ev "'42") 42)
-(cl-test "quote: nested" (ev "'(a (b c))") (list "A" (list "B" "C")))
-
-;; ── IF ────────────────────────────────────────────────────────────
-
-(cl-test "if: true branch" (ev "(if t 1 2)") 1)
-(cl-test "if: false branch" (ev "(if nil 1 2)") 2)
-(cl-test "if: no else nil" (ev "(if nil 99)") nil)
-(cl-test "if: number truthy" (ev "(if 0 'yes 'no)") "YES")
-(cl-test "if: empty string truthy" (ev "(if \"\" 'yes 'no)") "YES")
-(cl-test "if: nested" (ev "(if t (if nil 1 2) 3)") 2)
-
-;; ── PROGN ────────────────────────────────────────────────────────
-
-(cl-test "progn: single" (ev "(progn 42)") 42)
-(cl-test "progn: multiple" (ev "(progn 1 2 3)") 3)
-(cl-test "progn: nil last" (ev "(progn 1 nil)") nil)
-
-;; ── AND / OR ─────────────────────────────────────────────────────
-
-(cl-test "and: empty" (ev "(and)") true)
-(cl-test "and: all true" (ev "(and 1 2 3)") 3)
-(cl-test "and: short-circuit" (ev "(and nil 99)") nil)
-(cl-test "and: returns last" (ev "(and 1 2)") 2)
-(cl-test "or: empty" (ev "(or)") nil)
-(cl-test "or: first truthy" (ev "(or 1 2)") 1)
-(cl-test "or: all nil" (ev "(or nil nil)") nil)
-(cl-test "or: short-circuit" (ev "(or nil 42)") 42)
-
-;; ── COND ─────────────────────────────────────────────────────────
-
-(cl-test "cond: first match" (ev "(cond (t 1) (t 2))") 1)
-(cl-test "cond: second match" (ev "(cond (nil 1) (t 2))") 2)
-(cl-test "cond: no match" (ev "(cond (nil 1) (nil 2))") nil)
-(cl-test "cond: returns test value" (ev "(cond (42))") 42)
-
-;; ── WHEN / UNLESS ─────────────────────────────────────────────────
-
-(cl-test "when: true" (ev "(when t 1 2 3)") 3)
-(cl-test "when: nil" (ev "(when nil 99)") nil)
-(cl-test "unless: nil runs" (ev "(unless nil 42)") 42)
-(cl-test "unless: true skips" (ev "(unless t 99)") nil)
-
-;; ── LET ──────────────────────────────────────────────────────────
-
-(cl-test "let: empty bindings" (ev "(let () 42)") 42)
-(cl-test "let: single binding" (ev "(let ((x 5)) x)") 5)
-(cl-test "let: two bindings" (ev "(let ((x 3) (y 4)) (+ x y))") 7)
-(cl-test "let: parallel" (ev "(let ((x 1)) (let ((x 2) (y x)) y))") 1)
-(cl-test "let: nested" (ev "(let ((x 1)) (let ((y 2)) (+ x y)))") 3)
-(cl-test "let: progn body" (ev "(let ((x 5)) (+ x 1) (* x 2))") 10)
-(cl-test "let: bare name nil" (ev "(let (x) x)") nil)
-
-;; ── LET* ─────────────────────────────────────────────────────────
-
-(cl-test "let*: sequential" (ev "(let* ((x 1) (y (+ x 1))) y)") 2)
-(cl-test "let*: chain" (ev "(let* ((a 2) (b (* a 3)) (c (+ b 1))) c)") 7)
-(cl-test "let*: shadow" (ev "(let ((x 1)) (let* ((x 2) (y x)) y))") 2)
-
-;; ── SETQ / SETF ──────────────────────────────────────────────────
-
-(cl-test "setq: basic" (ev "(let ((x 0)) (setq x 5) x)") 5)
-(cl-test "setq: returns value" (ev "(let ((x 0)) (setq x 99))") 99)
-(cl-test "setf: basic" (ev "(let ((x 0)) (setf x 7) x)") 7)
-
-;; ── LAMBDA ────────────────────────────────────────────────────────
-
-(cl-test "lambda: call" (ev "((lambda (x) x) 42)") 42)
-(cl-test "lambda: multi-arg" (ev "((lambda (x y) (+ x y)) 3 4)") 7)
-(cl-test "lambda: closure" (ev "(let ((n 10)) ((lambda (x) (+ x n)) 5))") 15)
-(cl-test "lambda: rest arg"
-  (ev "((lambda (x &rest xs) (cons x xs)) 1 2 3)")
-  {:cl-type "cons" :car 1 :cdr (list 2 3)})
-(cl-test "lambda: optional no default"
-  (ev "((lambda (&optional x) x))")
-  nil)
-(cl-test "lambda: optional with arg"
-  (ev "((lambda (&optional (x 99)) x) 42)")
-  42)
-(cl-test "lambda: optional default used"
-  (ev "((lambda (&optional (x 7)) x))")
-  7)
-
-;; ── FUNCTION ─────────────────────────────────────────────────────
-
-(cl-test "function: lambda" (get (ev "(function (lambda (x) x))") "cl-type") "function")
-
-;; ── DEFUN ────────────────────────────────────────────────────────
-
-(cl-test "defun: returns name" (evall "(defun sq (x) (* x x))") "SQ")
-(cl-test "defun: call" (evall "(defun sq (x) (* x x)) (sq 5)") 25)
-(cl-test "defun: multi-arg" (evall "(defun add (x y) (+ x y)) (add 3 4)") 7)
-(cl-test "defun: recursive factorial"
-  (evall "(defun fact (n) (if (<= n 1) 1 (* n (fact (- n 1))))) (fact 5)")
-  120)
-(cl-test "defun: multiple calls"
-  (evall "(defun double (x) (* x 2)) (+ (double 3) (double 5))")
-  16)
-
-;; ── FLET ─────────────────────────────────────────────────────────
-
-(cl-test "flet: basic"
-  (ev "(flet ((double (x) (* x 2))) (double 5))")
-  10)
-(cl-test "flet: sees outer vars"
-  (ev "(let ((n 3)) (flet ((add-n (x) (+ x n))) (add-n 7)))")
-  10)
-(cl-test "flet: non-recursive"
-  (ev "(flet ((f (x) (+ x 1))) (flet ((f (x) (f (f x)))) (f 5)))")
-  7)
-
-;; ── LABELS ────────────────────────────────────────────────────────
-
-(cl-test "labels: basic"
-  (ev "(labels ((greet (x) x)) (greet 42))")
-  42)
-(cl-test "labels: recursive"
-  (ev "(labels ((count (n) (if (<= n 0) 0 (+ 1 (count (- n 1)))))) (count 5))")
-  5)
-(cl-test "labels: mutual recursion"
-  (ev "(labels
-         ((even? (n) (if (= n 0) t  (odd? (- n 1))))
-          (odd?  (n) (if (= n 0) nil   (even? (- n 1)))))
-         (list (even? 4) (odd? 3)))")
-  (list true true))
-
-;; ── THE / LOCALLY / EVAL-WHEN ────────────────────────────────────
-
-(cl-test "the: passthrough" (ev "(the integer 42)") 42)
-(cl-test "the: string" (ev "(the string \"hi\")") "hi")
-(cl-test "locally: body" (ev "(locally 1 2 3)") 3)
-(cl-test "eval-when: execute" (ev "(eval-when (:execute) 99)") 99)
-(cl-test "eval-when: no execute" (ev "(eval-when (:compile-toplevel) 99)") nil)
-
-;; ── DEFVAR / DEFPARAMETER ────────────────────────────────────────
-
-(cl-test "defvar: returns name" (evall "(defvar *x* 10)") "*X*")
-(cl-test "defparameter: sets value" (evall "(defparameter *y* 42) *y*") 42)
-(cl-test "defvar: no reinit" (evall "(defvar *z* 1) (defvar *z* 99) *z*") 1)
-
-;; ── built-in arithmetic ───────────────────────────────────────────
-
-(cl-test "arith: +" (ev "(+ 1 2 3)") 6)
-(cl-test "arith: + zero" (ev "(+)") 0)
-(cl-test "arith: -" (ev "(- 10 3 2)") 5)
-(cl-test "arith: - negate" (ev "(- 5)") -5)
-(cl-test "arith: *" (ev "(* 2 3 4)") 24)
-(cl-test "arith: * one" (ev "(*)") 1)
-(cl-test "arith: /" (ev "(/ 12 3)") 4)
-(cl-test "arith: max" (ev "(max 3 1 4 1 5)") 5)
-(cl-test "arith: min" (ev "(min 3 1 4 1 5)") 1)
-(cl-test "arith: abs neg" (ev "(abs -7)") 7)
-(cl-test "arith: abs pos" (ev "(abs 7)") 7)
-
-;; ── built-in comparisons ──────────────────────────────────────────
-
-(cl-test "cmp: = true" (ev "(= 3 3)") true)
-(cl-test "cmp: = false" (ev "(= 3 4)") nil)
-(cl-test "cmp: /=" (ev "(/= 3 4)") true)
-(cl-test "cmp: <" (ev "(< 1 2)") true)
-(cl-test "cmp: > false" (ev "(> 1 2)") nil)
-(cl-test "cmp: <=" (ev "(<= 2 2)") true)
-
-;; ── built-in predicates ───────────────────────────────────────────
-
-(cl-test "pred: null nil" (ev "(null nil)") true)
-(cl-test "pred: null non-nil" (ev "(null 5)") nil)
-(cl-test "pred: not nil" (ev "(not nil)") true)
-(cl-test "pred: not truthy" (ev "(not 5)") nil)
-(cl-test "pred: numberp" (ev "(numberp 5)") true)
-(cl-test "pred: numberp str" (ev "(numberp \"x\")") nil)
-(cl-test "pred: stringp" (ev "(stringp \"hello\")") true)
-(cl-test "pred: listp list" (ev "(listp '(1))") true)
-(cl-test "pred: listp nil" (ev "(listp nil)") true)
-(cl-test "pred: zerop" (ev "(zerop 0)") true)
-(cl-test "pred: plusp" (ev "(plusp 3)") true)
-(cl-test "pred: evenp" (ev "(evenp 4)") true)
-(cl-test "pred: oddp" (ev "(oddp 3)") true)
-
-;; ── built-in list ops ─────────────────────────────────────────────
-
-(cl-test "list: car" (ev "(car '(1 2 3))") 1)
-(cl-test "list: cdr" (ev "(cdr '(1 2 3))") (list 2 3))
-(cl-test "list: cons" (get (ev "(cons 1 2)") "car") 1)
-(cl-test "list: list fn" (ev "(list 1 2 3)") (list 1 2 3))
-(cl-test "list: length" (ev "(length '(a b c))") 3)
-(cl-test "list: length nil" (ev "(length nil)") 0)
-(cl-test "list: append" (ev "(append '(1 2) '(3 4))") (list 1 2 3 4))
-(cl-test "list: first" (ev "(first '(10 20 30))") 10)
-(cl-test "list: second" (ev "(second '(10 20 30))") 20)
-(cl-test "list: third" (ev "(third '(10 20 30))") 30)
-(cl-test "list: rest" (ev "(rest '(1 2 3))") (list 2 3))
-(cl-test "list: nth" (ev "(nth 1 '(a b c))") "B")
-(cl-test "list: reverse" (ev "(reverse '(1 2 3))") (list 3 2 1))
-
-;; ── FUNCALL / APPLY / MAPCAR ─────────────────────────────────────
-
-(cl-test "funcall: lambda"
-  (ev "(funcall (lambda (x) (* x x)) 5)")
-  25)
-(cl-test "apply: basic"
-  (ev "(apply #'+ '(1 2 3))")
-  6)
-(cl-test "apply: leading args"
-  (ev "(apply #'+ 1 2 '(3 4))")
-  10)
-(cl-test "mapcar: basic"
-  (ev "(mapcar (lambda (x) (* x 2)) '(1 2 3))")
-  (list 2 4 6))
-
-;; ── BLOCK / RETURN-FROM / RETURN ─────────────────────────────────
-
-(cl-test "block: last form value"
-  (ev "(block done 1 2 3)")
-  3)
-(cl-test "block: empty body"
-  (ev "(block done)")
-  nil)
-(cl-test "block: single form"
-  (ev "(block foo 42)")
-  42)
-(cl-test "block: return-from"
-  (ev "(block done 1 (return-from done 99) 2)")
-  99)
-(cl-test "block: return-from nil block"
-  (ev "(block nil 1 (return-from nil 42) 3)")
-  42)
-(cl-test "block: return-from no value"
-  (ev "(block done (return-from done))")
-  nil)
-(cl-test "block: nested inner return stays inner"
-  (ev "(block outer (block inner (return-from inner 1) 2) 3)")
-  3)
-(cl-test "block: nested outer return"
-  (ev "(block outer (block inner 1 2) (return-from outer 99) 3)")
-  99)
-(cl-test "return: shorthand for nil block"
-  (ev "(block nil (return 77))")
-  77)
-(cl-test "return: no value"
-  (ev "(block nil 1 (return) 2)")
-  nil)
-(cl-test "block: return-from inside let"
-  (ev "(block done (let ((x 5)) (when (> x 3) (return-from done x))) 0)")
-  5)
-(cl-test "block: return-from inside progn"
-  (ev "(block done (progn (return-from done 7) 99))")
-  7)
-(cl-test "block: return-from through function"
-  (ev "(block done (flet ((f () (return-from done 42))) (f)) nil)")
-  42)
-
-;; ── TAGBODY / GO ─────────────────────────────────────────────────
-
-(cl-test "tagbody: empty returns nil"
-  (ev "(tagbody)")
-  nil)
-(cl-test "tagbody: forms only, returns nil"
-  (ev "(let ((x 0)) (tagbody (setq x 1) (setq x 2)) x)")
-  2)
-(cl-test "tagbody: tag only, returns nil"
-  (ev "(tagbody done)")
-  nil)
-(cl-test "tagbody: go skips forms"
-  (ev "(let ((x 0)) (tagbody (go done) (setq x 99) done) x)")
-  0)
-(cl-test "tagbody: go to later tag"
-  (ev "(let ((x 0)) (tagbody start (setq x (+ x 1)) (go done) (setq x 99) done) x)")
-  1)
-(cl-test "tagbody: loop with counter"
-  (ev "(let ((n 0)) (tagbody loop (when (>= n 3) (go done)) (setq n (+ n 1)) (go loop) done) n)")
-  3)
-(cl-test "tagbody: go inside when"
-  (ev "(let ((x 0)) (tagbody (setq x 1) (when t (go done)) (setq x 99) done) x)")
-  1)
-(cl-test "tagbody: go inside progn"
-  (ev "(let ((x 0)) (tagbody (progn (setq x 1) (go done)) (setq x 99) done) x)")
-  1)
-(cl-test "tagbody: go inside let"
-  (ev "(let ((acc 0)) (tagbody (let ((y 5)) (when (> y 3) (go done))) (setq acc 99) done) acc)")
-  0)
-(cl-test "tagbody: integer tags"
-  (ev "(let ((x 0)) (tagbody (go 2) 1 (setq x 1) (go 3) 2 (setq x 2) (go 3) 3) x)")
-  2)
-(cl-test "tagbody: block-return propagates out"
-  (ev "(block done (tagbody (return-from done 42)) nil)")
-  42)
-
-;; ── UNWIND-PROTECT ───────────────────────────────────────────────
-
-(cl-test "unwind-protect: normal returns protected"
-  (ev "(unwind-protect 42 nil)")
-  42)
-(cl-test "unwind-protect: cleanup runs"
-  (ev "(let ((x 0)) (unwind-protect 1 (setq x 99)) x)")
-  99)
-(cl-test "unwind-protect: cleanup result ignored"
-  (ev "(unwind-protect 42 777)")
-  42)
-(cl-test "unwind-protect: multiple cleanup forms"
-  (ev "(let ((x 0)) (unwind-protect 1 (setq x (+ x 1)) (setq x (+ x 1))) x)")
-  2)
-(cl-test "unwind-protect: cleanup on return-from"
-  (ev "(let ((x 0)) (block done (unwind-protect (return-from done 7) (setq x 99))) x)")
-  99)
-(cl-test "unwind-protect: return-from still propagates"
-  (ev "(block done (unwind-protect (return-from done 42) nil))")
-  42)
-(cl-test "unwind-protect: cleanup on go"
-  (ev "(let ((x 0)) (tagbody (unwind-protect (go done) (setq x 1)) done) x)")
-  1)
-(cl-test "unwind-protect: nested, inner cleanup first"
-  (ev "(let ((n 0)) (unwind-protect (unwind-protect 1 (setq n (+ n 10))) (setq n (+ n 1))) n)")
-  11)
-
-;; ── VALUES / MULTIPLE-VALUE-BIND / NTH-VALUE ────────────────────
-
-(cl-test "values: single returns plain"
-  (ev "(values 42)")
-  42)
-(cl-test "values: zero returns nil"
-  (ev "(values)")
-  nil)
-(cl-test "values: multi — primary via funcall"
-  (ev "(car (list (values 1 2)))")
-  1)
-(cl-test "multiple-value-bind: basic"
-  (ev "(multiple-value-bind (a b) (values 1 2) (+ a b))")
-  3)
-(cl-test "multiple-value-bind: extra vars get nil"
-  (ev "(multiple-value-bind (a b c) (values 10 20) (list a b c))")
-  (list 10 20 nil))
-(cl-test "multiple-value-bind: extra values ignored"
-  (ev "(multiple-value-bind (a) (values 1 2 3) a)")
-  1)
-(cl-test "multiple-value-bind: single value source"
-  (ev "(multiple-value-bind (a b) 42 (list a b))")
-  (list 42 nil))
-(cl-test "nth-value: 0"
-  (ev "(nth-value 0 (values 10 20 30))")
-  10)
-(cl-test "nth-value: 1"
-  (ev "(nth-value 1 (values 10 20 30))")
-  20)
-(cl-test "nth-value: out of range"
-  (ev "(nth-value 5 (values 10 20))")
-  nil)
-(cl-test "multiple-value-call: basic"
-  (ev "(multiple-value-call #'+ (values 1 2) (values 3 4))")
-  10)
-(cl-test "multiple-value-prog1: returns first"
-  (ev "(multiple-value-prog1 1 2 3)")
-  1)
-(cl-test "multiple-value-prog1: side effects run"
-  (ev "(let ((x 0)) (multiple-value-prog1 99 (setq x 7)) x)")
-  7)
-(cl-test "values: nil primary in if"
-  (ev "(if (values nil t) 'yes 'no)")
-  "NO")
-(cl-test "values: truthy primary in if"
-  (ev "(if (values 42 nil) 'yes 'no)")
-  "YES")
-
-;; --- Dynamic variables ---
-(cl-test "defvar marks special"
-  (do (ev "(defvar *dv* 10)")
-    (cl-special? "*DV*"))
-  true)
-(cl-test "defvar: let rebinds dynamically"
-  (ev "(progn (defvar *x* 1) (defun get-x () *x*) (let ((*x* 99)) (get-x)))")
-  99)
-(cl-test "defvar: binding restores after let"
-  (ev "(progn (defvar *yrst* 5) (let ((*yrst* 42)) *yrst*) *yrst*)")
-  5)
-(cl-test "defparameter marks special"
-  (do (ev "(defparameter *dp* 0)")
-    (cl-special? "*DP*"))
-  true)
-(cl-test "defparameter: let rebinds dynamically"
-  (ev "(progn (defparameter *z* 10) (defun get-z () *z*) (let ((*z* 77)) (get-z)))")
-  77)
-(cl-test "defparameter: always assigns"
-  (ev "(progn (defparameter *p* 1) (defparameter *p* 2) *p*)")
-  2)
-(cl-test "dynamic binding: nested lets"
-  (ev "(progn (defvar *n* 0) (let ((*n* 1)) (let ((*n* 2)) *n*)))")
-  2)
-(cl-test "dynamic binding: restores across nesting"
-  (ev "(progn (defvar *m* 10) (let ((*m* 20)) (let ((*m* 30)) nil)) *m*)")
-  10)

lib/common-lisp/tests/lambda.sx

@@ -1,204 +0,0 @@
-;; Lambda list parser tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-;; Deep structural equality for dicts and lists
-(define
-  cl-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) (cl-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
-              chk
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (cl-deep= (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (chk)))))
-            (chk)
-            ok)))
-      (:else false))))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (cl-deep= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; Helper: parse lambda list from string "(x y ...)"
-(define ll (fn (src) (cl-parse-lambda-list-str src)))
-(define ll-req  (fn (src) (get (ll src) "required")))
-(define ll-opt  (fn (src) (get (ll src) "optional")))
-(define ll-rest (fn (src) (get (ll src) "rest")))
-(define ll-key  (fn (src) (get (ll src) "key")))
-(define ll-aok  (fn (src) (get (ll src) "allow-other-keys")))
-(define ll-aux  (fn (src) (get (ll src) "aux")))
-
-;; ── required parameters ───────────────────────────────────────────
-
-(cl-test "required: empty" (ll-req "()") (list))
-(cl-test "required: one" (ll-req "(x)") (list "X"))
-(cl-test "required: two" (ll-req "(x y)") (list "X" "Y"))
-(cl-test "required: three" (ll-req "(a b c)") (list "A" "B" "C"))
-(cl-test "required: upcased" (ll-req "(foo bar)") (list "FOO" "BAR"))
-
-;; ── &optional ─────────────────────────────────────────────────────
-
-(cl-test "optional: none" (ll-opt "(x)") (list))
-
-(cl-test
-  "optional: bare symbol"
-  (ll-opt "(x &optional z)")
-  (list {:name "Z" :default nil :supplied nil}))
-
-(cl-test
-  "optional: with default"
-  (ll-opt "(x &optional (z 0))")
-  (list {:name "Z" :default 0 :supplied nil}))
-
-(cl-test
-  "optional: with supplied-p"
-  (ll-opt "(x &optional (z 0 z-p))")
-  (list {:name "Z" :default 0 :supplied "Z-P"}))
-
-(cl-test
-  "optional: two params"
-  (ll-opt "(&optional a (b 1))")
-  (list {:name "A" :default nil :supplied nil} {:name "B" :default 1 :supplied nil}))
-
-(cl-test
-  "optional: string default"
-  (ll-opt "(&optional (name \"world\"))")
-  (list {:name "NAME" :default {:cl-type "string" :value "world"} :supplied nil}))
-
-;; ── &rest ─────────────────────────────────────────────────────────
-
-(cl-test "rest: none" (ll-rest "(x)") nil)
-(cl-test "rest: present" (ll-rest "(x &rest args)") "ARGS")
-(cl-test "rest: with required" (ll-rest "(a b &rest tail)") "TAIL")
-
-;; &body is an alias for &rest
-(cl-test "body: alias for rest" (ll-rest "(&body forms)") "FORMS")
-
-;; rest doesn't consume required params
-(cl-test "rest: required still there" (ll-req "(a b &rest rest)") (list "A" "B"))
-
-;; ── &key ──────────────────────────────────────────────────────────
-
-(cl-test "key: none" (ll-key "(x)") (list))
-
-(cl-test
-  "key: bare symbol"
-  (ll-key "(&key x)")
-  (list {:name "X" :keyword "X" :default nil :supplied nil}))
-
-(cl-test
-  "key: with default"
-  (ll-key "(&key (x 42))")
-  (list {:name "X" :keyword "X" :default 42 :supplied nil}))
-
-(cl-test
-  "key: with supplied-p"
-  (ll-key "(&key (x 42 x-p))")
-  (list {:name "X" :keyword "X" :default 42 :supplied "X-P"}))
-
-(cl-test
-  "key: two params"
-  (ll-key "(&key a b)")
-  (list
-    {:name "A" :keyword "A" :default nil :supplied nil}
-    {:name "B" :keyword "B" :default nil :supplied nil}))
-
-;; ── &allow-other-keys ─────────────────────────────────────────────
-
-(cl-test "aok: absent" (ll-aok "(x)") false)
-(cl-test "aok: present" (ll-aok "(&key x &allow-other-keys)") true)
-
-;; ── &aux ──────────────────────────────────────────────────────────
-
-(cl-test "aux: none" (ll-aux "(x)") (list))
-
-(cl-test
-  "aux: bare symbol"
-  (ll-aux "(&aux temp)")
-  (list {:name "TEMP" :init nil}))
-
-(cl-test
-  "aux: with init"
-  (ll-aux "(&aux (count 0))")
-  (list {:name "COUNT" :init 0}))
-
-(cl-test
-  "aux: two vars"
-  (ll-aux "(&aux a (b 1))")
-  (list {:name "A" :init nil} {:name "B" :init 1}))
-
-;; ── combined ──────────────────────────────────────────────────────
-
-(cl-test
-  "combined: full lambda list"
-  (let
-    ((parsed (ll "(x y &optional (z 0 z-p) &rest args &key a (b nil b-p) &aux temp)")))
-    (list
-      (get parsed "required")
-      (get (nth (get parsed "optional") 0) "name")
-      (get (nth (get parsed "optional") 0) "default")
-      (get (nth (get parsed "optional") 0) "supplied")
-      (get parsed "rest")
-      (get (nth (get parsed "key") 0) "name")
-      (get (nth (get parsed "key") 1) "supplied")
-      (get (nth (get parsed "aux") 0) "name")))
-  (list
-    (list "X" "Y")
-    "Z"
-    0
-    "Z-P"
-    "ARGS"
-    "A"
-    "B-P"
-    "TEMP"))
-
-(cl-test
-  "combined: required only stops before &"
-  (ll-req "(a b &optional c)")
-  (list "A" "B"))
-
-(cl-test
-  "combined: required only with &key"
-  (ll-req "(x &key y)")
-  (list "X"))
-
-(cl-test
-  "combined: &rest and &key together"
-  (let
-    ((parsed (ll "(&rest args &key verbose)")))
-    (list (get parsed "rest") (get (nth (get parsed "key") 0) "name")))
-  (list "ARGS" "VERBOSE"))

lib/common-lisp/tests/macros.sx

@@ -1,204 +0,0 @@
-;; lib/common-lisp/tests/macros.sx — Phase 5: defmacro, gensym, LOOP tests
-;;
-;; Depends on: runtime.sx, eval.sx, loop.sx already loaded.
-;; Tests via (ev "...") using the CL evaluator.
-
-(define ev (fn (src) (cl-eval-str src (cl-make-env))))
-(define evall (fn (src) (cl-eval-all-str src (cl-make-env))))
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-;; ── defmacro basics ──────────────────────────────────────────────────────────
-
-(check
-  "defmacro returns name"
-  (ev "(defmacro my-or (a b) (list 'if a a b))")
-  "MY-OR")
-
-(check
-  "defmacro expansion works"
-  (ev "(progn (defmacro my-inc (x) (list '+ x 1)) (my-inc 5))")
-  6)
-
-(check
-  "defmacro with &rest"
-  (ev "(progn (defmacro my-list (&rest xs) (cons 'list xs)) (my-list 1 2 3))")
-  (list 1 2 3))
-
-(check
-  "nested macro expansion"
-  (ev "(progn (defmacro sq (x) (list '* x x)) (sq 7))")
-  49)
-
-(check
-  "macro in conditional"
-  (ev
-    "(progn (defmacro my-when (c &rest body) (list 'if c (cons 'progn body) nil)) (my-when t 10 20))")
-  20)
-
-(check
-  "macro returns nil branch"
-  (ev
-    "(progn (defmacro my-when (c &rest body) (list 'if c (cons 'progn body) nil)) (my-when nil 42))")
-  nil)
-
-;; ── macroexpand ───────────────────────────────────────────────────────────────
-
-(check
-  "macroexpand returns expanded form"
-  (ev "(progn (defmacro double (x) (list '+ x x)) (macroexpand '(double 5)))")
-  (list "+" 5 5))
-
-;; ── gensym ────────────────────────────────────────────────────────────────────
-
-(check "gensym returns string" (ev "(stringp (gensym))") true)
-
-(check
-  "gensym prefix"
-  (ev "(let ((g (gensym \"MY\"))) (not (= g nil)))")
-  true)
-
-(check "gensyms are unique" (ev "(not (= (gensym) (gensym)))") true)
-
-;; ── swap! macro with gensym ───────────────────────────────────────────────────
-
-(check
-  "swap! macro"
-  (evall
-    "(defmacro swap! (a b) (let ((tmp (gensym))) (list 'let (list (list tmp a)) (list 'setq a b) (list 'setq b tmp)))) (defvar *a* 10) (defvar *b* 20) (swap! *a* *b*) (list *a* *b*)")
-  (list 20 10))
-
-;; ── LOOP: basic repeat and collect ────────────────────────────────────────────
-
-(check
-  "loop repeat collect"
-  (ev "(loop repeat 3 collect 99)")
-  (list 99 99 99))
-
-(check
-  "loop for-in collect"
-  (ev "(loop for x in '(1 2 3) collect (* x x))")
-  (list 1 4 9))
-
-(check
-  "loop for-from-to collect"
-  (ev "(loop for i from 1 to 5 collect i)")
-  (list 1 2 3 4 5))
-
-(check
-  "loop for-from-below collect"
-  (ev "(loop for i from 0 below 4 collect i)")
-  (list 0 1 2 3))
-
-(check
-  "loop for-downto collect"
-  (ev "(loop for i from 5 downto 1 collect i)")
-  (list 5 4 3 2 1))
-
-(check
-  "loop for-by collect"
-  (ev "(loop for i from 0 to 10 by 2 collect i)")
-  (list 0 2 4 6 8 10))
-
-;; ── LOOP: sum, count, maximize, minimize ─────────────────────────────────────
-
-(check "loop sum" (ev "(loop for i from 1 to 5 sum i)") 15)
-
-(check
-  "loop count"
-  (ev "(loop for x in '(1 2 3 4 5) count (> x 3))")
-  2)
-
-(check
-  "loop maximize"
-  (ev "(loop for x in '(3 1 4 1 5 9 2 6) maximize x)")
-  9)
-
-(check
-  "loop minimize"
-  (ev "(loop for x in '(3 1 4 1 5 9 2 6) minimize x)")
-  1)
-
-;; ── LOOP: while and until ─────────────────────────────────────────────────────
-
-(check
-  "loop while"
-  (ev "(loop for i from 1 to 10 while (< i 5) collect i)")
-  (list 1 2 3 4))
-
-(check
-  "loop until"
-  (ev "(loop for i from 1 to 10 until (= i 5) collect i)")
-  (list 1 2 3 4))
-
-;; ── LOOP: when / unless ───────────────────────────────────────────────────────
-
-(check
-  "loop when filter"
-  (ev "(loop for i from 0 below 8 when (evenp i) collect i)")
-  (list 0 2 4 6))
-
-(check
-  "loop unless filter"
-  (ev "(loop for i from 0 below 8 unless (evenp i) collect i)")
-  (list 1 3 5 7))
-
-;; ── LOOP: append ─────────────────────────────────────────────────────────────
-
-(check
-  "loop append"
-  (ev "(loop for x in '((1 2) (3 4) (5 6)) append x)")
-  (list 1 2 3 4 5 6))
-
-;; ── LOOP: always, never, thereis ─────────────────────────────────────────────
-
-(check
-  "loop always true"
-  (ev "(loop for x in '(2 4 6) always (evenp x))")
-  true)
-
-(check
-  "loop always false"
-  (ev "(loop for x in '(2 3 6) always (evenp x))")
-  false)
-
-(check "loop never" (ev "(loop for x in '(1 3 5) never (evenp x))") true)
-
-(check "loop thereis" (ev "(loop for x in '(1 2 3) thereis (> x 2))") true)
-
-;; ── LOOP: for = then (general iteration) ─────────────────────────────────────
-
-(check
-  "loop for = then doubling"
-  (ev "(loop repeat 5 for x = 1 then (* x 2) collect x)")
-  (list 1 2 4 8 16))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define macro-passed passed)
-(define macro-failed failed)
-(define macro-failures failures)

lib/common-lisp/tests/parse.sx

@@ -1,160 +0,0 @@
-;; Common Lisp reader/parser tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-(define
-  cl-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) (cl-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
-              chk
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (cl-deep= (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (chk)))))
-            (chk)
-            ok)))
-      (:else false))))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (cl-deep= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; ── atoms ─────────────────────────────────────────────────────────
-
-(cl-test "integer: 42" (cl-read "42") 42)
-(cl-test "integer: 0" (cl-read "0") 0)
-(cl-test "integer: negative" (cl-read "-5") -5)
-(cl-test "integer: positive sign" (cl-read "+3") 3)
-(cl-test "integer: hex #xFF" (cl-read "#xFF") 255)
-(cl-test "integer: hex #xAB" (cl-read "#xAB") 171)
-(cl-test "integer: binary #b1010" (cl-read "#b1010") 10)
-(cl-test "integer: octal #o17" (cl-read "#o17") 15)
-
-(cl-test "float: type" (get (cl-read "3.14") "cl-type") "float")
-(cl-test "float: value" (get (cl-read "3.14") "value") "3.14")
-(cl-test "float: neg" (get (cl-read "-2.5") "value") "-2.5")
-(cl-test "float: exp" (get (cl-read "1.0e10") "value") "1.0e10")
-
-(cl-test "ratio: type" (get (cl-read "1/3") "cl-type") "ratio")
-(cl-test "ratio: value" (get (cl-read "1/3") "value") "1/3")
-(cl-test "ratio: 22/7" (get (cl-read "22/7") "value") "22/7")
-
-(cl-test "string: basic" (cl-read "\"hello\"") {:cl-type "string" :value "hello"})
-(cl-test "string: empty" (cl-read "\"\"") {:cl-type "string" :value ""})
-(cl-test "string: with escape" (cl-read "\"a\\nb\"") {:cl-type "string" :value "a\nb"})
-
-(cl-test "symbol: foo" (cl-read "foo") "FOO")
-(cl-test "symbol: BAR" (cl-read "BAR") "BAR")
-(cl-test "symbol: pkg:sym" (cl-read "cl:car") "CL:CAR")
-(cl-test "symbol: pkg::sym" (cl-read "pkg::foo") "PKG::FOO")
-
-(cl-test "nil: symbol" (cl-read "nil") nil)
-(cl-test "nil: uppercase" (cl-read "NIL") nil)
-(cl-test "t: symbol" (cl-read "t") true)
-(cl-test "t: uppercase" (cl-read "T") true)
-
-(cl-test "keyword: type" (get (cl-read ":foo") "cl-type") "keyword")
-(cl-test "keyword: name" (get (cl-read ":foo") "name") "FOO")
-(cl-test "keyword: :test" (get (cl-read ":test") "name") "TEST")
-
-(cl-test "char: type" (get (cl-read "#\\a") "cl-type") "char")
-(cl-test "char: value" (get (cl-read "#\\a") "value") "a")
-(cl-test "char: Space" (get (cl-read "#\\Space") "value") " ")
-(cl-test "char: Newline" (get (cl-read "#\\Newline") "value") "\n")
-
-(cl-test "uninterned: type" (get (cl-read "#:foo") "cl-type") "uninterned")
-(cl-test "uninterned: name" (get (cl-read "#:foo") "name") "FOO")
-
-;; ── lists ─────────────────────────────────────────────────────────
-
-(cl-test "list: empty" (cl-read "()") (list))
-(cl-test "list: one element" (cl-read "(foo)") (list "FOO"))
-(cl-test "list: two elements" (cl-read "(foo bar)") (list "FOO" "BAR"))
-(cl-test "list: nested" (cl-read "((a b) c)") (list (list "A" "B") "C"))
-(cl-test "list: with integer" (cl-read "(+ 1 2)") (list "+" 1 2))
-(cl-test "list: with string" (cl-read "(print \"hi\")") (list "PRINT" {:cl-type "string" :value "hi"}))
-(cl-test "list: nil element" (cl-read "(a nil b)") (list "A" nil "B"))
-(cl-test "list: t element" (cl-read "(a t b)") (list "A" true "B"))
-
-;; ── dotted pairs ──────────────────────────────────────────────<E29480><E29480>──
-
-(cl-test "dotted: type" (get (cl-read "(a . b)") "cl-type") "cons")
-(cl-test "dotted: car" (get (cl-read "(a . b)") "car") "A")
-(cl-test "dotted: cdr" (get (cl-read "(a . b)") "cdr") "B")
-(cl-test "dotted: number cdr" (get (cl-read "(x . 42)") "cdr") 42)
-
-;; ── reader macros ────────────────────────────────────────────────<E29480><E29480>
-
-(cl-test "quote: form" (cl-read "'x") (list "QUOTE" "X"))
-(cl-test "quote: list" (cl-read "'(a b)") (list "QUOTE" (list "A" "B")))
-(cl-test "backquote: form" (cl-read "`x") (list "QUASIQUOTE" "X"))
-(cl-test "unquote: form" (cl-read ",x") (list "UNQUOTE" "X"))
-(cl-test "comma-at: form" (cl-read ",@x") (list "UNQUOTE-SPLICING" "X"))
-(cl-test "function: form" (cl-read "#'foo") (list "FUNCTION" "FOO"))
-
-;; ── vector ────────────────────────────────────────────────────────
-
-(cl-test "vector: type" (get (cl-read "#(1 2 3)") "cl-type") "vector")
-(cl-test "vector: elements" (get (cl-read "#(1 2 3)") "elements") (list 1 2 3))
-(cl-test "vector: empty" (get (cl-read "#()") "elements") (list))
-(cl-test "vector: mixed" (get (cl-read "#(a 1 \"s\")") "elements") (list "A" 1 {:cl-type "string" :value "s"}))
-
-;; ── cl-read-all ───────────────────────────────────────────────────
-
-(cl-test
-  "read-all: empty"
-  (cl-read-all "")
-  (list))
-
-(cl-test
-  "read-all: two forms"
-  (cl-read-all "42 foo")
-  (list 42 "FOO"))
-
-(cl-test
-  "read-all: three forms"
-  (cl-read-all "(+ 1 2) (+ 3 4) hello")
-  (list (list "+" 1 2) (list "+" 3 4) "HELLO"))
-
-(cl-test
-  "read-all: with comments"
-  (cl-read-all "; this is a comment\n42 ; inline\nfoo")
-  (list 42 "FOO"))
-
-(cl-test
-  "read-all: defun form"
-  (nth (cl-read-all "(defun square (x) (* x x))") 0)
-  (list "DEFUN" "SQUARE" (list "X") (list "*" "X" "X")))

lib/common-lisp/tests/programs/geometry.sx

@@ -1,291 +0,0 @@
-;; geometry.sx — Multiple dispatch with CLOS
-;;
-;; Demonstrates generic functions dispatching on combinations of
-;; geometric types: point, line, plane.
-;;
-;; Depends on: lib/common-lisp/runtime.sx, lib/common-lisp/clos.sx
-
-;; ── geometric classes ──────────────────────────────────────────────────────
-
-(clos-defclass "geo-point" (list "t") (list {:initform 0 :initarg ":px" :reader nil :writer nil :accessor nil :name "px"} {:initform 0 :initarg ":py" :reader nil :writer nil :accessor nil :name "py"}))
-
-(clos-defclass "geo-line" (list "t") (list {:initform nil :initarg ":p1" :reader nil :writer nil :accessor nil :name "p1"} {:initform nil :initarg ":p2" :reader nil :writer nil :accessor nil :name "p2"}))
-
-(clos-defclass "geo-plane" (list "t") (list {:initform nil :initarg ":normal" :reader nil :writer nil :accessor nil :name "normal"} {:initform 0 :initarg ":d" :reader nil :writer nil :accessor nil :name "d"}))
-
-;; ── helpers ────────────────────────────────────────────────────────────────
-
-(define geo-point-x (fn (p) (clos-slot-value p "px")))
-(define geo-point-y (fn (p) (clos-slot-value p "py")))
-
-(define
-  geo-make-point
-  (fn (x y) (clos-make-instance "geo-point" ":px" x ":py" y)))
-
-(define
-  geo-make-line
-  (fn (p1 p2) (clos-make-instance "geo-line" ":p1" p1 ":p2" p2)))
-
-(define
-  geo-make-plane
-  (fn
-    (nx ny d)
-    (clos-make-instance "geo-plane" ":normal" (list nx ny) ":d" d)))
-
-;; ── describe generic ───────────────────────────────────────────────────────
-
-(clos-defgeneric "geo-describe" {})
-
-(clos-defmethod
-  "geo-describe"
-  (list)
-  (list "geo-point")
-  (fn
-    (args next-fn)
-    (let
-      ((p (first args)))
-      (str "P(" (geo-point-x p) "," (geo-point-y p) ")"))))
-
-(clos-defmethod
-  "geo-describe"
-  (list)
-  (list "geo-line")
-  (fn
-    (args next-fn)
-    (let
-      ((l (first args)))
-      (str
-        "L["
-        (clos-call-generic "geo-describe" (list (clos-slot-value l "p1")))
-        "-"
-        (clos-call-generic "geo-describe" (list (clos-slot-value l "p2")))
-        "]"))))
-
-(clos-defmethod
-  "geo-describe"
-  (list)
-  (list "geo-plane")
-  (fn
-    (args next-fn)
-    (let
-      ((pl (first args)))
-      (str "Plane(d=" (clos-slot-value pl "d") ")"))))
-
-;; ── intersect: multi-dispatch generic ─────────────────────────────────────
-;;
-;; Returns a string description of the intersection result.
-
-(clos-defgeneric "intersect" {})
-
-;; point ∩ point: same if coordinates match
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-point" "geo-point")
-  (fn
-    (args next-fn)
-    (let
-      ((p1 (first args)) (p2 (first (rest args))))
-      (if
-        (and
-          (= (geo-point-x p1) (geo-point-x p2))
-          (= (geo-point-y p1) (geo-point-y p2)))
-        "point"
-        "empty"))))
-
-;; point ∩ line: check if point lies on line (cross product = 0)
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-point" "geo-line")
-  (fn
-    (args next-fn)
-    (let
-      ((pt (first args)) (ln (first (rest args))))
-      (let
-        ((lp1 (clos-slot-value ln "p1")) (lp2 (clos-slot-value ln "p2")))
-        (let
-          ((dx (- (geo-point-x lp2) (geo-point-x lp1)))
-            (dy (- (geo-point-y lp2) (geo-point-y lp1)))
-            (ex (- (geo-point-x pt) (geo-point-x lp1)))
-            (ey (- (geo-point-y pt) (geo-point-y lp1))))
-          (if (= (- (* dx ey) (* dy ex)) 0) "point" "empty"))))))
-
-;; line ∩ line: parallel (same slope = empty) or point
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-line" "geo-line")
-  (fn
-    (args next-fn)
-    (let
-      ((l1 (first args)) (l2 (first (rest args))))
-      (let
-        ((p1 (clos-slot-value l1 "p1"))
-          (p2 (clos-slot-value l1 "p2"))
-          (p3 (clos-slot-value l2 "p1"))
-          (p4 (clos-slot-value l2 "p2")))
-        (let
-          ((dx1 (- (geo-point-x p2) (geo-point-x p1)))
-            (dy1 (- (geo-point-y p2) (geo-point-y p1)))
-            (dx2 (- (geo-point-x p4) (geo-point-x p3)))
-            (dy2 (- (geo-point-y p4) (geo-point-y p3))))
-          (let
-            ((cross (- (* dx1 dy2) (* dy1 dx2))))
-            (if (= cross 0) "parallel" "point")))))))
-
-;; line ∩ plane: general case = point (or parallel if line ⊥ normal)
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-line" "geo-plane")
-  (fn
-    (args next-fn)
-    (let
-      ((ln (first args)) (pl (first (rest args))))
-      (let
-        ((p1 (clos-slot-value ln "p1"))
-          (p2 (clos-slot-value ln "p2"))
-          (n (clos-slot-value pl "normal")))
-        (let
-          ((dx (- (geo-point-x p2) (geo-point-x p1)))
-            (dy (- (geo-point-y p2) (geo-point-y p1)))
-            (nx (first n))
-            (ny (first (rest n))))
-          (let
-            ((dot (+ (* dx nx) (* dy ny))))
-            (if (= dot 0) "parallel" "point")))))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-;; describe
-(check
-  "describe point"
-  (clos-call-generic
-    "geo-describe"
-    (list (geo-make-point 3 4)))
-  "P(3,4)")
-(check
-  "describe line"
-  (clos-call-generic
-    "geo-describe"
-    (list
-      (geo-make-line
-        (geo-make-point 0 0)
-        (geo-make-point 1 1))))
-  "L[P(0,0)-P(1,1)]")
-(check
-  "describe plane"
-  (clos-call-generic
-    "geo-describe"
-    (list (geo-make-plane 0 1 5)))
-  "Plane(d=5)")
-
-;; intersect point×point
-(check
-  "P∩P same"
-  (clos-call-generic
-    "intersect"
-    (list
-      (geo-make-point 2 3)
-      (geo-make-point 2 3)))
-  "point")
-(check
-  "P∩P diff"
-  (clos-call-generic
-    "intersect"
-    (list
-      (geo-make-point 1 2)
-      (geo-make-point 3 4)))
-  "empty")
-
-;; intersect point×line
-(let
-  ((origin (geo-make-point 0 0))
-    (p10 (geo-make-point 10 0))
-    (p55 (geo-make-point 5 5))
-    (l-x
-      (geo-make-line
-        (geo-make-point 0 0)
-        (geo-make-point 10 0))))
-  (begin
-    (check
-      "P∩L on line"
-      (clos-call-generic "intersect" (list p10 l-x))
-      "point")
-    (check
-      "P∩L on x-axis"
-      (clos-call-generic "intersect" (list origin l-x))
-      "point")
-    (check
-      "P∩L off line"
-      (clos-call-generic "intersect" (list p55 l-x))
-      "empty")))
-
-;; intersect line×line
-(let
-  ((horiz (geo-make-line (geo-make-point 0 0) (geo-make-point 10 0)))
-    (vert
-      (geo-make-line
-        (geo-make-point 5 -5)
-        (geo-make-point 5 5)))
-    (horiz2
-      (geo-make-line
-        (geo-make-point 0 3)
-        (geo-make-point 10 3))))
-  (begin
-    (check
-      "L∩L crossing"
-      (clos-call-generic "intersect" (list horiz vert))
-      "point")
-    (check
-      "L∩L parallel"
-      (clos-call-generic "intersect" (list horiz horiz2))
-      "parallel")))
-
-;; intersect line×plane
-(let
-  ((diag (geo-make-line (geo-make-point 0 0) (geo-make-point 1 1)))
-    (vert-plane (geo-make-plane 1 0 5))
-    (diag-plane (geo-make-plane -1 1 0)))
-  (begin
-    (check
-      "L∩Plane cross"
-      (clos-call-generic "intersect" (list diag vert-plane))
-      "point")
-    (check
-      "L∩Plane parallel"
-      (clos-call-generic "intersect" (list diag diag-plane))
-      "parallel")))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define geo-passed passed)
-(define geo-failed failed)
-(define geo-failures failures)

lib/common-lisp/tests/programs/interactive-debugger.sx

@@ -1,196 +0,0 @@
-;; interactive-debugger.sx — Condition debugger using *debugger-hook*
-;;
-;; Demonstrates the classic CL debugger pattern:
-;;   - *debugger-hook* is invoked when an unhandled error reaches the top level
-;;   - The hook receives the condition and a reference to itself
-;;   - It can offer restarts interactively (here simulated with a policy fn)
-;;
-;; In real CL the debugger reads from the terminal. Here we simulate
-;; the "user input" via a policy function passed in at call time.
-;;
-;; Depends on: lib/common-lisp/runtime.sx already loaded.
-
-;; ── *debugger-hook* global ────────────────────────────────────────────────
-;;
-;; CL: when error is unhandled, invoke *debugger-hook* with (condition hook).
-;; A nil hook means use the system default (which we simulate as re-raise).
-
-(define cl-debugger-hook nil)
-
-;; ── invoke-debugger ────────────────────────────────────────────────────────
-;;
-;; Called when cl-error finds no handler. Tries cl-debugger-hook first;
-;; falls back to a simple error report.
-
-(define
-  cl-invoke-debugger
-  (fn
-    (c)
-    (if
-      (nil? cl-debugger-hook)
-      (error (str "Debugger: " (cl-condition-message c)))
-      (begin
-        (let
-          ((hook cl-debugger-hook))
-          (set! cl-debugger-hook nil)
-          (let
-            ((result (hook c hook)))
-            (set! cl-debugger-hook hook)
-            result))))))
-
-;; ── cl-error/debugger — error that routes through invoke-debugger ─────────
-
-(define
-  cl-error-with-debugger
-  (fn
-    (c &rest args)
-    (let
-      ((obj (cond ((cl-condition? c) c) ((string? c) (cl-make-condition "simple-error" "format-control" c "format-arguments" args)) (:else (cl-make-condition "simple-error" "format-control" (str c))))))
-      (cl-signal-obj obj cl-handler-stack)
-      (cl-invoke-debugger obj))))
-
-;; ── simulated debugger session ────────────────────────────────────────────
-;;
-;; A debugger hook takes (condition hook) and "reads" user commands.
-;; We simulate this with a policy function: (fn (c restarts) restart-name)
-;; that picks a restart given the condition and available restarts.
-
-(define
-  make-policy-debugger
-  (fn
-    (policy)
-    (fn
-      (c hook)
-      (let
-        ((available (cl-compute-restarts)))
-        (let
-          ((choice (policy c available)))
-          (if
-            (and choice (not (nil? (cl-find-restart choice))))
-            (cl-invoke-restart choice)
-            (error
-              (str
-                "Debugger: no restart chosen for: "
-                (cl-condition-message c)))))))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  reset-stacks!
-  (fn
-    ()
-    (set! cl-handler-stack (list))
-    (set! cl-restart-stack (list))
-    (set! cl-debugger-hook nil)))
-
-;; Test 1: debugger hook receives condition
-(reset-stacks!)
-(let
-  ((received-msg ""))
-  (begin
-    (set!
-      cl-debugger-hook
-      (fn (c hook) (set! received-msg (cl-condition-message c)) nil))
-    (cl-restart-case
-      (fn () (cl-error-with-debugger "something broke"))
-      (list "abort" (list) (fn () nil)))
-    (check "debugger hook receives condition" received-msg "something broke")))
-
-;; Test 2: policy-driven restart selection (use-zero)
-(reset-stacks!)
-(let
-  ((result (begin (set! cl-debugger-hook (make-policy-debugger (fn (c restarts) "use-zero"))) (cl-restart-case (fn () (cl-error-with-debugger (cl-make-condition "division-by-zero")) 999) (list "use-zero" (list) (fn () 0))))))
-  (check "policy debugger: use-zero restart" result 0))
-
-;; Test 3: policy selects abort
-(reset-stacks!)
-(let
-  ((result (begin (set! cl-debugger-hook (make-policy-debugger (fn (c restarts) "abort"))) (cl-restart-case (fn () (cl-error-with-debugger "aborting error") 999) (list "abort" (list) (fn () "aborted"))))))
-  (check "policy debugger: abort restart" result "aborted"))
-
-;; Test 4: compute-restarts inside debugger hook
-(reset-stacks!)
-(let
-  ((seen-restarts (list)))
-  (begin
-    (set!
-      cl-debugger-hook
-      (fn
-        (c hook)
-        (set! seen-restarts (cl-compute-restarts))
-        (cl-invoke-restart "continue")))
-    (cl-restart-case
-      (fn () (cl-error-with-debugger "test") 42)
-      (list "continue" (list) (fn () "ok"))
-      (list "abort" (list) (fn () "no")))
-    (check
-      "debugger: compute-restarts visible"
-      (= (len seen-restarts) 2)
-      true)))
-
-;; Test 5: hook not invoked when handler catches first
-(reset-stacks!)
-(let
-  ((hook-called false)
-    (result
-      (begin
-        (set! cl-debugger-hook (fn (c hook) (set! hook-called true) nil))
-        (cl-handler-case
-          (fn () (cl-error-with-debugger "handled"))
-          (list "error" (fn (c) "handler-won"))))))
-  (check "handler wins; hook not called" hook-called false)
-  (check "handler result returned" result "handler-won"))
-
-;; Test 6: debugger-hook nil after re-raise guard
-(reset-stacks!)
-(let
-  ((hook-calls 0))
-  (begin
-    (set!
-      cl-debugger-hook
-      (fn
-        (c hook)
-        (set! hook-calls (+ hook-calls 1))
-        (if
-          (> hook-calls 1)
-          (error "infinite loop guard")
-          (cl-invoke-restart "escape"))))
-    (cl-restart-case
-      (fn () (cl-error-with-debugger "once"))
-      (list "escape" (list) (fn () nil)))
-    (check
-      "hook called exactly once (no infinite recursion)"
-      hook-calls
-      1)))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define debugger-passed passed)
-(define debugger-failed failed)
-(define debugger-failures failures)

lib/common-lisp/tests/programs/mop-trace.sx

@@ -1,228 +0,0 @@
-;; mop-trace.sx — :before/:after method tracing with CLOS
-;;
-;; Classic CLOS pattern: instrument generic functions with :before and :after
-;; qualifiers to print call/return traces without modifying the primary method.
-;;
-;; Depends on: lib/common-lisp/runtime.sx, lib/common-lisp/clos.sx
-
-;; ── trace log (mutable accumulator) ───────────────────────────────────────
-
-(define trace-log (list))
-
-(define
-  trace-push
-  (fn (msg) (set! trace-log (append trace-log (list msg)))))
-
-(define trace-clear (fn () (set! trace-log (list))))
-
-;; ── domain classes ─────────────────────────────────────────────────────────
-
-(clos-defclass "shape" (list "t") (list {:initform "white" :initarg ":color" :reader nil :writer nil :accessor nil :name "color"}))
-
-(clos-defclass "circle" (list "shape") (list {:initform 1 :initarg ":radius" :reader nil :writer nil :accessor nil :name "radius"}))
-
-(clos-defclass "rect" (list "shape") (list {:initform 1 :initarg ":width" :reader nil :writer nil :accessor nil :name "width"} {:initform 1 :initarg ":height" :reader nil :writer nil :accessor nil :name "height"}))
-
-;; ── generic function: area ─────────────────────────────────────────────────
-
-(clos-defgeneric "area" {})
-
-;; primary methods
-(clos-defmethod
-  "area"
-  (list)
-  (list "circle")
-  (fn
-    (args next-fn)
-    (let
-      ((c (first args)))
-      (let ((r (clos-slot-value c "radius"))) (* r r)))))
-
-(clos-defmethod
-  "area"
-  (list)
-  (list "rect")
-  (fn
-    (args next-fn)
-    (let
-      ((r (first args)))
-      (* (clos-slot-value r "width") (clos-slot-value r "height")))))
-
-;; :before tracing
-(clos-defmethod
-  "area"
-  (list "before")
-  (list "shape")
-  (fn
-    (args next-fn)
-    (trace-push (str "BEFORE area(" (clos-class-of (first args)) ")"))))
-
-;; :after tracing
-(clos-defmethod
-  "area"
-  (list "after")
-  (list "shape")
-  (fn
-    (args next-fn)
-    (trace-push (str "AFTER area(" (clos-class-of (first args)) ")"))))
-
-;; ── generic function: describe-shape ──────────────────────────────────────
-
-(clos-defgeneric "describe-shape" {})
-
-(clos-defmethod
-  "describe-shape"
-  (list)
-  (list "shape")
-  (fn
-    (args next-fn)
-    (let
-      ((s (first args)))
-      (str "shape[" (clos-slot-value s "color") "]"))))
-
-(clos-defmethod
-  "describe-shape"
-  (list)
-  (list "circle")
-  (fn
-    (args next-fn)
-    (let
-      ((c (first args)))
-      (str
-        "circle[r="
-        (clos-slot-value c "radius")
-        " "
-        (clos-call-next-method next-fn)
-        "]"))))
-
-(clos-defmethod
-  "describe-shape"
-  (list)
-  (list "rect")
-  (fn
-    (args next-fn)
-    (let
-      ((r (first args)))
-      (str
-        "rect["
-        (clos-slot-value r "width")
-        "x"
-        (clos-slot-value r "height")
-        " "
-        (clos-call-next-method next-fn)
-        "]"))))
-
-;; :before on base shape (fires for all subclasses too)
-(clos-defmethod
-  "describe-shape"
-  (list "before")
-  (list "shape")
-  (fn
-    (args next-fn)
-    (trace-push
-      (str "BEFORE describe-shape(" (clos-class-of (first args)) ")"))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-;; ── area tests ────────────────────────────────────────────────────────────
-
-;; circle area = r*r (no pi — integer arithmetic for predictability)
-(let
-  ((c (clos-make-instance "circle" ":radius" 5 ":color" "red")))
-  (do
-    (trace-clear)
-    (check "circle area" (clos-call-generic "area" (list c)) 25)
-    (check
-      ":before fired for circle"
-      (= (first trace-log) "BEFORE area(circle)")
-      true)
-    (check
-      ":after fired for circle"
-      (= (first (rest trace-log)) "AFTER area(circle)")
-      true)
-    (check "trace length 2" (len trace-log) 2)))
-
-;; rect area = w*h
-(let
-  ((r (clos-make-instance "rect" ":width" 4 ":height" 6 ":color" "blue")))
-  (do
-    (trace-clear)
-    (check "rect area" (clos-call-generic "area" (list r)) 24)
-    (check
-      ":before fired for rect"
-      (= (first trace-log) "BEFORE area(rect)")
-      true)
-    (check
-      ":after fired for rect"
-      (= (first (rest trace-log)) "AFTER area(rect)")
-      true)
-    (check "trace length 2 (rect)" (len trace-log) 2)))
-
-;; ── describe-shape tests ───────────────────────────────────────────────────
-
-(let
-  ((c (clos-make-instance "circle" ":radius" 3 ":color" "green")))
-  (do
-    (trace-clear)
-    (check
-      "circle describe"
-      (clos-call-generic "describe-shape" (list c))
-      "circle[r=3 shape[green]]")
-    (check
-      ":before fired for describe circle"
-      (= (first trace-log) "BEFORE describe-shape(circle)")
-      true)))
-
-(let
-  ((r (clos-make-instance "rect" ":width" 2 ":height" 7 ":color" "black")))
-  (do
-    (trace-clear)
-    (check
-      "rect describe"
-      (clos-call-generic "describe-shape" (list r))
-      "rect[2x7 shape[black]]")
-    (check
-      ":before fired for describe rect"
-      (= (first trace-log) "BEFORE describe-shape(rect)")
-      true)))
-
-;; ── call-next-method: circle -> shape ─────────────────────────────────────
-
-(let
-  ((c (clos-make-instance "circle" ":radius" 1 ":color" "purple")))
-  (check
-    "call-next-method result in describe"
-    (clos-call-generic "describe-shape" (list c))
-    "circle[r=1 shape[purple]]"))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define mop-passed passed)
-(define mop-failed failed)
-(define mop-failures failures)

lib/common-lisp/tests/programs/parse-recover.sx

@@ -1,163 +0,0 @@
-;; parse-recover.sx — Parser with skipped-token restart
-;;
-;; Classic CL pattern: a simple token parser that signals a condition
-;; when it encounters an unexpected token. The :skip-token restart
-;; allows the parser to continue past the offending token.
-;;
-;; Depends on: lib/common-lisp/runtime.sx already loaded.
-
-;; ── condition type ─────────────────────────────────────────────────────────
-
-(cl-define-condition "parse-error" (list "error") (list "token" "position"))
-
-;; ── simple token parser ────────────────────────────────────────────────────
-;;
-;; parse-numbers: given a list of tokens (strings), parse integers.
-;; Non-integer tokens signal parse-error with two restarts:
-;;   skip-token   — skip the bad token and continue
-;;   use-zero     — use 0 in place of the bad token
-
-(define
-  parse-numbers
-  (fn
-    (tokens)
-    (define result (list))
-    (define
-      process
-      (fn
-        (toks)
-        (if
-          (empty? toks)
-          result
-          (let
-            ((tok (first toks)) (rest-toks (rest toks)))
-            (let
-              ((n (string->number tok 10)))
-              (if
-                n
-                (begin
-                  (set! result (append result (list n)))
-                  (process rest-toks))
-                (cl-restart-case
-                  (fn
-                    ()
-                    (cl-signal
-                      (cl-make-condition
-                        "parse-error"
-                        "token"
-                        tok
-                        "position"
-                        (len result)))
-                    (set! result (append result (list 0)))
-                    (process rest-toks))
-                  (list "skip-token" (list) (fn () (process rest-toks)))
-                  (list
-                    "use-zero"
-                    (list)
-                    (fn
-                      ()
-                      (begin
-                        (set! result (append result (list 0)))
-                        (process rest-toks)))))))))))
-    (process tokens)
-    result))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  reset-stacks!
-  (fn () (set! cl-handler-stack (list)) (set! cl-restart-stack (list))))
-
-;; All valid tokens
-(reset-stacks!)
-(check
-  "all valid: 1 2 3"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "skip-token"))))
-    (fn () (parse-numbers (list "1" "2" "3"))))
-  (list 1 2 3))
-
-;; Skip bad token
-(reset-stacks!)
-(check
-  "skip bad token: 1 x 3 -> (1 3)"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "skip-token"))))
-    (fn () (parse-numbers (list "1" "x" "3"))))
-  (list 1 3))
-
-;; Use zero for bad token
-(reset-stacks!)
-(check
-  "use-zero for bad: 1 x 3 -> (1 0 3)"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "use-zero"))))
-    (fn () (parse-numbers (list "1" "x" "3"))))
-  (list 1 0 3))
-
-;; Multiple bad tokens, all skipped
-(reset-stacks!)
-(check
-  "skip multiple bad: a 2 b 4 -> (2 4)"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "skip-token"))))
-    (fn () (parse-numbers (list "a" "2" "b" "4"))))
-  (list 2 4))
-
-;; handler-case: abort on first bad token
-(reset-stacks!)
-(check
-  "handler-case: abort on first bad"
-  (cl-handler-case
-    (fn () (parse-numbers (list "1" "bad" "3")))
-    (list
-      "parse-error"
-      (fn
-        (c)
-        (str
-          "parse error at position "
-          (cl-condition-slot c "position")
-          ": "
-          (cl-condition-slot c "token")))))
-  "parse error at position 1: bad")
-
-;; Verify condition type hierarchy
-(reset-stacks!)
-(check
-  "parse-error isa error"
-  (cl-condition-of-type?
-    (cl-make-condition "parse-error" "token" "x" "position" 0)
-    "error")
-  true)
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define parse-passed passed)
-(define parse-failed failed)
-(define parse-failures failures)

lib/common-lisp/tests/programs/restart-demo.sx

@@ -1,141 +0,0 @@
-;; restart-demo.sx — Classic CL condition system demo
-;;
-;; Demonstrates resumable exceptions via restarts.
-;; The `safe-divide` function signals a division-by-zero condition
-;; and offers two restarts:
-;;   :use-zero  — return 0 as the result
-;;   :retry     — call safe-divide again with a corrected divisor
-;;
-;; Depends on: lib/common-lisp/runtime.sx already loaded.
-
-;; ── safe-divide ────────────────────────────────────────────────────────────
-;;
-;; Divides numerator by denominator.
-;; When denominator is 0, signals division-by-zero with two restarts.
-
-(define
-  safe-divide
-  (fn
-    (n d)
-    (if
-      (= d 0)
-      (cl-restart-case
-        (fn
-          ()
-          (cl-signal
-            (cl-make-condition
-              "division-by-zero"
-              "operation"
-              "/"
-              "operands"
-              (list n d)))
-          (error "division by zero — no restart invoked"))
-        (list "use-zero" (list) (fn () 0))
-        (list "retry" (list "d") (fn (d2) (safe-divide n d2))))
-      (/ n d))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  reset-stacks!
-  (fn () (set! cl-handler-stack (list)) (set! cl-restart-stack (list))))
-
-;; Normal division
-(reset-stacks!)
-(check "10 / 2 = 5" (safe-divide 10 2) 5)
-
-;; Invoke use-zero restart
-(reset-stacks!)
-(check
-  "10 / 0 -> use-zero"
-  (cl-handler-bind
-    (list
-      (list "division-by-zero" (fn (c) (cl-invoke-restart "use-zero"))))
-    (fn () (safe-divide 10 0)))
-  0)
-
-;; Invoke retry restart with a corrected denominator
-(reset-stacks!)
-(check
-  "10 / 0 -> retry with 2"
-  (cl-handler-bind
-    (list
-      (list
-        "division-by-zero"
-        (fn (c) (cl-invoke-restart "retry" 2))))
-    (fn () (safe-divide 10 0)))
-  5)
-
-;; Nested calls: outer handles the inner divide-by-zero
-(reset-stacks!)
-(check
-  "nested: 20 / (0->4) = 5"
-  (cl-handler-bind
-    (list
-      (list
-        "division-by-zero"
-        (fn (c) (cl-invoke-restart "retry" 4))))
-    (fn () (let ((r1 (safe-divide 20 0))) r1)))
-  5)
-
-;; handler-case — unwinding version
-(reset-stacks!)
-(check
-  "handler-case: catches division-by-zero"
-  (cl-handler-case
-    (fn () (safe-divide 9 0))
-    (list "division-by-zero" (fn (c) "caught!")))
-  "caught!")
-
-;; Verify use-zero is idempotent (two uses)
-(reset-stacks!)
-(check
-  "two use-zero invocations"
-  (cl-handler-bind
-    (list
-      (list "division-by-zero" (fn (c) (cl-invoke-restart "use-zero"))))
-    (fn
-      ()
-      (+
-        (safe-divide 10 0)
-        (safe-divide 3 0))))
-  0)
-
-;; No restart needed for normal division
-(reset-stacks!)
-(check
-  "no restart needed for 8/4"
-  (safe-divide 8 4)
-  2)
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define demo-passed passed)
-(define demo-failed failed)
-(define demo-failures failures)

lib/common-lisp/tests/read.sx

@@ -1,180 +0,0 @@
-;; Common Lisp tokenizer tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; Helpers: extract types and values from token stream (drops eof)
-(define
-  cl-tok-types
-  (fn
-    (src)
-    (map
-      (fn (t) (get t "type"))
-      (filter (fn (t) (not (= (get t "type") "eof"))) (cl-tokenize src)))))
-
-(define
-  cl-tok-values
-  (fn
-    (src)
-    (map
-      (fn (t) (get t "value"))
-      (filter (fn (t) (not (= (get t "type") "eof"))) (cl-tokenize src)))))
-
-(define
-  cl-tok-first
-  (fn (src) (nth (cl-tokenize src) 0)))
-
-;; ── symbols ───────────────────────────────────────────────────────
-
-(cl-test "symbol: bare lowercase" (cl-tok-values "foo") (list "FOO"))
-(cl-test "symbol: uppercase" (cl-tok-values "BAR") (list "BAR"))
-(cl-test "symbol: mixed case folded" (cl-tok-values "FooBar") (list "FOOBAR"))
-(cl-test "symbol: with hyphen" (cl-tok-values "foo-bar") (list "FOO-BAR"))
-(cl-test "symbol: with star" (cl-tok-values "*special*") (list "*SPECIAL*"))
-(cl-test "symbol: with question" (cl-tok-values "null?") (list "NULL?"))
-(cl-test "symbol: with exclamation" (cl-tok-values "set!") (list "SET!"))
-(cl-test "symbol: plus sign alone" (cl-tok-values "+") (list "+"))
-(cl-test "symbol: minus sign alone" (cl-tok-values "-") (list "-"))
-(cl-test "symbol: type is symbol" (cl-tok-types "foo") (list "symbol"))
-
-;; ── package-qualified symbols ─────────────────────────────────────
-
-(cl-test "symbol: pkg:sym external" (cl-tok-values "cl:car") (list "CL:CAR"))
-(cl-test "symbol: pkg::sym internal" (cl-tok-values "pkg::foo") (list "PKG::FOO"))
-(cl-test "symbol: cl:car type" (cl-tok-types "cl:car") (list "symbol"))
-
-;; ── keywords ──────────────────────────────────────────────────────
-
-(cl-test "keyword: basic" (cl-tok-values ":foo") (list "FOO"))
-(cl-test "keyword: type" (cl-tok-types ":foo") (list "keyword"))
-(cl-test "keyword: upcase" (cl-tok-values ":hello-world") (list "HELLO-WORLD"))
-(cl-test "keyword: multiple" (cl-tok-types ":a :b :c") (list "keyword" "keyword" "keyword"))
-
-;; ── integers ──────────────────────────────────────────────────────
-
-(cl-test "integer: zero" (cl-tok-values "0") (list "0"))
-(cl-test "integer: positive" (cl-tok-values "42") (list "42"))
-(cl-test "integer: negative" (cl-tok-values "-5") (list "-5"))
-(cl-test "integer: positive-sign" (cl-tok-values "+3") (list "+3"))
-(cl-test "integer: type" (cl-tok-types "42") (list "integer"))
-(cl-test "integer: multi-digit" (cl-tok-values "12345678") (list "12345678"))
-
-;; ── hex, binary, octal ───────────────────────────────────────────
-
-(cl-test "hex: lowercase x" (cl-tok-values "#xFF") (list "#xFF"))
-(cl-test "hex: uppercase X" (cl-tok-values "#XFF") (list "#XFF"))
-(cl-test "hex: type" (cl-tok-types "#xFF") (list "integer"))
-(cl-test "hex: zero" (cl-tok-values "#x0") (list "#x0"))
-(cl-test "binary: #b" (cl-tok-values "#b1010") (list "#b1010"))
-(cl-test "binary: type" (cl-tok-types "#b1010") (list "integer"))
-(cl-test "octal: #o" (cl-tok-values "#o17") (list "#o17"))
-(cl-test "octal: type" (cl-tok-types "#o17") (list "integer"))
-
-;; ── floats ────────────────────────────────────────────────────────
-
-(cl-test "float: basic" (cl-tok-values "3.14") (list "3.14"))
-(cl-test "float: type" (cl-tok-types "3.14") (list "float"))
-(cl-test "float: negative" (cl-tok-values "-2.5") (list "-2.5"))
-(cl-test "float: exponent" (cl-tok-values "1.0e10") (list "1.0e10"))
-(cl-test "float: neg exponent" (cl-tok-values "1.5e-3") (list "1.5e-3"))
-(cl-test "float: leading dot" (cl-tok-values ".5") (list "0.5"))
-(cl-test "float: exp only" (cl-tok-values "1e5") (list "1e5"))
-
-;; ── ratios ────────────────────────────────────────────────────────
-
-(cl-test "ratio: 1/3" (cl-tok-values "1/3") (list "1/3"))
-(cl-test "ratio: type" (cl-tok-types "1/3") (list "ratio"))
-(cl-test "ratio: 22/7" (cl-tok-values "22/7") (list "22/7"))
-(cl-test "ratio: negative" (cl-tok-values "-1/2") (list "-1/2"))
-
-;; ── strings ───────────────────────────────────────────────────────
-
-(cl-test "string: empty" (cl-tok-values "\"\"") (list ""))
-(cl-test "string: basic" (cl-tok-values "\"hello\"") (list "hello"))
-(cl-test "string: type" (cl-tok-types "\"hello\"") (list "string"))
-(cl-test "string: with space" (cl-tok-values "\"hello world\"") (list "hello world"))
-(cl-test "string: escaped quote" (cl-tok-values "\"say \\\"hi\\\"\"") (list "say \"hi\""))
-(cl-test "string: escaped backslash" (cl-tok-values "\"a\\\\b\"") (list "a\\b"))
-(cl-test "string: newline escape" (cl-tok-values "\"a\\nb\"") (list "a\nb"))
-(cl-test "string: tab escape" (cl-tok-values "\"a\\tb\"") (list "a\tb"))
-
-;; ── characters ────────────────────────────────────────────────────
-
-(cl-test "char: lowercase a" (cl-tok-values "#\\a") (list "a"))
-(cl-test "char: uppercase A" (cl-tok-values "#\\A") (list "A"))
-(cl-test "char: digit" (cl-tok-values "#\\1") (list "1"))
-(cl-test "char: type" (cl-tok-types "#\\a") (list "char"))
-(cl-test "char: Space" (cl-tok-values "#\\Space") (list " "))
-(cl-test "char: Newline" (cl-tok-values "#\\Newline") (list "\n"))
-(cl-test "char: Tab" (cl-tok-values "#\\Tab") (list "\t"))
-(cl-test "char: Return" (cl-tok-values "#\\Return") (list "\r"))
-
-;; ── reader macros ─────────────────────────────────────────────────
-
-(cl-test "quote: type" (cl-tok-types "'x") (list "quote" "symbol"))
-(cl-test "backquote: type" (cl-tok-types "`x") (list "backquote" "symbol"))
-(cl-test "comma: type" (cl-tok-types ",x") (list "comma" "symbol"))
-(cl-test "comma-at: type" (cl-tok-types ",@x") (list "comma-at" "symbol"))
-(cl-test "hash-quote: type" (cl-tok-types "#'foo") (list "hash-quote" "symbol"))
-(cl-test "hash-paren: type" (cl-tok-types "#(1 2)") (list "hash-paren" "integer" "integer" "rparen"))
-
-;; ── uninterned ────────────────────────────────────────────────────
-
-(cl-test "uninterned: type" (cl-tok-types "#:foo") (list "uninterned"))
-(cl-test "uninterned: value upcase" (cl-tok-values "#:foo") (list "FOO"))
-(cl-test "uninterned: compound" (cl-tok-values "#:my-sym") (list "MY-SYM"))
-
-;; ── parens and structure ──────────────────────────────────────────
-
-(cl-test "paren: empty list" (cl-tok-types "()") (list "lparen" "rparen"))
-(cl-test "paren: nested" (cl-tok-types "((a))") (list "lparen" "lparen" "symbol" "rparen" "rparen"))
-(cl-test "dot: standalone" (cl-tok-types "(a . b)") (list "lparen" "symbol" "dot" "symbol" "rparen"))
-
-;; ── comments ──────────────────────────────────────────────────────
-
-(cl-test "comment: line" (cl-tok-types "; comment\nfoo") (list "symbol"))
-(cl-test "comment: inline" (cl-tok-values "foo ; bar\nbaz") (list "FOO" "BAZ"))
-(cl-test "block-comment: basic" (cl-tok-types "#| hello |# foo") (list "symbol"))
-(cl-test "block-comment: nested" (cl-tok-types "#| a #| b |# c |# x") (list "symbol"))
-
-;; ── combined ──────────────────────────────────────────────────────
-
-(cl-test
-  "combined: defun skeleton"
-  (cl-tok-types "(defun foo (x) x)")
-  (list "lparen" "symbol" "symbol" "lparen" "symbol" "rparen" "symbol" "rparen"))
-
-(cl-test
-  "combined: let form"
-  (cl-tok-types "(let ((x 1)) x)")
-  (list
-    "lparen"
-    "symbol"
-    "lparen"
-    "lparen"
-    "symbol"
-    "integer"
-    "rparen"
-    "rparen"
-    "symbol"
-    "rparen"))
-
-(cl-test
-  "combined: whitespace skip"
-  (cl-tok-values "  foo   bar   baz  ")
-  (list "FOO" "BAR" "BAZ"))
-
-(cl-test "eof: present" (get (nth (cl-tokenize "") 0) "type") "eof")
-(cl-test "eof: at end of tokens" (get (nth (cl-tokenize "x") 1) "type") "eof")

lib/common-lisp/tests/runtime.sx

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

lib/common-lisp/tests/stdlib.sx

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

lib/forth/ans-tests/README.md

@@ -0,0 +1,14 @@
+ANS Forth conformance tests — vendored from
+https://github.com/gerryjackson/forth2012-test-suite (master, commit-locked
+on first fetch: 2026-04-24).
+
+Files in this directory are pristine copies of upstream — do not edit them.
+They are consumed by the conformance runner in `lib/forth/conformance.sh`.
+
+- `tester.fr` — John Hayes' test harness (`T{ ... -> ... }T`). (C) 1995
+  Johns Hopkins APL, distributable under its notice.
+- `core.fr` — Core word set tests (Hayes, ~1000 lines).
+- `coreexttest.fth` — Core Extension tests (Gerry Jackson).
+
+Only `core.fr` is expected to run green end-to-end for Phase 3; the others
+stay parked until later phases.

lib/forth/ans-tests/coreexttest.fth

@@ -0,0 +1,775 @@
+\ To test the ANS Forth Core Extension word set
+
+\ This program was written by Gerry Jackson in 2006, with contributions from
+\ others where indicated, and is in the public domain - it can be distributed
+\ and/or modified in any way but please retain this notice.
+
+\ This program is distributed in the hope that it will be useful,
+\ but WITHOUT ANY WARRANTY; without even the implied warranty of
+\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+\ The tests are not claimed to be comprehensive or correct 
+
+\ ------------------------------------------------------------------------------
+\ Version 0.15 1 August 2025 Added two tests to VALUE
+\         0.14 21 July 2022 Updated first line of BUFFER: test as recommended
+\              in issue 32
+\         0.13 28 October 2015
+\              Replace <FALSE> and <TRUE> with FALSE and TRUE to avoid
+\              dependence on Core tests
+\              Moved SAVE-INPUT and RESTORE-INPUT tests in a file to filetest.fth
+\              Use of 2VARIABLE (from optional wordset) replaced with CREATE.
+\              Minor lower to upper case conversions.
+\              Calls to COMPARE replaced by S= (in utilities.fth) to avoid use
+\              of a word from an optional word set.
+\              UNUSED tests revised as UNUSED UNUSED = may return FALSE when an
+\              implementation has the data stack sharing unused dataspace.
+\              Double number input dependency removed from the HOLDS tests.
+\              Minor case sensitivities removed in definition names.
+\         0.11 25 April 2015
+\              Added tests for PARSE-NAME HOLDS BUFFER:
+\              S\" tests added
+\              DEFER IS ACTION-OF DEFER! DEFER@ tests added
+\              Empty CASE statement test added
+\              [COMPILE] tests removed because it is obsolescent in Forth 2012
+\         0.10 1 August 2014
+\             Added tests contributed by James Bowman for:
+\                <> U> 0<> 0> NIP TUCK ROLL PICK 2>R 2R@ 2R>
+\                HEX WITHIN UNUSED AGAIN MARKER
+\             Added tests for:
+\                .R U.R ERASE PAD REFILL SOURCE-ID 
+\             Removed ABORT from NeverExecuted to enable Win32
+\             to continue after failure of RESTORE-INPUT.
+\             Removed max-intx which is no longer used.
+\         0.7 6 June 2012 Extra CASE test added
+\         0.6 1 April 2012 Tests placed in the public domain.
+\             SAVE-INPUT & RESTORE-INPUT tests, position
+\             of T{ moved so that tests work with ttester.fs
+\             CONVERT test deleted - obsolete word removed from Forth 200X
+\             IMMEDIATE VALUEs tested
+\             RECURSE with :NONAME tested
+\             PARSE and .( tested
+\             Parsing behaviour of C" added
+\         0.5 14 September 2011 Removed the double [ELSE] from the
+\             initial SAVE-INPUT & RESTORE-INPUT test
+\         0.4 30 November 2009  max-int replaced with max-intx to
+\             avoid redefinition warnings.
+\         0.3  6 March 2009 { and } replaced with T{ and }T
+\                           CONVERT test now independent of cell size
+\         0.2  20 April 2007 ANS Forth words changed to upper case
+\                            Tests qd3 to qd6 by Reinhold Straub
+\         0.1  Oct 2006 First version released
+\ -----------------------------------------------------------------------------
+\ The tests are based on John Hayes test program for the core word set
+
+\ Words tested in this file are:
+\     .( .R 0<> 0> 2>R 2R> 2R@ :NONAME <> ?DO AGAIN C" CASE COMPILE, ENDCASE
+\     ENDOF ERASE FALSE HEX MARKER NIP OF PAD PARSE PICK REFILL
+\     RESTORE-INPUT ROLL SAVE-INPUT SOURCE-ID TO TRUE TUCK U.R U> UNUSED
+\     VALUE WITHIN [COMPILE]
+
+\ Words not tested or partially tested:
+\     \ because it has been extensively used already and is, hence, unnecessary
+\     REFILL and SOURCE-ID from the user input device which are not possible
+\     when testing from a file such as this one
+\     UNUSED (partially tested) as the value returned is system dependent
+\     Obsolescent words #TIB CONVERT EXPECT QUERY SPAN TIB as they have been
+\     removed from the Forth 2012 standard
+
+\ Results from words that output to the user output device have to visually
+\ checked for correctness. These are .R U.R .(
+
+\ -----------------------------------------------------------------------------
+\ Assumptions & dependencies:
+\     - tester.fr (or ttester.fs), errorreport.fth and utilities.fth have been
+\       included prior to this file
+\     - the Core word set available
+\ -----------------------------------------------------------------------------
+TESTING Core Extension words
+
+DECIMAL
+
+TESTING TRUE FALSE
+
+T{ TRUE  -> 0 INVERT }T
+T{ FALSE -> 0 }T
+
+\ -----------------------------------------------------------------------------
+TESTING <> U>   (contributed by James Bowman)
+
+T{ 0 0 <> -> FALSE }T
+T{ 1 1 <> -> FALSE }T
+T{ -1 -1 <> -> FALSE }T
+T{ 1 0 <> -> TRUE }T
+T{ -1 0 <> -> TRUE }T
+T{ 0 1 <> -> TRUE }T
+T{ 0 -1 <> -> TRUE }T
+
+T{ 0 1 U> -> FALSE }T
+T{ 1 2 U> -> FALSE }T
+T{ 0 MID-UINT U> -> FALSE }T
+T{ 0 MAX-UINT U> -> FALSE }T
+T{ MID-UINT MAX-UINT U> -> FALSE }T
+T{ 0 0 U> -> FALSE }T
+T{ 1 1 U> -> FALSE }T
+T{ 1 0 U> -> TRUE }T
+T{ 2 1 U> -> TRUE }T
+T{ MID-UINT 0 U> -> TRUE }T
+T{ MAX-UINT 0 U> -> TRUE }T
+T{ MAX-UINT MID-UINT U> -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING 0<> 0>   (contributed by James Bowman)
+
+T{ 0 0<> -> FALSE }T
+T{ 1 0<> -> TRUE }T
+T{ 2 0<> -> TRUE }T
+T{ -1 0<> -> TRUE }T
+T{ MAX-UINT 0<> -> TRUE }T
+T{ MIN-INT 0<> -> TRUE }T
+T{ MAX-INT 0<> -> TRUE }T
+
+T{ 0 0> -> FALSE }T
+T{ -1 0> -> FALSE }T
+T{ MIN-INT 0> -> FALSE }T
+T{ 1 0> -> TRUE }T
+T{ MAX-INT 0> -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING NIP TUCK ROLL PICK   (contributed by James Bowman)
+
+T{ 1 2 NIP -> 2 }T
+T{ 1 2 3 NIP -> 1 3 }T
+
+T{ 1 2 TUCK -> 2 1 2 }T
+T{ 1 2 3 TUCK -> 1 3 2 3 }T
+
+T{ : RO5 100 200 300 400 500 ; -> }T
+T{ RO5 3 ROLL -> 100 300 400 500 200 }T
+T{ RO5 2 ROLL -> RO5 ROT }T
+T{ RO5 1 ROLL -> RO5 SWAP }T
+T{ RO5 0 ROLL -> RO5 }T
+
+T{ RO5 2 PICK -> 100 200 300 400 500 300 }T
+T{ RO5 1 PICK -> RO5 OVER }T
+T{ RO5 0 PICK -> RO5 DUP }T
+
+\ -----------------------------------------------------------------------------
+TESTING 2>R 2R@ 2R>   (contributed by James Bowman)
+
+T{ : RR0 2>R 100 R> R> ; -> }T
+T{ 300 400 RR0 -> 100 400 300 }T
+T{ 200 300 400 RR0 -> 200 100 400 300 }T
+
+T{ : RR1 2>R 100 2R@ R> R> ; -> }T
+T{ 300 400 RR1 -> 100 300 400 400 300 }T
+T{ 200 300 400 RR1 -> 200 100 300 400 400 300 }T
+
+T{ : RR2 2>R 100 2R> ; -> }T
+T{ 300 400 RR2 -> 100 300 400 }T
+T{ 200 300 400 RR2 -> 200 100 300 400 }T
+
+\ -----------------------------------------------------------------------------
+TESTING HEX   (contributed by James Bowman)
+
+T{ BASE @ HEX BASE @ DECIMAL BASE @ - SWAP BASE ! -> 6 }T
+
+\ -----------------------------------------------------------------------------
+TESTING WITHIN   (contributed by James Bowman)
+
+T{ 0 0 0 WITHIN -> FALSE }T
+T{ 0 0 MID-UINT WITHIN -> TRUE }T
+T{ 0 0 MID-UINT+1 WITHIN -> TRUE }T
+T{ 0 0 MAX-UINT WITHIN -> TRUE }T
+T{ 0 MID-UINT 0 WITHIN -> FALSE }T
+T{ 0 MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ 0 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ 0 MID-UINT MAX-UINT WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 0 WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ 0 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ 0 MAX-UINT 0 WITHIN -> FALSE }T
+T{ 0 MAX-UINT MID-UINT WITHIN -> TRUE }T
+T{ 0 MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ 0 MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT 0 0 WITHIN -> FALSE }T
+T{ MID-UINT 0 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT 0 MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT 0 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT 0 WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT+1 0 WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT 0 WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 0 0 WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT 0 WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 0 WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT+1 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MAX-UINT 0 WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT 0 0 WITHIN -> FALSE }T
+T{ MAX-UINT 0 MID-UINT WITHIN -> FALSE }T
+T{ MAX-UINT 0 MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT 0 MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT 0 WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT+1 0 WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MAX-UINT 0 WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MID-UINT WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
+
+T{ MIN-INT MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT MIN-INT 0 WITHIN -> TRUE }T
+T{ MIN-INT MIN-INT 1 WITHIN -> TRUE }T
+T{ MIN-INT MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ MIN-INT 0 MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT 0 0 WITHIN -> FALSE }T
+T{ MIN-INT 0 1 WITHIN -> FALSE }T
+T{ MIN-INT 0 MAX-INT WITHIN -> FALSE }T
+T{ MIN-INT 1 MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT 1 0 WITHIN -> TRUE }T
+T{ MIN-INT 1 1 WITHIN -> FALSE }T
+T{ MIN-INT 1 MAX-INT WITHIN -> FALSE }T
+T{ MIN-INT MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT MAX-INT 0 WITHIN -> TRUE }T
+T{ MIN-INT MAX-INT 1 WITHIN -> TRUE }T
+T{ MIN-INT MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ 0 MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ 0 MIN-INT 0 WITHIN -> FALSE }T
+T{ 0 MIN-INT 1 WITHIN -> TRUE }T
+T{ 0 MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ 0 0 MIN-INT WITHIN -> TRUE }T
+T{ 0 0 0 WITHIN -> FALSE }T
+T{ 0 0 1 WITHIN -> TRUE }T
+T{ 0 0 MAX-INT WITHIN -> TRUE }T
+T{ 0 1 MIN-INT WITHIN -> FALSE }T
+T{ 0 1 0 WITHIN -> FALSE }T
+T{ 0 1 1 WITHIN -> FALSE }T
+T{ 0 1 MAX-INT WITHIN -> FALSE }T
+T{ 0 MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ 0 MAX-INT 0 WITHIN -> FALSE }T
+T{ 0 MAX-INT 1 WITHIN -> TRUE }T
+T{ 0 MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ 1 MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ 1 MIN-INT 0 WITHIN -> FALSE }T
+T{ 1 MIN-INT 1 WITHIN -> FALSE }T
+T{ 1 MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ 1 0 MIN-INT WITHIN -> TRUE }T
+T{ 1 0 0 WITHIN -> FALSE }T
+T{ 1 0 1 WITHIN -> FALSE }T
+T{ 1 0 MAX-INT WITHIN -> TRUE }T
+T{ 1 1 MIN-INT WITHIN -> TRUE }T
+T{ 1 1 0 WITHIN -> TRUE }T
+T{ 1 1 1 WITHIN -> FALSE }T
+T{ 1 1 MAX-INT WITHIN -> TRUE }T
+T{ 1 MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ 1 MAX-INT 0 WITHIN -> FALSE }T
+T{ 1 MAX-INT 1 WITHIN -> FALSE }T
+T{ 1 MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT 0 WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT 1 WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT 0 MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT 0 0 WITHIN -> FALSE }T
+T{ MAX-INT 0 1 WITHIN -> FALSE }T
+T{ MAX-INT 0 MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT 1 MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT 1 0 WITHIN -> TRUE }T
+T{ MAX-INT 1 1 WITHIN -> FALSE }T
+T{ MAX-INT 1 MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT MAX-INT MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT 0 WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT 1 WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT MAX-INT WITHIN -> FALSE }T
+
+\ -----------------------------------------------------------------------------
+TESTING UNUSED  (contributed by James Bowman & Peter Knaggs)
+
+VARIABLE UNUSED0
+T{ UNUSED DROP -> }T                  
+T{ ALIGN UNUSED UNUSED0 ! 0 , UNUSED CELL+ UNUSED0 @ = -> TRUE }T
+T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ =
+         -> TRUE }T  \ aligned -> unaligned
+T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ = -> TRUE }T  \ unaligned -> ?
+
+\ -----------------------------------------------------------------------------
+TESTING AGAIN   (contributed by James Bowman)
+
+T{ : AG0 701 BEGIN DUP 7 MOD 0= IF EXIT THEN 1+ AGAIN ; -> }T
+T{ AG0 -> 707 }T
+
+\ -----------------------------------------------------------------------------
+TESTING MARKER   (contributed by James Bowman)
+
+T{ : MA? BL WORD FIND NIP 0<> ; -> }T
+T{ MARKER MA0 -> }T
+T{ : MA1 111 ; -> }T
+T{ MARKER MA2 -> }T
+T{ : MA1 222 ; -> }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE TRUE }T
+T{ MA1 MA2 MA1 -> 222 111 }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE FALSE }T
+T{ MA0 -> }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> FALSE FALSE FALSE }T
+
+\ -----------------------------------------------------------------------------
+TESTING ?DO
+
+: QD ?DO I LOOP ;
+T{ 789 789 QD -> }T
+T{ -9876 -9876 QD -> }T
+T{ 5 0 QD -> 0 1 2 3 4 }T
+
+: QD1 ?DO I 10 +LOOP ;
+T{ 50 1 QD1 -> 1 11 21 31 41 }T
+T{ 50 0 QD1 -> 0 10 20 30 40 }T
+
+: QD2 ?DO I 3 > IF LEAVE ELSE I THEN LOOP ;
+T{ 5 -1 QD2 -> -1 0 1 2 3 }T
+
+: QD3 ?DO I 1 +LOOP ;
+T{ 4  4 QD3 -> }T
+T{ 4  1 QD3 -> 1 2 3 }T
+T{ 2 -1 QD3 -> -1 0 1 }T
+
+: QD4 ?DO I -1 +LOOP ;
+T{  4 4 QD4 -> }T
+T{  1 4 QD4 -> 4 3 2 1 }T
+T{ -1 2 QD4 -> 2 1 0 -1 }T
+
+: QD5 ?DO I -10 +LOOP ;
+T{   1 50 QD5 -> 50 40 30 20 10 }T
+T{   0 50 QD5 -> 50 40 30 20 10 0 }T
+T{ -25 10 QD5 -> 10 0 -10 -20 }T
+
+VARIABLE ITERS
+VARIABLE INCRMNT
+
+: QD6 ( limit start increment -- )
+   INCRMNT !
+   0 ITERS !
+   ?DO
+      1 ITERS +!
+      I
+      ITERS @  6 = IF LEAVE THEN
+      INCRMNT @
+   +LOOP ITERS @
+;
+
+T{  4  4 -1 QD6 -> 0 }T
+T{  1  4 -1 QD6 -> 4 3 2 1 4 }T
+T{  4  1 -1 QD6 -> 1 0 -1 -2 -3 -4 6 }T
+T{  4  1  0 QD6 -> 1 1 1 1 1 1 6 }T
+T{  0  0  0 QD6 -> 0 }T
+T{  1  4  0 QD6 -> 4 4 4 4 4 4 6 }T
+T{  1  4  1 QD6 -> 4 5 6 7 8 9 6 }T
+T{  4  1  1 QD6 -> 1 2 3 3 }T
+T{  4  4  1 QD6 -> 0 }T
+T{  2 -1 -1 QD6 -> -1 -2 -3 -4 -5 -6 6 }T
+T{ -1  2 -1 QD6 -> 2 1 0 -1 4 }T
+T{  2 -1  0 QD6 -> -1 -1 -1 -1 -1 -1 6 }T
+T{ -1  2  0 QD6 -> 2 2 2 2 2 2 6 }T
+T{ -1  2  1 QD6 -> 2 3 4 5 6 7 6 }T
+T{  2 -1  1 QD6 -> -1 0 1 3 }T
+
+\ -----------------------------------------------------------------------------
+TESTING BUFFER:
+
+T{ 2 CELLS BUFFER: BUF:TEST -> }T
+T{ BUF:TEST DUP ALIGNED = -> TRUE }T
+T{ 111 BUF:TEST ! 222 BUF:TEST CELL+ ! -> }T
+T{ BUF:TEST @ BUF:TEST CELL+ @ -> 111 222 }T
+
+\ -----------------------------------------------------------------------------
+TESTING VALUE TO
+
+T{ 111 VALUE VAL1 -999 VALUE VAL2 -> }T
+T{ VAL1 -> 111 }T
+T{ VAL2 -> -999 }T
+T{ 222 TO VAL1 -> }T
+T{ VAL1 -> 222 }T
+T{ : VD1 VAL1 ; -> }T
+T{ VD1 -> 222 }T
+T{ : VD2 TO VAL2 ; -> }T
+T{ VAL2 -> -999 }T
+T{ -333 VD2 -> }T
+T{ VAL2 -> -333 }T
+T{ VAL1 -> 222 }T
+T{ 444 TO VAL1 -> }T
+T{ VD1 -> 444 }T
+T{ 123 VALUE VAL3 IMMEDIATE VAL3 -> 123 }T
+T{ : VD3 VAL3 LITERAL ; VD3 -> 123 }T
+
+\ -----------------------------------------------------------------------------
+TESTING CASE OF ENDOF ENDCASE
+
+: CS1 CASE 1 OF 111 ENDOF
+           2 OF 222 ENDOF
+           3 OF 333 ENDOF
+           >R 999 R>
+      ENDCASE
+;
+
+T{ 1 CS1 -> 111 }T
+T{ 2 CS1 -> 222 }T
+T{ 3 CS1 -> 333 }T
+T{ 4 CS1 -> 999 }T
+
+\ Nested CASE's
+
+: CS2 >R CASE -1 OF CASE R@ 1 OF 100 ENDOF
+                            2 OF 200 ENDOF
+                           >R -300 R>
+                    ENDCASE
+                 ENDOF
+              -2 OF CASE R@ 1 OF -99  ENDOF
+                            >R -199 R>
+                    ENDCASE
+                 ENDOF
+                 >R 299 R>
+         ENDCASE R> DROP
+;
+
+T{ -1 1 CS2 ->  100 }T
+T{ -1 2 CS2 ->  200 }T
+T{ -1 3 CS2 -> -300 }T
+T{ -2 1 CS2 -> -99  }T
+T{ -2 2 CS2 -> -199 }T
+T{  0 2 CS2 ->  299 }T
+
+\ Boolean short circuiting using CASE
+
+: CS3  ( N1 -- N2 )
+   CASE 1- FALSE OF 11 ENDOF
+        1- FALSE OF 22 ENDOF
+        1- FALSE OF 33 ENDOF
+        44 SWAP
+   ENDCASE
+;
+
+T{ 1 CS3 -> 11 }T
+T{ 2 CS3 -> 22 }T
+T{ 3 CS3 -> 33 }T
+T{ 9 CS3 -> 44 }T
+
+\ Empty CASE statements with/without default
+
+T{ : CS4 CASE ENDCASE ; 1 CS4 -> }T
+T{ : CS5 CASE 2 SWAP ENDCASE ; 1 CS5 -> 2 }T
+T{ : CS6 CASE 1 OF ENDOF 2 ENDCASE ; 1 CS6 -> }T
+T{ : CS7 CASE 3 OF ENDOF 2 ENDCASE ; 1 CS7 -> 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING :NONAME RECURSE
+
+VARIABLE NN1
+VARIABLE NN2
+:NONAME 1234 ; NN1 !
+:NONAME 9876 ; NN2 !
+T{ NN1 @ EXECUTE -> 1234 }T
+T{ NN2 @ EXECUTE -> 9876 }T
+
+T{ :NONAME ( n -- 0,1,..n ) DUP IF DUP >R 1- RECURSE R> THEN ;
+   CONSTANT RN1 -> }T
+T{ 0 RN1 EXECUTE -> 0 }T
+T{ 4 RN1 EXECUTE -> 0 1 2 3 4 }T
+
+:NONAME  ( n -- n1 )    \ Multiple RECURSEs in one definition
+   1- DUP
+   CASE 0 OF EXIT ENDOF
+        1 OF 11 SWAP RECURSE ENDOF
+        2 OF 22 SWAP RECURSE ENDOF
+        3 OF 33 SWAP RECURSE ENDOF
+        DROP ABS RECURSE EXIT
+   ENDCASE
+; CONSTANT RN2
+
+T{  1 RN2 EXECUTE -> 0 }T
+T{  2 RN2 EXECUTE -> 11 0 }T
+T{  4 RN2 EXECUTE -> 33 22 11 0 }T
+T{ 25 RN2 EXECUTE -> 33 22 11 0 }T
+
+\ -----------------------------------------------------------------------------
+TESTING C"
+
+T{ : CQ1 C" 123" ; -> }T
+T{ CQ1 COUNT EVALUATE -> 123 }T
+T{ : CQ2 C" " ; -> }T
+T{ CQ2 COUNT EVALUATE -> }T
+T{ : CQ3 C" 2345"COUNT EVALUATE ; CQ3 -> 2345 }T
+
+\ -----------------------------------------------------------------------------
+TESTING COMPILE,
+
+:NONAME DUP + ; CONSTANT DUP+
+T{ : Q DUP+ COMPILE, ; -> }T
+T{ : AS1 [ Q ] ; -> }T
+T{ 123 AS1 -> 246 }T
+
+\ -----------------------------------------------------------------------------
+\ Cannot automatically test SAVE-INPUT and RESTORE-INPUT from a console source
+
+TESTING SAVE-INPUT and RESTORE-INPUT with a string source
+
+VARIABLE SI_INC 0 SI_INC !
+
+: SI1
+   SI_INC @ >IN +!
+   15 SI_INC !
+;
+
+: S$ S" SAVE-INPUT SI1 RESTORE-INPUT 12345" ;
+
+T{ S$ EVALUATE SI_INC @ -> 0 2345 15 }T
+
+\ -----------------------------------------------------------------------------
+TESTING .(
+
+CR CR .( Output from .() 
+T{ CR .( You should see -9876: ) -9876 . -> }T
+T{ CR .( and again: ).( -9876)CR -> }T
+
+CR CR .( On the next 2 lines you should see First then Second messages:)
+T{ : DOTP  CR ." Second message via ." [CHAR] " EMIT    \ Check .( is immediate
+     [ CR ] .( First message via .( ) ; DOTP -> }T
+CR CR
+T{ : IMM? BL WORD FIND NIP ; IMM? .( -> 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING .R and U.R - has to handle different cell sizes
+
+\ Create some large integers just below/above MAX and Min INTs
+MAX-INT 73 79 */ CONSTANT LI1
+MIN-INT 71 73 */ CONSTANT LI2
+
+LI1 0 <# #S #> NIP CONSTANT LENLI1
+
+: (.R&U.R)  ( u1 u2 -- )  \ u1 <= string length, u2 is required indentation
+   TUCK + >R
+   LI1 OVER SPACES  . CR R@    LI1 SWAP  .R CR
+   LI2 OVER SPACES  . CR R@ 1+ LI2 SWAP  .R CR
+   LI1 OVER SPACES U. CR R@    LI1 SWAP U.R CR
+   LI2 SWAP SPACES U. CR R>    LI2 SWAP U.R CR
+;
+
+: .R&U.R  ( -- )
+   CR ." You should see lines duplicated:" CR
+   ." indented by 0 spaces" CR 0      0 (.R&U.R) CR
+   ." indented by 0 spaces" CR LENLI1 0 (.R&U.R) CR \ Just fits required width
+   ." indented by 5 spaces" CR LENLI1 5 (.R&U.R) CR
+;
+
+CR CR .( Output from .R and U.R)
+T{ .R&U.R -> }T
+
+\ -----------------------------------------------------------------------------
+TESTING PAD ERASE
+\ Must handle different size characters i.e. 1 CHARS >= 1 
+
+84 CONSTANT CHARS/PAD      \ Minimum size of PAD in chars
+CHARS/PAD CHARS CONSTANT AUS/PAD
+: CHECKPAD  ( caddr u ch -- f )  \ f = TRUE if u chars = ch
+   SWAP 0
+   ?DO
+      OVER I CHARS + C@ OVER <>
+      IF 2DROP UNLOOP FALSE EXIT THEN
+   LOOP  
+   2DROP TRUE
+;
+
+T{ PAD DROP -> }T
+T{ 0 INVERT PAD C! -> }T
+T{ PAD C@ CONSTANT MAXCHAR -> }T
+T{ PAD CHARS/PAD 2DUP MAXCHAR FILL MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD CHARS/PAD 2DUP CHARS ERASE 0 CHECKPAD -> TRUE }T
+T{ PAD CHARS/PAD 2DUP MAXCHAR FILL PAD 0 ERASE MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD 43 CHARS + 9 CHARS ERASE -> }T
+T{ PAD 43 MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD 43 CHARS + 9 0 CHECKPAD -> TRUE }T
+T{ PAD 52 CHARS + CHARS/PAD 52 - MAXCHAR CHECKPAD -> TRUE }T
+
+\ Check that use of WORD and pictured numeric output do not corrupt PAD
+\ Minimum size of buffers for these are 33 chars and (2*n)+2 chars respectively
+\ where n is number of bits per cell
+
+PAD CHARS/PAD ERASE
+2 BASE !
+MAX-UINT MAX-UINT <# #S CHAR 1 DUP HOLD HOLD #> 2DROP
+DECIMAL
+BL WORD 12345678123456781234567812345678 DROP
+T{ PAD CHARS/PAD 0 CHECKPAD -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING PARSE
+
+T{ CHAR | PARSE 1234| DUP ROT ROT EVALUATE -> 4 1234 }T
+T{ CHAR ^ PARSE  23 45 ^ DUP ROT ROT EVALUATE -> 7 23 45 }T
+: PA1 [CHAR] $ PARSE DUP >R PAD SWAP CHARS MOVE PAD R> ;
+T{ PA1 3456
+   DUP ROT ROT EVALUATE -> 4 3456 }T
+T{ CHAR A PARSE A SWAP DROP -> 0 }T
+T{ CHAR Z PARSE
+   SWAP DROP -> 0 }T
+T{ CHAR " PARSE 4567 "DUP ROT ROT EVALUATE -> 5 4567 }T
+ 
+\ -----------------------------------------------------------------------------
+TESTING PARSE-NAME  (Forth 2012)
+\ Adapted from the PARSE-NAME RfD tests
+
+T{ PARSE-NAME abcd  STR1  S= -> TRUE }T        \ No leading spaces
+T{ PARSE-NAME      abcde STR2 S= -> TRUE }T    \ Leading spaces
+
+\ Test empty parse area, new lines are necessary
+T{ PARSE-NAME
+  NIP -> 0 }T
+\ Empty parse area with spaces after PARSE-NAME
+T{ PARSE-NAME         
+  NIP -> 0 }T
+
+T{ : PARSE-NAME-TEST ( "name1" "name2" -- n )
+    PARSE-NAME PARSE-NAME S= ; -> }T
+T{ PARSE-NAME-TEST abcd abcd  -> TRUE }T
+T{ PARSE-NAME-TEST abcd   abcd  -> TRUE }T  \ Leading spaces
+T{ PARSE-NAME-TEST abcde abcdf -> FALSE }T
+T{ PARSE-NAME-TEST abcdf abcde -> FALSE }T
+T{ PARSE-NAME-TEST abcde abcde
+   -> TRUE }T         \ Parse to end of line
+T{ PARSE-NAME-TEST abcde           abcde         
+   -> TRUE }T         \ Leading and trailing spaces
+
+\ -----------------------------------------------------------------------------
+TESTING DEFER DEFER@ DEFER! IS ACTION-OF (Forth 2012)
+\ Adapted from the Forth 200X RfD tests
+
+T{ DEFER DEFER1 -> }T
+T{ : MY-DEFER DEFER ; -> }T
+T{ : IS-DEFER1 IS DEFER1 ; -> }T
+T{ : ACTION-DEFER1 ACTION-OF DEFER1 ; -> }T
+T{ : DEF! DEFER! ; -> }T
+T{ : DEF@ DEFER@ ; -> }T
+
+T{ ' * ' DEFER1 DEFER! -> }T
+T{ 2 3 DEFER1 -> 6 }T
+T{ ' DEFER1 DEFER@ -> ' * }T
+T{ ' DEFER1 DEF@ -> ' * }T
+T{ ACTION-OF DEFER1 -> ' * }T
+T{ ACTION-DEFER1 -> ' * }T
+T{ ' + IS DEFER1 -> }T
+T{ 1 2 DEFER1 -> 3 }T
+T{ ' DEFER1 DEFER@ -> ' + }T
+T{ ' DEFER1 DEF@ -> ' + }T
+T{ ACTION-OF DEFER1 -> ' + }T
+T{ ACTION-DEFER1 -> ' + }T
+T{ ' - IS-DEFER1 -> }T
+T{ 1 2 DEFER1 -> -1 }T
+T{ ' DEFER1 DEFER@ -> ' - }T
+T{ ' DEFER1 DEF@ -> ' - }T
+T{ ACTION-OF DEFER1 -> ' - }T
+T{ ACTION-DEFER1 -> ' - }T
+
+T{ MY-DEFER DEFER2 -> }T
+T{ ' DUP IS DEFER2 -> }T
+T{ 1 DEFER2 -> 1 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING HOLDS  (Forth 2012)
+
+: HTEST S" Testing HOLDS" ;
+: HTEST2 S" works" ;
+: HTEST3 S" Testing HOLDS works 123" ;
+T{ 0 0 <#  HTEST HOLDS #> HTEST S= -> TRUE }T
+T{ 123 0 <# #S BL HOLD HTEST2 HOLDS BL HOLD HTEST HOLDS #>
+   HTEST3 S= -> TRUE }T
+T{ : HLD HOLDS ; -> }T
+T{ 0 0 <#  HTEST HLD #> HTEST S= -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING REFILL SOURCE-ID
+\ REFILL and SOURCE-ID from the user input device can't be tested from a file,
+\ can only be tested from a string via EVALUATE
+
+T{ : RF1  S" REFILL" EVALUATE ; RF1 -> FALSE }T
+T{ : SID1  S" SOURCE-ID" EVALUATE ; SID1 -> -1 }T
+
+\ ------------------------------------------------------------------------------
+TESTING S\"  (Forth 2012 compilation mode)
+\ Extended the Forth 200X RfD tests
+\ Note this tests the Core Ext definition of S\" which has unedfined
+\ interpretation semantics. S\" in interpretation mode is tested in the tests on
+\ the File-Access word set
+
+T{ : SSQ1 S\" abc" S" abc" S= ; -> }T  \ No escapes
+T{ SSQ1 -> TRUE }T
+T{ : SSQ2 S\" " ; SSQ2 SWAP DROP -> 0 }T    \ Empty string
+
+T{ : SSQ3 S\" \a\b\e\f\l\m\q\r\t\v\x0F0\x1Fa\xaBx\z\"\\" ; -> }T
+T{ SSQ3 SWAP DROP          ->  20 }T    \ String length
+T{ SSQ3 DROP            C@ ->   7 }T    \ \a   BEL  Bell
+T{ SSQ3 DROP  1 CHARS + C@ ->   8 }T    \ \b   BS   Backspace
+T{ SSQ3 DROP  2 CHARS + C@ ->  27 }T    \ \e   ESC  Escape
+T{ SSQ3 DROP  3 CHARS + C@ ->  12 }T    \ \f   FF   Form feed
+T{ SSQ3 DROP  4 CHARS + C@ ->  10 }T    \ \l   LF   Line feed
+T{ SSQ3 DROP  5 CHARS + C@ ->  13 }T    \ \m        CR of CR/LF pair
+T{ SSQ3 DROP  6 CHARS + C@ ->  10 }T    \           LF of CR/LF pair
+T{ SSQ3 DROP  7 CHARS + C@ ->  34 }T    \ \q   "    Double Quote
+T{ SSQ3 DROP  8 CHARS + C@ ->  13 }T    \ \r   CR   Carriage Return
+T{ SSQ3 DROP  9 CHARS + C@ ->   9 }T    \ \t   TAB  Horizontal Tab
+T{ SSQ3 DROP 10 CHARS + C@ ->  11 }T    \ \v   VT   Vertical Tab
+T{ SSQ3 DROP 11 CHARS + C@ ->  15 }T    \ \x0F      Given Char
+T{ SSQ3 DROP 12 CHARS + C@ ->  48 }T    \ 0    0    Digit follow on
+T{ SSQ3 DROP 13 CHARS + C@ ->  31 }T    \ \x1F      Given Char
+T{ SSQ3 DROP 14 CHARS + C@ ->  97 }T    \ a    a    Hex follow on
+T{ SSQ3 DROP 15 CHARS + C@ -> 171 }T    \ \xaB      Insensitive Given Char
+T{ SSQ3 DROP 16 CHARS + C@ -> 120 }T    \ x    x    Non hex follow on
+T{ SSQ3 DROP 17 CHARS + C@ ->   0 }T    \ \z   NUL  No Character
+T{ SSQ3 DROP 18 CHARS + C@ ->  34 }T    \ \"   "    Double Quote
+T{ SSQ3 DROP 19 CHARS + C@ ->  92 }T    \ \\   \    Back Slash
+
+\ The above does not test \n as this is a system dependent value.
+\ Check it displays a new line
+CR .( The next test should display:)
+CR .( One line...)
+CR .( another line)
+T{ : SSQ4 S\" \nOne line...\nanotherLine\n" TYPE ; SSQ4 -> }T
+
+\ Test bare escapable characters appear as themselves
+T{ : SSQ5 S\" abeflmnqrtvxz" S" abeflmnqrtvxz" S= ; SSQ5 -> TRUE }T
+
+T{ : SSQ6 S\" a\""2DROP 1111 ; SSQ6 -> 1111 }T \ Parsing behaviour
+
+T{ : SSQ7  S\" 111 : SSQ8 S\\\" 222\" EVALUATE ; SSQ8 333" EVALUATE ; -> }T
+T{ SSQ7 -> 111 222 333 }T
+T{ : SSQ9  S\" 11 : SSQ10 S\\\" \\x32\\x32\" EVALUATE ; SSQ10 33" EVALUATE ; -> }T
+T{ SSQ9 -> 11 22 33 }T
+
+\ -----------------------------------------------------------------------------
+CORE-EXT-ERRORS SET-ERROR-COUNT
+
+CR .( End of Core Extension word tests) CR
+
+

lib/forth/ans-tests/tester.fr

@@ -0,0 +1,66 @@
+\ From: John Hayes S1I
+\ Subject: tester.fr
+\ Date: Mon, 27 Nov 95 13:10:09 PST  
+
+\ (C) 1995 JOHNS HOPKINS UNIVERSITY / APPLIED PHYSICS LABORATORY
+\ MAY BE DISTRIBUTED FREELY AS LONG AS THIS COPYRIGHT NOTICE REMAINS.
+\ VERSION 1.2
+
+\ 24/11/2015 Replaced Core Ext word <> with = 0=
+\ 31/3/2015 Variable #ERRORS added and incremented for each error reported.
+\ 22/1/09 The words { and } have been changed to T{ and }T respectively to
+\ agree with the Forth 200X file ttester.fs. This avoids clashes with
+\ locals using { ... } and the FSL use of } 
+
+HEX
+
+\ SET THE FOLLOWING FLAG TO TRUE FOR MORE VERBOSE OUTPUT; THIS MAY
+\ ALLOW YOU TO TELL WHICH TEST CAUSED YOUR SYSTEM TO HANG.
+VARIABLE VERBOSE
+   FALSE VERBOSE !
+\   TRUE VERBOSE !
+
+: EMPTY-STACK   \ ( ... -- ) EMPTY STACK: HANDLES UNDERFLOWED STACK TOO.
+   DEPTH ?DUP IF DUP 0< IF NEGATE 0 DO 0 LOOP ELSE 0 DO DROP LOOP THEN THEN ;
+
+VARIABLE #ERRORS 0 #ERRORS !
+
+: ERROR      \ ( C-ADDR U -- ) DISPLAY AN ERROR MESSAGE FOLLOWED BY
+      \ THE LINE THAT HAD THE ERROR.
+   CR TYPE SOURCE TYPE       \ DISPLAY LINE CORRESPONDING TO ERROR
+   EMPTY-STACK               \ THROW AWAY EVERY THING ELSE
+   #ERRORS @ 1 + #ERRORS !
+\   QUIT  \ *** Uncomment this line to QUIT on an error
+;
+
+VARIABLE ACTUAL-DEPTH         \ STACK RECORD
+CREATE ACTUAL-RESULTS 20 CELLS ALLOT
+
+: T{      \ ( -- ) SYNTACTIC SUGAR.
+   ;
+
+: ->      \ ( ... -- ) RECORD DEPTH AND CONTENT OF STACK.
+   DEPTH DUP ACTUAL-DEPTH !      \ RECORD DEPTH
+   ?DUP IF            \ IF THERE IS SOMETHING ON STACK
+      0 DO ACTUAL-RESULTS I CELLS + ! LOOP \ SAVE THEM
+   THEN ;
+
+: }T      \ ( ... -- ) COMPARE STACK (EXPECTED) CONTENTS WITH SAVED
+      \ (ACTUAL) CONTENTS.
+   DEPTH ACTUAL-DEPTH @ = IF      \ IF DEPTHS MATCH
+      DEPTH ?DUP IF         \ IF THERE IS SOMETHING ON THE STACK
+         0  DO            \ FOR EACH STACK ITEM
+           ACTUAL-RESULTS I CELLS + @   \ COMPARE ACTUAL WITH EXPECTED
+           = 0= IF S" INCORRECT RESULT: " ERROR LEAVE THEN
+         LOOP
+      THEN
+   ELSE               \ DEPTH MISMATCH
+      S" WRONG NUMBER OF RESULTS: " ERROR
+   THEN ;
+
+: TESTING   \ ( -- ) TALKING COMMENT.
+  SOURCE VERBOSE @
+   IF DUP >R TYPE CR R> >IN !
+   ELSE >IN ! DROP [CHAR] * EMIT
+   THEN ;
+

lib/forth/conformance.sh

@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+# Run the Hayes/Gerry-Jackson Core conformance suite against our Forth
+# interpreter and emit scoreboard.json + scoreboard.md.
+#
+# Method:
+#   1. Preprocess lib/forth/ans-tests/core.fr — strip \ comments, ( ... )
+#      comments, and TESTING … metadata lines.
+#   2. Split into chunks ending at each `}T` so an error in one test
+#      chunk doesn't abort the run.
+#   3. Emit an SX file that exposes those chunks as a list.
+#   4. Run our Forth + hayes-runner under sx_server; record pass/fail/error.
+
+set -e
+FORTH_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$FORTH_DIR/../.." && pwd)"
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+SOURCE="$FORTH_DIR/ans-tests/core.fr"
+OUT_JSON="$FORTH_DIR/scoreboard.json"
+OUT_MD="$FORTH_DIR/scoreboard.md"
+TMP="$(mktemp -d)"
+PREPROC="$TMP/preproc.forth"
+CHUNKS_SX="$TMP/chunks.sx"
+
+cd "$ROOT"
+
+# 1. preprocess
+awk '
+{
+  line = $0
+  # protect POSTPONE \ so the comment-strip below leaves the literal \ alone
+  gsub(/POSTPONE[ \t]+\\/, "POSTPONE @@BS@@", line)
+  # strip leading/embedded \ line comments (must be \ followed by space or EOL)
+  gsub(/(^|[ \t])\\([ \t].*|$)/, " ", line)
+  # strip ( ... ) block comments that sit on one line
+  gsub(/\([^)]*\)/, " ", line)
+  # strip TESTING … metadata lines (rest of line, incl. bare TESTING)
+  sub(/TESTING([ \t].*)?$/, " ", line)
+  # restore the protected backslash
+  gsub(/@@BS@@/, "\\", line)
+  print line
+}' "$SOURCE" > "$PREPROC"
+
+# 2 + 3: split into chunks at each `}T` and emit as a SX file
+#
+# Cap chunks via MAX_CHUNKS env (default 638 = full Hayes Core). Lower
+# it temporarily if later tests regress into an infinite loop while you
+# are iterating on primitives.
+MAX_CHUNKS="${MAX_CHUNKS:-638}"
+
+MAX_CHUNKS="$MAX_CHUNKS" python3 - "$PREPROC" "$CHUNKS_SX" <<'PY'
+import os, re, sys
+preproc_path, out_path = sys.argv[1], sys.argv[2]
+max_chunks = int(os.environ.get("MAX_CHUNKS", "590"))
+text = open(preproc_path).read()
+# keep the `}T` attached to the preceding chunk
+parts = re.split(r'(\}T)', text)
+chunks = []
+buf = ""
+for p in parts:
+    buf += p
+    if p == "}T":
+        s = buf.strip()
+        if s:
+            chunks.append(s)
+        buf = ""
+if buf.strip():
+    chunks.append(buf.strip())
+chunks = chunks[:max_chunks]
+
+def esc(s):
+    s = s.replace('\\', '\\\\').replace('"', '\\"')
+    s = s.replace('\r', ' ').replace('\n', ' ')
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+with open(out_path, "w") as f:
+    f.write("(define hayes-chunks (list\n")
+    for c in chunks:
+        f.write('  "' + esc(c) + '"\n')
+    f.write("))\n\n")
+    f.write("(define\n")
+    f.write("  hayes-run-all\n")
+    f.write("  (fn\n")
+    f.write("    ()\n")
+    f.write("    (hayes-reset!)\n")
+    f.write("    (let ((s (hayes-boot)))\n")
+    f.write("      (for-each (fn (c) (hayes-run-chunk s c)) hayes-chunks))\n")
+    f.write("    (hayes-summary)))\n")
+PY
+
+# 4. run it
+OUT=$(printf '(epoch 1)\n(load "lib/forth/runtime.sx")\n(epoch 2)\n(load "lib/forth/reader.sx")\n(epoch 3)\n(load "lib/forth/interpreter.sx")\n(epoch 4)\n(load "lib/forth/compiler.sx")\n(epoch 5)\n(load "lib/forth/hayes-runner.sx")\n(epoch 6)\n(load "%s")\n(epoch 7)\n(eval "(hayes-run-all)")\n' "$CHUNKS_SX" \
+  | timeout 180 "$SX_SERVER" 2>&1)
+STATUS=$?
+
+SUMMARY=$(printf '%s\n' "$OUT" | awk '/^\{:pass / {print; exit}')
+PASS=$(printf '%s' "$SUMMARY" | sed -n 's/.*:pass \([0-9-]*\).*/\1/p')
+FAIL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:fail \([0-9-]*\).*/\1/p')
+ERR=$(printf '%s' "$SUMMARY" | sed -n 's/.*:error \([0-9-]*\).*/\1/p')
+TOTAL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:total \([0-9-]*\).*/\1/p')
+CHUNK_COUNT=$(grep -c '^  "' "$CHUNKS_SX" || echo 0)
+TOTAL_AVAILABLE=$(grep -c '}T' "$PREPROC" || echo 0)
+
+NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+if [ -z "$PASS" ]; then
+  PASS=0; FAIL=0; ERR=0; TOTAL=0
+  NOTE="runner halted before completing (timeout or SX error)"
+else
+  NOTE="completed"
+fi
+
+PCT=0
+if [ "$TOTAL" -gt 0 ]; then
+  PCT=$((PASS * 100 / TOTAL))
+fi
+
+cat > "$OUT_JSON" <<JSON
+{
+  "source": "gerryjackson/forth2012-test-suite src/core.fr",
+  "generated_at": "$NOW",
+  "chunks_available": $TOTAL_AVAILABLE,
+  "chunks_fed": $CHUNK_COUNT,
+  "total": $TOTAL,
+  "pass": $PASS,
+  "fail": $FAIL,
+  "error": $ERR,
+  "percent": $PCT,
+  "note": "$NOTE"
+}
+JSON
+
+cat > "$OUT_MD" <<MD
+# Forth Hayes Core scoreboard
+
+| metric            | value |
+| ----------------- | ----: |
+| chunks available  | $TOTAL_AVAILABLE |
+| chunks fed        | $CHUNK_COUNT |
+| total             | $TOTAL |
+| pass              | $PASS |
+| fail              | $FAIL |
+| error             | $ERR |
+| percent           | ${PCT}% |
+
+- **Source**: \`gerryjackson/forth2012-test-suite\` \`src/core.fr\`
+- **Generated**: $NOW
+- **Note**: $NOTE
+
+A "chunk" is any preprocessed segment ending at a \`}T\` (every Hayes test
+is one chunk, plus the small declaration blocks between tests).
+The runner catches raised errors at chunk boundaries so one bad chunk
+does not abort the rest. \`error\` covers chunks that raised; \`fail\`
+covers tests whose \`->\` / \`}T\` comparison mismatched.
+
+### Chunk cap
+
+\`conformance.sh\` processes the first \`\$MAX_CHUNKS\` chunks (default
+**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
+while iterating on primitives if a regression re-opens an infinite
+loop in later tests.
+MD
+
+echo "$SUMMARY"
+echo "Scoreboard: $OUT_JSON"
+echo "           $OUT_MD"
+
+if [ "$STATUS" -ne 0 ] && [ "$TOTAL" -eq 0 ]; then
+  exit 1
+fi

lib/forth/hayes-runner.sx

@@ -0,0 +1,158 @@
+;; Hayes conformance test runner.
+;; Installs T{ -> }T as Forth primitives that snapshot and compare dstack,
+;; plus stub TESTING / HEX / DECIMAL so the Hayes Core file can stream
+;; through the interpreter without halting on unsupported metadata words.
+
+(define hayes-pass 0)
+(define hayes-fail 0)
+(define hayes-error 0)
+(define hayes-start-depth 0)
+(define hayes-actual (list))
+(define hayes-actual-set false)
+(define hayes-failures (list))
+(define hayes-first-error "")
+(define hayes-error-hist (dict))
+
+(define
+  hayes-reset!
+  (fn
+    ()
+    (set! hayes-pass 0)
+    (set! hayes-fail 0)
+    (set! hayes-error 0)
+    (set! hayes-start-depth 0)
+    (set! hayes-actual (list))
+    (set! hayes-actual-set false)
+    (set! hayes-failures (list))
+    (set! hayes-first-error "")
+    (set! hayes-error-hist (dict))))
+
+(define
+  hayes-slice
+  (fn
+    (state base)
+    (let
+      ((n (- (forth-depth state) base)))
+      (if (<= n 0) (list) (take (get state "dstack") n)))))
+
+(define
+  hayes-truncate!
+  (fn
+    (state base)
+    (let
+      ((n (- (forth-depth state) base)))
+      (when (> n 0) (dict-set! state "dstack" (drop (get state "dstack") n))))))
+
+(define
+  hayes-install!
+  (fn
+    (state)
+    (forth-def-prim!
+      state
+      "T{"
+      (fn
+        (s)
+        (set! hayes-start-depth (forth-depth s))
+        (set! hayes-actual-set false)
+        (set! hayes-actual (list))))
+    (forth-def-prim!
+      state
+      "->"
+      (fn
+        (s)
+        (set! hayes-actual (hayes-slice s hayes-start-depth))
+        (set! hayes-actual-set true)
+        (hayes-truncate! s hayes-start-depth)))
+    (forth-def-prim!
+      state
+      "}T"
+      (fn
+        (s)
+        (let
+          ((expected (hayes-slice s hayes-start-depth)))
+          (hayes-truncate! s hayes-start-depth)
+          (if
+            (and hayes-actual-set (= expected hayes-actual))
+            (set! hayes-pass (+ hayes-pass 1))
+            (begin
+              (set! hayes-fail (+ hayes-fail 1))
+              (set!
+                hayes-failures
+                (concat
+                  hayes-failures
+                  (list
+                    (dict
+                      "kind"
+                      "fail"
+                      "expected"
+                      (str expected)
+                      "actual"
+                      (str hayes-actual))))))))))
+    (forth-def-prim! state "TESTING" (fn (s) nil))
+    ;; HEX/DECIMAL are real primitives now (runtime.sx) — no stub needed.
+    state))
+
+(define
+  hayes-boot
+  (fn () (let ((s (forth-boot))) (hayes-install! s) (hayes-reset!) s)))
+
+;; Run a single preprocessed chunk (string of Forth source) on the shared
+;; state. Catch any raised error and move on — the chunk boundary is a
+;; safe resume point.
+(define
+  hayes-bump-error-key!
+  (fn
+    (err)
+    (let
+      ((msg (str err)))
+      (let
+        ((space-idx (index-of msg " ")))
+        (let
+          ((key
+            (if
+              (> space-idx 0)
+              (substr msg 0 space-idx)
+              msg)))
+          (dict-set!
+            hayes-error-hist
+            key
+            (+ 1 (or (get hayes-error-hist key) 0))))))))
+
+(define
+  hayes-run-chunk
+  (fn
+    (state src)
+    (guard
+      (err
+        ((= 1 1)
+          (begin
+            (set! hayes-error (+ hayes-error 1))
+            (when
+              (= (len hayes-first-error) 0)
+              (set! hayes-first-error (str err)))
+            (hayes-bump-error-key! err)
+            (dict-set! state "dstack" (list))
+            (dict-set! state "rstack" (list))
+            (dict-set! state "compiling" false)
+            (dict-set! state "current-def" nil)
+            (dict-set! state "cstack" (list))
+            (dict-set! state "input" (list)))))
+      (forth-interpret state src))))
+
+(define
+  hayes-summary
+  (fn
+    ()
+    (dict
+      "pass"
+      hayes-pass
+      "fail"
+      hayes-fail
+      "error"
+      hayes-error
+      "total"
+      (+ (+ hayes-pass hayes-fail) hayes-error)
+      "first-error"
+      hayes-first-error
+      "error-hist"
+      hayes-error-hist)))

lib/forth/interpreter.sx

@@ -5,7 +5,39 @@
 
 (define
   forth-execute-word
-  (fn (state word) (let ((body (get word "body"))) (body state))))
+  (fn
+    (state word)
+    (dict-set! word "call-count" (+ 1 (or (get word "call-count") 0)))
+    (let ((body (get word "body"))) (body state))))
+
+(define
+  forth-hot-words
+  (fn
+    (state threshold)
+    (forth-hot-walk
+      (keys (get state "dict"))
+      (get state "dict")
+      threshold
+      (list))))
+
+(define
+  forth-hot-walk
+  (fn
+    (names dict threshold acc)
+    (if
+      (= (len names) 0)
+      acc
+      (let
+        ((n (first names)))
+        (let
+          ((w (get dict n)))
+          (let
+            ((c (or (get w "call-count") 0)))
+            (forth-hot-walk
+              (rest names)
+              dict
+              threshold
+              (if (>= c threshold) (cons (list n c) acc) acc))))))))
 
 (define
   forth-interpret-token
@@ -17,7 +49,7 @@
         (not (nil? w))
         (forth-execute-word state w)
         (let
-          ((n (forth-parse-number tok (get state "base"))))
+          ((n (forth-parse-number tok (get (get state "vars") "base"))))
           (if
             (not (nil? n))
             (forth-push state n)

lib/forth/scoreboard.json

@@ -0,0 +1,12 @@
+{
+  "source": "gerryjackson/forth2012-test-suite src/core.fr",
+  "generated_at": "2026-05-05T21:30:21Z",
+  "chunks_available": 638,
+  "chunks_fed": 638,
+  "total": 638,
+  "pass": 632,
+  "fail": 6,
+  "error": 0,
+  "percent": 99,
+  "note": "completed"
+}

lib/forth/scoreboard.md

@@ -0,0 +1,28 @@
+# Forth Hayes Core scoreboard
+
+| metric            | value |
+| ----------------- | ----: |
+| chunks available  | 638 |
+| chunks fed        | 638 |
+| total             | 638 |
+| pass              | 632 |
+| fail              | 6 |
+| error             | 0 |
+| percent           | 99% |
+
+- **Source**: `gerryjackson/forth2012-test-suite` `src/core.fr`
+- **Generated**: 2026-05-05T21:30:21Z
+- **Note**: completed
+
+A "chunk" is any preprocessed segment ending at a `}T` (every Hayes test
+is one chunk, plus the small declaration blocks between tests).
+The runner catches raised errors at chunk boundaries so one bad chunk
+does not abort the rest. `error` covers chunks that raised; `fail`
+covers tests whose `->` / `}T` comparison mismatched.
+
+### Chunk cap
+
+`conformance.sh` processes the first `$MAX_CHUNKS` chunks (default
+**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
+while iterating on primitives if a regression re-opens an infinite
+loop in later tests.

lib/forth/tests/test-phase3.sx

@@ -0,0 +1,239 @@
+;; Phase 3 — control flow (IF/ELSE/THEN, BEGIN/UNTIL/WHILE/REPEAT/AGAIN,
+;; DO/LOOP, return stack). Grows as each control construct lands.
+
+(define forth-p3-passed 0)
+(define forth-p3-failed 0)
+(define forth-p3-failures (list))
+
+(define
+  forth-p3-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p3-passed (+ forth-p3-passed 1))
+      (begin
+        (set! forth-p3-failed (+ forth-p3-failed 1))
+        (set!
+          forth-p3-failures
+          (concat
+            forth-p3-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p3-check-stack
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p3-assert label expected (nth r 2)))))
+
+(define
+  forth-p3-if-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "IF taken (-1)"
+      ": Q -1 IF 10 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF not taken (0)"
+      ": Q 0 IF 10 THEN ; Q"
+      (list))
+    (forth-p3-check-stack
+      "IF with non-zero truthy"
+      ": Q 42 IF 10 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF ELSE — true branch"
+      ": Q -1 IF 10 ELSE 20 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF ELSE — false branch"
+      ": Q 0 IF 10 ELSE 20 THEN ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "IF consumes flag"
+      ": Q IF 1 ELSE 2 THEN ; 0 Q"
+      (list 2))
+    (forth-p3-check-stack
+      "absolute value via IF"
+      ": ABS2 DUP 0 < IF NEGATE THEN ; -7 ABS2"
+      (list 7))
+    (forth-p3-check-stack
+      "abs leaves positive alone"
+      ": ABS2 DUP 0 < IF NEGATE THEN ; 7 ABS2"
+      (list 7))
+    (forth-p3-check-stack
+      "sign: negative"
+      ": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; -3 SIGN"
+      (list -1))
+    (forth-p3-check-stack
+      "sign: positive"
+      ": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; 3 SIGN"
+      (list 1))
+    (forth-p3-check-stack
+      "nested IF (both true)"
+      ": Q 1 IF 1 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "nested IF (inner false)"
+      ": Q 1 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "nested IF (outer false)"
+      ": Q 0 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 30))
+    (forth-p3-check-stack
+      "IF before other ops"
+      ": Q 1 IF 5 ELSE 6 THEN 2 * ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF in chained def"
+      ": POS? 0 > ;
+       : DOUBLE-IF-POS DUP POS? IF 2 * THEN ;
+       3 DOUBLE-IF-POS"
+      (list 6))
+    (forth-p3-check-stack
+      "empty then branch"
+      ": Q 1 IF THEN 99 ; Q"
+      (list 99))
+    (forth-p3-check-stack
+      "empty else branch"
+      ": Q 0 IF 99 ELSE THEN ; Q"
+      (list))
+    (forth-p3-check-stack
+      "sequential IF blocks"
+      ": Q -1 IF 1 THEN -1 IF 2 THEN ; Q"
+      (list 1 2))))
+
+(define
+  forth-p3-loop-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "BEGIN UNTIL (countdown to zero)"
+      ": CD BEGIN 1- DUP 0 = UNTIL ; 3 CD"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN UNTIL — single pass (UNTIL true immediately)"
+      ": Q BEGIN -1 UNTIL 42 ; Q"
+      (list 42))
+    (forth-p3-check-stack
+      "BEGIN UNTIL — accumulate sum 1+2+3"
+      ": SUM3 0 3 BEGIN TUCK + SWAP 1- DUP 0 = UNTIL DROP ; SUM3"
+      (list 6))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — triangular sum 5"
+      ": TRI 0 5 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 15))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — zero iterations"
+      ": TRI 0 0 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — one iteration"
+      ": TRI 0 1 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 1))
+    (forth-p3-check-stack
+      "nested BEGIN UNTIL"
+      ": INNER BEGIN 1- DUP 0 = UNTIL DROP ;
+       : OUTER BEGIN 3 INNER 1- DUP 0 = UNTIL ;
+       2 OUTER"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN UNTIL after colon prefix"
+      ": TEN 10 ;
+       : CD TEN BEGIN 1- DUP 0 = UNTIL ;
+       CD"
+      (list 0))
+    (forth-p3-check-stack
+      "WHILE inside IF branch"
+      ": Q 1 IF 0 3 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ELSE 99 THEN ; Q"
+      (list 6))))
+
+(define
+  forth-p3-do-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "DO LOOP — simple sum 0..4"
+      ": SUM 0 5 0 DO I + LOOP ; SUM"
+      (list 10))
+    (forth-p3-check-stack
+      "DO LOOP — 10..14 sum using I"
+      ": SUM 0 15 10 DO I + LOOP ; SUM"
+      (list 60))
+    (forth-p3-check-stack
+      "DO LOOP — limit = start runs one pass"
+      ": SUM 0 5 5 DO I + LOOP ; SUM"
+      (list 5))
+    (forth-p3-check-stack
+      "DO LOOP — count iterations"
+      ": COUNT 0 4 0 DO 1+ LOOP ; COUNT"
+      (list 4))
+    (forth-p3-check-stack
+      "DO LOOP — nested, I inner / J outer"
+      ": MATRIX 0 3 0 DO 3 0 DO I J + + LOOP LOOP ; MATRIX"
+      (list 18))
+    (forth-p3-check-stack
+      "DO LOOP — I used in arithmetic"
+      ": DBL 0 5 1 DO I 2 * + LOOP ; DBL"
+      (list 20))
+    (forth-p3-check-stack
+      "+LOOP — count by 2"
+      ": Q 0 10 0 DO I + 2 +LOOP ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "+LOOP — count by 3"
+      ": Q 0 10 0 DO I + 3 +LOOP ; Q"
+      (list 18))
+    (forth-p3-check-stack
+      "+LOOP — negative step"
+      ": Q 0 0 10 DO I + -1 +LOOP ; Q"
+      (list 55))
+    (forth-p3-check-stack
+      "LEAVE — early exit at I=3"
+      ": Q 0 10 0 DO I 3 = IF LEAVE THEN I + LOOP ; Q"
+      (list 3))
+    (forth-p3-check-stack
+      "LEAVE — in nested loop exits only inner"
+      ": Q 0 3 0 DO 5 0 DO I 2 = IF LEAVE THEN I + LOOP LOOP ; Q"
+      (list 3))
+    (forth-p3-check-stack
+      "DO LOOP preserves outer stack"
+      ": Q 99 5 0 DO I + LOOP ; Q"
+      (list 109))
+    (forth-p3-check-stack
+      ">R R>"
+      ": Q 7 >R 11 R> ; Q"
+      (list 11 7))
+    (forth-p3-check-stack
+      ">R R@ R>"
+      ": Q 7 >R R@ R> ; Q"
+      (list 7 7))
+    (forth-p3-check-stack
+      "2>R 2R>"
+      ": Q 1 2 2>R 99 2R> ; Q"
+      (list 99 1 2))
+    (forth-p3-check-stack
+      "2>R 2R@ 2R>"
+      ": Q 3 4 2>R 2R@ 2R> ; Q"
+      (list 3 4 3 4))))
+
+(define
+  forth-p3-run-all
+  (fn
+    ()
+    (set! forth-p3-passed 0)
+    (set! forth-p3-failed 0)
+    (set! forth-p3-failures (list))
+    (forth-p3-if-tests)
+    (forth-p3-loop-tests)
+    (forth-p3-do-tests)
+    (dict
+      "passed"
+      forth-p3-passed
+      "failed"
+      forth-p3-failed
+      "failures"
+      forth-p3-failures)))

lib/forth/tests/test-phase4.sx

@@ -0,0 +1,268 @@
+;; Phase 4 — strings + more Core.
+;; Uses the byte-memory model on state ("mem" dict + "here" cursor).
+
+(define forth-p4-passed 0)
+(define forth-p4-failed 0)
+(define forth-p4-failures (list))
+
+(define
+  forth-p4-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p4-passed (+ forth-p4-passed 1))
+      (begin
+        (set! forth-p4-failed (+ forth-p4-failed 1))
+        (set!
+          forth-p4-failures
+          (concat
+            forth-p4-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p4-check-output
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p4-assert label expected (nth r 1)))))
+
+(define
+  forth-p4-check-stack-size
+  (fn
+    (label src expected-n)
+    (let
+      ((r (forth-run src)))
+      (forth-p4-assert label expected-n (len (nth r 2))))))
+
+(define
+  forth-p4-check-top
+  (fn
+    (label src expected)
+    (let
+      ((r (forth-run src)))
+      (let
+        ((stk (nth r 2)))
+        (forth-p4-assert label expected (nth stk (- (len stk) 1)))))))
+
+(define
+  forth-p4-check-typed
+  (fn
+    (label src expected)
+    (forth-p4-check-output label (str src " TYPE") expected)))
+
+(define
+  forth-p4-string-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "S\" + TYPE — hello"
+      "S\" HELLO\""
+      "HELLO")
+    (forth-p4-check-typed
+      "S\" + TYPE — two words"
+      "S\" HELLO WORLD\""
+      "HELLO WORLD")
+    (forth-p4-check-typed
+      "S\" + TYPE — empty"
+      "S\" \""
+      "")
+    (forth-p4-check-typed
+      "S\" + TYPE — single char"
+      "S\" X\""
+      "X")
+    (forth-p4-check-stack-size
+      "S\" pushes (addr len)"
+      "S\" HI\""
+      2)
+    (forth-p4-check-top
+      "S\" length is correct"
+      "S\" HELLO\""
+      5)
+    (forth-p4-check-output
+      ".\" prints at interpret time"
+      ".\" HELLO\""
+      "HELLO")
+    (forth-p4-check-output
+      ".\" in colon def"
+      ": GREET .\" HI \" ; GREET GREET"
+      "HI HI ")))
+
+(define
+  forth-p4-count-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "C\" + COUNT + TYPE"
+      "C\" ABC\" COUNT"
+      "ABC")
+    (forth-p4-check-typed
+      "C\" then COUNT leaves right len"
+      "C\" HI THERE\" COUNT"
+      "HI THERE")))
+
+(define
+  forth-p4-fill-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "FILL overwrites prefix bytes"
+      "S\" ABCDE\" 2DUP DROP 3 65 FILL"
+      "AAADE")
+    (forth-p4-check-typed
+      "BLANK sets spaces"
+      "S\" XYZAB\" 2DUP DROP 3 BLANK"
+      "   AB")))
+
+(define
+  forth-p4-cmove-tests
+  (fn
+    ()
+    (forth-p4-check-output
+      "CMOVE copies HELLO forward"
+      ": MKH 72 0 C! 69 1 C! 76 2 C! 76 3 C! 79 4 C! ;
+       : T MKH 0 10 5 CMOVE 10 5 TYPE ; T"
+      "HELLO")
+    (forth-p4-check-output
+      "CMOVE> copies overlapping backward"
+      ": MKA 65 0 C! 66 1 C! 67 2 C! ;
+       : T MKA 0 1 2 CMOVE> 0 3 TYPE ; T"
+      "AAB")
+    (forth-p4-check-output
+      "MOVE picks direction for overlap"
+      ": MKA 65 0 C! 66 1 C! 67 2 C! ;
+       : T MKA 0 1 2 MOVE 0 3 TYPE ; T"
+      "AAB")))
+
+(define
+  forth-p4-charplus-tests
+  (fn
+    ()
+    (forth-p4-check-top
+      "CHAR+ increments"
+      "5 CHAR+"
+      6)))
+
+(define
+  forth-p4-char-tests
+  (fn
+    ()
+    (forth-p4-check-top "CHAR A -> 65" "CHAR A" 65)
+    (forth-p4-check-top "CHAR x -> 120" "CHAR x" 120)
+    (forth-p4-check-top "CHAR takes only first char" "CHAR HELLO" 72)
+    (forth-p4-check-top
+      "[CHAR] compiles literal"
+      ": AA [CHAR] A ; AA"
+      65)
+    (forth-p4-check-top
+      "[CHAR] reads past IMMEDIATE"
+      ": ZZ [CHAR] Z ; ZZ"
+      90)
+    (forth-p4-check-stack-size
+      "[CHAR] doesn't leak at compile time"
+      ": FOO [CHAR] A ; "
+      0)))
+
+(define
+  forth-p4-key-accept-tests
+  (fn
+    ()
+    (let
+      ((r (forth-run "1000 2 ACCEPT")))
+      (let ((stk (nth r 2))) (forth-p4-assert "ACCEPT empty buf -> 0" (list 0) stk)))))
+
+(define
+  forth-p4-shift-tests
+  (fn
+    ()
+    (forth-p4-check-top "1 0 LSHIFT" "1 0 LSHIFT" 1)
+    (forth-p4-check-top "1 1 LSHIFT" "1 1 LSHIFT" 2)
+    (forth-p4-check-top "1 2 LSHIFT" "1 2 LSHIFT" 4)
+    (forth-p4-check-top "1 15 LSHIFT" "1 15 LSHIFT" 32768)
+    (forth-p4-check-top "1 31 LSHIFT" "1 31 LSHIFT" -2147483648)
+    (forth-p4-check-top "1 0 RSHIFT" "1 0 RSHIFT" 1)
+    (forth-p4-check-top "1 1 RSHIFT" "1 1 RSHIFT" 0)
+    (forth-p4-check-top "2 1 RSHIFT" "2 1 RSHIFT" 1)
+    (forth-p4-check-top "4 2 RSHIFT" "4 2 RSHIFT" 1)
+    (forth-p4-check-top "-1 1 RSHIFT (logical, not arithmetic)" "-1 1 RSHIFT" 2147483647)
+    (forth-p4-check-top "MSB via 1S 1 RSHIFT INVERT" "0 INVERT 1 RSHIFT INVERT" -2147483648)))
+
+(define
+  forth-p4-sp-tests
+  (fn
+    ()
+    (forth-p4-check-top "SP@ returns depth (0)" "SP@" 0)
+    (forth-p4-check-top
+      "SP@ after pushes"
+      "1 2 3 SP@ SWAP DROP SWAP DROP SWAP DROP"
+      3)
+    (forth-p4-check-stack-size
+      "SP! truncates"
+      "1 2 3 4 5 2 SP!"
+      2)
+    (forth-p4-check-top
+      "SP! leaves base items intact"
+      "1 2 3 4 5 2 SP!"
+      2)))
+
+(define
+  forth-p4-base-tests
+  (fn
+    ()
+    (forth-p4-check-top
+      "BASE default is 10"
+      "BASE @"
+      10)
+    (forth-p4-check-top
+      "HEX switches base to 16"
+      "HEX BASE @"
+      16)
+    (forth-p4-check-top
+      "DECIMAL resets to 10"
+      "HEX DECIMAL BASE @"
+      10)
+    (forth-p4-check-top
+      "HEX parses 10 as 16"
+      "HEX 10"
+      16)
+    (forth-p4-check-top
+      "HEX parses FF as 255"
+      "HEX FF"
+      255)
+    (forth-p4-check-top
+      "DECIMAL parses 10 as 10"
+      "HEX DECIMAL 10"
+      10)
+    (forth-p4-check-top
+      "OCTAL parses 17 as 15"
+      "OCTAL 17"
+      15)
+    (forth-p4-check-top
+      "BASE @ ; 16 BASE ! ; BASE @"
+      "BASE @ 16 BASE ! BASE @ SWAP DROP"
+      16)))
+
+(define
+  forth-p4-run-all
+  (fn
+    ()
+    (set! forth-p4-passed 0)
+    (set! forth-p4-failed 0)
+    (set! forth-p4-failures (list))
+    (forth-p4-string-tests)
+    (forth-p4-count-tests)
+    (forth-p4-fill-tests)
+    (forth-p4-cmove-tests)
+    (forth-p4-charplus-tests)
+    (forth-p4-char-tests)
+    (forth-p4-key-accept-tests)
+    (forth-p4-base-tests)
+    (forth-p4-shift-tests)
+    (forth-p4-sp-tests)
+    (dict
+      "passed"
+      forth-p4-passed
+      "failed"
+      forth-p4-failed
+      "failures"
+      forth-p4-failures)))

lib/forth/tests/test-phase5.sx

@@ -0,0 +1,333 @@
+;; Phase 5 — Core Extension + memory primitives.
+
+(define forth-p5-passed 0)
+(define forth-p5-failed 0)
+(define forth-p5-failures (list))
+
+(define
+  forth-p5-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p5-passed (+ forth-p5-passed 1))
+      (begin
+        (set! forth-p5-failed (+ forth-p5-failed 1))
+        (set!
+          forth-p5-failures
+          (concat
+            forth-p5-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p5-check-stack
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p5-assert label expected (nth r 2)))))
+
+(define
+  forth-p5-check-top
+  (fn
+    (label src expected)
+    (let
+      ((r (forth-run src)))
+      (let
+        ((stk (nth r 2)))
+        (forth-p5-assert label expected (nth stk (- (len stk) 1)))))))
+
+(define
+  forth-p5-create-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "CREATE pushes HERE-at-creation"
+      "HERE CREATE FOO FOO ="
+      -1)
+    (forth-p5-check-top
+      "CREATE + ALLOT advances HERE"
+      "HERE 5 ALLOT HERE SWAP -"
+      5)
+    (forth-p5-check-top
+      "CREATE + , stores cell"
+      "CREATE FOO 42 , FOO @"
+      42)
+    (forth-p5-check-stack
+      "CREATE multiple ,"
+      "CREATE TBL 1 , 2 , 3 , TBL @ TBL CELL+ @ TBL CELL+ CELL+ @"
+      (list 1 2 3))
+    (forth-p5-check-top
+      "C, stores byte"
+      "CREATE B 65 C, 66 C, B C@"
+      65)))
+
+(define
+  forth-p5-unsigned-tests
+  (fn
+    ()
+    (forth-p5-check-top "1 2 U<" "1 2 U<" -1)
+    (forth-p5-check-top "2 1 U<" "2 1 U<" 0)
+    (forth-p5-check-top "0 1 U<" "0 1 U<" -1)
+    (forth-p5-check-top "-1 1 U< (since -1 unsigned is huge)" "-1 1 U<" 0)
+    (forth-p5-check-top "1 -1 U<" "1 -1 U<" -1)
+    (forth-p5-check-top "1 2 U>" "1 2 U>" 0)
+    (forth-p5-check-top "-1 1 U>" "-1 1 U>" -1)))
+
+(define
+  forth-p5-2bang-tests
+  (fn
+    ()
+    (forth-p5-check-stack
+      "2! / 2@"
+      "CREATE X 0 , 0 , 11 22 X 2! X 2@"
+      (list 11 22))))
+
+(define
+  forth-p5-mixed-tests
+  (fn
+    ()
+    (forth-p5-check-stack "S>D positive" "5 S>D" (list 5 0))
+    (forth-p5-check-stack "S>D negative" "-5 S>D" (list -5 -1))
+    (forth-p5-check-stack "S>D zero" "0 S>D" (list 0 0))
+    (forth-p5-check-top "D>S keeps low" "5 0 D>S" 5)
+    (forth-p5-check-stack "M* small positive" "3 4 M*" (list 12 0))
+    (forth-p5-check-stack "M* negative" "-3 4 M*" (list -12 -1))
+    (forth-p5-check-stack
+      "M* negative * negative"
+      "-3 -4 M*"
+      (list 12 0))
+    (forth-p5-check-stack "UM* small" "3 4 UM*" (list 12 0))
+    (forth-p5-check-stack
+      "UM/MOD: 100 0 / 5"
+      "100 0 5 UM/MOD"
+      (list 0 20))
+    (forth-p5-check-stack
+      "FM/MOD: -7 / 2 floored"
+      "-7 -1 2 FM/MOD"
+      (list 1 -4))
+    (forth-p5-check-stack
+      "SM/REM: -7 / 2 truncated"
+      "-7 -1 2 SM/REM"
+      (list -1 -3))
+    (forth-p5-check-top "*/ truncated" "7 11 13 */" 5)
+    (forth-p5-check-stack "*/MOD" "7 11 13 */MOD" (list 12 5))))
+
+(define
+  forth-p5-double-tests
+  (fn
+    ()
+    (forth-p5-check-stack "D+ small" "5 0 7 0 D+" (list 12 0))
+    (forth-p5-check-stack "D+ negative" "-5 -1 -3 -1 D+" (list -8 -1))
+    (forth-p5-check-stack "D- small" "10 0 3 0 D-" (list 7 0))
+    (forth-p5-check-stack "DNEGATE positive" "5 0 DNEGATE" (list -5 -1))
+    (forth-p5-check-stack "DNEGATE negative" "-5 -1 DNEGATE" (list 5 0))
+    (forth-p5-check-stack "DABS negative" "-7 -1 DABS" (list 7 0))
+    (forth-p5-check-stack "DABS positive" "7 0 DABS" (list 7 0))
+    (forth-p5-check-top "D= equal" "5 0 5 0 D=" -1)
+    (forth-p5-check-top "D= unequal lo" "5 0 7 0 D=" 0)
+    (forth-p5-check-top "D= unequal hi" "5 0 5 1 D=" 0)
+    (forth-p5-check-top "D< lt" "5 0 7 0 D<" -1)
+    (forth-p5-check-top "D< gt" "7 0 5 0 D<" 0)
+    (forth-p5-check-top "D0= zero" "0 0 D0=" -1)
+    (forth-p5-check-top "D0= nonzero" "5 0 D0=" 0)
+    (forth-p5-check-top "D0< neg" "-5 -1 D0<" -1)
+    (forth-p5-check-top "D0< pos" "5 0 D0<" 0)
+    (forth-p5-check-stack "DMAX" "5 0 7 0 DMAX" (list 7 0))
+    (forth-p5-check-stack "DMIN" "5 0 7 0 DMIN" (list 5 0))))
+
+(define
+  forth-p5-format-tests
+  (fn
+    ()
+    (forth-p4-check-output-passthrough
+      "U. prints with trailing space"
+      "123 U."
+      "123 ")
+    (forth-p4-check-output-passthrough
+      "<# #S #> TYPE — decimal"
+      "123 0 <# #S #> TYPE"
+      "123")
+    (forth-p4-check-output-passthrough
+      "<# #S #> TYPE — hex"
+      "255 HEX 0 <# #S #> TYPE"
+      "FF")
+    (forth-p4-check-output-passthrough
+      "<# # # #> partial"
+      "1234 0 <# # # #> TYPE"
+      "34")
+    (forth-p4-check-output-passthrough
+      "SIGN holds minus"
+      "<# -1 SIGN -1 SIGN 0 0 #> TYPE"
+      "--")
+    (forth-p4-check-output-passthrough
+      ".R right-justifies"
+      "42 5 .R"
+      "   42")
+    (forth-p4-check-output-passthrough
+      ".R negative"
+      "-42 5 .R"
+      "  -42")
+    (forth-p4-check-output-passthrough
+      "U.R"
+      "42 5 U.R"
+      "   42")
+    (forth-p4-check-output-passthrough
+      "HOLD char"
+      "<# 0 0 65 HOLD #> TYPE"
+      "A")))
+
+(define
+  forth-p5-dict-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "EXECUTE via tick"
+      ": INC 1+ ; 9 ' INC EXECUTE"
+      10)
+    (forth-p5-check-top
+      "['] inside def"
+      ": DUB 2* ; : APPLY ['] DUB EXECUTE ; 5 APPLY"
+      10)
+    (forth-p5-check-top
+      ">BODY of CREATE word"
+      "CREATE C 99 , ' C >BODY @"
+      99)
+    (forth-p5-check-stack
+      "WORD parses next token to counted-string"
+      ": A 5 ; BL WORD A COUNT TYPE"
+      (list))
+    (forth-p5-check-top
+      "FIND on known word -> non-zero"
+      ": A 5 ; BL WORD A FIND SWAP DROP"
+      -1)))
+
+(define
+  forth-p5-state-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "STATE @ in interpret mode"
+      "STATE @"
+      0)
+    (forth-p5-check-top
+      "STATE @ via IMMEDIATE inside compile"
+      ": GT8 STATE @ ; IMMEDIATE : T GT8 LITERAL ; T"
+      -1)
+    (forth-p5-check-top
+      "[ ] LITERAL captures"
+      ": SEVEN [ 7 ] LITERAL ; SEVEN"
+      7)
+    (forth-p5-check-top
+      "EVALUATE in interpret mode"
+      "S\" 5 7 +\" EVALUATE"
+      12)
+    (forth-p5-check-top
+      "EVALUATE inside def"
+      ": A 100 ; : B S\" A\" EVALUATE ; B"
+      100)))
+
+(define
+  forth-p5-misc-tests
+  (fn
+    ()
+    (forth-p5-check-top "WITHIN inclusive lower" "3 2 10 WITHIN" -1)
+    (forth-p5-check-top "WITHIN exclusive upper" "10 2 10 WITHIN" 0)
+    (forth-p5-check-top "WITHIN below range" "1 2 10 WITHIN" 0)
+    (forth-p5-check-top "WITHIN at lower" "2 2 10 WITHIN" -1)
+    (forth-p5-check-top
+      "EXIT leaves colon-def early"
+      ": F 5 EXIT 99 ; F"
+      5)
+    (forth-p5-check-stack
+      "EXIT in IF branch"
+      ": F 5 0 IF DROP 99 EXIT THEN ; F"
+      (list 5))
+    (forth-p5-check-top
+      "UNLOOP + EXIT in DO"
+      ": SUM 0 10 0 DO I 5 = IF I UNLOOP EXIT THEN LOOP ; SUM"
+      5)))
+
+(define
+  forth-p5-fa-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "R/O R/W W/O constants"
+      "R/O R/W W/O + +"
+      3)
+    (forth-p5-check-top
+      "CREATE-FILE returns ior=0"
+      "CREATE PAD 50 ALLOT PAD S\" /tmp/test.fxf\" ROT SWAP CMOVE S\" /tmp/test.fxf\" R/W CREATE-FILE SWAP DROP"
+      0)
+    (forth-p5-check-top
+      "WRITE-FILE then CLOSE"
+      "S\" /tmp/t2.fxf\" R/W CREATE-FILE DROP >R S\" HI\" R@ WRITE-FILE R> CLOSE-FILE +"
+      0)
+    (forth-p5-check-top
+      "OPEN-FILE on unknown path returns ior!=0"
+      "S\" /tmp/nope.fxf\" R/O OPEN-FILE SWAP DROP 0 ="
+      0)))
+
+(define
+  forth-p5-string-tests
+  (fn
+    ()
+    (forth-p5-check-top "COMPARE equal" "S\" ABC\" S\" ABC\" COMPARE" 0)
+    (forth-p5-check-top "COMPARE less" "S\" ABC\" S\" ABD\" COMPARE" -1)
+    (forth-p5-check-top "COMPARE greater" "S\" ABD\" S\" ABC\" COMPARE" 1)
+    (forth-p5-check-top
+      "COMPARE prefix less"
+      "S\" AB\" S\" ABC\" COMPARE"
+      -1)
+    (forth-p5-check-top
+      "COMPARE prefix greater"
+      "S\" ABC\" S\" AB\" COMPARE"
+      1)
+    (forth-p5-check-top
+      "SEARCH found flag"
+      "S\" HELLO WORLD\" S\" WORLD\" SEARCH"
+      -1)
+    (forth-p5-check-top
+      "SEARCH not found flag"
+      "S\" HELLO\" S\" XYZ\" SEARCH"
+      0)
+    (forth-p5-check-top
+      "SEARCH empty needle flag"
+      "S\" HELLO\" S\" \" SEARCH"
+      -1)
+    (forth-p5-check-top
+      "SLITERAL via [ S\" ... \" ]"
+      ": A [ S\" HI\" ] SLITERAL ; A SWAP DROP"
+      2)))
+
+(define
+  forth-p4-check-output-passthrough
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p5-assert label expected (nth r 1)))))
+
+(define
+  forth-p5-run-all
+  (fn
+    ()
+    (set! forth-p5-passed 0)
+    (set! forth-p5-failed 0)
+    (set! forth-p5-failures (list))
+    (forth-p5-create-tests)
+    (forth-p5-unsigned-tests)
+    (forth-p5-2bang-tests)
+    (forth-p5-mixed-tests)
+    (forth-p5-double-tests)
+    (forth-p5-format-tests)
+    (forth-p5-dict-tests)
+    (forth-p5-state-tests)
+    (forth-p5-misc-tests)
+    (forth-p5-fa-tests)
+    (forth-p5-string-tests)
+    (dict
+      "passed"
+      forth-p5-passed
+      "failed"
+      forth-p5-failed
+      "failures"
+      forth-p5-failures)))

lib/haskell/conformance.sh

@@ -1,140 +0,0 @@
-#!/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

@@ -1,249 +0,0 @@
-;; 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

@@ -1,658 +0,0 @@
-;; 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

@@ -1,329 +0,0 @@
-;; 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

@@ -1,201 +0,0 @@
-;; 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,130 +1,507 @@
-;; Haskell runtime: constructor registry.
+;; lib/haskell/runtime.sx — Haskell-on-SX runtime layer
 ;;
-;; 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.
+;; 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
 
-(define hk-constructors (dict))
+;; ===========================================================================
+;; 1. Numeric type class helpers
+;; ===========================================================================
 
+(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-register-con!
-  (fn
-    (cname arity type-name)
-    (dict-set!
-      hk-constructors
-      cname
-      {:arity arity :type type-name})))
-
-(define hk-is-con? (fn (name) (has-key? hk-constructors name)))
-
-(define
-  hk-con-arity
-  (fn
-    (name)
-    (if
-      (has-key? hk-constructors name)
-      (get (get hk-constructors name) "arity")
-      nil)))
-
-(define
-  hk-con-type
-  (fn
-    (name)
-    (if
-      (has-key? hk-constructors name)
-      (get (get hk-constructors name) "type")
-      nil)))
-
-(define hk-con-names (fn () (keys hk-constructors)))
-
-;; ── Registration from AST ────────────────────────────────────
-;; (:data NAME TVARS ((:con-def CNAME FIELDS) …))
-(define
-  hk-register-data!
-  (fn
-    (data-node)
+  (hk-div a b)
   (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))))
+    ((q (quotient a b)) (r (remainder a b)))
+    (if
+      (and
+        (not (= r 0))
+        (or
+          (and (< a 0) (> b 0))
+          (and (> a 0) (< b 0))))
+      (- q 1)
+      q)))
 
-;; (:newtype NAME TVARS CNAME FIELD)
-(define
-  hk-register-newtype!
-  (fn
-    (nt-node)
-    (hk-register-con!
-      (nth nt-node 3)
-      1
-      (nth nt-node 1))))
+;; Haskell mod: result has same sign as divisor
+(define hk-mod modulo)
 
-;; Walk a decls list, registering every `data` / `newtype` decl.
+;; 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-register-decls!
-  (fn
-    (decls)
-    (for-each
-      (fn
-        (d)
+  (hk-signum x)
   (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)))
+    ((> 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)
+;; ===========================================================================
 
 (define
-  hk-register-program!
-  (fn
-    (ast)
+  (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})))
+
+(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)))
     (cond
-      ((nil? ast) nil)
-      ((not (list? ast)) nil)
-      ((empty? ast) nil)
-      ((= (first ast) "program")
-        (hk-register-decls! (nth ast 1)))
-      ((= (first ast) "module")
-        (hk-register-decls! (nth ast 4)))
-      (:else nil))))
+      ((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))))))
 
-;; Convenience: source → AST → desugar → register.
+;; intToDigit: 0-15 → char
 (define
-  hk-load-source!
-  (fn (src) (hk-register-program! (hk-core src))))
+  (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)))))
 
-;; ── 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")
+;; ===========================================================================
+;; 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))))

lib/haskell/scoreboard.json

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-# 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 | awk 'NR==1{print $1}')
+  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
   if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
     SX_SERVER="$MAIN_ROOT/$SX_SERVER"
   else
@@ -42,35 +42,25 @@ 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 360 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
+  OUTPUT=$(timeout 60 "$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]+\)\)' || true; } | tail -1 \
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
             | sed -E 's/^\(ok 3 //; s/\)$//')
   fi
   if [ -z "$LINE" ]; then
@@ -92,20 +82,13 @@ EPOCHS
     cat > "$TMPFILE2" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
-(load "lib/haskell/layout.sx")
-(load "lib/haskell/parser.sx")
-(load "lib/haskell/desugar.sx")
 (load "lib/haskell/runtime.sx")
-(load "lib/haskell/match.sx")
-(load "lib/haskell/eval.sx")
-$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 360 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok 3 ' || true)
+    FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok 3 ' || true)
     rm -f "$TMPFILE2"
     echo "    $FAILS"
   elif [ "$VERBOSE" = "1" ]; then

lib/haskell/testlib.sx

@@ -1,58 +0,0 @@
-;; 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

@@ -1,60 +0,0 @@
-;; 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

@@ -1,84 +0,0 @@
-;; 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

@@ -1,305 +0,0 @@
-;; 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

@@ -1,117 +0,0 @@
-;; 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

@@ -1,278 +0,0 @@
-;; 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

@@ -1,181 +0,0 @@
-;; 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

@@ -1,137 +0,0 @@
-;; 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

@@ -1,85 +0,0 @@
-;; 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

@@ -1,245 +0,0 @@
-;; 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

@@ -1,256 +0,0 @@
-;; 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,8 +3,60 @@
 ;; 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.
-;; The hk-test / hk-deep=? helpers live in lib/haskell/testlib.sx
-;; and are preloaded by lib/haskell/test.sh.
+
+(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})))))
 
 ;; 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

@@ -1,278 +0,0 @@
-;; 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

@@ -1,273 +0,0 @@
-;; 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

@@ -1,258 +0,0 @@
-;; 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

@@ -1,261 +0,0 @@
-;; 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

@@ -1,202 +0,0 @@
-;; 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

@@ -1,234 +0,0 @@
-;; 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

@@ -1,191 +0,0 @@
-;; 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

@@ -1,234 +0,0 @@
-;; 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

@@ -1,70 +0,0 @@
-;; 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

@@ -1,83 +0,0 @@
-;; 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

@@ -1,55 +0,0 @@
-;; 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

@@ -1,83 +0,0 @@
-;; 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

@@ -1,83 +0,0 @@
-;; 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

@@ -1,45 +0,0 @@
-;; 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

@@ -1,84 +0,0 @@
-;; 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

@@ -1,49 +0,0 @@
-;; 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

@@ -1,84 +0,0 @@
-;; 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

@@ -1,83 +0,0 @@
-;; 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

@@ -1,38 +0,0 @@
-;; 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

@@ -1,86 +0,0 @@
-;; 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

@@ -1,78 +0,0 @@
-;; 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

@@ -1,83 +0,0 @@
-;; 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

@@ -1,65 +0,0 @@
-;; 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

@@ -1,83 +0,0 @@
-;; 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

@@ -1,48 +0,0 @@
-;; 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

@@ -1,74 +0,0 @@
-;; 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

@@ -1,74 +0,0 @@
-;; 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

@@ -1,40 +0,0 @@
--- 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

@@ -1,15 +0,0 @@
--- 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

@@ -1,18 +0,0 @@
--- 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

@@ -1,12 +0,0 @@
--- 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]