745232b | plum | pyrossh

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

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

745232b — Peter John 2026-10-27T00:41:32+05:30

fix(errors): fail Missing is the absent value in a T? slot; nested error unions as success values

Files changed (6) hide show

README.md +2 -0
plum-checker/src/lib.rs +32 -1
plum-checker/tests/error_union_tests.rs +22 -0
plum-examples/error_propagation.plum +11 -0
plum-examples/safe_navigation.plum +23 -0
plum-wasm-codegen/src/lib.rs +25 -0

README.md CHANGED Viewed

@@ -635,6 +635,8 @@ enum Failure =
 A missing value is `T?`, shorthand for `!T [Missing]`; absence is written `fail Missing`, and a plain `T` in a `T?` slot is the present value. For a reference type (a class, enum, `Str`, `List`, ...) a `T?` is stored as a nullable reference, so a present value costs no allocation and no code word; for `Int`, `Float`, `Bool` and value enums it is an ordinary error union. `T?` uses the same `?`, `!` and `catch` as every other error union. A doubled `?` suffix is not allowed.
+`fail Missing` is also a plain value wherever a `T?` is expected (a call or constructor argument, a `return`, a tail, a parameter default such as `n: Int? = fail Missing`): there it is the absent value, not an early return from the enclosing function, so `Cfg(port: fail Missing)` and a `List[Int?]` built by a function returning that type just work. Where no `T?` is expected (for example a bare statement, or a list literal whose element type is not yet known) `fail Missing` is the usual early return. An error union can be the success type of another (`List[!Int].get(i)` is a `!!Int`): unwrap it one level at a time with `!`, `?` or `catch`.
 ### Safe navigation: `?.`
 `obj?.field` / `obj?.method(args)` (safe navigation, Groovy/Kotlin-style) reaches into an error union (`!T` or `T?`) without unwrapping it -- a success maps the field or method access over the inner value and re-wraps it with the same set, an error passes through untouched. A field that is itself a `T?` flattens, so a chain is one `?` value, not a nested one:

plum-checker/src/lib.rs CHANGED Viewed

