HS: scoreboard — E38 sourceInfo +2, E39 correction

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

hosts/javascript/run_tests.js

@@ -293,8 +293,6 @@ env["pop-suite"] = function() {
   return null;
 };
 
-env["test-allowed?"] = function(name) { return true; };
-
 // Load test framework
 const projectDir = path.join(__dirname, "..", "..");
 const specTests = path.join(projectDir, "spec", "tests");
@@ -343,20 +341,6 @@ if (fs.existsSync(swapPath)) {
   }
 }
 
-// Load spec library files (define-library modules imported by tests)
-for (const libFile of ["stdlib.sx", "signals.sx", "coroutines.sx"]) {
-  const libPath = path.join(projectDir, "spec", libFile);
-  if (fs.existsSync(libPath)) {
-    const libSrc = fs.readFileSync(libPath, "utf8");
-    const libExprs = Sx.parse(libSrc);
-    for (const expr of libExprs) {
-      try { Sx.eval(expr, env); } catch (e) {
-        console.error(`Error loading spec/${libFile}: ${e.message}`);
-      }
-    }
-  }
-}
-
 // Load tw system (needed by spec/tests/test-tw.sx)
 const twDir = path.join(projectDir, "shared", "sx", "templates");
 for (const twFile of ["tw-type.sx", "tw-layout.sx", "tw.sx"]) {

hosts/ocaml/bin/mcp_tree.ml

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

hosts/ocaml/bin/run_tests.ml

@@ -37,10 +37,7 @@ 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
   | Symbol a, Symbol b -> a = b
   | Keyword a, Keyword b -> a = b
@@ -229,7 +226,7 @@ let make_test_env () =
     | [String s] ->
       let parsed = Sx_parser.parse_all s in
       (match parsed with
-       | [List (Symbol "sxbc" :: (Number _ | Integer _) :: payload :: _)] -> payload
+       | [List (Symbol "sxbc" :: Number _ :: payload :: _)] -> payload
        | _ -> raise (Eval_error "bytecode-deserialize: invalid sxbc format"))
     | _ -> raise (Eval_error "bytecode-deserialize: expected string"));
 
@@ -243,7 +240,7 @@ let make_test_env () =
     | [String s] ->
       let parsed = Sx_parser.parse_all s in
       (match parsed with
-       | [List (Symbol "cek-state" :: (Number _ | Integer _) :: payload :: _)] -> payload
+       | [List (Symbol "cek-state" :: Number _ :: payload :: _)] -> payload
        | _ -> raise (Eval_error "cek-deserialize: invalid cek-state format"))
     | _ -> raise (Eval_error "cek-deserialize: expected string"));
 
@@ -323,10 +320,7 @@ let make_test_env () =
   bind "identical?" (fun args ->
     match args with
     | [a; b] -> Bool (match a, b with
-      | Integer x, Integer y -> x = y
       | Number x, Number y -> x = y
-      | Integer x, Number y -> float_of_int x = y
-      | Number x, Integer y -> x = float_of_int y
       | String x, String y -> x = y
       | Bool x, Bool y -> x = y
       | Nil, Nil -> true
@@ -372,15 +366,11 @@ let make_test_env () =
 
   bind "append!" (fun args ->
     match args with
-    | [ListRef r; v; (Number n)] when int_of_float n = 0 ->
+    | [ListRef r; v; Number n] when int_of_float n = 0 ->
       r := v :: !r; ListRef r  (* prepend *)
-    | [ListRef r; v; (Integer 0)] ->
-      r := v :: !r; ListRef r  (* prepend Integer index *)
     | [ListRef r; v] -> r := !r @ [v]; ListRef r  (* append in place *)
-    | [List items; v; (Number n)] when int_of_float n = 0 ->
+    | [List items; v; Number n] when int_of_float n = 0 ->
       List (v :: items)  (* immutable prepend *)
-    | [List items; v; (Integer 0)] ->
-      List (v :: items)  (* immutable prepend Integer index *)
     | [List items; v] -> List (items @ [v])  (* immutable fallback *)
     | _ -> raise (Eval_error "append!: expected list and value"));
 
@@ -556,10 +546,7 @@ let make_test_env () =
   bind "batch-begin!" (fun _args -> Sx_ref.batch_begin_b ());
   bind "batch-end!" (fun _args -> Sx_ref.batch_end_b ());
   bind "now-ms" (fun _args -> Number 1000.0);
-  bind "random-int" (fun args -> match args with
-    | [Number lo; _] -> Number lo
-    | [Integer lo; _] -> Integer lo
-    | _ -> Integer 0);
+  bind "random-int" (fun args -> match args with [Number lo; _] -> Number lo | _ -> Number 0.0);
   bind "try-rerender-page" (fun _args -> Nil);
   bind "collect!" (fun args ->
     match args with
@@ -1120,47 +1107,6 @@ let make_test_env () =
     | _ :: _ -> String "confirmed"
     | _ -> Nil);
 
-  bind "values" (fun args ->
-    match args with
-    | [v] -> v
-    | vs ->
-      let d = Hashtbl.create 2 in
-      Hashtbl.replace d "_values" (Bool true);
-      Hashtbl.replace d "_list" (List vs);
-      Dict d);
-
-  bind "call-with-values" (fun args ->
-    match args with
-    | [producer; consumer] ->
-      let result = Sx_ref.cek_call producer (List []) in
-      let spread = (match result with
-        | Dict d when (match Hashtbl.find_opt d "_values" with Some (Bool true) -> true | _ -> false) ->
-          (match Hashtbl.find_opt d "_list" with Some (List l) -> l | _ -> [result])
-        | _ -> [result])
-      in
-      Sx_ref.cek_call consumer (List spread)
-    | _ -> raise (Eval_error "call-with-values: expected 2 args"));
-
-  bind "promise?" (fun args ->
-    match args with
-    | [v] -> Bool (Sx_ref.is_promise v)
-    | _ -> Bool false);
-
-  bind "make-promise" (fun args ->
-    match args with
-    | [v] ->
-      let d = Hashtbl.create 4 in
-      Hashtbl.replace d "_promise" (Bool true);
-      Hashtbl.replace d "forced" (Bool true);
-      Hashtbl.replace d "value" v;
-      Dict d
-    | _ -> Nil);
-
-  bind "force" (fun args ->
-    match args with
-    | [p] -> Sx_ref.force_promise p
-    | _ -> Nil);
-
   env
 
 (* ====================================================================== *)
@@ -1196,20 +1142,18 @@ let run_foundation_tests () =
   in
 
   Printf.printf "Suite: parser\n";
-  assert_eq "number" (Integer 42) (List.hd (parse_all "42"));
+  assert_eq "number" (Number 42.0) (List.hd (parse_all "42"));
   assert_eq "string" (String "hello") (List.hd (parse_all "\"hello\""));
   assert_eq "bool true" (Bool true) (List.hd (parse_all "true"));
   assert_eq "nil" Nil (List.hd (parse_all "nil"));
   assert_eq "keyword" (Keyword "class") (List.hd (parse_all ":class"));
   assert_eq "symbol" (Symbol "foo") (List.hd (parse_all "foo"));
-  assert_eq "list" (List [Symbol "+"; Integer 1; Integer 2]) (List.hd (parse_all "(+ 1 2)"));
+  assert_eq "list" (List [Symbol "+"; Number 1.0; Number 2.0]) (List.hd (parse_all "(+ 1 2)"));
   (match List.hd (parse_all "(div :class \"card\" (p \"hi\"))") with
    | List [Symbol "div"; Keyword "class"; String "card"; List [Symbol "p"; String "hi"]] ->
      incr pass_count; Printf.printf "  PASS: nested list\n"
    | v -> incr fail_count; Printf.printf "  FAIL: nested list — got %s\n" (Sx_types.inspect v));
   (match List.hd (parse_all "'(1 2 3)") with
-   | List [Symbol "quote"; List [Integer 1; Integer 2; Integer 3]] ->
-     incr pass_count; Printf.printf "  PASS: quote sugar\n"
    | List [Symbol "quote"; List [Number 1.0; Number 2.0; Number 3.0]] ->
      incr pass_count; Printf.printf "  PASS: quote sugar\n"
    | v -> incr fail_count; Printf.printf "  FAIL: quote sugar — got %s\n" (Sx_types.inspect v));
@@ -1217,7 +1161,7 @@ let run_foundation_tests () =
    | Dict d when dict_has d "a" && dict_has d "b" ->
      incr pass_count; Printf.printf "  PASS: dict literal\n"
    | v -> incr fail_count; Printf.printf "  FAIL: dict literal — got %s\n" (Sx_types.inspect v));
-  assert_eq "comment" (Integer 42) (List.hd (parse_all ";; comment\n42"));
+  assert_eq "comment" (Number 42.0) (List.hd (parse_all ";; comment\n42"));
   assert_eq "string escape" (String "hello\nworld") (List.hd (parse_all "\"hello\\nworld\""));
   assert_eq "multiple exprs" (Number 2.0) (Number (float_of_int (List.length (parse_all "(1 2 3) (4 5)"))));
 
@@ -2034,10 +1978,6 @@ let run_spec_tests env test_files =
       (match Hashtbl.find_opt d "children" with
        | Some (List l) when i >= 0 && i < List.length l -> List.nth l i
        | _ -> (match Hashtbl.find_opt d (string_of_int i) with Some v -> v | None -> Nil))
-    | [Dict d; Integer n] ->
-      (match Hashtbl.find_opt d "children" with
-       | Some (List l) when n >= 0 && n < List.length l -> List.nth l n
-       | _ -> (match Hashtbl.find_opt d (string_of_int n) with Some v -> v | None -> Nil))
     | _ -> Nil);
 
   (* Stringify a value for DOM string properties *)
@@ -2112,8 +2052,8 @@ let run_spec_tests env test_files =
          Hashtbl.replace d "childNodes" (List [])
        | _ -> ());
       stored
-    | [ListRef r; idx_v; value] when (match idx_v with Number _ | Integer _ -> true | _ -> false) ->
-      let idx = match idx_v with Number n -> int_of_float n | Integer n -> n | _ -> 0 in
+    | [ListRef r; Number n; value] ->
+      let idx = int_of_float n in
       let lst = !r in
       if idx >= 0 && idx < List.length lst then
         r := List.mapi (fun i v -> if i = idx then value else v) lst
@@ -2250,7 +2190,7 @@ let run_spec_tests env test_files =
             | [String name; value] ->
               let attrs = match Hashtbl.find_opt d "attributes" with Some (Dict a) -> a | _ ->
                 let a = Hashtbl.create 4 in Hashtbl.replace d "attributes" (Dict a); a in
-              let sv = match value with String s -> s | Integer n -> string_of_int n | Number n ->
+              let sv = match value with String s -> s | Number n ->
                 let i = int_of_float n in if float_of_int i = n then string_of_int i
                 else string_of_float n | _ -> Sx_types.inspect value in
               Hashtbl.replace attrs name (String sv);
@@ -2692,7 +2632,6 @@ let run_spec_tests env test_files =
   let rec json_of_value = function
     | Nil -> `Null
     | Bool b -> `Bool b
-    | Integer n -> `Int n
     | Number n ->
       if Float.is_integer n && Float.abs n < 1e16
       then `Int (int_of_float n) else `Float n
@@ -2708,8 +2647,8 @@ let run_spec_tests env test_files =
   let rec value_of_json = function
     | `Null -> Nil
     | `Bool b -> Bool b
-    | `Int i -> Integer i
-    | `Intlit s -> (try Integer (int_of_string s) with _ -> try Number (float_of_string s) with _ -> String s)
+    | `Int i -> Number (float_of_int i)
+    | `Intlit s -> (try Number (float_of_string s) with _ -> String s)
     | `Float f -> Number f
     | `String s -> String s
     | `List xs -> List (List.map value_of_json xs)
@@ -2872,7 +2811,6 @@ let run_spec_tests env test_files =
       match sx_vm_execute with
       | Some fn -> Sx_ref.cek_call fn (List args)
       | None -> Nil)));
-  load_module "stdlib.sx" spec_dir;   (* pure SX stdlib: format etc. *)
   load_module "signals.sx" spec_dir;  (* core reactive primitives *)
   load_module "signals.sx" web_dir;   (* web extensions *)
   load_module "freeze.sx" lib_dir;

hosts/ocaml/bin/sx_server.ml

@@ -296,10 +296,6 @@ let read_blob () =
       (* consume trailing newline *)
       (try ignore (input_line stdin) with End_of_file -> ());
       data
-    | [List [Symbol "blob"; Integer n]] ->
-      let data = read_exact_bytes n in
-      (try ignore (input_line stdin) with End_of_file -> ());
-      data
     | _ -> raise (Eval_error ("read_blob: expected (blob N), got: " ^ line))
 
 (** Batch IO mode — collect requests during aser-slot, resolve after. *)
@@ -361,11 +357,6 @@ let rec read_io_response () =
     | [List (Symbol "io-response" :: Number n :: values)]
       when int_of_float n = !current_epoch ->
       (match values with [v] -> v | _ -> List values)
-    | [List [Symbol "io-response"; Integer n; value]]
-      when n = !current_epoch -> value
-    | [List (Symbol "io-response" :: Integer n :: values)]
-      when n = !current_epoch ->
-      (match values with [v] -> v | _ -> List values)
     (* Legacy untagged: (io-response value) — accept for backwards compat *)
     | [List [Symbol "io-response"; value]] -> value
     | [List (Symbol "io-response" :: values)] ->
@@ -405,12 +396,6 @@ let read_batched_io_response () =
         when int_of_float n = !current_epoch -> s
       | [List [Symbol "io-response"; Number n; v]]
         when int_of_float n = !current_epoch -> serialize_value v
-      | [List [Symbol "io-response"; Integer n; String s]]
-        when n = !current_epoch -> s
-      | [List [Symbol "io-response"; Integer n; SxExpr s]]
-        when n = !current_epoch -> s
-      | [List [Symbol "io-response"; Integer n; v]]
-        when n = !current_epoch -> serialize_value v
       (* Legacy untagged *)
       | [List [Symbol "io-response"; String s]]
       | [List [Symbol "io-response"; SxExpr s]] -> s
@@ -974,7 +959,6 @@ let setup_io_bridges env =
   bind "sleep" (fun args -> io_request "sleep" args);
   bind "set-response-status" (fun args -> match args with
     | [Number n] -> _pending_response_status := int_of_float n; Nil
-    | [Integer n] -> _pending_response_status := n; Nil
     | _ -> Nil);
   bind "set-response-header" (fun args -> io_request "set-response-header" args)
 
@@ -1377,7 +1361,6 @@ let rec dispatch env cmd =
         | Bool true -> "true"
         | Bool false -> "false"
         | Number n -> Sx_types.format_number n
-        | Integer n -> string_of_int n
         | String s -> "\"" ^ escape_sx_string s ^ "\""
         | Symbol s -> s
         | Keyword k -> ":" ^ k
@@ -1391,10 +1374,6 @@ let rec dispatch env cmd =
         | Island i -> "~" ^ i.i_name
         | SxExpr s -> s
         | RawHTML s -> "\"" ^ escape_sx_string s ^ "\""
-        | Char n -> Sx_types.inspect (Char n)
-        | Eof -> Sx_types.inspect Eof
-        | Port _ -> Sx_types.inspect result
-        | Rational (n, d) -> Printf.sprintf "%d/%d" n d
         | _ -> "nil"
       in
       send_ok_raw (raw_serialize result)
@@ -4471,8 +4450,6 @@ let site_mode () =
           match exprs with
           | [List [Symbol "epoch"; Number n]] ->
             current_epoch := int_of_float n
