ad8b044 | plum | pyrossh

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

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

ad8b044 — Peter John 2026-10-26T12:13:42+05:30

feat: duck-typed operators; README for Zig-style generics; results

Files changed (7) hide show

README.md +54 -3
docs/plans/2026-10-26-zig-generics-and-numbers.md +21 -0
plum-checker/src/lib.rs +100 -1
plum-checker/tests/checker_tests.rs +12 -0
plum-examples/generics.plum +14 -0
plum-examples/operators.plum +68 -0
plum-wasm-codegen/src/lib.rs +33 -0

README.md CHANGED Viewed

@@ -127,6 +127,32 @@ negated = -sum
 inverted = !cmp
 ```
+### Operators on your own types
+On `Int`, `Float`, `Byte` and `Str` operators are built in. On any other (declared) type, an operator calls a method on the left operand, resolved statically per instantiation:
+| Operator | Method |
+|---|---|
+| `a + b`, `a - b`, `a * b`, `a / b` | `a.add(b)`, `sub`, `mul`, `div` |
+| `-a` | `a.neg()` |
+| `a == b`, `a != b` | `a.eq(b)`, `!a.eq(b)` |
+| `a < b`, `a <= b`, `a > b`, `a >= b` | `a.lt(b)`, `a.le(b)`, `a.gt(b)`, `a.ge(b)` |
+Each operator needs its own method (no derivation from `lt`/`eq`). The right operand may have a different type: `v * 2.0` calls `mul(self, s: Float)`. Using an operator without the method is an error such as `Vec2 has no operator '+' (define add)`, with the instantiation chain when it happens inside a generic. `==`/`!=` on a type with no `eq` keep their built-in meaning (variant identity), and tag-union `==` is unchanged.
+```plum
+enum Vec2 =
+  | Vec2(x: Float, y: Float)
+  fun add(self, o: Vec2) -> Vec2 =
+    Vec2(x: self.x + o.x, y: self.y + o.y)
+  fun mul(self, s: Float) -> Vec2 =
+    Vec2(x: self.x * s, y: self.y * s)
+```
+See [`plum-examples/operators.plum`](plum-examples/operators.plum).
 ## Variables and assignment
 ```plum
@@ -241,9 +267,34 @@ Generic types, methods, and free functions are duck-typed and compiled once per
 ### How generics compile
-Generics are duck-typed, as in Zig. A generic body is type-checked once per concrete instantiation, and each instantiation gets its own compiled copy with unboxed values. `List[Int]` and `List[Str]` are different code.
+Generics are duck-typed and compiled per type, as in Zig. A generic body is type-checked once per concrete instantiation, and each instantiation gets its own compiled copy with unboxed values: `List[Int]` and `List[Str]` are different code, and a `List[Float]` stores raw `f64`s.
+- **No bounds, no traits.** `[T]` carries no constraint. `fun show(x: T) -> Str = x.toStr()` works for every type that has a `toStr` method and fails at the use site otherwise. The old `trait`/`implements` syntax and `[T: X]` bounds are a parse error with a migration hint.
+- **Errors point at the use site.** A missing method is reported against the concrete type, with the chain of instantiations that led there:
+```
+in outer[Plain] (called at main.plum:9:3):
+  in maxOf[Plain] (called at main.plum:5:3):
+    Plain has no method 'lt'
+```
+- **Unreachable generics are not emitted.** A generic that no root (a non-generic fn or a test) reaches is neither checked per type nor compiled.
+- **Typed arrays are native.** Each instantiation stores its elements in an array of its own element type, with no boxing at generic edges.
+- **Explicit "trait values".** When a generic needs behavior that is not a method on `T`, pass it explicitly, like a Zig comptime parameter or a Haskell dictionary:
+```plum
+fun sumWith(xs: List[T], zero: T, add: fn(T, T) -> T) -> T =
+  acc := zero
+  for i := range xs.length()
+    acc = add(acc, xs.get(i) ?? zero)
+  acc
+sumWith(List(1, 2, 3), 0, |a, b| a + b)       # 6
+sumWith(List("a", "b"), "", |a, b| a + b)     # "ab"
+```
+  See `num_record_passed_explicitly` in [`plum-examples/generics.plum`](plum-examples/generics.plum). (Enum fields cannot hold `fn` types yet, so the "record of functions" is passed as separate arguments.)
-- **No bounds, no traits.** `[T]` carries no constraint. `fun show(x: T) -> Str = x.toStr()` works for every type that has a `toStr` method and fails at the call site otherwise. The old `trait` and `implements` syntax and `[T: X]` bounds were removed and now give a parse error with a migration hint.
 - **Mixed types are enums.** To hold several kinds of value in one list, declare an enum and `match self`:
 ```plum
@@ -350,7 +401,7 @@ fun greet(name: Str) -> Str =
 extern fun printLn(s: Str)
 ```
