35af6cf | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

35af6cf — Peter John 2026-07-23T17:55:25+05:30

feat: close closures/match/interpolation known gaps in codegen

Files changed (9) hide show

.recall/.capture.json +1 -1
.recall/history.md +654 -0
README.md +6 -12
plum-checker/src/monomorphize.rs +66 -31
plum-wasm-codegen/src/lib.rs +1180 -215
plum-wasm-codegen/tests/codegen_tests.rs +425 -17
plum-wasm-codegen/tests/examples_test.rs +6 -5
tooling/tree-sitter-plum/src/scanner.c +28 -2
tooling/tree-sitter-plum/test/corpus/function.txt +29 -0

.recall/.capture.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"505dc4d5-42ca-45dc-8df3-1f5e1b1c5bc6": 1886367, "78fe4b8b-6ba2-4a17-b415-0bf00e4a0f4d": 4168472, "61ed18b5-cab0-453c-9a65-dcb8cfc58361": 5702751, "4126b3b8-6d8e-4ca3-8898-fa4ab65a979c": ~~2683872~~}
1	+ {"505dc4d5-42ca-45dc-8df3-1f5e1b1c5bc6": 1886367, "78fe4b8b-6ba2-4a17-b415-0bf00e4a0f4d": 4168472, "61ed18b5-cab0-453c-9a65-dcb8cfc58361": 5702751, "4126b3b8-6d8e-4ca3-8898-fa4ab65a979c": 5858356}

.recall/history.md CHANGED Viewed

@@ -7749,3 +7749,657 @@ Now let's fix `else if`, which is a real bug — confirmed it's a single combine
 If it's still showing as type-color in your actual running Helix session, that's very likely a **stale cache** — Helix compiles and caches the query set once per running instance, and picks up `highlights.scm` changes only on a full restart, not just closing/reopening the buffer or `:reload`. Fully quit Helix and reopen it (not just the file) and it should show correctly now — let me know if it still doesn't after that, since I'd want to dig further rather than assume.
 Also fixed along the way: `tooling/tree-sitter-plum/Makefile`'s `make build`/`make corpus_test` called a bare `tree-sitter` binary that isn't installed globally on this machine — updated it to use `npx --yes tree-sitter-cli`, verified both targets now work and produce `grammars/plum.so`.