@@ -497,13 +497,19 @@ fn recordBind(name: &str, ty: &PlumType) {
 pub const ERR_WRAP: usize = 4;
 pub const ERR_FROM_NULLABLE: usize = 5;
 pub const ERR_TO_NULLABLE: usize = 6;
+/// `+7` marks a `fail Missing` written where a `T?` is expected (a call or
+/// constructor argument, a tail, a `return`): it is the ABSENT VALUE of that `T?`,
+/// not an early return from the enclosing fn.
+pub const ERR_ABSENT: usize = 7;
 fn recordErrCoercion(expr: &ast::Expr, actual: &PlumType, expected: Option<&PlumType>, ctx: &CheckCtx) {
     let Some(expected) = expected else { return };
     let kind = match (expected, actual) {
         (_, PlumType::TVar(_) | PlumType::TParam(_)) => return,
         (PlumType::TErr(inner, _), a) => {
+            if matches!(**inner, PlumType::TErr(..)) && matches!(a, PlumType::TErr(..)) && unify(inner, a, ctx).is_ok() {
+                Some(ERR_WRAP)
-            if let PlumType::TErr(..) = a {
+            } else if let PlumType::TErr(..) = a {
                 // Both sides are error unions; only a layout change needs code.
                 match (nullableErrPayload(a).is_some(), nullableErrPayload(expected).is_some()) {
                     (true, false) => Some(ERR_FROM_NULLABLE),
@@ -651,6 +657,10 @@ fn addToErrSet(set: &ErrSet, names: &BTreeSet<String>) -> Result<(), String> {
 /// fits a `!T` slot; the reverse needs `?`, `!` or `catch`.
 fn unifyErr(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String> {
     match (errView(t1), errView(t2)) {
+        // The success type is itself an error union (`Map[K, !V].get`): an
+        // actual error union that fits it is the success VALUE, never a
+        // propagation of its errors into the outer set.
+        (Some((et @ PlumType::TErr(..), _)), Some(_)) if unify(&et, t2, ctx).is_ok() => Ok(()),
         (Some((et, es)), Some((at, aset))) => {
             unify(&et, &at, ctx)
                 .map_err(|e| format!("type mismatch: expected {}, found {} ({})", t1, t2, e))?;
@@ -3437,6 +3447,27 @@ fn inferExprInner(
             Ok(success)
         }
         ast::Expr::Fail(f) => {
+            // `fail Missing` where a `T?` is expected is the absent value itself.
+            let ptr = expr as *const ast::Expr as usize + ERR_ABSENT;
+            let absent = match expected {
+                Some(t @ PlumType::TErr(_, ErrSet::Pinned(names)))
+                    if f.tag == "Missing" && names.len() == 1 && names.contains("Missing") =>
+                {
+                    Some(t.clone())
+                }
+                _ => None,
+            };
+            RECORD.with(|r| {
+                if let Some(m) = r.borrow_mut().as_mut() {
+                    m.remove(&ptr);
+                    if let Some(t) = &absent {
+                        m.insert(ptr, t.clone());
+                    }
+                }
+            });
+            if let Some(t) = absent {
+                return Ok(t);
+            }
             let Some(outer) = env.get(RETURN_KEY).map(|s| (*s.body).clone()) else {
                 return Err(
                     "`fail` is only allowed in a function that returns an error union (-> !T)"

plum-checker/tests/error_union_tests.rs CHANGED Viewed

@@ -376,3 +376,25 @@ fun f() -> !Int =
         assert!(kinds.contains(&k), "missing {:?} in {:?}", k, kinds);
     }
 }
+#[test]
+fn fail_missing_is_an_absent_value_where_a_nullable_is_expected() {
+    // Constructor argument of type `Int?`: not an early return, and legal in a
+    // fn that returns a plain value.
+    let src = "\
+enum Cfg =
+  | Cfg(port: Int?)
+fun mk() -> Cfg =
+  Cfg(port: fail Missing)
+";
+    assert_eq!(check(src), Ok(()));
+    // Where no `T?` is expected it is still the ordinary early return, so a fn
+    // that cannot fail rejects it.
+    let bad = "\
+fun f() -> Int =
+  x := fail Missing
+  1
+";
+    assert!(check(bad).unwrap_err().contains("declare `-> !T`"));
+}

plum-examples/error_propagation.plum CHANGED Viewed

@@ -176,3 +176,14 @@ test "match falls back to a wildcard arm"
   assert ageOrDefault("30") == 30
   assert ageOrDefault("999") == 150
   assert ageOrDefault("x") == 0
+# An error union can be the success type of another (a `List[!Int]` holds
+# per-element results): `xs.get(i)` is `!!Int`, unwrapped one level at a time.
+test "a list of error unions nests one level per access"
+  results := List(parsePositive("1"), parsePositive("-1"), parsePositive("x"))
+  first := results.get(0)!
+  assert first! == 1
+  second := results.get(1)!
+  assert {second catch 0} == 0
+  fallback := {results.get(9) catch parsePositive("5")}
+  assert {fallback catch 0} == 5

plum-examples/safe_navigation.plum CHANGED Viewed

@@ -1,11 +1,16 @@
 import std/Number
 import std/Str
+import std/List
 # `T?` is shorthand for `!T [Missing]`: a `T` or nothing. Absence is written
 # `fail Missing`; a plain `T` where a `T?` is expected is the present value.
 # For a reference type (class, enum, Str, List, ...) a `T?` is stored as a
 # nullable reference, so a present value costs no allocation. It is handled with
 # the same `?`, `!` and `catch` as every other error union.
 #
+# `fail Missing` also works as a VALUE wherever a `T?` is expected (a call or
+# constructor argument, a list element, a default): it is the absent value, not
+# an early return from the enclosing function.
+#
 # `obj?.field` / `obj?.method(args)` -- Groovy/Kotlin-style safe navigation.
 # Reaches into an error union's success value without unwrapping it and
 # re-wraps the result; an error passes through untouched. A field that is
@@ -40,6 +45,12 @@ fun noPerson() -> Person? =
 fun noTarget() -> Target? =
   fail Missing
+fun maybeCount(n: Int? = fail Missing) -> Int? =
+  n
+fun sparse() -> List[Int?] =
+  List(1, fail Missing, 3)
 fun noUser() -> User? =
   fail Missing
@@ -72,3 +83,15 @@ test "catch e handles a nullable"
     match e
       Missing => Person(name: "gone", age: 1)
   assert q.name == "gone"
+test "fail Missing is the absent value in an argument, a list element and a default"
+  u := User(name: "w", target: fail Missing)
+  assert {targetName(u) catch "none"} == "none"
+  xs := sparse()
+  assert xs.length() == 3
+  second := xs.get(1)!
+  assert {second catch 9} == 9
+  first := xs.get(0)!
+  assert first! == 1
+  assert {maybeCount() catch 5} == 5
+  assert maybeCount(7)! == 7

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

@@ -6075,6 +6075,19 @@ fn resultBlock(success: &PlumType) -> BlockType {
     }
 }
+/// The absent value of a `T?`: a null reference, or `(zeros, code)`.
+fn emitAbsent(ty: &PlumType, tag: &str, body: &mut Vec<u8>) -> Result<(), String> {
+    if nullableErr(ty).is_some() {
+        Instruction::RefNull(nullableHeapType(ty)).encode(body);
+    } else if let PlumType::TErr(t, _) = ty {
+        if !matches!(**t, PlumType::TUnit) {
+            emitZeros(t, body);
+        }
+        Instruction::I32Const(errCode(tag)?).encode(body);
+    }
+    Ok(())
+}
 /// `return (zeros, code)` for an enclosing `!T` fn, or null for a nullable `T?` fn.
 fn emitErrReturn(
     push_code: &dyn Fn(&mut Vec<u8>) -> Result<(), String>,
@@ -6299,6 +6312,11 @@ fn compileExprCore(
         ast::Expr::Yield(_) => return Err("internal codegen error: yield survived expansion".to_string()),
         ast::Expr::Bang(b) => compileErrBang(expr, b, body, ctx, state)?,
         ast::Expr::Catch(c) => compileErrCatch(expr, c, body, ctx, state)?,
+        ast::Expr::Fail(f) if ctx.types.contains_key(&(expr as *const ast::Expr as usize + plum_checker::ERR_ABSENT)) => {
+            // `fail Missing` in a `T?` slot: the absent value, no early return.
+            let ty = &ctx.types[&(expr as *const ast::Expr as usize + plum_checker::ERR_ABSENT)];
+            emitAbsent(ty, &f.tag, body)?;
+        }
         ast::Expr::Fail(f) => {
             let code = errCode(&f.tag)?;
             emitErrReturn(&|b| { Instruction::I32Const(code).encode(b); Ok(()) }, body, ctx)?
@@ -7245,6 +7263,13 @@ fn compileDefaultArgs(
             )
         })?;
         match sig.decl_params.get(i) {
+            // A `T?` param defaulting to `fail Missing`: the absent value (the
+            // default is a clone, so the checker recorded nothing for it).
+            Some(d) if matches!(default_expr, ast::Expr::Fail(f) if f.tag == "Missing")
+                && matches!(d, PlumType::TErr(_, plum_checker::types::ErrSet::Pinned(n)) if n.len() == 1 && n.contains("Missing")) =>
+            {
+                emitAbsent(d, "Missing", body)?
+            }
             Some(d) => compileExprInto(default_expr, d, body, ctx, state)?,
             None => compileExpr(default_expr, body, ctx, state)?,
         }