af1776b | plum | pyrossh

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

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

af1776b — Peter John 2026-09-08T12:57:14+05:30

feat(lang): add postfix `?` error-propagation operator

Files changed (14) hide show

README.md +11 -0
plum-checker/src/lib.rs +52 -0
plum-checker/src/monomorphize.rs +3 -0
plum-core/src/ast.rs +3 -0
plum-core/src/builtin_usage.rs +1 -0
plum-core/src/parser.rs +10 -0
plum-examples/try_operator.plum +58 -0
plum-tooling/tree-sitter-plum/grammar.js +16 -1
plum-tooling/tree-sitter-plum/queries/plum/highlights.scm +2 -0
plum-tooling/tree-sitter-plum/src/grammar.json +0 -0
plum-tooling/tree-sitter-plum/src/node-types.json +0 -0
plum-tooling/tree-sitter-plum/src/parser.c +0 -0
plum-tooling/tree-sitter-plum/test/corpus/try.txt +85 -0
plum-wasm-codegen/src/lib.rs +75 -0

README.md CHANGED Viewed

@@ -312,6 +312,17 @@ $ plum run plum-examples/io.plum
 hello from plum
 ```
+## Error propagation
+`expr?` unwraps a `Result`'s `Ok` or an `Option`'s `Some`, or exits the enclosing function early with the `Err`/`None` value as-is otherwise — Rust's `?`:
+```plum
+fun sumTwo(a: Str, b: Str) -> Result[Int, Str] =
+  x := parsePositive(a)?
+  y := parsePositive(b)?
+  return Ok(x + y)
+```
 ## Standard library highlights
 - **`Bool`** (`import std/Bool`) — ordinary `enum Bool = | True | False`

plum-checker/src/lib.rs CHANGED Viewed

@@ -1104,6 +1104,39 @@ pub(crate) fn lookupFieldType(class_name: &str, field_name: &str, ctx: &CheckCtx
     }
 }
+/// A mangled variant name's own unmangled base (`"Ok$Int$Str"` -> `"Ok"`,
+/// `"None"` -> `"None"`) — `monomorphize::mangle` always joins the original
+/// variant name and its resolved type args with `$`, so the base is simply
+/// everything before the first `$`.
+fn variantBaseName(name: &str) -> &str {
+    name.split('$').next().unwrap_or(name)
+}
+/// Finds the "success" (`Ok`/`Some`) and "failure" (`Err`/`None`) variants
+/// belonging to the same enum as `enum_name`, for the `?` operator (`Expr::Try`)
+/// — used identically by the checker (`inferExpr`) and codegen (`inferLocalType`
+/// callers), which is why this lives here rather than inline in either. Returns
+/// `None` if `enum_name` isn't (a monomorphized specialization of) `Result` or
+/// `Option` — i.e. doesn't have both shapes of variant.
+pub fn tryOperatorVariants<'a>(enum_name: &str, ctx: &'a CheckCtx) -> Option<(&'a str, &'a EnumVariantInfo, &'a str, &'a EnumVariantInfo)> {
+    let mut success: Option<(&str, &EnumVariantInfo)> = None;
+    let mut failure: Option<(&str, &EnumVariantInfo)> = None;
+    for (vname, info) in ctx.enum_variants.iter() {
+        if info.enum_name != enum_name {
+            continue;
+        }
+        match variantBaseName(vname) {
+            "Ok" | "Some" => success = Some((vname.as_str(), info)),
+            "Err" | "None" => failure = Some((vname.as_str(), info)),
+            _ => {}
+        }
+    }
+    match (success, failure) {
+        (Some((sn, si)), Some((fn_, fi))) => Some((sn, si, fn_, fi)),
+        _ => None,
+    }
+}
 pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<PlumType, String> {
     match expr {
         ast::Expr::Int(_) => Ok(PlumType::TInt),
@@ -1134,6 +1167,25 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             },
         },
         ast::Expr::Paren(inner) => inferExpr(inner, env, ctx),
+        // `expr?` — deliberately does NOT check that the enclosing function's
+        // return type actually accepts the `Err`/`None` value this can exit
+        // with early; that's left permissive here (codegen will catch a
+        // genuine mismatch as a wasm type error), consistent with this
+        // checker's existing "unmodeled/unvalidated, codegen catches it"
+        // fallbacks elsewhere (e.g. `TypeName`'s unmodeled-type-name arm
+        // above) — checking it properly would need the enclosing function's
+        // declared return type threaded through every `inferExpr` call site,
+        // for a case a wrong program still fails on, just less precisely.
+        ast::Expr::Try(inner) => {
+            let inner_ty = inferExpr(inner, env, ctx)?;
+            match &inner_ty {
+                PlumType::TNamed(name) => match tryOperatorVariants(name, ctx) {
+                    Some((_, success_info, _, _)) => Ok(success_info.field_types.first().cloned().unwrap_or(PlumType::TUnit)),
+                    None => Err(format!("'?' requires a Result or Option value, found '{}'", name)),
+                },
+                other => Err(format!("'?' requires a Result or Option value, found {}", other)),
+            }
+        }
         ast::Expr::Closure(cl) => {
             let mut closure_env = env.clone();
             let param_names: std::collections::HashSet<&str> = cl.params.iter().map(|s| s.as_str()).collect();

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -294,6 +294,7 @@ fn substituteTypesInExpr(expr: &mut ast::Expr, subst: &Substitution) {
             substituteTypesInExpr(&mut b.right, subst);
         }
         ast::Expr::Not(inner) => substituteTypesInExpr(inner, subst),
+        ast::Expr::Try(inner) => substituteTypesInExpr(inner, subst),
         ast::Expr::Compare(c) => {
             substituteTypesInExpr(&mut c.left, subst);
             substituteTypesInExpr(&mut c.right, subst);
@@ -486,6 +487,7 @@ fn renameVarInExpr(expr: &mut ast::Expr, old: &str, new: &str) {
         ast::Expr::Bool(b) => { renameVarInExpr(&mut b.left, old, new); renameVarInExpr(&mut b.right, old, new); }
         ast::Expr::Compare(c) => { renameVarInExpr(&mut c.left, old, new); renameVarInExpr(&mut c.right, old, new); }
         ast::Expr::Not(inner) => renameVarInExpr(inner, old, new),
+        ast::Expr::Try(inner) => renameVarInExpr(inner, old, new),
         ast::Expr::Unary(u) => renameVarInExpr(&mut u.operand, old, new),
         ast::Expr::Paren(inner) => renameVarInExpr(inner, old, new),
         ast::Expr::Ternary(t) => {
@@ -2211,6 +2213,7 @@ impl<'a> Monomorphizer<'a> {
                 self.resolveBareVariantAgainstExpected(&mut c.right, &lt);
             }
             ast::Expr::Not(inner) => self.rewriteExpr(inner, env)?,
+            ast::Expr::Try(inner) => self.rewriteExpr(inner, env)?,
             ast::Expr::Unary(u) => self.rewriteExpr(&mut u.operand, env)?,
             ast::Expr::Paren(inner) => self.rewriteExpr(inner, env)?,
             ast::Expr::Ternary(t) => {

plum-core/src/ast.rs CHANGED Viewed

@@ -335,6 +335,9 @@ pub enum Expr {
     ClassCall(ClassCall),
     /// `expr.field` or `expr.method(…)`
     Attribute(Box<AttributeExpr>),
+    /// `expr?` — unwraps a `Result`'s `Ok`/an `Option`'s `Some`, or returns the
+    /// `Err`/`None` value from the enclosing function as-is otherwise.
+    Try(Box<Expr>),
     /// `{expr}` — grouped/parenthesized expression
     Paren(Box<Expr>),
     String(StringExpr),

plum-core/src/builtin_usage.rs CHANGED Viewed

@@ -188,6 +188,7 @@ fn walkExpr(expr: &Expr, names: &mut HashSet<String>) {
             walkExpr(&b.right, names);
         }
         Expr::Not(e) => walkExpr(e, names),
+        Expr::Try(e) => walkExpr(e, names),
         Expr::Compare(c) => {
             walkExpr(&c.left, names);
             walkExpr(&c.right, names);

plum-core/src/parser.rs CHANGED Viewed

@@ -670,6 +670,7 @@ impl<'a> AstParser<'a> {
             "binary_operator" => self.parseBinary(node),
             "unary_operator" => self.parseUnary(node),
             "attribute" => self.parseAttribute(node),
+            "try_expression" => self.parseTryExpression(node),
             "fn_call" => Expr::FnCall(self.parseFnCall(node)),
             "class_call" => Expr::ClassCall(self.parseClassCall(node)),
             "parenthesized_expression" => {
@@ -802,6 +803,14 @@ impl<'a> AstParser<'a> {
         Expr::Attribute(Box::new(AttributeExpr { object, attr }))
     }
+    fn parseTryExpression(&self, node: Node) -> Expr {
+        // try_expression: primary_expression "?" — the sole named child is the value.
+        let value = node.child_by_field_name("value")
+            .map(|n| { let u = self.unwrapExprNode(n); self.parsePrimaryExpression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Try(Box::new(value))
+    }
     fn parseFnCall(&self, node: Node) -> FnCall {
         // fn_call: var_identifier fn_argument_list (the callee lexes as var_identifier
         // to avoid an identifier-token tie with all-lowercase, no-underscore names)
@@ -1052,6 +1061,7 @@ fn isExpressionKind(kind: &str) -> bool {
             | "comparison_operator"
             | "ternary_expression"
             | "attribute"
+            | "try_expression"
             | "fn_call"
             | "class_call"
             | "parenthesized_expression"

plum-examples/try_operator.plum ADDED Viewed

@@ -0,0 +1,58 @@
+import std/Result
+import std/Option
+import std/Bool
+import std/Number
+import std/Str
+import std/List
+# `expr?` unwraps a `Result`'s `Ok` or an `Option`'s `Some`, or exits the
+# enclosing function early with the `Err`/`None` value as-is otherwise — same
+# idea as Rust's `?`. The enclosing function's own return type must accept
+# whatever gets returned early; that isn't checked until codegen (see
+# `plum-checker`'s `inferExpr` on `Expr::Try`), so a mismatch there still
+# surfaces as a clear compile error, just a less precise one.
+fun parsePositive(s: Str) -> Result[Int, Str] =
+  n := parseInt(s)?
+  if n < 0
+    return Err("negative")
+  return Ok(n)
+fun sumTwo(a: Str, b: Str) -> Result[Int, Str] =
+  x := parsePositive(a)?
+  y := parsePositive(b)?
+  return Ok(x + y)
+fun firstPositive(list: List[Int]) -> Option[Int] =
+  match list.get(0)
+    Some(v) =>
+      if v > 0
+        return Some(v)
+      return None
+    None =>
+      return None
+fun doubledFirstPositive(list: List[Int]) -> Option[Int] =
+  a := firstPositive(list)?
+  return Some(a * 2)
+test "try operator unwraps Ok and propagates the value through two calls"
+  r := sumTwo("2", "3")
+  assert r.isOk()
+  assert r.unwrap() == 5
+test "try operator exits early with Err, skipping the rest of the function"
+  r := sumTwo("2", "-3")
+  assert r.isErr()
+  assert r.unwrapErr() == "negative"
+test "try operator unwraps Some and propagates the value"
+  l := List(5)
+  r := doubledFirstPositive(l)
+  assert r.isSome()
+  assert r.unwrap() == 10
+test "try operator exits early with None, skipping the rest of the function"
+  l := List[Int]()
+  r := doubledFirstPositive(l)
+  assert r.isNone()

plum-tooling/tree-sitter-plum/grammar.js CHANGED Viewed

@@ -71,7 +71,14 @@ module.exports = grammar({
   // Conflict arises at the empty-argument-list state (e.g. `Foo()`): the parser cannot
   // distinguish fn_argument_list from class_argument_list until it sees content or ')'.
   // Declaring the conflict at the argument-list level (not the call level) resolves this.
+  conflicts: ($) => [
-  conflicts: ($) => [[$.fn_argument_list, $.class_argument_list]],
+    [$.fn_argument_list, $.class_argument_list],
+    // `cmp ? sum : bits` (ternary) vs `cmp?` (try-operator postfix) both start
+    // with `primary_expression "?"` — genuinely ambiguous with only 1 token of
+    // lookahead (a `:` may or may not follow much later); GLR resolves it by
+    // trying both and keeping whichever completes.
+    [$.expression, $.try_expression],
+  ],
   inline: ($) => [$.generic_type],
   rules: {
     source: ($) =>
@@ -394,6 +401,7 @@ module.exports = grammar({
         $.float,
         $.unary_operator,
         $.attribute,
+        $.try_expression,
         $.fn_call,
         $.class_call,
         $.parenthesized_expression,
@@ -509,6 +517,13 @@ module.exports = grammar({
         ),
       ),
+    // Rust-style error-propagation postfix: `expr?` — unwraps a `Result`'s `Ok`
+    // or an `Option`'s `Some`, or exits the enclosing function early with the
+    // `Err`/`None` value as-is otherwise. Same postfix shape/precedence as
+    // `attribute` (`.`) just above.
+    try_expression: ($) =>
+      seq(field("value", $.primary_expression), "?"),
     // The callee name lexes as `var_identifier` (widened to a superset of
     // `fn_identifier`'s charset below) rather than `fn_identifier` — using two
     // different identifier tokens here was ambiguous for any all-lowercase,

plum-tooling/tree-sitter-plum/queries/plum/highlights.scm CHANGED Viewed

@@ -62,6 +62,8 @@
   ".."
 ] @operator
+(try_expression "?" @operator)
 [
   "->"
   "=>"

plum-tooling/tree-sitter-plum/src/grammar.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/node-types.json CHANGED Viewed

Binary file

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

Binary file

plum-tooling/tree-sitter-plum/test/corpus/try.txt ADDED Viewed

@@ -0,0 +1,85 @@
+================================================================================
+try operator - postfix ? unwraps or returns early
+================================================================================
+fun parsePositive(s: Str) -> Result[Int, Str] =
+  n := parseInt(s)?
+  return Ok(n)
+--------------------------------------------------------------------------------
+(source
+  (fn
+    name: (fn_identifier)
+    params: (param
+      name: (var_identifier)
+      type: (type
+        (type_identifier)))
+    returns: (type
+      (type_identifier)
+      generics: (type
+        (type_identifier))
+      generics: (type
+        (type_identifier)))
+    body: (body
+      (assign
+        (var_identifier)
+        (expression
+          (primary_expression
+            (try_expression
+              value: (primary_expression
+                (fn_call
+                  function: (var_identifier)
+                  arguments: (fn_argument_list
+                    (expression
+                      (primary_expression
+                        (var_identifier))))))))))
+      (return
+        (expression
+          (primary_expression
+            (fn_call
+              function: (type_identifier)
+              arguments: (fn_argument_list
+                (expression
+                  (primary_expression
+                    (var_identifier)))))))))))
+================================================================================
+try operator - coexists with the unrelated ternary operator, same `?` token
+================================================================================
+fun classify(n: Int) -> Int =
+  picked = n > 0 ? n : 0
+  picked
+--------------------------------------------------------------------------------
+(source
+  (fn
+    (fn_identifier)
+    (param
+      (var_identifier)
+      (type
+        (type_identifier)))
+    (type
+      (type_identifier))
+    (body
+      (assign
+        (var_identifier)
+        (expression
+          (ternary_expression
+            (expression
+              (comparison_operator
+                (primary_expression
+                  (var_identifier))
+                (primary_expression
+                  (integer))))
+            (expression
+              (primary_expression
+                (var_identifier)))
+            (expression
+              (primary_expression
+                (integer))))))
+      (expression
+        (primary_expression
+          (var_identifier))))))

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

@@ -511,6 +511,12 @@ fn withGcTypes<R>(f: impl FnOnce(&GcTypeRegistry) -> R) -> R {
 fn classOrVariantTypeIdx(r: &GcTypeRegistry, name: &str) -> u32 {
     *r.variant_type_idx.get(name)
         .or_else(|| r.class_type_idx.get(name))
+        // A scratch slot narrowed to a MULTI-variant enum's own wide supertype
+        // (not any one variant) — the `?` operator's scratch local holds the
+        // subject at its natural (possibly multi-variant, e.g. `Result`/`Option`)
+        // type, never narrower, since it ref.casts to whichever of the two
+        // variants applies only at the point of use, not up front.
+        .or_else(|| r.enum_super_type_idx.get(name))
         .unwrap_or_else(|| panic!("internal codegen error: '{}' missing from the GC type registry", name))
 }
@@ -2145,6 +2151,7 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
             ast::Expr::Bool(b) => { self.walkExpr(&b.left, None); self.walkExpr(&b.right, None); }
             ast::Expr::Compare(c) => { self.walkExpr(&c.left, None); self.walkExpr(&c.right, None); }
             ast::Expr::Not(inner) => self.walkExpr(inner, None),
+            ast::Expr::Try(inner) => self.walkExpr(inner, None),
             ast::Expr::Unary(u) => self.walkExpr(&u.operand, None),
             ast::Expr::Paren(inner) => self.walkExpr(inner, None),
             ast::Expr::Ternary(t) => {
@@ -2657,6 +2664,7 @@ fn fvCollectRefsExpr(
         ast::Expr::Bool(b) => { fvCollectRefsExpr(&b.left, bound, seen, free, env, fn_decls); fvCollectRefsExpr(&b.right, bound, seen, free, env, fn_decls); }
         ast::Expr::Compare(c) => { fvCollectRefsExpr(&c.left, bound, seen, free, env, fn_decls); fvCollectRefsExpr(&c.right, bound, seen, free, env, fn_decls); }
         ast::Expr::Not(inner) => fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls),
+        ast::Expr::Try(inner) => fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls),
         ast::Expr::Unary(u) => fvCollectRefsExpr(&u.operand, bound, seen, free, env, fn_decls),
         ast::Expr::Paren(inner) => fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls),
         ast::Expr::Ternary(t) => {
@@ -2892,6 +2900,29 @@ impl<'a> Collector<'a> {
                 self.walkExpr(&c.right);
             }
             ast::Expr::Not(inner) => self.walkExpr(inner),
+            // `expr?` needs a scratch local to hold `inner`'s value across the
+            // `ref.test` that decides Ok/Some vs Err/None (which consumes it)
+            // and the `ref.cast` that reads it again inside whichever branch —
+            // reuses the same pointer-identity-keyed scratch-slot mechanism
+            // constructor patterns already use (`nested_class_scratch`), keyed
+            // by this `Expr::Try` node itself. Declared with `inner`'s own
+            // (possibly multi-variant, e.g. `Result`/`Option`) enum type —
+            // `classOrVariantTypeIdx` falls back to `enum_super_type_idx` for
+            // exactly this case — since narrowing happens later via `ref.cast`
+            // in each branch, not by declaring this local pre-narrowed.
+            ast::Expr::Try(inner) => {
+                let key = expr as *const ast::Expr as usize;
+                let ty = plum_checker::inferExpr(inner, &self.env, &self.cctx).unwrap_or(PlumType::TVar("_".to_string()));
+                let name = match &ty {
+                    PlumType::TNamed(n) => n.clone(),
+                    _ => String::new(),
+                };
+                let slot = self.next_nested_class_slot;
+                self.next_nested_class_slot += 1;
+                self.nested_class_scratch.insert(key, slot);
+                self.nested_class_scratch_types.push(name);
+                self.walkExpr(inner);
+            }
             ast::Expr::Unary(u) => self.walkExpr(&u.operand),
             ast::Expr::Paren(inner) => self.walkExpr(inner),
             ast::Expr::Ternary(t) => {
@@ -4039,6 +4070,50 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
         ast::Expr::Paren(inner) => {
             compileExpr(inner, body, ctx, state)?;
         }
+        // `expr?` — `ref.test` decides Ok/Some (fall through, extract the
+        // field) vs Err/None (return the already-constructed value AS-IS,
+        // no reconstruction needed). The `then`/`else` branches don't need to
+        // agree in wasm's usual sense: after `return`, the rest of that
+        // branch is unreachable, so the validator accepts the `if`'s single
+        // declared result type (the success field's) coming only from the
+        // `else` branch — the same stack-polymorphism-after-`return` rule
+        // `compileStmt`'s own `Return` arm relies on, just reached from
+        // inside an expression here for the first time.
+        ast::Expr::Try(inner) => {
+            let inner_ty = inferLocalType(inner, ctx);
+            let enum_name = match &inner_ty {
+                PlumType::TNamed(n) => n.clone(),
+                other => return Err(format!("codegen: '?' requires a Result or Option value, found {}", other)),
+            };
+            let cctx = checkCtxOf(ctx.methods, ctx.enum_variants, ctx.enum_params, ctx.min_required);
+            let (success_name, success_info, failure_name, _) = plum_checker::tryOperatorVariants(&enum_name, &cctx)
+                .ok_or_else(|| format!("codegen: '?' requires a Result or Option value, found '{}'", enum_name))?;
+            let success_idx = *ctx.gc_types.variant_type_idx.get(success_name)
+                .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", success_name))?;
+            let failure_idx = *ctx.gc_types.variant_type_idx.get(failure_name)
+                .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", failure_name))?;
+            let success_vt = plumTypeToValtype(&success_info.field_types.first().cloned().unwrap_or(PlumType::TUnit));
+            let key = expr as *const ast::Expr as usize;
+            let slot = *ctx.nested_class_scratch.get(&key)
+                .ok_or_else(|| "internal codegen error: missing '?' scratch slot".to_string())?;
+            let scratch_local = ctx.nested_class_scratch_base + slot;
+            compileExpr(inner, body, ctx, state)?;
+            Instruction::LocalTee(scratch_local).encode(body);
+            Instruction::RefTestNonNull(HeapType::Concrete(failure_idx)).encode(body);
+            Instruction::If(BlockType::Result(success_vt)).encode(body);
+            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::RefCastNonNull(HeapType::Concrete(failure_idx)).encode(body);
+            Instruction::Return.encode(body);
+            Instruction::Else.encode(body);
+            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::RefCastNonNull(HeapType::Concrete(success_idx)).encode(body);
+            if !success_info.field_types.is_empty() {
+                Instruction::StructGet { struct_type_index: success_idx, field_index: 0 }.encode(body);
+            }
+            Instruction::End.encode(body);
+        }
         ast::Expr::Unary(u) => match u.op {
             ast::UnOp::Neg => {
                 if matches!(inferLocalType(&u.operand, ctx), PlumType::TFloat) {