accb2b1 | plum | pyrossh

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

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

accb2b1 — Peter John 2026-09-03T14:49:22+05:30

fix(plum-checker): substitute a generic method's own extra generics in its body; ship Map.map

Files changed (3) hide show

README.md +1 -1
libs/std/map.plum +20 -30
plum-checker/src/monomorphize.rs +137 -1

README.md CHANGED Viewed

@@ -390,5 +390,5 @@ Some things parse and type-check but don't compile to wasm yet — `plum-wasm-co
 - 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
 - The generic-field-type gap that used to block `libs/std`'s real `List[T]`/`Node[T]` from compiling at all (a class/enum-variant field declared with a concrete instantiation of another generic type, e.g. `Node.next: Option[Node]`) is fixed — `List[T]`'s methods (`get`/`length`/`add`/`set`/`removeAt`/`remove`/`clear`/`reverse`/`each`/`map`/`reduce`/`sort`/`join`, including its `Stringable`-bounded dispatch) are exercised directly, at their real generic type, by the `test` blocks at the bottom of [`libs/std/list.plum`](libs/std/list.plum) itself (run via `plum test libs/std/list.plum`) — not a non-generic stand-in.
-- `Map[K, V]` previously hit a *different* bug here: a top-level function whose own declared return type was a fully-concrete generic instantiation (e.g. `fun makeMap() -> Map[Str, Int] = ...`) caused monomorphization to eagerly (and incorrectly) attempt to specialize an unrelated generic type's method (`Option.filter`) at an unresolved type variable, producing a spurious `expected Option, found Option$V` type error even though `filter` was never called anywhere in the program. Root cause: `maybeRewriteReturn` (in `plum-checker/src/monomorphize.rs`) treated ANY return type merely NAMING a known generic class/enum as still-unresolved and in need of rewriting from the body's inferred tail type — even when that name already carried concrete type args (`List[Str]`, `Map[Str, Int]`), clobbering an already-correct declared return type with a stale, unmangled one inferred through tables monomorphization hadn't finished refreshing yet. Fixed by only treating a BARE reference (no `[...]` at all, e.g. `-> Box`) as needing that rewrite; a companion fix pre-resolves every ordinary (non-generic) fn/method's signature into the type tables before any body rewriting begins, so cross-file call order no longer matters. `Option.andThen`/`Result.map`/`Result.mapErr` (a single extra generic, possibly nested inside a closure's return type) are now implemented and working. `Map`'s `map` method specifically (needing TWO new generic params nested inside a closure's return type, on a class rather than an enum) remains genuinely unimplemented — a distinct pair of gaps (a generic method's body never gets its own extra generics substituted, and closure-argument inference doesn't use the callee's declared param types as a hint) documented in code and project memory
+- `Map[K, V]` previously hit a *different* bug here: a top-level function whose own declared return type was a fully-concrete generic instantiation (e.g. `fun makeMap() -> Map[Str, Int] = ...`) caused monomorphization to eagerly (and incorrectly) attempt to specialize an unrelated generic type's method (`Option.filter`) at an unresolved type variable, producing a spurious `expected Option, found Option$V` type error even though `filter` was never called anywhere in the program. Root cause: `maybeRewriteReturn` (in `plum-checker/src/monomorphize.rs`) treated ANY return type merely NAMING a known generic class/enum as still-unresolved and in need of rewriting from the body's inferred tail type — even when that name already carried concrete type args (`List[Str]`, `Map[Str, Int]`), clobbering an already-correct declared return type with a stale, unmangled one inferred through tables monomorphization hadn't finished refreshing yet. Fixed by only treating a BARE reference (no `[...]` at all, e.g. `-> Box`) as needing that rewrite; a companion fix pre-resolves every ordinary (non-generic) fn/method's signature into the type tables before any body rewriting begins, so cross-file call order no longer matters. `Option.andThen`/`Result.map`/`Result.mapErr` (a single extra generic, possibly nested inside a closure's return type) are now implemented and working. `Map.map` (needing TWO new generic params nested inside a closure's return type, on a class rather than an enum) is now implemented too, once `specializeFn` was fixed to also substitute a method's own extra generics inside its BODY (not just its params/return) — an explicit bracketed construction like `Map[X, Y](items: ...)` written directly in a method's own body previously kept the literal letters "X"/"Y" forever, silently minting bogus specializations that corrupted unrelated template compilation elsewhere in the program. A second, narrower gap remains: a closure-literal argument whose body does field access on its own param (`|p| cb(p.key, p.val)`) still can't type-check once more than one specialization of the same generic class shares that field name (e.g. both `Pair$Str$Int` and `Pair$Str$Str` declare `key`/`val`) — the checker's field-usage heuristic for inferring a closure param's class becomes ambiguous and gives up; `Map.map`'s own body sidesteps this by using a manual linked-list walk (matching `keys`/`values`/`each`'s existing style) instead of `List.map` with a field-accessing closure
 - A generic class/enum method whose return type nests that SAME class/enum inside itself (`List[T].chunk(self) -> List[List[T]]`) used to stack-overflow the compiler for every program merely importing the class, whether or not anything called the method — fixed; `List.chunk`/`List.partition` now ship and work as a working example of the pattern (build any inner `List[T]` value via an EXISTING ordinary method, e.g. `self.sublist(...)`, never a second bare `List(...)` construction in the same body, which is ambiguous with the method's own return-type fallback)

libs/std/map.plum CHANGED Viewed

@@ -138,36 +138,17 @@ type Map[K, V] =
           break
     return result
-  # `map` is left unimplemented — two DISTINCT compiler gaps were found
+  fun map(self, cb: fn(K, V) -> Pair[X, Y]) -> Map[X, Y] =
-  # while attempting it (2026-09-02), both real and both deeper than this
+    result := Map[X, Y](items: List[Pair[X, Y]](head: None, tail: None, size: 0))
+    current := self.items.head
+    while current != None
+      match current
+        Some(node) =>
+          result.items.add(cb(node.value.key, node.value.val))
+          current = node.next
-  # one method:
+        None =>
-  #
+          break
-  # 1. A generic method's BODY is never substituted for its OWN extra
-  #    generics — `specializeFn` only substitutes PARAM/RETURN types,
-  #    cloning the body as-is. An explicit `Map[X, Y](items: List[Pair[X,
-  #    Y]](...))` construction written directly in `map`'s body therefore
-  #    keeps the LITERAL letters "X"/"Y" forever, which `resolveFieldType`
-  #    then treats as if they were real concrete type names — silently
-  #    manufacturing bogus `List$X`/`Pair$X`-style "specializations" that
-  #    corrupt unrelated `List`/`Node` template compilation elsewhere in the
-  #    SAME program (confirmed: broke `List.add`/`sort`/`find`/etc, none of
-  #    which `map` even touches). Worked around by building the result via
-  #    `self.items.map(...)` (whose own extra-generic resolution IS
-  #    per-call-site, not body-substitution-dependent) plus a BARE `Map(items:
-  #    ...)` construction relying on `current_return_type`, matching
-  #    `keys`/`values` above — this part alone got further than before.
-  # 2. Once past that, `self.items.map(|p| cb(p.key, p.val))` still fails:
-  #    `plum-checker/src/lib.rs`'s `inferExpr` never propagates a method
-  #    CALL's own declared param types down as an "expected type" hint when
-  #    inferring a closure-literal ARGUMENT — it only guesses a closure
-  #    param's type from field-ACCESS patterns within the closure's own body
-  #    (`resolveClosureParamFromFieldUsage`), which can't know `p`'s class is
-  #    `Pair` at all here. Fixing this needs threading an expected `PlumType`
-  #    through `inferExpr`'s closure-literal handling at (at least) 8 call
-  #    sites in `lib.rs` — a materially bigger, riskier change than
-  #    warranted for this one method; not attempted.
-  fun map(self) =
+    return result
-    todo
 fun makeStrIntMapForTest() -> Map[Str, Int] =
   return Map[Str, Int](items: List[Pair[Str, Int]](head: None, tail: None, size: 0))
@@ -218,3 +199,12 @@ test "each calls the callback with every key and value"
   seen.clear()
   m.each(|k, v| seen.add(v))
   expect seen.join(",") == "1,2"
+test "map transforms every key/value pair into a new map, changing the value type"
+  m := makeStrIntMapForTest()
+  m.set("a", 1)
+  m.set("b", 2)
+  stringified := m.map(|k, v| Pair(key: k, val: v.toStr()))
+  expect stringified.get("a").unwrap() == "1"
+  expect stringified.get("b").unwrap() == "2"
+  expect stringified.length() == 2

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -213,7 +213,143 @@ pub fn specializeFn(f: &ast::Fn, subst: &Substitution, mangled_name: &str, new_t
             default: p.default.clone(),
         }).collect(),
         returns: f.returns.as_ref().map(|r| substituteType(r, subst)),
+        body: {
-        body: f.body.clone(),
+            let mut body = f.body.clone();
+            match &mut body {
+                ast::FnBody::Block(b) => substituteTypesInBlock(b, subst),
+                ast::FnBody::Expr(e) => substituteTypesInExpr(e, subst),
+                ast::FnBody::Extern => {}
+            }
+            body
+        },
+    }
+}
+/// Rewrites every explicit generic-type-argument annotation reachable inside
+/// `block` (currently only `ClassCall.generics`, e.g. the `[X, Y]` in
+/// `Map[X, Y](...)`) through `subst` — the SAME substitution `specializeFn`
+/// already applies to a method's own params/return, just extended to its
+/// BODY. Without this, a method with its own extra generic param(s) (beyond
+/// its receiver's) that writes an explicit bracketed construction using one
+/// of those letters keeps the literal, un-substituted letter ("X") after
+/// specialization: `resolveClassInstantiation` then treats "X" as a real
+/// (nonexistent) class name, silently minting bogus `List$X`/`Pair$X`
+/// "specializations" that corrupt unrelated template compilation. See the
+/// `plum_map_map_gaps_2026_09` memory (gap 1) for the discovery writeup.
+fn substituteTypesInBlock(block: &mut ast::Block, subst: &Substitution) {
+    for stmt in &mut block.stmts {
+        substituteTypesInStmt(stmt, subst);
+    }
+}
+fn substituteTypesInStmt(stmt: &mut ast::Stmt, subst: &Substitution) {
+    match stmt {
+        ast::Stmt::Assign(a) => {
+            for v in &mut a.values {
+                substituteTypesInExpr(v, subst);
+            }
+            for t in &mut a.targets {
+                if let ast::AssignTarget::Field(obj, _) = t {
+                    substituteTypesInExpr(obj, subst);
+                }
+            }
+        }
+        ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
+        ast::Stmt::Assert(e) | ast::Stmt::Expect(e) => substituteTypesInExpr(e, subst),
+        ast::Stmt::For(f) => {
+            substituteTypesInExpr(&mut f.iter, subst);
+            substituteTypesInBlock(&mut f.body, subst);
+        }
+        ast::Stmt::While(w) => {
+            substituteTypesInExpr(&mut w.condition, subst);
+            substituteTypesInBlock(&mut w.body, subst);
+        }
+        ast::Stmt::If(i) => {
+            substituteTypesInExpr(&mut i.condition, subst);
+            substituteTypesInBlock(&mut i.body, subst);
+            for ei in &mut i.else_ifs {
+                substituteTypesInExpr(&mut ei.condition, subst);
+                substituteTypesInBlock(&mut ei.body, subst);
+            }
+            if let Some(e) = &mut i.else_ {
+                substituteTypesInBlock(e, subst);
+            }
+        }
+        ast::Stmt::Match(m) => {
+            for s in &mut m.subjects {
+                substituteTypesInExpr(s, subst);
+            }
+            for c in &mut m.cases {
+                substituteTypesInBlock(&mut c.body, subst);
+            }
+        }
+        ast::Stmt::Return(Some(e)) => substituteTypesInExpr(e, subst),
+        ast::Stmt::Return(None) => {}
+        ast::Stmt::Expr(e) => substituteTypesInExpr(e, subst),
+    }
+}
+fn substituteTypesInArg(arg: &mut ast::Arg, subst: &Substitution) {
+    match arg {
+        ast::Arg::Positional(e) => substituteTypesInExpr(e, subst),
+        ast::Arg::Keyword { value, .. } => substituteTypesInExpr(value, subst),
+        ast::Arg::Pair { value, .. } => substituteTypesInExpr(value, subst),
+    }
+}
+fn substituteTypesInExpr(expr: &mut ast::Expr, subst: &Substitution) {
+    match expr {
+        ast::Expr::Binary(b) => {
+            substituteTypesInExpr(&mut b.left, subst);
+            substituteTypesInExpr(&mut b.right, subst);
+        }
+        ast::Expr::Unary(u) => substituteTypesInExpr(&mut u.operand, subst),
+        ast::Expr::Bool(b) => {
+            substituteTypesInExpr(&mut b.left, subst);
+            substituteTypesInExpr(&mut b.right, subst);
+        }
+        ast::Expr::Not(inner) => substituteTypesInExpr(inner, subst),
+        ast::Expr::Compare(c) => {
+            substituteTypesInExpr(&mut c.left, subst);
+            substituteTypesInExpr(&mut c.right, subst);
+        }
+        ast::Expr::Ternary(t) => {
+            substituteTypesInExpr(&mut t.condition, subst);
+            substituteTypesInExpr(&mut t.then, subst);
+            substituteTypesInExpr(&mut t.else_, subst);
+        }
+        ast::Expr::FnCall(call) => {
+            for arg in &mut call.args {
+                substituteTypesInArg(arg, subst);
+            }
+        }
+        ast::Expr::ClassCall(call) => {
+            for g in &mut call.generics {
+                *g = substituteType(g, subst);
+            }
+            for fa in &mut call.fields {
+                substituteTypesInExpr(&mut fa.value, subst);
+            }
+        }
+        ast::Expr::Attribute(attr) => {
+            substituteTypesInExpr(&mut attr.object, subst);
+            if let ast::AttrKind::Method(call) = &mut attr.attr {
+                for arg in &mut call.args {
+                    substituteTypesInArg(arg, subst);
+                }
+            }
+        }
+        ast::Expr::Paren(inner) => substituteTypesInExpr(inner, subst),
+        ast::Expr::String(s) => {
+            for part in &mut s.parts {
+                if let ast::StringPart::Interp(e) = part {
+                    substituteTypesInExpr(e, subst);
+                }
+            }
+        }
+        ast::Expr::Closure(cl) => substituteTypesInBlock(&mut cl.body, subst),
+        ast::Expr::Int(_) | ast::Expr::Float(_)
+        | ast::Expr::Self_ | ast::Expr::Var(_) | ast::Expr::TypeName(_) => {}
     }
 }