ec5336f | plum | pyrossh

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

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

ec5336f — Peter John 2026-09-08T13:13:12+05:30

feat(lang): add elvis `?:` operator

Files changed (15) hide show

README.md +9 -0
plum-checker/src/lib.rs +17 -0
plum-checker/src/monomorphize.rs +12 -0
plum-core/src/ast.rs +10 -0
plum-core/src/builtin_usage.rs +4 -0
plum-core/src/parser.rs +14 -0
plum-examples/{try_operator.plum → error_propagation.plum} +25 -0
plum-tooling/tree-sitter-plum/grammar.js +13 -0
plum-tooling/tree-sitter-plum/queries/plum/format.scm +2 -0
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/elvis.txt +107 -0
plum-wasm-codegen/src/lib.rs +68 -0

README.md CHANGED Viewed

@@ -323,6 +323,15 @@ fun sumTwo(a: Str, b: Str) -> Result[Int, Str] =
   return Ok(x + y)
 ```
+`left ?: right` (elvis) is the plain-expression counterpart — no early return, just a fallback value if `left` is `Err`/`None`:
+```plum
+fun sumOrZero(a: Str, b: Str) -> Int =
+  x := parsePositive(a) ?: 0
+  y := parsePositive(b) ?: 0
+  x + y
+```
 ## Standard library highlights
 - **`Bool`** (`import std/Bool`) — ordinary `enum Bool = | True | False`

plum-checker/src/lib.rs CHANGED Viewed

@@ -1038,6 +1038,7 @@ fn resolveClosureParamFromFieldUsage(
             ast::Expr::Not(inner) | ast::Expr::Paren(inner) => scanExpr(inner, params, ctx, resolved),
             ast::Expr::Unary(u) => scanExpr(&u.operand, params, ctx, resolved),
             ast::Expr::Ternary(t) => { scanExpr(&t.condition, params, ctx, resolved); scanExpr(&t.then, params, ctx, resolved); scanExpr(&t.else_, params, ctx, resolved); }
+            ast::Expr::Elvis(e) => { scanExpr(&e.left, params, ctx, resolved); scanExpr(&e.right, params, ctx, resolved); }
             _ => {}
         }
     }
@@ -1259,6 +1260,22 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             unify(&tt, &et, ctx).map_err(|e| format!("ternary branches: {}", e))?;
             Ok(tt)
         }
+        // `left ?: right` — unlike `?`, a plain expression (no early return),
+        // so (unlike `Try` above) it's fully validated here: `right` must
+        // unify with `left`'s success (`Ok`/`Some`) field type.
+        ast::Expr::Elvis(e) => {
+            let left_ty = inferExpr(&e.left, env, ctx)?;
+            let success_ty = match &left_ty {
+                PlumType::TNamed(name) => match tryOperatorVariants(name, ctx) {
+                    Some((_, success_info, _, _)) => success_info.field_types.first().cloned().unwrap_or(PlumType::TUnit),
+                    None => return Err(format!("'?:' requires a Result or Option value, found '{}'", name)),
+                },
+                other => return Err(format!("'?:' requires a Result or Option value, found {}", other)),
+            };
+            let right_ty = inferExpr(&e.right, env, ctx)?;
+            unify(&success_ty, &right_ty, ctx).map_err(|e| format!("'?:' branches: {}", e))?;
+            Ok(success_ty)
+        }
         ast::Expr::FnCall(call) => {
             // `Int(x)`/`Float(x)`/`Byte(x)` are builtin numeric conversions, not
             // ordinary calls — handled here so `y = Float(x)` unifies against

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -295,6 +295,10 @@ fn substituteTypesInExpr(expr: &mut ast::Expr, subst: &Substitution) {
         }
         ast::Expr::Not(inner) => substituteTypesInExpr(inner, subst),
         ast::Expr::Try(inner) => substituteTypesInExpr(inner, subst),
+        ast::Expr::Elvis(e) => {
+            substituteTypesInExpr(&mut e.left, subst);
+            substituteTypesInExpr(&mut e.right, subst);
+        }
         ast::Expr::Compare(c) => {
             substituteTypesInExpr(&mut c.left, subst);
             substituteTypesInExpr(&mut c.right, subst);
@@ -488,6 +492,10 @@ fn renameVarInExpr(expr: &mut ast::Expr, old: &str, new: &str) {
         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::Elvis(e) => {
+            renameVarInExpr(&mut e.left, old, new);
+            renameVarInExpr(&mut e.right, old, new);
+        }
         ast::Expr::Unary(u) => renameVarInExpr(&mut u.operand, old, new),
         ast::Expr::Paren(inner) => renameVarInExpr(inner, old, new),
         ast::Expr::Ternary(t) => {
@@ -2221,6 +2229,10 @@ impl<'a> Monomorphizer<'a> {
                 self.rewriteExpr(&mut t.then, env)?;
                 self.rewriteExpr(&mut t.else_, env)?;
             }
+            ast::Expr::Elvis(e) => {
+                self.rewriteExpr(&mut e.left, env)?;
+                self.rewriteExpr(&mut e.right, env)?;
+            }
             // String interpolation can embed arbitrary expressions (including generic
             // call sites), so recurse into its interpolated parts.
             ast::Expr::String(s) => {

plum-core/src/ast.rs CHANGED Viewed

@@ -338,6 +338,10 @@ pub enum Expr {
     /// `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>),
