2e28ecc | plum

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

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

2e28ecc — Peter John 2026-07-20T16:22:48+05:30

test+docs: generics monomorphization complete; extend examples, update known gaps

Files changed (5) hide show

README.md +2 -2
examples/functions.plum +6 -0
examples/types.plum +6 -0
plum-checker/tests/checker_tests.rs +27 -0
plum-wasm-codegen/tests/codegen_tests.rs +92 -0

README.md CHANGED Viewed

@@ -240,7 +240,7 @@ wrap(value: a) -> Bool =      # generic param type
   True
 ```
-Generic **arguments** (instantiating a generic type) accept either bracket or paren syntax: `List[Int]` and `List(Int)` both parse. There's no monomorphization/codegen for user-defined generics yet — they type-check permissively but don't compile to wasm.
+Generic **arguments** (instantiating a generic type) accept either bracket or paren syntax: `List[Int]` and `List(Int)` both parse. User-defined generics (classes, their methods, free functions, and enums) are monomorphized: each concrete-type-argument combination actually used in the program gets its own specialized, fully-concrete copy, which then type-checks and compiles to wasm through the normal, unmodified pipeline. See `useWrap`/`usePair` in [`examples/functions.plum`](examples/functions.plum) and `makeIntBox`/`makeStrBox` in [`examples/types.plum`](examples/types.plum) for real instantiation sites. One documented limitation: a generic *enum* may only be instantiated at one concrete type per program (instantiating the same generic enum at two different concrete types produces a clear `monomorphize:`-prefixed error, since the runtime's enum-variant table is keyed by bare variant name).
 Full example: [`examples/types.plum`](examples/types.plum), [`examples/functions.plum`](examples/functions.plum).
@@ -322,7 +322,7 @@ Some things parse and type-check but don't compile to wasm yet — `plum-wasm-co
 - string interpolation (plain, non-interpolated string literals do compile)
 - multi-subject `match` (`match a, b`)
-- user-defined generics (they type-check but aren't monomorphized) — this also blocks `libs/std`'s actual `Option`/`Result`/`List`/`Map`, which are declared generically
 - 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 (closures, `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
 `closure` (`|params| body`) exists in `grammar.js` but isn't wired into any reachable rule yet, so it doesn't actually parse in context.

examples/functions.plum CHANGED Viewed

@@ -15,3 +15,9 @@ wrap(value: a) -> Bool =
 pair(first: a, second: b) -> Bool =
   True
+useWrap() -> Bool =
+  wrap(5)
+usePair() -> Bool =
+  pair(1, "x")

examples/types.plum CHANGED Viewed

@@ -23,3 +23,9 @@ enum Color =
 enum Option =
   | Some(Int)
   | None
+makeIntBox() -> Box =
+  Box(value: 5)
+makeStrBox() -> Box =
+  Box(value: "x")

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -482,3 +482,30 @@ use() -> Int =
     let result = check_source(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
+#[test]
+fn unbounded_recursive_generic_instantiation_is_a_clear_error() {
+    // `recurse` re-wraps its argument in a `Box` on every recursive call, so each
+    // specialization's own body demands a specialization of `recurse` at a STRICTLY
+    // bigger type (`recurse$Int`, then `recurse$Box$Int`, then `recurse$Box$Box$Int`,
+    // ...), forever. This genuinely grows the worklist without bound (unlike a
+    // generic class field merely NAMING a recursive generic type in its own
+    // declaration, which is never itself a call site and so never reaches the
+    // worklist at all) and must fail with a clear, bounded error rather than hang.
+    let src = "\
+type Box(a) =
+  value: a
+recurse(v: a) -> Int =
+  b = Box(value: v)
+  recurse(b)
+use() -> Int =
+  recurse(5)
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs[0].message.contains("monomorphize"), "got: {:?}", errs);
+}

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

@@ -684,3 +684,95 @@ bad(n: Int) -> Int =
     let err = compile_source(&source).expect_err("a match arm ending in a non-value statement must be a clear error, not invalid wasm");
     assert!(err.contains("doesn't produce a return value"), "got: {}", err);
 }
+#[test]
+fn generic_class_specialized_at_two_types_does_not_alias() {
+    let src = "\
+type Box(a) =
+  value: a
+getIntValue<Box>() -> Int =
+  self.value
+useInt() -> Int =
+  b = Box(value: 7)
+  b.getIntValue()
+main() -> Int =
+  useInt()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn generic_function_called_at_multiple_concrete_types_runs_correctly() {
+    let src = "\
+identity(value: a) -> a =
+  value
+main() -> Int =
+  identity(5) + identity(37)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}
+#[test]
+fn generic_method_on_generic_class_runs_correctly() {
+    let src = "\
+type Box(a) =
+  value: a
+getValue<Box>() -> Int =
+  self.value
+main() -> Int =
+  b = Box(value: 9)
+  b.getValue()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 9);
+}
+#[test]
+fn transitively_generic_call_chain_runs_correctly() {
+    let src = "\
+identity(value: a) -> a =
+  value
+doubled(value: a) -> Int =
+  identity(value) + identity(value)
+main() -> Int =
+  doubled(21)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}
+#[test]
+fn generic_enum_specialized_and_matched_runs_correctly() {
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+unwrapOr(o: Option, default: Int) -> Int =
+  match o
+    Some(v) =>
+      v
+    None =>
+      default
+main() -> Int =
+  unwrapOr(Some(13), 0)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 13);
+}