+**You:** Ok great can you complete and finish the known gaps
+  - `Bash: cd /Users/pyrossh/Code/plum grep -n -i "known gap" -A 40 README.md | head -80`
+  - `Bash: cd /Users/pyrossh/Code/plum grep -n "^## Known gaps" README.md sed -n '/^## Known gaps/,/^## /p' README.md | head -150`
+  - `Bash: cd /Users/pyrossh/Code/plum grep -n -i "known gaps" README.md wc -l README.md`
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+**Claude:** This is a substantial compiler engineering task — let me first get a clear picture of the codegen internals so I can tackle each gap correctly rather than guessing.
+  - `Agent: Survey codegen internals for known-gaps work`
+**Claude:** That research turned up 7 fairly different problems — three are contained (Small/Medium), two are genuinely large and cross-cutting (real type-inference work, and scanner internals with real regression risk), and two are structurally invasive. Here's the shape of it:
+| # | Gap | Difficulty |
+|---|-----|------------|
+| 6 | Named function as `fn(...)` value (`each(double)`) | Small–Medium — design already sketched in an old plan doc |
+| 2 | Multi-subject `match` | Medium |
+| 3 | Nested constructor patterns in `match` | Medium |
+| 4 | Multi-line closure body + closing `)` on the same line | Medium–Large — tree-sitter scanner surgery, regression-prone |
+| 1 | String interpolation codegen | Large — needs a new runtime string-concat/build subsystem that doesn't exist at all |
+| 5 | Closure-via-assignment `call_indirect` trap at Float/class types | Large — real fix lives in the type checker's non-unifying inference, not codegen |
+| 7 | Nested closures | Large — the whole closure-discovery pass is single-level; needs to become recursive with multi-level capture-chain analysis |
+Given the size and risk profile here, I'd rather not silently plow through all seven in one unattended pass — a couple of these touch shared inference/scanner code where a mistake could quietly regress things that already work.
+  - `AskUserQuestion`
+**Claude:** Let's start. First, gap #6 — using a plain top-level function as a `fn(...)`-typed value (e.g. `each(double)`).
+  - `Bash: cd /Users/pyrossh/Code/plum sed -n '1,50p' docs/superpowers/plans/2026-07-20-closures.md | head -5 grep -n "useNamedFunctionAsValue\|named function\|table_index`
+  - `Bash: cd /Users/pyrossh/Code/plum grep -n "struct RawClosure\|struct ClosureInfo\|struct ClosureSigKey\|closures:\|closure_table\|elem_segment\|fn record_closure\|fn`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum grep -n "STRING_BASE\|HEAP_BASE\|bump_global\s*=\|add_data_segment\|memory.min\|Memory {" plum-wasm-codegen/src/lib.rs | head -30`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum grep -n "struct FuncSig" -A 5 plum-wasm-codegen/src/lib.rs grep -n "fn add_type\|fn add_function\|fn add_table_element\|fn add_globa`
+**Claude:** Now let's implement. First, the discovery-pass changes in `ClosureWalker` to detect a bare reference to a top-level function name.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Need to import `HashSet`. Let's make all the changes now.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now the `ClosureWalker` struct — add `locals` and `named_fn_refs` fields:
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update the discovery-loop setup to seed `locals` and collect `named_fn_refs`:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update `walk_stmt`'s `Assign`/`For` arms to track locals, and `walk_expr`'s `Var` arm to detect named function references:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update `walk_expr`'s catch-all to split out `Var`:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "let mut closures: HashMap<usize, ClosureInfo>\|let ctx = CompileCtx\|let mut state = ModuleState\|for f in &fns {$" /Users/pyrossh/Code/plum/plum-wasm-`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "Instruction::End\|fn compile_fn_body" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -10`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "fn finish\|functions.push\|fn add_function" -A 15 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -60`
+  - `Bash: grep -n "Function::new\|CodeSection\|code.function" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -10`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "Function::new\|encode_leb128_u32\|fn compile_fn_body\|Ok(body)\|-> Result<Vec<u8>, String>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | hea`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's wire this into `CompileCtx`/`LocalCtx` and the module-building orchestration. First, the struct fields:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now `LocalCtx`:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now the two `LocalCtx` construction sites:
+  - `Bash: grep -n "closure_call_types: &ctx.closure_call_types," /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum sed -i '' 's/closure_call_types: &ctx.closure_call_types,/closure_call_types: \&ctx.closure_call_types,\n named_fn_values: \&ctx.nam`
+  - `Bash: sed -n '1205,1216p;2298,2310p' /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Good, both aligned correctly. Now the main registration block in `compile_source`, and the `ctx`/`state` construction.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's update `compile_expr`'s `Var` arm to use this table.
+  - `Bash: grep -n "ast::Expr::Var(name) =>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: sed -n '735,750p;925,940p' /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "fn collect_free_vars\|fn fv_collect_refs_expr\|fn fv_collect_refs_stmt" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "^fn fv_collect_refs" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update `fv_collect_refs_block` and `fv_collect_refs_expr` signatures and all recursive calls with a sed-based mechanical pass, then fix the `Var` arm.
+  - `Bash: cd /Users/pyrossh/Code/plum python3 - << 'EOF' import re path = "plum-wasm-codegen/src/lib.rs" src = open(path).read() start = src.index("fn fv_collect_refs_blo`
+**Claude:** Now fix the `Var` arm inside `fv_collect_refs_expr` to skip top-level function names:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Mechanical threading worked. Now fix the `Var` arm itself:
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update the call site of `collect_free_vars` in `record_closure`:
+  - `Bash: grep -n "collect_free_vars(cl" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's check for any other `CompileCtx { ... }` construction sites (tests might build one directly) that need the new `named_fn_values` field, then build.
+  - `Bash: grep -rn "CompileCtx {" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/*.rs 2>/dev/null`
+**Claude:** Good, only one construction site. Let's build.
+  - `Bash: cargo build -p plum-wasm-codegen 2>&1 | tail -100`
+**Claude:** Compiles cleanly. Now let's write a real test proving `each(double)` compiles and runs correctly.
+  - `Bash: grep -n "fn run_main\|fn assert_valid\|fn compile_and_run\|^fn " /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs | head -20`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Now let's write the test for gap #6, using the exact `each(double)` scenario the README/plan docs anticipated.
+  - `Bash: grep -n "^fn run_main" -A 15 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Let's insert our new test right after these closure tests.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: grep -n "cb(5)\|cb(0)\|compile_closure_call\|fn check_fn_call\|ast::Expr::FnCall" /Users/pyrossh/Code/plum/plum-checker/src/lib.rs | head -10`
+  - `Read: /Users/pyrossh/Code/plum/plum-checker/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests named_function -- --nocapture 2>&1 | tail -60`
+**Claude:** All three pass on the first try. Let's run the full test suite to make sure nothing else regressed.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -80`
+**Claude:** Gap #6 done, all tests green. Let's update the README before moving on.
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Now let's tackle gap #2: multi-subject `match`. First let's look at the current match compilation machinery in detail.
+  - `Bash: grep -n "fn compile_match\|fn compile_match_arms\|fn compile_variant_eq_arm\|fn compile_variant_constructor_arm\|fn compile_case_body\|fn match_covers_every_enu`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Let's implement. First, the `Collector`'s `match_scratch` type change and its `Match` walk logic:
+  - `Bash: grep -n "match_scratch: HashMap<usize, PlumType>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now the `walk_stmt`'s `Match` arm:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now the two duplicated slot-allocation blocks:
+  - `Bash: grep -n "for (ptr, ty) in collector.match_scratch.iter()" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's rewrite the core match-compilation functions. Let's view the current state with fresh line numbers:
+  - `Bash: grep -n "^fn match_covers_every_enum_variant\|^fn compile_match\|^fn compile_match_arms\|^fn compile_variant_eq_arm\|^fn compile_variant_constructor_arm\|^fn co`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "compile_match_arms(" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** No stale references. Let's build.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -150`
+**Claude:** Compiles. Now let's fix the `monomorphize.rs` gap flagged in the research (only mangles the first subject/pattern).
+  - `Read: /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-checker 2>&1 | tail -60`
+**Claude:** Now let's write tests for multi-subject match and run everything.
+  - `Bash: grep -n "match_string_pattern_is_a_clear_error\|nested_constructor_pattern_is_a_clear_error" -A 30 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_test`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Let's add multi-subject match tests near the closure tests at the end (with `run_main`), covering compile+runtime correctness.
+  - `Bash: grep -n "fn named_function_used_as_a_value_alongside_a_closure_at_the_same_call_type_runs_correctly" -A 20 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/code`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests multi_subject -- --nocapture 2>&1 | tail -60`
+**Claude:** This is exactly the case in `libs/std/bool.plum`'s `and`/`or` (a full Bool×Bool cross-product with no wildcard). The existing exhaustiveness heuristic only understood single-subject matches — let's generalize it to a proper cross-product check.
+  - `Bash: grep -n "^fn match_covers_every_enum_variant" -A 40 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -45`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update `compile_match` to use this generalized check regardless of subject count:
+  - `Bash: grep -n "match_covers_every_enum_variant\|if let \[(subject_vt, _)\] = all_subjects" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -60`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests multi_subject -- --nocapture 2>&1 | tail -30`
+**Claude:** All 4 pass. Let's run the full suite.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -100`
+**Claude:** All green. Let's update the README and check whether `bool.plum` (which uses this exact `and`/`or` pattern) now actually compiles end-to-end.
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+  - `Bash: cd /Users/pyrossh/Code/plum cat > /tmp/bool_compile_test.rs << 'EOF' use plum_checker::check_source; use plum_core::AstParser; use plum_wasm_codegen::compile_so`
+  - `Bash: sed -i '' 's#libs/std/bool.plum#/Users/pyrossh/Code/plum/libs/std/bool.plum#' /tmp/bool_check/src/main.rs cd /tmp/bool_check && cargo run 2>&1 | tail -10`
+  - `Bash: rm -rf /tmp/bool_check /tmp/bool_compile_test.rs`
+**Claude:** Confirms our fix directly unblocks `and`/`or` (the remaining error is just `Ok`/`Err` living in a separate file — a cross-module concern, not related to this gap). Now let's tackle gap #3: nested constructor patterns inside `match`.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Given how the recursion works, I can keep this contained — reusing the existing top-level dispatch and adding a new recursive helper just for a constructor pattern's own fields. Let's implement.
+  - `Bash: grep -n "struct Collector\|classcall_scratch: HashMap<usize, u32>,\|next_classcall_slot: u32,\|match_scratch: HashMap" /Users/pyrossh/Code/plum/plum-wasm-codege`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's add the recursive binding/scratch-collection method and rewire the `Match` handling in `walk_stmt`:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update the `Match` handling in `walk_stmt` to call this instead of its old flat binding logic:
+  - `Bash: grep -n "ast::Stmt::Match(m) =>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** This is the one to replace.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "next_closure_slot: 0," /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum sed -i '' 's/next_closure_slot: 0,/next_closure_slot: 0,\n nested_class_scratch: HashMap::new(),\n next_nested_class_slot: 0,/' plum`
+**Claude:** Now let's add `LocalCtx` fields and wire the slot-allocation logic (both places):
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now update the two slot-allocation blocks (in `compile_fn_body` and `compile_closure_body`):
+  - `Bash: grep -n "let closure_scratch_base = idx;" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "closure_scratch_base,\s*$\|closure_scratch: collector.closure_scratch,\s*$" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum python3 - << 'EOF' path = "plum-wasm-codegen/src/lib.rs" src = open(path).read() old = " closure_scratch_base,\n closure_scratch: co`
+**Claude:** Now let's build to catch any remaining field-mismatch errors.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -80`
+**Claude:** Good, plumbing compiles — just unused until we wire it into the constructor-arm field loop. Now let's write `compile_fields`/`compile_field_pattern` and update `compile_variant_constructor_arm`.
+  - `Bash: grep -n "^fn compile_variant_constructor_arm" -A 75 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -80`
+  - `Bash: grep -n "^fn emit_store\|^fn emit_load" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's rewrite `compile_variant_constructor_arm`'s field loop and add the two new recursive helpers.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -150`
+**Claude:** Now let's flip the existing "clear error" test into a positive test, and add a couple more covering binding + fallthrough.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests nested_constructor -- --nocapture 2>&1 | tail -60 cargo test -p plum-wasm-codeg`
+  - `Bash: grep -n "fn collect_pattern\|collect_pattern(" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "^fn compile_case_body" -A 40 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -45`
+  - `Bash: grep -n "Stmt::Todo =>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Root cause found: the exhaustiveness heuristic clones `m.cases` to append a synthetic wildcard, which reallocates every nested `CasePattern::Class` node at a new address — breaking the pointer-identity-keyed scratch-slot lookup. Let's fix it by threading a boolean flag instead of cloning.
+  - `Bash: grep -n "compile_match_arms_multi(rest, all_subjects, result_vt, body, ctx, state)\|fn compile_match_arms_multi\|fn compile_case_positions\|fn compile_variant_e`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's rewrite this whole section with the threaded `exhaustive_fallback: bool` instead of cloning.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's view and update `compile_match_arms_multi`'s body and signature:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Given the volume of mechanical threading needed across these four functions, let's do it with a careful scripted rewrite rather than dozens of manual edits.
+  - `Bash: cd /Users/pyrossh/Code/plum python3 - << 'PYEOF' import re path = "plum-wasm-codegen/src/lib.rs" src = open(path).read() start = src.index("fn compile_case_posi`
+**Claude:** Let's build and see what's left.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | grep -E "^error" -A 8 | head -200`
+**Claude:** Just one over-eager replacement — `compile_case_body` doesn't need this param. Let's fix it.
+  - `Bash: grep -n "compile_case_body(&case.body, result_vt, exhaustive_fallback, body, ctx, state)" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | grep -E "^error" -A 8 | head -200`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -30`
+  - `Bash: grep -n "exhaustive_fallback" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | wc -l sed -n '1980,2050p' /Users/pyrossh/Code/plum/plum-wasm-codegen/src/l`
+**Claude:** Threading correctly propagated into the nested closure too. Now let's run the tests.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests -- --nocapture 2>&1 | tail -100`
+**Claude:** All 62 pass, including the two previously-failing nested-constructor tests. Let's run the full workspace suite.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -50`
+**Claude:** Now let's also fix the monomorphize.rs side for gap #3 — recursing into nested constructor-pattern fields for generic-enum mangling.
+  - `Read: /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+  - `Bash: grep -n "fn rewrite_stmt\|impl.*Monomorphizer\|enum_variant_mangling:\|enum_variants:" /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs | head -20`
+  - `Read: /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+**Claude:** Let's add `mangle_pattern` right before `rewrite_stmt`:
+  - `Edit: /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+**Claude:** Now let's also update the call site to pass `Option<&BTreeMap<...>>` instead of `Option<BTreeMap<...>>`:
+  - `Bash: grep -n "self.mangle_pattern(pat, subject_ty, variant_mangling" /Users/pyrossh/Code/plum/plum-checker/src/monomorphize.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-checker 2>&1 | tail -60`
+**Claude:** Now let's write a test proving nested constructor patterns against a generic-enum specialization work correctly.
+  - `Bash: grep -n "fn generic_enum_specialized_and_matched_runs_correctly\|fn generic_enum_multiple_instantiations_coexist_and_run_correctly" -A 20 /Users/pyrossh/Code/pl`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests nested_constructor_pattern_against -- --nocapture 2>&1 | tail -40`
+**Claude:** Passes. Let's run the full suite once more to confirm everything's still green.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -60`
+**Claude:** Gap #3 done. Let's update the README.
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Now gap #4 — the scanner surgery for multi-line closure bodies followed by a closing bracket on the same line. Let's study the scanner carefully first.
+  - `Bash: wc -l /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+**Claude:** Now let's rebuild the parser (native scanner) and regenerate.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make build 2>&1 | tail -40`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make corpus_test 2>&1 | tail -40`
+**Claude:** All 28 existing corpus tests still pass. Now let's directly test the exact target syntax with the tree-sitter CLI parse command.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum cat > /tmp/multiline_closure.plum << 'EOF' each(cb: fn(Int) -> Int) -> Int = cb(5) main() -> Int = each(|v|`
+**Claude:** It parses correctly with zero errors. Let's test a multi-statement body too, and the case with a trailing comma/multiple args.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum cat > /tmp/multiline_closure2.plum << 'EOF' each(cb: fn(Int) -> Int) -> Int = cb(5) main() -> Int = each(|v`
+**Claude:** Excellent — multi-statement bodies work too. Let's check a couple more edge cases (nested brackets, additional args after the closure) before locking this in.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum cat > /tmp/multiline_closure3.plum << 'EOF' each(cb: fn(Int) -> Int, extra: Int) -> Int = cb(5) + extra mai`
+  - `Bash: cat /tmp/out3.txt`
+**Claude:** Let's handle the comma-continuation case too (closure followed by more call arguments on the same line) — same root cause.
+  - `Bash: grep -n "at_closing_bracket_without_newline" /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make build 2>&1 | tail -20 npx --yes tree-sitter-cli parse /tmp/multiline_closure3.plum > /tmp/out3.txt 2>&`
+**Claude:** That specific case (comma continuation) doesn't have `DEDENT` as a valid symbol at that exact parser state, so my extension didn't help — and it's outside the documented gap anyway (which specifically calls out the closing-bracket case). Let's revert that speculative addition and keep scope to what's proven and documented.
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c`
+**Claude:** Let's rebuild and re-verify everything, then run the full corpus + Rust test suites.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make build 2>&1 | tail -20 make corpus_test 2>&1 | tail -15`
+**Claude:** Now let's add a corpus test locking in this new behavior, then run the full Rust workspace suite (which will actually compile & execute wasm for this shape).
+  - `Bash: grep -n "function - inline closure literal as a call argument" -A 20 /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/test/corpus/function.txt`
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/test/corpus/function.txt`
+**Claude:** Let's add a new corpus case right after this for the multi-line body + same-line closing paren.
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/test/corpus/function.txt`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make corpus_test 2>&1 | tail -20`
+**Claude:** All 29 pass. Now let's run the full Rust workspace test suite (which rebuilds the vendored scanner.c via cargo's build.rs) to confirm nothing regressed.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -100`
+**Claude:** Now let's update the existing codegen test that explicitly avoided this shape, and add a real multi-statement version.
+  - `Bash: grep -n "non_capturing_closure_passed_and_called_runs_correctly" -A 20 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests multi_line_closure -- --nocapture 2>&1 | tail -30`
+**Claude:** Real end-to-end wasm execution proves it. Let's run the full suite once more and update the README, then also simplify `libs/std/list.plum`'s `join()` now that this actually works.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -15`
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Let's tackle gap #1: string interpolation codegen. First, let's understand the existing string representation exactly.
+  - `Bash: grep -n "ast::Expr::String(s) =>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cat /Users/pyrossh/Code/plum/examples/strings.plum`
+  - `Bash: grep -n "wasm-encoder" /Users/pyrossh/Code/plum/plum-wasm-codegen/Cargo.toml grep -rn "MemoryCopy\|memory.copy\|bulk" /Users/pyrossh/Code/plum/plum-wasm-codegen`
+  - `Bash: grep -n "MemoryCopy\|MemoryFill" ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wasm-encoder-0.224.1/src/core/code.rs | head -5`
+  - `Bash: grep -n "Instruction::Loop\|Instruction::Block\|Instruction::BrIf\|Instruction::Br(" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -20`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** This is a substantial addition — I need to hand-write two runtime helper functions in raw wasm bytecode (string concatenation and int-to-string conversion), since wasm has no built-in string manipulation. Let me implement carefully and test thoroughly.
+  - `Bash: grep -n "pub struct FuncSig\|struct CompileCtx" -A 20 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -25`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now `LocalCtx`:
+  - `Bash: grep -n "named_fn_values: &'a HashMap<String, u32>," /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's update both `LocalCtx` construction sites:
+  - `Bash: grep -n "named_fn_values: &ctx.named_fn_values," /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum python3 - << 'EOF' path = "plum-wasm-codegen/src/lib.rs" src = open(path).read() old = " named_fn_values: &ctx.named_fn_values,\n" n`
+**Claude:** Now let's write the two helper-function-generator functions and wire them into `compile_source`.
+  - `Bash: grep -n "let ctx = CompileCtx {" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "^pub fn compile_source" -A 2 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs awk '/^pub fn compile_source/{f=1} f && /^}/{print NR; exit}' /Users`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's insert the two helper-generator functions right after `compile_source`:
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's wire up the actual `Expr::String` interpolation-lowering logic.
+  - `Bash: grep -n "ast::Expr::String(s) =>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's add `compile_static_string` and `compile_interpolated_string` helper functions right after this. Let's find a good spot (near `emit_load`/`emit_store`):
+  - `Bash: grep -n "^fn emit_load" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -150`
+  - `Bash: grep -n "struct Str\|enum StringPart\|pub struct.*Str" /Users/pyrossh/Code/plum/plum-core/src/ast.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-core/src/ast.rs`
+  - `Bash: grep -n "String(" /Users/pyrossh/Code/plum/plum-core/src/ast.rs | head -5`
+  - `Bash: grep -n "fn compile_interpolated_string" -A 15 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -100`
+**Claude:** Now let's update the two existing "clear error" tests that assumed interpolation was unsupported, and write real positive tests that read the string back from wasm memory.
+  - `Bash: grep -n "string_interpolation_is_a_clear_error" -A 10 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs echo "---" grep -n "strings_example_repo`
+  - `Bash: grep -n "add_export.*[Mm]emory\|ExportKind::Memory" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "enum ExportKind\|fn add_memory" -A 8 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -30`
+  - `Bash: grep -n "ExportKind" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -5`
+  - `Bash: grep -n "module.add_memory" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -30`
+**Claude:** Now let's write the test helper and real tests.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: grep -n "^fn run_main" -A 10 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Let's add a `run_main_str` helper right after `run_main`.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Now let's replace the "clear error" test with real positive tests.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Now let's fix the `examples_test.rs` one and check `examples/strings.plum` content, since it uses interpolation extensively.
+  - `Bash: cat /Users/pyrossh/Code/plum/examples/strings.plum echo "---" sed -n '1,120p' /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/examples_test.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/examples_test.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests string_interpolation -- --nocapture 2>&1 | tail -60`
+  - `Bash: which wasm2wat wasm-tools 2>&1 cargo tree -p plum-wasm-codegen 2>&1 | grep -i "wasmprinter\|wat "`
+**Claude:** `wasm-tools` is available. Let's dump the failing module and inspect around the byte offset.
+  - `Bash: cd /Users/pyrossh/Code/plum cat > /tmp/dump_wasm.rs << 'EOF' fn main() { let src = "main() -> Str =\n x = 42\n \"{x}\"\n"; let mut parser = tree_sitter::Parser`
+  - `Bash: wasm-tools print /tmp/out.wasm 2>&1 | head -150`
+  - `Bash: wasm-tools print /tmp/out.wasm 2>&1 | sed -n '150,220p'`
+  - `Bash: wasm-tools validate /tmp/out.wasm 2>&1`
+**Claude:** Found the bug — the `string_concat` helper's bump-allocation math is missing a final `I32Add` to combine the saved base pointer with the computed size (the `int_to_string` helper has it correctly, `string_concat` doesn't). Let's fix it.
+  - `Bash: grep -n "register_string_concat_helper" -A 25 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -30`
+  - `Bash: grep -n "result = bump; bump += 4 + len_a + len_b" -A 10 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's rebuild, re-validate, and re-run the tests.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -10 cd /tmp/dumpwasm && cargo run 2>&1 | tail -5 wasm-tools validate /tmp/out.wasm 2>&1`
+  - `Bash: wasm-tools print /tmp/out.wasm 2>&1 | sed -n '95,145p'`
+  - `Bash: wasm-tools print /tmp/out.wasm 2>&1 | sed -n '140,180p'`
+  - `Bash: wasm-tools print /tmp/out.wasm 2>&1 | sed -n '85,100p'`
+**Claude:** Found it — a local-index/type mismatch: I declared locals as one group of 5 `i32` then one group of 2 `i64`, but my constants interleaved i32/i64 assignments assuming per-variable ordering. Let me fix the constant indices to match the actual declared groups.
+  - `Bash: grep -n "const N: u32 = 0;" -A 10 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Let's verify the locals group declaration matches (5 i32, then 2 i64), rebuild, and re-validate.
+  - `Bash: grep -n "body.extend(encode_leb128_u32(2)); // two locals groups" -A 5 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Good, matches. Let's rebuild and re-validate.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -10 cd /tmp/dumpwasm && cargo run 2>&1 | tail -5 wasm-tools validate /tmp/out.wasm 2>&1`
+**Claude:** Valid now. Let's clean up the scratch project and run the full test suite.
+  - `Bash: rm -rf /tmp/dumpwasm /tmp/out.wasm /tmp/dump_wasm.rs cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests string_interpolation -- --`
+**Claude:** All 7 pass, including negative numbers, zero, multi-interpolation, Str, and Bool. Let's run the complete workspace suite.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -100`
+**Claude:** Gap #1 done. Let's update the README.
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Now let's tackle gap #5 — the `call_indirect` trap. Let's look at the exact checker logic for closure inference first.
+  - `Bash: grep -n "ast::Expr::Closure(cl) =>" -A 20 /Users/pyrossh/Code/plum/plum-checker/src/lib.rs`
+  - `Bash: grep -n "fn record_closure" -A 40 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -45`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "^fn collect_free_vars" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Let's insert the new helper functions right before `collect_free_vars`:
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** That got garbled — let me fix the `Not`/`Unary` arm properly.
+  - `Bash: grep -n "ast::Expr::Not(inner) | ast::Expr::Unary" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -150`
+**Claude:** I need to check the call-site's own signature re-derivation too, since it independently re-infers the closure's type — let's find that.
+  - `Bash: grep -n "ast::Stmt::Assign(a) =>" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "type_env.borrow_mut().insert" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -20`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "^fn compile_closure_call" -A 45 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** I also need to fix the call-site's own signature re-derivation, which independently re-infers the closure's type from `ctx.type_env` (populated via the same buggy checker inference at the assignment site) — otherwise the two would now disagree. Let's add a side-channel that threads the already-correct `ClosureInfo` through.
+  - `Bash: grep -n "string_concat_func: u32,\s*$" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's initialize this field at both `LocalCtx` construction sites:
+  - `Bash: grep -n "type_env: RefCell::new(base_env)," /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum python3 - << 'EOF' path = "plum-wasm-codegen/src/lib.rs" src = open(path).read() old = " type_env: RefCell::new(base_env),\n" new =`
+**Claude:** Now let's update the `Assign` handling in `compile_stmt` to populate this map when the value is a closure literal:
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's update `compile_closure_call` to check this map first:
+  - `Bash: grep -n "^fn compile_closure_call" -A 25 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -100`
+**Claude:** Compiles cleanly. Now let's write the exact regression test for the documented bug — a closure assigned via `=` and later called at Float and at a class/pointer type.
+  - `Bash: grep -n "fn capturing_closure_snapshots_value_at_creation_time_runs_correctly" -A 20 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: grep -n "^fn run_main(bytes" -A 10 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Let's add an `f64` runner right after `run_main`.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+**Claude:** Now let's add the regression tests right after `capturing_closure_snapshots_value_at_creation_time_runs_correctly`.
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests closure_assigned_then_called -- --nocapture 2>&1 | tail -40`
+**Claude:** Let's extend the resolution to handle the class/pointer case via attribute access (`c.age` implies `c`'s type has an `age` field).
+  - `Bash: grep -n "pub type ClassEnv" /Users/pyrossh/Code/plum/plum-checker/src/lib.rs`
+  - `Bash: grep -n "pub struct CheckCtx" -A 6 /Users/pyrossh/Code/plum/plum-checker/src/lib.rs`
+**Claude:** Now let's update the `Attribute` arm in `scan_expr_for_param_types`:
+  - `Bash: grep -n "ast::Expr::Attribute(a) => {" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "enum AttrKind" -A 6 /Users/pyrossh/Code/plum/plum-core/src/ast.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -60`
+  - `Bash: grep -n "struct Attribute" -A 5 /Users/pyrossh/Code/plum/plum-core/src/ast.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -60`
+**Claude:** Compiles. Let's test.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests closure_assigned_then_called -- --nocapture 2>&1 | tail -30`
+  - `Bash: cd /Users/pyrossh/Code/plum mkdir -p /tmp/dumpwasm2/src cat > /tmp/dumpwasm2/src/main.rs << 'EOF' fn main() { let src = "\ type Cat = age: Int eachCat(cb: fn(Ca`
+  - `Bash: wasm-tools print /tmp/out2.wasm 2>&1`
+  - `Bash: rm -rf /tmp/dumpwasm2 /tmp/out2.wasm grep -n "impl<'a> Collector" -A 3 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: sed -n '1490,1560p' /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "ast::Expr::Closure" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: grep -n "let mut collector = Collector {" -A 15 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -20`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -10 mkdir -p /tmp/dumpwasm3/src cat > /tmp/dumpwasm3/src/main.rs << 'EOF' fn main() { l`
+**Claude:** Found it — a *third* place with the same root problem: the `Collector` (which decides each local's wasm `ValType`) also calls the checker's fragile closure inference, and here it fails outright (returns `Err`, not just a bad `TVar`), silently defaulting `cb`'s local slot to `Int` (i64) instead of the pointer type (i32) every closure actually is. Let's remove my debug print and fix this properly.
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's fix `Collector::walk_stmt`'s `Assign` arm to not rely on the fragile whole-closure inference for local-slot typing:
+  - `Bash: grep -n "fn walk_stmt(&mut self, stmt: &ast::Stmt) {" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Let's apply the same defensive fix to `compile_stmt`'s runtime type-tracking for consistency, then rebuild and test.
+  - `Bash: grep -n "let vty = infer_local_type(value, ctx);" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's rebuild and test.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -20 cargo test -p plum-wasm-codegen --test codegen_tests closure_assigned_then_called -`
+**Claude:** Both pass. Let's clean up scratch files and run the full workspace suite.
+  - `Bash: rm -rf /tmp/dumpwasm3 cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -100`
+**Claude:** All green. Gap #5 done — let's update the README.
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Now the final one — gap #7, nested closures. Let's implement it by making `record_closure` recurse into the closure's own body using the same `ClosureWalker` machinery.
+  - `Bash: grep -n "fn record_closure" -A 40 /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -45`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's fix `fv_collect_refs_expr`'s catch-all, which currently skips into nested closures entirely (needed for the outer closure's own capture list to include names its nested closure needs from the outer's scope):
+  - `Bash: grep -n "A nested closure isn't supported by the discovery pre-pass" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Let's also clean up the now-inaccurate error message in `compile_closure_literal`.
+  - `Bash: grep -n "nested closures are not supported" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+**Claude:** Now let's build and test.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -100`
+  - `Bash: grep -n "param_ptypes,$" /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs | head -5`
+  - `Read: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/src/lib.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-wasm-codegen 2>&1 | tail -60`
+**Claude:** Compiles. Now let's write tests for nested closures.
+  - `Bash: grep -n "fn closure_passed_through_already_generic_higher_order_function_runs_correctly" -A 15 /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-wasm-codegen/tests/codegen_tests.rs`
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test -p plum-wasm-codegen --test codegen_tests nested_closure -- --nocapture 2>&1 | tail -60`
+**Claude:** Both pass on the first try. Let's run the complete workspace suite one final time.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | tail -110`
+**Claude:** All 7 gaps done. Let's do the final README update.
+  - `Read: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Now the final Known Gaps section:
+  - `Edit: /Users/pyrossh/Code/plum/README.md`
+**Claude:** Let's do one final full verification pass and review the overall diff.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo test --workspace 2>&1 | grep -E "test result:|FAILED|error\[" echo "---" git status --short | head -30`
+**Claude:** All 7 known gaps from the README are now closed, and the entire workspace test suite is green (0 failures across every crate).
+## Summary
+Worked through all 7 gaps in the agreed order (6 → 2 → 3 → 4 → 1 → 5 → 7), verifying each with real `wasmtime` execution before moving on:
+1. **Named function as a `fn(...)`-typed value** (`each(double)`) — compiles as a zero-capture "trampoline" closure: a synthetic wasm function forwarding to the real one, registered once in the funcref table with a compile-time-constant `{table_idx, env_ptr=0}` struct (no runtime allocation needed).
+2. **Multi-subject `match`** (`match a, b`) — reworked the match compiler to evaluate N subjects into N scratch locals and check patterns position-by-position with correct AND/fallthrough semantics. Bonus: generalized the exhaustiveness heuristic to full cross-products, which is what let `libs/std/bool.plum`'s `and`/`or` (`match self, o` over all 4 `Bool×Bool` combinations) compile at all. Also fixed a monomorphize.rs bug that only mangled the first subject's generic-enum variants.
+3. **Nested constructor patterns** (`Some(Some(v))`) — made the constructor-arm field-matching recursive, arbitrary depth, with correct case-to-case fallthrough on a nested mismatch. Also fixed monomorphize.rs to recurse into nested patterns' own field types for generic-enum mangling.
+4. **Multi-line closure body + closing `)` on the same line** — real scanner surgery in `tooling/tree-sitter-plum/src/scanner.c`: taught the external scanner to emit a DEDENT when the parser needs one but no newline preceded (only when gated by the grammar's own `valid_symbols[DEDENT]`, so it can't misfire elsewhere).
+5. **String interpolation codegen** — built two hand-written wasm runtime helpers (`__string_concat`, `__int_to_string`) from scratch, byte-copy loops and all. Caught and fixed two real bugs this way (a missing pointer-arithmetic `add` and a local-index/type mismatch) — both found via `wasm-tools validate`, not guessing. `Str`/`Int`/`Bool` interpolation all work; `Float` gets a clear error (real decimal formatting is its own project).
+6. **`call_indirect` trap for closures assigned then called at Float/class type** — the checker's closure inference gives every param a fresh, never-unified `TVar`, defaulting silently to `Int`. Added a usage-based resolution pass (`resolve_closure_param_types_from_usage`) plus a side-channel (`closure_local_sigs`) so the call site's signature can't drift from what the closure's body was actually compiled with.
+7. **Nested closures** — made the discovery pass recurse into a closure's own body, and fixed free-variable collection to propagate multi-level captures correctly (a name only the inner closure needs still gets captured by the outer, but a name the outer already binds doesn't).
+Also updated the README's closure/match sections to drop language describing now-fixed limitations, and cleaned up now-inaccurate error messages/test names along the way.

README.md CHANGED Viewed

@@ -262,11 +262,11 @@ main() -> Int =
 A closure literal is `|params| body`: zero or more bare parameter names between pipes, followed by an expression or an indented block body. A parameter's type is inferred from context (e.g. the declared type of the `fn(...)` slot it's passed into) rather than annotated inline.
-A `fn(...)` / `fn(...) -> T` type annotates a closure-typed parameter or field: `fn(Int) -> Int` is a function from one `Int` to an `Int`; parameter types are positional only (no names). Closures compile to a `{table_index, env_pointer}` pair and are called via `call_indirect` through a function table, so a `fn(...)`-typed value can hold either a closure literal or (once that gap below is closed) a plain function.
+A `fn(...)` / `fn(...) -> T` type annotates a closure-typed parameter or field: `fn(Int) -> Int` is a function from one `Int` to an `Int`; parameter types are positional only (no names). Closures compile to a `{table_index, env_pointer}` pair and are called via `call_indirect` through a function table, so a `fn(...)`-typed value can hold a closure literal, a plain top-level named function (`each(double)` — compiled as a zero-capture "trampoline" closure), or a closure nested inside another closure's body.
 Capture is **snapshot-by-value**: any outer variable a closure body references is copied into the closure's environment at the moment the closure literal is evaluated, not re-read live later. Reassigning the captured variable afterward does not change what the closure sees.
-Closures parse and compile in two shapes: passed directly as a call argument (`each(|v| v * 3)`, single-line body only — see Known gaps), or assigned to a local first and called or passed on later (`cb = |v|\n  v + offset` followed by `cb(5)` or `each(cb)`, which does support a multi-line indented body).
+Closures parse and compile in two shapes: passed directly as a call argument (`each(|v| v * 3)`), or assigned to a local first and called or passed on later (`cb = |v|\n  v + offset` followed by `cb(5)` or `each(cb)`). Both support a multi-line indented body.
 Full example: [`examples/closures.plum`](examples/closures.plum).
@@ -327,7 +327,7 @@ match opt
     0
 ```
-A case body can be a single inline expression right after `=>`, or an indented block — pick whichever reads better for that arm. Patterns can be: integer/float/string literals, a bare identifier (binds a new local to the subject's value), a bare capitalized tag (`True`, `False`, or any declared `enum` variant with no payload — compared, not bound), a constructor pattern (`Some(v)`, binding its argument), or `_` (wildcard). Multiple comma-separated subjects/patterns are accepted by the grammar but not yet lowered by codegen.
+A case body can be a single inline expression right after `=>`, or an indented block — pick whichever reads better for that arm. Patterns can be: integer/float/string literals, a bare identifier (binds a new local to the subject's value), a bare capitalized tag (`True`, `False`, or any declared `enum` variant with no payload — compared, not bound), a constructor pattern (`Some(v)`, binding its argument — sub-patterns can themselves be constructor patterns, e.g. `Wrap(Some(v))`), or `_` (wildcard). `match a, b, ...` against multiple comma-separated subjects is also supported — each case supplies one pattern per subject, and every position must match for that case to apply.
 Full example: [`examples/match.plum`](examples/match.plum).
@@ -338,7 +338,7 @@ greet(name: Str) -> Str =
   "Hello, {name}!"
 ```
-`{expr}` inside a string interpolates a single primary expression (a variable, literal, attribute access, etc). Parses and type-checks; codegen doesn't lower it yet (see below).
+`{expr}` inside a string interpolates a single primary expression (a variable, literal, attribute access, etc). Parses, type-checks, and compiles for `Str`, `Int`, and `Bool` values; interpolating a `Float` reports a clear error (see below).
 Full example: [`examples/strings.plum`](examples/strings.plum).
@@ -346,11 +346,5 @@ Full example: [`examples/strings.plum`](examples/strings.plum).
 Some things parse and type-check but don't compile to wasm yet — `plum-wasm-codegen` reports a clear error rather than silently producing wrong code:
-- string interpolation (plain, non-interpolated string literals do compile)
-- multi-subject `match` (`match a, b`)
-- nested constructor patterns inside `match` (`Some(Some(v))`) — a constructor pattern's own sub-patterns must be a bare binding or `_`
-- `libs/std`'s actual `List`/`Map`/`Option`/`Result` still don't compile — they use several other unimplemented features (`Nil`/optional chaining, decorators, colon-arrow return syntax) unrelated to generics, which are themselves now monomorphized and compiled correctly for the currently-documented generic syntax
-- a closure literal used directly as a call argument only parses with a single-line body (`each(|v| v * 3)`); a multi-line indented body immediately followed by a closing `)` on the same line as the body's last statement (e.g. `each(|v|\n  v)`) does not yet parse — the external scanner doesn't emit a `DEDENT` at a closing bracket. Assigning the closure to a local first (`cb = |v|\n  v + offset` then `cb(...)` or `each(cb)`) does support a multi-line body and sidesteps this
-- a closure created via assignment (not passed directly as a call argument) and later called at a concrete non-`Int` type (`Float` or a class/pointer type) can hit a wasm runtime trap due to a signature-resolution gap in `call_indirect` dispatch; this does not affect closures over `Int`, or closures passed directly as call arguments at any type. Tracked as a separate follow-up task
-- a plain top-level named function (not a `|params| body` closure literal) cannot yet be used directly as a `fn(...)`-typed value (e.g. `each(double)`) — only closure literals are supported at closure-typed call sites today
-- a closure literal nested inside another closure's body is not supported (produces a clear compile error)
+- interpolating a `Float` value in a string (`Str`/`Int`/`Bool` interpolation, and plain non-interpolated literals, all compile) — correct decimal formatting of a float is a substantial separate undertaking (something like Grisu/Ryu), scoped out for now
+- `libs/std`'s actual `List`/`Map` still don't fully compile — mutating a field or attribute (`self.head = ...`) isn't a supported assignment target yet (only a plain local variable is), and there's no cross-file import resolution yet either, so a file that references a type/enum declared in a different `libs/std` file won't type-check standalone

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -326,6 +326,55 @@ impl<'a> Monomorphizer<'a> {
         Ok(())
     }
+    /// Rewrites `pat` (bare-name/constructor pattern) in place: an uppercase variant
+    /// name gets mangled to its specialized form (`Some` -> `Some$Int`) if `mangling`
+    /// says this position's subject is a specialized generic enum; a plain binding
+    /// name is inserted into `case_env` at `ty`. Recurses into a constructor
+    /// pattern's own fields (`Some(Some(v))`), looking up *that* field's own
+    /// mangling table from `self.enum_variant_mangling` — a nested sub-pattern can
+    /// be a specialization independent of its enclosing pattern's.
+    fn mangle_pattern(
+        &self,
+        pat: &mut ast::CasePattern,
+        ty: &PlumType,
+        mangling: Option<&BTreeMap<String, String>>,
+        case_env: &mut TypeEnv,
+    ) {
+        match pat {
+            ast::CasePattern::Name(n) => {
+                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                    && self.enum_variants.contains_key(n.as_str());
+                if is_variant {
+                    if let Some(table) = mangling {
+                        if let Some(mangled_variant) = table.get(n) {
+                            *n = mangled_variant.clone();
+                        }
+                    }
+                } else {
+                    case_env.insert(n.clone(), TypeScheme::mono(ty.clone()));
+                }
+            }
+            ast::CasePattern::Class { name, fields } => {
+                if let Some(table) = mangling {
+                    if let Some(mangled_variant) = table.get(name) {
+                        *name = mangled_variant.clone();
+                    }
+                }
+                if let Some(info) = self.enum_variants.get(name.as_str()) {
+                    let field_types = info.field_types.clone();
+                    for (f, fty) in fields.iter_mut().zip(field_types.iter()) {
+                        let field_mangling = match fty {
+                            PlumType::TNamed(n) => self.enum_variant_mangling.get(n),
+                            _ => None,
+                        };
+                        self.mangle_pattern(f, fty, field_mangling, case_env);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
     fn rewrite_stmt(&mut self, stmt: &mut ast::Stmt, env: &mut TypeEnv) -> Result<(), String> {
         match stmt {
             ast::Stmt::Assign(a) => {
@@ -366,42 +415,28 @@ impl<'a> Monomorphizer<'a> {
                 for s in &mut m.subjects {
                     self.rewrite_expr(s, env)?;
                 }
+                // One (type, variant-mangling table) pair per subject — `match a, b`
+                // needs each position's own generic-enum specialization handled
+                // independently, not just the first subject's.
-                let subject_ty = m.subjects.first().map(|s| self.infer(s, env)).unwrap_or(PlumType::TInt);
+                let subject_types: Vec<PlumType> = m.subjects.iter().map(|s| self.infer(s, env)).collect();
-                // If the subject's concrete type is a specialized generic enum, its
+                // If a subject's concrete type is a specialized generic enum, its
-                // variant-name mangling table lets us rewrite this match's patterns
+                // variant-name mangling table lets us rewrite that position's patterns
                 // (`Some`/`None` -> `Some$Int`/`None$Int`) to reference the correct
                 // specialization, so the checker/codegen's unmodified, bare-name-keyed
                 // `EnumVariants` lookup still resolves each pattern correctly.
-                let variant_mangling: Option<BTreeMap<String, String>> = match &subject_ty {
+                let variant_manglings: Vec<Option<BTreeMap<String, String>>> = subject_types
+                    .iter()
+                    .map(|ty| match ty {
-                    PlumType::TNamed(n) => self.enum_variant_mangling.get(n).cloned(),
+                        PlumType::TNamed(n) => self.enum_variant_mangling.get(n).cloned(),
-                    _ => None,
+                        _ => None,
-                };
+                    })
+                    .collect();
                 for case in &mut m.cases {
                     let mut case_env = env.clone();
-                    if let Some(pat) = case.patterns.first_mut() {
-                        match pat {
-                            ast::CasePattern::Name(n) => {
-                                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                                    && self.enum_variants.contains_key(n.as_str());
-                                if is_variant {
-                                    if let Some(table) = &variant_mangling {
+                    for (pat, (subject_ty, variant_mangling)) in
-                                        if let Some(mangled_variant) = table.get(n) {
-                                            *n = mangled_variant.clone();
-                                        }
-                                    }
-                                } else {
-                                    case_env.insert(n.clone(), TypeScheme::mono(subject_ty.clone()));
+                        case.patterns.iter_mut().zip(subject_types.iter().zip(variant_manglings.iter()))
-                                }
+                    {
-                            }
-                            ast::CasePattern::Class { name, .. } => {
-                                if let Some(table) = &variant_mangling {
+                        self.mangle_pattern(pat, subject_ty, variant_mangling.as_ref(), &mut case_env);
-                                    if let Some(mangled_variant) = table.get(name) {
-                                        *name = mangled_variant.clone();
-                                    }
-                                }
-                            }
-                            _ => {}
-                        }
                     }
                     self.rewrite_block(&mut case.body, &mut case_env)?;
                 }

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -1,6 +1,6 @@
 use wasm_encoder::*;
 use std::cell::RefCell;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use plum_core::ast;
 use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
 use plum_checker::{ClassEnv, MethodEnv, EnumVariants, EnumVariantInfo};
@@ -256,6 +256,19 @@ pub struct CompileCtx<'a> {
     pub closure_asts: HashMap<usize, &'a ast::Closure>,
     /// Closure wasm signature -> function-type index, for `call_indirect` at call sites.
     pub closure_call_types: HashMap<ClosureSigKey, u32>,
+    /// Top-level function name -> static data offset of its zero-capture "trampoline"
+    /// closure struct `{table_idx, env_ptr=0}`, for using a plain named function
+    /// wherever a `fn(...)`-typed value is expected (e.g. `each(double)`). Since the
+    /// struct has no captures it never changes, so it's baked into a data segment
+    /// once at compile time instead of being bump-allocated per reference.
+    pub named_fn_values: HashMap<String, u32>,
+    /// Shared runtime helper `(a: i32, b: i32) -> i32`: bump-allocates a new
+    /// length-prefixed string exactly long enough to hold `a`'s bytes followed by
+    /// `b`'s, for lowering string interpolation (`"{expr}"`).
+    pub string_concat_func: u32,
+    /// Shared runtime helper `(n: i64) -> i32`: bump-allocates a new length-prefixed
+    /// string holding `n`'s decimal representation, for interpolating an `Int`.
+    pub int_to_string_func: u32,
 }
 /// Per-module state that accumulates as function bodies are compiled: the running
@@ -280,10 +293,19 @@ struct LocalCtx<'a> {
     closure_scratch_base: u32,
     /// `Closure` expr identity (pointer address) -> offset of its first (of two) slots.
     closure_scratch: HashMap<usize, u32>,
+    /// First local index reserved for nested-constructor-pattern scratch temporaries
+    /// (`Some(Some(v))`'s inner `Some(v)`); the outermost pattern uses a
+    /// `match_scratch` slot instead, so this only covers depth >= 1.
+    nested_class_scratch_base: u32,
+    /// `CasePattern::Class` identity (pointer address) -> scratch slot offset.
+    nested_class_scratch: HashMap<usize, u32>,
     func_ids: &'a HashMap<String, u32>,
     func_sigs: &'a HashMap<String, FuncSig>,
     closures: &'a HashMap<usize, ClosureInfo>,
     closure_call_types: &'a HashMap<ClosureSigKey, u32>,
+    named_fn_values: &'a HashMap<String, u32>,
+    string_concat_func: u32,
+    int_to_string_func: u32,
     classes: &'a ClassEnv,
     methods: &'a MethodEnv,
     enum_variants: &'a EnumVariants,
@@ -291,6 +313,15 @@ struct LocalCtx<'a> {
     /// statements in order, mirroring `plum-checker`'s own env evolution — needed
     /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
     type_env: RefCell<TypeEnv>,
+    /// Local name -> the exact wasm `call_indirect` signature of the closure literal
+    /// assigned to it (populated when compiling that `Stmt::Assign`, straight from
+    /// the already-correct `ClosureInfo` the discovery pass computed). Exists so
+    /// `compile_closure_call` doesn't have to re-derive the signature via
+    /// `plum_checker::infer_expr` on the closure a second time — which, unlike the
+    /// discovery pass, doesn't have `resolve_closure_param_types_from_usage`'s fix
+    /// and would fall back to its old TVar-defaults-to-Int behavior, disagreeing
+    /// with the (now correct) signature the closure's body was actually compiled with.
+    closure_local_sigs: RefCell<HashMap<String, ClosureSigKey>>,
     bump_global: u32,
 }
@@ -390,6 +421,7 @@ pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
     let mut module = WasmModule::new();
     module.add_memory(2, None);
+    module.add_export("memory", ExportKind::Memory, 0);
     let mut bump_init = Vec::new();
     Instruction::I32Const(HEAP_BASE as i32).encode(&mut bump_init);
     let bump_global = module.add_global(ValType::I32, true, &bump_init);
@@ -447,25 +479,31 @@ pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
     // element and records the free variables it must capture.
     let fn_decls: HashMap<String, &ast::Fn> = fns.iter().map(|f| (f.name.clone(), *f)).collect();
     let mut raw_closures: Vec<RawClosure> = Vec::new();
+    let mut named_fn_refs: HashSet<String> = HashSet::new();
     for f in &fns {
         let mut env = global_env.clone();
         if let Some(recv) = &f.type_param {
             env.insert("self".to_string(), TypeScheme::mono(PlumType::TNamed(recv.clone())));
         }
+        let mut locals: HashSet<String> = HashSet::new();
         for p in &f.params {
             env.insert(p.name.clone(), TypeScheme::mono(param_plum_type(&p.ty)));
+            locals.insert(p.name.clone());
         }
         let mut walker = ClosureWalker {
             env,
             cctx: check_ctx_of(&classes, &methods, &enum_variants),
             fn_decls: &fn_decls,
             found: Vec::new(),
+            locals,
+            named_fn_refs: HashSet::new(),
         };
         match &f.body {
             ast::FnBody::Block(block) => walker.walk_block(block),
             ast::FnBody::Expr(e) => walker.walk_expr(e, None),
         }
         raw_closures.extend(walker.found);
+        named_fn_refs.extend(walker.named_fn_refs);
     }
     let mut closures: HashMap<usize, ClosureInfo> = HashMap::new();
@@ -496,12 +534,64 @@ pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
         closure_asts.insert(rc.ptr, rc.closure);
     }
+    // Register a zero-capture "trampoline" closure for every top-level function
+    // referenced as a bare value (e.g. `each(double)`): a real wasm function with the
+    // closure calling convention `(env_ptr, ...real_params) -> ret` that ignores its
+    // env pointer and forwards straight to the real function, plus a funcref-table
+    // entry for it. Since it never captures anything, its `{table_idx, env_ptr=0}`
+    // closure struct is a compile-time constant — baked into a data segment once
+    // rather than bump-allocated at every reference site.
+    let mut named_fn_values: HashMap<String, u32> = HashMap::new();
+    let mut named_fn_data_segments: Vec<(u32, Vec<u8>)> = Vec::new();
+    let mut next_static_offset = STRING_BASE;
+    for name in &named_fn_refs {
+        let sig = func_sigs.get(name).expect("named fn ref must be a registered top-level function");
+        let real_func_idx = *func_ids.get(name).expect("named fn ref must be a registered top-level function");
+        let mut sig_params = vec![ValType::I32]; // env pointer
+        sig_params.extend(sig.params.iter().copied());
+        let sig_key: ClosureSigKey = (sig_params.clone(), sig.ret);
+        let type_idx = match closure_call_types.get(&sig_key) {
+            Some(t) => *t,
+            None => {
+                let results: Vec<ValType> = sig.ret.into_iter().collect();
+                let t = module.add_type(&sig_params, &results);
+                closure_call_types.insert(sig_key, t);
+                t
+            }
+        };
+        let mut tbody = Vec::new();
+        tbody.push(0u8); // no locals beyond the params already in the signature
+        for i in 0..sig.params.len() {
+            Instruction::LocalGet((i + 1) as u32).encode(&mut tbody); // local 0 is env_ptr, ignored
+        }
+        Instruction::Call(real_func_idx).encode(&mut tbody);
+        Instruction::End.encode(&mut tbody);
+        let func_idx = module.add_function(type_idx, &tbody);
+        let table_idx = module.add_table_element(func_idx);
+        let offset = next_static_offset;
+        next_static_offset += 8;
+        let mut bytes = Vec::with_capacity(8);
+        bytes.extend_from_slice(&(table_idx as i32).to_le_bytes());
+        bytes.extend_from_slice(&0i32.to_le_bytes());
+        named_fn_data_segments.push((offset, bytes));
+        named_fn_values.insert(name.clone(), offset);
+    }
+    // Runtime helpers backing string interpolation (`"{expr}"`): always registered
+    // (unconditionally, for simplicity) since they're cheap and self-contained.
+    let string_concat_func = register_string_concat_helper(&mut module, bump_global);
+    let int_to_string_func = register_int_to_string_helper(&mut module, bump_global);
     let ctx = CompileCtx {
         func_ids, func_sigs, classes, methods, enum_variants, global_env, bump_global,
-        closures, closure_asts, closure_call_types,
+        closures, closure_asts, closure_call_types, named_fn_values,
+        string_concat_func, int_to_string_func,
     };
-    let mut state = ModuleState { next_string_offset: STRING_BASE, data_segments: Vec::new() };
+    let mut state = ModuleState { next_string_offset: next_static_offset, data_segments: named_fn_data_segments };
     let mut compiled_bodies: Vec<(String, Vec<u8>)> = Vec::new();
     for f in &fns {
@@ -539,6 +629,259 @@ pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
     Ok(module.finish())
 }
+/// Registers `__string_concat(a: i32, b: i32) -> i32`, a hand-written runtime
+/// helper backing string interpolation: bump-allocates a new length-prefixed
+/// string (`[len: u32][bytes]`, matching a literal string's own layout) exactly
+/// long enough for `a`'s bytes followed by `b`'s, and copies them in. There's no
+/// bulk-memory `memory.copy` assumed available, so each byte is copied by an
+/// explicit loop.
+fn register_string_concat_helper(module: &mut WasmModule, bump_global: u32) -> u32 {
+    let type_idx = module.add_type(&[ValType::I32, ValType::I32], &[ValType::I32]);
+    // locals: 0=a (param), 1=b (param), 2=len_a, 3=len_b, 4=result, 5=i
+    const A: u32 = 0;
+    const B: u32 = 1;
+    const LEN_A: u32 = 2;
+    const LEN_B: u32 = 3;
+    const RESULT: u32 = 4;
+    const I: u32 = 5;
+    let mut body = Vec::new();
+    body.extend(encode_leb128_u32(1)); // one locals group
+    body.extend(encode_leb128_u32(4)); // 4 locals (len_a, len_b, result, i)
+    ValType::I32.encode(&mut body);
+    // len_a = load(a); len_b = load(b)
+    Instruction::LocalGet(A).encode(&mut body);
+    Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    Instruction::LocalSet(LEN_A).encode(&mut body);
+    Instruction::LocalGet(B).encode(&mut body);
+    Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    Instruction::LocalSet(LEN_B).encode(&mut body);
+    // result = bump; bump += 4 + len_a + len_b
+    Instruction::GlobalGet(bump_global).encode(&mut body);
+    Instruction::LocalSet(RESULT).encode(&mut body);
+    Instruction::GlobalGet(bump_global).encode(&mut body);
+    Instruction::LocalGet(LEN_A).encode(&mut body);
+    Instruction::LocalGet(LEN_B).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Const(4).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::GlobalSet(bump_global).encode(&mut body);
+    // store combined length at result+0
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::LocalGet(LEN_A).encode(&mut body);
+    Instruction::LocalGet(LEN_B).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    // for (i = 0; i < len_a; i++) result[4+i] = a[4+i]
+    Instruction::I32Const(0).encode(&mut body);
+    Instruction::LocalSet(I).encode(&mut body);
+    Instruction::Block(BlockType::Empty).encode(&mut body);
+    Instruction::Loop(BlockType::Empty).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::LocalGet(LEN_A).encode(&mut body);
+    Instruction::I32GeU.encode(&mut body);
+    Instruction::BrIf(1).encode(&mut body);
+    // address = result + i
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    // value = load8u(a + i, offset 4)
+    Instruction::LocalGet(A).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Load8U(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::I32Store8(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::I32Const(1).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::LocalSet(I).encode(&mut body);
+    Instruction::Br(0).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    Instruction::End.encode(&mut body);
+    // for (i = 0; i < len_b; i++) result[4+len_a+i] = b[4+i]
+    Instruction::I32Const(0).encode(&mut body);
+    Instruction::LocalSet(I).encode(&mut body);
+    Instruction::Block(BlockType::Empty).encode(&mut body);
+    Instruction::Loop(BlockType::Empty).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::LocalGet(LEN_B).encode(&mut body);
+    Instruction::I32GeU.encode(&mut body);
+    Instruction::BrIf(1).encode(&mut body);
+    // address = result + len_a + i
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::LocalGet(LEN_A).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    // value = load8u(b + i, offset 4)
+    Instruction::LocalGet(B).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Load8U(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::I32Store8(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::LocalGet(I).encode(&mut body);
+    Instruction::I32Const(1).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::LocalSet(I).encode(&mut body);
+    Instruction::Br(0).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    Instruction::End.encode(&mut body);
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    module.add_function(type_idx, &body)
+}
+/// Registers `__int_to_string(n: i64) -> i32`, a hand-written runtime helper
+/// backing string interpolation: bump-allocates a new length-prefixed string
+/// holding `n`'s decimal representation (handling a leading `-` for negatives, and
+/// `0` correctly via a do-while digit count that always runs at least once).
+fn register_int_to_string_helper(module: &mut WasmModule, bump_global: u32) -> u32 {
+    let type_idx = module.add_type(&[ValType::I64], &[ValType::I32]);
+    // locals: 0=n (param, i64), 1=is_neg (i32), 2=abs_n (i64), 3=count (i32),
+    // 4=total_len (i32), 5=result (i32), 6=pos (i32), 7=temp (i64)
+    // Locals are declared as one group of 5 `i32`s followed by one group of 2
+    // `i64`s (see below), so indices must stay grouped by type in that same order —
+    // NOT in whatever order reads best logically.
+    const N: u32 = 0;
+    const IS_NEG: u32 = 1;
+    const COUNT: u32 = 2;
+    const TOTAL_LEN: u32 = 3;
+    const RESULT: u32 = 4;
+    const POS: u32 = 5;
+    const ABS_N: u32 = 6;
+    const TEMP: u32 = 7;
+    let mut body = Vec::new();
+    body.extend(encode_leb128_u32(2)); // two locals groups
+    body.extend(encode_leb128_u32(5)); // is_neg, count, total_len, result, pos: i32
+    ValType::I32.encode(&mut body);
+    body.extend(encode_leb128_u32(2)); // abs_n, temp: i64
+    ValType::I64.encode(&mut body);
+    // is_neg = n < 0
+    Instruction::LocalGet(N).encode(&mut body);
+    Instruction::I64Const(0).encode(&mut body);
+    Instruction::I64LtS.encode(&mut body);
+    Instruction::LocalSet(IS_NEG).encode(&mut body);
+    // abs_n = is_neg ? (0 - n) : n
+    Instruction::LocalGet(IS_NEG).encode(&mut body);
+    Instruction::If(BlockType::Result(ValType::I64)).encode(&mut body);
+    Instruction::I64Const(0).encode(&mut body);
+    Instruction::LocalGet(N).encode(&mut body);
+    Instruction::I64Sub.encode(&mut body);
+    Instruction::Else.encode(&mut body);
+    Instruction::LocalGet(N).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    Instruction::LocalSet(ABS_N).encode(&mut body);
+    // count digits: do { temp /= 10; count++ } while (temp != 0); temp starts as abs_n
+    Instruction::I32Const(0).encode(&mut body);
+    Instruction::LocalSet(COUNT).encode(&mut body);
+    Instruction::LocalGet(ABS_N).encode(&mut body);
+    Instruction::LocalSet(TEMP).encode(&mut body);
+    Instruction::Loop(BlockType::Empty).encode(&mut body);
+    Instruction::LocalGet(TEMP).encode(&mut body);
+    Instruction::I64Const(10).encode(&mut body);
+    Instruction::I64DivS.encode(&mut body);
+    Instruction::LocalSet(TEMP).encode(&mut body);
+    Instruction::LocalGet(COUNT).encode(&mut body);
+    Instruction::I32Const(1).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::LocalSet(COUNT).encode(&mut body);
+    Instruction::LocalGet(TEMP).encode(&mut body);
+    Instruction::I64Const(0).encode(&mut body);
+    Instruction::I64Ne.encode(&mut body);
+    Instruction::BrIf(0).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    // total_len = count + is_neg
+    Instruction::LocalGet(COUNT).encode(&mut body);
+    Instruction::LocalGet(IS_NEG).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::LocalSet(TOTAL_LEN).encode(&mut body);
+    // result = bump; bump += 4 + total_len
+    Instruction::GlobalGet(bump_global).encode(&mut body);
+    Instruction::LocalSet(RESULT).encode(&mut body);
+    Instruction::GlobalGet(bump_global).encode(&mut body);
+    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
+    Instruction::I32Const(4).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::GlobalSet(bump_global).encode(&mut body);
+    // store total_len at result+0
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
+    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    // pos = 4 + total_len; temp = abs_n
+    Instruction::I32Const(4).encode(&mut body);
+    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::LocalSet(POS).encode(&mut body);
+    Instruction::LocalGet(ABS_N).encode(&mut body);
+    Instruction::LocalSet(TEMP).encode(&mut body);
+    // do { pos--; result[pos] = '0' + temp % 10; temp /= 10 } while (pos > 4 + is_neg)
+    Instruction::Loop(BlockType::Empty).encode(&mut body);
+    Instruction::LocalGet(POS).encode(&mut body);
+    Instruction::I32Const(1).encode(&mut body);
+    Instruction::I32Sub.encode(&mut body);
+    Instruction::LocalSet(POS).encode(&mut body);
+    // address = result + pos
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::LocalGet(POS).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    // value = '0' + (temp % 10)
+    Instruction::LocalGet(TEMP).encode(&mut body);
+    Instruction::I64Const(10).encode(&mut body);
+    Instruction::I64RemS.encode(&mut body);
+    Instruction::I64Const(48).encode(&mut body);
+    Instruction::I64Add.encode(&mut body);
+    Instruction::I32WrapI64.encode(&mut body);
+    Instruction::I32Store8(MemArg { offset: 0, align: 0, memory_index: 0 }).encode(&mut body);
+    // temp /= 10
+    Instruction::LocalGet(TEMP).encode(&mut body);
+    Instruction::I64Const(10).encode(&mut body);
+    Instruction::I64DivS.encode(&mut body);
+    Instruction::LocalSet(TEMP).encode(&mut body);
+    // while (pos > 4 + is_neg)
+    Instruction::LocalGet(POS).encode(&mut body);
+    Instruction::I32Const(4).encode(&mut body);
+    Instruction::LocalGet(IS_NEG).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32GtU.encode(&mut body);
+    Instruction::BrIf(0).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    // if (is_neg) result[4] = '-'
+    Instruction::LocalGet(IS_NEG).encode(&mut body);
+    Instruction::If(BlockType::Empty).encode(&mut body);
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::I32Const(4).encode(&mut body);
+    Instruction::I32Add.encode(&mut body);
+    Instruction::I32Const(45).encode(&mut body); // '-'
+    Instruction::I32Store8(MemArg { offset: 0, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    Instruction::LocalGet(RESULT).encode(&mut body);
+    Instruction::End.encode(&mut body);
+    module.add_function(type_idx, &body)
+}
 /// The `PlumType` of a declared parameter, including `fn(...)`-typed params as `TFun`.
 fn param_plum_type(pt: &ast::ParamType) -> PlumType {
     match pt {
@@ -573,6 +916,16 @@ struct ClosureWalker<'a, 'c> {
     cctx: plum_checker::CheckCtx<'c>,
     fn_decls: &'a HashMap<String, &'a ast::Fn>,
     found: Vec<RawClosure<'a>>,
+    /// Local names bound in the function currently being walked (params, assign
+    /// targets, for-loop vars) — used to tell a local variable reference apart from a
+    /// bare reference to a top-level function name (see `named_fn_refs`).
+    locals: HashSet<String>,
+    /// Top-level (non-method) function names referenced as a bare value (e.g.
+    /// `each(double)`) rather than called directly (`double(x)`, which compiles via
+    /// `Expr::FnCall` and never reaches here). Each one needs a zero-capture
+    /// "trampoline" closure so it can be used wherever a `fn(...)`-typed value is
+    /// expected.
+    named_fn_refs: HashSet<String>,
 }
 impl<'a, 'c> ClosureWalker<'a, 'c> {
@@ -589,6 +942,7 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
                     self.walk_expr(value, None);
                     let ty = plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt);
                     self.env.insert(target.clone(), TypeScheme::mono(ty));
+                    self.locals.insert(target.clone());
                 }
             }
             ast::Stmt::Return(Some(e)) => self.walk_expr(e, None),
@@ -612,6 +966,7 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
                 self.walk_expr(&f.iter, None);
                 for v in &f.vars {
                     self.env.insert(v.clone(), TypeScheme::mono(PlumType::TInt));
+                    self.locals.insert(v.clone());
                 }
                 self.walk_block(&f.body);
             }
@@ -668,11 +1023,23 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
                     }
                 }
             }
+            ast::Expr::Var(name) => {
+                // A bare name that isn't a local in this scope but does name a
+                // top-level (non-method) function is a reference to that function as
+                // a value (e.g. `each(double)`), not a direct call — a direct call
+                // compiles via `Expr::FnCall` and never reaches this arm.
+                if !self.locals.contains(name) {
+                    if let Some(f) = self.fn_decls.get(name) {
+                        if f.type_param.is_none() {
+                            self.named_fn_refs.insert(name.clone());
+                        }
+                    }
+                }
+            }
             ast::Expr::Int(_)
             | ast::Expr::Float(_)
             | ast::Expr::String(_)
             | ast::Expr::Self_
-            | ast::Expr::Var(_)
             | ast::Expr::TypeName(_) => {}
         }
     }
@@ -686,33 +1053,78 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
                 (param_vts, param_ptypes, ret_vt)
             }
             _ => {
-                // Not a direct `fn`-typed call argument: infer the closure's own type.
+                // Not a direct `fn`-typed call argument (e.g. assigned to a local
+                // first, then called/passed on later): the checker's own closure
+                // inference (`plum_checker::infer_expr` on `Expr::Closure`) gives
+                // each param a fresh `TVar` and never actually unifies it against
+                // how the param is used in the body — `unify` is a no-op for any
+                // `TVar` — so a param that's genuinely Float or a class/pointer
+                // silently comes back as an unresolved `TVar`, which
+                // `plum_type_to_valtype` then defaults to `Int`. If the closure is
+                // later called at its real (non-Int) type, the wasm function actually
+                // compiled for its body (built from this wrong, Int-assumed signature)
+                // won't match the `call_indirect` type the real call site expects —
+                // a mismatch `call_indirect` only traps on at runtime, not at compile
+                // or validation time.
+                //
+                // Fix: resolve each param's type from a direct usage in the body
+                // first (see `resolve_closure_param_types_from_usage`) — e.g. `cb = |v|
+                // x + v` with a captured `Float` `x` resolves `v` to `Float` from that
+                // `Binary` op — then infer the return type against an env where the
+                // params are already bound concretely (bypassing the checker's
+                // Closure-inference arm entirely, since it always re-binds params to
+                // fresh TVars regardless of what's already in the env passed to it).
-                match plum_checker::infer_expr(&ast::Expr::Closure(Box::new(cl.clone())), &self.env, &self.cctx) {
+                let resolved_params = resolve_closure_param_types_from_usage(cl, &self.env, &self.cctx);
-                    Ok(PlumType::TFun(ptypes, ret)) => {
+                let param_ptypes: Vec<PlumType> = cl.params.iter()
+                    .map(|p| resolved_params.get(p).cloned().unwrap_or(PlumType::TInt))
+                    .collect();
-                        let param_vts = ptypes.iter().map(plum_type_to_valtype).collect();
+                let param_vts: Vec<ValType> = param_ptypes.iter().map(plum_type_to_valtype).collect();
-                        let ret_vt = match *ret {
+                let mut body_env = self.env.clone();
-                            PlumType::TUnit => None,
-                            other => Some(plum_type_to_valtype(&other)),
-                        };
-                        (param_vts, ptypes, ret_vt)
-                    }
-                    _ => {
-                        let param_vts = cl.params.iter().map(|_| ValType::I64).collect();
+                for (p, ty) in cl.params.iter().zip(param_ptypes.iter()) {
-                        let param_ptypes = cl.params.iter().map(|_| PlumType::TInt).collect();
+                    body_env.insert(p.clone(), TypeScheme::mono(ty.clone()));
-                        (param_vts, param_ptypes, Some(ValType::I64))
-                    }
                 }
+                let ret_ty = match cl.body.stmts.last() {
+                    Some(ast::Stmt::Expr(e)) => plum_checker::infer_expr(e, &body_env, &self.cctx).ok(),
+                    Some(ast::Stmt::Return(Some(e))) => plum_checker::infer_expr(e, &body_env, &self.cctx).ok(),
+                    _ => Some(PlumType::TUnit),
+                };
+                let ret_vt = match ret_ty {
+                    Some(PlumType::TUnit) => None,
+                    Some(PlumType::TVar(_)) | None => Some(ValType::I64), // unresolved: preserve prior Int-default behavior
+                    Some(other) => Some(plum_type_to_valtype(&other)),
+                };
+                (param_vts, param_ptypes, ret_vt)
             }
         };
-        let free_vars = collect_free_vars(cl, &self.env);
+        let free_vars = collect_free_vars(cl, &self.env, self.fn_decls);
         self.found.push(RawClosure {
             ptr: cl as *const ast::Closure as usize,
             closure: cl,
             param_vts,
-            param_ptypes,
+            param_ptypes: param_ptypes.clone(),
             ret_vt,
             free_vars,
         });
+        // Recurse into this closure's own body to find any closure literals nested
+        // inside it (`|v| |w| v + w`, or a closure literal used inside a `match`/`if`
+        // within this one's body). Each nested closure gets registered exactly like a
+        // top-level one, seeing this closure's own params as locals in scope — which
+        // is also what makes its free-variable analysis correctly capture a name from
+        // *this* closure's scope (rather than silently missing it): once discovery
+        // finishes, `ctx.closures` holds every closure at every depth before any body
+        // is compiled, so the single fixed "compile each registered closure" pass in
+        // `compile_source` already handles arbitrary nesting with no further changes.
+        let saved_env = self.env.clone();
+        let saved_locals = self.locals.clone();
+        for (p, ty) in cl.params.iter().zip(param_ptypes.iter()) {
+            self.env.insert(p.clone(), TypeScheme::mono(ty.clone()));
+            self.locals.insert(p.clone());
+        }
+        self.walk_block(&cl.body);
+        self.env = saved_env;
+        self.locals = saved_locals;
     }
 }
@@ -724,17 +1136,197 @@ fn arg_expr_of(arg: &ast::Arg) -> &ast::Expr {
     }
 }
+/// Resolves as many of a closure's param types as possible from how they're actually
+/// used in its body — e.g. `|v| x + v` with a captured `Float` `x` resolves `v` to
+/// `Float` from that `Binary` op, or `|v| helper(v)` where `helper`'s declared param
+/// type is concrete resolves `v` to that. A param never used in a way that pins down
+/// a concrete type simply doesn't appear in the returned map (callers fall back to
+/// `Int`, matching the prior default). This is intentionally a shallow, best-effort
+/// scan — not full unification — scoped to fixing the specific `call_indirect`
+/// signature-mismatch gap this exists for, not replacing the checker's inference.
+fn resolve_closure_param_types_from_usage(
+    cl: &ast::Closure,
+    env: &TypeEnv,
+    cctx: &plum_checker::CheckCtx,
+) -> HashMap<String, PlumType> {
+    let params: std::collections::HashSet<String> = cl.params.iter().cloned().collect();
+    let mut resolved: HashMap<String, PlumType> = HashMap::new();
+    for stmt in &cl.body.stmts {
+        scan_stmt_for_param_types(stmt, &params, env, cctx, &mut resolved);
+    }
+    resolved
+}
+fn scan_stmt_for_param_types(
+    stmt: &ast::Stmt,
+    params: &std::collections::HashSet<String>,
+    env: &TypeEnv,
+    cctx: &plum_checker::CheckCtx,
+    resolved: &mut HashMap<String, PlumType>,
+) {
+    match stmt {
+        ast::Stmt::Assign(a) => {
+            for v in &a.values {
+                scan_expr_for_param_types(v, params, env, cctx, resolved);
+            }
+        }
+        ast::Stmt::Return(Some(e)) | ast::Stmt::Expr(e) | ast::Stmt::Assert(e) => {
+            scan_expr_for_param_types(e, params, env, cctx, resolved);
+        }
+        ast::Stmt::If(i) => {
+            scan_expr_for_param_types(&i.condition, params, env, cctx, resolved);
+            for s in &i.body.stmts {
+                scan_stmt_for_param_types(s, params, env, cctx, resolved);
+            }
+            for ei in &i.else_ifs {
+                scan_expr_for_param_types(&ei.condition, params, env, cctx, resolved);
+                for s in &ei.body.stmts {
+                    scan_stmt_for_param_types(s, params, env, cctx, resolved);
+                }
+            }
+            if let Some(e) = &i.else_ {
+                for s in &e.stmts {
+                    scan_stmt_for_param_types(s, params, env, cctx, resolved);
+                }
+            }
+        }
+        ast::Stmt::While(w) => {
+            scan_expr_for_param_types(&w.condition, params, env, cctx, resolved);
+            for s in &w.body.stmts {
+                scan_stmt_for_param_types(s, params, env, cctx, resolved);
+            }
+        }
+        ast::Stmt::For(f) => {
+            scan_expr_for_param_types(&f.iter, params, env, cctx, resolved);
+            for s in &f.body.stmts {
+                scan_stmt_for_param_types(s, params, env, cctx, resolved);
+            }
+        }
+        _ => {}
+    }
+}
+fn scan_expr_for_param_types(
+    expr: &ast::Expr,
+    params: &std::collections::HashSet<String>,
+    env: &TypeEnv,
+    cctx: &plum_checker::CheckCtx,
+    resolved: &mut HashMap<String, PlumType>,
+) {
+    match expr {
+        ast::Expr::Binary(b) => {
+            try_resolve_param_from_pair(&b.left, &b.right, params, env, cctx, resolved);
+            scan_expr_for_param_types(&b.left, params, env, cctx, resolved);
+            scan_expr_for_param_types(&b.right, params, env, cctx, resolved);
+        }
+        ast::Expr::Compare(c) => {
+            try_resolve_param_from_pair(&c.left, &c.right, params, env, cctx, resolved);
+            scan_expr_for_param_types(&c.left, params, env, cctx, resolved);
+            scan_expr_for_param_types(&c.right, params, env, cctx, resolved);
+        }
+        ast::Expr::Bool(b) => {
+            scan_expr_for_param_types(&b.left, params, env, cctx, resolved);
+            scan_expr_for_param_types(&b.right, params, env, cctx, resolved);
+        }
+        ast::Expr::Not(inner) => scan_expr_for_param_types(inner, params, env, cctx, resolved),
+        ast::Expr::Unary(u) => scan_expr_for_param_types(&u.operand, params, env, cctx, resolved),
+        ast::Expr::Paren(inner) => scan_expr_for_param_types(inner, params, env, cctx, resolved),
+        ast::Expr::Ternary(t) => {
+            scan_expr_for_param_types(&t.condition, params, env, cctx, resolved);
+            scan_expr_for_param_types(&t.then, params, env, cctx, resolved);
+            scan_expr_for_param_types(&t.else_, params, env, cctx, resolved);
+        }
+        ast::Expr::FnCall(call) => {
+            if let Ok(PlumType::TFun(param_types, _)) = plum_checker::lookup(env, &call.name) {
+                for (arg, expected) in call.args.iter().zip(param_types.iter()) {
+                    let arg_expr = arg_expr_of(arg);
+                    if let ast::Expr::Var(n) = arg_expr {
+                        if params.contains(n) && !resolved.contains_key(n) && !matches!(expected, PlumType::TVar(_)) {
+                            resolved.insert(n.clone(), expected.clone());
+                        }
+                    }
+                }
+            }
+            for arg in &call.args {
+                scan_expr_for_param_types(arg_expr_of(arg), params, env, cctx, resolved);
+            }
+        }
+        ast::Expr::ClassCall(call) => {
+            for fa in &call.fields {
+                scan_expr_for_param_types(&fa.value, params, env, cctx, resolved);
+            }
+        }
+        ast::Expr::Attribute(a) => {
+            // `c.field` on a bare, unresolved param implies `c`'s type is whichever
+            // class declares that field name — ambiguous if more than one class has
+            // a field by that name, but resolvable in the common case.
+            if let ast::AttrKind::Field(field_name) = &a.attr {
+                if let ast::Expr::Var(n) = &a.object {
+                    if params.contains(n) && !resolved.contains_key(n) {
+                        let mut matches = cctx.classes.iter().filter(|(_, fields)| fields.iter().any(|(fname, _)| fname == field_name));
+                        if let (Some((class_name, _)), None) = (matches.next(), matches.next()) {
+                            resolved.insert(n.clone(), PlumType::TNamed(class_name.clone()));
+                        }
+                    }
+                }
+            }
+            scan_expr_for_param_types(&a.object, params, env, cctx, resolved);
+            if let ast::AttrKind::Method(call) = &a.attr {
+                for arg in &call.args {
+                    scan_expr_for_param_types(arg_expr_of(arg), params, env, cctx, resolved);
+                }
+            }
+        }
+        _ => {}
+    }
+}
+/// If either side of a `Binary`/`Compare` operand pair is a bare reference to an
+/// unresolved param and the *other* side has a concrete (non-`TVar`) inferred type,
+/// binds the param to that type.
+fn try_resolve_param_from_pair(
+    left: &ast::Expr,
+    right: &ast::Expr,
+    params: &std::collections::HashSet<String>,
+    env: &TypeEnv,
+    cctx: &plum_checker::CheckCtx,
+    resolved: &mut HashMap<String, PlumType>,
+) {
+    if let ast::Expr::Var(n) = left {
+        if params.contains(n) && !resolved.contains_key(n) {
+            if let Ok(ty) = plum_checker::infer_expr(right, env, cctx) {
+                if !matches!(ty, PlumType::TVar(_)) {
+                    resolved.insert(n.clone(), ty);
+                }
+            }
+        }
+    }
+    if let ast::Expr::Var(n) = right {
+        if params.contains(n) && !resolved.contains_key(n) {
+            if let Ok(ty) = plum_checker::infer_expr(left, env, cctx) {
+                if !matches!(ty, PlumType::TVar(_)) {
+                    resolved.insert(n.clone(), ty);
+                }
+            }
+        }
+    }
+}
 /// Determines a closure's captured free variables: every `Var` referenced in its body
 /// that is neither one of the closure's own params nor assigned locally inside the body,
 /// in first-appearance order. Each free variable's type is looked up in the *enclosing*
 /// scope's type env.
+fn collect_free_vars(
+    cl: &ast::Closure,
+    env: &TypeEnv,
+    fn_decls: &HashMap<String, &ast::Fn>,
-fn collect_free_vars(cl: &ast::Closure, env: &TypeEnv) -> Vec<(String, PlumType)> {
+) -> Vec<(String, PlumType)> {
     let mut bound: std::collections::HashSet<String> = cl.params.iter().cloned().collect();
     fv_collect_bound_block(&cl.body, &mut bound);
     let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
     let mut free: Vec<(String, PlumType)> = Vec::new();
-    fv_collect_refs_block(&cl.body, &bound, &mut seen, &mut free, env);
+    fv_collect_refs_block(&cl.body, &bound, &mut seen, &mut free, env, fn_decls);
     free
 }
@@ -793,42 +1385,43 @@ fn fv_collect_refs_block(
     seen: &mut std::collections::HashSet<String>,
     free: &mut Vec<(String, PlumType)>,
     env: &TypeEnv,
+    fn_decls: &HashMap<String, &ast::Fn>,
 ) {
     for s in &block.stmts {
         match s {
             ast::Stmt::Assign(a) => {
                 for v in &a.values {
-                    fv_collect_refs_expr(v, bound, seen, free, env);
+                    fv_collect_refs_expr(v, bound, seen, free, env, fn_decls);
                 }
             }
             ast::Stmt::Return(Some(e)) | ast::Stmt::Expr(e) | ast::Stmt::Assert(e) => {
-                fv_collect_refs_expr(e, bound, seen, free, env);
+                fv_collect_refs_expr(e, bound, seen, free, env, fn_decls);
             }
             ast::Stmt::If(i) => {
-                fv_collect_refs_expr(&i.condition, bound, seen, free, env);
+                fv_collect_refs_expr(&i.condition, bound, seen, free, env, fn_decls);
-                fv_collect_refs_block(&i.body, bound, seen, free, env);
+                fv_collect_refs_block(&i.body, bound, seen, free, env, fn_decls);
                 for ei in &i.else_ifs {
-                    fv_collect_refs_expr(&ei.condition, bound, seen, free, env);
+                    fv_collect_refs_expr(&ei.condition, bound, seen, free, env, fn_decls);
-                    fv_collect_refs_block(&ei.body, bound, seen, free, env);
+                    fv_collect_refs_block(&ei.body, bound, seen, free, env, fn_decls);
                 }
                 if let Some(e) = &i.else_ {
-                    fv_collect_refs_block(e, bound, seen, free, env);
+                    fv_collect_refs_block(e, bound, seen, free, env, fn_decls);
                 }
             }
             ast::Stmt::While(w) => {
-                fv_collect_refs_expr(&w.condition, bound, seen, free, env);
+                fv_collect_refs_expr(&w.condition, bound, seen, free, env, fn_decls);
-                fv_collect_refs_block(&w.body, bound, seen, free, env);
+                fv_collect_refs_block(&w.body, bound, seen, free, env, fn_decls);
             }
             ast::Stmt::For(f) => {
-                fv_collect_refs_expr(&f.iter, bound, seen, free, env);
+                fv_collect_refs_expr(&f.iter, bound, seen, free, env, fn_decls);
-                fv_collect_refs_block(&f.body, bound, seen, free, env);
+                fv_collect_refs_block(&f.body, bound, seen, free, env, fn_decls);
             }
             ast::Stmt::Match(m) => {
                 for subj in &m.subjects {
-                    fv_collect_refs_expr(subj, bound, seen, free, env);
+                    fv_collect_refs_expr(subj, bound, seen, free, env, fn_decls);
                 }
                 for case in &m.cases {
-                    fv_collect_refs_block(&case.body, bound, seen, free, env);
+                    fv_collect_refs_block(&case.body, bound, seen, free, env, fn_decls);
                 }
             }
             _ => {}
@@ -842,45 +1435,67 @@ fn fv_collect_refs_expr(
     seen: &mut std::collections::HashSet<String>,
     free: &mut Vec<(String, PlumType)>,
     env: &TypeEnv,
+    fn_decls: &HashMap<String, &ast::Fn>,
 ) {
     match expr {
         ast::Expr::Var(name) => {
+            // A top-level (non-method) function referenced bare (e.g. `each(double)`)
+            // is not a captured variable — it's compiled as a static trampoline
+            // reference (see `named_fn_values`), not loaded from an enclosing local.
+            let is_named_fn_ref = fn_decls.get(name).is_some_and(|f| f.type_param.is_none());
-            if !bound.contains(name) && seen.insert(name.clone()) {
+            if !is_named_fn_ref && !bound.contains(name) && seen.insert(name.clone()) {
                 let ty = plum_checker::lookup(env, name).unwrap_or(PlumType::TInt);
                 free.push((name.clone(), ty));
             }
         }
-        ast::Expr::Binary(b) => { fv_collect_refs_expr(&b.left, bound, seen, free, env); fv_collect_refs_expr(&b.right, bound, seen, free, env); }
+        ast::Expr::Binary(b) => { fv_collect_refs_expr(&b.left, bound, seen, free, env, fn_decls); fv_collect_refs_expr(&b.right, bound, seen, free, env, fn_decls); }
-        ast::Expr::Bool(b) => { fv_collect_refs_expr(&b.left, bound, seen, free, env); fv_collect_refs_expr(&b.right, bound, seen, free, env); }
+        ast::Expr::Bool(b) => { fv_collect_refs_expr(&b.left, bound, seen, free, env, fn_decls); fv_collect_refs_expr(&b.right, bound, seen, free, env, fn_decls); }
-        ast::Expr::Compare(c) => { fv_collect_refs_expr(&c.left, bound, seen, free, env); fv_collect_refs_expr(&c.right, bound, seen, free, env); }
+        ast::Expr::Compare(c) => { fv_collect_refs_expr(&c.left, bound, seen, free, env, fn_decls); fv_collect_refs_expr(&c.right, bound, seen, free, env, fn_decls); }
-        ast::Expr::Not(inner) => fv_collect_refs_expr(inner, bound, seen, free, env),
+        ast::Expr::Not(inner) => fv_collect_refs_expr(inner, bound, seen, free, env, fn_decls),
-        ast::Expr::Unary(u) => fv_collect_refs_expr(&u.operand, bound, seen, free, env),
+        ast::Expr::Unary(u) => fv_collect_refs_expr(&u.operand, bound, seen, free, env, fn_decls),
-        ast::Expr::Paren(inner) => fv_collect_refs_expr(inner, bound, seen, free, env),
+        ast::Expr::Paren(inner) => fv_collect_refs_expr(inner, bound, seen, free, env, fn_decls),
         ast::Expr::Ternary(t) => {
-            fv_collect_refs_expr(&t.condition, bound, seen, free, env);
+            fv_collect_refs_expr(&t.condition, bound, seen, free, env, fn_decls);
-            fv_collect_refs_expr(&t.then, bound, seen, free, env);
+            fv_collect_refs_expr(&t.then, bound, seen, free, env, fn_decls);
-            fv_collect_refs_expr(&t.else_, bound, seen, free, env);
+            fv_collect_refs_expr(&t.else_, bound, seen, free, env, fn_decls);
         }
         ast::Expr::FnCall(call) => {
             for arg in &call.args {
-                fv_collect_refs_expr(arg_expr_of(arg), bound, seen, free, env);
+                fv_collect_refs_expr(arg_expr_of(arg), bound, seen, free, env, fn_decls);
             }
         }
         ast::Expr::ClassCall(call) => {
             for fa in &call.fields {
-                fv_collect_refs_expr(&fa.value, bound, seen, free, env);
+                fv_collect_refs_expr(&fa.value, bound, seen, free, env, fn_decls);
             }
         }
         ast::Expr::Attribute(a) => {
-            fv_collect_refs_expr(&a.object, bound, seen, free, env);
+            fv_collect_refs_expr(&a.object, bound, seen, free, env, fn_decls);
             if let ast::AttrKind::Method(call) = &a.attr {
                 for arg in &call.args {
-                    fv_collect_refs_expr(arg_expr_of(arg), bound, seen, free, env);
+                    fv_collect_refs_expr(arg_expr_of(arg), bound, seen, free, env, fn_decls);
                 }
             }
         }
+        ast::Expr::Closure(inner) => {
+            // A name the *inner* closure references that isn't bound by the inner
+            // itself (its own params/locals) and isn't bound by *this* (outer)
+            // closure either is a genuine multi-level capture: this outer closure
+            // also needs to capture it from its own enclosing scope, in order to
+            // pass it down when it later constructs the inner closure. A name the
+            // inner references that the outer already binds (e.g. one of the
+            // outer's own params) needs no such propagation — the outer's compiled
+            // body can already reference it as an ordinary local when snapshotting
-        // A nested closure isn't supported by the discovery pre-pass; its own free-var
+            // the inner closure's env, so it's deliberately excluded here by
+            // unioning `bound` (outer) with the inner's own bound set below, rather
-        // references are not hoisted here.
+            // than passing the inner's bound set alone.
+            let mut inner_bound = bound.clone();
+            for p in &inner.params {
+                inner_bound.insert(p.clone());
+            }
+            fv_collect_bound_block(&inner.body, &mut inner_bound);
+            fv_collect_refs_block(&inner.body, &inner_bound, seen, free, env, fn_decls);
+        }
         _ => {}
     }
 }
@@ -894,11 +1509,18 @@ struct Collector<'a> {
     named: Vec<(String, PlumType)>,
     named_set: std::collections::HashSet<String>,
     classcall_scratch: HashMap<usize, u32>,
+    /// One scratch-local type per subject (usually one, more for `match a, b, ...`).
-    match_scratch: HashMap<usize, PlumType>,
+    match_scratch: HashMap<usize, Vec<PlumType>>,
     next_classcall_slot: u32,
     /// `Closure` expr identity -> offset of its first (of two) construction scratch slots.
     closure_scratch: HashMap<usize, u32>,
     next_closure_slot: u32,
+    /// `CasePattern::Class` identity -> its scratch local, for a constructor pattern
+    /// *nested* inside another constructor pattern's fields (`Some(Some(v))`) — the
+    /// outermost, per-subject pattern already has a scratch local via `match_scratch`
+    /// / `all_subjects`, so this only covers depth >= 1.
+    nested_class_scratch: HashMap<usize, u32>,
+    next_nested_class_slot: u32,
 }
 impl<'a> Collector<'a> {
@@ -909,6 +1531,37 @@ impl<'a> Collector<'a> {
         self.env.insert(name.to_string(), TypeScheme::mono(ty));
     }
+    /// Binds every `Name` sub-pattern anywhere inside `pat` (at any nesting depth) to
+    /// its correct field type, and reserves a scratch local for every `Class`
+    /// sub-pattern found *nested* inside another constructor pattern's fields (the
+    /// outermost, per-subject pattern doesn't need one — see `nested_class_scratch`).
+    fn collect_pattern(&mut self, pat: &ast::CasePattern, ty: &PlumType, top_level: bool) {
+        match pat {
+            ast::CasePattern::Name(n) => {
+                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                    && self.cctx.enum_variants.contains_key(n);
+                if !is_variant {
+                    self.bind(n, ty.clone());
+                }
+            }
+            ast::CasePattern::Class { name, fields } => {
+                if !top_level {
+                    let key = pat as *const ast::CasePattern as usize;
+                    let slot = self.next_nested_class_slot;
+                    self.next_nested_class_slot += 1;
+                    self.nested_class_scratch.insert(key, slot);
+                }
+                if let Some(info) = self.cctx.enum_variants.get(name) {
+                    let field_types = info.field_types.clone();
+                    for (f, fty) in fields.iter().zip(field_types.iter()) {
+                        self.collect_pattern(f, fty, false);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
     fn walk_block(&mut self, block: &ast::Block) {
         for s in &block.stmts {
             self.walk_stmt(s);
@@ -920,7 +1573,22 @@ impl<'a> Collector<'a> {
             ast::Stmt::Assign(a) => {
                 for (target, value) in a.targets.iter().zip(a.values.iter()) {
                     self.walk_expr(value);
+                    let ty = if matches!(value, ast::Expr::Closure(_)) {
+                        // The checker's own closure inference (`infer_expr` on
+                        // `Expr::Closure`) infers the return type by recursively
+                        // inferring the body's tail expression with each param bound
+                        // to a fresh, unconstrained `TVar` — e.g. a captured/param
+                        // attribute access (`c.age`) on a `TVar`-typed object isn't a
+                        // known class, so it errors out entirely, and this call site
+                        // then silently defaults to `TInt` — the *wrong* wasm local
+                        // width for what's actually always an `i32` pointer. All that
+                        // actually matters here is the local's wasm width, and every
+                        // closure value is an i32 pointer regardless of its
+                        // parameter/return types, so skip inference entirely.
+                        PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
+                    } else {
-                    let ty = plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt);
+                        plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt)
+                    };
                     self.bind(target, ty);
                 }
             }
@@ -951,39 +1619,15 @@ impl<'a> Collector<'a> {
             ast::Stmt::Expr(e) => self.walk_expr(e),
             ast::Stmt::Assert(e) => self.walk_expr(e),
             ast::Stmt::Match(m) => {
-                let subject_ty = if m.subjects.len() == 1 {
+                let subject_types: Vec<PlumType> = m.subjects.iter().map(|s| {
-                    self.walk_expr(&m.subjects[0]);
-                    plum_checker::infer_expr(&m.subjects[0], &self.env, &self.cctx).unwrap_or(PlumType::TInt)
-                } else {
-                    for s in &m.subjects {
-                        self.walk_expr(s);
+                    self.walk_expr(s);
-                    }
+                    plum_checker::infer_expr(s, &self.env, &self.cctx).unwrap_or(PlumType::TInt)
-                    PlumType::TInt
+                }).collect();
-                };
-                self.match_scratch.insert(m as *const ast::Match as usize, subject_ty.clone());
+                self.match_scratch.insert(m as *const ast::Match as usize, subject_types.clone());
                 for case in &m.cases {
                     let saved = self.env.clone();
-                    if m.subjects.len() == 1 {
-                        match case.patterns.first() {
-                            Some(ast::CasePattern::Name(n)) => {
-                                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                                    && self.cctx.enum_variants.contains_key(n);
-                                if !is_variant {
-                                    self.bind(n, subject_ty.clone());
-                                }
-                            }
-                            Some(ast::CasePattern::Class { name, fields }) => {
-                                if let Some(info) = self.cctx.enum_variants.get(name) {
-                                    let field_types = info.field_types.clone();
-                                    for (f, fty) in fields.iter().zip(field_types.iter()) {
+                    for (pat, subject_ty) in case.patterns.iter().zip(subject_types.iter()) {
-                                        if let ast::CasePattern::Name(n) = f {
+                        self.collect_pattern(pat, subject_ty, true);
-                                            self.bind(n, fty.clone());
-                                        }
-                                    }
-                                }
-                            }
-                            _ => {}
-                        }
                     }
                     self.walk_block(&case.body);
                     self.env = saved;
@@ -1101,6 +1745,8 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Re
         next_classcall_slot: 0,
         closure_scratch: HashMap::new(),
         next_closure_slot: 0,
+        nested_class_scratch: HashMap::new(),
+        next_nested_class_slot: 0,
     };
     if let ast::FnBody::Block(block) = &f.body {
         collector.walk_block(block);
@@ -1109,7 +1755,6 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Re
         // `main() -> Int = each(|v| v)`), which needs construction scratch slots.
         collector.walk_expr(e);
     }
     // ---- assign local indices: [self?][params][named...][classcall scratch...][match scratch...] ----
     let mut locals: HashMap<String, u32> = HashMap::new();
     let mut groups: Vec<ValType> = Vec::new();
@@ -1139,9 +1784,18 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Re
     let match_scratch_base = idx;
     let mut match_scratch_index: HashMap<usize, u32> = HashMap::new();
-    for (ptr, ty) in collector.match_scratch.iter() {
+    for (ptr, types) in collector.match_scratch.iter() {
         match_scratch_index.insert(*ptr, idx - match_scratch_base);
+        for ty in types {
-        groups.push(plum_type_to_valtype(ty));
+            groups.push(plum_type_to_valtype(ty));
+            idx += 1;
+        }
+    }
+    let nested_class_scratch_base = idx;
+    let nested_class_scratch_count = collector.nested_class_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
+    for _ in 0..nested_class_scratch_count {
+        groups.push(ValType::I32);
         idx += 1;
     }
@@ -1169,14 +1823,20 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Re
         match_scratch_index,
         closure_scratch_base,
         closure_scratch: collector.closure_scratch,
+        nested_class_scratch_base,
+        nested_class_scratch: collector.nested_class_scratch,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
+        named_fn_values: &ctx.named_fn_values,
+        string_concat_func: ctx.string_concat_func,
+        int_to_string_func: ctx.int_to_string_func,
         classes: &ctx.classes,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         type_env: RefCell::new(base_env),
+        closure_local_sigs: RefCell::new(HashMap::new()),
         bump_global: ctx.bump_global,
     };
@@ -1321,7 +1981,15 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
     match stmt {
         ast::Stmt::Assign(a) => {
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
+                // See the matching comment in `Collector::walk_stmt`: the checker's
+                // closure inference is unreliable (can error out entirely depending
+                // on the body), but every closure value is an i32 pointer regardless
+                // of its real signature, so don't bother inferring it at all here.
+                let vty = if matches!(value, ast::Expr::Closure(_)) {
+                    PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
+                } else {
-                let vty = infer_local_type(value, ctx);
+                    infer_local_type(value, ctx)
+                };
                 compile_expr(value, body, ctx, state)?;
                 let idx = ctx
                     .locals
@@ -1330,6 +1998,17 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
                     .ok_or_else(|| format!("undeclared local '{}'", target))?;
                 Instruction::LocalSet(idx).encode(body);
                 ctx.type_env.borrow_mut().insert(target.clone(), TypeScheme::mono(vty));
+                // If this assigns a closure *literal*, remember its exact, already-
+                // correct signature (computed by the discovery pass) so a later call
+                // to it doesn't have to re-derive one — see `closure_local_sigs`.
+                if let ast::Expr::Closure(cl) = value {
+                    let key = cl.as_ref() as *const ast::Closure as usize;
+                    if let Some(info) = ctx.closures.get(&key) {
+                        let mut sig_params = vec![ValType::I32];
+                        sig_params.extend(info.param_vts.iter().copied());
+                        ctx.closure_local_sigs.borrow_mut().insert(target.clone(), (sig_params, info.ret_vt));
+                    }
+                }
             }
         }
         ast::Stmt::Return(Some(e)) => {
@@ -1453,40 +2132,64 @@ fn expr_has_result(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
 /// so previously-working exhaustive enum matches (e.g. `Some`/`None`, `True`/`False`)
 /// keep compiling even without a trailing wildcard, while a genuinely non-exhaustive
 /// match (an `Int` match, or an enum match missing a variant) still gets a clear error.
+/// True if `cases` already covers every combination of enum variants across all
+/// subject positions (by explicit tag/constructor patterns only — no binding or
+/// wildcard in any position), i.e. the match is exhaustive at runtime even though
+/// `compile_match_arms_multi` can't see that from the remaining-cases slice alone.
+/// For a single subject this is "every variant of its enum is named somewhere";
+/// for `match a, b, ...` it's the full cross product (e.g. `Bool, Bool` needs all
+/// 4 combinations named, matching `libs/std/bool.plum`'s `and`/`or`).
-fn match_covers_every_enum_variant(cases: &[ast::Case], subject_vt: ValType, ctx: &LocalCtx) -> bool {
+fn match_covers_every_enum_variant(cases: &[ast::Case], subject_vts: &[ValType], ctx: &LocalCtx) -> bool {
-    if subject_vt != ValType::I32 {
+    if subject_vts.is_empty() || subject_vts.iter().any(|vt| *vt != ValType::I32) {
         return false;
     }
+    let n = subject_vts.len();
-    let mut enum_name: Option<&str> = None;
+    let mut enum_names: Vec<Option<String>> = vec![None; n];
-    let mut tags_seen: std::collections::BTreeSet<i32> = std::collections::BTreeSet::new();
+    let mut tuples_seen: std::collections::BTreeSet<Vec<i32>> = std::collections::BTreeSet::new();
     for case in cases {
+        if case.patterns.len() != n {
+            return false;
+        }
+        let mut tuple = Vec::with_capacity(n);
+        for (i, pat) in case.patterns.iter().enumerate() {
-        let variant_name = match case.patterns.first() {
+            let variant_name = match pat {
-            Some(ast::CasePattern::Name(n))
+                ast::CasePattern::Name(nm)
-                if n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) && ctx.enum_variants.contains_key(n) =>
+                    if nm.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) && ctx.enum_variants.contains_key(nm) =>
-            {
+                {
-                n.as_str()
+                    nm.as_str()
-            }
+                }
-            Some(ast::CasePattern::Class { name, .. }) => name.as_str(),
+                ast::CasePattern::Class { name, .. } => name.as_str(),
+                // A binding or wildcard at any position could match variants we
+                // haven't otherwise named, so we can't prove full coverage this way.
-            _ => return false,
+                _ => return false,
-        };
+            };
-        let info = match ctx.enum_variants.get(variant_name) {
+            let info = match ctx.enum_variants.get(variant_name) {
-            Some(info) => info,
+                Some(info) => info,
+                None => return false,
+            };
+            match &enum_names[i] {
+                Some(en) if en != &info.enum_name => return false,
+                Some(_) => {}
+                None => enum_names[i] = Some(info.enum_name.clone()),
+            }
+            tuple.push(info.tag);
+        }
+        tuples_seen.insert(tuple);
+    }
+    let mut total_combinations: usize = 1;
+    for en in &enum_names {
+        match en {
+            Some(name) => {
+                let count = ctx.enum_variants.values().filter(|v| &v.enum_name == name).count();
+                total_combinations = match total_combinations.checked_mul(count) {
+                    Some(t) => t,
+                    None => return false,
+                };
+            }
             None => return false,
-        };
-        match enum_name {
-            Some(en) if en != info.enum_name => return false,
-            Some(_) => {}
-            None => enum_name = Some(&info.enum_name),
         }
-        tags_seen.insert(info.tag);
-    }
-    match enum_name {
-        Some(en) => {
-            let total_variants = ctx.enum_variants.values().filter(|v| v.enum_name == en).count();
-            !tags_seen.is_empty() && tags_seen.len() == total_variants
-        }
-        None => false,
     }
+    !tuples_seen.is_empty() && tuples_seen.len() == total_combinations
 }
 fn compile_match(
@@ -1496,46 +2199,51 @@ fn compile_match(
     state: &mut ModuleState,
     result_vt: Option<ValType>,
 ) -> Result<(), String> {
-    if m.subjects.len() != 1 {
-        return Err("codegen: multi-subject match is not yet supported".to_string());
-    }
-    let subject = &m.subjects[0];
-    let subject_ty = infer_local_type(subject, ctx);
-    let subject_vt = plum_type_to_valtype(&subject_ty);
     let key = m as *const ast::Match as usize;
-    let slot = *ctx
+    let base_slot = *ctx
         .match_scratch_index
         .get(&key)
         .ok_or_else(|| "internal codegen error: missing match scratch slot".to_string())?;
-    let scratch_local = ctx.match_scratch_base + slot;
-    compile_expr(subject, body, ctx, state)?;
-    Instruction::LocalSet(scratch_local).encode(body);
-    // A match in value position whose arms already cover every variant of the
-    // subject's enum type (by explicit tag/constructor patterns, no wildcard) is
-    // exhaustive at runtime even though `compile_match_arms` can't see that from the
-    // remaining-cases slice alone. Give it a synthetic trailing `_ => todo` arm so the
-    // "out of patterns" fallback compiles to an (unreachable, but valid) trap instead
-    // of a spurious non-exhaustive-match error.
-    if result_vt.is_some() && match_covers_every_enum_variant(&m.cases, subject_vt, ctx) {
-        let mut cases = m.cases.clone();
-        cases.push(ast::Case {
-            patterns: vec![ast::CasePattern::Wildcard],
-            body: ast::Block { stmts: vec![ast::Stmt::Todo] },
-        });
-        return compile_match_arms(&cases, subject_vt, scratch_local, result_vt, body, ctx, state);
-    }
+    // Evaluate every subject into its own consecutive scratch local (one per
+    // subject, in `match a, b, ...` order) before checking any pattern.
+    let mut all_subjects: Vec<(ValType, u32)> = Vec::with_capacity(m.subjects.len());
+    for (i, subject) in m.subjects.iter().enumerate() {
+        let subject_ty = infer_local_type(subject, ctx);
+        let subject_vt = plum_type_to_valtype(&subject_ty);
+        let scratch_local = ctx.match_scratch_base + base_slot + i as u32;
+        compile_expr(subject, body, ctx, state)?;
+        Instruction::LocalSet(scratch_local).encode(body);
+        all_subjects.push((subject_vt, scratch_local));
+    }
+    // A match in value position whose arms already cover every combination of
+    // enum variants across all subjects (by explicit tag/constructor patterns, no
+    // wildcard) is exhaustive at runtime even though `compile_match_arms_multi` can't
+    // see that from the remaining-cases slice alone. `exhaustive_fallback` tells it to
+    // compile the "ran out of cases" path as an (unreachable, but valid) trap instead
+    // of a spurious non-exhaustive-match error — threaded through as a flag, rather
+    // than appending a synthetic wildcard case by cloning `m.cases`, because cloning
+    // would reallocate every nested `CasePattern::Class` node at a new address and
+    // break `nested_class_scratch`'s pointer-identity-keyed lookup.
+    let subject_vts: Vec<ValType> = all_subjects.iter().map(|(vt, _)| *vt).collect();
+    let exhaustive_fallback = result_vt.is_some() && match_covers_every_enum_variant(&m.cases, &subject_vts, ctx);
-    compile_match_arms(&m.cases, subject_vt, scratch_local, result_vt, body, ctx, state)
+    compile_match_arms_multi(&m.cases, &all_subjects, result_vt, exhaustive_fallback, body, ctx, state)
 }
+/// Tries each case in turn (in source order); a case that fails to match falls
+/// through to the next one. `all_subjects` is the full `(valtype, scratch_local)`
+/// list for every subject of the enclosing `match`, shared unchanged across every
+/// case (each case's own pattern list is checked position-by-position against it
+/// via `compile_case_positions`). `exhaustive_fallback` (see `compile_match`) says
+/// what to do once `cases` runs out: trap (proven exhaustive) or report a
+/// non-exhaustive-match error.
-fn compile_match_arms(
+fn compile_match_arms_multi(
     cases: &[ast::Case],
-    subject_vt: ValType,
+    all_subjects: &[(ValType, u32)],
-    scratch_local: u32,
     result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -1543,6 +2251,10 @@ fn compile_match_arms(
     let (case, rest) = match cases.split_first() {
         None => {
             return match result_vt {
+                Some(_) if exhaustive_fallback => {
+                    Instruction::Unreachable.encode(body);
+                    Ok(())
+                }
                 Some(_) => Err(
                     "codegen: function has a control-flow path that doesn't produce a return value (non-exhaustive match)".to_string(),
                 ),
@@ -1551,17 +2263,49 @@ fn compile_match_arms(
         }
         Some(pair) => pair,
     };
+    if case.patterns.len() != all_subjects.len() {
+        return Err(format!(
+            "codegen: match case has {} pattern(s), expected {} (one per subject)",
+            case.patterns.len(), all_subjects.len()
+        ));
+    }
+    compile_case_positions(case, 0, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
+}
+/// Checks `case.patterns[pos]` against `all_subjects[pos]`; on success, recurses to
+/// `pos + 1` (or, once every position has matched, compiles the case body). On
+/// failure at any position, falls through to `compile_match_arms_multi(rest, ...)`
+/// — i.e. the *entire next case*, restarting from its own position 0, not the next
-    let pat = case.patterns.first().ok_or_else(|| "codegen: match case has no pattern".to_string())?;
+/// position of this case. This is what gives `match a, b` its "all positions must
+/// match" (AND) semantics while still trying cases in order.
+#[allow(clippy::too_many_arguments)]
+fn compile_case_positions(
+    case: &ast::Case,
+    pos: usize,
+    all_subjects: &[(ValType, u32)],
+    rest: &[ast::Case],
+    result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    if pos == case.patterns.len() {
+        // Every position matched.
+        return compile_case_body(&case.body, result_vt, body, ctx, state);
+    }
+    let pat = &case.patterns[pos];
+    let (subject_vt, scratch_local) = all_subjects[pos];
     match pat {
         ast::CasePattern::Wildcard => {
-            // Any cases after a wildcard are unreachable, matching real match semantics.
+            // Always matches this position; move on to the next one.
-            compile_case_body(&case.body, result_vt, body, ctx, state)
+            compile_case_positions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
         }
         ast::CasePattern::Name(n) => {
             let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
                 && ctx.enum_variants.contains_key(n);
             if is_variant {
-                compile_variant_eq_arm(n, subject_vt, scratch_local, result_vt, case, rest, body, ctx, state)
+                compile_variant_eq_arm(n, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
             } else {
                 let idx = ctx
                     .locals
@@ -1571,8 +2315,8 @@ fn compile_match_arms(
                 Instruction::LocalGet(scratch_local).encode(body);
                 Instruction::LocalSet(idx).encode(body);
                 ctx.type_env.borrow_mut().insert(n.clone(), TypeScheme::mono(plum_type_from_valtype_hint(subject_vt)));
-                compile_case_body(&case.body, result_vt, body, ctx, state)
-                // A binding arm always matches — any following cases are unreachable.
+                // A binding always matches this position; move on to the next one.
+                compile_case_positions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
             }
         }
         ast::CasePattern::Int(n) => {
@@ -1583,16 +2327,16 @@ fn compile_match_arms(
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(block_type_for(result_vt)).encode(body);
-            compile_case_body(&case.body, result_vt, body, ctx, state)?;
+            compile_case_positions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)?;
             Instruction::Else.encode(body);
-            compile_match_arms(rest, subject_vt, scratch_local, result_vt, body, ctx, state)?;
+            compile_match_arms_multi(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
             Instruction::End.encode(body);
             Ok(())
         }
         ast::CasePattern::String(_) => Err("codegen: string match patterns are not yet supported".to_string()),
         ast::CasePattern::Float(_) => Err("codegen: float match patterns are not yet supported".to_string()),
         ast::CasePattern::Class { name, fields } => {
-            compile_variant_constructor_arm(name, fields, subject_vt, scratch_local, result_vt, case, rest, body, ctx, state)
+            compile_variant_constructor_arm(name, fields, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
         }
     }
 }
@@ -1602,9 +2346,12 @@ fn compile_variant_eq_arm(
     name: &str,
     subject_vt: ValType,
     scratch_local: u32,
-    result_vt: Option<ValType>,
     case: &ast::Case,
+    pos: usize,
+    all_subjects: &[(ValType, u32)],
     rest: &[ast::Case],
+    result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -1621,9 +2368,9 @@ fn compile_variant_eq_arm(
     Instruction::I32Const(tag).encode(body);
     Instruction::I32Eq.encode(body);
     Instruction::If(block_type_for(result_vt)).encode(body);
-    compile_case_body(&case.body, result_vt, body, ctx, state)?;
+    compile_case_positions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)?;
     Instruction::Else.encode(body);
-    compile_match_arms(rest, subject_vt, scratch_local, result_vt, body, ctx, state)?;
+    compile_match_arms_multi(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
     Instruction::End.encode(body);
     Ok(())
 }
@@ -1634,9 +2381,12 @@ fn compile_variant_constructor_arm(
     fields: &[ast::CasePattern],
     subject_vt: ValType,
     scratch_local: u32,
-    result_vt: Option<ValType>,
     case: &ast::Case,
+    pos: usize,
+    all_subjects: &[(ValType, u32)],
     rest: &[ast::Case],
+    result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -1674,34 +2424,151 @@ fn compile_variant_constructor_arm(
     Instruction::I32Const(0).encode(body);
     Instruction::End.encode(body);
     Instruction::If(block_type_for(result_vt)).encode(body);
+    compile_field_patterns(
+        fields, &field_types, 0, scratch_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state,
+        &mut |body, state| compile_case_positions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state),
+    )?;
+    Instruction::Else.encode(body);
+    compile_match_arms_multi(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
+    Instruction::End.encode(body);
+    Ok(())
+}
+/// Checks `fields[fpos..]` (a constructor pattern's own sub-patterns, e.g. the `v` in
+/// `Some(v)`, or — recursively — the `Some(v)` in `Wrap(Some(v))`) against the
-    for (i, (pat, field_ty)) in fields.iter().zip(field_types.iter()).enumerate() {
+/// already-loaded value in `container_local`, one field at a time. Once every field
+/// has matched, calls `on_match` (typically: proceed to the next top-level subject
+/// position). A mismatch at any field — at any nesting depth — falls through to
+/// `compile_match_arms_multi(rest, ...)`, exactly like a top-level pattern mismatch.
+#[allow(clippy::too_many_arguments)]
+fn compile_field_patterns(
+    fields: &[ast::CasePattern],
+    field_types: &[PlumType],
+    fpos: usize,
+    container_local: u32,
+    rest: &[ast::Case],
+    all_subjects: &[(ValType, u32)],
+    result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+    on_match: &mut dyn FnMut(&mut Vec<u8>, &mut ModuleState) -> Result<(), String>,
+) -> Result<(), String> {
+    if fpos == fields.len() {
+        return on_match(body, state);
+    }
-        let bind_name = match pat {
+    let pat = &fields[fpos];
+    let field_ty = &field_types[fpos];
-            ast::CasePattern::Name(n) => Some(n.as_str()),
+    let field_vt = plum_type_to_valtype(field_ty);
+    let offset = ((fpos + 1) as u64) * 8;
+    match pat {
-            ast::CasePattern::Wildcard => None,
+        ast::CasePattern::Wildcard => {
-            _ => return Err("codegen: only bare bindings or '_' are supported inside a constructor pattern".to_string()),
+            compile_field_patterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
-        };
+        }
+        ast::CasePattern::Name(n) if !(n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) && ctx.enum_variants.contains_key(n)) => {
+            // A plain binding always matches this field; load it straight into its
-        if let Some(n) = bind_name {
+            // binding local and move on to the next field.
             let idx = ctx
                 .locals
                 .get(n)
                 .copied()
                 .ok_or_else(|| format!("internal codegen error: missing binding local '{}'", n))?;
-            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::LocalGet(container_local).encode(body);
-            let offset = ((i + 1) as u64) * 8;
-            match plum_type_to_valtype(field_ty) {
+            emit_load(field_vt, offset, body);
-                ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }),
-                ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }),
-                _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }),
-            }.encode(body);
             Instruction::LocalSet(idx).encode(body);
             ctx.type_env.borrow_mut().insert(n.to_string(), TypeScheme::mono(field_ty.clone()));
+            compile_field_patterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
+        }
+        ast::CasePattern::Name(n) => {
+            // An uppercase, payload-free variant name used as a field pattern (e.g.
+            // matching a nested `None` rather than binding a name to it).
+            let info = ctx
+                .enum_variants
+                .get(n)
+                .ok_or_else(|| format!("codegen: unknown enum variant '{}'", n))?;
+            if field_vt != ValType::I32 {
+                return Err(format!("codegen: enum tag pattern '{}' against a non-enum field", n));
+            }
+            Instruction::LocalGet(container_local).encode(body);
+            emit_load(field_vt, offset, body);
+            Instruction::I32Const(info.tag).encode(body);
+            Instruction::I32Eq.encode(body);
+            Instruction::If(block_type_for(result_vt)).encode(body);
+            compile_field_patterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)?;
+            Instruction::Else.encode(body);
+            compile_match_arms_multi(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
+            Instruction::End.encode(body);
+            Ok(())
+        }
+        ast::CasePattern::Int(n) => {
+            if field_vt != ValType::I64 {
+                return Err("codegen: integer match pattern against a non-Int field".to_string());
+            }
+            Instruction::LocalGet(container_local).encode(body);
+            emit_load(field_vt, offset, body);
+            Instruction::I64Const(*n).encode(body);
+            Instruction::I64Eq.encode(body);
+            Instruction::If(block_type_for(result_vt)).encode(body);
+            compile_field_patterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)?;
+            Instruction::Else.encode(body);
+            compile_match_arms_multi(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
+            Instruction::End.encode(body);
+            Ok(())
+        }
+        ast::CasePattern::String(_) => Err("codegen: string match patterns are not yet supported".to_string()),
+        ast::CasePattern::Float(_) => Err("codegen: float match patterns are not yet supported".to_string()),
+        ast::CasePattern::Class { name, fields: inner_fields } => {
+            let info = ctx
+                .enum_variants
+                .get(name)
+                .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
+            if field_vt != ValType::I32 {
+                return Err(format!("codegen: constructor pattern '{}' against a non-enum field", name));
+            }
+            if inner_fields.len() != info.field_types.len() {
+                return Err(format!(
+                    "codegen: constructor pattern '{}' expects {} field(s), got {}",
+                    name, info.field_types.len(), inner_fields.len()
+                ));
+            }
+            let key = pat as *const ast::CasePattern as usize;
+            let slot = *ctx
+                .nested_class_scratch
+                .get(&key)
+                .ok_or_else(|| "internal codegen error: missing nested constructor pattern scratch slot".to_string())?;
+            let nested_local = ctx.nested_class_scratch_base + slot;
+            let tag = info.tag;
+            let inner_field_types = info.field_types.clone();
+            Instruction::LocalGet(container_local).encode(body);
+            emit_load(field_vt, offset, body);
+            Instruction::LocalSet(nested_local).encode(body);
+            // Same heap-pointer guard as the top-level constructor check: a
+            // payload-free sibling variant is a small int tag, not a pointer.
+            Instruction::LocalGet(nested_local).encode(body);
+            Instruction::I32Const(HEAP_BASE as i32).encode(body);
+            Instruction::I32GeU.encode(body);
+            Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+            Instruction::LocalGet(nested_local).encode(body);
+            Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
+            Instruction::I32Const(tag).encode(body);
+            Instruction::I32Eq.encode(body);
+            Instruction::Else.encode(body);
+            Instruction::I32Const(0).encode(body);
+            Instruction::End.encode(body);
+            Instruction::If(block_type_for(result_vt)).encode(body);
+            compile_field_patterns(inner_fields, &inner_field_types, 0, nested_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, &mut |body, state| {
+                compile_field_patterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
+            })?;
+            Instruction::Else.encode(body);
+            compile_match_arms_multi(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
+            Instruction::End.encode(body);
+            Ok(())
         }
     }
-    compile_case_body(&case.body, result_vt, body, ctx, state)?;
-    Instruction::Else.encode(body);
-    compile_match_arms(rest, subject_vt, scratch_local, result_vt, body, ctx, state)?;
-    Instruction::End.encode(body);
-    Ok(())
 }
 fn plum_type_from_valtype_hint(vt: ValType) -> PlumType {
@@ -1721,11 +2588,19 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
             Instruction::F64Const(*f).encode(body);
         }
         ast::Expr::Var(name) => {
+            match ctx.locals.get(name.as_str()) {
+                Some(idx) => Instruction::LocalGet(*idx).encode(body),
+                // Not a local: a bare reference to a top-level function used as a
+                // value (e.g. `each(double)`) — push its zero-capture trampoline
+                // closure's (compile-time-constant) struct pointer.
+                None => {
-            let idx = *ctx
+                    let offset = *ctx
-                .locals
+                        .named_fn_values
-                .get(name.as_str())
+                        .get(name.as_str())
-                .ok_or_else(|| format!("undeclared variable '{}'", name))?;
+                        .ok_or_else(|| format!("undeclared variable '{}'", name))?;
-            Instruction::LocalGet(idx).encode(body);
+                    Instruction::I32Const(offset as i32).encode(body);
+                }
+            }
         }
         ast::Expr::Paren(inner) => {
             compile_expr(inner, body, ctx, state)?;
@@ -1943,23 +2818,20 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
             }
         }
         ast::Expr::String(s) => {
+            let has_interp = s.parts.iter().any(|p| matches!(p, ast::StringPart::Interp(_)));
+            if !has_interp {
+                // Fast path: every part is static text, so the whole literal is one
+                // fixed byte blob known at compile time — no runtime work at all.
-            let mut text = String::new();
+                let mut text = String::new();
-            for part in &s.parts {
+                for part in &s.parts {
-                match part {
-                    ast::StringPart::Text(t) => text.push_str(t),
-                    ast::StringPart::Interp(_) => {
+                    if let ast::StringPart::Text(t) = part {
-                        return Err("codegen: string interpolation is not yet supported".to_string());
+                        text.push_str(t);
                     }
                 }
+                compile_static_string(&text, body, state);
+            } else {
+                compile_interpolated_string(s, body, ctx, state)?;
             }
-            let bytes = text.as_bytes();
-            let offset = state.next_string_offset;
-            let mut data = Vec::with_capacity(4 + bytes.len());
-            data.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
-            data.extend_from_slice(bytes);
-            state.next_string_offset += data.len() as u32;
-            state.data_segments.push((offset, data));
-            Instruction::I32Const(offset as i32).encode(body);
         }
         ast::Expr::Closure(cl) => {
             compile_closure_literal(cl, body, ctx, state)?;
@@ -2047,6 +2919,74 @@ fn emit_load(vt: ValType, offset: u64, body: &mut Vec<u8>) {
     }.encode(body);
 }
+/// Emits a static (compile-time-known) length-prefixed string as a fresh data
+/// segment, pushing its address.
+fn compile_static_string(text: &str, body: &mut Vec<u8>, state: &mut ModuleState) {
+    let bytes = text.as_bytes();
+    let offset = state.next_string_offset;
+    let mut data = Vec::with_capacity(4 + bytes.len());
+    data.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
+    data.extend_from_slice(bytes);
+    state.next_string_offset += data.len() as u32;
+    state.data_segments.push((offset, data));
+    Instruction::I32Const(offset as i32).encode(body);
+}
+/// Lowers a string literal that contains at least one `{expr}` interpolation.
+/// Every part becomes a string-pointer-valued expression (static text via
+/// `compile_static_string`; `Str`/`Int`/`Bool` interpolated values converted at
+/// runtime), then all parts are left-folded together with the `__string_concat`
+/// runtime helper.
+fn compile_interpolated_string(
+    s: &ast::StringExpr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let mut first = true;
+    for part in &s.parts {
+        match part {
+            ast::StringPart::Text(t) => {
+                compile_static_string(t, body, state);
+            }
+            ast::StringPart::Interp(expr) => {
+                let ty = infer_local_type(expr, ctx);
+                match ty {
+                    PlumType::TStr => {
+                        compile_expr(expr, body, ctx, state)?;
+                    }
+                    PlumType::TInt => {
+                        compile_expr(expr, body, ctx, state)?;
+                        Instruction::Call(ctx.int_to_string_func).encode(body);
+                    }
+                    PlumType::TBool => {
+                        compile_expr(expr, body, ctx, state)?;
+                        Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+                        compile_static_string("True", body, state);
+                        Instruction::Else.encode(body);
+                        compile_static_string("False", body, state);
+                        Instruction::End.encode(body);
+                    }
+                    PlumType::TFloat => {
+                        return Err("codegen: interpolating a Float value is not yet supported".to_string());
+                    }
+                    other => {
+                        return Err(format!(
+                            "codegen: interpolating a value of type {} is not yet supported",
+                            other
+                        ));
+                    }
+                }
+            }
+        }
+        if !first {
+            Instruction::Call(ctx.string_concat_func).encode(body);
+        }
+        first = false;
+    }
+    Ok(())
+}
 /// Compiles a closure *literal* at its construction site. Snapshots each captured free
 /// variable's CURRENT value into a fresh heap env struct, then builds the 2-word closure
 /// struct `{table_index @0, env_pointer @8}` and leaves its pointer on the stack.
@@ -2060,7 +3000,7 @@ fn compile_closure_literal(
     let info = ctx
         .closures
         .get(&key)
-        .ok_or_else(|| "codegen: closure literal was not discovered (nested closures are not supported)".to_string())?;
+        .ok_or_else(|| "internal codegen error: closure literal was not discovered by the discovery pre-pass".to_string())?;
     let scratch_off = *ctx
         .closure_scratch
         .get(&key)
@@ -2124,20 +3064,28 @@ fn compile_closure_call(
         .get(&call.name)
         .ok_or_else(|| format!("codegen: closure '{}' is not a local", call.name))?;
+    // Prefer the exact signature recorded when this local was assigned a closure
+    // *literal* (see `closure_local_sigs`) — it's already correct. Otherwise (e.g.
+    // `call.name` is a `fn(...)`-typed parameter, whose declared type is reliable on
+    // its own) fall back to re-deriving it from the type env.
+    let sig_key: ClosureSigKey = match ctx.closure_local_sigs.borrow().get(&call.name) {
+        Some(key) => key.clone(),
+        None => {
-    let (param_ptypes, ret_ptype) = match infer_local_type(&ast::Expr::Var(call.name.clone()), ctx) {
+            let (param_ptypes, ret_ptype) = match infer_local_type(&ast::Expr::Var(call.name.clone()), ctx) {
-        PlumType::TFun(p, r) => (p, *r),
+                PlumType::TFun(p, r) => (p, *r),
-        other => return Err(format!("codegen: '{}' is not callable (type {:?})", call.name, other)),
+                other => return Err(format!("codegen: '{}' is not callable (type {:?})", call.name, other)),
-    };
+            };
-    let mut sig_params = vec![ValType::I32]; // env pointer
+            let mut sig_params = vec![ValType::I32]; // env pointer
-    for p in &param_ptypes {
+            for p in &param_ptypes {
-        sig_params.push(plum_type_to_valtype(p));
+                sig_params.push(plum_type_to_valtype(p));
-    }
+            }
-    let ret_vt = match ret_ptype {
+            let ret_vt = match ret_ptype {
-        PlumType::TUnit => None,
+                PlumType::TUnit => None,
-        other => Some(plum_type_to_valtype(&other)),
+                other => Some(plum_type_to_valtype(&other)),
+            };
+            (sig_params, ret_vt)
+        }
     };
-    let sig_key: ClosureSigKey = (sig_params, ret_vt);
     let type_index = *ctx
         .closure_call_types
         .get(&sig_key)
@@ -2187,6 +3135,8 @@ fn compile_closure_body(
         next_classcall_slot: 0,
         closure_scratch: HashMap::new(),
         next_closure_slot: 0,
+        nested_class_scratch: HashMap::new(),
+        next_nested_class_slot: 0,
     };
     collector.walk_block(&cl.body);
@@ -2224,9 +3174,18 @@ fn compile_closure_body(
     let match_scratch_base = idx;
     let mut match_scratch_index: HashMap<usize, u32> = HashMap::new();
-    for (ptr, ty) in collector.match_scratch.iter() {
+    for (ptr, types) in collector.match_scratch.iter() {
         match_scratch_index.insert(*ptr, idx - match_scratch_base);
+        for ty in types {
-        groups.push(plum_type_to_valtype(ty));
+            groups.push(plum_type_to_valtype(ty));
+            idx += 1;
+        }
+    }
+    let nested_class_scratch_base = idx;
+    let nested_class_scratch_count = collector.nested_class_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
+    for _ in 0..nested_class_scratch_count {
+        groups.push(ValType::I32);
         idx += 1;
     }
@@ -2262,14 +3221,20 @@ fn compile_closure_body(
         match_scratch_index,
         closure_scratch_base,
         closure_scratch: collector.closure_scratch,
+        nested_class_scratch_base,
+        nested_class_scratch: collector.nested_class_scratch,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
+        named_fn_values: &ctx.named_fn_values,
+        string_concat_func: ctx.string_concat_func,
+        int_to_string_func: ctx.int_to_string_func,
         classes: &ctx.classes,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         type_env: RefCell::new(base_env),
+        closure_local_sigs: RefCell::new(HashMap::new()),
         bump_global: ctx.bump_global,
     };

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -80,11 +80,62 @@ fn empty_string_literal_compiles() {
 }
 #[test]
-fn string_interpolation_is_a_clear_error() {
+fn string_interpolation_of_an_int_runs_correctly() {
-    let src = "main() -> Str =\n  x = 1\n  \"{x}\"\n";
+    let src = "main() -> Str =\n  x = 42\n  \"{x}\"\n";
     let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_str(&bytes), "42");
+}
+#[test]
+fn string_interpolation_of_a_negative_int_runs_correctly() {
+    let src = "main() -> Str =\n  x = -7\n  \"{x}\"\n";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_str(&bytes), "-7");
+}
+#[test]
+fn string_interpolation_of_zero_runs_correctly() {
+    let src = "main() -> Str =\n  x = 0\n  \"{x}\"\n";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_str(&bytes), "0");
+}
+#[test]
+fn string_interpolation_with_surrounding_text_and_multiple_interps_runs_correctly() {
+    let src = "main() -> Str =\n  count = 3\n  total = 10\n  \"{count} of {total} complete\"\n";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_str(&bytes), "3 of 10 complete");
+}
+#[test]
+fn string_interpolation_of_a_str_runs_correctly() {
+    let src = "greet(name: Str) -> Str =\n  \"Hello, {name}!\"\n\nmain() -> Str =\n  greet(\"World\")\n";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_str(&bytes), "Hello, World!");
+}
+#[test]
+fn string_interpolation_of_a_bool_runs_correctly() {
+    let src = "main() -> Str =\n  b = True\n  \"is {b}\"\n";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_str(&bytes), "is True");
+}
+#[test]
+fn string_interpolation_of_a_float_is_a_clear_error() {
+    // Float-to-decimal-string formatting is a substantial separate undertaking
+    // (correct rounding needs something like Grisu/Ryu); scoped out for now with
+    // an explicit error rather than emitting an incorrect conversion.
+    let src = "main() -> Str =\n  x = 1.5\n  \"{x}\"\n";
+    let source = parse(src);
-    let err = compile_source(&source).expect_err("interpolation should not silently compile");
+    let err = compile_source(&source).expect_err("float interpolation should not silently compile");
-    assert!(err.contains("interpolation"), "got: {}", err);
+    assert!(err.contains("Float"), "got: {}", err);
 }
 #[test]
@@ -161,7 +212,7 @@ fn match_string_pattern_is_a_clear_error() {
 }
 #[test]
-fn nested_constructor_pattern_is_a_clear_error() {
+fn nested_constructor_pattern_matches_and_binds_runs_correctly() {
     let src = "\
 enum Option =
   | Some(Int)
@@ -175,19 +226,101 @@ f(n: Nested) -> Int =
   match n
     Wrap(Some(v)) =>
       return v
+    Wrap(None) =>
+      return -1
     Empty =>
       return 0
 main() -> Int =
-  f(Empty)
+  f(Wrap(Some(5)))
 ";
     let source = parse(src);
-    let err = compile_source(&source).expect_err("nested constructor patterns are not yet supported");
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 5);
+}
-    assert!(
+#[test]
+fn nested_constructor_pattern_mismatch_falls_through_to_next_case_runs_correctly() {
-        err.contains("only bare bindings or '_' are supported inside a constructor pattern"),
+    // `Wrap(Some(v))` shouldn't match a runtime `Wrap(None)` — codegen must fall
+    // through to the next *top-level* case, not just fail to bind `v`.
-        "got: {}",
+    let src = "\
+enum Option =
+  | Some(Int)
+  | None
+enum Nested =
+  | Wrap(Option)
+  | Empty
+f(n: Nested) -> Int =
+  match n
+    Wrap(Some(v)) =>
-        err
+      return v
+    Wrap(None) =>
+      return -1
+    Empty =>
+      return 0
+main() -> Int =
+  f(Wrap(None))
-    );
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), -1);
+}
+#[test]
+fn nested_constructor_pattern_against_a_specialized_generic_enum_runs_correctly() {
+    // Exercises monomorphize.rs's recursive mangling: the outer `Full(...)` pattern
+    // matches against `Box`'s own specialization, but the *inner* `Some(v)`/`None`
+    // sub-pattern matches against `Box`'s generic field type (`Option`, itself
+    // specialized to `Option$Int`) — each level needs its own mangling table, not
+    // just the outermost one.
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+enum Box =
+  | Full(a)
+  | Empty
+unwrap(b: Box) -> Int =
+  match b
+    Full(Some(v)) => v
+    Full(None) => -1
+    Empty => 0
+main() -> Int =
+  unwrap(Full(Some(7)))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn doubly_nested_constructor_pattern_runs_correctly() {
+    // `Some(Some(v))` — two levels of nesting, proving the recursion isn't just
+    // one level deep.
+    let src = "\
+enum Option =
+  | Some(Option)
+  | None
+unwrapTwice(o: Option) -> Int =
+  match o
+    Some(Some(None)) => 1
+    Some(None) => 2
+    None => 3
+    _ => 0
+main() -> Int =
+  unwrapTwice(Some(Some(None)))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 1);
 }
 /// Runs `main`'s wasm bytes and returns its i64 result. wasm's own validator
@@ -204,6 +337,37 @@ fn run_main(bytes: &[u8]) -> i64 {
     main.call(&mut store, ()).expect("main should not trap")
 }
+fn run_main_f64(bytes: &[u8]) -> f64 {
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::new(&engine, bytes).expect("module should be loadable");
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
+    let main = instance
+        .get_typed_func::<(), f64>(&mut store, "main")
+        .expect("main should have signature () -> f64");
+    main.call(&mut store, ()).expect("main should not trap")
+}
+/// Runs a `() -> Str`-returning `main`, reading the length-prefixed
+/// `[len: u32][utf8 bytes]` string back out of the module's exported memory.
+fn run_main_str(bytes: &[u8]) -> String {
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::new(&engine, bytes).expect("module should be loadable");
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
+    let main = instance
+        .get_typed_func::<(), i32>(&mut store, "main")
+        .expect("main should have signature () -> i32");
+    let ptr = main.call(&mut store, ()).expect("main should not trap") as u32 as usize;
+    let memory = instance.get_memory(&mut store, "memory").expect("module should export memory");
+    let mut len_bytes = [0u8; 4];
+    memory.read(&store, ptr, &mut len_bytes).expect("string length read should be in bounds");
+    let len = u32::from_le_bytes(len_bytes) as usize;
+    let mut str_bytes = vec![0u8; len];
+    memory.read(&store, ptr + 4, &mut str_bytes).expect("string bytes read should be in bounds");
+    String::from_utf8(str_bytes).expect("string bytes should be valid utf8")
+}
 #[test]
 fn factorial_runs_correctly() {
     let src = "\
@@ -904,11 +1068,6 @@ fn wasm_module_with_a_table_element_validates_and_call_indirect_works() {
 #[test]
 fn non_capturing_closure_passed_and_called_runs_correctly() {
-    // The brief's plan scopes closures as "passable as an ordinary call argument
-    // (`each(|v| ...)`)"; the inline single-expression body is that supported form.
-    // (A multi-line indented closure body immediately followed by `)` on the same line
-    // needs the external scanner to emit a dedent at a closing bracket, which is a
-    // parser/scanner concern outside this codegen task — see task-5-report.md.)
     let src = "\
 each(cb: fn(Int) -> Int) -> Int =
   cb(5)
@@ -921,6 +1080,25 @@ main() -> Int =
     assert_eq!(run_main(&bytes), 5);
 }
+#[test]
+fn multi_line_closure_call_argument_with_closing_paren_on_last_statement_line_runs_correctly() {
+    // Was a documented gap: the external scanner never emitted a dedent for a
+    // multi-line closure body immediately followed by `)` on the same line as the
+    // body's last statement, so this shape didn't parse at all before.
+    let src = "\
+each(cb: fn(Int) -> Int) -> Int =
+  cb(5)
+main() -> Int =
+  each(|v|
+    x = v + 1
+    x * 2)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 12);
+}
 #[test]
 fn capturing_closure_snapshots_value_at_creation_time_runs_correctly() {
     let src = "\
@@ -945,6 +1123,54 @@ main() -> Int =
     assert_eq!(run_main(&bytes), 10);
 }
+#[test]
+fn closure_assigned_then_called_at_float_type_runs_correctly() {
+    // Was a documented gap: a closure created via assignment (not passed directly as
+    // a call argument) and later called at a concrete non-Int type could hit a wasm
+    // runtime trap — the checker's own closure inference gives every param a fresh
+    // TVar and never unifies it against how it's used in the body, so a genuinely
+    // Float param silently defaulted to Int, producing a `call_indirect` signature
+    // mismatch between the compiled closure body and its call site.
+    let src = "\
+eachF(cb: fn(Float) -> Float) -> Float =
+  cb(0.0)
+useClosure() -> Float =
+  offset = 2.5
+  cb = |v|
+    offset + v
+  eachF(cb)
+main() -> Float =
+  useClosure()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main_f64(&bytes), 2.5);
+}
+#[test]
+fn closure_assigned_then_called_at_class_type_runs_correctly() {
+    let src = "\
+type Cat =
+  age: Int
+eachCat(cb: fn(Cat) -> Int) -> Int =
+  cb(Cat(age: 7))
+useClosure() -> Int =
+  cb = |c|
+    c.age
+  eachCat(cb)
+main() -> Int =
+  useClosure()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
 #[test]
 fn closure_passed_through_already_generic_higher_order_function_runs_correctly() {
     let src = "\
@@ -961,3 +1187,185 @@ main() -> Int =
     let bytes = compile_source(&source).expect("compile failed");
     assert_eq!(run_main(&bytes), 14);
 }
+#[test]
+fn nested_closure_literal_runs_correctly() {
+    // Was a documented gap: a closure literal nested inside another closure's body
+    // produced a clear compile error (the discovery pre-pass never recursed into a
+    // closure's own body to find closures nested inside it). Here `inner` (nested
+    // inside `outer`'s body) needs `offset` — a name from `useNested`'s scope, two
+    // levels up from `inner` itself, and not referenced by `outer` directly — which
+    // exercises the multi-level capture chain: `outer` must itself capture `offset`
+    // purely because `inner` needs it, not because `outer` uses it.
+    let src = "\
+each(cb: fn(Int) -> Int) -> Int =
+  cb(5)
+useNested() -> Int =
+  offset = 100
+  outer = |v|
+    inner = |w|
+      w + offset
+    inner(v)
+  each(outer)
+main() -> Int =
+  useNested()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 105);
+}
+#[test]
+fn nested_closure_literal_passed_directly_as_call_argument_runs_correctly() {
+    let src = "\
+each(cb: fn(Int) -> Int) -> Int =
+  cb(5)
+main() -> Int =
+  each(|v|
+    each(|w| w + v))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 10);
+}
+#[test]
+fn named_function_used_as_a_closure_typed_value_runs_correctly() {
+    // A plain top-level named function (not a `|params| body` closure literal) used
+    // wherever a `fn(...)`-typed value is expected — no closure literal involved at
+    // the call site at all.
+    let src = "\
+double(x: Int) -> Int =
+  x * 2
+each(cb: fn(Int) -> Int) -> Int =
+  cb(21)
+main() -> Int =
+  each(double)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}
+#[test]
+fn named_function_used_as_a_value_assigned_then_called_runs_correctly() {
+    let src = "\
+double(x: Int) -> Int =
+  x * 2
+main() -> Int =
+  f = double
+  f(21)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}
+#[test]
+fn named_function_used_as_a_value_alongside_a_closure_at_the_same_call_type_runs_correctly() {
+    // Proves the trampoline shares the same call_indirect type as an ordinary
+    // closure of the same signature (both must resolve to the same wasm function
+    // type, since both flow through the exact same `cb(...)` call site).
+    let src = "\
+double(x: Int) -> Int =
+  x * 2
+each(cb: fn(Int) -> Int) -> Int =
+  cb(10)
+main() -> Int =
+  each(double) + each(|v| v + 1)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 31);
+}
+#[test]
+fn multi_subject_match_with_enum_tags_runs_correctly() {
+    // Mirrors libs/std/bool.plum's `and`/`or`: `match self, o` against two Bool
+    // subjects, each case naming a tag pattern per position.
+    let src = "\
+and(a: Bool, b: Bool) -> Bool =
+  match a, b
+    True, True => True
+    True, False => False
+    False, True => False
+    False, False => False
+main() -> Int =
+  x = and(True, True)
+  y = and(True, False)
+  match x, y
+    True, False => 1
+    _, _ => 0
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 1);
+}
+#[test]
+fn multi_subject_match_falls_through_to_next_case_when_only_first_position_matches() {
+    // The first case's position-0 pattern (`1`) matches, but position-1 (`1`)
+    // doesn't (b is 2) — codegen must fall through to the *next case* (trying its
+    // own position 0 again), not just "move on" within the first case.
+    let src = "\
+classify(a: Int, b: Int) -> Int =
+  match a, b
+    1, 1 => 100
+    1, 2 => 200
+    _, _ => 0
+main() -> Int =
+  classify(1, 2)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 200);
+}
+#[test]
+fn multi_subject_match_with_binding_and_wildcard_runs_correctly() {
+    let src = "\
+combine(a: Int, b: Int) -> Int =
+  match a, b
+    0, y => y
+    x, 0 => x
+    x, y => x + y
+main() -> Int =
+  combine(3, 4)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn multi_subject_match_with_generic_enum_variant_runs_correctly() {
+    // Exercises the monomorphize.rs fix: each subject's own generic-enum
+    // specialization (`Some$Int`) must be mangled independently per position.
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+both(a: Option, b: Option) -> Int =
+  match a, b
+    Some(x), Some(y) => x + y
+    _, _ => 0
+main() -> Int =
+  both(Some(3), Some(4))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}

plum-wasm-codegen/tests/examples_test.rs CHANGED Viewed

@@ -100,10 +100,11 @@ fn closures_example_compiles_and_runs_correctly() {
     assert_eq!(main.call(&mut store, ()).expect("main should not trap"), 120);
 }
-/// strings.plum still exercises string interpolation, which remains unimplemented.
+/// strings.plum exercises string interpolation (plain literals, `Str`/`Int`
+/// interpolation, and escape sequences) — it has no `main` to execute, so (matching
+/// `basics_compiles`/`control_flow_compiles`/etc. above for other main-less examples)
+/// this only checks that it compiles to a valid module.
 #[test]
-fn strings_example_reports_clear_interpolation_error() {
+fn strings_example_compiles() {
-    let source = parse_file("strings.plum");
+    assert_compiles("strings.plum");
-    let err = compile_source(&source).expect_err("string interpolation is not yet supported");
-    assert!(err.contains("interpolation"), "got: {}", err);
 }

tooling/tree-sitter-plum/src/scanner.c CHANGED Viewed

@@ -263,7 +263,33 @@ bool tree_sitter_plum_external_scanner_scan(void *payload, TSLexer *lexer, const
         }
     }
+    // A closure literal's indented body, used directly as a call argument, can be
+    // immediately followed by a closing bracket with no intervening newline at all
+    // (`each(|v|\n  v)`), since the body's last statement and the bracket that ends
+    // the enclosing call are on the same line. The loop above only ever sets
+    // `found_end_of_line` by actually consuming a `\n`, so that shape reaches here
+    // with `found_end_of_line == false` and no dedent is ever considered — even
+    // though the grammar, mid-parse, is already asking for one (`valid_symbols[DEDENT]`
+    // is true here exactly when a `body` node needs to close before the bracket can be
+    // shifted). Treat that specific situation as equivalent to "found a blank new
+    // line" for dedent purposes only: there's no partial line indentation to measure
+    // (we're mid-expression, not at a line start), so it behaves as `indent_length == 0`,
+    // which is `< current_indent_length` for any real indented block. Never treat it as
+    // a NEWLINE — the grammar isn't expecting one at a raw closing bracket.
+    //
+    // (A comma continuing the argument list on the same line, e.g.
+    // `each(|v|\n  v, extra)`, is the same underlying shape but isn't handled here:
+    // at that exact position the parser's automaton doesn't have `valid_symbols[DEDENT]`
+    // true, so there's no signal to act on without guessing. Out of scope for now —
+    // put the closure last, or give it its own line, to work around it.)
+    bool at_closing_bracket_without_newline =
+        !found_end_of_line && within_brackets && valid_symbols[DEDENT] &&
+        (lexer->lookahead == ')' || lexer->lookahead == ']' || lexer->lookahead == '}');
-    if (found_end_of_line) {
+    if (at_closing_bracket_without_newline) {
+        indent_length = 0;
+    }
+    if (found_end_of_line || at_closing_bracket_without_newline) {
         if (scanner->indents.size > 0) {
             uint16_t current_indent_length = *array_back(&scanner->indents);
@@ -291,7 +317,7 @@ bool tree_sitter_plum_external_scanner_scan(void *payload, TSLexer *lexer, const
             }
         }
-        if (valid_symbols[NEWLINE] && !error_recovery_mode) {
+        if (found_end_of_line && valid_symbols[NEWLINE] && !error_recovery_mode) {
             lexer->result_symbol = NEWLINE;
             return true;
         }

tooling/tree-sitter-plum/test/corpus/function.txt CHANGED Viewed

@@ -405,3 +405,32 @@ main() -> Int =
                   body: (expression
                     (primary_expression
                       (var_identifier))))))))))))
+================================================================================
+function - multi-line closure literal call argument, closing paren on same line as body
+================================================================================
+main() -> Int =
+  each(|v|
+    v)
+--------------------------------------------------------------------------------
+(source
+  (fn
+    name: (fn_identifier)
+    returns: (return_type
+      (type_identifier))
+    body: (body
+      (expression
+        (primary_expression
+          (fn_call
+            function: (var_identifier)
+            arguments: (fn_argument_list
+              (expression
+                (closure
+                  parameters: (var_identifier)
+                  body: (body
+                    (expression
+                      (primary_expression
+                        (var_identifier)))))))))))))