+    /// `left ?: right` — if `left` is `Ok(v)`/`Some(v)`, the value is `v`; if
+    /// it's `Err(_)`/`None`, the value is `right`. Unlike `Try`, a plain
+    /// expression with no early return.
+    Elvis(Box<ElvisExpr>),
     /// `{expr}` — grouped/parenthesized expression
     Paren(Box<Expr>),
     String(StringExpr),
@@ -421,6 +425,12 @@ pub struct TernaryExpr {
     pub else_: Expr,
 }
+#[derive(Debug, Clone, PartialEq)]
+pub struct ElvisExpr {
+    pub left: Expr,
+    pub right: Expr,
+}
 #[derive(Debug, Clone, PartialEq)]
 pub struct FnCall {
     pub name: String,

plum-core/src/builtin_usage.rs CHANGED Viewed

@@ -198,6 +198,10 @@ fn walkExpr(expr: &Expr, names: &mut HashSet<String>) {
             walkExpr(&t.then, names);
             walkExpr(&t.else_, names);
         }
+        Expr::Elvis(e) => {
+            walkExpr(&e.left, names);
+            walkExpr(&e.right, names);
+        }
         Expr::FnCall(call) => {
             if isTracked(&call.name) {
                 names.insert(call.name.clone());

plum-core/src/parser.rs CHANGED Viewed

@@ -637,6 +637,7 @@ impl<'a> AstParser<'a> {
             }
             "boolean_operator" => self.parseBoolOp(node),
             "ternary_expression" => self.parseTernary(node),
+            "elvis_expression" => self.parseElvis(node),
             "closure" => Expr::Closure(Box::new(self.parseClosure(node))),
             _ => self.parsePrimaryExpression(node),
         }
@@ -781,6 +782,18 @@ impl<'a> AstParser<'a> {
         Expr::Ternary(Box::new(TernaryExpr { condition, then, else_ }))
     }
+    fn parseElvis(&self, node: Node) -> Expr {
+        // elvis_expression: expression "?:" expression
+        let named: Vec<Node> = self.namedChildren(node);
+        let left = named.first()
+            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })
+            .unwrap_or(Expr::Int(0));
+        let right = named.get(1)
+            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Elvis(Box::new(ElvisExpr { left, right }))
+    }
     fn parseAttribute(&self, node: Node) -> Expr {
         // attribute: primary_expression "." fn_identifier fn_argument_list?
         // The member name is always fn_identifier (a superset of var_identifier); an
@@ -1060,6 +1073,7 @@ fn isExpressionKind(kind: &str) -> bool {
             | "not_operator"
             | "comparison_operator"
             | "ternary_expression"
+            | "elvis_expression"
             | "attribute"
             | "try_expression"
             | "fn_call"

plum-examples/{try_operator.plum → error_propagation.plum} RENAMED Viewed

@@ -11,6 +11,11 @@ import std/List
 # 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.
+#
+# `left ?: right` (elvis) is the plain-expression counterpart: same Ok/Some
+# vs Err/None narrowing, but no early return — `right` is a fallback value,
+# fully checked (unlike `?`) since there's no enclosing-return-type
+# uncertainty to be permissive about.
 fun parsePositive(s: Str) -> Result[Int, Str] =
   n := parseInt(s)?
@@ -36,6 +41,18 @@ fun doubledFirstPositive(list: List[Int]) -> Option[Int] =
   a := firstPositive(list)?
   return Some(a * 2)
+# `left ?: right` — same Ok/Some-vs-Err/None narrowing as `?`, but a plain
+# expression (no early return): `right` is the fallback value, unified against
+# the success field's type by the checker.
+fun sumOrZero(a: Str, b: Str) -> Int =
+  x := parsePositive(a) ?: 0
+  y := parsePositive(b) ?: 0
+  x + y
+fun firstOrDefault(list: List[Int], default: Int) -> Int =
+  list.get(0) ?: default
 test "try operator unwraps Ok and propagates the value through two calls"
   r := sumTwo("2", "3")
   assert r.isOk()
@@ -56,3 +73,11 @@ test "try operator exits early with None, skipping the rest of the function"
   l := List[Int]()
   r := doubledFirstPositive(l)
   assert r.isNone()
+test "elvis operator unwraps Ok and falls back to 0 on Err"
+  assert sumOrZero("2", "3") == 5
+  assert sumOrZero("2", "-3") == 2
+test "elvis operator unwraps Some and falls back to the given default on None"
+  assert firstOrDefault(List(5), 99) == 5
+  assert firstOrDefault(List[Int](), 99) == 99

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

@@ -387,6 +387,7 @@ module.exports = grammar({
         $.closure,
         $.primary_expression,
         $.ternary_expression,
+        $.elvis_expression,
       ),
     primary_expression: ($) =>
@@ -594,6 +595,18 @@ module.exports = grammar({
         seq($.expression, "?", $.expression, ":", $.expression),
       ),
+    // Elvis / null-coalescing: `opt ?: default` — if `left` is `Ok(v)`/`Some(v)`,
+    // the value is `v`; if it's `Err(_)`/`None`, the value is `right`. A single
+    // atomic `"?:"` token (maximal munch out-munches the bare `"?"` ternary/
+    // try-operator tokens at the same position, so — unlike `try_expression`,
+    // which genuinely shares ternary's leading `?` and needs the `conflicts`
+    // entry above — this needs no special conflict handling).
+    elvis_expression: ($) =>
+      prec.right(
+        PREC.conditional,
+        seq($.expression, "?:", $.expression),
+      ),
     // ==========
     // Literals
     // ==========

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

@@ -82,6 +82,8 @@
     ":"
   ] @prepend_space @append_space)
+(elvis_expression "?:" @prepend_space @append_space)
 ; ============================================================
 ; Keywords — space after (Topiary inserts NO whitespace at all
 ; between adjacent leaves unless a query says to; every keyword

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

@@ -64,6 +64,8 @@
 (try_expression "?" @operator)
+(elvis_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/elvis.txt ADDED Viewed

@@ -0,0 +1,107 @@
+================================================================================
+elvis operator - unwraps Ok/Some or falls back to the right-hand value
+================================================================================
+fun firstOrDefault(list: List[Int], default: Int) -> Int =
+  list.get(0) ?: default
+--------------------------------------------------------------------------------
+(source
+  (fn
+    (fn_identifier)
+    (param
+      (var_identifier)
+      (type
+        (type_identifier)
+        (type
+          (type_identifier))))
+    (param
+      (var_identifier)
+      (type
+        (type_identifier)))
+    (type
+      (type_identifier))
+    (body
+      (expression
+        (elvis_expression
+          (expression
+            (primary_expression
+              (attribute
+                (primary_expression
+                  (var_identifier))
+                (fn_identifier)
+                (fn_argument_list
+                  (expression
+                    (primary_expression
+                      (integer)))))))
+          (expression
+            (primary_expression
+              (var_identifier))))))))
+================================================================================
+elvis operator - coexists with ternary and try, all sharing `?`-prefixed tokens
+================================================================================
+fun classify(n: Int) -> Int =
+  a = n > 0 ? n : 0
+  b = n ?: 0
+  c = n?
+  a + b + c
+--------------------------------------------------------------------------------
+(source
+  (fn
+    name: (fn_identifier)
+    params: (param
+      name: (var_identifier)
+      type: (type
+        (type_identifier)))
+    returns: (type
+      (type_identifier))
+    body: (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))))))
+      (assign
+        (var_identifier)
+        (expression
+          (elvis_expression
+            (expression
+              (primary_expression
+                (var_identifier)))
+            (expression
+              (primary_expression
+                (integer))))))
+      (assign
+        (var_identifier)
+        (expression
+          (primary_expression
+            (try_expression
+              value: (primary_expression
+                (var_identifier))))))
+      (expression
+        (primary_expression
+          (binary_operator
+            left: (primary_expression
+              (binary_operator
+                left: (primary_expression
+                  (var_identifier))
+                right: (primary_expression
+                  (var_identifier))))
+            right: (primary_expression
+              (var_identifier))))))))

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