-          | [List [Symbol "epoch"; Integer n]] ->
-            current_epoch := n
           (* render-page: full SSR pipeline — URL → complete HTML *)
           | [List [Symbol "render-page"; String path]] ->
             (try match http_render_page env path [] with
@@ -4530,8 +4507,6 @@ let () =
             (* Epoch marker: (epoch N) — set current epoch, read next command *)
             | [List [Symbol "epoch"; Number n]] ->
               current_epoch := int_of_float n
-            | [List [Symbol "epoch"; Integer n]] ->
-              current_epoch := n
             | [cmd] -> dispatch env cmd
             | _ -> send_error ("Expected single command, got " ^ string_of_int (List.length exprs))
           end

hosts/ocaml/bootstrap.py

@@ -47,9 +47,7 @@ open Sx_runtime
 let trampoline_fn : (value -> value) ref = ref (fun v -> v)
 let trampoline v = !trampoline_fn v
 
-(* Step limit for timeout detection — set to 0 to disable *)
-let step_limit : int ref = ref 0
-let step_count : int ref = ref 0
+
 
 (* === Mutable globals — backing refs for transpiler's !_ref / _ref := === *)
 let _strict_ref = ref (Bool false)
@@ -128,90 +126,6 @@ let enhance_error_with_trace msg =
   _last_error_kont_ref := Nil;
   msg ^ (format_comp_trace trace)
 
-(* Hand-written sf_define_type — skipped from transpile because the spec uses
-   &rest params and empty-dict literals that the transpiler can't emit cleanly.
-   Implements: (define-type Name (Ctor1 f1 f2) (Ctor2 f3) ...)
-   Creates constructor fns, Name?/Ctor? predicates, Ctor-field accessors,
-   and records ctors in *adt-registry*. *)
-let sf_define_type args env_val =
-  let items = (match args with List l -> l | _ -> []) in
-  let type_sym = List.nth items 0 in
-  let type_name = value_to_string type_sym in
-  let ctor_specs = List.tl items in
-  let env_has_v k = sx_truthy (env_has env_val (String k)) in
-  let env_bind_v k v = ignore (env_bind env_val (String k) v) in
-  let env_get_v k = env_get env_val (String k) in
-  if not (env_has_v "*adt-registry*") then
-    env_bind_v "*adt-registry*" (Dict (Hashtbl.create 8));
-  let registry = env_get_v "*adt-registry*" in
-  let ctor_names = List.map (fun spec ->
-    (match spec with List (sym :: _) -> String (value_to_string sym) | _ -> Nil)
-  ) ctor_specs in
-  (match registry with Dict d -> Hashtbl.replace d type_name (List ctor_names) | _ -> ());
-  env_bind_v (type_name ^ "?")
-    (NativeFn (type_name ^ "?", fun pargs ->
-      (match pargs with
-      | [v] ->
-        (match v with
-        | Dict d -> Bool (Hashtbl.mem d "_adt" &&
-          (match Hashtbl.find_opt d "_type" with Some (String t) -> t = type_name | _ -> false))
-        | _ -> Bool false)
-      | _ -> Bool false)));
-  List.iter (fun spec ->
-    (match spec with
-    | List (sym :: fields) ->
-      let cn = value_to_string sym in
-      let field_names = List.map value_to_string fields in
-      let arity = List.length fields in
-      env_bind_v cn
-        (NativeFn (cn, fun ctor_args ->
-          if List.length ctor_args <> arity then
-            raise (Eval_error (Printf.sprintf "%s: expected %d args, got %d"
-              cn arity (List.length ctor_args)))
-          else begin
-            let d = Hashtbl.create 4 in
-            Hashtbl.replace d "_adt"    (Bool true);
-            Hashtbl.replace d "_type"   (String type_name);
-            Hashtbl.replace d "_ctor"   (String cn);
-            Hashtbl.replace d "_fields" (List ctor_args);
-            Dict d
-          end));
-      env_bind_v (cn ^ "?")
-        (NativeFn (cn ^ "?", fun pargs ->
-          (match pargs with
-          | [v] ->
-            (match v with
-            | Dict d -> Bool (Hashtbl.mem d "_adt" &&
-              (match Hashtbl.find_opt d "_ctor" with Some (String c) -> c = cn | _ -> false))
-            | _ -> Bool false)
-          | _ -> Bool false)));
-      List.iteri (fun idx fname ->
-        env_bind_v (cn ^ "-" ^ fname)
-          (NativeFn (cn ^ "-" ^ fname, fun pargs ->
-            (match pargs with
-            | [v] ->
-              (match v with
-              | Dict d ->
-                (match Hashtbl.find_opt d "_fields" with
-                | Some (List fs) ->
-                  if idx < List.length fs then List.nth fs idx
-                  else raise (Eval_error (cn ^ "-" ^ fname ^ ": index out of bounds"))
-                | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not an ADT")))
-              | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not a dict")))
-            | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": expected 1 arg")))))
-      ) field_names
-    | _ -> ())
-  ) ctor_specs;
-  Nil
-
-(* Register define-type via custom_special_forms so the CEK dispatch finds it.
-   The top-level (register-special-form! ...) in spec/evaluator.sx is not a
-   define and therefore is not transpiled; we wire it up here instead. *)
-let () = ignore (register_special_form (String "define-type")
-  (NativeFn ("define-type", fun call_args ->
-    match call_args with
-    | [args; env] -> sf_define_type args env
-    | _ -> Nil)))
 
 
 """
@@ -257,10 +171,7 @@ def compile_spec_to_ml(spec_dir: str | None = None) -> str:
                 "debug-log", "debug_log", "range", "chunk-every", "zip-pairs",
                 "string-contains?", "starts-with?", "ends-with?",
                 "string-replace", "trim", "split", "index-of",
-                "pad-left", "pad-right", "char-at", "substring",
-                # sf-define-type uses &rest + empty-dict literals that the transpiler
-                # can't emit as valid OCaml; hand-written implementation in FIXUPS.
-                "sf-define-type"}
+                "pad-left", "pad-right", "char-at", "substring"}
         defines = [(n, e) for n, e in defines if n not in skip]
 
         # Deduplicate — keep last definition for each name (CEK overrides tree-walk)

hosts/ocaml/lib/sx_parser.ml

@@ -89,38 +89,10 @@ let read_symbol s =
   while s.pos < s.len && is_symbol_char s.src.[s.pos] do advance s done;
   String.sub s.src start (s.pos - start)
 
-let gcd a b =
-  let rec g a b = if b = 0 then a else g b (a mod b) in g (abs a) (abs b)
-
-let make_rat n d =
-  if d = 0 then raise (Parse_error "rational: division by zero");
-  let sign = if d < 0 then -1 else 1 in
-  let g = gcd (abs n) (abs d) in
-  let rn = sign * n / g and rd = sign * d / g in
-  if rd = 1 then Integer rn else Rational (rn, rd)
-
 let try_number str =
-  (* Integers (no '.' or 'e'/'E') → exact Integer; rationals N/D; floats → inexact Number *)
-  let has_dec = String.contains str '.' in
-  let has_exp = String.contains str 'e' || String.contains str 'E' in
-  if has_dec || has_exp then
-    match float_of_string_opt str with
-    | Some n -> Some (Number n)
-    | None -> None
-  else
-    match String.split_on_char '/' str with
-    | [num_s; den_s] when num_s <> "" && den_s <> "" ->
-      (match int_of_string_opt num_s, int_of_string_opt den_s with
-       | Some n, Some d -> (try Some (make_rat n d) with _ -> None)
-       | _ -> None)
-    | _ ->
-      match int_of_string_opt str with
-      | Some n -> Some (Integer n)
-      | None ->
-        (* handles "nan", "inf", "-inf" *)
-        match float_of_string_opt str with
-        | Some n -> Some (Number n)
-        | None -> None
+  match float_of_string_opt str with
+  | Some n -> Some (Number n)
+  | None -> None
 
 let rec read_value s : value =
   skip_whitespace_and_comments s;
@@ -136,34 +108,6 @@ let rec read_value s : value =
   | '"' -> String (read_string s)
   | '\'' -> advance s; List [Symbol "quote"; read_value s]
   | '`' -> advance s; List [Symbol "quasiquote"; read_value s]
-  | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = '\\' ->
-    (* Character literal: #\a, #\space, #\newline, etc. *)
-    advance s; advance s;
-    if at_end s then raise (Parse_error "Unexpected end of input after #\\");
-    let char_start = s.pos in
-    (* Read a name if starts with ident char, else single char *)
-    if is_ident_start s.src.[s.pos] then begin
-      while s.pos < s.len && is_ident_char s.src.[s.pos] do advance s done;
-      let name = String.sub s.src char_start (s.pos - char_start) in
-      let cp = match name with
-        | "space" -> 32 | "newline" -> 10 | "tab" -> 9
-        | "return" -> 13 | "nul" -> 0 | "null" -> 0
-        | "escape" -> 27 | "delete" -> 127 | "backspace" -> 8
-        | "altmode" -> 27 | "rubout" -> 127
-        | _ -> Char.code name.[0]  (* single letter like #\a *)
-      in Char cp
-    end else begin
-      let c = s.src.[s.pos] in
-      advance s;
-      Char (Char.code c)
-    end
-  | '#' when s.pos + 1 < s.len &&
-             (s.src.[s.pos + 1] = 't' || s.src.[s.pos + 1] = 'f') &&
-             (s.pos + 2 >= s.len || not (is_ident_char s.src.[s.pos + 2])) ->
-    (* #t / #f — boolean literals (R7RS shorthand) *)
-    let b = s.src.[s.pos + 1] = 't' in
-    advance s; advance s;
-    Bool b
   | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = ';' ->
     (* Datum comment: #; discards next expression *)
     advance s; advance s;

hosts/ocaml/lib/sx_runtime.ml

@@ -46,7 +46,7 @@ let sx_call f args =
     !Sx_types._cek_eval_lambda_ref f args
   | Continuation (k, _) ->
     k (match args with x :: _ -> x | [] -> Nil)
-  | CallccContinuation (_, _) ->
+  | CallccContinuation _ ->
     raise (Eval_error "callcc continuations must be invoked through the CEK machine")
   | _ ->
     let nargs = List.length args in
@@ -156,9 +156,6 @@ let get_val container key =
      | "extra" -> f.cf_extra | "extra2" -> f.cf_extra2
      | "subscribers" -> f.cf_results
      | "prev-tracking" -> f.cf_extra
-     | "after-thunk" -> f.cf_f        (* wind-after frame *)
-     | "winders-len" -> f.cf_extra    (* wind-after frame *)
-     | "body-result" -> f.cf_name     (* wind-return frame *)
      | _ -> Nil)
   | VmFrame f, String k ->
     (match k with
@@ -211,8 +208,6 @@ let get_val container key =
   | Dict d, Keyword k -> dict_get d k
   | (List l | ListRef { contents = l }), Number n ->
     (try List.nth l (int_of_float n) with _ -> Nil)
-  | (List l | ListRef { contents = l }), Integer n ->
-    (try List.nth l n with _ -> Nil)
   | Nil, _ -> Nil  (* nil.anything → nil *)
   | _, _ -> Nil    (* type mismatch → nil (matches JS/Python behavior) *)
 
@@ -386,20 +381,15 @@ let continuation_data v = match v with
   | _ -> raise (Eval_error "not a continuation")
 
 (* Callcc (undelimited) continuation support *)
-let callcc_continuation_p v = match v with CallccContinuation (_, _) -> Bool true | _ -> Bool false
+let callcc_continuation_p v = match v with CallccContinuation _ -> Bool true | _ -> Bool false
 
-let make_callcc_continuation captured winders_len =
-  let n = match winders_len with Number f -> int_of_float f | Integer n -> n | _ -> 0 in
-  CallccContinuation (sx_to_list captured, n)
+let make_callcc_continuation captured =
+  CallccContinuation (sx_to_list captured)
 
 let callcc_continuation_data v = match v with
-  | CallccContinuation (frames, _) -> List frames
+  | CallccContinuation frames -> List frames
   | _ -> raise (Eval_error "not a callcc continuation")
 
-let callcc_continuation_winders_len v = match v with
-  | CallccContinuation (_, n) -> Number (float_of_int n)
-  | _ -> Number 0.0
-
 (* Dynamic wind — simplified for OCaml (no async) *)
 let host_error msg =
   raise (Eval_error (value_to_str msg))

hosts/ocaml/lib/sx_types.ml

@@ -43,10 +43,9 @@ type env = {
 
 and value =
   | Nil
-  | Bool    of bool
-  | Integer of int    (** Exact integer — distinct from inexact float. *)
-  | Number  of float  (** Inexact float. *)
-  | String  of string
+  | Bool   of bool
+  | Number of float
+  | String of string
   | Symbol of string
   | Keyword of string
   | List   of value list
@@ -57,7 +56,7 @@ and value =
   | Macro  of macro
   | Thunk  of value * env
   | Continuation of (value -> value) * dict option
-  | CallccContinuation of value list * int  (** Undelimited continuation — captured kont frames + winders depth at capture *)
+  | CallccContinuation of value list  (** Undelimited continuation — captured kont frames *)
   | NativeFn of string * (value list -> value)
   | Signal of signal
   | RawHTML of string
@@ -73,25 +72,6 @@ and value =
   | Record of record  (** R7RS record — opaque, generative, field-indexed. *)
   | Parameter of parameter  (** R7RS parameter — dynamic binding via kont-stack provide frames. *)
   | Vector of value array  (** R7RS vector — mutable fixed-size array. *)
-  | StringBuffer of Buffer.t  (** Mutable string buffer — O(1) amortized append. *)
-  | HashTable of (value, value) Hashtbl.t  (** Mutable hash table with arbitrary keys. *)
-  | Char of int  (** Unicode codepoint — R7RS char type. *)
-  | Eof            (** EOF sentinel — returned by read-char etc. at end of input. *)
-  | Port of sx_port  (** String port — input (string cursor) or output (buffer). *)
-  | Rational of int * int  (** Exact rational: numerator, denominator (reduced, denom>0). *)
-  | SxSet of (string, value) Hashtbl.t  (** Mutable set keyed by inspect(value). *)
-  | SxRegexp of string * string * Re.re  (** Regexp: source, flags, compiled. *)
-  | SxBytevector of bytes  (** Mutable bytevector — R7RS bytevector type. *)
-
-(** String input port: source string + mutable cursor position. *)
-and sx_port_kind =
-  | PortInput of string * int ref
-  | PortOutput of Buffer.t
-
-and sx_port = {
-  mutable sp_closed : bool;
-  sp_kind : sx_port_kind;
-}
 
 (** CEK machine state — record instead of Dict for performance.
     5 fields × 55K steps/sec = 275K Hashtbl allocations/sec eliminated. *)
@@ -412,7 +392,6 @@ let format_number n =
 
 let value_to_string = function
   | String s -> s | Symbol s -> s | Keyword k -> k
-  | Integer n -> string_of_int n
   | Number n -> format_number n
   | Bool true -> "true" | Bool false -> "false"
   | Nil -> "" | _ -> "<value>"
@@ -482,7 +461,6 @@ let make_keyword name = Keyword (value_to_string name)
 let type_of = function
   | Nil            -> "nil"
   | Bool _         -> "boolean"
-  | Integer _      -> "number"
   | Number _       -> "number"
   | String _       -> "string"
   | Symbol _       -> "symbol"
@@ -495,7 +473,7 @@ let type_of = function
   | Macro _        -> "macro"
   | Thunk _        -> "thunk"
   | Continuation (_, _) -> "continuation"
-  | CallccContinuation (_, _) -> "continuation"
+  | CallccContinuation _ -> "continuation"
   | NativeFn _     -> "function"
   | Signal _       -> "signal"
   | RawHTML _      -> "raw-html"
@@ -510,16 +488,6 @@ let type_of = function
   | Record r       -> r.r_type.rt_name
   | Parameter _    -> "parameter"
   | Vector _       -> "vector"
-  | StringBuffer _ -> "string-buffer"
-  | HashTable _    -> "hash-table"
-  | Char _         -> "char"
-  | Eof            -> "eof-object"
-  | Port { sp_kind = PortInput _; _ }  -> "input-port"
-  | Port { sp_kind = PortOutput _; _ } -> "output-port"
-  | Rational _  -> "rational"
-  | SxSet _          -> "set"
-  | SxRegexp _       -> "regexp"
-  | SxBytevector _   -> "bytevector"
 
 let is_nil = function Nil -> true | _ -> false
 let is_lambda = function Lambda _ -> true | _ -> false
@@ -535,7 +503,7 @@ let is_signal = function
 let is_record = function Record _ -> true | _ -> false
 
 let is_callable = function
-  | Lambda _ | NativeFn _ | Continuation (_, _) | CallccContinuation (_, _) | VmClosure _ -> true
+  | Lambda _ | NativeFn _ | Continuation (_, _) | CallccContinuation _ | VmClosure _ -> true
   | _ -> false
 
 
@@ -648,7 +616,6 @@ let thunk_env = function
 (** {1 Record operations} *)
 
 let val_to_int = function
-  | Integer n -> n
   | Number n -> int_of_float n
   | v -> raise (Eval_error ("Expected number, got " ^ type_of v))
 
@@ -810,7 +777,6 @@ let rec inspect = function
   | Nil -> "nil"
   | Bool true -> "true"
   | Bool false -> "false"
-  | Integer n -> string_of_int n
   | Number n -> format_number n
   | String s ->
     let buf = Buffer.create (String.length s + 2) in
@@ -844,7 +810,7 @@ let rec inspect = function
     Printf.sprintf "<%s(%s)>" tag (String.concat ", " m.m_params)
   | Thunk _ -> "<thunk>"
   | Continuation (_, _) -> "<continuation>"
-  | CallccContinuation (_, _) -> "<callcc-continuation>"
+  | CallccContinuation _ -> "<callcc-continuation>"
   | NativeFn (name, _) -> Printf.sprintf "<native:%s>" name
   | Signal _ -> "<signal>"
   | RawHTML s -> Printf.sprintf "\"<raw-html:%d>\"" (String.length s)
@@ -865,23 +831,3 @@ let rec inspect = function
     Printf.sprintf "#(%s)" (String.concat " " elts)
   | VmFrame f -> Printf.sprintf "<vm-frame:ip=%d base=%d>" f.vf_ip f.vf_base
   | VmMachine m -> Printf.sprintf "<vm-machine:sp=%d frames=%d>" m.vm_sp (List.length m.vm_frames)
-  | StringBuffer buf -> Printf.sprintf "<string-buffer:%d>" (Buffer.length buf)
-  | HashTable ht -> Printf.sprintf "<hash-table:%d>" (Hashtbl.length ht)
-  | Char n ->
-    let name = match n with
-      | 32 -> "space" | 10 -> "newline" | 9 -> "tab"
-      | 13 -> "return" | 0 -> "nul" | 27 -> "escape"
-      | 127 -> "delete" | 8 -> "backspace"
-      | _ -> let buf = Buffer.create 1 in
-             Buffer.add_utf_8_uchar buf (Uchar.of_int n);
-             Buffer.contents buf
-    in "#\\" ^ name
-  | Eof -> "#!eof"
-  | Port { sp_kind = PortInput (_, pos); sp_closed } ->
-    Printf.sprintf "<input-port:pos=%d%s>" !pos (if sp_closed then ":closed" else "")
-  | Port { sp_kind = PortOutput buf; sp_closed } ->
-    Printf.sprintf "<output-port:len=%d%s>" (Buffer.length buf) (if sp_closed then ":closed" else "")
-  | Rational (n, d) -> Printf.sprintf "%d/%d" n d
-  | SxSet ht -> Printf.sprintf "<set:%d>" (Hashtbl.length ht)
-  | SxRegexp (src, flags, _) -> Printf.sprintf "#/%s/%s" src flags
-  | SxBytevector b -> Printf.sprintf "#u8(%s)" (String.concat " " (List.init (Bytes.length b) (fun i -> string_of_int (Char.code (Bytes.get b i)))))

hosts/ocaml/lib/sx_vm.ml

@@ -185,8 +185,7 @@ let code_from_value v =
       | Some _ as r -> r | None -> Hashtbl.find_opt d k2 in
     let bc_list = match find2 "bytecode" "vc-bytecode" with
       | Some (List l | ListRef { contents = l }) ->
-        Array.of_list (List.map (fun x -> match x with
-          | Integer n -> n | Number n -> int_of_float n | _ -> 0) l)
+        Array.of_list (List.map (fun x -> match x with Number n -> int_of_float n | _ -> 0) l)
       | _ -> [||]
     in
     let entries = match find2 "constants" "vc-constants" with
@@ -199,10 +198,10 @@ let code_from_value v =
       | _ -> entry
     ) entries in
     let arity = match find2 "arity" "vc-arity" with
-      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> 0
+      | Some (Number n) -> int_of_float n | _ -> 0
     in
     let rest_arity = match find2 "rest-arity" "vc-rest-arity" with
-      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> -1
+      | Some (Number n) -> int_of_float n | _ -> -1
     in
     (* Compute locals from bytecode: scan for highest LOCAL_GET/LOCAL_SET slot.
        The compiler's arity may undercount when nested lets add many locals. *)
@@ -750,7 +749,10 @@ and run vm =
             | _ -> (Hashtbl.find Sx_primitives.primitives "/") [a; b])
         | 164 (* OP_EQ *) ->
           let b = pop vm and a = pop vm in
-          push vm ((Hashtbl.find Sx_primitives.primitives "=") [a; b])
+          let rec norm = function
+            | ListRef { contents = l } -> List (List.map norm l)
+            | List l -> List (List.map norm l) | v -> v in
+          push vm (Bool (norm a = norm b))
         | 165 (* OP_LT *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
@@ -769,10 +771,10 @@ and run vm =
         | 168 (* OP_LEN *) ->
           let v = pop vm in
           push vm (match v with
-            | List l | ListRef { contents = l } -> Integer (List.length l)
-            | String s -> Integer (String.length s)
-            | Dict d -> Integer (Hashtbl.length d)
-            | Nil -> Integer 0
+            | List l | ListRef { contents = l } -> Number (float_of_int (List.length l))
+            | String s -> Number (float_of_int (String.length s))
+            | Dict d -> Number (float_of_int (Hashtbl.length d))
+            | Nil -> Number 0.0
             | _ -> (Hashtbl.find Sx_primitives.primitives "len") [v])
         | 169 (* OP_FIRST *) ->
           let v = pop vm in

hosts/ocaml/transpiler.sx

@@ -256,7 +256,6 @@
     "callcc-continuation?"
     "callcc-continuation-data"
     "make-callcc-continuation"
-    "callcc-continuation-winders-len"
     "dynamic-wind-call"
     "strip-prefix"
     "component-set-param-types!"
@@ -296,8 +295,7 @@
     "*bind-tracking*"
     "*provide-batch-depth*"
     "*provide-batch-queue*"
-    "*provide-subscribers*"
-    "*winders*"))
+    "*provide-subscribers*"))
 
 (define
   ml-is-mutable-global?
@@ -535,13 +533,13 @@
               "; cf_env = "
               (ef "env")
               "; cf_name = "
-              (if (= frame-type "if") (ef "else") (cond (some (fn (k) (= k "body-result")) items) (ef "body-result") :else (ef "name")))
+              (if (= frame-type "if") (ef "else") (ef "name"))
               "; cf_body = "
               (if (= frame-type "if") (ef "then") (ef "body"))
               "; cf_remaining = "
               (ef "remaining")
               "; cf_f = "
-              (cond (some (fn (k) (= k "after-thunk")) items) (ef "after-thunk") (some (fn (k) (= k "f")) items) (ef "f") :else "Nil")
+              (ef "f")
               "; cf_args = "
               (cond
                 (some (fn (k) (= k "evaled")) items)
@@ -584,8 +582,6 @@
                 (ef "prev-tracking")
                 (some (fn (k) (= k "extra")) items)
                 (ef "extra")
-                (some (fn (k) (= k "winders-len")) items)
-                (ef "winders-len")
                 :else "Nil")
               "; cf_extra2 = "
               (cond

lib/apl/conformance.sh

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

lib/apl/parser.sx

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

lib/apl/scoreboard.json

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

lib/apl/scoreboard.md

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

lib/apl/test.sh

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

lib/apl/tests/dfn.sx

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

lib/apl/tests/eval-ops.sx

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

lib/apl/tests/idioms.sx

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

lib/apl/tests/operators.sx

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

lib/apl/tests/parse.sx

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

lib/apl/tests/pipeline.sx

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

lib/apl/tests/programs-e2e.sx

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

lib/apl/tests/programs.sx

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

lib/apl/tests/programs/life.apl

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

lib/apl/tests/programs/mandelbrot.apl

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

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

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

lib/apl/tests/programs/primes.apl

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

lib/apl/tests/programs/quicksort.apl

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

lib/apl/tests/runtime.sx

@@ -1,327 +0,0 @@
-;; lib/apl/tests/runtime.sx — Tests for lib/apl/runtime.sx
-
-;; --- Test framework ---
-(define apl-test-pass 0)
-(define apl-test-fail 0)
-(define apl-test-fails (list))
-
-(define
-  (apl-test name got expected)
-  (if
-    (= got expected)
-    (set! apl-test-pass (+ apl-test-pass 1))
-    (begin
-      (set! apl-test-fail (+ apl-test-fail 1))
-      (set! apl-test-fails (append apl-test-fails (list {:got got :expected expected :name name}))))))
-
-;; ---------------------------------------------------------------------------
-;; 1. Core vector constructors
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "iota 5"
-  (apl-iota 5)
-  (list 1 2 3 4 5))
-(apl-test "iota 1" (apl-iota 1) (list 1))
-(apl-test "iota 0" (apl-iota 0) (list))
-(apl-test
-  "rho list"
-  (apl-rho (list 1 2 3))
-  3)
-(apl-test "rho scalar" (apl-rho 42) 1)
-(apl-test
-  "at 1"
-  (apl-at (list 10 20 30) 1)
-  10)
-(apl-test
-  "at 3"
-  (apl-at (list 10 20 30) 3)
-  30)
-
-;; ---------------------------------------------------------------------------
-;; 2. Arithmetic — element-wise and rank-polymorphic
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "add v+v"
-  (apl-add
-    (list 1 2 3)
-    (list 10 20 30))
-  (list 11 22 33))
-(apl-test
-  "add s+v"
-  (apl-add 10 (list 1 2 3))
-  (list 11 12 13))
-(apl-test
-  "add v+s"
-  (apl-add (list 1 2 3) 100)
-  (list 101 102 103))
-(apl-test "add s+s" (apl-add 3 4) 7)
-(apl-test
-  "sub v-v"
-  (apl-sub
-    (list 5 4 3)
-    (list 1 2 3))
-  (list 4 2 0))
-(apl-test
-  "mul v*s"
-  (apl-mul (list 1 2 3) 3)
-  (list 3 6 9))
-(apl-test
-  "neg -v"
-  (apl-neg (list 1 -2 3))
-  (list -1 2 -3))
-(apl-test
-  "abs v"
-  (apl-abs (list -1 2 -3))
-  (list 1 2 3))
-(apl-test
-  "floor v"
-  (apl-floor (list 1.7 2.2 3.9))
-  (list 1 2 3))
-(apl-test
-  "ceil v"
-  (apl-ceil (list 1.1 2.5 3))
-  (list 2 3 3))
-(apl-test
-  "max v v"
-  (apl-max
-    (list 1 5 3)
-    (list 4 2 6))
-  (list 4 5 6))
-(apl-test
-  "min v v"
-  (apl-min
-    (list 1 5 3)
-    (list 4 2 6))
-  (list 1 2 3))
-
-;; ---------------------------------------------------------------------------
-;; 3. Comparison (returns 0/1)
-;; ---------------------------------------------------------------------------
-
-(apl-test "eq 3 3" (apl-eq 3 3) 1)
-(apl-test "eq 3 4" (apl-eq 3 4) 0)
-(apl-test
-  "gt v>s"
-  (apl-gt (list 1 5 3 7) 4)
-  (list 0 1 0 1))
-(apl-test
-  "lt v<v"
-  (apl-lt
-    (list 1 2 3)
-    (list 3 2 1))
-  (list 1 0 0))
-(apl-test
-  "le v<=s"
-  (apl-le (list 3 4 5) 4)
-  (list 1 1 0))
-(apl-test
-  "ge v>=s"
-  (apl-ge (list 3 4 5) 4)
-  (list 0 1 1))
-(apl-test
-  "neq v!=s"
-  (apl-neq (list 1 2 3) 2)
-  (list 1 0 1))
-
-;; ---------------------------------------------------------------------------
-;; 4. Boolean logic (0/1 values)
-;; ---------------------------------------------------------------------------
-
-(apl-test "and 1 1" (apl-and 1 1) 1)
-(apl-test "and 1 0" (apl-and 1 0) 0)
-(apl-test "or 0 1" (apl-or 0 1) 1)
-(apl-test "or 0 0" (apl-or 0 0) 0)
-(apl-test "not 0" (apl-not 0) 1)
-(apl-test "not 1" (apl-not 1) 0)
-(apl-test
-  "not vec"
-  (apl-not (list 1 0 1 0))
-  (list 0 1 0 1))
-
-;; ---------------------------------------------------------------------------
-;; 5. Bitwise operations
-;; ---------------------------------------------------------------------------
-
-(apl-test "bitand s" (apl-bitand 5 3) 1)
-(apl-test "bitor s" (apl-bitor 5 3) 7)
-(apl-test "bitxor s" (apl-bitxor 5 3) 6)
-(apl-test "bitnot 0" (apl-bitnot 0) -1)
-(apl-test "lshift 1 4" (apl-lshift 1 4) 16)
-(apl-test "rshift 16 2" (apl-rshift 16 2) 4)
-(apl-test
-  "bitand vec"
-  (apl-bitand (list 5 6) (list 3 7))
-  (list 1 6))
-(apl-test
-  "bitor vec"
-  (apl-bitor (list 5 6) (list 3 7))
-  (list 7 7))
-
-;; ---------------------------------------------------------------------------
-;; 6. Reduction and scan
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "reduce-add"
-  (apl-reduce-add
-    (list 1 2 3 4 5))
-  15)
-(apl-test
-  "reduce-mul"
-  (apl-reduce-mul (list 1 2 3 4))
-  24)
-(apl-test
-  "reduce-max"
-  (apl-reduce-max
-    (list 3 1 4 1 5))
-  5)
-(apl-test
-  "reduce-min"
-  (apl-reduce-min
-    (list 3 1 4 1 5))
-  1)
-(apl-test
-  "reduce-and"
-  (apl-reduce-and (list 1 1 1))
-  1)
-(apl-test
-  "reduce-and0"
-  (apl-reduce-and (list 1 0 1))
-  0)
-(apl-test
-  "reduce-or"
-  (apl-reduce-or (list 0 1 0))
-  1)
-(apl-test
-  "scan-add"
-  (apl-scan-add (list 1 2 3 4))
-  (list 1 3 6 10))
-(apl-test
-  "scan-mul"
-  (apl-scan-mul (list 1 2 3 4))
-  (list 1 2 6 24))
-
-;; ---------------------------------------------------------------------------
-;; 7. Vector manipulation
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "reverse"
-  (apl-reverse (list 1 2 3 4))
-  (list 4 3 2 1))
-(apl-test
-  "cat v v"
-  (apl-cat (list 1 2) (list 3 4))
-  (list 1 2 3 4))
-(apl-test
-  "cat v s"
-  (apl-cat (list 1 2) 3)
-  (list 1 2 3))
-(apl-test
-  "cat s v"
-  (apl-cat 1 (list 2 3))
-  (list 1 2 3))
-(apl-test
-  "cat s s"
-  (apl-cat 1 2)
-  (list 1 2))
-(apl-test
-  "take 3"
-  (apl-take
-    3
-    (list 10 20 30 40 50))
-  (list 10 20 30))
-(apl-test
-  "take 0"
-  (apl-take 0 (list 1 2 3))
-  (list))
-(apl-test
-  "take neg"
-  (apl-take -2 (list 10 20 30))
-  (list 20 30))
-(apl-test
-  "drop 2"
-  (apl-drop 2 (list 10 20 30 40))
-  (list 30 40))
-(apl-test
-  "drop neg"
-  (apl-drop -1 (list 10 20 30))
-  (list 10 20))
-(apl-test
-  "rotate 2"
-  (apl-rotate
-    2
-    (list 1 2 3 4 5))
-  (list 3 4 5 1 2))
-(apl-test
-  "compress"
-  (apl-compress
-    (list 1 0 1 0)
-    (list 10 20 30 40))
-  (list 10 30))
-(apl-test
-  "index"
-  (apl-index
-    (list 10 20 30 40)
-    (list 2 4))
-  (list 20 40))
-
-;; ---------------------------------------------------------------------------
-;; 8. Set operations
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "member yes"
-  (apl-member
-    (list 1 2 5)
-    (list 2 4 6))
-  (list 0 1 0))
-(apl-test
-  "member s"
-  (apl-member 2 (list 1 2 3))
-  1)
-(apl-test
-  "member no"
-  (apl-member 9 (list 1 2 3))
-  0)
-(apl-test
-  "nub"
-  (apl-nub (list 1 2 1 3 2))
-  (list 1 2 3))
-(apl-test
-  "union"
-  (apl-union
-    (list 1 2 3)
-    (list 2 3 4))
-  (list 1 2 3 4))
-(apl-test
-  "intersect"
-  (apl-intersect
-    (list 1 2 3 4)
-    (list 2 4 6))
-  (list 2 4))
-(apl-test
-  "without"
-  (apl-without
-    (list 1 2 3 4)
-    (list 2 4))
-  (list 1 3))
-
-;; ---------------------------------------------------------------------------
-;; 9. Format
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "format vec"
-  (apl-format (list 1 2 3))
-  "1 2 3")
-(apl-test "format scalar" (apl-format 42) "42")
-(apl-test "format empty" (apl-format (list)) "")
-
-;; ---------------------------------------------------------------------------
-;; Summary
-;; ---------------------------------------------------------------------------
-
-(list apl-test-pass apl-test-fail)

lib/apl/tests/scalar.sx

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

lib/apl/tests/structural.sx

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

lib/apl/tests/system.sx

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

lib/apl/tests/tradfn.sx

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

lib/apl/tests/valence.sx

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

lib/apl/tokenizer.sx

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

lib/apl/transpile.sx

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

lib/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,724 +0,0 @@
-;; lib/common-lisp/runtime.sx — CL built-ins + condition system on SX
-;;
-;; 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).
-;;
-;; 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
-
-;; ---------------------------------------------------------------------------
-;; 1.  Type predicates
-;; ---------------------------------------------------------------------------
-
-(define (cl-null? x) (= x nil))
-(define (cl-consp? x) (and (list? x) (not (cl-empty? x))))
-(define (cl-listp? x) (or (cl-empty? x) (list? x)))
-(define (cl-atom? x) (not (cl-consp? x)))
-
-(define
-  (cl-numberp? x)
-  (let ((t (type-of x))) (or (= t "number") (= t "rational"))))
-
-(define cl-integerp? integer?)
-(define cl-floatp? float?)
-(define cl-rationalp? rational?)
-
-(define (cl-realp? x) (or (integer? x) (float? x) (rational? x)))
-
-(define cl-characterp? char?)
-(define cl-stringp? (fn (x) (= (type-of x) "string")))
-(define cl-symbolp? (fn (x) (= (type-of x) "symbol")))
-(define cl-keywordp? (fn (x) (= (type-of x) "keyword")))
-
-(define
-  (cl-functionp? x)
-  (let
-    ((t (type-of x)))
-    (or
-      (= t "function")
-      (= t "lambda")
-      (= t "native-fn")
-      (= t "component"))))
-
-(define cl-vectorp? vector?)
-(define cl-arrayp? vector?)
-
-;; sx_server: (rest (list x)) returns () not nil — cl-empty? handles both
-(define
-  (cl-empty? x)
-  (or (nil? x) (and (list? x) (= (len x) 0))))
-
-;; ---------------------------------------------------------------------------
-;; 2.  Arithmetic — thin aliases to spec primitives
-;; ---------------------------------------------------------------------------
-
-(define cl-mod modulo)
-(define cl-rem remainder)
-(define cl-gcd gcd)
-(define cl-lcm lcm)
-(define cl-expt expt)
-(define cl-floor floor)
-(define cl-ceiling ceil)
-(define cl-truncate truncate)
-(define cl-round round)
-(define cl-abs (fn (x) (if (< x 0) (- 0 x) x)))
-(define cl-min (fn (a b) (if (< a b) a b)))
-(define cl-max (fn (a b) (if (> a b) a b)))
-(define cl-quotient quotient)
-
-(define
-  (cl-signum x)
-  (cond
-    ((> x 0) 1)
-    ((< x 0) -1)
-    (else 0)))
-
-(define (cl-evenp? n) (= (modulo n 2) 0))
-(define (cl-oddp? n) (= (modulo n 2) 1))
-(define (cl-zerop? n) (= n 0))
-(define (cl-plusp? n) (> n 0))
-(define (cl-minusp? n) (< n 0))
-
-;; ---------------------------------------------------------------------------
-;; 3.  Character functions — alias spec char primitives + CL name mapping
-;; ---------------------------------------------------------------------------
-
-(define cl-char->integer char->integer)
-(define cl-integer->char integer->char)
-(define cl-char-upcase char-upcase)
-(define cl-char-downcase char-downcase)
-(define cl-char-code char->integer)
-(define cl-code-char integer->char)
-
-(define cl-char=? char=?)
-(define cl-char<? char<?)
-(define cl-char>? char>?)
-(define cl-char<=? char<=?)
-(define cl-char>=? char>=?)
-(define cl-char-ci=? char-ci=?)
-(define cl-char-ci<? char-ci<?)
-(define cl-char-ci>? char-ci>?)
-
-;; Inline predicates — char-alphabetic?/char-numeric? unreliable in sx_server
-(define
-  (cl-alpha-char-p c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (cl-digit-char-p c)
-  (let ((n (char->integer c))) (and (>= n 48) (<= n 57))))
-
-(define
-  (cl-alphanumericp c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 48) (<= n 57))
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (cl-upper-case-p c)
-  (let ((n (char->integer c))) (and (>= n 65) (<= n 90))))
-
-(define
-  (cl-lower-case-p c)
-  (let ((n (char->integer c))) (and (>= n 97) (<= n 122))))
-
-;; Named character constants
-(define cl-char-space (integer->char 32))
-(define cl-char-newline (integer->char 10))
-(define cl-char-tab (integer->char 9))
-(define cl-char-backspace (integer->char 8))
-(define cl-char-return (integer->char 13))
-(define cl-char-null (integer->char 0))
-(define cl-char-escape (integer->char 27))
-(define cl-char-delete (integer->char 127))
-
-;; ---------------------------------------------------------------------------
-;; 4.  String + IO — use spec format and ports
-;; ---------------------------------------------------------------------------
-
-;; CL format: (cl-format nil "~a ~a" x y) — nil destination means return string
-(define
-  (cl-format dest template &rest args)
-  (let ((s (apply format (cons template args)))) (if (= dest nil) s s)))
-
-(define cl-write-to-string write-to-string)
-(define cl-princ-to-string display-to-string)
-
-;; CL read-from-string: parse value from a string using SX port
-(define
-  (cl-read-from-string s)
-  (let ((p (open-input-string s))) (read p)))
-
-;; String stream (output)
-(define cl-make-string-output-stream open-output-string)
-(define cl-get-output-stream-string get-output-string)
-
-;; String stream (input)
-(define cl-make-string-input-stream open-input-string)
-
-;; ---------------------------------------------------------------------------
-;; 5.  Gensym
-;; ---------------------------------------------------------------------------
-
-(define cl-gensym gensym)
-(define cl-gentemp gensym)
-
-;; ---------------------------------------------------------------------------
-;; 6.  Multiple values (CL: values / nth-value)
-;; ---------------------------------------------------------------------------
-
-(define (cl-values &rest args) {:_values true :_list args})
-
-(define
-  (cl-call-with-values producer consumer)
-  (let
-    ((mv (producer)))
-    (if
-      (and (dict? mv) (get mv :_values))
-      (apply consumer (get mv :_list))
-      (consumer mv))))
-
-(define
-  (cl-nth-value n mv)
-  (cond
-    ((and (dict? mv) (get mv :_values))
-      (let
-        ((lst (get mv :_list)))
-        (if (>= n (len lst)) nil (nth lst n))))
-    ((= n 0) mv)
-    (else nil)))
-
-;; ---------------------------------------------------------------------------
-;; 7.  Sets (CL: adjoin / member / union / intersection / set-difference)
-;; ---------------------------------------------------------------------------
-
-(define cl-make-set make-set)
-(define cl-set? set?)
-(define cl-set-add set-add!)
-(define cl-set-memberp set-member?)
-(define cl-set-remove set-remove!)
-(define cl-set-union set-union)
-(define cl-set-intersect set-intersection)
-(define cl-set-difference set-difference)
-(define cl-list->set list->set)
-(define cl-set->list set->list)
-
-;; CL: (member item list) — returns tail starting at item, or nil
-(define
-  (cl-member item lst)
-  (cond
-    ((cl-empty? lst) nil)
-    ((equal? item (first lst)) lst)
-    (else (cl-member item (rest lst)))))
-
-;; CL: (adjoin item list) — cons only if not already present
-(define (cl-adjoin item lst) (if (cl-member item lst) lst (cons item lst)))
-
-;; ---------------------------------------------------------------------------
-;; 8.  Radix formatting  (CL: (write-to-string n :base radix))
-;; ---------------------------------------------------------------------------
-
-(define (cl-integer-to-string n radix) (number->string n radix))
-
-(define (cl-string-to-integer s radix) (string->number s radix))
-
-;; CL ~R directive helpers
-(define (cl-format-binary n) (number->string n 2))
-(define (cl-format-octal n) (number->string n 8))
-(define (cl-format-hex n) (number->string n 16))
-(define (cl-format-decimal n) (number->string n 10))
-
-;; ---------------------------------------------------------------------------
-;; 9.  List utilities — cl-empty? guards against () from rest
-;; ---------------------------------------------------------------------------
-
-(define
-  (cl-last lst)
-  (cond
-    ((cl-empty? lst) nil)
-    ((cl-empty? (rest lst)) lst)
-    (else (cl-last (rest lst)))))
-
-(define
-  (cl-butlast lst)
-  (if
-    (or (cl-empty? lst) (cl-empty? (rest lst)))
-    nil
-    (cons (first lst) (cl-butlast (rest lst)))))
-
-(define
-  (cl-nthcdr n lst)
-  (if (= n 0) lst (cl-nthcdr (- n 1) (rest lst))))
-
-(define (cl-nth n lst) (first (cl-nthcdr n lst)))
-
-(define (cl-list-length lst) (len lst))
-
-(define
-  (cl-copy-list lst)
-  (if (cl-empty? lst) nil (cons (first lst) (cl-copy-list (rest lst)))))
-
-(define
-  (cl-flatten lst)
-  (cond
-    ((cl-empty? lst) nil)
-    ((list? (first lst))
-      (append (cl-flatten (first lst)) (cl-flatten (rest lst))))
-    (else (cons (first lst) (cl-flatten (rest lst))))))
-
-;; CL: (assoc key alist) — returns matching pair or nil
-(define
-  (cl-assoc key alist)
-  (cond
-    ((cl-empty? alist) nil)
-    ((equal? key (first (first alist))) (first alist))
-    (else (cl-assoc key (rest alist)))))
-
-;; CL: (rassoc val alist) — reverse assoc (match on second element)
-(define
-  (cl-rassoc val alist)
-  (cond
-    ((cl-empty? alist) nil)
-    ((equal? val (first (rest (first alist)))) (first alist))
-    (else (cl-rassoc val (rest alist)))))
-
-;; CL: (getf plist key) — property list lookup
-(define
-  (cl-getf plist key)
-  (cond
-    ((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

@@ -1,443 +0,0 @@
-#!/usr/bin/env bash
-# lib/common-lisp/test.sh — quick smoke-test the CL runtime layer.
-# Uses sx_server.exe epoch protocol (same as lib/lua/test.sh).
-#
-# Usage:
-#   bash lib/common-lisp/test.sh
-#   bash lib/common-lisp/test.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. Run: cd hosts/ocaml && dune build"
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-PASS=0; FAIL=0; ERRORS=""
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/common-lisp/runtime.sx")
-
-;; --- Type predicates ---
-(epoch 10)
-(eval "(cl-null? nil)")
-(epoch 11)
-(eval "(cl-null? false)")
-(epoch 12)
-(eval "(cl-consp? (list 1 2))")
-(epoch 13)
-(eval "(cl-consp? nil)")
-(epoch 14)
-(eval "(cl-listp? nil)")
-(epoch 15)
-(eval "(cl-listp? (list 1))")
-(epoch 16)
-(eval "(cl-atom? nil)")
-(epoch 17)
-(eval "(cl-atom? (list 1))")
-(epoch 18)
-(eval "(cl-integerp? 42)")
-(epoch 19)
-(eval "(cl-floatp? 3.14)")
-(epoch 20)
-(eval "(cl-characterp? (integer->char 65))")
-(epoch 21)
-(eval "(cl-stringp? \"hello\")")
-
-;; --- Arithmetic ---
-(epoch 30)
-(eval "(cl-mod 10 3)")
-(epoch 31)
-(eval "(cl-rem 10 3)")
-(epoch 32)
-(eval "(cl-quotient 10 3)")
-(epoch 33)
-(eval "(cl-gcd 12 8)")
-(epoch 34)
-(eval "(cl-lcm 4 6)")
-(epoch 35)
-(eval "(cl-abs -5)")
-(epoch 36)
-(eval "(cl-abs 5)")
-(epoch 37)
-(eval "(cl-min 2 7)")
-(epoch 38)
-(eval "(cl-max 2 7)")
-(epoch 39)
-(eval "(cl-evenp? 4)")
-(epoch 40)
-(eval "(cl-evenp? 3)")
-(epoch 41)
-(eval "(cl-oddp? 7)")
-(epoch 42)
-(eval "(cl-zerop? 0)")
-(epoch 43)
-(eval "(cl-plusp? 1)")
-(epoch 44)
-(eval "(cl-minusp? -1)")
-(epoch 45)
-(eval "(cl-signum 42)")
-(epoch 46)
-(eval "(cl-signum -7)")
-(epoch 47)
-(eval "(cl-signum 0)")
-
-;; --- Characters ---
-(epoch 50)
-(eval "(cl-char-code (integer->char 65))")
-(epoch 51)
-(eval "(char? (cl-code-char 65))")
-(epoch 52)
-(eval "(cl-char=? (integer->char 65) (integer->char 65))")
-(epoch 53)
-(eval "(cl-char<? (integer->char 65) (integer->char 90))")
-(epoch 54)
-(eval "(cl-char-code cl-char-space)")
-(epoch 55)
-(eval "(cl-char-code cl-char-newline)")
-(epoch 56)
-(eval "(cl-alpha-char-p (integer->char 65))")
-(epoch 57)
-(eval "(cl-digit-char-p (integer->char 48))")
-
-;; --- Format ---
-(epoch 60)
-(eval "(cl-format nil \"hello\")")
-(epoch 61)
-(eval "(cl-format nil \"~a\" \"world\")")
-(epoch 62)
-(eval "(cl-format nil \"~d\" 42)")
-(epoch 63)
-(eval "(cl-format nil \"~x\" 255)")
-(epoch 64)
-(eval "(cl-format nil \"x=~d y=~d\" 3 4)")
-
-;; --- Gensym ---
-(epoch 70)
-(eval "(= (type-of (cl-gensym)) \"symbol\")")
-(epoch 71)
-(eval "(not (= (cl-gensym) (cl-gensym)))")
-
-;; --- Sets ---
-(epoch 80)
-(eval "(cl-set? (cl-make-set))")
-(epoch 81)
-(eval "(let ((s (cl-make-set))) (do (cl-set-add s 1) (cl-set-memberp s 1)))")
-(epoch 82)
-(eval "(cl-set-memberp (cl-make-set) 42)")
-(epoch 83)
-(eval "(cl-set-memberp (cl-list->set (list 1 2 3)) 2)")
-
-;; --- Lists ---
-(epoch 90)
-(eval "(cl-nth 0 (list 1 2 3))")
-(epoch 91)
-(eval "(cl-nth 2 (list 1 2 3))")
-(epoch 92)
-(eval "(cl-last (list 1 2 3))")
-(epoch 93)
-(eval "(cl-butlast (list 1 2 3))")
-(epoch 94)
-(eval "(cl-nthcdr 1 (list 1 2 3))")
-(epoch 95)
-(eval "(cl-assoc \"b\" (list (list \"a\" 1) (list \"b\" 2)))")
-(epoch 96)
-(eval "(cl-assoc \"z\" (list (list \"a\" 1)))")
-(epoch 97)
-(eval "(cl-getf (list \"x\" 42 \"y\" 99) \"x\")")
-(epoch 98)
-(eval "(cl-adjoin 0 (list 1 2))")
-(epoch 99)
-(eval "(cl-adjoin 1 (list 1 2))")
-(epoch 100)
-(eval "(cl-member 2 (list 1 2 3))")
-(epoch 101)
-(eval "(cl-member 9 (list 1 2 3))")
-(epoch 102)
-(eval "(cl-flatten (list 1 (list 2 3) 4))")
-
-;; --- Radix ---
-(epoch 110)
-(eval "(cl-format-binary 10)")
-(epoch 111)
-(eval "(cl-format-octal 15)")
-(epoch 112)
-(eval "(cl-format-hex 255)")
-(epoch 113)
-(eval "(cl-format-decimal 42)")
-(epoch 114)
-(eval "(cl-integer-to-string 31 16)")
-(epoch 115)
-(eval "(cl-string-to-integer \"1f\" 16)")
-
-EPOCHS
-
-OUTPUT=$(timeout 30 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-check() {
-  local epoch="$1" desc="$2" expected="$3"
-  local actual
-  # ok-len format: value appears on the line AFTER "(ok-len N length)"
-  actual=$(echo "$OUTPUT" | grep -A1 "^(ok-len $epoch " | tail -1 || true)
-  # strip any leading "(ok-len ...)" if grep -A1 returned it instead
-  if echo "$actual" | grep -q "^(ok-len"; then actual=""; fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(ok $epoch " | head -1 || true)
-  fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(error $epoch " | head -1 || true)
-  fi
-  [ -z "$actual" ] && actual="<no output for epoch $epoch>"
-
-  if echo "$actual" | grep -qF -- "$expected"; then
-    PASS=$((PASS+1))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $desc"
-  else
-    FAIL=$((FAIL+1))
-    ERRORS+="  FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual
-"
-  fi
-}
-
-# Type predicates
-check 10  "cl-null? nil"           "true"
-check 11  "cl-null? false"         "false"
-check 12  "cl-consp? pair"         "true"
-check 13  "cl-consp? nil"          "false"
-check 14  "cl-listp? nil"          "true"
-check 15  "cl-listp? list"         "true"
-check 16  "cl-atom? nil"           "true"
-check 17  "cl-atom? pair"          "false"
-check 18  "cl-integerp?"           "true"
-check 19  "cl-floatp?"             "true"
-check 20  "cl-characterp?"         "true"
-check 21  "cl-stringp?"            "true"
-
-# Arithmetic
-check 30  "cl-mod 10 3"            "1"
-check 31  "cl-rem 10 3"            "1"
-check 32  "cl-quotient 10 3"       "3"
-check 33  "cl-gcd 12 8"            "4"
-check 34  "cl-lcm 4 6"             "12"
-check 35  "cl-abs -5"              "5"
-check 36  "cl-abs 5"               "5"
-check 37  "cl-min 2 7"             "2"
-check 38  "cl-max 2 7"             "7"
-check 39  "cl-evenp? 4"            "true"
-check 40  "cl-evenp? 3"            "false"
-check 41  "cl-oddp? 7"             "true"
-check 42  "cl-zerop? 0"            "true"
-check 43  "cl-plusp? 1"            "true"
-check 44  "cl-minusp? -1"          "true"
-check 45  "cl-signum pos"          "1"
-check 46  "cl-signum neg"          "-1"
-check 47  "cl-signum zero"         "0"
-
-# Characters
-check 50  "cl-char-code"           "65"
-check 51  "code-char returns char" "true"
-check 52  "cl-char=?"              "true"
-check 53  "cl-char<?"              "true"
-check 54  "cl-char-space code"     "32"
-check 55  "cl-char-newline code"   "10"
-check 56  "cl-alpha-char-p A"      "true"
-check 57  "cl-digit-char-p 0"      "true"
-
-# Format
-check 60  "cl-format plain"        '"hello"'
-check 61  "cl-format ~a"           '"world"'
-check 62  "cl-format ~d"           '"42"'
-check 63  "cl-format ~x"           '"ff"'
-check 64  "cl-format multi"        '"x=3 y=4"'
-
-# Gensym
-check 70  "gensym returns symbol"  "true"
-check 71  "gensyms are unique"     "true"
-
-# Sets
-check 80  "make-set is set?"       "true"
-check 81  "set-add + member"       "true"
-check 82  "member in empty"        "false"
-check 83  "list->set member"       "true"
-
-# Lists
-check 90  "cl-nth 0"               "1"
-check 91  "cl-nth 2"               "3"
-check 92  "cl-last"                "(3)"
-check 93  "cl-butlast"             "(1 2)"
-check 94  "cl-nthcdr 1"            "(2 3)"
-check 95  "cl-assoc hit"           '("b" 2)'
-check 96  "cl-assoc miss"          "nil"
-check 97  "cl-getf hit"            "42"
-check 98  "cl-adjoin new"          "(0 1 2)"
-check 99  "cl-adjoin dup"          "(1 2)"
-check 100 "cl-member hit"          "(2 3)"
-check 101 "cl-member miss"         "nil"
-check 102 "cl-flatten"             "(1 2 3 4)"
-
-# Radix
-check 110 "cl-format-binary 10"    '"1010"'
-check 111 "cl-format-octal 15"     '"17"'
-check 112 "cl-format-hex 255"      '"ff"'
-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"
-else
-  echo "FAIL $PASS/$TOTAL passed, $FAIL failed:"
-  echo "$ERRORS"
-fi
-[ $FAIL -eq 0 ]

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/erlang/bench_ring.sh

@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-# Erlang-on-SX ring benchmark.
-#
-# Spawns N processes in a ring, passes a token N hops (one full round),
-# and reports wall-clock time + throughput. Aspirational target from
-# the plan is 1M processes; current sync-scheduler architecture caps out
-# orders of magnitude lower — this script measures honestly across a
-# range of N so the result/scaling is recorded.
-#
-# Usage:
-#   bash lib/erlang/bench_ring.sh                # default ladder
-#   bash lib/erlang/bench_ring.sh 100 1000 5000  # custom Ns
-
-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." >&2
-  exit 1
-fi
-
-if [ "$#" -gt 0 ]; then
-  NS=("$@")
-else
-  NS=(10 100 500 1000)
-fi
-
-TMPFILE=$(mktemp)
-trap "rm -f $TMPFILE" EXIT
-
-# One-line Erlang program. Replaces __N__ with the size for each run.
-PROGRAM='Me = self(), N = __N__, Spawner = fun () -> receive {setup, Next} -> Loop = fun () -> receive {token, 0, Parent} -> Parent ! done; {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop() end end, Loop() end end, BuildRing = fun (K, Acc) -> if K =:= 0 -> Acc; true -> BuildRing(K-1, [spawn(Spawner) | Acc]) end end, Pids = BuildRing(N, []), Wire = fun (Ps) -> case Ps of [P, Q | _] -> P ! {setup, Q}, Wire(tl(Ps)); [Last] -> Last ! {setup, hd(Pids)} end end, Wire(Pids), hd(Pids) ! {token, N, Me}, receive done -> done end'
-
-run_n() {
-  local n="$1"
-  local prog="${PROGRAM//__N__/$n}"
-  cat > "$TMPFILE" <<EPOCHS
-(epoch 1)
-(load "lib/erlang/tokenizer.sx")
-(load "lib/erlang/parser.sx")
-(load "lib/erlang/parser-core.sx")
-(load "lib/erlang/parser-expr.sx")
-(load "lib/erlang/parser-module.sx")
-(load "lib/erlang/transpile.sx")
-(load "lib/erlang/runtime.sx")
-(epoch 2)
-(eval "(erlang-eval-ast \"${prog//\"/\\\"}\")")
-EPOCHS
-
-  local start_s start_ns end_s end_ns elapsed_ms
-  start_s=$(date +%s)
-  start_ns=$(date +%N)
-  out=$(timeout 300 "$SX_SERVER" < "$TMPFILE" 2>&1)
-  end_s=$(date +%s)
-  end_ns=$(date +%N)
-
-  local ok="false"
-  if echo "$out" | grep -q ':name "done"'; then ok="true"; fi
-
-  # ms = (end_s - start_s)*1000 + (end_ns - start_ns)/1e6
-  elapsed_ms=$(awk -v s1="$start_s" -v n1="$start_ns" -v s2="$end_s" -v n2="$end_ns" \
-    'BEGIN { printf "%d", (s2 - s1) * 1000 + (n2 - n1) / 1000000 }')
-
-  if [ "$ok" = "true" ]; then
-    local hops_per_s
-    hops_per_s=$(awk -v n="$n" -v ms="$elapsed_ms" \
-      'BEGIN { if (ms == 0) ms = 1; printf "%.0f", n * 1000 / ms }')
-    printf "  N=%-8s  hops=%-8s  %sms  (%s hops/s)\n" "$n" "$n" "$elapsed_ms" "$hops_per_s"
-  else
-    printf "  N=%-8s  FAILED  %sms\n" "$n" "$elapsed_ms"
-  fi
-}
-
-echo "Ring benchmark — sx_server.exe (synchronous scheduler)"
-echo
-for n in "${NS[@]}"; do
-  run_n "$n"
-done
-echo
-echo "Note: 1M-process target from the plan is aspirational; the synchronous"
-echo "scheduler with shift-based suspension and dict-based env copies is not"
-echo "engineered for that scale. Numbers above are honest baselines."

lib/erlang/bench_ring_results.md

@@ -1,35 +0,0 @@
-# Ring Benchmark Results
-
-Generated by `lib/erlang/bench_ring.sh` against `sx_server.exe` on the
-synchronous Erlang-on-SX scheduler.
-
-| N (processes) | Hops | Wall-clock | Throughput |
-|---|---|---|---|
-| 10 | 10 | 907ms | 11 hops/s |
-| 50 | 50 | 2107ms | 24 hops/s |
-| 100 | 100 | 3827ms | 26 hops/s |
-| 500 | 500 | 17004ms | 29 hops/s |
-| 1000 | 1000 | 29832ms | 34 hops/s |
-
-(Each `Nm` row spawns N processes connected in a ring and passes a
-single token N hops total — i.e. the token completes one full lap.)
-
-## Status of the 1M-process target
-
-Phase 3's stretch goal in `plans/erlang-on-sx.md` is a million-process
-ring benchmark. **That target is not met** in the current synchronous
-scheduler; extrapolating from the table above, 1M hops would take
-~30 000 s. Correctness is fine — the program runs at every measured
-size — but throughput is bound by per-hop overhead.
-
-Per-hop cost is dominated by:
-- `er-env-copy` per fun clause attempt (whole-dict copy each time)
-- `call/cc` capture + `raise`/`guard` unwind on every `receive`
-- `er-q-delete-at!` rebuilds the mailbox backing list on every match
-- `dict-set!`/`dict-has?` lookups in the global processes table
-
-To reach 1M-process throughput in this architecture would need at
-least: persistent (path-copying) envs, an inline scheduler that
-doesn't call/cc on the common path (msg-already-in-mailbox), and a
-linked-list mailbox. None of those are in scope for the Phase 3
-checkbox — captured here as the floor we're starting from.

lib/erlang/conformance.sh

@@ -1,153 +0,0 @@
-#!/usr/bin/env bash
-# Erlang-on-SX conformance runner.
-#
-# Loads every erlang test suite via the epoch protocol, collects
-# pass/fail counts, and writes lib/erlang/scoreboard.json + .md.
-#
-# Usage:
-#   bash lib/erlang/conformance.sh           # run all suites
-#   bash lib/erlang/conformance.sh -v        # verbose per-suite
-
-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." >&2
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-TMPFILE=$(mktemp)
-OUTFILE=$(mktemp)
-trap "rm -f $TMPFILE $OUTFILE" EXIT
-
-# Each suite: name | counter pass | counter total
-SUITES=(
-  "tokenize|er-test-pass|er-test-count"
-  "parse|er-parse-test-pass|er-parse-test-count"
-  "eval|er-eval-test-pass|er-eval-test-count"
-  "runtime|er-rt-test-pass|er-rt-test-count"
-  "ring|er-ring-test-pass|er-ring-test-count"
-  "ping-pong|er-pp-test-pass|er-pp-test-count"
-  "bank|er-bank-test-pass|er-bank-test-count"
-  "echo|er-echo-test-pass|er-echo-test-count"
-  "fib|er-fib-test-pass|er-fib-test-count"
-)
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/erlang/tokenizer.sx")
-(load "lib/erlang/parser.sx")
-(load "lib/erlang/parser-core.sx")
-(load "lib/erlang/parser-expr.sx")
-(load "lib/erlang/parser-module.sx")
-(load "lib/erlang/transpile.sx")
-(load "lib/erlang/runtime.sx")
-(load "lib/erlang/tests/tokenize.sx")
-(load "lib/erlang/tests/parse.sx")
-(load "lib/erlang/tests/eval.sx")
-(load "lib/erlang/tests/runtime.sx")
-(load "lib/erlang/tests/programs/ring.sx")
-(load "lib/erlang/tests/programs/ping_pong.sx")
-(load "lib/erlang/tests/programs/bank.sx")
-(load "lib/erlang/tests/programs/echo.sx")
-(load "lib/erlang/tests/programs/fib_server.sx")
-(epoch 100)
-(eval "(list er-test-pass er-test-count)")
-(epoch 101)
-(eval "(list er-parse-test-pass er-parse-test-count)")
-(epoch 102)
-(eval "(list er-eval-test-pass er-eval-test-count)")
-(epoch 103)
-(eval "(list er-rt-test-pass er-rt-test-count)")
-(epoch 104)
-(eval "(list er-ring-test-pass er-ring-test-count)")
-(epoch 105)
-(eval "(list er-pp-test-pass er-pp-test-count)")
-(epoch 106)
-(eval "(list er-bank-test-pass er-bank-test-count)")
-(epoch 107)
-(eval "(list er-echo-test-pass er-echo-test-count)")
-(epoch 108)
-(eval "(list er-fib-test-pass er-fib-test-count)")
-EPOCHS
-
-timeout 120 "$SX_SERVER" < "$TMPFILE" > "$OUTFILE" 2>&1
-
-# Parse "(N M)" from the line after each "(ok-len <epoch> ...)" marker.
-parse_pair() {
-  local epoch="$1"
-  local line
-  line=$(grep -A1 "^(ok-len $epoch " "$OUTFILE" | tail -1)
-  echo "$line" | sed -E 's/[()]//g'
-}
-
-TOTAL_PASS=0
-TOTAL_COUNT=0
-JSON_SUITES=""
-MD_ROWS=""
-
-idx=0
-for entry in "${SUITES[@]}"; do
-  name="${entry%%|*}"
-  epoch=$((100 + idx))
-  pair=$(parse_pair "$epoch")
-  pass=$(echo "$pair" | awk '{print $1}')
-  count=$(echo "$pair" | awk '{print $2}')
-  if [ -z "$pass" ] || [ -z "$count" ]; then
-    pass=0
-    count=0
-  fi
-  TOTAL_PASS=$((TOTAL_PASS + pass))
-  TOTAL_COUNT=$((TOTAL_COUNT + count))
-  status="ok"
-  marker="✅"
-  if [ "$pass" != "$count" ]; then
-    status="fail"
-    marker="❌"
-  fi
-  if [ "$VERBOSE" = "-v" ]; then
-    printf "  %-12s %s/%s\n" "$name" "$pass" "$count"
-  fi
-  if [ -n "$JSON_SUITES" ]; then JSON_SUITES+=","; fi
-  JSON_SUITES+=$'\n    '
-  JSON_SUITES+="{\"name\":\"$name\",\"pass\":$pass,\"total\":$count,\"status\":\"$status\"}"
-  MD_ROWS+="| $marker | $name | $pass | $count |"$'\n'
-  idx=$((idx + 1))
-done
-
-printf '\nErlang-on-SX conformance: %d / %d\n' "$TOTAL_PASS" "$TOTAL_COUNT"
-
-# scoreboard.json
-cat > lib/erlang/scoreboard.json <<JSON
-{
-  "language": "erlang",
-  "total_pass": $TOTAL_PASS,
-  "total": $TOTAL_COUNT,
-  "suites": [$JSON_SUITES
-  ]
-}
-JSON
-
-# scoreboard.md
-cat > lib/erlang/scoreboard.md <<MD
-# Erlang-on-SX Scoreboard
-
-**Total: ${TOTAL_PASS} / ${TOTAL_COUNT} tests passing**
-
-|  | Suite | Pass | Total |
-|---|---|---|---|
-$MD_ROWS
-
-Generated by \`lib/erlang/conformance.sh\`.
-MD
-
-if [ "$TOTAL_PASS" -eq "$TOTAL_COUNT" ]; then
-  exit 0
-else
-  exit 1
-fi

lib/erlang/parser-expr.sx

@@ -237,8 +237,6 @@
         (er-parse-fun-expr st)
         (er-is? st "keyword" "try")
         (er-parse-try st)
-        (er-is? st "punct" "<<")
-        (er-parse-binary st)
         :else (error
           (str
             "Erlang parse: unexpected "
@@ -283,56 +281,12 @@
   (fn
     (st)
     (er-expect! st "punct" "[")
-    (cond
+    (if
       (er-is? st "punct" "]")
       (do (er-advance! st) {:type "nil"})
-      :else (let
-        ((first (er-parse-expr-prec st 0)))
-        (cond
-          (er-is? st "punct" "||") (er-parse-list-comp st first)
-          :else (er-parse-list-tail st (list first)))))))
-
-(define
-  er-parse-list-comp
-  (fn
-    (st head)
-    (er-advance! st)
-    (let
-      ((quals (list (er-parse-lc-qualifier st))))
-      (er-parse-list-comp-tail st head quals))))
-
-(define
-  er-parse-list-comp-tail
-  (fn
-    (st head quals)
-    (cond
-      (er-is? st "punct" ",")
-      (do
-        (er-advance! st)
-        (append! quals (er-parse-lc-qualifier st))
-        (er-parse-list-comp-tail st head quals))
-      (er-is? st "punct" "]")
-      (do (er-advance! st) {:head head :qualifiers quals :type "lc"})
-      :else (error
-        (str
-          "Erlang parse: expected ',' or ']' in list comprehension, got '"
-          (er-cur-value st)
-          "'")))))
-
-(define
-  er-parse-lc-qualifier
-  (fn
-    (st)
-    (let
-      ((e (er-parse-expr-prec st 0)))
-      (cond
-        (er-is? st "punct" "<-")
-        (do
-          (er-advance! st)
-          (let
-            ((source (er-parse-expr-prec st 0)))
-            {:kind "gen" :pattern e :source source}))
-        :else {:kind "filter" :expr e}))))
+      (let
+        ((elems (list (er-parse-expr-prec st 0))))
+        (er-parse-list-tail st elems)))))
 
 (define
   er-parse-list-tail
@@ -578,63 +532,3 @@
           ((guards (if (er-is? st "keyword" "when") (do (er-advance! st) (er-parse-guards st)) (list))))
           (er-expect! st "punct" "->")
           (let ((body (er-parse-body st))) {:pattern pat :body body :class klass :guards guards}))))))
-
-;; ── binary literals / patterns ────────────────────────────────
-;; `<< [Seg {, Seg}] >>` where Seg = Value [: Size] [/ Spec]. Size is
-;; a literal integer (multiple of 8 supported); Spec is `integer`
-;; (default) or `binary` (rest-of-binary tail). Sufficient for the
-;; common `<<A:8, B:16, Rest/binary>>` patterns.
-(define
-  er-parse-binary
-  (fn
-    (st)
-    (er-expect! st "punct" "<<")
-    (cond
-      (er-is? st "punct" ">>")
-      (do (er-advance! st) {:segments (list) :type "binary"})
-      :else (let
-        ((segs (list (er-parse-binary-segment st))))
-        (er-parse-binary-tail st segs)))))
-
-(define
-  er-parse-binary-tail
-  (fn
-    (st segs)
-    (cond
-      (er-is? st "punct" ",")
-      (do
-        (er-advance! st)
-        (append! segs (er-parse-binary-segment st))
-        (er-parse-binary-tail st segs))
-      (er-is? st "punct" ">>")
-      (do (er-advance! st) {:segments segs :type "binary"})
-      :else (error
-        (str
-          "Erlang parse: expected ',' or '>>' in binary, got '"
-          (er-cur-value st)
-          "'")))))
-
-(define
-  er-parse-binary-segment
-  (fn
-    (st)
-    ;; Use `er-parse-primary` for the value so a leading `:` falls
-    ;; through to the segment's size suffix instead of being eaten
-    ;; by `er-parse-postfix-loop` as a `Mod:Fun` remote call.
-    (let
-      ((v (er-parse-primary st)))
-      (let
-        ((size (cond
-                 (er-is? st "punct" ":")
-                 (do (er-advance! st) (er-parse-primary st))
-                 :else nil))
-          (spec (cond
-                  (er-is? st "op" "/")
-                  (do
-                    (er-advance! st)
-                    (let
-                      ((tok (er-cur st)))
-                      (er-advance! st)
-                      (get tok :value)))
-                  :else "integer")))
-        {:size size :spec spec :value v}))))

lib/erlang/scoreboard.json

@@ -1,16 +0,0 @@
-{
-  "language": "erlang",
-  "total_pass": 530,
-  "total": 530,
-  "suites": [
-    {"name":"tokenize","pass":62,"total":62,"status":"ok"},
-    {"name":"parse","pass":52,"total":52,"status":"ok"},
-    {"name":"eval","pass":346,"total":346,"status":"ok"},
-    {"name":"runtime","pass":39,"total":39,"status":"ok"},
-    {"name":"ring","pass":4,"total":4,"status":"ok"},
-    {"name":"ping-pong","pass":4,"total":4,"status":"ok"},
-    {"name":"bank","pass":8,"total":8,"status":"ok"},
-    {"name":"echo","pass":7,"total":7,"status":"ok"},
-    {"name":"fib","pass":8,"total":8,"status":"ok"}
-  ]
-}

lib/erlang/scoreboard.md

@@ -1,18 +0,0 @@
-# Erlang-on-SX Scoreboard
-
-**Total: 530 / 530 tests passing**
-
-|  | Suite | Pass | Total |
-|---|---|---|---|
-| ✅ | tokenize | 62 | 62 |
-| ✅ | parse | 52 | 52 |
-| ✅ | eval | 346 | 346 |
-| ✅ | runtime | 39 | 39 |
-| ✅ | ring | 4 | 4 |
-| ✅ | ping-pong | 4 | 4 |
-| ✅ | bank | 8 | 8 |
-| ✅ | echo | 7 | 7 |
-| ✅ | fib | 8 | 8 |
-
-
-Generated by `lib/erlang/conformance.sh`.

lib/erlang/test.sh

@@ -1,260 +0,0 @@
-#!/usr/bin/env bash
-# lib/erlang/test.sh — smoke-test the Erlang runtime layer.
-# Uses sx_server.exe epoch protocol.
-#
-# Usage:
-#   bash lib/erlang/test.sh
-#   bash lib/erlang/test.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. Run: cd hosts/ocaml && dune build"
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-PASS=0; FAIL=0; ERRORS=""
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/erlang/runtime.sx")
-
-;; --- Numeric tower ---
-(epoch 10)
-(eval "(er-is-integer? 42)")
-(epoch 11)
-(eval "(er-is-integer? 3.14)")
-(epoch 12)
-(eval "(er-is-float? 3.14)")
-(epoch 13)
-(eval "(er-is-float? 42)")
-(epoch 14)
-(eval "(er-is-number? 42)")
-(epoch 15)
-(eval "(er-is-number? 3.14)")
-(epoch 16)
-(eval "(er-float 5)")
-(epoch 17)
-(eval "(er-trunc 3.9)")
-(epoch 18)
-(eval "(er-round 3.5)")
-(epoch 19)
-(eval "(er-abs -7)")
-(epoch 20)
-(eval "(er-max 3 7)")
-(epoch 21)
-(eval "(er-min 3 7)")
-
-;; --- div + rem ---
-(epoch 30)
-(eval "(er-div 10 3)")
-(epoch 31)
-(eval "(er-div -10 3)")
-(epoch 32)
-(eval "(er-rem 10 3)")
-(epoch 33)
-(eval "(er-rem -10 3)")
-(epoch 34)
-(eval "(er-gcd 12 8)")
-
-;; --- Bitwise ---
-(epoch 40)
-(eval "(er-band 12 10)")
-(epoch 41)
-(eval "(er-bor 12 10)")
-(epoch 42)
-(eval "(er-bxor 12 10)")
-(epoch 43)
-(eval "(er-bnot 0)")
-(epoch 44)
-(eval "(er-bsl 1 4)")
-(epoch 45)
-(eval "(er-bsr 16 2)")
-
-;; --- Sets ---
-(epoch 50)
-(eval "(er-sets-is-set? (er-sets-new))")
-(epoch 51)
-(eval "(let ((s (er-sets-new))) (do (er-sets-add-element s 1) (er-sets-is-element s 1)))")
-(epoch 52)
-(eval "(er-sets-is-element (er-sets-new) 42)")
-(epoch 53)
-(eval "(er-sets-is-element (er-sets-from-list (list 1 2 3)) 2)")
-(epoch 54)
-(eval "(er-sets-size (er-sets-from-list (list 1 2 3)))")
-(epoch 55)
-(eval "(len (er-sets-to-list (er-sets-from-list (list 1 2 3))))")
-
-;; --- Regexp ---
-(epoch 60)
-(eval "(not (= (er-re-run \"hello\" \"ll\") nil))")
-(epoch 61)
-(eval "(= (er-re-run \"hello\" \"xyz\") nil)")
-(epoch 62)
-(eval "(get (er-re-run \"hello\" \"ll\") :match)")
-(epoch 63)
-(eval "(er-re-replace \"hello\" \"l\" \"r\")")
-(epoch 64)
-(eval "(er-re-replace-all \"hello\" \"l\" \"r\")")
-(epoch 65)
-(eval "(er-re-match-groups (er-re-run \"hello world\" \"(\\w+)\\s+(\\w+)\"))")
-(epoch 66)
-(eval "(len (er-re-split \"a,b,c\" \",\"))")
-
-;; --- List BIFs ---
-(epoch 70)
-(eval "(er-hd (list 1 2 3))")
-(epoch 71)
-(eval "(er-tl (list 1 2 3))")
-(epoch 72)
-(eval "(er-length (list 1 2 3))")
-(epoch 73)
-(eval "(er-lists-member 2 (list 1 2 3))")
-(epoch 74)
-(eval "(er-lists-member 9 (list 1 2 3))")
-(epoch 75)
-(eval "(er-lists-reverse (list 1 2 3))")
-(epoch 76)
-(eval "(er-lists-nth 2 (list 10 20 30))")
-(epoch 77)
-(eval "(er-lists-foldl + 0 (list 1 2 3 4 5))")
-(epoch 78)
-(eval "(er-lists-seq 1 5)")
-(epoch 79)
-(eval "(er-lists-flatten (list 1 (list 2 3) (list 4 (list 5))))")
-
-;; --- Type conversions ---
-(epoch 80)
-(eval "(er-integer-to-list 42)")
-(epoch 81)
-(eval "(er-list-to-integer \"42\")")
-(epoch 82)
-(eval "(er-integer-to-list-radix 255 16)")
-(epoch 83)
-(eval "(er-atom-to-list (make-symbol \"hello\"))")
-(epoch 84)
-(eval "(= (type-of (er-list-to-atom \"foo\")) \"symbol\")")
-
-;; --- ok/error tuples ---
-(epoch 90)
-(eval "(er-is-ok? (er-ok 42))")
-(epoch 91)
-(eval "(er-is-error? (er-error \"reason\"))")
-(epoch 92)
-(eval "(er-unwrap (er-ok 42))")
-(epoch 93)
-(eval "(er-is-ok? (er-error \"bad\"))")
-
-EPOCHS
-
-OUTPUT=$(timeout 30 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-check() {
-  local epoch="$1" desc="$2" expected="$3"
-  local actual
-  actual=$(echo "$OUTPUT" | grep -A1 "^(ok-len $epoch " | tail -1 || true)
-  if echo "$actual" | grep -q "^(ok-len"; then actual=""; fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(ok $epoch " | head -1 || true)
-  fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(error $epoch " | head -1 || true)
-  fi
-  [ -z "$actual" ] && actual="<no output for epoch $epoch>"
-
-  if echo "$actual" | grep -qF -- "$expected"; then
-    PASS=$((PASS+1))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $desc"
-  else
-    FAIL=$((FAIL+1))
-    ERRORS+="  FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual
-"
-  fi
-}
-
-# Numeric tower
-check 10  "is-integer? 42"        "true"
-check 11  "is-integer? float"     "false"
-check 12  "is-float? 3.14"        "true"
-check 13  "is-float? int"         "false"
-check 14  "is-number? int"        "true"
-check 15  "is-number? float"      "true"
-check 16  "float 5"               "5"
-check 17  "trunc 3.9"             "3"
-check 18  "round 3.5"             "4"
-check 19  "abs -7"                "7"
-check 20  "max 3 7"               "7"
-check 21  "min 3 7"               "3"
-
-# div + rem
-check 30  "div 10 3"              "3"
-check 31  "div -10 3"             "-3"
-check 32  "rem 10 3"              "1"
-check 33  "rem -10 3"             "-1"
-check 34  "gcd 12 8"              "4"
-
-# Bitwise
-check 40  "band 12 10"            "8"
-check 41  "bor 12 10"             "14"
-check 42  "bxor 12 10"            "6"
-check 43  "bnot 0"                "-1"
-check 44  "bsl 1 4"               "16"
-check 45  "bsr 16 2"              "4"
-
-# Sets
-check 50  "sets-new is-set?"      "true"
-check 51  "sets add+member"       "true"
-check 52  "member empty"          "false"
-check 53  "from-list member"      "true"
-check 54  "sets-size"             "3"
-check 55  "sets-to-list len"      "3"
-
-# Regexp
-check 60  "re-run match"          "true"
-check 61  "re-run no match"       "true"
-check 62  "re-run match text"     '"ll"'
-check 63  "re-replace first"      '"herlo"'
-check 64  "re-replace-all"        '"herro"'
-check 65  "re-match-groups"       '"hello"'
-check 66  "re-split count"        "3"
-
-# List BIFs
-check 70  "hd"                    "1"
-check 71  "tl"                    "(2 3)"
-check 72  "length"                "3"
-check 73  "member hit"            "true"
-check 74  "member miss"           "false"
-check 75  "reverse"               "(3 2 1)"
-check 76  "nth 2"                 "20"
-check 77  "foldl sum"             "15"
-check 78  "seq 1..5"              "(1 2 3 4 5)"
-check 79  "flatten"               "(1 2 3 4 5)"
-
-# Type conversions
-check 80  "integer-to-list"       '"42"'
-check 81  "list-to-integer"       "42"
-check 82  "integer-to-list hex"   '"ff"'
-check 83  "atom-to-list"          '"hello"'
-check 84  "list-to-atom"          "true"
-
-# ok/error
-check 90  "ok? ok-tuple"          "true"
-check 91  "error? error-tuple"    "true"
-check 92  "unwrap ok"             "42"
-check 93  "ok? error-tuple"       "false"
-
-TOTAL=$((PASS+FAIL))
-if [ $FAIL -eq 0 ]; then
-  echo "ok $PASS/$TOTAL lib/erlang tests passed"
-else
-  echo "FAIL $PASS/$TOTAL passed, $FAIL failed:"
-  echo "$ERRORS"
-fi
-[ $FAIL -eq 0 ]

lib/erlang/tests/programs/bank.sx

@@ -1,159 +0,0 @@
-;; Bank account server — stateful process, balance threaded through
-;; recursive loop. Handles {deposit, Amt, From}, {withdraw, Amt, From},
-;; {balance, From}, stop. Tests stateful process patterns.
-
-(define er-bank-test-count 0)
-(define er-bank-test-pass 0)
-(define er-bank-test-fails (list))
-
-(define
-  er-bank-test
-  (fn
-    (name actual expected)
-    (set! er-bank-test-count (+ er-bank-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-bank-test-pass (+ er-bank-test-pass 1))
-      (append! er-bank-test-fails {:actual actual :expected expected :name name}))))
-
-(define bank-ev erlang-eval-ast)
-
-;; Server fun shared by all tests — threaded via the program string.
-(define
-  er-bank-server-src
-  "Server = fun (Balance) ->
-     receive
-       {deposit, Amt, From} -> From ! ok, Server(Balance + Amt);
-       {withdraw, Amt, From} ->
-         if Amt > Balance -> From ! insufficient, Server(Balance);
-            true -> From ! ok, Server(Balance - Amt)
-         end;
-       {balance, From} -> From ! Balance, Server(Balance);
-       stop -> ok
-     end
-   end")
-
-;; Open account, deposit, check balance.
-(er-bank-test
-  "deposit 100 -> balance 100"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(0) end),
-       Bank ! {deposit, 100, Me},
-       receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  100)
-
-;; Multiple deposits accumulate.
-(er-bank-test
-  "deposits accumulate"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(0) end),
-       Bank ! {deposit, 50, Me}, receive ok -> ok end,
-       Bank ! {deposit, 25, Me}, receive ok -> ok end,
-       Bank ! {deposit, 10, Me}, receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  85)
-
-;; Withdraw within balance succeeds; insufficient gets rejected.
-(er-bank-test
-  "withdraw within balance"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(100) end),
-       Bank ! {withdraw, 30, Me}, receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  70)
-
-(er-bank-test
-  "withdraw insufficient"
-  (get
-    (bank-ev
-      (str
-        er-bank-server-src
-        ", Me = self(),
-         Bank = spawn(fun () -> Server(20) end),
-         Bank ! {withdraw, 100, Me},
-         receive R -> Bank ! stop, R end"))
-    :name)
-  "insufficient")
-
-;; State preserved across an insufficient withdrawal.
-(er-bank-test
-  "state preserved on rejection"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(50) end),
-       Bank ! {withdraw, 1000, Me}, receive _ -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  50)
-
-;; Mixed deposits and withdrawals.
-(er-bank-test
-  "mixed transactions"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(100) end),
-       Bank ! {deposit, 50, Me}, receive ok -> ok end,
-       Bank ! {withdraw, 30, Me}, receive ok -> ok end,
-       Bank ! {deposit, 10, Me}, receive ok -> ok end,
-       Bank ! {withdraw, 5, Me}, receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  125)
-
-;; Server.stop terminates the bank cleanly — main can verify by
-;; sending stop and then exiting normally.
-(er-bank-test
-  "server stops cleanly"
-  (get
-    (bank-ev
-      (str
-        er-bank-server-src
-        ", Me = self(),
-         Bank = spawn(fun () -> Server(0) end),
-         Bank ! stop,
-         done"))
-    :name)
-  "done")
-
-;; Two clients sharing one bank — interleaved transactions.
-(er-bank-test
-  "two clients share bank"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(0) end),
-       Client = fun (Amt) ->
-         spawn(fun () ->
-           Bank ! {deposit, Amt, self()},
-           receive ok -> Me ! deposited end
-         end)
-       end,
-       Client(40),
-       Client(60),
-       receive deposited -> ok end,
-       receive deposited -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  100)
-
-(define
-  er-bank-test-summary
-  (str "bank " er-bank-test-pass "/" er-bank-test-count))

lib/erlang/tests/programs/echo.sx

@@ -1,140 +0,0 @@
-;; Echo server — minimal classic Erlang server. Receives {From, Msg}
-;; and sends Msg back to From, then loops. `stop` ends the server.
-
-(define er-echo-test-count 0)
-(define er-echo-test-pass 0)
-(define er-echo-test-fails (list))
-
-(define
-  er-echo-test
-  (fn
-    (name actual expected)
-    (set! er-echo-test-count (+ er-echo-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-echo-test-pass (+ er-echo-test-pass 1))
-      (append! er-echo-test-fails {:actual actual :expected expected :name name}))))
-
-(define echo-ev erlang-eval-ast)
-
-(define
-  er-echo-server-src
-  "EchoSrv = fun () ->
-     Loop = fun () ->
-       receive
-         {From, Msg} -> From ! Msg, Loop();
-         stop -> ok
-       end
-     end,
-     Loop()
-   end")
-
-;; Single round-trip with an atom.
-(er-echo-test
-  "atom round-trip"
-  (get
-    (echo-ev
-      (str
-        er-echo-server-src
-        ", Me = self(),
-         Echo = spawn(EchoSrv),
-         Echo ! {Me, hello},
-         receive R -> Echo ! stop, R end"))
-    :name)
-  "hello")
-
-;; Number round-trip.
-(er-echo-test
-  "number round-trip"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, 42},
-       receive R -> Echo ! stop, R end"))
-  42)
-
-;; Tuple round-trip — pattern-match the reply to extract V.
-(er-echo-test
-  "tuple round-trip"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, {ok, 7}},
-       receive {ok, V} -> Echo ! stop, V end"))
-  7)
-
-;; List round-trip.
-(er-echo-test
-  "list round-trip"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, [1, 2, 3]},
-       receive [H | _] -> Echo ! stop, H end"))
-  1)
-
-;; Multiple sequential round-trips.
-(er-echo-test
-  "three round-trips"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, 10}, A = receive Ra -> Ra end,
-       Echo ! {Me, 20}, B = receive Rb -> Rb end,
-       Echo ! {Me, 30}, C = receive Rc -> Rc end,
-       Echo ! stop,
-       A + B + C"))
-  60)
-
-;; Two clients sharing one echo server. Each gets its own reply.
-(er-echo-test
-  "two clients"
-  (get
-    (echo-ev
-      (str
-        er-echo-server-src
-        ", Me = self(),
-         Echo = spawn(EchoSrv),
-         Client = fun (Tag) ->
-           spawn(fun () ->
-             Echo ! {self(), Tag},
-             receive R -> Me ! {got, R} end
-           end)
-         end,
-         Client(a),
-         Client(b),
-         receive {got, _} -> ok end,
-         receive {got, _} -> ok end,
-         Echo ! stop,
-         finished"))
-    :name)
-  "finished")
-
-;; Echo via io trace — verify each message round-trips through.
-(er-echo-test
-  "trace 4 messages"
-  (do
-    (er-io-flush!)
-    (echo-ev
-      (str
-        er-echo-server-src
-        ", Me = self(),
-         Echo = spawn(EchoSrv),
-         Send = fun (V) -> Echo ! {Me, V}, receive R -> io:format(\"~p \", [R]) end end,
-         Send(1), Send(2), Send(3), Send(4),
-         Echo ! stop,
-         done"))
-    (er-io-buffer-content))
-  "1 2 3 4 ")
-
-(define
-  er-echo-test-summary
-  (str "echo " er-echo-test-pass "/" er-echo-test-count))

lib/erlang/tests/programs/fib_server.sx

@@ -1,152 +0,0 @@
-;; Fib server — long-lived process that computes fibonacci numbers on
-;; request. Tests recursive function evaluation inside a server loop.
-
-(define er-fib-test-count 0)
-(define er-fib-test-pass 0)
-(define er-fib-test-fails (list))
-
-(define
-  er-fib-test
-  (fn
-    (name actual expected)
-    (set! er-fib-test-count (+ er-fib-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-fib-test-pass (+ er-fib-test-pass 1))
-      (append! er-fib-test-fails {:actual actual :expected expected :name name}))))
-
-(define fib-ev erlang-eval-ast)
-
-;; Fib + server-loop source. Standalone so each test can chain queries.
-(define
-  er-fib-server-src
-  "Fib = fun (0) -> 0; (1) -> 1; (N) -> Fib(N-1) + Fib(N-2) end,
-   FibSrv = fun () ->
-     Loop = fun () ->
-       receive
-         {fib, N, From} -> From ! Fib(N), Loop();
-         stop -> ok
-       end
-     end,
-     Loop()
-   end")
-
-;; Base cases.
-(er-fib-test
-  "fib(0)"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 0, Me},
-       receive R -> Srv ! stop, R end"))
-  0)
-
-(er-fib-test
-  "fib(1)"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 1, Me},
-       receive R -> Srv ! stop, R end"))
-  1)
-
-;; Larger values.
-(er-fib-test
-  "fib(10) = 55"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 10, Me},
-       receive R -> Srv ! stop, R end"))
-  55)
-
-(er-fib-test
-  "fib(15) = 610"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 15, Me},
-       receive R -> Srv ! stop, R end"))
-  610)
-
-;; Multiple sequential queries to one server. Sum to avoid dict-equality.
-(er-fib-test
-  "sequential fib(5..8) sum"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 5, Me}, A = receive Ra -> Ra end,
-       Srv ! {fib, 6, Me}, B = receive Rb -> Rb end,
-       Srv ! {fib, 7, Me}, C = receive Rc -> Rc end,
-       Srv ! {fib, 8, Me}, D = receive Rd -> Rd end,
-       Srv ! stop,
-       A + B + C + D"))
-  47)
-
-;; Verify Fib obeys the recurrence — fib(n) = fib(n-1) + fib(n-2).
-(er-fib-test
-  "fib recurrence at n=12"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 10, Me}, A = receive Ra -> Ra end,
-       Srv ! {fib, 11, Me}, B = receive Rb -> Rb end,
-       Srv ! {fib, 12, Me}, C = receive Rc -> Rc end,
-       Srv ! stop,
-       C - (A + B)"))
-  0)
-
-;; Two clients each get their own answer; main sums the results.
-(er-fib-test
-  "two clients sum"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Client = fun (N) ->
-         spawn(fun () ->
-           Srv ! {fib, N, self()},
-           receive R -> Me ! {result, R} end
-         end)
-       end,
-       Client(7),
-       Client(9),
-       {result, A} = receive M1 -> M1 end,
-       {result, B} = receive M2 -> M2 end,
-       Srv ! stop,
-       A + B"))
-  47)
-
-;; Trace queries via io-buffer.
-(er-fib-test
-  "trace fib 0..6"
-  (do
-    (er-io-flush!)
-    (fib-ev
-      (str
-        er-fib-server-src
-        ", Me = self(),
-         Srv = spawn(FibSrv),
-         Ask = fun (N) -> Srv ! {fib, N, Me}, receive R -> io:format(\"~p \", [R]) end end,
-         Ask(0), Ask(1), Ask(2), Ask(3), Ask(4), Ask(5), Ask(6),
-         Srv ! stop,
-         done"))
-    (er-io-buffer-content))
-  "0 1 1 2 3 5 8 ")
-
-(define
-  er-fib-test-summary
-  (str "fib " er-fib-test-pass "/" er-fib-test-count))

lib/erlang/tests/programs/ping_pong.sx

@@ -1,127 +0,0 @@
-;; Ping-pong program — two processes exchange N messages, then signal
-;; main via separate `ping_done` / `pong_done` notifications.
-
-(define er-pp-test-count 0)
-(define er-pp-test-pass 0)
-(define er-pp-test-fails (list))
-
-(define
-  er-pp-test
-  (fn
-    (name actual expected)
-    (set! er-pp-test-count (+ er-pp-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-pp-test-pass (+ er-pp-test-pass 1))
-      (append! er-pp-test-fails {:actual actual :expected expected :name name}))))
-
-(define pp-ev erlang-eval-ast)
-
-;; Three rounds of ping-pong, then stop. Main receives ping_done and
-;; pong_done in arrival order (Ping finishes first because Pong exits
-;; only after receiving stop).
-(define
-  er-pp-program
-  "Me = self(),
-   Pong = spawn(fun () ->
-     Loop = fun () ->
-       receive
-         {ping, From} -> From ! pong, Loop();
-         stop -> Me ! pong_done
-       end
-     end,
-     Loop()
-   end),
-   Ping = fun (Target, K) ->
-     if K =:= 0 -> Target ! stop, Me ! ping_done;
-        true -> Target ! {ping, self()}, receive pong -> Ping(Target, K - 1) end
-     end
-   end,
-   spawn(fun () -> Ping(Pong, 3) end),
-   receive ping_done -> ok end,
-   receive pong_done -> both_done end")
-
-(er-pp-test
-  "ping-pong 3 rounds"
-  (get (pp-ev er-pp-program) :name)
-  "both_done")
-
-;; Count exchanges via io-buffer — each pong trip prints "p".
-(er-pp-test
-  "ping-pong 5 rounds trace"
-  (do
-    (er-io-flush!)
-    (pp-ev
-      "Me = self(),
-       Pong = spawn(fun () ->
-         Loop = fun () ->
-           receive
-             {ping, From} -> io:format(\"p\"), From ! pong, Loop();
-             stop -> Me ! pong_done
-           end
-         end,
-         Loop()
-       end),
-       Ping = fun (Target, K) ->
-         if K =:= 0 -> Target ! stop, Me ! ping_done;
-            true -> Target ! {ping, self()}, receive pong -> Ping(Target, K - 1) end
-         end
-       end,
-       spawn(fun () -> Ping(Pong, 5) end),
-       receive ping_done -> ok end,
-       receive pong_done -> ok end")
-    (er-io-buffer-content))
-  "ppppp")
-
-;; Main → Pong directly (no Ping process). Main plays the ping role.
-(er-pp-test
-  "main-as-pinger 4 rounds"
-  (pp-ev
-    "Me = self(),
-     Pong = spawn(fun () ->
-       Loop = fun () ->
-         receive
-           {ping, From} -> From ! pong, Loop();
-           stop -> ok
-         end
-       end,
-       Loop()
-     end),
-     Go = fun (K) ->
-       if K =:= 0 -> Pong ! stop, K;
-          true -> Pong ! {ping, Me}, receive pong -> Go(K - 1) end
-       end
-     end,
-     Go(4)")
-  0)
-
-;; Ensure the processes really interleave — inject an id into each
-;; ping and check we get them all back via trace (the order is
-;; deterministic under our sync scheduler).
-(er-pp-test
-  "ids round-trip"
-  (do
-    (er-io-flush!)
-    (pp-ev
-      "Me = self(),
-       Pong = spawn(fun () ->
-         Loop = fun () ->
-           receive
-             {ping, From, Id} -> From ! {pong, Id}, Loop();
-             stop -> ok
-           end
-         end,
-         Loop()
-       end),
-       Go = fun (K) ->
-         if K =:= 0 -> Pong ! stop, done;
-            true -> Pong ! {ping, Me, K}, receive {pong, RId} -> io:format(\"~p \", [RId]), Go(K - 1) end
-         end
-       end,
-       Go(4)")
-    (er-io-buffer-content))
-  "4 3 2 1 ")
-
-(define
-  er-pp-test-summary
-  (str "ping-pong " er-pp-test-pass "/" er-pp-test-count))

lib/erlang/tests/programs/ring.sx

@@ -1,132 +0,0 @@
-;; Ring program — N processes in a ring, token passes M times.
-;;
-;; Each process waits for {setup, Next} so main can tie the knot
-;; (can't reference a pid before spawning it). Once wired, main
-;; injects the first token; each process forwards decrementing K
-;; until it hits 0, at which point it signals `done` to main.
-
-(define er-ring-test-count 0)
-(define er-ring-test-pass 0)
-(define er-ring-test-fails (list))
-
-(define
-  er-ring-test
-  (fn
-    (name actual expected)
-    (set! er-ring-test-count (+ er-ring-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-ring-test-pass (+ er-ring-test-pass 1))
-      (append! er-ring-test-fails {:actual actual :expected expected :name name}))))
-
-(define ring-ev erlang-eval-ast)
-
-(define
-  er-ring-program-3-6
-  "Me = self(),
-   Spawner = fun () ->
-     receive {setup, Next} ->
-       Loop = fun () ->
-         receive
-           {token, 0, Parent} -> Parent ! done;
-           {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
-         end
-       end,
-       Loop()
-     end
-   end,
-   P1 = spawn(Spawner),
-   P2 = spawn(Spawner),
-   P3 = spawn(Spawner),
-   P1 ! {setup, P2},
-   P2 ! {setup, P3},
-   P3 ! {setup, P1},
-   P1 ! {token, 5, Me},
-   receive done -> finished end")
-
-(er-ring-test
-  "ring N=3 M=6"
-  (get (ring-ev er-ring-program-3-6) :name)
-  "finished")
-
-;; Two-node ring — token bounces twice between P1 and P2.
-(er-ring-test
-  "ring N=2 M=4"
-  (get (ring-ev
-    "Me = self(),
-     Spawner = fun () ->
-       receive {setup, Next} ->
-         Loop = fun () ->
-           receive
-             {token, 0, Parent} -> Parent ! done;
-             {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
-           end
-         end,
-         Loop()
-       end
-     end,
-     P1 = spawn(Spawner),
-     P2 = spawn(Spawner),
-     P1 ! {setup, P2},
-     P2 ! {setup, P1},
-     P1 ! {token, 3, Me},
-     receive done -> done end") :name)
-  "done")
-
-;; Single-node "ring" — P sends to itself M times.
-(er-ring-test
-  "ring N=1 M=5"
-  (get (ring-ev
-    "Me = self(),
-     Spawner = fun () ->
-       receive {setup, Next} ->
-         Loop = fun () ->
-           receive
-             {token, 0, Parent} -> Parent ! finished_loop;
-             {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
-           end
-         end,
-         Loop()
-       end
-     end,
-     P = spawn(Spawner),
-     P ! {setup, P},
-     P ! {token, 4, Me},
-     receive finished_loop -> ok end") :name)
-  "ok")
-
-;; Confirm the token really went around — count hops via io-buffer.
-(er-ring-test
-  "ring N=3 M=9 hop count"
-  (do
-    (er-io-flush!)
-    (ring-ev
-      "Me = self(),
-       Spawner = fun () ->
-         receive {setup, Next} ->
-           Loop = fun () ->
-             receive
-               {token, 0, Parent} -> Parent ! done;
-               {token, K, Parent} ->
-                 io:format(\"~p \", [K]),
-                 Next ! {token, K-1, Parent},
-                 Loop()
-             end
-           end,
-           Loop()
-         end
-       end,
-       P1 = spawn(Spawner),
-       P2 = spawn(Spawner),
-       P3 = spawn(Spawner),
-       P1 ! {setup, P2},
-       P2 ! {setup, P3},
-       P3 ! {setup, P1},
-       P1 ! {token, 8, Me},
-       receive done -> done end")
-    (er-io-buffer-content))
-  "8 7 6 5 4 3 2 1 ")
-
-(define
-  er-ring-test-summary
-  (str "ring " er-ring-test-pass "/" er-ring-test-count))

lib/erlang/tests/runtime.sx

@@ -1,139 +0,0 @@
-;; Erlang runtime tests — scheduler + process-record primitives.
-
-(define er-rt-test-count 0)
-(define er-rt-test-pass 0)
-(define er-rt-test-fails (list))
-
-(define
-  er-rt-test
-  (fn
-    (name actual expected)
-    (set! er-rt-test-count (+ er-rt-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-rt-test-pass (+ er-rt-test-pass 1))
-      (append! er-rt-test-fails {:actual actual :expected expected :name name}))))
-
-;; ── queue ─────────────────────────────────────────────────────────
-(er-rt-test "queue empty len" (er-q-len (er-q-new)) 0)
-(er-rt-test "queue empty?" (er-q-empty? (er-q-new)) true)
-
-(define q1 (er-q-new))
-(er-q-push! q1 "a")
-(er-q-push! q1 "b")
-(er-q-push! q1 "c")
-(er-rt-test "queue push len" (er-q-len q1) 3)
-(er-rt-test "queue empty? after push" (er-q-empty? q1) false)
-(er-rt-test "queue peek" (er-q-peek q1) "a")
-(er-rt-test "queue pop 1" (er-q-pop! q1) "a")
-(er-rt-test "queue pop 2" (er-q-pop! q1) "b")
-(er-rt-test "queue len after pops" (er-q-len q1) 1)
-(er-rt-test "queue pop 3" (er-q-pop! q1) "c")
-(er-rt-test "queue empty again" (er-q-empty? q1) true)
-(er-rt-test "queue pop empty" (er-q-pop! q1) nil)
-
-;; Queue FIFO under interleaved push/pop
-(define q2 (er-q-new))
-(er-q-push! q2 1)
-(er-q-push! q2 2)
-(er-q-pop! q2)
-(er-q-push! q2 3)
-(er-rt-test "queue interleave peek" (er-q-peek q2) 2)
-(er-rt-test "queue to-list" (er-q-to-list q2) (list 2 3))
-
-;; ── scheduler init ─────────────────────────────────────────────
-(er-sched-init!)
-(er-rt-test "sched process count 0" (er-sched-process-count) 0)
-(er-rt-test "sched runnable count 0" (er-sched-runnable-count) 0)
-(er-rt-test "sched current nil" (er-sched-current-pid) nil)
-
-;; ── pid allocation ─────────────────────────────────────────────
-(define pa (er-pid-new!))
-(define pb (er-pid-new!))
-(er-rt-test "pid tag" (get pa :tag) "pid")
-(er-rt-test "pid ids distinct" (= (er-pid-id pa) (er-pid-id pb)) false)
-(er-rt-test "pid? true" (er-pid? pa) true)
-(er-rt-test "pid? false" (er-pid? 42) false)
-(er-rt-test
-  "pid-equal same"
-  (er-pid-equal? pa (er-mk-pid (er-pid-id pa)))
-  true)
-(er-rt-test "pid-equal diff" (er-pid-equal? pa pb) false)
-
-;; ── process lifecycle ──────────────────────────────────────────
-(er-sched-init!)
-(define p1 (er-proc-new! {}))
-(define p2 (er-proc-new! {}))
-(er-rt-test "proc count 2" (er-sched-process-count) 2)
-(er-rt-test "runnable count 2" (er-sched-runnable-count) 2)
-(er-rt-test
-  "proc state runnable"
-  (er-proc-field (get p1 :pid) :state)
-  "runnable")
-(er-rt-test
-  "proc mailbox empty"
-  (er-proc-mailbox-size (get p1 :pid))
-  0)
-(er-rt-test
-  "proc lookup"
-  (er-pid-equal? (get (er-proc-get (get p1 :pid)) :pid) (get p1 :pid))
-  true)
-(er-rt-test "proc exists" (er-proc-exists? (get p1 :pid)) true)
-(er-rt-test
-  "proc no-such-pid"
-  (er-proc-exists? (er-mk-pid 9999))
-  false)
-
-;; runnable queue dequeue order
-(er-rt-test
-  "dequeue first"
-  (er-pid-equal? (er-sched-next-runnable!) (get p1 :pid))
-  true)
-(er-rt-test
-  "dequeue second"
-  (er-pid-equal? (er-sched-next-runnable!) (get p2 :pid))
-  true)
-(er-rt-test "dequeue empty" (er-sched-next-runnable!) nil)
-
-;; current-pid get/set
-(er-sched-set-current! (get p1 :pid))
-(er-rt-test
-  "current pid set"
-  (er-pid-equal? (er-sched-current-pid) (get p1 :pid))
-  true)
-
-;; ── mailbox push ──────────────────────────────────────────────
-(er-proc-mailbox-push! (get p1 :pid) {:tag "atom" :name "ping"})
-(er-proc-mailbox-push! (get p1 :pid) 42)
-(er-rt-test "mailbox size 2" (er-proc-mailbox-size (get p1 :pid)) 2)
-
-;; ── field update ──────────────────────────────────────────────
-(er-proc-set! (get p1 :pid) :state "waiting")
-(er-rt-test
-  "proc state waiting"
-  (er-proc-field (get p1 :pid) :state)
-  "waiting")
-(er-proc-set! (get p1 :pid) :trap-exit true)
-(er-rt-test
-  "proc trap-exit"
-  (er-proc-field (get p1 :pid) :trap-exit)
-  true)
-
-;; ── fresh scheduler ends in clean state ───────────────────────
-(er-sched-init!)
-(er-rt-test
-  "sched init resets count"
-  (er-sched-process-count)
-  0)
-(er-rt-test
-  "sched init resets queue"
-  (er-sched-runnable-count)
-  0)
-(er-rt-test
-  "sched init resets current"
-  (er-sched-current-pid)
-  nil)
-
-(define
-  er-rt-test-summary
-  (str "runtime " er-rt-test-pass "/" er-rt-test-count))

lib/forth/runtime.sx

@@ -1,175 +1,433 @@
-;; lib/forth/runtime.sx — Forth primitives on SX
-;;
-;; Provides Forth-idiomatic wrappers over SX built-ins.
-;; Primitives used:
-;;   bitwise-and/or/xor/not/arithmetic-shift/bit-count (Phase 7)
-;;   make-bytevector/bytevector-u8-ref/u8-set!/...     (Phase 20)
-;;   quotient/remainder/modulo                          (Phase 15 / builtin)
-;;
-;; Naming: SX identifiers can't include @ or !-alone, so Forth words are:
-;;   C@ → forth-cfetch    C! → forth-cstore
-;;   @  → forth-fetch     !  → forth-store
-
-;; ---------------------------------------------------------------------------
-;; 1. Bitwise operations — Forth core words
-;;    Forth TRUE = -1 (all bits set), FALSE = 0.
-;;    All ops coerce to integer via truncate.
-;; ---------------------------------------------------------------------------
-
-(define (forth-and a b) (bitwise-and (truncate a) (truncate b)))
-(define (forth-or a b) (bitwise-or (truncate a) (truncate b)))
-(define (forth-xor a b) (bitwise-xor (truncate a) (truncate b)))
-
-;; INVERT — bitwise NOT (Forth NOT is logical; INVERT is bitwise)
-(define (forth-invert a) (bitwise-not (truncate a)))
-
-;; LSHIFT RSHIFT — n bit — shift a by n positions
-(define (forth-lshift a n) (arithmetic-shift (truncate a) (truncate n)))
-(define
-  (forth-rshift a n)
-  (arithmetic-shift (truncate a) (- 0 (truncate n))))
-
-;; 2* 2/ — multiply/divide by 2 via bit shift
-(define (forth-2* a) (arithmetic-shift (truncate a) 1))
-(define (forth-2/ a) (arithmetic-shift (truncate a) -1))
-
-;; BIT-COUNT — number of set bits (Kernighan popcount)
-(define (forth-bit-count a) (bit-count (truncate a)))
-
-;; INTEGER-LENGTH — index of highest set bit (0 for zero)
-(define (forth-integer-length a) (integer-length (truncate a)))
-
-;; WITHIN — ( u ul uh -- flag ) true if ul <= u < uh
-(define (forth-within u ul uh) (and (>= u ul) (< u uh)))
-
-;; Arithmetic complements commonly used alongside bitwise ops
-(define (forth-negate a) (- 0 (truncate a)))
-(define (forth-abs a) (abs (truncate a)))
-(define (forth-min a b) (if (< a b) a b))
-(define (forth-max a b) (if (> a b) a b))
-(define (forth-mod a b) (modulo (truncate a) (truncate b)))
-
-;; /MOD — ( n1 n2 -- rem quot ) returns list (remainder quotient)
-(define
-  (forth-divmod a b)
-  (list
-    (remainder (truncate a) (truncate b))
-    (quotient (truncate a) (truncate b))))
-
-;; ---------------------------------------------------------------------------
-;; 2. String buffer — word-definition / string accumulation
-;;    EMIT appends one char; TYPE appends a string.
-;;    Value is retrieved with forth-sb-value.
-;; ---------------------------------------------------------------------------
+;; Forth runtime — state, stacks, dictionary, output buffer.
+;; Data stack: mutable SX list, TOS = first.
+;; Return stack: separate mutable list.
+;; Dictionary: SX dict {lowercased-name -> word-record}.
+;; Word record: {"kind" "body" "immediate?"}; kind is "primitive" or "colon-def".
+;; Output buffer: mutable string appended to by `.`, `EMIT`, `CR`, etc.
+;; Compile-mode flag: "compiling" on the state.
 
 (define
-  (forth-sb-new)
-  (let
-    ((sb (dict)))
-    (dict-set! sb "_forth_sb" true)
-    (dict-set! sb "_chars" (list))
-    sb))
-
-(define (forth-sb? v) (and (dict? v) (dict-has? v "_forth_sb")))
-
-;; EMIT — append one character
-(define
-  (forth-sb-emit! sb c)
-  (dict-set! sb "_chars" (append (get sb "_chars") (list c)))
-  sb)
-
-;; TYPE — append a string
-(define
-  (forth-sb-type! sb s)
-  (dict-set! sb "_chars" (append (get sb "_chars") (string->list s)))
-  sb)
-
-(define (forth-sb-value sb) (list->string (get sb "_chars")))
-
-(define (forth-sb-length sb) (len (get sb "_chars")))
-
-(define (forth-sb-clear! sb) (dict-set! sb "_chars" (list)) sb)
-
-;; Emit integer as decimal digits
-(define (forth-sb-emit-int! sb n) (forth-sb-type! sb (str (truncate n))))
-
-;; ---------------------------------------------------------------------------
-;; 3. Memory / Bytevectors — Forth raw memory model
-;;    ALLOT allocates a bytevector. Byte and cell (32-bit LE) access.
-;; ---------------------------------------------------------------------------
-
-;; ALLOT — allocate n bytes zero-initialised
-(define (forth-mem-new n) (make-bytevector (truncate n) 0))
-
-(define (forth-mem? v) (bytevector? v))
-
-(define (forth-mem-size v) (bytevector-length v))
-
-;; C@ C! — byte fetch/store
-(define (forth-cfetch mem addr) (bytevector-u8-ref mem (truncate addr)))
+  forth-make-state
+  (fn
+    ()
+    (let
+      ((s (dict)))
+      (dict-set! s "dstack" (list))
+      (dict-set! s "rstack" (list))
+      (dict-set! s "dict" (dict))
+      (dict-set! s "output" "")
+      (dict-set! s "compiling" false)
+      (dict-set! s "current-def" nil)
+      (dict-set! s "base" 10)
+      (dict-set! s "vars" (dict))
+      s)))
 
 (define
-  (forth-cstore mem addr val)
-  (bytevector-u8-set!
-    mem
-    (truncate addr)
-    (modulo (truncate val) 256))
-  mem)
-
-;; @ ! — 32-bit little-endian cell fetch/store
-(define
-  (forth-fetch mem addr)
-  (let
-    ((a (truncate addr)))
-    (+
-      (bytevector-u8-ref mem a)
-      (* 256 (bytevector-u8-ref mem (+ a 1)))
-      (* 65536 (bytevector-u8-ref mem (+ a 2)))
-      (* 16777216 (bytevector-u8-ref mem (+ a 3))))))
+  forth-error
+  (fn (state msg) (dict-set! state "error" msg) (raise msg)))
 
 (define
-  (forth-store mem addr val)
-  (let
-    ((a (truncate addr)) (v (truncate val)))
-    (bytevector-u8-set! mem a (modulo v 256))
-    (bytevector-u8-set!
-      mem
-      (+ a 1)
-      (modulo (quotient v 256) 256))
-    (bytevector-u8-set!
-      mem
-      (+ a 2)
-      (modulo (quotient v 65536) 256))
-    (bytevector-u8-set!
-      mem
-      (+ a 3)
-      (modulo (quotient v 16777216) 256)))
-  mem)
+  forth-push
+  (fn (state v) (dict-set! state "dstack" (cons v (get state "dstack")))))
 
-;; MOVE — copy count bytes from src[src-addr] to dst[dst-addr]
 (define
-  (forth-move! src src-addr dst dst-addr count)
-  (letrec
-    ((go (fn (i) (when (< i (truncate count)) (bytevector-u8-set! dst (+ (truncate dst-addr) i) (bytevector-u8-ref src (+ (truncate src-addr) i))) (go (+ i 1))))))
-    (go 0))
-  dst)
+  forth-pop
+  (fn
+    (state)
+    (let
+      ((st (get state "dstack")))
+      (if
+        (= (len st) 0)
+        (forth-error state "stack underflow")
+        (let ((top (first st))) (dict-set! state "dstack" (rest st)) top)))))
 
-;; FILL — fill count bytes at addr with byte value
 (define
-  (forth-fill! mem addr count byte)
-  (letrec
-    ((go (fn (i) (when (< i (truncate count)) (bytevector-u8-set! mem (+ (truncate addr) i) (modulo (truncate byte) 256)) (go (+ i 1))))))
-    (go 0))
-  mem)
+  forth-peek
+  (fn
+    (state)
+    (let
+      ((st (get state "dstack")))
+      (if (= (len st) 0) (forth-error state "stack underflow") (first st)))))
 
-;; ERASE — fill with zeros (Forth: ERASE)
-(define
-  (forth-erase! mem addr count)
-  (forth-fill! mem addr count 0))
+(define forth-depth (fn (state) (len (get state "dstack"))))
 
-;; Dump memory region as list of byte values
 (define
-  (forth-mem->list mem addr count)
-  (letrec
-    ((go (fn (i acc) (if (= i 0) acc (go (- i 1) (cons (bytevector-u8-ref mem (+ (truncate addr) (- i 1))) acc))))))
-    (go (truncate count) (list))))
+  forth-rpush
+  (fn (state v) (dict-set! state "rstack" (cons v (get state "rstack")))))
+
+(define
+  forth-rpop
+  (fn
+    (state)
+    (let
+      ((st (get state "rstack")))
+      (if
+        (= (len st) 0)
+        (forth-error state "return stack underflow")
+        (let ((top (first st))) (dict-set! state "rstack" (rest st)) top)))))
+
+(define
+  forth-rpeek
+  (fn
+    (state)
+    (let
+      ((st (get state "rstack")))
+      (if
+        (= (len st) 0)
+        (forth-error state "return stack underflow")
+        (first st)))))
+
+(define
+  forth-emit-str
+  (fn (state s) (dict-set! state "output" (str (get state "output") s))))
+
+(define
+  forth-make-word
+  (fn
+    (kind body immediate?)
+    (let
+      ((w (dict)))
+      (dict-set! w "kind" kind)
+      (dict-set! w "body" body)
+      (dict-set! w "immediate?" immediate?)
+      w)))
+
+(define
+  forth-def-prim!
+  (fn
+    (state name body)
+    (dict-set!
+      (get state "dict")
+      (downcase name)
+      (forth-make-word "primitive" body false))))
+
+(define
+  forth-def-prim-imm!
+  (fn
+    (state name body)
+    (dict-set!
+      (get state "dict")
+      (downcase name)
+      (forth-make-word "primitive" body true))))
+
+(define
+  forth-lookup
+  (fn (state name) (get (get state "dict") (downcase name))))
+
+(define
+  forth-binop
+  (fn
+    (op)
+    (fn
+      (state)
+      (let
+        ((b (forth-pop state)) (a (forth-pop state)))
+        (forth-push state (op a b))))))
+
+(define
+  forth-unop
+  (fn
+    (op)
+    (fn (state) (let ((a (forth-pop state))) (forth-push state (op a))))))
+
+(define
+  forth-cmp
+  (fn
+    (op)
+    (fn
+      (state)
+      (let
+        ((b (forth-pop state)) (a (forth-pop state)))
+        (forth-push state (if (op a b) -1 0))))))
+
+(define
+  forth-cmp0
+  (fn
+    (op)
+    (fn
+      (state)
+      (let ((a (forth-pop state))) (forth-push state (if (op a) -1 0))))))
+
+(define
+  forth-trunc
+  (fn (x) (if (< x 0) (- 0 (floor (- 0 x))) (floor x))))
+
+(define
+  forth-div
+  (fn
+    (a b)
+    (if (= b 0) (raise "division by zero") (forth-trunc (/ a b)))))
+
+(define
+  forth-mod
+  (fn
+    (a b)
+    (if (= b 0) (raise "division by zero") (- a (* b (forth-div a b))))))
+
+(define forth-bits-width 32)
+
+(define
+  forth-to-unsigned
+  (fn (n w) (let ((m (pow 2 w))) (mod (+ (mod n m) m) m))))
+
+(define
+  forth-from-unsigned
+  (fn
+    (n w)
+    (let ((half (pow 2 (- w 1)))) (if (>= n half) (- n (pow 2 w)) n))))
+
+(define
+  forth-bitwise-step
+  (fn
+    (op ua ub out place i w)
+    (if
+      (>= i w)
+      out
+      (let
+        ((da (mod ua 2)) (db (mod ub 2)))
+        (forth-bitwise-step
+          op
+          (floor (/ ua 2))
+          (floor (/ ub 2))
+          (+ out (* place (op da db)))
+          (* place 2)
+          (+ i 1)
+          w)))))
+
+(define
+  forth-bitwise-uu
+  (fn
+    (op)
+    (fn
+      (a b)
+      (let
+        ((ua (forth-to-unsigned a forth-bits-width))
+          (ub (forth-to-unsigned b forth-bits-width)))
+        (forth-from-unsigned
+          (forth-bitwise-step op ua ub 0 1 0 forth-bits-width)
+          forth-bits-width)))))
+
+(define
+  forth-bit-and
+  (forth-bitwise-uu (fn (x y) (if (and (= x 1) (= y 1)) 1 0))))
+
+(define
+  forth-bit-or
+  (forth-bitwise-uu (fn (x y) (if (or (= x 1) (= y 1)) 1 0))))
+
+(define forth-bit-xor (forth-bitwise-uu (fn (x y) (if (= x y) 0 1))))
+
+(define forth-bit-invert (fn (a) (- 0 (+ a 1))))
+
+(define
+  forth-install-primitives!
+  (fn
+    (state)
+    (forth-def-prim! state "DUP" (fn (s) (forth-push s (forth-peek s))))
+    (forth-def-prim! state "DROP" (fn (s) (forth-pop s)))
+    (forth-def-prim!
+      state
+      "SWAP"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s b)
+          (forth-push s a))))
+    (forth-def-prim!
+      state
+      "OVER"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s a)
+          (forth-push s b)
+          (forth-push s a))))
+    (forth-def-prim!
+      state
+      "ROT"
+      (fn
+        (s)
+        (let
+          ((c (forth-pop s)) (b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s b)
+          (forth-push s c)
+          (forth-push s a))))
+    (forth-def-prim!
+      state
+      "-ROT"
+      (fn
+        (s)
+        (let
+          ((c (forth-pop s)) (b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s c)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "NIP"
+      (fn (s) (let ((b (forth-pop s))) (forth-pop s) (forth-push s b))))
+    (forth-def-prim!
+      state
+      "TUCK"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s b)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "?DUP"
+      (fn
+        (s)
+        (let ((a (forth-peek s))) (when (not (= a 0)) (forth-push s a)))))
+    (forth-def-prim! state "DEPTH" (fn (s) (forth-push s (forth-depth s))))
+    (forth-def-prim!
+      state
+      "PICK"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (st (get s "dstack")))
+          (if
+            (or (< n 0) (>= n (len st)))
+            (forth-error s "PICK out of range")
+            (forth-push s (nth st n))))))
+    (forth-def-prim!
+      state
+      "ROLL"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (st (get s "dstack")))
+          (if
+            (or (< n 0) (>= n (len st)))
+            (forth-error s "ROLL out of range")
+            (let
+              ((taken (nth st n))
+                (before (take st n))
+                (after (drop st (+ n 1))))
+              (dict-set! s "dstack" (concat before after))
+              (forth-push s taken))))))
+    (forth-def-prim!
+      state
+      "2DUP"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s a)
+          (forth-push s b)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim! state "2DROP" (fn (s) (forth-pop s) (forth-pop s)))
+    (forth-def-prim!
+      state
+      "2SWAP"
+      (fn
+        (s)
+        (let
+          ((d (forth-pop s))
+            (c (forth-pop s))
+            (b (forth-pop s))
+            (a (forth-pop s)))
+          (forth-push s c)
+          (forth-push s d)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "2OVER"
+      (fn
+        (s)
+        (let
+          ((d (forth-pop s))
+            (c (forth-pop s))
+            (b (forth-pop s))
+            (a (forth-pop s)))
+          (forth-push s a)
+          (forth-push s b)
+          (forth-push s c)
+          (forth-push s d)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim! state "+" (forth-binop (fn (a b) (+ a b))))
+    (forth-def-prim! state "-" (forth-binop (fn (a b) (- a b))))
+    (forth-def-prim! state "*" (forth-binop (fn (a b) (* a b))))
+    (forth-def-prim! state "/" (forth-binop forth-div))
+    (forth-def-prim! state "MOD" (forth-binop forth-mod))
+    (forth-def-prim!
+      state
+      "/MOD"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s (forth-mod a b))
+          (forth-push s (forth-div a b)))))
+    (forth-def-prim! state "NEGATE" (forth-unop (fn (a) (- 0 a))))
+    (forth-def-prim! state "ABS" (forth-unop abs))
+    (forth-def-prim!
+      state
+      "MIN"
+      (forth-binop (fn (a b) (if (< a b) a b))))
+    (forth-def-prim!
+      state
+      "MAX"
+      (forth-binop (fn (a b) (if (> a b) a b))))
+    (forth-def-prim! state "1+" (forth-unop (fn (a) (+ a 1))))
+    (forth-def-prim! state "1-" (forth-unop (fn (a) (- a 1))))
+    (forth-def-prim! state "2+" (forth-unop (fn (a) (+ a 2))))
+    (forth-def-prim! state "2-" (forth-unop (fn (a) (- a 2))))
+    (forth-def-prim! state "2*" (forth-unop (fn (a) (* a 2))))
+    (forth-def-prim! state "2/" (forth-unop (fn (a) (floor (/ a 2)))))
+    (forth-def-prim! state "=" (forth-cmp (fn (a b) (= a b))))
+    (forth-def-prim! state "<>" (forth-cmp (fn (a b) (not (= a b)))))
+    (forth-def-prim! state "<" (forth-cmp (fn (a b) (< a b))))
+    (forth-def-prim! state ">" (forth-cmp (fn (a b) (> a b))))
+    (forth-def-prim! state "<=" (forth-cmp (fn (a b) (<= a b))))
+    (forth-def-prim! state ">=" (forth-cmp (fn (a b) (>= a b))))
+    (forth-def-prim! state "0=" (forth-cmp0 (fn (a) (= a 0))))
+    (forth-def-prim! state "0<>" (forth-cmp0 (fn (a) (not (= a 0)))))
+    (forth-def-prim! state "0<" (forth-cmp0 (fn (a) (< a 0))))
+    (forth-def-prim! state "0>" (forth-cmp0 (fn (a) (> a 0))))
+    (forth-def-prim! state "AND" (forth-binop forth-bit-and))
+    (forth-def-prim! state "OR" (forth-binop forth-bit-or))
+    (forth-def-prim! state "XOR" (forth-binop forth-bit-xor))
+    (forth-def-prim! state "INVERT" (forth-unop forth-bit-invert))
+    (forth-def-prim!
+      state
+      "."
+      (fn (s) (forth-emit-str s (str (forth-pop s) " "))))
+    (forth-def-prim!
+      state
+      ".S"
+      (fn
+        (s)
+        (let
+          ((st (reverse (get s "dstack"))))
+          (forth-emit-str s "<")
+          (forth-emit-str s (str (len st)))
+          (forth-emit-str s "> ")
+          (for-each (fn (v) (forth-emit-str s (str v " "))) st))))
+    (forth-def-prim!
+      state
+      "EMIT"
+      (fn (s) (forth-emit-str s (code-char (forth-pop s)))))
+    (forth-def-prim! state "CR" (fn (s) (forth-emit-str s "\n")))
+    (forth-def-prim! state "SPACE" (fn (s) (forth-emit-str s " ")))
+    (forth-def-prim!
+      state
+      "SPACES"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (when
+            (> n 0)
+            (for-each (fn (_) (forth-emit-str s " ")) (range 0 n))))))
+    (forth-def-prim! state "BL" (fn (s) (forth-push s 32)))
+    state))

lib/forth/test.sh

@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-# lib/forth/test.sh — smoke-test the Forth runtime layer.
-
-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
-
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/forth/runtime.sx")
-(epoch 2)
-(load "lib/forth/tests/runtime.sx")
-(epoch 3)
-(eval "(list forth-test-pass forth-test-fail)")
-EPOCHS
-
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
-if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
-fi
-if [ -z "$LINE" ]; then
-  echo "ERROR: could not extract summary"
-  echo "$OUTPUT" | tail -20
-  exit 1
-fi
-
-P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-TOTAL=$((P + F))
-
-if [ "$F" -eq 0 ]; then
-  echo "ok $P/$TOTAL lib/forth tests passed"
-else
-  echo "FAIL $P/$TOTAL passed, $F failed"
-  TMPFILE2=$(mktemp)
-  cat > "$TMPFILE2" << 'EPOCHS2'
-(epoch 1)
-(load "lib/forth/runtime.sx")
-(epoch 2)
-(load "lib/forth/tests/runtime.sx")
-(epoch 3)
-(eval "(map (fn (f) (list (get f :name) (get f :got) (get f :expected))) forth-test-fails)")
-EPOCHS2
-  FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>/dev/null | grep -E '^\(ok-len 3' -A1 | tail -1 || true)
-  echo "  Details: $FAILS"
-  rm -f "$TMPFILE2"
-fi
-
-[ "$F" -eq 0 ]

lib/forth/tests/runtime.sx

@@ -1,201 +0,0 @@
-;; lib/forth/tests/runtime.sx — Tests for lib/forth/runtime.sx
-
-(define forth-test-pass 0)
-(define forth-test-fail 0)
-(define forth-test-fails (list))
-
-(define
-  (forth-test name got expected)
-  (if
-    (= got expected)
-    (set! forth-test-pass (+ forth-test-pass 1))
-    (begin
-      (set! forth-test-fail (+ forth-test-fail 1))
-      (set! forth-test-fails (append forth-test-fails (list {:got got :expected expected :name name}))))))
-
-;; ---------------------------------------------------------------------------
-;; 1. Bitwise operations
-;; ---------------------------------------------------------------------------
-
-;; AND
-(forth-test "and 0b1100 0b1010" (forth-and 12 10) 8)
-(forth-test "and 0xFF 0x0F" (forth-and 255 15) 15)
-(forth-test "and 0 any" (forth-and 0 42) 0)
-
-;; OR
-(forth-test "or 0b1100 0b1010" (forth-or 12 10) 14)
-(forth-test "or 0 x" (forth-or 0 7) 7)
-
-;; XOR
-(forth-test "xor 0b1100 0b1010" (forth-xor 12 10) 6)
-(forth-test "xor x x" (forth-xor 42 42) 0)
-
-;; INVERT
-(forth-test "invert 0" (forth-invert 0) -1)
-(forth-test "invert -1" (forth-invert -1) 0)
-(forth-test "invert 1" (forth-invert 1) -2)
-
-;; LSHIFT RSHIFT
-(forth-test "lshift 1 3" (forth-lshift 1 3) 8)
-(forth-test "lshift 3 2" (forth-lshift 3 2) 12)
-(forth-test "rshift 8 3" (forth-rshift 8 3) 1)
-(forth-test "rshift 16 2" (forth-rshift 16 2) 4)
-
-;; 2* 2/
-(forth-test "2* 5" (forth-2* 5) 10)
-(forth-test "2/ 10" (forth-2/ 10) 5)
-(forth-test "2/ 7" (forth-2/ 7) 3)
-
-;; BIT-COUNT
-(forth-test "bit-count 0" (forth-bit-count 0) 0)
-(forth-test "bit-count 1" (forth-bit-count 1) 1)
-(forth-test "bit-count 7" (forth-bit-count 7) 3)
-(forth-test "bit-count 255" (forth-bit-count 255) 8)
-(forth-test "bit-count 256" (forth-bit-count 256) 1)
-
-;; INTEGER-LENGTH
-(forth-test "integer-length 0" (forth-integer-length 0) 0)
-(forth-test "integer-length 1" (forth-integer-length 1) 1)
-(forth-test "integer-length 4" (forth-integer-length 4) 3)
-(forth-test "integer-length 255" (forth-integer-length 255) 8)
-
-;; WITHIN
-(forth-test
-  "within 5 0 10"
-  (forth-within 5 0 10)
-  true)
-(forth-test
-  "within 0 0 10"
-  (forth-within 0 0 10)
-  true)
-(forth-test
-  "within 10 0 10"
-  (forth-within 10 0 10)
-  false)
-(forth-test
-  "within -1 0 10"
-  (forth-within -1 0 10)
-  false)
-
-;; Arithmetic ops
-(forth-test "negate 5" (forth-negate 5) -5)
-(forth-test "negate -3" (forth-negate -3) 3)
-(forth-test "abs -7" (forth-abs -7) 7)
-(forth-test "min 3 5" (forth-min 3 5) 3)
-(forth-test "max 3 5" (forth-max 3 5) 5)
-(forth-test "mod 7 3" (forth-mod 7 3) 1)
-(forth-test
-  "divmod 7 3"
-  (forth-divmod 7 3)
-  (list 1 2))
-(forth-test
-  "divmod 10 5"
-  (forth-divmod 10 5)
-  (list 0 2))
-
-;; ---------------------------------------------------------------------------
-;; 2. String buffer
-;; ---------------------------------------------------------------------------
-
-(define sb1 (forth-sb-new))
-(forth-test "sb? new" (forth-sb? sb1) true)
-(forth-test "sb? non-sb" (forth-sb? 42) false)
-(forth-test "sb value empty" (forth-sb-value sb1) "")
-(forth-test "sb length empty" (forth-sb-length sb1) 0)
-
-(forth-sb-type! sb1 "HELLO")
-(forth-test "sb type" (forth-sb-value sb1) "HELLO")
-(forth-test "sb length after type" (forth-sb-length sb1) 5)
-
-;; EMIT one char
-(define sb2 (forth-sb-new))
-(forth-sb-emit! sb2 (nth (string->list "A") 0))
-(forth-sb-emit! sb2 (nth (string->list "B") 0))
-(forth-sb-emit! sb2 (nth (string->list "C") 0))
-(forth-test "sb emit chars" (forth-sb-value sb2) "ABC")
-
-;; Emit integer
-(define sb3 (forth-sb-new))
-(forth-sb-type! sb3 "n=")
-(forth-sb-emit-int! sb3 42)
-(forth-test "sb emit-int" (forth-sb-value sb3) "n=42")
-
-(forth-sb-clear! sb1)
-(forth-test "sb clear" (forth-sb-value sb1) "")
-(forth-test "sb length after clear" (forth-sb-length sb1) 0)
-
-;; Build a word definition-style name
-(define sb4 (forth-sb-new))
-(forth-sb-type! sb4 ": ")
-(forth-sb-type! sb4 "SQUARE")
-(forth-sb-type! sb4 " DUP * ;")
-(forth-test "sb word def" (forth-sb-value sb4) ": SQUARE DUP * ;")
-
-;; ---------------------------------------------------------------------------
-;; 3. Memory / Bytevectors
-;; ---------------------------------------------------------------------------
-
-(define m1 (forth-mem-new 8))
-(forth-test "mem? yes" (forth-mem? m1) true)
-(forth-test "mem? no" (forth-mem? 42) false)
-(forth-test "mem size" (forth-mem-size m1) 8)
-(forth-test "mem cfetch zero" (forth-cfetch m1 0) 0)
-
-;; C! C@
-(forth-cstore m1 0 65)
-(forth-cstore m1 1 66)
-(forth-test "mem cstore/cfetch 0" (forth-cfetch m1 0) 65)
-(forth-test "mem cstore/cfetch 1" (forth-cfetch m1 1) 66)
-(forth-cstore m1 2 256)
-(forth-test
-  "mem cstore wraps 256→0"
-  (forth-cfetch m1 2)
-  0)
-(forth-cstore m1 2 257)
-(forth-test
-  "mem cstore wraps 257→1"
-  (forth-cfetch m1 2)
-  1)
-
-;; @ ! (32-bit LE cell)
-(define m2 (forth-mem-new 8))
-(forth-store m2 0 305419896)
-(forth-test "mem store/fetch" (forth-fetch m2 0) 305419896)
-(forth-store m2 4 1)
-(forth-test "mem fetch byte 4" (forth-cfetch m2 4) 1)
-(forth-test "mem fetch byte 5" (forth-cfetch m2 5) 0)
-
-;; FILL ERASE
-(define m3 (forth-mem-new 4))
-(forth-fill! m3 0 4 42)
-(forth-test
-  "mem fill"
-  (forth-mem->list m3 0 4)
-  (list 42 42 42 42))
-(forth-erase! m3 1 2)
-(forth-test
-  "mem erase middle"
-  (forth-mem->list m3 0 4)
-  (list 42 0 0 42))
-
-;; MOVE
-(define m4 (forth-mem-new 4))
-(forth-cstore m4 0 1)
-(forth-cstore m4 1 2)
-(forth-cstore m4 2 3)
-(define m5 (forth-mem-new 4))
-(forth-move! m4 0 m5 0 3)
-(forth-test
-  "mem move"
-  (forth-mem->list m5 0 3)
-  (list 1 2 3))
-
-;; mem->list
-(define m6 (forth-mem-new 3))
-(forth-cstore m6 0 10)
-(forth-cstore m6 1 20)
-(forth-cstore m6 2 30)
-(forth-test
-  "mem->list"
-  (forth-mem->list m6 0 3)
-  (list 10 20 30))

lib/haskell/runtime.sx

@@ -1,507 +0,0 @@
-;; lib/haskell/runtime.sx — Haskell-on-SX runtime layer
-;;
-;; 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
-
-;; ===========================================================================
-;; 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-div a b)
-  (let
-    ((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)))
-
-;; Haskell mod: result has same sign as divisor
-(define hk-mod modulo)
-
-;; Haskell rem: result has same sign as dividend
-(define hk-rem remainder)
-
-;; Haskell quot: truncation division
-(define hk-quot quotient)
-
-;; divMod and quotRem return pairs (lists)
-(define (hk-div-mod a b) (list (hk-div a b) (hk-mod a b)))
-(define (hk-quot-rem a b) (list (hk-quot a b) (hk-rem a b)))
-
-(define (hk-abs x) (if (< x 0) (- 0 x) x))
-(define
-  (hk-signum x)
-  (cond
-    ((> x 0) 1)
-    ((< x 0) -1)
-    (else 0)))
-
-(define hk-gcd gcd)
-(define hk-lcm lcm)
-
-(define (hk-even? n) (= (modulo n 2) 0))
-(define (hk-odd? n) (not (= (modulo n 2) 0)))
-
-;; ===========================================================================
-;; 2. Rational numbers (dict implementation — no built-in rational in sx_server)
-;; ===========================================================================
-
-(define
-  (hk-make-rational n d)
-  (let
-    ((g (gcd (hk-abs n) (hk-abs d))))
-    (if (< d 0) {:num (quotient (- 0 n) g) :den (quotient (- 0 d) g) :_rational true} {:num (quotient n g) :den (quotient d g) :_rational true})))
-
-(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
-      ((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))))))
-
-;; intToDigit: 0-15 → char
-(define
-  (hk-int-to-digit n)
-  (cond
-    ((and (>= n 0) (<= n 9))
-      (integer->char (+ n 48)))
-    ((and (>= n 10) (<= n 15))
-      (integer->char (+ n 87)))
-    (else (error (str "hk-int-to-digit: out of range: " n)))))
-
-;; ===========================================================================
-;; 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/test.sh

@@ -46,7 +46,6 @@ for FILE in "${FILES[@]}"; do
   cat > "$TMPFILE" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
-(load "lib/haskell/runtime.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
@@ -82,7 +81,6 @@ EPOCHS
     cat > "$TMPFILE2" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
-(load "lib/haskell/runtime.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)

lib/haskell/tests/runtime.sx

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

lib/hyperscript/integration.sx

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

lib/hyperscript/tokenizer.sx

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

lib/js/conformance.sh

@@ -49,8 +49,6 @@ trap "rm -f $TMPFILE" EXIT
   echo '(load "lib/js/transpile.sx")'
   echo '(epoch 5)'
   echo '(load "lib/js/runtime.sx")'
-  echo '(epoch 6)'
-  echo '(load "lib/js/regex.sx")'
 
   epoch=100
   for f in "${FIXTURES[@]}"; do

lib/js/regex.sx

@@ -1,943 +0,0 @@
-;; lib/js/regex.sx — pure-SX recursive backtracking regex engine
-;;
-;; Installed via (js-regex-platform-override! ...) at load time.
-;; Covers: character classes (\d\w\s . [abc] [^abc] [a-z]),
-;;   anchors (^ $ \b \B), quantifiers (* + ? {n,m} lazy variants),
-;;   groups (capturing + non-capturing), alternation (a|b),
-;;   flags: i (case-insensitive), g (global), m (multiline).
-;;
-;; Architecture:
-;;   1. rx-parse-pattern  — pattern string → compiled node list
-;;   2. rx-match-nodes    — recursive backtracker
-;;   3. rx-exec / rx-test — public interface
-;;   4. Install as {:test rx-test :exec rx-exec}
-
-;; ── Utilities ─────────────────────────────────────────────────────
-
-(define
-  rx-char-at
-  (fn (s i) (if (and (>= i 0) (< i (len s))) (char-at s i) "")))
-
-(define
-  rx-digit?
-  (fn
-    (c)
-    (and (not (= c "")) (>= (char-code c) 48) (<= (char-code c) 57))))
-
-(define
-  rx-word?
-  (fn
-    (c)
-    (and
-      (not (= c ""))
-      (or
-        (and (>= (char-code c) 65) (<= (char-code c) 90))
-        (and (>= (char-code c) 97) (<= (char-code c) 122))
-        (and (>= (char-code c) 48) (<= (char-code c) 57))
-        (= c "_")))))
-
-(define
-  rx-space?
-  (fn
-    (c)
-    (or (= c " ") (= c "\t") (= c "\n") (= c "\r") (= c "\\f") (= c ""))))
-
-(define rx-newline? (fn (c) (or (= c "\n") (= c "\r"))))
-
-(define
-  rx-downcase-char
-  (fn
-    (c)
-    (let
-      ((cc (char-code c)))
-      (if (and (>= cc 65) (<= cc 90)) (char-from-code (+ cc 32)) c))))
-
-(define
-  rx-char-eq?
-  (fn
-    (a b ci?)
-    (if ci? (= (rx-downcase-char a) (rx-downcase-char b)) (= a b))))
-
-(define
-  rx-parse-int
-  (fn
-    (pat i acc)
-    (let
-      ((c (rx-char-at pat i)))
-      (if
-        (rx-digit? c)
-        (rx-parse-int pat (+ i 1) (+ (* acc 10) (- (char-code c) 48)))
-        (list acc i)))))
-
-(define
-  rx-hex-digit-val
-  (fn
-    (c)
-    (cond
-      ((and (>= (char-code c) 48) (<= (char-code c) 57))
-        (- (char-code c) 48))
-      ((and (>= (char-code c) 65) (<= (char-code c) 70))
-        (+ 10 (- (char-code c) 65)))
-      ((and (>= (char-code c) 97) (<= (char-code c) 102))
-        (+ 10 (- (char-code c) 97)))
-      (else -1))))
-
-(define
-  rx-parse-hex-n
-  (fn
-    (pat i n acc)
-    (if
-      (= n 0)
-      (list (char-from-code acc) i)
-      (let
-        ((v (rx-hex-digit-val (rx-char-at pat i))))
-        (if
-          (< v 0)
-          (list (char-from-code acc) i)
-          (rx-parse-hex-n pat (+ i 1) (- n 1) (+ (* acc 16) v)))))))
-
-;; ── Pattern compiler ──────────────────────────────────────────────
-
-;; Node types (stored in dicts with "__t__" key):
-;;   literal  : {:__t__ "literal" :__c__ char}
-;;   any      : {:__t__ "any"}
-;;   class-d  : {:__t__ "class-d"  :__neg__ bool}
-;;   class-w  : {:__t__ "class-w"  :__neg__ bool}
-;;   class-s  : {:__t__ "class-s"  :__neg__ bool}
-;;   char-class: {:__t__ "char-class" :__neg__ bool :__items__ list}
-;;   anchor-start / anchor-end / anchor-word / anchor-nonword
-;;   quant    : {:__t__ "quant" :__node__ n :__min__ m :__max__ mx :__lazy__ bool}
-;;   group    : {:__t__ "group" :__idx__ i :__nodes__ list}
-;;   ncgroup  : {:__t__ "ncgroup" :__nodes__ list}
-;;   alt      : {:__t__ "alt" :__branches__ list-of-node-lists}
-
-;; parse one escape after `\`, returns (node new-i)
-(define
-  rx-parse-escape
-  (fn
-    (pat i)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "d") (list (dict "__t__" "class-d" "__neg__" false) (+ i 1)))
-        ((= c "D") (list (dict "__t__" "class-d" "__neg__" true) (+ i 1)))
-        ((= c "w") (list (dict "__t__" "class-w" "__neg__" false) (+ i 1)))
-        ((= c "W") (list (dict "__t__" "class-w" "__neg__" true) (+ i 1)))
-        ((= c "s") (list (dict "__t__" "class-s" "__neg__" false) (+ i 1)))
-        ((= c "S") (list (dict "__t__" "class-s" "__neg__" true) (+ i 1)))
-        ((= c "b") (list (dict "__t__" "anchor-word") (+ i 1)))
-        ((= c "B") (list (dict "__t__" "anchor-nonword") (+ i 1)))
-        ((= c "n") (list (dict "__t__" "literal" "__c__" "\n") (+ i 1)))
-        ((= c "r") (list (dict "__t__" "literal" "__c__" "\r") (+ i 1)))
-        ((= c "t") (list (dict "__t__" "literal" "__c__" "\t") (+ i 1)))
-        ((= c "f") (list (dict "__t__" "literal" "__c__" "\\f") (+ i 1)))
-        ((= c "v") (list (dict "__t__" "literal" "__c__" "") (+ i 1)))
-        ((= c "u")
-          (let
-            ((res (rx-parse-hex-n pat (+ i 1) 4 0)))
-            (list (dict "__t__" "literal" "__c__" (nth res 0)) (nth res 1))))
-        ((= c "x")
-          (let
-            ((res (rx-parse-hex-n pat (+ i 1) 2 0)))
-            (list (dict "__t__" "literal" "__c__" (nth res 0)) (nth res 1))))
-        (else (list (dict "__t__" "literal" "__c__" c) (+ i 1)))))))
-
-;; parse a char-class item inside [...], returns (item new-i)
-(define
-  rx-parse-class-item
-  (fn
-    (pat i)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "\\")
-          (let
-            ((esc (rx-parse-escape pat (+ i 1))))
-            (let
-              ((node (nth esc 0)) (ni (nth esc 1)))
-              (let
-                ((t (get node "__t__")))
-                (cond
-                  ((= t "class-d")
-                    (list
-                      (dict "kind" "class-d" "neg" (get node "__neg__"))
-                      ni))
-                  ((= t "class-w")
-                    (list
-                      (dict "kind" "class-w" "neg" (get node "__neg__"))
-                      ni))
-                  ((= t "class-s")
-                    (list
-                      (dict "kind" "class-s" "neg" (get node "__neg__"))
-                      ni))
-                  (else
-                    (let
-                      ((lc (get node "__c__")))
-                      (if
-                        (and
-                          (= (rx-char-at pat ni) "-")
-                          (not (= (rx-char-at pat (+ ni 1)) "]")))
-                        (let
-                          ((hi-c (rx-char-at pat (+ ni 1))))
-                          (list
-                            (dict "kind" "range" "lo" lc "hi" hi-c)
-                            (+ ni 2)))
-                        (list (dict "kind" "lit" "c" lc) ni)))))))))
-        (else
-          (if
-            (and
-              (not (= c ""))
-              (= (rx-char-at pat (+ i 1)) "-")
-              (not (= (rx-char-at pat (+ i 2)) "]"))
-              (not (= (rx-char-at pat (+ i 2)) "")))
-            (let
-              ((hi-c (rx-char-at pat (+ i 2))))
-              (list (dict "kind" "range" "lo" c "hi" hi-c) (+ i 3)))
-            (list (dict "kind" "lit" "c" c) (+ i 1))))))))
-
-(define
-  rx-parse-class-items
-  (fn
-    (pat i items)
-    (let
-      ((c (rx-char-at pat i)))
-      (if
-        (or (= c "]") (= c ""))
-        (list items i)
-        (let
-          ((res (rx-parse-class-item pat i)))
-          (begin
-            (append! items (nth res 0))
-            (rx-parse-class-items pat (nth res 1) items)))))))
-
-;; parse a sequence until stop-ch or EOF; returns (nodes new-i groups-count)
-(define
-  rx-parse-seq
-  (fn
-    (pat i stop-ch ds)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "") (list (get ds "nodes") i (get ds "groups")))
-        ((= c stop-ch) (list (get ds "nodes") i (get ds "groups")))
-        ((= c "|") (rx-parse-alt-rest pat i ds))
-        (else
-          (let
-            ((res (rx-parse-atom pat i ds)))
-            (let
-              ((node (nth res 0)) (ni (nth res 1)) (ds2 (nth res 2)))
-              (let
-                ((qres (rx-parse-quant pat ni node)))
-                (begin
-                  (append! (get ds2 "nodes") (nth qres 0))
-                  (rx-parse-seq pat (nth qres 1) stop-ch ds2))))))))))
-
-;; when we hit | inside a sequence, collect all alternatives
-(define
-  rx-parse-alt-rest
-  (fn
-    (pat i ds)
-    (let
-      ((left-branch (get ds "nodes")) (branches (list)))
-      (begin
-        (append! branches left-branch)
-        (rx-parse-alt-branches pat i (get ds "groups") branches)))))
-
-(define
-  rx-parse-alt-branches
-  (fn
-    (pat i n-groups branches)
-    (let
-      ((new-nodes (list)) (ds2 (dict "groups" n-groups "nodes" new-nodes)))
-      (let
-        ((res (rx-parse-seq pat (+ i 1) "|" ds2)))
-        (begin
-          (append! branches (nth res 0))
-          (let
-            ((ni2 (nth res 1)) (g2 (nth res 2)))
-            (if
-              (= (rx-char-at pat ni2) "|")
-              (rx-parse-alt-branches pat ni2 g2 branches)
-              (list
-                (list (dict "__t__" "alt" "__branches__" branches))
-                ni2
-                g2))))))))
-
-;; parse quantifier suffix, returns (node new-i)
-(define
-  rx-parse-quant
-  (fn
-    (pat i node)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "*")
-          (let
-            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
-            (list
-              (dict
-                "__t__"
-                "quant"
-                "__node__"
-                node
-                "__min__"
-                0
-                "__max__"
-                -1
-                "__lazy__"
-                lazy?)
-              (if lazy? (+ i 2) (+ i 1)))))
-        ((= c "+")
-          (let
-            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
-            (list
-              (dict
-                "__t__"
-                "quant"
-                "__node__"
-                node
-                "__min__"
-                1
-                "__max__"
-                -1
-                "__lazy__"
-                lazy?)
-              (if lazy? (+ i 2) (+ i 1)))))
-        ((= c "?")
-          (let
-            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
-            (list
-              (dict
-                "__t__"
-                "quant"
-                "__node__"
-                node
-                "__min__"
-                0
-                "__max__"
-                1
-                "__lazy__"
-                lazy?)
-              (if lazy? (+ i 2) (+ i 1)))))
-        ((= c "{")
-          (let
-            ((mres (rx-parse-int pat (+ i 1) 0)))
-            (let
-              ((mn (nth mres 0)) (mi (nth mres 1)))
-              (let
-                ((sep (rx-char-at pat mi)))
-                (cond
-                  ((= sep "}")
-                    (let
-                      ((lazy? (= (rx-char-at pat (+ mi 1)) "?")))
-                      (list
-                        (dict
-                          "__t__"
-                          "quant"
-                          "__node__"
-                          node
-                          "__min__"
-                          mn
-                          "__max__"
-                          mn
-                          "__lazy__"
-                          lazy?)
-                        (if lazy? (+ mi 2) (+ mi 1)))))
-                  ((= sep ",")
-                    (let
-                      ((c2 (rx-char-at pat (+ mi 1))))
-                      (if
-                        (= c2 "}")
-                        (let
-                          ((lazy? (= (rx-char-at pat (+ mi 2)) "?")))
-                          (list
-                            (dict
-                              "__t__"
-                              "quant"
-                              "__node__"
-                              node
-                              "__min__"
-                              mn
-                              "__max__"
-                              -1
-                              "__lazy__"
-                              lazy?)
-                            (if lazy? (+ mi 3) (+ mi 2))))
-                        (let
-                          ((mxres (rx-parse-int pat (+ mi 1) 0)))
-                          (let
-                            ((mx (nth mxres 0)) (mxi (nth mxres 1)))
-                            (let
-                              ((lazy? (= (rx-char-at pat (+ mxi 1)) "?")))
-                              (list
-                                (dict
-                                  "__t__"
-                                  "quant"
-                                  "__node__"
-                                  node
-                                  "__min__"
-                                  mn
-                                  "__max__"
-                                  mx
-                                  "__lazy__"
-                                  lazy?)
-                                (if lazy? (+ mxi 2) (+ mxi 1)))))))))
-                  (else (list node i)))))))
-        (else (list node i))))))
-
-;; parse one atom, returns (node new-i new-ds)
-(define
-  rx-parse-atom
-  (fn
-    (pat i ds)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c ".") (list (dict "__t__" "any") (+ i 1) ds))
-        ((= c "^") (list (dict "__t__" "anchor-start") (+ i 1) ds))
-        ((= c "$") (list (dict "__t__" "anchor-end") (+ i 1) ds))
-        ((= c "\\")
-          (let
-            ((esc (rx-parse-escape pat (+ i 1))))
-            (list (nth esc 0) (nth esc 1) ds)))
-        ((= c "[")
-          (let
-            ((neg? (= (rx-char-at pat (+ i 1)) "^")))
-            (let
-              ((start (if neg? (+ i 2) (+ i 1))) (items (list)))
-              (let
-                ((res (rx-parse-class-items pat start items)))
-                (let
-                  ((ci (nth res 1)))
-                  (list
-                    (dict
-                      "__t__"
-                      "char-class"
-                      "__neg__"
-                      neg?
-                      "__items__"
-                      items)
-                    (+ ci 1)
-                    ds))))))
-        ((= c "(")
-          (let
-            ((c2 (rx-char-at pat (+ i 1))))
-            (if
-              (and (= c2 "?") (= (rx-char-at pat (+ i 2)) ":"))
-              (let
-                ((inner-nodes (list))
-                  (inner-ds
-                    (dict "groups" (get ds "groups") "nodes" inner-nodes)))
-                (let
-                  ((res (rx-parse-seq pat (+ i 3) ")" inner-ds)))
-                  (list
-                    (dict "__t__" "ncgroup" "__nodes__" (nth res 0))
-                    (+ (nth res 1) 1)
-                    (dict "groups" (nth res 2) "nodes" (get ds "nodes")))))
-              (let
-                ((gidx (+ (get ds "groups") 1)) (inner-nodes (list)))
-                (let
-                  ((inner-ds (dict "groups" gidx "nodes" inner-nodes)))
-                  (let
-                    ((res (rx-parse-seq pat (+ i 1) ")" inner-ds)))
-                    (list
-                      (dict
-                        "__t__"
-                        "group"
-                        "__idx__"
-                        gidx
-                        "__nodes__"
-                        (nth res 0))
-                      (+ (nth res 1) 1)
-                      (dict "groups" (nth res 2) "nodes" (get ds "nodes")))))))))
-        (else (list (dict "__t__" "literal" "__c__" c) (+ i 1) ds))))))
-
-;; top-level compile
-(define
-  rx-compile
-  (fn
-    (pattern)
-    (let
-      ((nodes (list)) (ds (dict "groups" 0 "nodes" nodes)))
-      (let
-        ((res (rx-parse-seq pattern 0 "" ds)))
-        (dict "nodes" (nth res 0) "ngroups" (nth res 2))))))
-
-;; ── Matcher ───────────────────────────────────────────────────────
-
-;; Match a char-class item against character c
-(define
-  rx-item-matches?
-  (fn
-    (item c ci?)
-    (let
-      ((kind (get item "kind")))
-      (cond
-        ((= kind "lit") (rx-char-eq? c (get item "c") ci?))
-        ((= kind "range")
-          (let
-            ((lo (if ci? (rx-downcase-char (get item "lo")) (get item "lo")))
-              (hi
-                (if ci? (rx-downcase-char (get item "hi")) (get item "hi")))
-              (dc (if ci? (rx-downcase-char c) c)))
-            (and
-              (>= (char-code dc) (char-code lo))
-              (<= (char-code dc) (char-code hi)))))
-        ((= kind "class-d")
-          (let ((m (rx-digit? c))) (if (get item "neg") (not m) m)))
-        ((= kind "class-w")
-          (let ((m (rx-word? c))) (if (get item "neg") (not m) m)))
-        ((= kind "class-s")
-          (let ((m (rx-space? c))) (if (get item "neg") (not m) m)))
-        (else false)))))
-
-(define
-  rx-class-items-any?
-  (fn
-    (items c ci?)
-    (if
-      (empty? items)
-      false
-      (if
-        (rx-item-matches? (first items) c ci?)
-        true
-        (rx-class-items-any? (rest items) c ci?)))))
-
-(define
-  rx-class-matches?
-  (fn
-    (node c ci?)
-    (let
-      ((neg? (get node "__neg__")) (items (get node "__items__")))
-      (let
-        ((hit (rx-class-items-any? items c ci?)))
-        (if neg? (not hit) hit)))))
-
-;; Word boundary check
-(define
-  rx-is-word-boundary?
-  (fn
-    (s i slen)
-    (let
-      ((before (if (> i 0) (rx-word? (char-at s (- i 1))) false))
-        (after (if (< i slen) (rx-word? (char-at s i)) false)))
-      (not (= before after)))))
-
-;; ── Core matcher ──────────────────────────────────────────────────
-;;
-;; rx-match-nodes : nodes s i slen ci? mi? groups → end-pos or -1
-;;
-;; Matches `nodes` starting at position `i` in string `s`.
-;; Returns the position after the last character consumed, or -1 on failure.
-;; Mutates `groups` dict to record captures.
-
-(define
-  rx-match-nodes
-  (fn
-    (nodes s i slen ci? mi? groups)
-    (if
-      (empty? nodes)
-      i
-      (let
-        ((node (first nodes)) (rest-nodes (rest nodes)))
-        (let
-          ((t (get node "__t__")))
-          (cond
-            ((= t "literal")
-              (if
-                (and
-                  (< i slen)
-                  (rx-char-eq? (char-at s i) (get node "__c__") ci?))
-                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                -1))
-            ((= t "any")
-              (if
-                (and (< i slen) (not (rx-newline? (char-at s i))))
-                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                -1))
-            ((= t "class-d")
-              (let
-                ((m (and (< i slen) (rx-digit? (char-at s i)))))
-                (if
-                  (if (get node "__neg__") (not m) m)
-                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                  -1)))
-            ((= t "class-w")
-              (let
-                ((m (and (< i slen) (rx-word? (char-at s i)))))
-                (if
-                  (if (get node "__neg__") (not m) m)
-                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                  -1)))
-            ((= t "class-s")
-              (let
-                ((m (and (< i slen) (rx-space? (char-at s i)))))
-                (if
-                  (if (get node "__neg__") (not m) m)
-                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                  -1)))
-            ((= t "char-class")
-              (if
-                (and (< i slen) (rx-class-matches? node (char-at s i) ci?))
-                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                -1))
-            ((= t "anchor-start")
-              (if
-                (or
-                  (= i 0)
-                  (and mi? (rx-newline? (rx-char-at s (- i 1)))))
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "anchor-end")
-              (if
-                (or (= i slen) (and mi? (rx-newline? (rx-char-at s i))))
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "anchor-word")
-              (if
-                (rx-is-word-boundary? s i slen)
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "anchor-nonword")
-              (if
-                (not (rx-is-word-boundary? s i slen))
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "group")
-              (let
-                ((gidx (get node "__idx__"))
-                  (inner (get node "__nodes__")))
-                (let
-                  ((g-end (rx-match-nodes inner s i slen ci? mi? groups)))
-                  (if
-                    (>= g-end 0)
-                    (begin
-                      (dict-set!
-                        groups
-                        (js-to-string gidx)
-                        (substring s i g-end))
-                      (let
-                        ((final-end (rx-match-nodes rest-nodes s g-end slen ci? mi? groups)))
-                        (if
-                          (>= final-end 0)
-                          final-end
-                          (begin
-                            (dict-set! groups (js-to-string gidx) nil)
-                            -1))))
-                    -1))))
-            ((= t "ncgroup")
-              (let
-                ((inner (get node "__nodes__")))
-                (rx-match-nodes
-                  (append inner rest-nodes)
-                  s
-                  i
-                  slen
-                  ci?
-                  mi?
-                  groups)))
-            ((= t "alt")
-              (let
-                ((branches (get node "__branches__")))
-                (rx-try-branches branches rest-nodes s i slen ci? mi? groups)))
-            ((= t "quant")
-              (let
-                ((inner-node (get node "__node__"))
-                  (mn (get node "__min__"))
-                  (mx (get node "__max__"))
-                  (lazy? (get node "__lazy__")))
-                (if
-                  lazy?
-                  (rx-quant-lazy
-                    inner-node
-                    mn
-                    mx
-                    rest-nodes
-                    s
-                    i
-                    slen
-                    ci?
-                    mi?
-                    groups
-                    0)
-                  (rx-quant-greedy
-                    inner-node
-                    mn
-                    mx
-                    rest-nodes
-                    s
-                    i
-                    slen
-                    ci?
-                    mi?
-                    groups
-                    0))))
-            (else -1)))))))
-
-(define
-  rx-try-branches
-  (fn
-    (branches rest-nodes s i slen ci? mi? groups)
-    (if
-      (empty? branches)
-      -1
-      (let
-        ((res (rx-match-nodes (append (first branches) rest-nodes) s i slen ci? mi? groups)))
-        (if
-          (>= res 0)
-          res
-          (rx-try-branches (rest branches) rest-nodes s i slen ci? mi? groups))))))
-
-;; Greedy: expand as far as possible, then try rest from the longest match
-;; Strategy: recurse forward (extend first); only try rest when extension fails
-(define
-  rx-quant-greedy
-  (fn
-    (inner-node mn mx rest-nodes s i slen ci? mi? groups count)
-    (let
-      ((can-extend (and (< i slen) (or (= mx -1) (< count mx)))))
-      (if
-        can-extend
-        (let
-          ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
-          (if
-            (>= ni 0)
-            (let
-              ((res (rx-quant-greedy inner-node mn mx rest-nodes s ni slen ci? mi? groups (+ count 1))))
-              (if
-                (>= res 0)
-                res
-                (if
-                  (>= count mn)
-                  (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                  -1)))
-            (if
-              (>= count mn)
-              (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-              -1)))
-        (if
-          (>= count mn)
-          (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-          -1)))))
-
-;; Lazy: try rest first, extend only if rest fails
-(define
-  rx-quant-lazy
-  (fn
-    (inner-node mn mx rest-nodes s i slen ci? mi? groups count)
-    (if
-      (>= count mn)
-      (let
-        ((res (rx-match-nodes rest-nodes s i slen ci? mi? groups)))
-        (if
-          (>= res 0)
-          res
-          (if
-            (and (< i slen) (or (= mx -1) (< count mx)))
-            (let
-              ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
-              (if
-                (>= ni 0)
-                (rx-quant-lazy
-                  inner-node
-                  mn
-                  mx
-                  rest-nodes
-                  s
-                  ni
-                  slen
-                  ci?
-                  mi?
-                  groups
-                  (+ count 1))
-                -1))
-            -1)))
-      (if
-        (< i slen)
-        (let
-          ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
-          (if
-            (>= ni 0)
-            (rx-quant-lazy
-              inner-node
-              mn
-              mx
-              rest-nodes
-              s
-              ni
-              slen
-              ci?
-              mi?
-              groups
-              (+ count 1))
-            -1))
-        -1))))
-
-;; Match a single node at position i, return new pos or -1
-(define
-  rx-match-one
-  (fn
-    (node s i slen ci? mi? groups)
-    (rx-match-nodes (list node) s i slen ci? mi? groups)))
-
-;; ── Engine entry points ───────────────────────────────────────────
-
-;; Try matching at exactly position i. Returns result dict or nil.
-(define
-  rx-try-at
-  (fn
-    (compiled s i slen ci? mi?)
-    (let
-      ((nodes (get compiled "nodes")) (ngroups (get compiled "ngroups")))
-      (let
-        ((groups (dict)))
-        (let
-          ((end (rx-match-nodes nodes s i slen ci? mi? groups)))
-          (if
-            (>= end 0)
-            (dict "start" i "end" end "groups" groups "ngroups" ngroups)
-            nil))))))
-
-;; Find first match scanning from search-start.
-(define
-  rx-find-from
-  (fn
-    (compiled s search-start slen ci? mi?)
-    (if
-      (> search-start slen)
-      nil
-      (let
-        ((res (rx-try-at compiled s search-start slen ci? mi?)))
-        (if
-          res
-          res
-          (rx-find-from compiled s (+ search-start 1) slen ci? mi?))))))
-
-;; Build exec result dict from raw match result
-(define
-  rx-build-exec-result
-  (fn
-    (s match-res)
-    (let
-      ((start (get match-res "start"))
-        (end (get match-res "end"))
-        (groups (get match-res "groups"))
-        (ngroups (get match-res "ngroups")))
-      (let
-        ((matched (substring s start end))
-          (caps (rx-build-captures groups ngroups 1)))
-        (dict "match" matched "index" start "input" s "groups" caps)))))
-
-(define
-  rx-build-captures
-  (fn
-    (groups ngroups idx)
-    (if
-      (> idx ngroups)
-      (list)
-      (let
-        ((cap (get groups (js-to-string idx))))
-        (cons
-          (if (= cap nil) :js-undefined cap)
-          (rx-build-captures groups ngroups (+ idx 1)))))))
-
-;; ── Public interface ──────────────────────────────────────────────
-
-;; Lazy compile: build NFA on first use, cache under "__compiled__"
-(define
-  rx-ensure-compiled!
-  (fn
-    (rx)
-    (if
-      (dict-has? rx "__compiled__")
-      (get rx "__compiled__")
-      (let
-        ((c (rx-compile (get rx "source"))))
-        (begin (dict-set! rx "__compiled__" c) c)))))
-
-(define
-  rx-test
-  (fn
-    (rx s)
-    (let
-      ((compiled (rx-ensure-compiled! rx))
-        (ci? (get rx "ignoreCase"))
-        (mi? (get rx "multiline"))
-        (slen (len s)))
-      (let
-        ((start (if (get rx "global") (let ((li (get rx "lastIndex"))) (if (number? li) li 0)) 0)))
-        (let
-          ((res (rx-find-from compiled s start slen ci? mi?)))
-          (if
-            (get rx "global")
-            (begin
-              (dict-set! rx "lastIndex" (if res (get res "end") 0))
-              (if res true false))
-            (if res true false)))))))
-
-(define
-  rx-exec
-  (fn
-    (rx s)
-    (let
-      ((compiled (rx-ensure-compiled! rx))
-        (ci? (get rx "ignoreCase"))
-        (mi? (get rx "multiline"))
-        (slen (len s)))
-      (let
-        ((start (if (get rx "global") (let ((li (get rx "lastIndex"))) (if (number? li) li 0)) 0)))
-        (let
-          ((res (rx-find-from compiled s start slen ci? mi?)))
-          (if
-            res
-            (begin
-              (when
-                (get rx "global")
-                (dict-set! rx "lastIndex" (get res "end")))
-              (rx-build-exec-result s res))
-            (begin
-              (when (get rx "global") (dict-set! rx "lastIndex" 0))
-              nil)))))))
-
-;; match-all for String.prototype.matchAll
-(define
-  js-regex-match-all
-  (fn
-    (rx s)
-    (let
-      ((compiled (rx-ensure-compiled! rx))
-        (ci? (get rx "ignoreCase"))
-        (mi? (get rx "multiline"))
-        (slen (len s))
-        (results (list)))
-      (rx-match-all-loop compiled s 0 slen ci? mi? results))))
-
-(define
-  rx-match-all-loop
-  (fn
-    (compiled s i slen ci? mi? results)
-    (if
-      (> i slen)
-      results
-      (let
-        ((res (rx-find-from compiled s i slen ci? mi?)))
-        (if
-          res
-          (begin
-            (append! results (rx-build-exec-result s res))
-            (let
-              ((next (get res "end")))
-              (rx-match-all-loop
-                compiled
-                s
-                (if (= next i) (+ i 1) next)
-                slen
-                ci?
-                mi?
-                results)))
-          results)))))
-
-;; ── Install platform ──────────────────────────────────────────────
-
-(js-regex-platform-override! "test" rx-test)
-(js-regex-platform-override! "exec" rx-exec)

lib/js/runtime.sx

@@ -2032,15 +2032,7 @@
           (&rest args)
           (cond
             ((= (len args) 0) nil)
-            ((js-regex? (nth args 0))
-              (let
-                ((rx (nth args 0)))
-                (let
-                  ((impl (get __js_regex_platform__ "exec")))
-                  (if
-                    (js-undefined? impl)
-                    (js-regex-stub-exec rx s)
-                    (impl rx s)))))
+            ((js-regex? (nth args 0)) (js-regex-stub-exec (nth args 0) s))
             (else
               (let
                 ((needle (js-to-string (nth args 0))))
@@ -2049,7 +2041,7 @@
                   (if
                     (= idx -1)
                     nil
-                    (let ((res (list))) (begin (append! res needle) res)))))))))
+                    (let ((res (list))) (append! res needle) res))))))))
       ((= name "at")
         (fn
           (i)
@@ -2107,20 +2099,6 @@
       ((= name "toWellFormed") (fn () s))
       (else js-undefined))))
 
-(define __js_tdz_sentinel__ (dict "__tdz__" true))
-
-(define js-tdz? (fn (v) (and (dict? v) (dict-has? v "__tdz__"))))
-
-(define
-  js-tdz-check
-  (fn
-    (name val)
-    (if
-      (js-tdz? val)
-      (raise
-        (TypeError (str "Cannot access '" name "' before initialization")))
-      val)))
-
 (define
   js-string-slice
   (fn

lib/js/stdlib.sx

@@ -1,239 +0,0 @@
-;; lib/js/stdlib.sx — Phase 22 JS additions
-;;
-;; Adds to lib/js/runtime.sx (already loaded):
-;;   1. Bitwise binary ops (js-bitand/bitor/bitxor/lshift/rshift/urshift/bitnot)
-;;   2. Map class (arbitrary-key hash map via list of pairs)
-;;   3. Set class (uniqueness collection via SX make-set)
-;;   4. RegExp constructor (wraps js-regex-new already in runtime)
-;;   5. Wires Map / Set / RegExp into js-global
-
-;; ---------------------------------------------------------------------------
-;; 1. Bitwise binary ops
-;;    JS coerces operands to 32-bit signed int before applying the op.
-;;    Use truncate (not js-num-to-int) since integer / 0 crashes the evaluator.
-;; ---------------------------------------------------------------------------
-
-(define
-  (js-bitand a b)
-  (bitwise-and (truncate (js-to-number a)) (truncate (js-to-number b))))
-
-(define
-  (js-bitor a b)
-  (bitwise-or (truncate (js-to-number a)) (truncate (js-to-number b))))
-
-(define
-  (js-bitxor a b)
-  (bitwise-xor (truncate (js-to-number a)) (truncate (js-to-number b))))
-
-;; << : left-shift by (b mod 32) positions
-(define
-  (js-lshift a b)
-  (arithmetic-shift
-    (truncate (js-to-number a))
-    (modulo (truncate (js-to-number b)) 32)))
-
-;; >> : arithmetic right-shift (sign-extending)
-(define
-  (js-rshift a b)
-  (arithmetic-shift
-    (truncate (js-to-number a))
-    (- 0 (modulo (truncate (js-to-number b)) 32))))
-
-;; >>> : logical right-shift (zero-extending)
-;;   Convert to uint32 first, then divide by 2^n.
-(define
-  (js-urshift a b)
-  (let
-    ((u32 (modulo (truncate (js-to-number a)) 4294967296))
-      (n (modulo (truncate (js-to-number b)) 32)))
-    (quotient u32 (arithmetic-shift 1 n))))
-
-;; ~ : bitwise NOT — equivalent to -(n+1) in 32-bit signed arithmetic
-(define (js-bitnot a) (bitwise-not (truncate (js-to-number a))))
-
-;; ---------------------------------------------------------------------------
-;; 2. Map class
-;;    Stored as {:__js_map__ true :size N :_pairs (list (list key val) ...)}
-;;    Mutation via dict-set! on the underlying dict.
-;; ---------------------------------------------------------------------------
-
-(define
-  (js-map-new)
-  (let
-    ((m (dict)))
-    (dict-set! m "__js_map__" true)
-    (dict-set! m "size" 0)
-    (dict-set! m "_pairs" (list))
-    m))
-
-(define (js-map? v) (and (dict? v) (dict-has? v "__js_map__")))
-
-;; Linear scan for key using ===; returns index or -1
-(define
-  (js-map-find-idx pairs k)
-  (letrec
-    ((go (fn (ps i) (cond ((= (len ps) 0) -1) ((js-strict-eq (first (first ps)) k) i) (else (go (rest ps) (+ i 1)))))))
-    (go pairs 0)))
-
-(define
-  (js-map-get m k)
-  (letrec
-    ((go (fn (ps) (if (= (len ps) 0) js-undefined (if (js-strict-eq (first (first ps)) k) (nth (first ps) 1) (go (rest ps)))))))
-    (go (get m "_pairs"))))
-
-;; Replace element at index i in list
-(define
-  (js-list-set-nth lst i newval)
-  (letrec
-    ((go (fn (ps j) (if (= (len ps) 0) (list) (cons (if (= j i) newval (first ps)) (go (rest ps) (+ j 1)))))))
-    (go lst 0)))
-
-;; Remove element at index i from list
-(define
-  (js-list-remove-nth lst i)
-  (letrec
-    ((go (fn (ps j) (if (= (len ps) 0) (list) (if (= j i) (go (rest ps) (+ j 1)) (cons (first ps) (go (rest ps) (+ j 1))))))))
-    (go lst 0)))
-
-(define
-  (js-map-set! m k v)
-  (let
-    ((pairs (get m "_pairs")) (idx (js-map-find-idx (get m "_pairs") k)))
-    (if
-      (= idx -1)
-      (begin
-        (dict-set! m "_pairs" (append pairs (list (list k v))))
-        (dict-set! m "size" (+ (get m "size") 1)))
-      (dict-set! m "_pairs" (js-list-set-nth pairs idx (list k v)))))
-  m)
-
-(define
-  (js-map-has m k)
-  (not (= (js-map-find-idx (get m "_pairs") k) -1)))
-
-(define
-  (js-map-delete! m k)
-  (let
-    ((idx (js-map-find-idx (get m "_pairs") k)))
-    (when
-      (not (= idx -1))
-      (dict-set! m "_pairs" (js-list-remove-nth (get m "_pairs") idx))
-      (dict-set! m "size" (- (get m "size") 1))))
-  m)
-
-(define
-  (js-map-clear! m)
-  (dict-set! m "_pairs" (list))
-  (dict-set! m "size" 0)
-  m)
-
-(define (js-map-keys m) (map first (get m "_pairs")))
-(define
-  (js-map-vals m)
-  (map (fn (p) (nth p 1)) (get m "_pairs")))
-(define (js-map-entries m) (get m "_pairs"))
-
-(define
-  (js-map-for-each m cb)
-  (for-each
-    (fn (p) (cb (nth p 1) (first p) m))
-    (get m "_pairs"))
-  js-undefined)
-
-;; Map method dispatch (called from js-object-method-call in runtime)
-(define
-  (js-map-method m name args)
-  (cond
-    ((= name "set")
-      (js-map-set! m (nth args 0) (nth args 1)))
-    ((= name "get") (js-map-get m (nth args 0)))
-    ((= name "has") (js-map-has m (nth args 0)))
-    ((= name "delete") (js-map-delete! m (nth args 0)))
-    ((= name "clear") (js-map-clear! m))
-    ((= name "keys") (js-map-keys m))
-    ((= name "values") (js-map-vals m))
-    ((= name "entries") (js-map-entries m))
-    ((= name "forEach") (js-map-for-each m (nth args 0)))
-    ((= name "toString") "[object Map]")
-    (else js-undefined)))
-
-(define Map {:__callable__ (fn (&rest args) (let ((m (js-map-new))) (when (and (> (len args) 0) (list? (nth args 0))) (for-each (fn (entry) (js-map-set! m (nth entry 0) (nth entry 1))) (nth args 0))) m)) :prototype {:entries (fn (&rest a) (js-map-entries (js-this))) :delete (fn (&rest a) (js-map-delete! (js-this) (nth a 0))) :get (fn (&rest a) (js-map-get (js-this) (nth a 0))) :values (fn (&rest a) (js-map-vals (js-this))) :toString (fn () "[object Map]") :has (fn (&rest a) (js-map-has (js-this) (nth a 0))) :set (fn (&rest a) (js-map-set! (js-this) (nth a 0) (nth a 1))) :forEach (fn (&rest a) (js-map-for-each (js-this) (nth a 0))) :clear (fn (&rest a) (js-map-clear! (js-this))) :keys (fn (&rest a) (js-map-keys (js-this)))}})
-
-;; ---------------------------------------------------------------------------
-;; 3. Set class
-;;    {:__js_set__ true :size N :_set <sx-set>}
-;;    Note: set-member?/set-add!/set-remove! all take (set item) order.
-;; ---------------------------------------------------------------------------
-
-(define
-  (js-set-new)
-  (let
-    ((s (dict)))
-    (dict-set! s "__js_set__" true)
-    (dict-set! s "size" 0)
-    (dict-set! s "_set" (make-set))
-    s))
-
-(define (js-set? v) (and (dict? v) (dict-has? v "__js_set__")))
-
-(define
-  (js-set-add! s v)
-  (let
-    ((sx (get s "_set")))
-    (when
-      (not (set-member? sx v))
-      (set-add! sx v)
-      (dict-set! s "size" (+ (get s "size") 1))))
-  s)
-
-(define (js-set-has s v) (set-member? (get s "_set") v))
-
-(define
-  (js-set-delete! s v)
-  (let
-    ((sx (get s "_set")))
-    (when
-      (set-member? sx v)
-      (set-remove! sx v)
-      (dict-set! s "size" (- (get s "size") 1))))
-  s)
-
-(define
-  (js-set-clear! s)
-  (dict-set! s "_set" (make-set))
-  (dict-set! s "size" 0)
-  s)
-
-(define (js-set-vals s) (set->list (get s "_set")))
-
-(define
-  (js-set-for-each s cb)
-  (for-each (fn (v) (cb v v s)) (set->list (get s "_set")))
-  js-undefined)
-
-(define Set {:__callable__ (fn (&rest args) (let ((s (js-set-new))) (when (and (> (len args) 0) (list? (nth args 0))) (for-each (fn (v) (js-set-add! s v)) (nth args 0))) s)) :prototype {:entries (fn (&rest a) (map (fn (v) (list v v)) (js-set-vals (js-this)))) :delete (fn (&rest a) (js-set-delete! (js-this) (nth a 0))) :values (fn (&rest a) (js-set-vals (js-this))) :add (fn (&rest a) (js-set-add! (js-this) (nth a 0))) :toString (fn () "[object Set]") :has (fn (&rest a) (js-set-has (js-this) (nth a 0))) :forEach (fn (&rest a) (js-set-for-each (js-this) (nth a 0))) :clear (fn (&rest a) (js-set-clear! (js-this))) :keys (fn (&rest a) (js-set-vals (js-this)))}})
-
-;; ---------------------------------------------------------------------------
-;; 4. RegExp constructor — callable lambda wrapping js-regex-new
-;; ---------------------------------------------------------------------------
-
-(define
-  RegExp
-  (fn
-    (&rest args)
-    (cond
-      ((= (len args) 0) (js-regex-new "" ""))
-      ((= (len args) 1)
-        (js-regex-new (js-to-string (nth args 0)) ""))
-      (else
-        (js-regex-new
-          (js-to-string (nth args 0))
-          (js-to-string (nth args 1)))))))
-
-;; ---------------------------------------------------------------------------
-;; 5. Wire new globals into js-global
-;; ---------------------------------------------------------------------------
-
-(dict-set! js-global "Map" Map)
-(dict-set! js-global "Set" Set)
-(dict-set! js-global "RegExp" RegExp)

lib/js/test.sh

@@ -33,10 +33,6 @@ cat > "$TMPFILE" << 'EPOCHS'
 (load "lib/js/transpile.sx")
 (epoch 5)
 (load "lib/js/runtime.sx")
-(epoch 6)
-(load "lib/js/regex.sx")
-(epoch 7)
-(load "lib/js/stdlib.sx")
 
 ;; ── Phase 0: stubs still behave ─────────────────────────────────
 (epoch 10)
@@ -1327,166 +1323,6 @@ cat > "$TMPFILE" << 'EPOCHS'
 (epoch 3505)
 (eval "(js-eval \"var a = {length: 3, 0: 10, 1: 20, 2: 30}; var sum = 0; Array.prototype.forEach.call(a, function(x){sum += x;}); sum\")")
 
-;; ── Phase 12: Regex engine ────────────────────────────────────────
-;; Platform is installed (test key is a function, not undefined)
-(epoch 5000)
-(eval "(js-undefined? (get __js_regex_platform__ \"test\"))")
-(epoch 5001)
-(eval "(js-eval \"/foo/.test('hi foo bar')\")")
-(epoch 5002)
-(eval "(js-eval \"/foo/.test('hi bar')\")")
-;; Case-insensitive flag
-(epoch 5003)
-(eval "(js-eval \"/FOO/i.test('hello foo world')\")")
-;; Anchors
-(epoch 5004)
-(eval "(js-eval \"/^hello/.test('hello world')\")")
-(epoch 5005)
-(eval "(js-eval \"/^hello/.test('say hello')\")")
-(epoch 5006)
-(eval "(js-eval \"/world$/.test('hello world')\")")
-;; Character classes
-(epoch 5007)
-(eval "(js-eval \"/\\\\d+/.test('abc 123')\")")
-(epoch 5008)
-(eval "(js-eval \"/\\\\w+/.test('hello')\")")
-(epoch 5009)
-(eval "(js-eval \"/[abc]/.test('dog')\")")
-(epoch 5010)
-(eval "(js-eval \"/[abc]/.test('cat')\")")
-;; Quantifiers
-(epoch 5011)
-(eval "(js-eval \"/a*b/.test('b')\")")
-(epoch 5012)
-(eval "(js-eval \"/a+b/.test('b')\")")
-(epoch 5013)
-(eval "(js-eval \"/a{2,3}/.test('aa')\")")
-(epoch 5014)
-(eval "(js-eval \"/a{2,3}/.test('a')\")")
-;; Dot
-(epoch 5015)
-(eval "(js-eval \"/h.llo/.test('hello')\")")
-(epoch 5016)
-(eval "(js-eval \"/h.llo/.test('hllo')\")")
-;; exec result
-(epoch 5017)
-(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.match\")")
-(epoch 5018)
-(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.index\")")
-(epoch 5019)
-(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.groups[0]\")")
-;; Alternation
-(epoch 5020)
-(eval "(js-eval \"/cat|dog/.test('I have a dog')\")")
-(epoch 5021)
-(eval "(js-eval \"/cat|dog/.test('I have a fish')\")")
-;; Non-capturing group
-(epoch 5022)
-(eval "(js-eval \"/(?:foo)+/.test('foofoo')\")")
-;; Negated char class
-(epoch 5023)
-(eval "(js-eval \"/[^abc]/.test('d')\")")
-(epoch 5024)
-(eval "(js-eval \"/[^abc]/.test('a')\")")
-;; Range inside char class
-(epoch 5025)
-(eval "(js-eval \"/[a-z]+/.test('hello')\")")
-;; Word boundary
-(epoch 5026)
-(eval "(js-eval \"/\\\\bword\\\\b/.test('a word here')\")")
-(epoch 5027)
-(eval "(js-eval \"/\\\\bword\\\\b/.test('password')\")")
-;; Lazy quantifier
-(epoch 5028)
-(eval "(js-eval \"var m = /a+?/.exec('aaa'); m.match\")")
-;; Global flag exec
-(epoch 5029)
-(eval "(js-eval \"var r=/\\\\d+/g; r.exec('a1b2'); r.exec('a1b2').match\")")
-;; String.prototype.match with regex
-(epoch 5030)
-(eval "(js-eval \"'hello world'.match(/\\\\w+/).match\")")
-;; String.prototype.search
-(epoch 5031)
-(eval "(js-eval \"'hello world'.search(/world/)\")")
-;; String.prototype.replace with regex
-(epoch 5032)
-(eval "(js-eval \"'hello world'.replace(/world/, 'there')\")")
-;; multiline anchor
-(epoch 5033)
-(eval "(js-eval \"/^bar/m.test('foo\\nbar')\")")
-
-;; ── Phase 13: let/const TDZ infrastructure ───────────────────────
-;; The TDZ sentinel and checker are defined in runtime.sx.
-;; let/const bindings work normally after initialization.
-(epoch 5100)
-(eval "(js-eval \"let x = 5; x\")")
-(epoch 5101)
-(eval "(js-eval \"const y = 42; y\")")
-;; TDZ sentinel exists and is detectable
-(epoch 5102)
-(eval "(js-tdz? __js_tdz_sentinel__)")
-;; js-tdz-check passes through non-sentinel values
-(epoch 5103)
-(eval "(js-tdz-check \"x\" 42)")
-
-;; ── Phase 22: Bitwise ops ────────────────────────────────────────
-(epoch 6000)
-(eval "(js-bitand 5 3)")
-(epoch 6001)
-(eval "(js-bitor 5 3)")
-(epoch 6002)
-(eval "(js-bitxor 5 3)")
-(epoch 6003)
-(eval "(js-lshift 1 4)")
-(epoch 6004)
-(eval "(js-rshift 32 2)")
-(epoch 6005)
-(eval "(js-rshift -8 1)")
-(epoch 6006)
-(eval "(js-urshift 4294967292 2)")
-(epoch 6007)
-(eval "(js-bitnot 0)")
-
-;; ── Phase 22: Map ─────────────────────────────────────────────────
-(epoch 6010)
-(eval "(js-map? (js-map-new))")
-(epoch 6011)
-(eval "(get (js-map-set! (js-map-new) \"k\" 42) \"size\")")
-(epoch 6012)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-get m \"a\"))")
-(epoch 6013)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"x\" 9) (js-map-has m \"x\"))")
-(epoch 6014)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"x\" 9) (js-map-has m \"y\"))")
-(epoch 6015)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-set! m \"b\" 2) (get m \"size\"))")
-(epoch 6016)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-delete! m \"a\") (get m \"size\"))")
-(epoch 6017)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-set! m \"a\" 99) (js-map-get m \"a\"))")
-
-;; ── Phase 22: Set ─────────────────────────────────────────────────
-(epoch 6020)
-(eval "(js-set? (js-set-new))")
-(epoch 6021)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-has s 1))")
-(epoch 6022)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-has s 2))")
-(epoch 6023)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-add! s 1) (get s \"size\"))")
-(epoch 6024)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-add! s 2) (get s \"size\"))")
-(epoch 6025)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-delete! s 1) (get s \"size\"))")
-
-;; ── Phase 22: RegExp constructor ──────────────────────────────────
-(epoch 6030)
-(eval "(js-regex? (RegExp \"ab\" \"i\"))")
-(epoch 6031)
-(eval "(get (RegExp \"hello\" \"gi\") \"global\")")
-(epoch 6032)
-(eval "(get (RegExp \"foo\" \"i\") \"ignoreCase\")")
-
 EPOCHS
 
 
@@ -2206,81 +2042,6 @@ check 3503 "indexOf.call arrLike"          '1'
 check 3504 "filter.call arrLike"           '"2,3"'
 check 3505 "forEach.call arrLike sum"      '60'
 
-# ── Phase 12: Regex engine ────────────────────────────────────────
-check 5000 "regex platform installed"           'false'
-check 5001 "/foo/ matches"                      'true'
-check 5002 "/foo/ no match"                     'false'
-check 5003 "/FOO/i case-insensitive"            'true'
-check 5004 "/^hello/ anchor match"              'true'
-check 5005 "/^hello/ anchor no-match"           'false'
-check 5006 "/world$/ end anchor"                'true'
-check 5007 "/\\d+/ digit class"                 'true'
-check 5008 "/\\w+/ word class"                  'true'
-check 5009 "/[abc]/ class no-match"             'false'
-check 5010 "/[abc]/ class match"                'true'
-check 5011 "/a*b/ zero-or-more"                 'true'
-check 5012 "/a+b/ one-or-more no-match"         'false'
-check 5013 "/a{2,3}/ quant match"               'true'
-check 5014 "/a{2,3}/ quant no-match"            'false'
-check 5015 "dot matches any"                    'true'
-check 5016 "dot requires char"                  'false'
-check 5017 "exec match string"                  '"foobar"'
-check 5018 "exec match index"                   '0'
-check 5019 "exec capture group"                 '"bar"'
-check 5020 "alternation cat|dog match"          'true'
-check 5021 "alternation cat|dog no-match"       'false'
-check 5022 "non-capturing group"                'true'
-check 5023 "negated class match"                'true'
-check 5024 "negated class no-match"             'false'
-check 5025 "range [a-z]+"                       'true'
-check 5026 "word boundary match"                'true'
-check 5027 "word boundary no-match"             'false'
-check 5028 "lazy quantifier"                    '"a"'
-check 5029 "global exec advances"               '"2"'
-check 5030 "String.match regex"                 '"hello"'
-check 5031 "String.search regex"                '6'
-check 5032 "String.replace regex"               '"hello there"'
-check 5033 "multiline anchor"                   'true'
-
-# ── Phase 13: let/const TDZ infrastructure ───────────────────────
-check 5100 "let binding initialized"            '5'
-check 5101 "const binding initialized"          '42'
-check 5102 "TDZ sentinel is detectable"         'true'
-check 5103 "tdz-check passes non-sentinel"      '42'
-
-# ── Phase 22: Bitwise ops ─────────────────────────────────────────
-check 6000 "bitand 5&3"     '1'
-check 6001 "bitor 5|3"      '7'
-check 6002 "bitxor 5^3"     '6'
-check 6003 "lshift 1<<4"    '16'
-check 6004 "rshift 32>>2"   '8'
-check 6005 "rshift -8>>1"   '-4'
-check 6006 "urshift >>>"     '1073741823'
-check 6007 "bitnot ~0"      '-1'
-
-# ── Phase 22: Map ─────────────────────────────────────────────────
-check 6010 "map? new map"          'true'
-check 6011 "map set→size 1"        '1'
-check 6012 "map get existing"      '1'
-check 6013 "map has key yes"       'true'
-check 6014 "map has key no"        'false'
-check 6015 "map size 2 entries"    '2'
-check 6016 "map delete→size 0"     '0'
-check 6017 "map set overwrites"    '99'
-
-# ── Phase 22: Set ─────────────────────────────────────────────────
-check 6020 "set? new set"          'true'
-check 6021 "set has after add"     'true'
-check 6022 "set has absent"        'false'
-check 6023 "set dedup size"        '1'
-check 6024 "set size 2"            '2'
-check 6025 "set delete→size 0"     '0'
-
-# ── Phase 22: RegExp ──────────────────────────────────────────────
-check 6030 "RegExp? result"        'true'
-check 6031 "RegExp global flag"    'true'
-check 6032 "RegExp ignoreCase"     'true'
-
 TOTAL=$((PASS + FAIL))
 if [ $FAIL -eq 0 ]; then
   echo "✓ $PASS/$TOTAL JS-on-SX tests passed"

lib/js/test262-runner.py

@@ -798,7 +798,6 @@ class ServerSession:
         self._run_and_collect(3, '(load "lib/js/parser.sx")', timeout=60.0)
         self._run_and_collect(4, '(load "lib/js/transpile.sx")', timeout=60.0)
         self._run_and_collect(5, '(load "lib/js/runtime.sx")', timeout=60.0)
-        self._run_and_collect(50, '(load "lib/js/regex.sx")', timeout=60.0)
         # Preload the stub harness — use precomputed SX cache when available
         # (huge win: ~15s js-eval HARNESS_STUB → ~0s load precomputed .sx).
         cache_rel = _harness_cache_rel_path()

lib/js/transpile.sx

@@ -935,12 +935,12 @@
 
 (define
   js-transpile-var
-  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms kind decls))))
+  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls))))
 
 (define
   js-vardecl-forms
   (fn
-    (kind decls)
+    (decls)
     (cond
       ((empty? decls) (list))
       (else
@@ -953,7 +953,7 @@
                   (js-sym "define")
                   (js-sym (nth d 1))
                   (js-transpile (nth d 2)))
-                (js-vardecl-forms kind (rest decls))))
+                (js-vardecl-forms (rest decls))))
             ((js-tag? d "js-vardecl-obj")
               (let
                 ((names (nth d 1))
@@ -964,7 +964,7 @@
                   (js-vardecl-obj-forms
                     names
                     tmp-sym
-                    (js-vardecl-forms kind (rest decls))))))
+                    (js-vardecl-forms (rest decls))))))
             ((js-tag? d "js-vardecl-arr")
               (let
                 ((names (nth d 1))
@@ -976,7 +976,7 @@
                     names
                     tmp-sym
                     0
-                    (js-vardecl-forms kind (rest decls))))))
+                    (js-vardecl-forms (rest decls))))))
             (else (error "js-vardecl-forms: unexpected decl"))))))))
 
 (define

lib/lua/runtime.sx

@@ -123,7 +123,7 @@
               (fn
                 (i)
                 (if
-                  (not (= (get a (str i)) nil))
+                  (has? a (str i))
                   (begin (set! n i) (count-loop (+ i 1)))
                   n)))
             (count-loop 1))))
@@ -152,9 +152,7 @@
                   (cond
                     ((= (first f) "pos")
                       (begin
-                        (set!
-                          t
-                          (assoc t (str array-idx) (nth f 1)))
+                        (set! t (assoc t (str array-idx) (nth f 1)))
                         (set! array-idx (+ array-idx 1))))
                     ((= (first f) "kv")
                       (let
@@ -171,108 +169,3 @@
     (if (= t nil) nil (let ((v (get t (str k)))) (if (= v nil) nil v)))))
 
 (define lua-set! (fn (t k v) (assoc t (str k) v)))
-
-;; ---------------------------------------------------------------------------
-;; Helpers for stdlib
-;; ---------------------------------------------------------------------------
-
-;; Apply a char function to every character in a string
-(define (lua-str-map s fn) (list->string (map fn (string->list s))))
-
-;; Repeat string s n times
-(define
-  (lua-str-rep s n)
-  (letrec
-    ((go (fn (acc i) (if (= i 0) acc (go (str acc s) (- i 1))))))
-    (go "" n)))
-
-;; Force a promise created by delay
-(define
-  (lua-force p)
-  (if
-    (and (dict? p) (get p :_promise))
-    (if (get p :forced) (get p :value) ((get p :thunk)))
-    p))
-
-;; ---------------------------------------------------------------------------
-;; math — Lua math library
-;; ---------------------------------------------------------------------------
-
-(define math {:asin asin :floor floor :exp exp :huge 1e+308 :tan tan :sqrt sqrt :log log :abs abs :ceil ceil :sin sin :max (fn (a b) (if (> a b) a b)) :acos acos :min (fn (a b) (if (< a b) a b)) :cos cos :pi 3.14159 :atan atan})
-
-;; ---------------------------------------------------------------------------
-;; string — Lua string library
-;; ---------------------------------------------------------------------------
-
-(define
-  (lua-string-find s pat)
-  (let
-    ((m (regexp-match (make-regexp pat) s)))
-    (if (= m nil) nil (list (+ (get m :start) 1) (get m :end)))))
-
-(define
-  (lua-string-match s pat)
-  (let
-    ((m (regexp-match (make-regexp pat) s)))
-    (if
-      (= m nil)
-      nil
-      (let
-        ((groups (get m :groups)))
-        (if (= (len groups) 0) (get m :match) (first groups))))))
-
-(define
-  (lua-string-gmatch s pat)
-  (map (fn (m) (get m :match)) (regexp-match-all (make-regexp pat) s)))
-
-(define
-  (lua-string-gsub s pat repl)
-  (regexp-replace-all (make-regexp pat) s repl))
-
-(define string {:rep lua-str-rep :sub (fn (s i &rest j-args) (let ((slen (len s)) (j (if (= (len j-args) 0) -1 (first j-args)))) (let ((from (if (< i 0) (let ((r (+ slen i))) (if (< r 0) 0 r)) (- i 1))) (to (if (< j 0) (let ((r (+ slen j 1))) (if (< r 0) 0 r)) (if (> j slen) slen j)))) (if (> from to) "" (substring s from to))))) :len (fn (s) (len s)) :upper (fn (s) (lua-str-map s char-upcase)) :char (fn (&rest codes) (list->string (map (fn (c) (integer->char (truncate c))) codes))) :gmatch lua-string-gmatch :gsub lua-string-gsub :lower (fn (s) (lua-str-map s char-downcase)) :byte (fn (s &rest args) (char->integer (nth (string->list s) (- (if (= (len args) 0) 1 (first args)) 1)))) :match lua-string-match :find lua-string-find :reverse (fn (s) (list->string (reverse (string->list s))))})
-
-;; ---------------------------------------------------------------------------
-;; table — Lua table library
-;; ---------------------------------------------------------------------------
-
-(define
-  (lua-table-insert t v)
-  (assoc t (str (+ (lua-len t) 1)) v))
-
-(define
-  (lua-table-remove t &rest args)
-  (let
-    ((n (lua-len t))
-      (pos (if (= (len args) 0) (lua-len t) (first args))))
-    (letrec
-      ((slide (fn (t i) (if (< i n) (assoc (slide t (+ i 1)) (str i) (lua-get t (+ i 1))) (assoc t (str n) nil)))))
-      (slide t pos))))
-
-(define
-  (lua-table-concat t &rest args)
-  (let
-    ((sep (if (= (len args) 0) "" (first args)))
-      (n (lua-len t)))
-    (letrec
-      ((go (fn (acc i) (if (> i n) acc (go (str acc (if (= i 1) "" sep) (lua-to-string (lua-get t i))) (+ i 1))))))
-      (go "" 1))))
-
-(define
-  (lua-table-sort t)
-  (let
-    ((n (lua-len t)))
-    (letrec
-      ((collect (fn (i acc) (if (< i 1) acc (collect (- i 1) (cons (lua-get t i) acc)))))
-        (rebuild
-          (fn
-            (t i items)
-            (if
-              (= (len items) 0)
-              t
-              (rebuild
-                (assoc t (str i) (first items))
-                (+ i 1)
-                (rest items))))))
-      (rebuild t 1 (sort (collect n (list)))))))
-
-(define table {:sort lua-table-sort :concat lua-table-concat :insert lua-table-insert :remove lua-table-remove})