-`extern fun` declares a function backed by a host-provided wasm import, with no Plum body. `plum-std/Os.plum` declares `printLn` for use via `import std/os`.
+`extern fun` declares a function backed by a host-provided wasm import, with no Plum body. At the boundary `Int` is narrowed to a wasm `i32` (the rest of the language uses 64-bit `Int`), so extern parameters and results are 32-bit. `plum-std/Os.plum` declares `printLn` for use via `import std/os`.
 ```sh
 $ plum run plum-examples/io.plum

docs/plans/2026-10-26-zig-generics-and-numbers.md CHANGED Viewed

@@ -128,3 +128,24 @@ Migrate every example, test and README snippet off traits. Update the README sec
 ## Open questions
 - Will the user's further ideas change scope or order? This is still a draft.
+## Results
+T5 (duck-typed operators) and T6 (docs) are done. `a + b`, `-a`, `==` and `<` on a non-primitive left operand now call `add`, `neg`, `eq` and `lt`. Each of `sub mul div le gt ge` is its own method with no derivation from `lt`/`eq`, and the right operand may have a different type. A missing method is `<Type> has no operator '+' (define add)`, with the instantiation chain inside generics. `==`/`!=` on a type with no `eq` keep their built-in meaning, because existing code compares enum variants that way. Tag-union `==` is unchanged.
+Tests: `cargo test --workspace` has 0 failures and `plum test plum-std plum-examples` ran 2321 passed, 0 failed (baseline 2252). New tests are in `plum-examples/operators.plum` (`vec2_add_operator`, `mul_scalar_rhs`, `neg`, `eq_and_neq`, `lt_ordering`), the checker test `operator_missing_method_error`, and `num_record_passed_explicitly` in `generics.plum`. `sumWith` takes `zero` and `add` as separate arguments, because enum fields cannot hold `fn` types yet.
+Compile time (release bench, best of 5, from the repo root, over `plum-examples/*.plum` and `plum-std/*.plum`; load + check + codegen):
+| | typical | max | wasm size |
+|---|---|---|---|
+| per-type copies (now) | 31-37 ms | 53.0 ms (`dop_visitor`; `oop_visitor` 52.4, `Os` 50.8) | 28.8-42.1 KB (typical about 29-30 KB) |
+| erased baseline | 20-25 ms | not recorded | Bool.wasm 19 KB |
+So compile time is about 1.4x the erased baseline and the smallest wasm is about 1.5x larger. Part of that is the always-loaded std prelude: even a near-empty file costs 31 ms and 28.8 KB, and the examples add only 0-20 ms on top of that.
+LOC since b7a5ee8 (excluding generated parser files): 62 files changed, 2509 insertions(+), 2721 deletions(-). That is 212 fewer lines, even with the per-instantiation machinery added.
+Known gaps:
+- A closure that calls an `fn`-typed parameter fails with `unknown function`; this was found while writing `sumWith`.
+- An enum field cannot have an `fn` type.

plum-checker/src/lib.rs CHANGED Viewed

@@ -31,6 +31,9 @@ thread_local! {
     /// generic arguments are pinned like a directly-returned expression's.
     static TAIL: RefCell<Option<PlumType>> = const { RefCell::new(None) };
     static MATCH_TAIL: RefCell<Option<PlumType>> = const { RefCell::new(None) };
+    /// Operator expressions (address) on non-primitive operands -> the synthetic method call
+    /// (`a + b` -> `a.add(b)`) they resolve to. Kept so the cloned arguments have stable addresses.
+    static OP_CALLS: RefCell<HashMap<usize, std::rc::Rc<ast::FnCall>>> = RefCell::new(HashMap::new());
 }
 /// A call to a generic fn/method seen in some body: callee identity plus the
@@ -100,6 +103,9 @@ pub struct TypedInfo {
     /// the instantiation it calls. `implicit` marks calls codegen makes itself (the
     /// `toStr` of a `"{x}"` interpolation, keyed by the interpolated expression).
     pub call_inst: HashMap<(Option<usize>, usize, bool), usize>,
+    /// Operator expression address -> the method call it desugars to (`a + b` -> `a.add(b)`;
+    /// the receiver is the operator's own left operand, `args` holds the right one).
+    pub op_calls: HashMap<usize, std::rc::Rc<ast::FnCall>>,
 }
 /// One reached instantiation of a generic fn or method of a generic type.
@@ -1003,7 +1009,9 @@ fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     RECORD.with(|r| *r.borrow_mut() = Some(HashMap::new()));
     RECORD_BINDS.with(|r| *r.borrow_mut() = Some(Binds::new()));
     CALLS.with(|r| *r.borrow_mut() = Some(Vec::new()));
+    OP_CALLS.with(|r| r.borrow_mut().clear());
     let (result, mut info) = checkSourceInner(source);
+    info.op_calls = OP_CALLS.with(|r| std::mem::take(&mut *r.borrow_mut()));
     let mut recorded = RECORD.with(|r| r.borrow_mut().take()).unwrap_or_default();
     let binds = RECORD_BINDS.with(|r| r.borrow_mut().take()).unwrap_or_default();
     CALLS.with(|r| r.borrow_mut().take());
@@ -2866,6 +2874,46 @@ fn expectedTagLiteral(
     }
 }
+/// True for an operand whose operators are user methods (`add`, `eq`, ...): a
+/// declared class/enum, not a primitive, `Str`, `Bool` or tag union.
+pub fn isOperatorOperand(t: &PlumType) -> bool {
+    matches!(t, PlumType::TNamed(n) | PlumType::TApp(n, _) if n != "Str" && n != "Int" && n != "Float" && n != "Bool" && n != "Byte")
+}
+/// Resolves operator `sym` on a non-primitive left operand to `left.method(right)`,
+/// recording the synthetic call (see `TypedInfo::op_calls`) and its instantiation.
+#[allow(clippy::too_many_arguments)]
+fn inferOperatorCall(
+    expr: &ast::Expr,
+    lt: &PlumType,
+    sym: &str,
+    method: &str,
+    right: Option<&ast::Expr>,
+    env: &TypeEnv,
+    ctx: &CheckCtx,
+    expected: Option<&PlumType>,
+) -> Result<PlumType, String> {
+    let class = methodReceiverName(lt).unwrap_or_default();
+    if !ctx.methods.contains_key(&(class, method.to_string())) {
+        return Err(format!("{} has no operator '{}' (define {})", lt, sym, method));
+    }
+    let addr = expr as *const ast::Expr as usize;
+    let call = OP_CALLS.with(|m| {
+        m.borrow_mut()
+            .entry(addr)
+            .or_insert_with(|| {
+                std::rc::Rc::new(ast::FnCall {
+                    name: method.to_string(),
+                    args: right.iter().map(|r| ast::Arg::Positional((*r).clone())).collect(),
+                    line: 0,
+                    column: 0,
+                })
+            })
+            .clone()
+    });
+    inferMethodCall(lt, method, &call.args, env, ctx, expected)
+}
 pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<PlumType, String> {
     inferExprWith(expr, env, ctx, None)
 }
@@ -3091,10 +3139,38 @@ fn inferExprInner(
             unify(&PlumType::TBool, &t, ctx)?;
             Ok(PlumType::TBool)
         }
+        ast::Expr::Unary(u) => {
-        ast::Expr::Unary(u) => inferExpr(&u.operand, env, ctx),
+            let t = inferExpr(&u.operand, env, ctx)?;
+            if matches!(u.op, ast::UnOp::Neg) {
+                if matches!(t, PlumType::TParam(_)) {
+                    return Ok(PlumType::TVar("_".to_string()));
+                }
+                if isOperatorOperand(&t) {
+                    return inferOperatorCall(expr, &t, "-", "neg", None, env, ctx, expected);
+                }
+            }
+            Ok(t)
+        }
         ast::Expr::Binary(b) => {
             let lt = inferExpr(&b.left, env, ctx)?;
             let rt = inferExpr(&b.right, env, ctx)?;
+            let opn = match b.op {
+                ast::BinOp::Add => Some(("+", "add")),
+                ast::BinOp::Sub => Some(("-", "sub")),
+                ast::BinOp::Mul => Some(("*", "mul")),
+                ast::BinOp::Div => Some(("/", "div")),
+                _ => None,
+            };
+            if let Some((sym, method)) = opn {
+                if matches!(lt, PlumType::TParam(_)) && lt != rt {
+                    return Ok(PlumType::TVar("_".to_string()));
+                }
+                if isOperatorOperand(&lt) {
+                    return inferOperatorCall(
+                        expr, &lt, sym, method, Some(&b.right), env, ctx, expected,
+                    );
+                }
+            }
             unify(&lt, &rt, ctx).map_err(|e| format!("binary op: {}", e))?;
             bindAcross(&lt, &rt);
             if matches!(lt, PlumType::TVar(_)) && !matches!(rt, PlumType::TVar(_)) {
@@ -3122,6 +3198,29 @@ fn inferExprInner(
                 }
                 return Ok(PlumType::TBool);
             }
+            let opn = match c.op {
+                ast::CmpOp::Eq => Some(("==", "eq")),
+                ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Some(("!=", "eq")),
+                ast::CmpOp::Lt => Some(("<", "lt")),
+                ast::CmpOp::Lte => Some(("<=", "le")),
+                ast::CmpOp::Gt => Some((">", "gt")),
+                ast::CmpOp::Gte => Some((">=", "ge")),
+            };
+            if let Some((sym, method)) = opn {
+                if matches!(lt, PlumType::TParam(_)) && lt != rt {
+                    return Ok(PlumType::TBool);
+                }
+                // `==`/`!=` keep their built-in meaning (variant/reference identity) on a
+                // type that defines no `eq`; the ordering operators have no fallback.
+                let has_eq = methodReceiverName(&lt)
+                    .is_some_and(|cl| ctx.methods.contains_key(&(cl, "eq".to_string())));
+                if isOperatorOperand(&lt) && (method != "eq" || has_eq) {
+                    let r = inferOperatorCall(expr, &lt, sym, method, Some(&c.right), env, ctx, None)?;
+                    unify(&PlumType::TBool, &r, ctx)
+                        .map_err(|e| format!("operator '{}' ({}) must return Bool: {}", sym, method, e))?;
+                    return Ok(PlumType::TBool);
+                }
+            }
             unify(&lt, &rt, ctx).map_err(|e| format!("compare op: {}", e))?;
             bindAcross(&lt, &rt);
             Ok(PlumType::TBool)

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1889,6 +1889,18 @@ fn nested_instantiation_chain() {
     assert!(msg.contains("Plain has no method 'lt'"), "{}", msg);
 }
+#[test]
+fn operator_missing_method_error() {
+    let src = format!(
+        "{}fun twice(a: T) -> T =\n  a + a\n\nfun main() -> Plain =\n  twice(Plain(v: 1))\n",
+        DUCK_DEFS
+    );
+    let msg = errText(checkSource(&parseClean(&src)));
+    assert!(msg.contains("in twice[Plain]"), "{}", msg);
+    assert!(msg.contains("called at"), "{}", msg);
+    assert!(msg.contains("Plain has no operator '+' (define add)"), "{}", msg);
+}
 #[test]
 fn instantiation_set_listed() {
     let src = format!(

plum-examples/generics.plum CHANGED Viewed

@@ -68,6 +68,15 @@ fun nameOf(s: T) -> Str =
 # --- numeric -------------------------------------------------------------
+# "Trait values": there are no traits, so the behavior a generic needs is passed
+# explicitly (here the "Num dictionary" `add` + `zero` as two arguments; enum
+# fields cannot hold `fn` types yet, so it is not bundled into a record).
+fun sumWith(xs: List[T], zero: T, add: fn(T, T) -> T) -> T =
+  acc := zero
+  for i := range xs.length()
+    acc = add(acc, xs.get(i) ?? zero)
+  acc
 test "Int extremes survive a generic fn"
   big := 9223372036854775807
   small := 0 - 9223372036854775807 - 1
@@ -209,3 +218,8 @@ test "== on T works for Int and Str"
   assert !same("a", "b")
   assert same(9007199254740993, 9007199254740993)
   assert !same(9007199254740993, 9007199254740992)
+test "num_record_passed_explicitly"
+  assert sumWith(List(1, 2, 3), 0, |a, b| a + b) == 6
+  assert sumWith(List("a", "b"), "", |a, b| a + b) == "ab"
+  assert sumWith(List(1.5, 2.5), 0.0, |a, b| a + b) == 4.0

plum-examples/operators.plum ADDED Viewed

@@ -0,0 +1,68 @@
+module operators
+import std/Str
+import std/Number
+# Operators on non-primitive operands call methods: `a + b` is `a.add(b)`,
+# `-a` is `a.neg()`, `a == b` is `a.eq(b)`, `a < b` is `a.lt(b)`.
+enum Vec2 =
+  | Vec2(x: Float, y: Float)
+  fun toStr(self) -> Str =
+    "Vec2({self.x}, {self.y})"
+  fun add(self, o: Vec2) -> Vec2 =
+    Vec2(x: self.x + o.x, y: self.y + o.y)
+  fun mul(self, s: Float) -> Vec2 =
+    Vec2(x: self.x * s, y: self.y * s)
+  fun neg(self) -> Vec2 =
+    Vec2(x: 0.0 - self.x, y: 0.0 - self.y)
+  fun eq(self, o: Vec2) -> Bool =
+    self.x == o.x && self.y == o.y
+  fun lt(self, o: Vec2) -> Bool =
+    self.x < o.x
+  fun le(self, o: Vec2) -> Bool =
+    self.x <= o.x
+enum Plain =
+  | Plain(v: Int)
+fun double(a: T) -> T =
+  a + a
+test "vec2_add_operator"
+  r := Vec2(x: 1.0, y: 2.0) + Vec2(x: 3.0, y: 4.0)
+  assert r.x == 4.0
+  assert r.y == 6.0
+test "mul_scalar_rhs"
+  r := Vec2(x: 1.0, y: 2.0) * 2.0
+  assert r.x == 2.0
+  assert r.y == 4.0
+test "neg"
+  r := -Vec2(x: 1.0, y: -2.0)
+  assert r.x == -1.0
+  assert r.y == 2.0
+test "eq_and_neq"
+  a := Vec2(x: 1.0, y: 2.0)
+  assert a == Vec2(x: 1.0, y: 2.0)
+  assert a != Vec2(x: 1.0, y: 3.0)
+  assert !{a == Vec2(x: 0.0, y: 0.0)}
+test "lt_ordering"
+  a := Vec2(x: 1.0, y: 0.0)
+  b := Vec2(x: 2.0, y: 0.0)
+  assert a < b
+  assert !{b < a}
+  assert a <= b
+test "operators work through a generic"
+  d := double(Vec2(x: 1.0, y: 1.0))
+  assert d.x == 2.0
+  assert double(4) == 8

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

@@ -379,6 +379,8 @@ pub struct CompileCtx<'a> {
     pub inst_funcs: HashMap<usize, (u32, FuncSig)>,
     /// See `plum_checker::TypedInfo::call_inst`.
     pub call_inst: HashMap<(Option<usize>, usize, bool), usize>,
+    /// See `plum_checker::TypedInfo::op_calls`.
+    pub op_calls: HashMap<usize, std::rc::Rc<ast::FnCall>>,
     /// Every free (non-method) fn name, generic or not.
     pub known_fns: HashSet<String>,
     pub eg: EnumGenerics,
@@ -450,6 +452,7 @@ struct LocalCtx<'a> {
     func_sigs: &'a HashMap<String, FuncSig>,
     inst_funcs: &'a HashMap<usize, (u32, FuncSig)>,
     call_inst: &'a HashMap<(Option<usize>, usize, bool), usize>,
+    op_calls: &'a HashMap<usize, std::rc::Rc<ast::FnCall>>,
     known_fns: &'a HashSet<String>,
     /// Index of the unit being compiled (closures are keyed by it) and its instantiation.
     unit_idx: usize,
@@ -1641,6 +1644,7 @@ fn compileSourceInner(
         instantiations,
         inst_expr_types,
         call_inst,
+        op_calls,
         ..
     } = typed;
     // Per-instantiation expression types, split out by instantiation id.
@@ -2157,6 +2161,7 @@ fn compileSourceInner(
         func_sigs,
         inst_funcs,
         call_inst,
+        op_calls,
         known_fns,
         eg,
         methods,
@@ -3807,6 +3812,7 @@ fn compileFnBody(
         func_sigs: &ctx.func_sigs,
         inst_funcs: &ctx.inst_funcs,
         call_inst: &ctx.call_inst,
+        op_calls: &ctx.op_calls,
         known_fns: &ctx.known_fns,
         unit_idx: unit.idx,
         unit_inst: unit.inst,
@@ -5498,6 +5504,14 @@ fn plumTypeFromValtypeHint(vt: ValType) -> PlumType {
     }
 }
+/// An operator on a non-primitive operand compiled as its desugared method call. The
+/// checker's `op_calls` entry is shared by every instantiation of a generic body, so
+/// the operand's type in THIS unit decides.
+fn isOpCall(expr: &ast::Expr, operand: &ast::Expr, ctx: &LocalCtx) -> bool {
+    ctx.op_calls.contains_key(&(expr as *const ast::Expr as usize))
+        && plum_checker::isOperatorOperand(&inferLocalType(operand, ctx))
+}
 fn compileExpr(
     expr: &ast::Expr,
     body: &mut Vec<u8>,
@@ -5695,6 +5709,24 @@ fn compileExpr(
             }
             Instruction::End.encode(body);
         }
+        ast::Expr::Unary(u) if isOpCall(expr, &u.operand, ctx) => {
+            let call = &ctx.op_calls[&(expr as *const ast::Expr as usize)];
+            let ty = inferLocalType(&u.operand, ctx);
+            compileMethodCall(&u.operand, call, &ty, expr, false, body, ctx, state)?;
+        }
+        ast::Expr::Binary(b) if isOpCall(expr, &b.left, ctx) => {
+            let call = &ctx.op_calls[&(expr as *const ast::Expr as usize)];
+            let ty = inferLocalType(&b.left, ctx);
+            compileMethodCall(&b.left, call, &ty, expr, false, body, ctx, state)?;
+        }
+        ast::Expr::Compare(c) if isOpCall(expr, &c.left, ctx) => {
+            let call = &ctx.op_calls[&(expr as *const ast::Expr as usize)];
+            let ty = inferLocalType(&c.left, ctx);
+            compileMethodCall(&c.left, call, &ty, expr, false, body, ctx, state)?;
+            if matches!(c.op, ast::CmpOp::Neq | ast::CmpOp::NotEq2) {
+                Instruction::I32Eqz.encode(body);
+            }
+        }
         ast::Expr::Unary(u) => match u.op {
             ast::UnOp::Neg => {
                 if matches!(inferLocalType(&u.operand, ctx), PlumType::TFloat) {
@@ -6885,6 +6917,7 @@ fn compileClosureBody(
         func_sigs: &ctx.func_sigs,
         inst_funcs: &ctx.inst_funcs,
         call_inst: &ctx.call_inst,
+        op_calls: &ctx.op_calls,
         known_fns: &ctx.known_fns,
         unit_idx: unit.idx,
         unit_inst: unit.inst,