@@ -2159,6 +2159,10 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
                 self.walkExpr(&t.then, None);
                 self.walkExpr(&t.else_, None);
             }
+            ast::Expr::Elvis(e) => {
+                self.walkExpr(&e.left, None);
+                self.walkExpr(&e.right, None);
+            }
             ast::Expr::FnCall(call) => {
                 let callee = self.fn_decls.get(&call.name).copied();
                 for (i, arg) in call.args.iter().enumerate() {
@@ -2434,6 +2438,10 @@ fn scanExprForParamTypes(
             scanExprForParamTypes(&t.then, params, env, cctx, resolved);
             scanExprForParamTypes(&t.else_, params, env, cctx, resolved);
         }
+        ast::Expr::Elvis(e) => {
+            scanExprForParamTypes(&e.left, params, env, cctx, resolved);
+            scanExprForParamTypes(&e.right, params, env, cctx, resolved);
+        }
         ast::Expr::FnCall(call) => {
             if let Ok(PlumType::TFun(param_types, _)) = plum_checker::lookup(env, &call.name) {
                 for (arg, expected) in call.args.iter().zip(param_types.iter()) {
@@ -2672,6 +2680,10 @@ fn fvCollectRefsExpr(
             fvCollectRefsExpr(&t.then, bound, seen, free, env, fn_decls);
             fvCollectRefsExpr(&t.else_, bound, seen, free, env, fn_decls);
         }
+        ast::Expr::Elvis(e) => {
+            fvCollectRefsExpr(&e.left, bound, seen, free, env, fn_decls);
+            fvCollectRefsExpr(&e.right, bound, seen, free, env, fn_decls);
+        }
         ast::Expr::FnCall(call) => {
             for arg in &call.args {
                 fvCollectRefsExpr(argExprOf(arg), bound, seen, free, env, fn_decls);
@@ -2930,6 +2942,24 @@ impl<'a> Collector<'a> {
                 self.walkExpr(&t.then);
                 self.walkExpr(&t.else_);
             }
+            // Same scratch-slot need as `Try` above — `left` is narrowed via
+            // `ref.test`/`ref.cast` the same way, just with `right` (an
+            // ordinary expression, no narrowing) as the fallback instead of a
+            // `return`.
+            ast::Expr::Elvis(e) => {
+                let key = expr as *const ast::Expr as usize;
+                let ty = plum_checker::inferExpr(&e.left, &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(&e.left);
+                self.walkExpr(&e.right);
+            }
             ast::Expr::FnCall(call) => {
                 for arg in &call.args {
                     self.walkArg(arg);
@@ -4114,6 +4144,44 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             }
             Instruction::End.encode(body);
         }
+        // `left ?: right` — same `ref.test`/scratch-local narrowing as `Try`
+        // above, but both branches produce an ordinary value (no `return`):
+        // the failure branch compiles `right` (already unified against the
+        // success field's type by the checker), the success branch extracts
+        // the field, same as `Try`'s own success branch.
+        ast::Expr::Elvis(e) => {
+            let left_ty = inferLocalType(&e.left, ctx);
+            let enum_name = match &left_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(&e.left, 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);
+            compileExpr(&e.right, body, ctx, state)?;
+            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) {