b952f81 | plum | pyrossh

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

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

b952f81 — Peter John 2026-10-26T13:41:57+05:30

feat: fn-typed enum fields (record of functions); closures capture called fn params

Files changed (4) hide show

README.md +10 -8
plum-checker/src/lib.rs +7 -1
plum-examples/generics.plum +13 -10
plum-wasm-codegen/src/lib.rs +48 -1

README.md CHANGED Viewed

@@ -283,17 +283,19 @@ in outer[Plain] (called at main.plum:9:3):
 - **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
+enum Num[T] =
-fun sumWith(xs: List[T], zero: T, add: fn(T, T) -> T) -> T =
+  | Num(add: fn(T, T) -> T, zero: T)
-  acc := zero
-  for i := range xs.length()
-    acc = add(acc, xs.get(i) ?? zero)
-  acc
+fun sumWith(xs: List[T], num: Num[T]) -> T =
+  xs.reduce(num.zero, |acc, x| num.add(acc, x))
+intNum := Num(add: |a, b| a + b, zero: 0)
+floatNum := Num(add: |a, b| a + b, zero: 0.0)
-sumWith(List(1, 2, 3), 0, |a, b| a + b)       # 6
+sumWith(List(1, 2, 3), intNum)      # 6
-sumWith(List("a", "b"), "", |a, b| a + b)     # "ab"
+sumWith(List(1.5, 2.5), floatNum)   # 4.0
 ```
-  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.)
+  `num.add(a, b)` calls the closure stored in the fn-typed field `add`; if the type also declares a method named `add`, the method wins. See `num_record_passed_explicitly` in [`plum-examples/generics.plum`](plum-examples/generics.plum).
 - **Mixed types are enums.** To hold several kinds of value in one list, declare an enum and `match self`:

plum-checker/src/lib.rs CHANGED Viewed

@@ -2275,7 +2275,13 @@ fn inferClassCallRaw(
         // separate class-construction path needed.
         Some(info) if !info.field_names.is_empty() => {
             let (owner, result, mut binds) = startVariant(info, &explicit, expected);
+            // Closure-valued fields last (same two passes as `checkCallArgs`), so
+            // `Num(add: |a, b| a + b, zero: 0)` learns `T = Int` from `zero` first.
+            let (closures, others): (Vec<&ast::FieldArg>, Vec<&ast::FieldArg>) = call
+                .fields
+                .iter()
+                .partition(|fa| matches!(fa.value, ast::Expr::Closure(_)));
-            for fa in &call.fields {
+            for fa in others.into_iter().chain(closures) {
                 match info.field_names.iter().position(|n| n == &fa.name) {
                     Some(i) => {
                         let pat = types::substitute(&info.field_types[i], &owner);

plum-examples/generics.plum CHANGED Viewed

@@ -69,13 +69,13 @@ 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
+# explicitly as a record of functions (a "Num dictionary"). `num.add(a, b)` calls
-# fields cannot hold `fn` types yet, so it is not bundled into a record).
+# the closure stored in the `add` field (a method named `add` would win).
+enum Num[T] =
+  | Num(add: fn(T, T) -> T, zero: T)
-fun sumWith(xs: List[T], zero: T, add: fn(T, T) -> T) -> T =
+fun sumWith(xs: List[T], num: Num[T]) -> T =
-  acc := zero
-  for i := range xs.length()
-    acc = add(acc, xs.get(i) ?? zero)
+  xs.reduce(num.zero, |acc, x| num.add(acc, x))
-  acc
 test "Int extremes survive a generic fn"
   big := 9223372036854775807
@@ -220,6 +220,9 @@ test "== on T works for Int and Str"
   assert !same(9007199254740993, 9007199254740992)
 test "num_record_passed_explicitly"
+  intNum := Num(add: |a, b| a + b, zero: 0)
+  floatNum := Num(add: |a, b| a + b, zero: 0.0)
+  strNum := Num(add: |a, b| a + b, zero: "")
-  assert sumWith(List(1, 2, 3), 0, |a, b| a + b) == 6
+  assert sumWith(List(1, 2, 3), intNum) == 6
+  assert sumWith(List(1.5, 2.5), floatNum) == 4.0
-  assert sumWith(List("a", "b"), "", |a, b| a + b) == "ab"
+  assert sumWith(List("a", "b"), strNum) == "ab"
-  assert sumWith(List(1.5, 2.5), 0.0, |a, b| a + b) == 4.0

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

@@ -551,6 +551,27 @@ fn instFields(info: &EnumVariantInfo, subject_ty: &PlumType) -> Vec<PlumType> {
         .collect()
 }
+/// The `fn(...)` type of named field `field` on a value of type `obj_ty`, if it has one
+/// (`add` in `enum Num[T] = | Num(add: fn(T, T) -> T, ...)`).
+fn fnFieldType(obj_ty: &PlumType, field: &str, enum_variants: &EnumVariants) -> Option<PlumType> {
+    let enum_name = plum_checker::methodReceiverName(obj_ty)?;
+    enum_variants
+        .values()
+        .filter(|i| i.enum_name == enum_name)
+        .find_map(|i| {
+            let idx = i.field_names.iter().position(|n| n == field)?;
+            instFields(i, obj_ty).into_iter().nth(idx)
+        })
+        .filter(|t| matches!(t, PlumType::TFun(_, _)))
+}
+/// The synthetic local (reserved by `Collector`) that holds the closure read from an
+/// fn-typed field for the call `rec.add(a, b)` at `call_expr` — `#` keeps it
+/// disjoint from every source identifier.
+fn fnFieldLocal(call_expr: &ast::Expr) -> String {
+    format!("fnfield#{}", call_expr as *const ast::Expr as usize)
+}
 /// Import key of the `plum::crash(Str)` host function in `func_ids`.
 const CRASH_FN_KEY: &str = "__crash";
@@ -3698,6 +3719,12 @@ impl<'a> Collector<'a> {
             ast::Expr::Attribute(a) => {
                 self.walkExpr(&a.object);
                 if let ast::AttrKind::Method(call) = &a.attr {
+                    // A call through an fn-typed field needs a local to hold the
+                    // closure (read twice: env, then table index). Reserved even if
+                    // a same-named method wins at compile time (then left unused).
+                    if let Some(t) = fnFieldType(&self.ty(&a.object), &call.name, self.enum_variants) {
+                        self.bind(&fnFieldLocal(expr), t);
+                    }
                     for arg in &call.args {
                         self.walkArg(arg);
                     }
@@ -4413,7 +4440,13 @@ fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
                     ctx.func_sigs
                         .get(&key)
                         .map(|s| s.ret.is_some())
-                        .unwrap_or(true)
+                        .unwrap_or_else(|| {
+                            // A call through an fn-typed field (see `fnFieldLocal`).
+                            !matches!(
+                                ctx.local_decl_types.get(&fnFieldLocal(expr)),
+                                Some(PlumType::TFun(_, r)) if matches!(**r, PlumType::TUnit)
+                            )
+                        })
                 } else {
                     true
                 }
@@ -6490,6 +6523,20 @@ fn compileMethodCall(
         }
     };
     let (dispatch_name, key, box_variant) = resolveMethodKey(&class_name, &call.name, ctx);
+    // `rec.add(a, b)` with no method `add` but an fn-typed field `add`: read the
+    // field's closure into its reserved local, then call it. A method wins.
+    let field_local = fnFieldLocal(result_expr);
+    if !ctx.func_ids.contains_key(&key) && ctx.locals.contains_key(&field_local) {
+        compileFieldRead(object, &call.name, obj_ty, result_expr, body, ctx, state)?;
+        Instruction::LocalSet(ctx.locals[&field_local]).encode(body);
+        let field_call = ast::FnCall {
+            name: field_local,
+            args: call.args.clone(),
+            line: call.line,
+            column: call.column,
+        };
+        return compileClosureCall(&field_call, result_expr, body, ctx, state);
+    }
     let func_idx = *ctx
         .func_ids
         .get(&key)