d7658cc | plum | pyrossh

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

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

d7658cc — Peter John 2026-11-05T15:11:39+05:30

Language simplification run D2: port std, examples and tests to Option/Result

Files changed (60) hide show

docs/plans/2026-11-05-language-simplification-d2.md +10 -11
docs/plans/2026-11-05-language-simplification-d2.results.md +24 -0
plum-checker/src/lib.rs +43 -3
plum-checker/tests/closure_hint_test.rs +55 -0
plum-checker/tests/question_tests.rs +64 -0
plum-core/src/drive.rs +22 -3
plum-core/src/forms.rs +8 -5
plum-core/tests/for_next_test.rs +10 -7
plum-core/tests/fused_closure_generic_test.rs +28 -0
plum-core/tests/record_init_test.rs +2 -0
plum-core/tests/tail_test.rs +2 -0
plum-examples/errors.plum +323 -281
plum-examples/functional.plum +30 -29
plum-examples/games/functional/game_state_view.plum +6 -2
plum-examples/games/functional/kids/balloon_pop.plum +5 -3
plum-examples/games/imperative/game_loop.plum +2 -1
plum-examples/games/imperative/game_scene.plum +3 -2
plum-examples/games/imperative/scene.plum +8 -7
plum-examples/games/pure/game_pure_scene.plum +4 -3
plum-examples/generics.plum +55 -48
plum-examples/json.plum +16 -14
plum-examples/list_literal_probe.plum +2 -1
plum-examples/match.plum +32 -29
plum-examples/numbers.plum +7 -5
plum-examples/recursion.plum +14 -10
plum-examples/sequences.plum +10 -9
plum-examples/structs_records.plum +33 -31
plum-examples/unions.plum +14 -10
plum-game/web-test/fixtures/stress_pure_scene.plum +3 -2
plum-game/web-test/fixtures/stress_state_view.plum +9 -5
plum-std/Base64.plum +10 -5
plum-std/Bool.plum +12 -7
plum-std/Deque.plum +16 -15
plum-std/Float.plum +9 -7
plum-std/Heap.plum +10 -9
plum-std/Http.plum +26 -16
plum-std/Int.plum +12 -7
plum-std/Json.plum +151 -139
plum-std/List.plum +10 -9
plum-std/Map.plum +8 -7
plum-std/Os.plum +69 -53
plum-std/Pair.plum +3 -2
plum-std/Slice.plum +39 -38
plum-std/Testing.plum +30 -21
plum-std/Uuid.plum +14 -10
plum-std/game/Affine.plum +9 -8
plum-std/game/Input.plum +10 -9
plum-std/game/functional/FunctionalScene.plum +66 -65
plum-std/game/functional/Ui.plum +48 -44
plum-std/game/imperative/Scene.plum +47 -46
plum-std/game/pure/Actions.plum +15 -14
plum-std/game/pure/PureScene.plum +33 -32
plum-std/game/pure/SceneInput.plum +40 -36
plum-wasm-codegen/src/lib.rs +54 -1
plum-wasm-codegen/tests/codegen_tests.rs +51 -17
plum-wasm-codegen/tests/e2e_tail/error_tail.rs +27 -0
plum-wasm-codegen/tests/e2e_tail/tail.rs +2 -2
plum-wasm-codegen/tests/e2e_types/closure_optional.rs +8 -8
plum-wasm-codegen/tests/e2e_types/question.rs +16 -0
plum-wasm-codegen/tests/e2e_types/type_param_static.rs +5 -6

docs/plans/2026-11-05-language-simplification-d2.md CHANGED Viewed

@@ -94,7 +94,7 @@ e.g. `Slice.get(i)` / `List.first()` / `Str.find(..)` return `Option[..]`
 **Tests:** fast
 **Model:** sonnet
 **Consumes:** iterator protocol `next(self) -> Option[Pair[T, Self]]`; `for x := range v` lowers to `while Some(step) := it.next() { .. }` (T1)
-**Produces:** `Base64.decode(s) -> Result[Buffer, Base64Error]`, `Uuid.parse(s) -> Result[Uuid, UuidError]`, Testing helpers on Option
+**Produces:** Testing, Bool, Base64 and Uuid ported (decode/parse return Result with a module error enum)
 **Test code:** `plum test` on the four files green.
 ### T3 Map, Set, Deque, Heap, Grid · Complexity 3 · Est. context 35k
@@ -104,8 +104,7 @@ e.g. `Slice.get(i)` / `List.first()` / `Str.find(..)` return `Option[..]`
 **Tests:** fast
 **Model:** sonnet
 **Consumes:** iterator protocol `next(self) -> Option[Pair[T, Self]]`; `for x := range v` lowers to `while Some(step) := it.next() { .. }` (T1)
-**Produces:** `Map.get(k) -> Option[V]`, `Deque.popFront() -> Option[..]`, `Heap.pop() -> Option[..]`, `Grid.get(x, y) -> Option[T]`
+**Produces:** Map, Set, Deque, Heap and Grid ported (lookups and pops return Option)
-e.g. `Map.empty().with("a", 1).get("a")` -> `Some(1)`; `.get("b")` -> `None`
 **Test code:** `plum test` on the five files green.
 ### T4 game Affine and Input · Complexity 2 · Est. context 25k
@@ -115,7 +114,7 @@ e.g. `Map.empty().with("a", 1).get("a")` -> `Some(1)`; `.get("b")` -> `None`
 **Tests:** fast
 **Model:** sonnet
 **Consumes:** iterator protocol `next(self) -> Option[Pair[T, Self]]`; `for x := range v` lowers to `while Some(step) := it.next() { .. }` (T1)
-**Produces:** `Affine.inverse() -> Option[Affine]`, Input lookups return Option
+**Produces:** game Affine, Input, Vec2, Color and Game ported (lookups return Option)
 **Test code:** `plum test` on the owned files green.
 ### T5 Json · Complexity 5 · Est. context 50k
@@ -124,7 +123,7 @@ e.g. `Map.empty().with("a", 1).get("a")` -> `Some(1)`; `.get("b")` -> `None`
 **LOC owned:** 150
 **Tests:** fast
 **Model:** sonnet
-**Consumes:** `Map.get(k) -> Option[V]`, `Deque.popFront() -> Option[..]`, `Heap.pop() -> Option[..]`, `Grid.get(x, y) -> Option[T]` (T3)
+**Consumes:** Map, Set, Deque, Heap and Grid ported (lookups and pops return Option) (T3)
 **Produces:** `enum JsonError`; `Json.parse(s) -> Result[Json, JsonError]`; decoders `fromJson(j) -> Result[T, JsonError]`; field lookups `-> Option[Json]`
 e.g. `Json.parse("[1,2]")` -> `Ok(JsonArr(..))`; `Json.parse("[1,")` -> `Err(..)` carrying pos/text as today's error does
 **Notes:** keep the JsonParse/Failed shape where tests assert it, or map it into JsonError with the same fields. Generic statics `T.fromJson` keep working (type_param_static).
@@ -136,7 +135,7 @@ e.g. `Json.parse("[1,2]")` -> `Ok(JsonArr(..))`; `Json.parse("[1,")` -> `Err(..)
 **LOC owned:** 100
 **Tests:** fast
 **Model:** sonnet
-**Consumes:** `Base64.decode(s) -> Result[Buffer, Base64Error]`, `Uuid.parse(s) -> Result[Uuid, UuidError]`, Testing helpers on Option (T2)
+**Consumes:** Testing, Bool, Base64 and Uuid ported (decode/parse return Result with a module error enum) (T2)
 **Produces:** `enum IoError` (e.g. `NoSuchPath | ..`); Os fs/env calls `-> Result[T, IoError]` or `Option[T]`
 e.g. `Os.readFile(io, "missing")` -> `Err(NoSuchPath)`
 **Test code:** `plum test` on the owned files green.
@@ -147,7 +146,7 @@ e.g. `Os.readFile(io, "missing")` -> `Err(NoSuchPath)`
 **LOC owned:** 60
 **Tests:** fast
 **Model:** sonnet
-**Consumes:** `Affine.inverse() -> Option[Affine]`, Input lookups return Option (T4)
+**Consumes:** game Affine, Input, Vec2, Color and Game ported (lookups return Option) (T4)
 **Produces:** FunctionalScene lookups (find/hit-test/parent) return `Option[..]`
 **Test code:** `plum test` on the owned files green.
@@ -157,7 +156,7 @@ e.g. `Os.readFile(io, "missing")` -> `Err(NoSuchPath)`
 **LOC owned:** 60
 **Tests:** fast
 **Model:** sonnet
-**Consumes:** `Affine.inverse() -> Option[Affine]`, Input lookups return Option (T4)
+**Consumes:** game Affine, Input, Vec2, Color and Game ported (lookups return Option) (T4)
 **Produces:** Scene `mut parent: Option[Actor]` and lookups returning `Option[Actor]`
 **Notes:** `Some(ship)` into `Option[Actor]` needs the expected type to flow into the argument; if the checker rejects it, log an incident and annotate (`p: Option[Actor] = Some(ship)`).
 **Test code:** `plum test plum-std/game/imperative/Scene.plum` green.
@@ -168,7 +167,7 @@ e.g. `Os.readFile(io, "missing")` -> `Err(NoSuchPath)`
 **LOC owned:** 20
 **Tests:** fast
 **Model:** sonnet
-**Consumes:** `Affine.inverse() -> Option[Affine]`, Input lookups return Option (T4)
+**Consumes:** game Affine, Input, Vec2, Color and Game ported (lookups return Option) (T4)
 **Produces:** Actions lookups return `Option[..]`
 **Test code:** `plum test plum-std/game/pure/Actions.plum` green.
@@ -218,7 +217,7 @@ e.g. `Os.readFile(io, "missing")` -> `Err(NoSuchPath)`
 ### T14 examples: errors.plum · Complexity 4 · Est. context 45k
 **Owns:** plum-examples/errors.plum
 **Components:** 1
-**LOC owned:** 200
+**LOC owned:** 160
 **Tests:** fast
 **Model:** sonnet
 **Consumes:** `enum IoError` (e.g. `NoSuchPath | ..`); Os fs/env calls `-> Result[T, IoError]` or `Option[T]` (T6)
@@ -232,7 +231,7 @@ e.g. `Os.readFile(io, "missing")` -> `Err(NoSuchPath)`
 **LOC owned:** 80
 **Tests:** fast
 **Model:** sonnet
-**Consumes:** `Base64.decode(s) -> Result[Buffer, Base64Error]`, `Uuid.parse(s) -> Result[Uuid, UuidError]`, Testing helpers on Option (T2)
+**Consumes:** Testing, Bool, Base64 and Uuid ported (decode/parse return Result with a module error enum) (T2)
 **Produces:** examples A ported (own `next` fns return `Option[Pair[..]]`)
 **Test code:** `plum test` on the four files green.

docs/plans/2026-11-05-language-simplification-d2.results.md ADDED Viewed

@@ -0,0 +1,24 @@
+# Run D2 results (2026-11-05)
+All of plum-std, plum-examples (incl. games) and the plum-game web-test fixtures use std `Option`/`Result`, postfix `?` and `x!`; no `null`, `catch`, `try`, `?:`, `?.`, `T?`, `E!T`, `error` decls or `error.X` remain in .plum code (grep hits left are the JSON `null` literal and wasm comments). Old syntax still parses; D3 removes it.
+## API shape after the port
+- Iterators: `next(self) -> Option[Pair[T, Self]]`; `for` lowers to `while Some(step) := it.next()`.
+- Single-cause lookups return Option (Slice/List get/first/last/pop, Map.get, Deque/Heap pops, scene hit tests, Affine.invert, Input.position). `Grid.get` stays `T` (no failure path, hot loop).
+- Multi-cause or data-carrying failures return `Result[_, ModError]`, one enum per module with `fun name(self) -> Str`: NumError (Int/Float.parse), BoolError, Base64Error, UuidError, JsonError, IoError (Os fs calls), HttpError. `Json.parse` keeps `Parsed | Failed(pos, text)`.
+- `Map.getOrNull` survives as an alias of `get` (no callers left); D3 deletes it.
+## Compiler fixes found by the port
+- Checker: a fn-ending `if`/`match` branch value was never checked against the return type (any type passed); now "return type mismatch" with "wrap it with Some(..)/Ok(..)" hints.
+- Codegen: `None` as a param default panicked (default exprs are clones without checker types); `x!` crash lost its location — now "unwrap on Err(Variant) at file:line:col".
+- Fusion: closure-specialisation receiver hints were always empty since run C (looked up on a clone; masked while `map` had one candidate) — restored with no compile-time cost; this may explain part of run C's unexplained game slowdown (benchmark item). Exposed `drive::dropDeadParams` dropping the only param that fixed a kept closure's input generic.
+- Fixture stress_state_view.plum still used run-A-removed variadic `List(..)`; rewritten to `[..]`.
+## Sweep
+`cargo build --workspace --tests` clean; all 63 test binaries green (fusion_alloc_test 3/3, codegen_tests 85, e2e_types 48, e2e_tail 33, question_tests 16, checker_tests 48); `plum test plum-std plum-examples` 662 passed, 65/65 files; every web-test fixture compiles.
+## Left for D3
+Tests whose subject is the old syntax (listed in .superlite/progress.md, archived with this run): error_union_tests.rs, parser/formatter old-syntax tests, codegen_tests nullable/catch/inferred-set tests, error_tail error-union twins, checker_tests error-set/null tests, optional_unpinned, types.rs error-union display, simplify/drive error-tag pattern tests.
+## Backlog
+`pos := match ..` as a declaration value doesn't parse; `Link(k, rest) => match ..` single-line nested match arm doesn't parse; single-variant enums are rejected (one-error types become structs); `fun g[T](..)` explicit fn generics (queued).

plum-checker/src/lib.rs CHANGED Viewed

@@ -912,7 +912,7 @@ fn unifyArg(
     actual_expr: &ast::Expr,
     ctx: &CheckCtx,
 ) -> Result<(), String> {
-    unify(expected, actual, ctx)?;
+    unify(expected, actual, ctx).map_err(|e| format!("{}{}", e, wrapHint(expected, actual, ctx)))?;
     if let (PlumType::TNamed(variant_name), PlumType::TNamed(actual_name)) = (expected, actual) {
         if variant_name != actual_name
             && !subtyping::accepts(expected, actual)
@@ -928,6 +928,28 @@ fn unifyArg(
     Ok(())
 }
+/// `: wrap it with Some(..)` / `Ok(..)` when a plain value meets an
+/// `Option[T]` / `Result[T, E]` slot whose success type it fits.
+fn wrapHint(expected: &PlumType, actual: &PlumType, ctx: &CheckCtx) -> &'static str {
+    let (ctor, inner) = match expected {
+        PlumType::TApp(n, xs) if n == "Option" && xs.len() == 1 => ("Some", &xs[0]),
+        PlumType::TApp(n, xs) if n == "Result" && xs.len() == 2 => ("Ok", &xs[0]),
+        _ => return "",
+    };
+    if matches!(actual, PlumType::TApp(n, _) if n == "Option" || n == "Result") {
+        return "";
+    }
+    // Side-effect free: `unify` of two error unions extends the fn's inferred
+    // error set, so that is restored after the probe.
+    let saved = withCheck(|s| s.err_acc.borrow().clone());
+    let fits = unify(inner, actual, ctx).is_ok();
+    withCheck(|s| *s.err_acc.borrow_mut() = saved);
+    if !fits {
+        return "";
+    }
+    if ctor == "Some" { ": wrap it with Some(..)" } else { ": wrap it with Ok(..)" }
+}
 pub fn lookup(env: &TypeEnv, name: &str) -> Result<PlumType, String> {
     env.get(name)
         .map(|s| *s.body.clone())
@@ -1195,7 +1217,13 @@ pub fn typedSourceWith(source: &ast::Source, fusion: FusionOptions) -> CheckResu
         let mut pre = preUnionSource(source);
         // Closure specialisation: copies of callees with the closure argument inlined.
         {
+            // `info` is keyed by the addresses of the program it checked (`lowered`, or
+            // `source` itself), not of the clone `pre`; hints are keyed by call position,
+            // so read them off the checked program and apply them to its twin `pre`.
+            let hints = match info.lowered.clone() {
+                Some(checked) => closureHints(&checked, &info),
-            let hints = closureHints(&pre, &info);
+                None => closureHints(source, &info),
+            };
             let mut copy = pre.clone();
             if !plum_core::closure_spec::specialiseWith(&mut copy, &hints).is_empty()
                 && adoptPre(&copy, &mut result, &mut info)
@@ -3256,7 +3284,19 @@ fn checkStmtInner(
                         }
                     }
                 }
+                // The last value of an `if`/`match` branch is the value of the
+                // enclosing block's tail slot (the fn's return, a catch block).
-                Ok(_) => {}
+                Ok(t) => {
+                    if let Some(want) = &tail {
+                        if let Err(msg) = unifyArg(want, &t, e, ctx) {
+                            errors.push(CheckError::at(
+                                *line,
+                                *column,
+                                format!("fn '{}': return type mismatch: {}", fn_name, msg),
+                            ));
+                        }
+                    }
+                }
             }
         }
         ast::Stmt::Assert(c) => match inferExpr(&c.cond, env, ctx) {

plum-checker/tests/closure_hint_test.rs ADDED Viewed

@@ -0,0 +1,55 @@
+#![allow(non_snake_case)]
+//! Closure specialisation resolves a method call by the receiver's checked type, not
+//! by the method name being unique: `Box.apply` and `Bag.apply` both exist here.
+use plum_checker::{typedSourceWith, FusionOptions};
+use plum_core::ast::{Expr, Item};
+use plum_core::visit::walkRef;
+use plum_test_support::parse;
+const TYPES: &str = "\
+struct Box(v: Int) =
+  fun apply(self, f: fn(Int) -> Int) -> Int = f(self.v)
+struct Bag(v: Int) =
+  fun apply(self, f: fn(Int) -> Int) -> Int = f(self.v) + 1
+fun useBox(b: Box) -> Int = b.apply(|x| x + 1)
+";
+/// Method names `useBox` calls, in the checked (and specialised) program fusion would see.
+fn calledByUse(src: &str) -> Vec<String> {
+    let info = typedSourceWith(&parse(src), FusionOptions { enabled: false, explain: false }).expect("checks");
+    let low = info.lowered.as_ref().expect("closure specialisation adopted a rewrite");
+    let f = low
+        .items
+        .iter()
+        .find_map(|i| match i {
+            Item::Fn(f) if f.name == "useBox" => Some(f),
+            _ => None,
+        })
+        .expect("useBox");
+    let mut out = Vec::new();
+    let plum_core::ast::FnBody::Expr(e) = &f.body else { panic!("expression body") };
+    walkRef(e, &mut |x| {
+        if let Expr::Attribute(a) = x {
+            if let plum_core::ast::AttrKind::Method(c) = &a.attr {
+                out.push(c.name.clone());
+            }
+        }
+    });
+    out
+}
+#[test]
+fn ambiguous_method_name_specialised_by_receiver_type() {
+    let calls = calledByUse(TYPES);
+    assert!(calls.iter().any(|n| n.starts_with("apply$c")), "Box.apply not specialised: {calls:?}");
+}
+#[test]
+fn ambiguous_method_name_specialised_in_lowered_program() {
+    // a `for` loop makes the checker check a lowered copy, as for every std program
+    let src = format!("{TYPES}\nfun count(n: Int) -> Int =\n  s := 0\n  for i := range n\n    s = s + i\n  s\n");
+    let calls = calledByUse(&src);
+    assert!(calls.iter().any(|n| n.starts_with("apply$c")), "Box.apply not specialised: {calls:?}");
+}

plum-checker/tests/question_tests.rs CHANGED Viewed

@@ -109,3 +109,67 @@ fn fn_typed_param_shadows_top_level_fn_arity() {
     // `f(v)` calls the param, not the two-param top-level `fun f`.
     ok("fun f(first: Int, second: Int) -> Int = first + second\n\nfun apply(f: fn(Int) -> Int, v: Int) -> Int = f(v)\n");
 }
+#[test]
+fn bare_value_into_option_return_errors() {
+    rejected("fun f(x: Int) -> Option[Int] = x", "wrap it with Some(..)");
+    rejected("fun f(o: Option[Int]) -> Option[Int] =\n  match o\n    Some(v) => v\n    None => None", "Some(");
+    rejected("fun f(o: Option[Int]) -> Option[Int] =\n  if Some(v) := o\n    return v\n  None", "Some(");
+}
+#[test]
+fn bare_value_into_result_return_errors() {
+    rejected("fun f(x: Int) -> Result[Int, ErrA] = x", "wrap it with Ok(..)");
+}
+#[test]
+fn bare_value_into_option_arg_and_annotation_errors() {
+    rejected("fun g(o: Option[Int]) -> Int = 1\nfun f() -> Int = g(1)", "wrap it with Some(..)");
+    rejected("fun f() -> Int =\n  o: Option[Int] := 1\n  2", "wrap it with Some(..)");
+    rejected("fun f() -> Int =\n  o: Option[Int] := None\n  o = 1\n  2", "wrap it with Some(..)");
+}
+#[test]
+fn bare_value_in_branch_tail_into_option_errors() {
+    // The FunctionalScene `hitKids` shape: a recursive static on a generic enum.
+    rejected(
+        "enum Tree[M] =\n  | Leaf(m: M)\n  | Node(kids: Option[Tree[M]])\n\n  fun first(t: Option[Tree[M]], i: Int) -> Option[Int] = match t\n    None => None\n    Some(x) =>\n      if Some(later) := Tree.first(None, i + 1)\n        later\n      else\n        None\n\nfun g() -> Option[Int] = Tree.first(Some(Leaf(1)), 0)\n",
+        "wrap it with Some(..)",
+    );
+    rejected("fun f(o: Option[Int]) -> Option[Int] =\n  if Some(later) := o\n    later\n  else\n    None", "wrap it with Some(..)");
+    rejected("fun f(o: Option[Int]) -> Option[Int] = match o\n  None => None\n  Some(v) => v", "wrap it with Some(..)");
+    rejected("fun f(x: Int) -> Result[Int, ErrA] =\n  if x > 1\n    x\n  else\n    Err(Other)", "wrap it with Ok(..)");
+    rejected("fun f(x: Int) -> Int =\n  if x > 1\n    true\n  else\n    2", "expected Int, found Bool");
+    ok("fun f(o: Option[Int]) -> Option[Int] =\n  if Some(later) := o\n    Some(later)\n  else\n    None");
+}
+fn errors(body: &str) -> Vec<String> {
+    run(body).err().unwrap_or_default()
+}
+#[test]
+fn wrap_hint_into_generic_option_slot_is_one_error() {
+    let e = errors("fun g(x: T, o: Option[T]) -> Int = 1\nfun f() -> Int = g(1, 2)");
+    assert_eq!(e.len(), 1, "{e:?}");
+    assert!(e[0].contains("wrap it with Some(..)"), "{e:?}");
+    let e = errors("fun h(x: T) -> Option[T] = x\nfun f() -> Int =\n  o := h(1)\n  2");
+    assert_eq!(e.len(), 1, "{e:?}");
+    assert!(e[0].contains("wrap it with Some(..)"), "{e:?}");
+}
+#[test]
+fn non_final_branch_values_are_not_the_return_value() {
+    ok("fun f(x: Int) -> Option[Int] =\n  if x > 1\n    x\n  else\n    2\n  match x\n    1 => 3\n    _ => 4\n  Some(x)");
+    ok("fun f(x: Int) -> Option[Int] =\n  y := 0\n  if x > 1\n    y = x\n    y\n  else\n    0\n  None");
+}
+#[test]
+fn branch_tail_mismatch_reported_once() {
+    let e = errors("fun f(o: Option[Int]) -> Option[Int] =\n  if Some(v) := o\n    v\n  else\n    None");
+    assert_eq!(e.len(), 1, "{e:?}");
+    let e = errors("fun f(o: Option[Int]) -> Option[Int] = match o\n  None => None\n  Some(v) => v");
+    assert_eq!(e.len(), 1, "{e:?}");
+    let e = errors("fun f(x: Int) -> Option[Int] =\n  if x > 1\n    if x > 2\n      x\n    else\n      None\n  else\n    None");
+    assert_eq!(e.len(), 1, "{e:?}");
+}

plum-core/src/drive.rs CHANGED Viewed

@@ -130,6 +130,23 @@ fn ptGens(p: &ParamType, out: &mut HashSet<String>) {
     }
 }
+/// The generics a call argument for a parameter of type `p` fixes (`bound`), and those it
+/// needs fixed elsewhere (`needs`): a fn type's parameter types, which an untyped closure
+/// argument cannot supply. Its result type is inferred from the closure body.
+fn bindingGens(p: &ParamType, bound: &mut HashSet<String>, needs: &mut HashSet<String>) {
+    let (ps, r): (&[Type], Option<&Type>) = match p {
+        ParamType::Fn(ps, r) => (ps, r.as_deref()),
+        ParamType::Type(t) => match t.asFn() {
+            Some((ps, r)) => (ps, Some(r)),
+            None => return collectGens(t, bound),
+        },
+    };
+    ps.iter().for_each(|t| collectGens(t, needs));
+    if let Some(r) = r {
+        collectGens(r, bound);
+    }
+}
 fn unify(a: &Type, b: &Type, map: &mut HashMap<String, Type>) -> Option<()> {
     if a.generics.is_empty() && isGenericName(&a.name) {
         map.insert(a.name.clone(), b.clone());
@@ -546,14 +563,16 @@ impl Driver {
                 }
                 // A generic that only this parameter binds (a closure's result type) and the
                 // return type mentions can no longer be inferred at the call once the
-                // parameter is gone: keep the parameter then.
+                // parameter is gone: keep the parameter then. The same holds for a generic in
+                // the parameter types of a kept fn-typed parameter: an untyped closure
+                // argument (`|t| t.name`) cannot fix its own parameter types.
                 let mut covered = HashSet::new();
+                let mut needed = HashSet::new();
                 for (i, p) in f.params.iter().enumerate() {
                     if !idx.contains(&i) {
-                        ptGens(&p.ty, &mut covered);
+                        bindingGens(&p.ty, &mut covered, &mut needed);
                     }
                 }
-                let mut needed = HashSet::new();
                 if let Some(r) = &f.returns {
                     collectGens(r, &mut needed);
                 }

plum-core/src/forms.rs CHANGED Viewed

@@ -9,8 +9,8 @@
 //! What a loop lowers to depends on the type of its source:
 //!
 //! * `Int`: `i` counts 0, 1, ... n - 1.
-//! * a type with `next(self) -> Pair[T, Self]?`:
+//! * a type with `next(self) -> Option[Pair[T, Self]]`:
-//!   `it := v; while step := it.next() { x := step.first; it = step.second; .. }`.
+//!   `it := v; while Some(step) := it.next() { x := step.first; it = step.second; .. }`.
 //! * anything else: plain iteration over `length()` / `at(i)`, lowered to a
 //!   `while` loop.
 //!
@@ -281,8 +281,8 @@ fn lowerInt(f: ForLoop) -> Vec<Stmt> {
     ]
 }
-/// `for x := range v` over a type with `next(self) -> Pair[T, Self]?`:
+/// `for x := range v` over a type with `next(self) -> Option[Pair[T, Self]]`:
-/// `it := v; while step := it.next() { x := step.first; it = step.second; ... }`.
+/// `it := v; while Some(step) := it.next() { x := step.first; it = step.second; ... }`.
 /// The iterator is rebound before the body, so a `continue` still advances it.
 fn lowerNext(f: ForLoop) -> Vec<Stmt> {
     let id = freshId();
@@ -300,7 +300,10 @@ fn lowerNext(f: ForLoop) -> Vec<Stmt> {
     inner.extend(f.body.stmts);
     let cond = Expr::Bind(Box::new(BindExpr {
         case: Case {
+            patterns: vec![CasePattern::Class {
+                name: "Some".to_string(),
-            patterns: vec![CasePattern::Name(step.clone())],
+                fields: vec![CasePattern::Name(step.clone())],
+            }],
             guard: None,
             body: Block {
                 stmts: vec![Stmt::Expr(Expr::BoolLit(true), f.line, f.column)],

plum-core/tests/for_next_test.rs CHANGED Viewed

@@ -1,7 +1,7 @@
 #![allow(non_snake_case)]
 //! The one loop form `for x := range v`: `v: Int` counts 0..v; any other `v`
-//! whose type has `next(self) -> Pair[T, Self]?` iterates (null = done, else
+//! whose type has `next(self) -> Option[Pair[T, Self]]` iterates (None = done, else
-//! `Pair(value, rest)`, the iterator rebound to `rest` each step).
+//! `Some(Pair(value, rest))`, the iterator rebound to `rest` each step).
 use plum_test_support::runInt;
 #[test]
@@ -40,13 +40,14 @@ fn list_next_steps() {
 import std/Int
 import std/List
 import std/Pair
+import std/Option
 fun main() -> Int =
   xs := [5, 6]
   p := xs.next()!
   q := p.second.next()!
   r := q.second.next()
-  p.first * 100 + q.first * 10 + {if r == null then 1 else 0}
+  p.first * 100 + q.first * 10 + {if r.isNone() then 1 else 0}
 ";
     assert_eq!(runInt("for_next_list_next", src), 561);
 }
@@ -56,10 +57,11 @@ fn range_user_struct_with_next() {
     let src = "\
 import std/Int
 import std/Pair
+import std/Option
 struct Countdown(n: Int) =
-  fun next(self) -> Pair[Int, Countdown]? =
+  fun next(self) -> Option[Pair[Int, Countdown]] =
-    if self.n == 0 then null else Pair(first: self.n, second: Countdown(n: self.n - 1))
+    if self.n == 0 then None else Some(Pair(first: self.n, second: Countdown(n: self.n - 1)))
 fun main() -> Int =
   acc := 0
@@ -75,10 +77,11 @@ fn range_next_supports_continue_and_break() {
     let src = "\
 import std/Int
 import std/Pair
+import std/Option
 struct Up(i: Int, n: Int) =
-  fun next(self) -> Pair[Int, Up]? =
+  fun next(self) -> Option[Pair[Int, Up]] =
-    if self.i >= self.n then null else Pair(first: self.i, second: Up(i: self.i + 1, n: self.n))
+    if self.i >= self.n then None else Some(Pair(first: self.i, second: Up(i: self.i + 1, n: self.n)))
 fun main() -> Int =
   acc := 0

plum-core/tests/fused_closure_generic_test.rs ADDED Viewed

@@ -0,0 +1,28 @@
+#![allow(non_snake_case)]
+//! A fused fn keeps a specialised-away closure parameter when it is the only thing that
+//! fixes a generic another kept closure parameter takes as its input: `map(andThen(..))`
+//! on `Option` fuses to `map$c0$andThen$c0$0(|t| t.name, u)`, whose `|t| ..` needs the
+//! `B` that only `andThen`'s closure binds. Dropping it left the fused fn uninstantiable
+//! ("unknown function" at codegen).
+use plum_test_support::runInt;
+#[test]
+fn option_and_then_then_map_compiles_and_runs() {
+    let src = "\
+import std/Str
+import std/Int
+import std/Option
+struct Target(size: Int)
+struct User(name: Str, target: Option[Target])
+fun targetSize(u: Option[User]) -> Option[Int] =
+  u.andThen(|v| v.target).map(|t| t.size)
+fun main() -> Int =
+  full := User(name: \"u\", target: Some(Target(size: 40)))
+  none: Option[User] := None
+  targetSize(Some(full)).unwrapOr(0) + targetSize(none).unwrapOr(2)
+";
+    assert_eq!(runInt("fused_closure_generic", src), 42);
+}

plum-core/tests/record_init_test.rs CHANGED Viewed

@@ -117,6 +117,8 @@ fn init_with_params_rejected() {
 fn annotate_error_and_annotation() {
     let (_, e) = lower("struct Rec(a: Int) =\n  fun init(self) =\n    self.t = null\n");
     assert!(e.iter().any(|m| m.starts_with("annotate the type: self.t: T = ...")), "{e:?}");
+    let (_, e) = lower("struct Rec(a: Int) =\n  fun init(self) =\n    self.t: Option[Int] = None\n");
+    assert!(e.is_empty(), "{e:?}");
     let (s, e) = lower("struct Rec(a: Int) =\n  fun init(self) =\n    self.t: Int? = null\n    self.l = Slice[Int]()\n    self.s = \"x\"\n    self.b = true\n");
     assert!(e.is_empty(), "{e:?}");
     let v = &enumOf(&s, "Rec").variants[0];

plum-core/tests/tail_test.rs CHANGED Viewed

@@ -59,6 +59,8 @@ fn not_tail_as_argument() {
 fn not_tail_inside_try() {
     let src = "fun f(n: Int) -> !Int =\n  try g(n)\n";
     assert_eq!(sites(src, "f"), vec![]);
+    let src = "fun f(n: Int) -> Result[Int, Str] =\n  g(n)?\n";
+    assert_eq!(sites(src, "f"), vec![]);
     let src = "fun f(n: Int) -> Int =\n  g(n)!\n";
     assert_eq!(sites(src, "f"), vec![]);
 }

plum-examples/errors.plum CHANGED Viewed

@@ -1,107 +1,140 @@
-# Errors and optionals: error propagation and T?.
+# Errors and absence: `Option[T]`, `Result[T, E]`, postfix `?` and `x!`.
 import std/Int
 import std/Float
 import std/Str
 import std/Slice
 import std/Map
 import std/List
+import std/Option
+import std/Result
-# ==== error propagation ====
+# ==== Result: a value or an error ====
-# `!T` is "a `T` or an error". An error is a value written `error.Name` (for
+# `Result[T, E]` is `Ok(value)` or `Err(err)`. A failure is an ordinary value of
-# example `return error.NegativeNum`): it needs no declaration and carries no
-# data. A function's error set is inferred from its body (every error value it
-# returns, plus the sets of the calls it propagates with `try`), or pinned in
-# front of the `!`: `error{A, B}!T` inline, `ParseError!T` for a set declared
+# an ordinary type `E`: usually one enum per module whose cases name what can go
-# with `error ParseError = A | B`, or `(A || B)!T` to merge sets. Pin the set on
+# wrong (`NumError` in std/Int, `IoError` in std/Os, `JsonError` in std/Json).
-# a public API, on a recursive function and on an `extern fun`. There is no
+# Nothing is implicit: a success is written `Ok(n)`, a failure `Err(Case)`.
-# `Option`: an optional `T?` (see optionals.plum) is not an error.
 #
-# A plain `T` (a tail value or `return n`) is the success value; an error value
-# (`return error.X`) is the failure. A bare name is never an implicit failure.
-#
-# `try expr` unwraps the success value, or returns the error from the enclosing
+# `r?` unwraps the `Ok` value, or returns the `Err` from the enclosing function
+# (which must itself return a `Result` with the same error type). `r!` unwraps
+# the value or crashes. `r.unwrapOr(d)` falls back to `d`. `r.map(f)` changes the
-# function. The sets of different calls merge automatically, so `try Int.parse(s)`
+# success value, `r.andThen(f)` chains a step that can fail, and `r.mapErr(f)`
-# (`[BadNumStr]`) and `try xs.get(i)` (`[OutOfBounds]`) can share one function.
-#
-# `expr!` unwraps the success value, or crashes with a message naming the
-# callee, the error and the source position.
-#
-# `expr catch default` is the plain-expression counterpart: no early return,
-# `default` is used on any error. The default may diverge, Zig-style:
-# `Int.parse(s) catch return error.InvalidInput` returns that error from the function.
+# changes the error type, which is how errors cross module boundaries.
-# `expr catch e` plus an indented block binds `e` to the error name; `match e`
-# is exhaustive over the exact set and `e.name()` is its text.
 #
 # `crash "msg"` aborts the program with a message; use it for bugs, not for
 # expected failures.
+# What can go wrong with a positive number.
-fun parsePositive(s: Str) -> !Int =
+enum PositiveError =
-  n := try Int.parse(s)
-  if n < 0
+  | BadNumber
-    return error.NegativeNum
+  | NegativeNum
-  return n
-fun sumTwo(a: Str, b: Str) -> !Int =
+  fun name(self) -> Str = match self
+    BadNumber => "BadNumber"
-  x := try parsePositive(a)
+    NegativeNum => "NegativeNum"
-  y := try parsePositive(b)
-  x + y
+# `Int.parse` fails with std/Int's `NumError`; `mapErr` turns it into ours.
+fun parsePositive(s: Str) -> Result[Int, PositiveError] =
+  n := Int.parse(s).mapErr(|e| BadNumber)?
+  if n < 0
+    return Err(NegativeNum)
+  Ok(n)
+# `?` returns the first error on the way out and skips the rest of the function.
+fun sumTwo(a: Str, b: Str) -> Result[Int, PositiveError] =
+  x := parsePositive(a)?
+  y := parsePositive(b)?
+  Ok(x + y)
-# Two calls with different error sets merge into [BadNumStr, OutOfBounds].
+# Two sources of failure with different types share one error enum.
+enum NumAtError =
+  | BadDigits
+  | OutOfRange
+  fun name(self) -> Str = match self
+    BadDigits => "BadDigits"
+    OutOfRange => "OutOfRange"
+# `okOr` turns an `Option` into a `Result` by naming the error for `None`.
-fun numAt(s: Str, i: Int) -> error{BadNumStr, OutOfBounds}!Int =
+fun numAt(s: Str, i: Int) -> Result[Int, NumAtError] =
-  n := try Int.parse(s)
+  n := Int.parse(s).mapErr(|e| BadDigits)?
   xs := [10, 20, 30].toSlice()
-  x := try xs.get(i)
+  x := xs.get(i).okOr(OutOfRange)?
-  n + x
+  Ok(n + x)
-# `catch return error.X` returns that error on the way out.
-fun parseOrInvalid(s: Str) -> error{InvalidInput}!Int =
+fun numAtCode(s: Str, i: Int) -> Int = match numAt(s, i)
+  Ok(v) => v
+  Err(BadDigits) => 100
-  n := Int.parse(s) catch return error.InvalidInput
+  Err(OutOfRange) => 200
-  n
+enum InputError =
+  | InvalidInput
+  | Other
+  fun name(self) -> Str = match self
+    InvalidInput => "InvalidInput"
+    Other => "Other"
+# `mapErr` maps the error to another one.
+fun parseOrInvalid(s: Str) -> Result[Int, InputError] =
+  Int.parse(s).mapErr(|e| InvalidInput)
+# `?` on an `Option` returns `None`; the function returns an `Option`.
-fun doubledFirst(list: Slice[Int]) -> error{ListWasEmpty}!Int =
+fun doubledFirst(list: Slice[Int]) -> Option[Int] =
-  a := try list.first()
+  a := list.first()?
-  a * 2
+  Some(a * 2)
 fun sumOrZero(a: Str, b: Str) -> Int =
-  x := {parsePositive(a) catch 0}
+  x := parsePositive(a).unwrapOr(0)
-  y := {parsePositive(b) catch 0}
+  y := parsePositive(b).unwrapOr(0)
   x + y
 fun firstOrDefault(list: Slice[Int], default: Int) -> Int =
-  {list.first() catch default}
+  list.first().unwrapOr(default)
 fun mustBePositive(n: Int) -> Int =
   if n < 0
     crash "n must not be negative"
   n
-# `try` is a prefix operator at unary precedence: `n * try f()` is `n * {try f()}`.
+# `?` is a postfix operator: `n * f()?` is `n * {f()?}`.
-fun scaled(n: Int, s: Str) -> error{BadNumStr}!Int =
+fun scaled(n: Int, s: Str) -> Result[Int, NumError] =
-  n * try Int.parse(s)
+  Ok(n * Int.parse(s)?)
+# Mapping and chaining without leaving the Result.
+fun doubledPositive(s: Str) -> Result[Int, PositiveError] =
+  parsePositive(s).map(|n| n * 2)
+fun halfOfPositive(s: Str) -> Result[Int, PositiveError] =
+  parsePositive(s).andThen(|n| if n % 2 == 0 then Ok(n / 2) else Err(BadNumber))
+enum AgeError =
+  | NotANumber
+  | Negative
+  | TooOld
+  fun name(self) -> Str = match self
+    NotANumber => "NotANumber"
+    Negative => "Negative"
+    TooOld => "TooOld"
-fun parseAge(s: Str) -> !Int =
+fun parseAge(s: Str) -> Result[Int, AgeError] =
-  n := try Int.parse(s)
+  n := Int.parse(s).mapErr(|e| NotANumber)?
   if n < 0
-    return error.Negative
+    return Err(Negative)
   if n > 150
-    return error.TooOld
+    return Err(TooOld)
-  n
+  Ok(n)
-# Handling errors with `catch e`: `match e` needs one arm per name in the set
+# Handling errors with `match`: one arm per case (or `_`), and every arm
-# (or `_`), and the block must produce the success type or diverge.
+# produces the same type.
-fun describeAge(s: Str) -> Str =
+fun describeAge(s: Str) -> Str = match parseAge(s)
-  n := parseAge(s) catch e
+  Ok(n) => "age {n}"
-    match e
-      BadNumStr =>
-        return "not a number"
+  Err(NotANumber) => "not a number"
-      Negative =>
-        return "can't be negative"
+  Err(Negative) => "can't be negative"
-      TooOld =>
-        return "too old"
+  Err(TooOld) => "too old"
-  "age {n}"
-# A plain list of cases is an ordinary enum.
+# A plain list of cases is an ordinary enum; a case can carry data.
 enum Failure = Timeout | Refused | BadRequest(v: Str)
 fun isRetryable(f: Failure) -> Bool =
@@ -111,113 +144,115 @@ fun isRetryable(f: Failure) -> Bool =
     BadRequest(_) => false
 # `_` catches whatever the earlier arms didn't.
-fun ageOrDefault(s: Str) -> Int =
+fun ageOrDefault(s: Str) -> Int = match parseAge(s)
-  parseAge(s) catch e
+  Ok(n) => n
-    match e
-      TooOld => 150
+  Err(TooOld) => 150
-      _ => 0
+  Err(_) => 0
-# `e.name()` is the error's text.
+# `e.name()` is the error's text, when the error enum defines it.
-fun errorText(s: Str) -> Str =
+fun errorText(s: Str) -> Str = match parseAge(s)
-  parseAge(s) catch e
-    return e.name()
-  "none"
+  Ok(_) => "none"
+  Err(e) => e.name()
+# An error can be any type, including a struct that carries data.
+struct Neg(value: Int)
-fun checkNonNeg(n: Int) -> error{Neg}!Unit =
+fun checkNonNeg(n: Int) -> Result[Unit, Neg] =
   if n < 0
-    return error.Neg
+    return Err(Neg(value: n))
+  Ok(Unit)
-fun passCheck(n: Int) -> error{Neg}!Unit =
+fun passCheck(n: Int) -> Result[Unit, Neg] =
-  try checkNonNeg(n)
+  checkNonNeg(n)
-fun runChecked(n: Int) -> error{Neg}!Int =
+fun runChecked(n: Int) -> Result[Int, Neg] =
-  try checkNonNeg(n)
+  checkNonNeg(n)?
-  n
+  Ok(n)
-fun negOrSeven(n: Int) -> error{Neg}!Int =
+fun negOrSeven(n: Int) -> Result[Int, Neg] =
   if n < 0
-    return error.Neg
+    return Err(Neg(value: n))
-  n
+  Ok(n)
-fun lookup(m: Map[Int, error{Neg}!Int]) -> Int =
+fun lookup(m: Map[Int, Result[Int, Neg]]) -> Int =
-  v := m.get(1) catch negOrSeven(-1)
+  v := m.get(1).unwrapOr(negOrSeven(-1))
-  v catch 0
+  v.unwrapOr(0)
-# `try` on a type parameter's static method, bound with `:=` inside a loop: the
+# `?` on a type parameter's static method, bound with `:=` inside a loop: the
-# operand's type is `T`, so it is checked per instantiation (here `T = Age`).
+# operand's type is `Result[T, _]`, so it is checked per instantiation (here
+# `T = Age`).
 struct Age(n: Int) =
-  fun parse(s: Str) -> !Age =
+  fun parse(s: Str) -> Result[Age, PositiveError] =
-    n := try parsePositive(s)
+    n := parsePositive(s)?
-    return Age(n)
+    return Ok(Age(n))
 struct Ages[T](items: Slice[T]) =
-  fun parseAll(xs: Slice[Str]) -> !Ages[T] =
+  fun parseAll(xs: Slice[Str]) -> Result[Ages[T], PositiveError] =
     out := Slice[T]()
     for x := range xs
-      v := try T.parse(x)
+      v := T.parse(x)?
       out.push(v)
-    return Ages(out)
+    return Ok(Ages(out))
-fun parseAges(xs: Slice[Str]) -> !Ages[Age] = Ages.parseAll(xs)
+fun parseAges(xs: Slice[Str]) -> Result[Ages[Age], PositiveError] = Ages.parseAll(xs)
-# ==== optionals ====
+# ==== Option: a value or nothing ====
-# Optionals: `T?` is a `T` or `null`. A plain `T` in a `T?` slot is the present
+# `Option[T]` is `Some(value)` or `None`. A present value is always written
-# value. An optional is handled with `?:` (Kotlin elvis), `if x := opt`,
+# `Some(v)`. An option is handled with `unwrapOr(d)`, `if Some(x) := opt`,
-# `while x := opt`, `opt!` (crashes on null) and `opt == null`; `catch` and `try`
+# `while Some(x) := opt`, `opt!` (crashes on `None`), `isSome()` and `isNone()`
-# are for errors only. `!T?` is an error union whose success value is an optional.
+# (`==` on an Option is an error: it would compare identity, not contents).
 #
-# `obj?.field` / `obj?.method(args)` is safe navigation: it reaches into an
+# `opt.map(f)` reaches into an option without unwrapping it and passes `None`
+# through; `opt.andThen(f)` does the same for a step that itself returns an
-# optional without unwrapping it and passes null through. A field that is itself
+# option, so a chain of fields is `u.andThen(|v| v.target).map(|t| t.name)`.
-# a `T?` flattens, so `u?.target?.name` is one `Str?`. It is sugar for
-# `obj.andThen(|v| v.field)`.
 struct Box(label: Str)
-struct Holder(mut item: Box?, mut count: Int?)
+struct Holder(mut item: Option[Box], mut count: Option[Int])
-fun maybeBox(c: Bool) -> Box? =
+fun maybeBox(c: Bool) -> Option[Box] =
   if c
-    return Box(label: "in")
+    return Some(Box(label: "in"))
-  return null
+  return None
-fun maybeInt(c: Bool) -> Int? =
+fun maybeInt(c: Bool) -> Option[Int] =
   if c
-    return 7
+    return Some(7)
-  null
+  None
-fun orFive(n: Int? = null) -> Int =
+fun orFive(n: Option[Int] = None) -> Int =
-  n ?: 5
+  n.unwrapOr(5)
+# `okOr` names the error for `None`; `?` then propagates it.
-fun failOnNull(c: Bool) -> error{Absent}!Int =
+fun failOnNone(c: Bool) -> Result[Int, Str] =
-  n := maybeInt(c) ?: return error.Absent
+  n := maybeInt(c).okOr("absent")?
-  n + 1
+  Ok(n + 1)
-fun nullOnNull(c: Bool) -> Int? =
+fun noneOnNone(c: Bool) -> Option[Int] =
-  n := maybeInt(c) ?: return null
+  n := maybeInt(c)?
-  n * 2
+  Some(n * 2)
-fun chainDefault(a: Int?, b: Int?) -> Int =
+fun chainDefault(a: Option[Int], b: Option[Int]) -> Int =
-  a ?: b ?: 99
+  a.unwrapOr(b.unwrapOr(99))
+# A Result whose success value is an Option.
-fun fallible(n: Int) -> error{Bad}!Int? =
+fun fallible(n: Int) -> Result[Option[Int], Str] =
   if n < 0
-    return error.Bad
+    return Err("bad")
   if n == 0
-    return null
+    return Ok(None)
-  n
+  Ok(Some(n))
-fun viaTry(n: Int) -> error{Bad}!Int =
+fun viaQuestion(n: Int) -> Result[Int, Str] =
-  v := try fallible(n)
+  v := fallible(n)?
-  v ?: -1
+  Ok(v.unwrapOr(-1))
-fun nextItem(items: Slice[Int], i: Int) -> Int? =
+fun nextItem(items: Slice[Int], i: Int) -> Option[Int] =
-  if i < items.length()
-    return items.get(i)!
+  items.get(i)
-  null
-fun sparse() -> Slice[Int?] =
+fun sparse() -> Slice[Option[Int]] =
-  xs: List[Int?] := [1, null, 3]
+  xs: List[Option[Int]] := [Some(1), None, Some(3)]
   xs.toSlice()
 fun sumBig() -> Int =
@@ -230,76 +265,74 @@ struct Person(name: Str, age: Int) =
 struct Target(name: Str)
-struct User(name: Str, target: Target?)
+struct User(name: Str, target: Option[Target])
-fun personName(p: Person?) -> Str? =
+fun personName(p: Option[Person]) -> Option[Str] =
-  p?.name
+  p.map(|v| v.name)
-fun personBirthday(p: Person?) -> Int? =
+fun personBirthday(p: Option[Person]) -> Option[Int] =
-  p?.birthday()
+  p.map(|v| v.birthday())
-fun somePerson() -> Person? =
+fun somePerson() -> Option[Person] =
-  Person(name: "Ann", age: 3)
+  Some(Person(name: "Ann", age: 3))
-fun noPerson() -> Person? =
+fun noPerson() -> Option[Person] =
-  return null
+  return None
-fun noTarget() -> Target? =
+fun noTarget() -> Option[Target] =
-  return null
+  return None
-fun maybeCount(n: Int? = null) -> Int? =
+fun maybeCount(n: Option[Int] = None) -> Option[Int] =
   n
-fun noUser() -> User? =
+fun noUser() -> Option[User] =
-  return null
+  return None
-fun targetName(u: User?) -> Str? =
+fun targetName(u: Option[User]) -> Option[Str] =
-  u?.target?.name
+  u.andThen(|v| v.target).map(|t| t.name)
-# ==== error propagation tests ====
+# ==== Result tests ====
-test "try operator unwraps the value and propagates it through two calls"
+test "question mark unwraps the value and propagates it through two calls"
   assert sumTwo("2", "3")! == 5
-test "try operator exits early with the error, skipping the rest of the function"
+test "question mark exits early with the error, skipping the rest of the function"
-  assert {sumTwo("2", "-3") catch -1} == -1
+  assert sumTwo("2", "-3").unwrapOr(-1) == -1
   assert errorText("-3") == "Negative"
-test "try operator merges two different error sets"
+test "an Option and a Result with different error types share one error enum"
   assert numAt("5", 1)! == 25
-  assert {numAt("x", 1) catch -1} == -1
+  assert numAt("x", 1).unwrapOr(-1) == -1
-  assert {numAt("5", 9) catch -2} == -2
+  assert numAt("5", 9).unwrapOr(-2) == -2
-  r2 := numAt("5", 9) catch e
+  assert numAtCode("5", 9) == 200
-    match e
-      BadNumStr => 100
-      OutOfBounds => 200
-  assert r2 == 200
+  assert numAtCode("x", 1) == 100
+  assert numAtCode("5", 0) == 15
-test "catch return error.X maps the error to another name"
+test "mapErr maps the error to another type"
   assert parseOrInvalid("7")! == 7
-  name := parseOrInvalid("x") catch e
+  if Err(e) := parseOrInvalid("x")
     assert e.name() == "InvalidInput"
-    0
+  else
-  assert name == 0
+    assert false
-test "try binds a declaration from a type parameter's static method in a loop"
+test "question mark binds a declaration from a type parameter's static method in a loop"
   ages := parseAges(["3", "4"].toSlice())!
   assert ages.items.length() == 2
   assert ages.items.get(1)!.n == 4
-  failed := parseAges(["3", "-1"].toSlice()) catch e
+  if Err(e) := parseAges(["3", "-1"].toSlice())
     assert e.name() == "NegativeNum"
-    Ages(Slice[Age]())
+  else
-  assert failed.items.length() == 0
+    assert false
-test "try operator on a list that is empty yields ListWasEmpty"
+test "question mark on an empty list yields None"
   assert doubledFirst([5].toSlice())! == 10
-  assert {doubledFirst(Slice[Int]()) catch -1} == -1
+  assert doubledFirst(Slice[Int]()).unwrapOr(-1) == -1
-test "catch default unwraps the value and falls back to 0 on an error"
+test "unwrapOr falls back to 0 on an error"
   assert sumOrZero("2", "3") == 5
   assert sumOrZero("2", "-3") == 2
-test "catch default falls back to the given default on an empty list"
+test "unwrapOr falls back to the given default on an empty list"
   assert firstOrDefault([5].toSlice(), 99) == 5
   assert firstOrDefault(Slice[Int](), 99) == 99
@@ -310,7 +343,14 @@ test "bang unwraps a success value"
   assert parseAge("30")! == 30
   assert scaled(2, "21")! == 42
+test "map and andThen transform a success and leave an error alone"
+  assert doubledPositive("4")! == 8
+  assert doubledPositive("-4").unwrapOr(0) == 0
+  assert halfOfPositive("8")! == 4
+  assert halfOfPositive("7").unwrapOr(-1) == -1
+  assert halfOfPositive("x").unwrapOr(-2) == -2
-test "catch e handles each error name in its own arm"
+test "match handles each error case in its own arm"
   assert describeAge("42") == "age 42"
   assert describeAge("abc") == "not a number"
   assert describeAge("-3") == "can't be negative"
@@ -326,115 +366,117 @@ test "match falls back to a wildcard arm"
   assert ageOrDefault("999") == 150
   assert ageOrDefault("x") == 0
-# An error union can be the success type of another (a `Slice[!Int]` holds
+# A Result can be the element of a collection: `xs.get(i)` is an
-# per-element results): `xs.get(i)` is `!!Int`, unwrapped one level at a time.
+# `Option[Result[Int, E]]`, unwrapped one level at a time.
-test "a list of error unions nests one level per access"
+test "a list of results nests one level per access"
   results := [parsePositive("1"), parsePositive("-1"), parsePositive("x")].toSlice()
   first := results.get(0)!
   assert first! == 1
   second := results.get(1)!
-  assert {second catch 0} == 0
+  assert second.unwrapOr(0) == 0
-  fallback := {results.get(9) catch parsePositive("5")}
+  fallback := results.get(9).unwrapOr(parsePositive("5"))
-  assert {fallback catch 0} == 5
+  assert fallback.unwrapOr(0) == 5
-test "a Unit error union propagates with try and is handled with catch"
+test "a Unit result propagates with question mark and is handled with if Err"
-  assert {runChecked(4) catch 0} == 4
+  assert runChecked(4).unwrapOr(0) == 4
-  assert {runChecked(-1) catch 5} == 5
+  assert runChecked(-1).unwrapOr(5) == 5
   hits := 0
-  passCheck(1) catch e
+  if Err(e) := passCheck(1)
     hits = hits + 1
+  if Err(e) := passCheck(-1)
-  passCheck(-1) catch e
+    assert e.value == -1
     hits = hits + 10
   assert hits == 10
-test "a Map can hold error unions as values"
+test "a Map can hold results as values"
-  m: Map[Int, error{Neg}!Int] := Map.empty()
+  m: Map[Int, Result[Int, Neg]] := Map.empty()
   m.set(1, negOrSeven(7))
   assert lookup(m) == 7
   m.set(1, negOrSeven(-2))
   assert lookup(m) == 0
-# ==== optionals tests ====
+# ==== Option tests ====
-test "null_return_absent"
+test "none_return_absent"
-  assert maybeBox(false) == null
+  assert maybeBox(false).isNone()
-  assert maybeBox(true) != null
+  assert maybeBox(true).isSome()
-  assert maybeInt(false) == null
+  assert maybeInt(false).isNone()
-  assert null != maybeInt(true)
+  assert maybeInt(true).isSome()
-test "null_field_and_arg"
+test "none_field_and_arg"
-  h := Holder(item: null, count: null)
+  h := Holder(item: None, count: None)
-  assert h.item == null
+  assert h.item.isNone()
-  assert h.count == null
+  assert h.count.isNone()
-  h2 := Holder(item: Box(label: "x"), count: 3)
+  h2 := Holder(item: Some(Box(label: "x")), count: Some(3))
   assert h2.count! == 3
-  assert orFive(null) == 5
-  assert orFive(8) == 8
+  assert orFive() == 5
+  assert orFive(None) == 5
+  assert orFive(Some(8)) == 8
   xs := sparse()
   assert xs.length() == 3
-test "elvis_default"
+test "unwrapOr_default"
-  assert {maybeInt(false) ?: 4} == 4
+  assert maybeInt(false).unwrapOr(4) == 4
-  assert {maybeInt(true) ?: 4} == 7
+  assert maybeInt(true).unwrapOr(4) == 7
-  assert {maybeBox(false)?.label ?: "none"} == "none"
+  assert maybeBox(false).map(|b| b.label).unwrapOr("none") == "none"
-  assert {maybeBox(true)?.label ?: "none"} == "in"
+  assert maybeBox(true).map(|b| b.label).unwrapOr("none") == "in"
-test "elvis_return_error"
+test "okOr_turns_none_into_an_error"
-  assert {failOnNull(true) catch 0} == 8
+  assert failOnNone(true).unwrapOr(0) == 8
-  assert {failOnNull(false) catch 0} == 0
+  assert failOnNone(false).unwrapOr(0) == 0
-test "elvis_return_null"
+test "question_mark_returns_none"
-  assert nullOnNull(true)! == 14
+  assert noneOnNone(true)! == 14
-  assert nullOnNull(false) == null
+  assert noneOnNone(false).isNone()
-test "elvis_chain_right_assoc"
+test "unwrapOr_chain"
-  assert chainDefault(null, null) == 99
+  assert chainDefault(None, None) == 99
-  assert chainDefault(null, 2) == 2
+  assert chainDefault(None, Some(2)) == 2
-  assert chainDefault(1, 2) == 1
+  assert chainDefault(Some(1), Some(2)) == 1
-test "if_bind_optional"
+test "if_bind_option"
   r := 0
-  if x := maybeInt(true)
+  if Some(x) := maybeInt(true)
     r = x
   else
     r = -1
   assert r == 7
-  if y := maybeInt(false)
+  if Some(y) := maybeInt(false)
     r = y
   else
     r = -1
   assert r == -1
-  assert {if v := maybeInt(true) then v + 1 else 0} == 8
+  assert {if Some(v) := maybeInt(true) then v + 1 else 0} == 8
-  assert {if w := maybeInt(false) then w + 1 else 0} == 0
+  assert {if Some(w) := maybeInt(false) then w + 1 else 0} == 0
-  if b := maybeBox(true)
+  if Some(b) := maybeBox(true)
     assert b.label == "in"
-test "while_bind_optional"
+test "while_bind_option"
   items := [3, 2, 1].toSlice()
   total := 0
   i := 0
-  while v := nextItem(items, i)
+  while Some(v) := nextItem(items, i)
     total = total + v
     i = i + 1
   assert total == 6
-test "safe_nav_optional_flattens"
+test "map_over_option_flattens_with_andThen"
-  assert maybeBox(true)?.label! == "in"
+  assert maybeBox(true).map(|b| b.label)! == "in"
-  assert maybeBox(false)?.label == null
+  assert maybeBox(false).map(|b| b.label).isNone()
-test "null_eq_ref and null_eq_int"
+test "isNone_and_isSome"
   b := maybeBox(false)
-  assert b == null
+  assert b.isNone()
   n := maybeInt(true)
+  assert n.isSome()
-  assert n != null
+  assert !n.isNone()
-  assert !{n == null}
-test "error_union_of_optional"
+test "result_of_option"
-  assert {viaTry(5) catch 0} == 5
+  assert viaQuestion(5).unwrapOr(0) == 5
-  assert {viaTry(0) catch 0} == -1
+  assert viaQuestion(0).unwrapOr(0) == -1
-  assert {viaTry(-3) catch 100} == 100
+  assert viaQuestion(-3).unwrapOr(100) == 100
   x := fallible(0)!
-  assert x == null
+  assert x.isNone()
   y := fallible(4)!
   assert y! == 4
@@ -442,52 +484,52 @@ test "int_min_literal"
   assert Int.Min == -0x8000_0000_0000_0000
   assert sumBig() == -1
-test "reassigning an optional local or field to null or a value"
+test "reassigning an option local or field to None or a value"
   o := maybeInt(true)
-  o = null
+  o = None
-  assert o == null
+  assert o.isNone()
-  o = 4
+  o = Some(4)
   assert o! == 4
   b := maybeBox(true)
-  b = null
+  b = None
-  assert b == null
+  assert b.isNone()
-  h := Holder(item: Box(label: "x"), count: 2)
+  h := Holder(item: Some(Box(label: "x")), count: Some(2))
-  h.count = null
+  h.count = None
-  h.item = null
+  h.item = None
-  assert h.count == null
+  assert h.count.isNone()
-  assert h.item == null
+  assert h.item.isNone()
-  h.count = 5
+  h.count = Some(5)
-  h.item = Box(label: "y")
+  h.item = Some(Box(label: "y"))
   assert h.count! == 5
   assert h.item!.label == "y"
-test "safe navigation maps a field access over a present value, passes absence through"
+test "map over an option maps a field access over a present value, passes absence through"
   assert personName(somePerson())! == "Ann"
-  assert {personName(noPerson()) ?: "gone"} == "gone"
+  assert personName(noPerson()).unwrapOr("gone") == "gone"
-test "safe navigation maps a method call over a present value"
+test "map over an option maps a method call over a present value"
   assert personBirthday(somePerson())! == 4
-  assert {personBirthday(noPerson()) ?: -1} == -1
+  assert personBirthday(noPerson()).unwrapOr(-1) == -1
-test "safe navigation chains through a nullable field"
+test "andThen chains through an optional field"
-  full := User(name: "u", target: Target(name: "home"))
+  full := User(name: "u", target: Some(Target(name: "home")))
-  assert {targetName(full) ?: "none"} == "home"
+  assert targetName(Some(full)).unwrapOr("none") == "home"
-  assert {targetName(User(name: "v", target: noTarget())) ?: "none"} == "none"
+  assert targetName(Some(User(name: "v", target: noTarget()))).unwrapOr("none") == "none"
-  assert {targetName(noUser()) ?: "none"} == "none"
+  assert targetName(noUser()).unwrapOr("none") == "none"
-test "?: handles a nullable with a diverging or computed default"
+test "unwrapOr and bang handle a present or computed default"
-  p := somePerson() ?: crash "missing"
+  p := somePerson()!
   assert p.age == 3
-  q := noPerson() ?: Person(name: "gone", age: 1)
+  q := noPerson().unwrapOr(Person(name: "gone", age: 1))
   assert q.name == "gone"
-test "null is the absent value in an argument, a list element and a default"
+test "None is the absent value in an argument, a list element and a default"
-  u := User(name: "w", target: null)
+  u := User(name: "w", target: None)
-  assert {targetName(u) ?: "none"} == "none"
+  assert targetName(Some(u)).unwrapOr("none") == "none"
   xs := sparse()
-  second := xs.get(1)!
+  second := xs.at(1)
-  assert {second ?: 9} == 9
+  assert second.unwrapOr(9) == 9
-  first := xs.get(0)!
+  first := xs.at(0)
   assert first! == 1
-  assert {maybeCount() ?: 5} == 5
+  assert maybeCount(None).unwrapOr(5) == 5
-  assert maybeCount(7)! == 7
+  assert maybeCount(Some(7))! == 7

plum-examples/functional.plum CHANGED Viewed

@@ -26,6 +26,7 @@ import std/Int
 import std/Float
 import std/Slice
 import std/Pair
+import std/Option
 # ---------------------------------------------------------------------------
 # 1. Chain[T]: a cons list (std/List is the same shape, with variants Nil and Cons;
@@ -52,10 +53,10 @@ enum Chain[T] =
       f(h)
       t.each(f)
-  # A `for` source: `for x := range xs` steps with `next` (null = done).
+  # A `for` source: `for x := range xs` steps with `next` (`None` = done).
-  fun next(self) -> Pair[T, Chain[T]]? = match self
+  fun next(self) -> Option[Pair[T, Chain[T]]] = match self
-    Empty => null
+    Empty => None
-    Link(h, t) => Pair(first: h, second: t)
+    Link(h, t) => Some(Pair(first: h, second: t))
   # Structural recursion: rebuild the list with `f` applied to every element.
   fun map(self, f: fn(T) -> B) -> Chain[B] = match self
@@ -101,10 +102,10 @@ enum Chain[T] =
     Empty => Empty
     Link(_, t) => if n <= 0 then self else t.drop(n - 1)
-  # The first element, or null for an empty list.
+  # The first element, or None for an empty list.
-  fun first(self) -> T? = match self
+  fun first(self) -> Option[T] = match self
-    Empty => null
+    Empty => None
-    Link(h, _) => h
+    Link(h, _) => Some(h)
   # Pairs up two lists, stopping at the shorter one.
   fun zip(self, ys: Chain[B]) -> Chain[Pair[T, B]] = match self
@@ -195,9 +196,9 @@ enum Tree =
   fun inOrder(self) -> Chain[Int] =
     self.fold(Empty, |x, acc| cons(x, acc))
-  fun smallest(self) -> Int? = match self
+  fun smallest(self) -> Option[Int] = match self
-    Leaf => null
+    Leaf => None
-    Branch(Leaf, x, _) => x
+    Branch(Leaf, x, _) => Some(x)
     Branch(l, _, _) => l.smallest()
 fun fromLink(xs: Chain[Int]) -> Tree =
@@ -306,30 +307,30 @@ enum Node =
       Button(id, _, _, _, _, pressed) => single(cmd(if pressed then "button-down" else "button", id, xf))
       Group(_, _, kids) => kids.foldr(Empty, |k, acc| k.draw(xf).append(acc))
-  # The id of the topmost node under stage point (px, py), or null. Children drawn
+  # The id of the topmost node under stage point (px, py), or None. Children drawn
   # later are on top, so they are tried first (in reverse order).
-  fun findHit(self, parent: Xf, px: Float, py: Float) -> Int? =
+  fun findHit(self, parent: Xf, px: Float, py: Float) -> Option[Int] =
     xf := thenXf(parent, self.xf())
     p := undo(xf, px, py)
     match self
       Sprite(_, _, w, h, _, _) => hitBox(self, p, w, h)
       Button(_, _, bw, bh, _, _) => hitBox(self, p, bw, bh)
-      Label(_, _, _) => null
+      Label(_, _, _) => None
       Group(_, _, kids) => firstHit(kids.reverse(), xf, px, py)
   fun press(self) -> Node = match self
     Button(id, xf, w, h, text, _) => Button(id: id, xf: xf, w: w, h: h, text: text, pressed: true)
     _ => self
-# An inline `if` with `null` in the other branch is an optional: `Int?`.
+# An `if` that picks between `Some(..)` and `None` builds an `Option[Int]`.
-fun hitBox(n: Node, p: Pt, w: Float, h: Float) -> Int? =
+fun hitBox(n: Node, p: Pt, w: Float, h: Float) -> Option[Int] =
-  if inBox(p, w, h) then n.id() else null
+  if inBox(p, w, h) then Some(n.id()) else None
-fun firstHit(kids: Chain[Node], xf: Xf, px: Float, py: Float) -> Int? = match kids
+fun firstHit(kids: Chain[Node], xf: Xf, px: Float, py: Float) -> Option[Int] = match kids
-  Empty => null
+  Empty => None
   Link(k, rest) =>
-    if hit := k.findHit(xf, px, py)
+    if Some(hit) := k.findHit(xf, px, py)
-      hit
+      Some(hit)
     else
       firstHit(rest, xf, px, py)
@@ -342,7 +343,7 @@ struct UiEvent(id: Int, kind: UiKind)
 struct Routed(node: Node, events: Chain[UiEvent])
 fun click(root: Node, px: Float, py: Float) -> Routed =
-  if id := root.findHit(identityXf(), px, py)
+  if Some(id) := root.findHit(identityXf(), px, py)
     Routed(node: root.update(id, |n| n.press()), events: single(UiEvent(id: id, kind: Clicked)))
   else
     Routed(node: root, events: Empty)
@@ -428,8 +429,8 @@ test "link sharing"
   assert joinInts(tail, " ") == "2 3"
 test "link first and zip"
-  assert {fromTo(7, 9).first() ?: 0} == 7
+  assert fromTo(7, 9).first().unwrapOr(0) == 7
-  assert {fromTo(7, 7).first() ?: 0} == 0
+  assert fromTo(7, 7).first().unwrapOr(0) == 0
   ps := fromTo(1, 4).zip(fromTo(10, 20))
   assert ps.length() == 3
   assert ps.foldl(0, |a, p| a + p.first * p.second) == 1 * 10 + 2 * 11 + 3 * 12
@@ -473,8 +474,8 @@ test "persistent tree"
   assert !t.member(7)
   assert t.size() == 6
   assert t2.size() == 7
-  assert {t2.smallest() ?: -1} == 1
+  assert t2.smallest().unwrapOr(-1) == 1
-  assert {Leaf.smallest() ?: -1} == -1
+  assert Leaf.smallest().unwrapOr(-1) == -1
 test "pattern matching"
   assert Circle(r: 0.0).describe() == "point"
@@ -508,9 +509,9 @@ test "scene act is pure"
 test "scene hit test"
   scene := demoScene()
-  assert {scene.findHit(identityXf(), 105.0, 55.0) ?: 0} == 2
+  assert scene.findHit(identityXf(), 105.0, 55.0).unwrapOr(0) == 2
-  assert {scene.findHit(identityXf(), 115.0, 165.0) ?: 0} == 5
+  assert scene.findHit(identityXf(), 115.0, 165.0).unwrapOr(0) == 5
-  assert {scene.findHit(identityXf(), 0.0, 0.0) ?: 0} == 0
+  assert scene.findHit(identityXf(), 0.0, 0.0).unwrapOr(0) == 0
 test "scene click routes an event"
   scene := demoScene()

plum-examples/games/functional/game_state_view.plum CHANGED Viewed

@@ -27,6 +27,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/List
 import std/Math
 import std/Random
@@ -426,7 +427,10 @@ struct State(
   # One pointer input: finds what is under it in the current picture, runs the Ui,
   # and sends the messages of the buttons it clicked to `update`.
   fun feed(self, input: Input) -> State =
-    pos := input.position() ?: return self
+    po := input.position()
+    if po.isNone()
+      return self
+    pos := po.unwrap()
     view := self.render()
     r := Ui.step(self.ui, input, view.hitId(pos.x, pos.y))
     Ui.messages(view, r.events).fold(State(..self, ui: r.ui), |s, m| s.update(m))
@@ -510,7 +514,7 @@ struct State(
   # True when (x, y) in screen pixels is on the restart button of the picture `render` builds.
   fun onRestart(self, x: Float, y: Float) -> Bool =
-    {self.render().hitId(x, y) ?: -1} == Id.Restart
+    self.render().hitId(x, y).unwrapOr(-1) == Id.Restart
 # Enter or R going down.
 fun isRestartKey(e: Input) -> Bool = match e

plum-examples/games/functional/kids/balloon_pop.plum CHANGED Viewed

@@ -15,6 +15,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/List
 import std/Math
 import std/Random
@@ -208,9 +209,10 @@ struct State(balloons: List[Balloon], rng: Random, pops: Int, clock: Float, part
   fun pressAt(self, x: Float, y: Float) -> State =
     view := self.render()
-    id := view.hitId(x, y) ?: return self
+    if Some(id) := view.hitId(x, y)
-    msg := view.msgOf(id) ?: return self
+      if Some(msg) := view.msgOf(id)
-    self.update(msg)
+        return self.update(msg)
+    self
   # --- render ---

plum-examples/games/imperative/game_loop.plum CHANGED Viewed

@@ -7,6 +7,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/Map
 struct Vec2(x: Float, y: Float) =
@@ -59,7 +60,7 @@ fun handle(world: Map[Int, Entity], e: Event) =
     Spawn(id, name) =>
       world.set(id, Entity(id: id, name: name, hp: 100))
     Damage(id, amount) =>
-      if ent := world.getOrNull(id)
+      if Some(ent) := world.get(id)
         ent.hp = ent.hp - amount
     Despawn(id) =>
       world.remove(id)

plum-examples/games/imperative/game_scene.plum CHANGED Viewed

@@ -25,6 +25,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/Math
 import std/Random
 import std/game/Vec2
@@ -297,7 +298,7 @@ struct World(
     overlay.add(Text.create("Press Enter to play again", 24.0, Color.White).at(270.0, 316.0))
     hud.add(overlay)
     w := World(
-      camX: 0.0, camY: 0.0, camScale: 1.0, focus: null, ship: ship, mines: mines, orbs: orbs, mineList: Slice[Mine](), orbList: Slice[Orb](),
+      camX: 0.0, camY: 0.0, camScale: 1.0, focus: None, ship: ship, mines: mines, orbs: orbs, mineList: Slice[Mine](), orbList: Slice[Orb](),
       overlay: overlay, scoreText: scoreText, bestText: bestText, lifeIcons: icons,
       rng: Random.seeded(seed), score: 0, best: 0, lives: Rules.StartLives, over: false, clock: 0.0, held: Held.none(), sheet: sheet,
       pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
@@ -540,7 +541,7 @@ test "collecting an orb scores and respawns it elsewhere, still in the orbs laye
   assert Math.hypot(orb.x - w.ship.x, orb.y - w.ship.y) >= 120.0
   assert orb.x < 5000.0
   assert w.orbs.children.length() == Rules.OrbCount
-  assert same({orb.parent ?: crash "orphaned"}, w.orbs)
+  assert same(orb.parent.unwrap(), w.orbs)
   assert w.scoreText.text == "Score 10"
 test "a mine costs one life and makes the ship flash through its own act"

plum-examples/games/imperative/scene.plum CHANGED Viewed

@@ -16,6 +16,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/Math
 import std/game/Vec2
 import std/game/Color
@@ -100,7 +101,7 @@ struct Sky(
   sun: Spinner,
   label: Text,
   crowd: Group,
-  mut front: Actor?,
+  mut front: Option[Actor],
   mut selected: Int,
   mut clock: Float,
   mut paused: Bool,
@@ -136,7 +137,7 @@ fun newSky(sheet: Int) -> Sky =
   label.y = 12.0
   sky := Sky(
     stage: stage, bodies: Slice[Actor](), halos: Slice[Actor](), names: Slice[Str](),
-    sun: sun, label: label, crowd: Group(), front: null, selected: -1, clock: 0.0, paused: false, held: Held.none(), map: -1)
+    sun: sun, label: label, crowd: Group(), front: None, selected: -1, clock: 0.0, paused: false, held: Held.none(), map: -1)
   # faint orbit rings, added first so every body draws (and is hit) above them
   for i := range Layout.Planets
     r := 90.0 + Float(i) * 60.0
@@ -193,12 +194,12 @@ fun select(sky: Sky, i: Int) =
 # selected already, and clears the selection on empty space.
 fun clickAt(sky: Sky, x: Float, y: Float) =
   i := -1
-  if n := sky.stage.hit(x, y)
+  if Some(n) := sky.stage.hit(x, y)
     i = indexOf(sky, n)
-    if p := n.parent
+    if Some(p) := n.parent
       if p.children == sky.crowd.children
         n.toFront()
-        sky.front = n
+        sky.front = Some(n)
   if i == sky.selected
     i = -1
   select(sky, i)
@@ -215,7 +216,7 @@ fun tick(sky: Sky, dt: Float) =
   sky.clock = sky.clock + dt
   sky.stage.act(dt)
   sky.crowd.sortChildren(|a, b| a.y < b.y)
-  if f := sky.front
+  if Some(f) := sky.front
     f.toFront()
   sky.sun.srcX = Float(Int(sky.clock * 6.0) % 4) * Layout.Cell
@@ -428,4 +429,4 @@ test "walker_record: a Walker in a Stage moves via its own act and draws via its
   a: Actor := w
   a.act(1.0)
   assert near(w.x, 8.0)
-  assert same({stage.hit(8.5, 5.0) ?: crash "miss"}, w)
+  assert same(stage.hit(8.5, 5.0).unwrap(), w)

plum-examples/games/pure/game_pure_scene.plum CHANGED Viewed

@@ -19,6 +19,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/Math
 import std/Random
 import std/game/Vec2
@@ -270,11 +271,11 @@ fun nodeAt(a: Node, path: Slice[Int], depth: Int) -> Node =
 # The node with `id` below `root`, searched depth first, borrowed from the tree.
 fun find(root: Node, id: Int) -> Node =
-  path := root.findPath(id) ?: crash "no such actor"
+  path := root.findPath(id).unwrap()
   nodeAt(root, path, 0)
 fun kidsOf(n: Node) -> Slice[Node] =
-  n.children() ?: crash "not a group"
+  n.children().unwrap()
 fun setVisible(n: Node, v: Bool) -> Node =
   Node(..n, visible: v)
@@ -417,7 +418,7 @@ fun restart(w: World) =
   spots := startSpots(w.rng, w.ship)
   next := spots.rng
   w.rng = next
-  w.stage = Stage(root: buildRoot(spots, w.sheet, w.best), camera: w.stage.camera, captured: null, focus: null)
+  w.stage = Stage(root: buildRoot(spots, w.sheet, w.best), camera: w.stage.camera, captured: None, focus: None)
 # Copies the score, best score, lives and game-over panel into the HUD actors.
 fun syncHud(w: World) =

plum-examples/generics.plum CHANGED Viewed

@@ -7,10 +7,12 @@ import std/Float
 import std/Slice
 import std/Map
 import std/List
+import std/Option
+import std/Result
 # Generics are erased: a `T` is a nullable object reference at run time, and
 # Int / Float values are boxed when they cross a generic edge (a `T` param,
-# a Slice slot, a Map value, an error-union payload) and unboxed on the way out. These
+# a Slice slot, a Map value, a Result payload) and unboxed on the way out. These
 # tests push awkward values through every such edge and check they come back
 # bit-for-bit.
@@ -20,19 +22,24 @@ fun id(x: T) -> T =
 fun same(a: T, b: T) -> Bool =
   a == b
+enum GenError =
+  | Boom
+  | OutOfBounds
+  | KeyNotFound
-fun wrap(x: T) -> error{A}!T =
+fun wrap(x: T) -> Result[T, GenError] =
-  x
+  Ok(x)
-fun viaQ(x: T) -> error{A}!T =
+fun viaQ(x: T) -> Result[T, GenError] =
-  y := try wrap(x)
+  y := wrap(x)?
-  return y
+  return Ok(y)
-fun failing() -> error{A}!Int =
+fun failing() -> Result[Int, GenError] =
-  return error.A
+  return Err(Boom)
-fun viaQFailing() -> error{A}!Int =
+fun viaQFailing() -> Result[Int, GenError] =
-  y := try failing()
+  y := failing()?
-  return y
+  return Ok(y)
 fun pick(x: T, f: fn(T) -> T) -> T =
   f(x)
@@ -40,11 +47,11 @@ fun pick(x: T, f: fn(T) -> T) -> T =
 fun twice(f: fn(T) -> T, x: T) -> T =
   f(f(x))
-fun readDeep(outer: Slice[Slice[Map[Str, Int]]], r: Int, c: Int, key: Str) -> error{OutOfBounds, KeyNotFound}!Int =
+fun readDeep(outer: Slice[Slice[Map[Str, Int]]], r: Int, c: Int, key: Str) -> Result[Int, GenError] =
-  row := try outer.get(r)
+  row := outer.get(r).okOr(OutOfBounds)?
-  m := try row.get(c)
+  m := row.get(c).okOr(OutOfBounds)?
-  v := try m.get(key)
+  v := m.get(key).okOr(KeyNotFound)?
-  return v
+  return Ok(v)
 struct Circle(r: Float) =
@@ -117,11 +124,11 @@ struct Crate[T](value: T) =
     kept.push(c)
     kept.at(0).value
-struct Chain[T](v: T, next: Chain?) =
+struct Chain[T](v: T, next: Option[Chain[T]]) =
   fun last(self) -> T =
     cur: Chain := self
-    while n := cur.next
+    while Some(n) := cur.next
       cur = n
     cur.v
@@ -163,47 +170,47 @@ test "Int and Float extremes survive List push/get"
   ints.push(9223372036854775807)
   ints.push(0 - 9223372036854775807 - 1)
   ints.push(9007199254740993)
-  assert {ints.get(0) catch 0} == 9223372036854775807
+  assert ints.get(0).unwrapOr(0) == 9223372036854775807
-  assert {ints.get(1) catch 0} == 0 - 9223372036854775807 - 1
+  assert ints.get(1).unwrapOr(0) == 0 - 9223372036854775807 - 1
-  assert {ints.get(2) catch 0} == 9007199254740993
+  assert ints.get(2).unwrapOr(0) == 9007199254740993
   floats := Slice[Float]()
   floats.push(0.0 / 0.0)
   floats.push(-0.0)
   floats.push(5e-324)
-  nan := {floats.get(0) catch 0.0}
+  nan := floats.get(0).unwrapOr(0.0)
   assert nan != nan
-  assert 1.0 / {floats.get(1) catch 1.0} < 0.0
+  assert 1.0 / floats.get(1).unwrapOr(1.0) < 0.0
-  assert {floats.get(2) catch 0.0} == 5e-324
+  assert floats.get(2).unwrapOr(0.0) == 5e-324
 test "Int and Float extremes survive a Map[Str, V] value"
   mi: Map[Str, Int] := Map.empty()
   mi.set("big", 9223372036854775807)
   mi.set("small", 0 - 9223372036854775807 - 1)
   mi.set("odd", 9007199254740993)
-  assert {mi.get("big") catch 0} == 9223372036854775807
+  assert mi.get("big").unwrapOr(0) == 9223372036854775807
-  assert {mi.get("small") catch 0} == 0 - 9223372036854775807 - 1
+  assert mi.get("small").unwrapOr(0) == 0 - 9223372036854775807 - 1
-  assert {mi.get("odd") catch 0} == 9007199254740993
+  assert mi.get("odd").unwrapOr(0) == 9007199254740993
   mf: Map[Str, Float] := Map.empty()
   mf.set("nan", 0.0 / 0.0)
   mf.set("negzero", -0.0)
   mf.set("tiny", 5e-324)
-  nan := {mf.get("nan") catch 0.0}
+  nan := mf.get("nan").unwrapOr(0.0)
   assert nan != nan
-  assert 1.0 / {mf.get("negzero") catch 1.0} < 0.0
+  assert 1.0 / mf.get("negzero").unwrapOr(1.0) < 0.0
-  assert {mf.get("tiny") catch 0.0} == 5e-324
+  assert mf.get("tiny").unwrapOr(0.0) == 5e-324
-test "Int extremes survive an error-union payload with ? and catch"
+test "Int extremes survive a Result payload with ? and unwrapOr"
-  assert {wrap(9223372036854775807) catch 0} == 9223372036854775807
+  assert wrap(9223372036854775807).unwrapOr(0) == 9223372036854775807
-  assert {viaQ(0 - 9223372036854775807 - 1) catch 0} == 0 - 9223372036854775807 - 1
+  assert viaQ(0 - 9223372036854775807 - 1).unwrapOr(0) == 0 - 9223372036854775807 - 1
-  assert {viaQ(9007199254740993) catch 0} == 9007199254740993
+  assert viaQ(9007199254740993).unwrapOr(0) == 9007199254740993
-  assert {viaQFailing() catch 42} == 42
+  assert viaQFailing().unwrapOr(42) == 42
-test "Float specials survive an error-union payload with ? and catch"
+test "Float specials survive a Result payload with ? and unwrapOr"
-  nan := {viaQ(0.0 / 0.0) catch 0.0}
+  nan := viaQ(0.0 / 0.0).unwrapOr(0.0)
   assert nan != nan
-  assert 1.0 / {viaQ(-0.0) catch 1.0} < 0.0
+  assert 1.0 / viaQ(-0.0).unwrapOr(1.0) < 0.0
-  assert {viaQ(5e-324) catch 0.0} == 5e-324
+  assert viaQ(5e-324).unwrapOr(0.0) == 5e-324
-  assert {wrap(5e-324) catch 0.0} == 5e-324
+  assert wrap(5e-324).unwrapOr(0.0) == 5e-324
 # --- deep ----------------------------------------------------------------
@@ -219,12 +226,12 @@ test "List[List[Map[Str, Int]]] builds and reads back"
   outer.push(inner1)
   outer.push(inner2)
   assert outer.length() == 2
-  assert {outer.get(0) catch inner2}.length() == 2
+  assert outer.get(0).unwrapOr(inner2).length() == 2
-  assert {readDeep(outer, 0, 0, "ok") catch 0 - 1} == 7
+  assert readDeep(outer, 0, 0, "ok").unwrapOr(0 - 1) == 7
-  assert {readDeep(outer, 0, 0, "nokey") catch 98} == 98
+  assert readDeep(outer, 0, 0, "nokey").unwrapOr(98) == 98
-  assert {readDeep(outer, 0, 1, "big") catch 0} == 9223372036854775807
+  assert readDeep(outer, 0, 1, "big").unwrapOr(0) == 9223372036854775807
-  assert {readDeep(outer, 1, 0, "big") catch 0} == 9223372036854775807
+  assert readDeep(outer, 1, 0, "big").unwrapOr(0) == 9223372036854775807
-  assert {readDeep(outer, 2, 0, "big") catch 97} == 97
+  assert readDeep(outer, 2, 0, "big").unwrapOr(97) == 97
 test "a generic receiver's methods are chosen per element type"
   ints := [1, 22, 333].toSlice()
@@ -322,7 +329,7 @@ test "a bare generic type name inside its own methods means its applied form"
   assert Crate(value: "a").pick(Crate(value: "b"), false).value == "a"
   assert Crate(value: 7).viaLocal() == 7
   assert Crate(value: "x").viaLocal() == "x"
-  assert Chain(v: 1, next: Chain(v: 2, next: Chain(v: 3, next: null))).last() == 3
+  assert Chain(v: 1, next: Some(Chain(v: 2, next: Some(Chain(v: 3, next: None))))).last() == 3
-  assert Chain(v: "p", next: Chain(v: "q", next: null)).last() == "q"
+  assert Chain(v: "p", next: Some(Chain(v: "q", next: None))).last() == "q"
   assert stashedOr(Stashed(5), 0) == 5
   assert stashedOr(Unstashed, 9) == 9

plum-examples/json.plum CHANGED Viewed

@@ -1,32 +1,34 @@
 # JSON: `Json.encode(x)` and `Json.decode(s)`. A type with a `toJson(self) -> Json`
-# method encodes; a type with a static `fromJson(j: Json) -> JsonError!T` decodes.
+# method encodes; a type with a static `fromJson(j: Json) -> Result[T, JsonError]` decodes.
 # `T` of `decode` comes from the annotation. Records write both by hand.
 import std/Int
 import std/Str
 import std/Slice
 import std/Json
+import std/Option
+import std/Result
 struct House(name: Str, rooms: Int, tags: Slice[Str], annex: Slice[House]) =
   fun toJson(self) -> Json =
     Json.object(["name" => self.name.toJson(), "rooms" => self.rooms.toJson(), "tags" => self.tags.toJson(), "annex" => self.annex.toJson()])
-  fun fromJson(j: Json) -> JsonError!House =
+  fun fromJson(j: Json) -> Result[House, JsonError] =
-    name := try Str.fromJson(try j.field("name"))
+    name := Str.fromJson(j.field("name")?)?
-    rooms := try Int.fromJson(try j.field("rooms"))
+    rooms := Int.fromJson(j.field("rooms")?)?
-    tags := try tagsOf(try j.field("tags"))
+    tags := tagsOf(j.field("tags")?)?
-    annex := try annexOf(try j.field("annex"))
+    annex := annexOf(j.field("annex")?)?
-    return House(name: name, rooms: rooms, tags: tags, annex: annex)
+    return Ok(House(name: name, rooms: rooms, tags: tags, annex: annex))
-fun tagsOf(j: Json) -> JsonError!Slice[Str] = j.into()
+fun tagsOf(j: Json) -> Result[Slice[Str], JsonError] = j.into()
-fun annexOf(j: Json) -> JsonError!Slice[House] = j.into()
+fun annexOf(j: Json) -> Result[Slice[House], JsonError] = j.into()
-fun parseHouse(s: Str) -> JsonError!House = Json.decode(s)
+fun parseHouse(s: Str) -> Result[House, JsonError] = Json.decode(s)
 fun errorOf(s: Str) -> Str =
-  parseHouse(s) catch e
+  match parseHouse(s)
+    Ok(h) => "ok"
-    return e.name()
+    Err(e) => e.name()
-  "ok"
 fun house(a: Pair[Str, Json], b: Pair[Str, Json]) -> Str =
   Json.object([a.first => a.second, b.first => b.second, "tags" => Json.array([]), "annex" => Json.array([])]).toStr()
@@ -38,7 +40,7 @@ test "nested round trip"
   annex.push(House(name: "shed", rooms: 1, tags: Slice[Str](), annex: Slice[House]()))
   h := House(name: "main", rooms: 5, tags: tags, annex: annex)
   text := Json.encode(h)
-  back: JsonError!House := Json.decode(text)
+  back: Result[House, JsonError] := Json.decode(text)
   assert back!.name == "main"
   assert back!.tags.get(0)! == "old"
   assert back!.annex.get(0)!.name == "shed"

plum-examples/list_literal_probe.plum CHANGED Viewed

@@ -3,6 +3,7 @@ import std/Int
 import std/List
 import std/Map
 import std/Str
+import std/Option
 test "list literal of ints"
   xs := [1, 2, 3]
@@ -22,4 +23,4 @@ test "nested list literal"
 test "map literal"
   m := ["a" => 1, "b" => 2]
   assert m.length() == 2
-  assert {m.getOrNull("b") ?: 0} == 2
+  assert m.get("b").unwrapOr(0) == 2

plum-examples/match.plum CHANGED Viewed

@@ -6,6 +6,8 @@
 import std/Int
 import std/Float
 import std/Str
+import std/Option
+import std/Result
 enum Color =
   | Red
@@ -156,10 +158,10 @@ fun wide(s: Shape) -> Str =
   else
     "other"
-fun pick(s: Shape, o: Int?, n: Int) -> Str =
+fun pick(s: Shape, o: Option[Int], n: Int) -> Str =
   if Circle(r) := s
     "circle"
-  else if v := o
+  else if Some(v) := o
     "opt {v}"
   else if n > 10
     "big"
@@ -193,28 +195,29 @@ fun sumXY(v: Vec2) -> Int =
     return x + y
   0
+enum SmallError = TooBig | NotNum
-fun parseSmall(s: Str) -> error{TooBig, NotNum}!Int =
+fun parseSmall(s: Str) -> Result[Int, SmallError] =
-  n := Int.parse(s) catch return error.NotNum
+  n := Int.parse(s).mapErr(|e| NotNum)?
   if n > 9
-    return error.TooBig
+    return Err(TooBig)
-  n
+  Ok(n)
 fun describe(s: Str) -> Str =
-  n := parseSmall(s) catch e
+  match parseSmall(s)
-    if TooBig := e
+    Ok(n) => "ok {n}"
-      return "too big"
+    Err(TooBig) => "too big"
-    return "not a number"
+    Err(NotNum) => "not a number"
-  "ok {n}"
-fun firstSome(a: Int?, b: Int?) -> Int =
+fun firstSome(a: Option[Int], b: Option[Int]) -> Int =
-  if x := a
+  if Some(x) := a
     return x
-  else if y := b
+  else if Some(y) := b
     return y + 1
   -1
-fun bigOnly(a: Int?) -> Int =
+fun bigOnly(a: Option[Int]) -> Int =
-  if x := a, x > 3
+  if Some(x) := a, x > 3
     return x
   0
@@ -325,11 +328,11 @@ test "if_pattern_enum_variant"
   assert area(Dot) == 0.0
 test "else_if_pattern_chain"
-  assert pick(Circle(radius: 1.0), null, 0) == "circle"
+  assert pick(Circle(radius: 1.0), None, 0) == "circle"
-  assert pick(Dot, 4, 0) == "opt 4"
+  assert pick(Dot, Some(4), 0) == "opt 4"
-  assert pick(Dot, null, 11) == "big"
+  assert pick(Dot, None, 11) == "big"
-  assert pick(Rect(w: 1.0, h: 1.0), null, 0) == "rect"
+  assert pick(Rect(w: 1.0, h: 1.0), None, 0) == "rect"
-  assert pick(Dot, null, 0) == "none"
+  assert pick(Dot, None, 0) == "none"
 test "pattern_with_trailing_condition"
   assert wide(Rect(w: 3.0, h: 1.0)) == "wide"
@@ -351,22 +354,22 @@ test "while_pattern"
   assert countDown(Idle) == 0
 test "else_if_optional_binding"
-  assert firstSome(null, 7) == 8
+  assert firstSome(None, Some(7)) == 8
-  assert firstSome(2, 7) == 2
+  assert firstSome(Some(2), Some(7)) == 2
-  assert firstSome(null, null) == -1
+  assert firstSome(None, None) == -1
 test "irrefutable_pattern_if_allowed"
   assert sumXY(Vec2(x: 3, y: 4)) == 7
-test "error_name_pattern_in_catch_block"
+test "error_enum_patterns_in_match"
   assert describe("5") == "ok 5"
   assert describe("50") == "too big"
   assert describe("x") == "not a number"
 test "optional_binding_with_trailing_condition"
-  assert bigOnly(5) == 5
+  assert bigOnly(Some(5)) == 5
-  assert bigOnly(2) == 0
+  assert bigOnly(Some(2)) == 0
-  assert bigOnly(null) == 0
+  assert bigOnly(None) == 0
 test "when guard picks between two cases of the same member"
   mythic := FantasyBook(title: "Dragon Tales", pages: 200, hasMythicalCreatures: true)

plum-examples/numbers.plum CHANGED Viewed

@@ -5,6 +5,8 @@ import std/Float
 import std/Math
 import std/Slice
 import std/List
+import std/Option
+import std/Result
 # ==== operators ====
@@ -158,11 +160,11 @@ test "toStr renders Int and Float correctly, including negatives and fractions"
   assert {-3.5}.toStr() == "-3.5"
 test "Int.parse/Float.parse round-trip a rendered number"
-  assert {Int.parse("123") catch -1} == 123
+  assert Int.parse("123").unwrapOr(-1) == 123
-  assert {Int.parse("-45") catch 1} == -45
+  assert Int.parse("-45").unwrapOr(1) == -45
-  assert {Float.parse("3.25") catch -1.0f} == 3.25f
+  assert Float.parse("3.25").unwrapOr(-1.0f) == 3.25f
-  assert {Int.parse("12x") catch -1} == -1
+  assert Int.parse("12x").unwrapOr(-1) == -1
-  assert {Float.parse("") catch -1.0f} == -1.0f
+  assert Float.parse("").unwrapOr(-1.0f) == -1.0f
 test "Math namespace functions and hyperbolic methods work"
   assert Math.sin(0.0f) == 0.0f

plum-examples/recursion.plum CHANGED Viewed

@@ -5,6 +5,8 @@ import std/List
 import std/Str
 import std/Slice
 import std/Array
+import std/Option
+import std/Result
 # ==== tail calls ====
@@ -56,11 +58,13 @@ fun spin(c: Counter) -> Counter =
 fun depth(n: Int) -> Int =
   if n == 0 then 0 else 1 + depth(n - 1)
+enum DownError = Neg
-fun down(n: Int) -> error{Neg}!Int =
+fun down(n: Int) -> Result[Int, DownError] =
   if n < 0
-    return error.Neg
+    return Err(Neg)
   if n == 0
-    return 5
+    return Ok(5)
   down(n - 1)
 # ==== cons list ====
@@ -132,8 +136,8 @@ test "closure_body_tail_million"
   fin := |n: Int| sumTo(n, 0)
   assert fin(1000000) == 500000500000
-test "error_union_loop_million"
+test "result_loop_million"
-  assert { down(1000000) catch 99 } == 5
+  assert down(1000000).unwrapOr(99) == 5
 test "map_single_pass_million"
   ys := map(fromTo(0, 1000000), |x| x * 2)
@@ -149,8 +153,8 @@ test "tree_recursion_depth_recorded"
 test "init_sum"
   assert [1, 2, 3, 4].fold(0, |a, x| a + x) == 10
   assert [1, 2, 3].length() == 3
-  assert { [1, 2, 3].get(1) ?: -1 } == 2
+  assert [1, 2, 3].get(1).unwrapOr(-1) == 2
-  assert [1, 2, 3].get(5) == null
+  assert [1, 2, 3].get(5).isNone()
   nil: List[Int] := Nil
   assert nil.isEmpty()
   assert ![1].isEmpty()
@@ -163,8 +167,8 @@ test "map_filter_fold"
 test "reverse_append"
   xs := [1, 2, 3].reverse()
-  assert { xs.get(0) ?: -1 } == 3
+  assert xs.get(0).unwrapOr(-1) == 3
-  assert { xs.get(2) ?: -1 } == 1
+  assert xs.get(2).unwrapOr(-1) == 1
   ys := [1, 2].append([3, 4])
   assert ys.equals([1, 2, 3, 4])
@@ -197,7 +201,7 @@ test "cons_fold_million"
   xs := range(0, 1000000)
   assert xs.fold(0, |a, x| a + x) == 499999500000
   assert xs.filter(|x| x % 2 == 0).length() == 500000
-  assert { xs.reverse().get(0) ?: -1 } == 999999
+  assert xs.reverse().get(0).unwrapOr(-1) == 999999
 test "equals_and_toStr"
   assert [1, 2, 3].equals([1, 2, 3])

plum-examples/sequences.plum CHANGED Viewed

@@ -7,15 +7,16 @@ import std/Pair
 import std/Str
 import std/Testing
 import std/List
+import std/Option
 # ==== iterators ====
 # `for x := range v` works over:
 #
 #   * an `Int` n: x counts 0, 1, ... n - 1;
-#   * any value whose type has `next(self) -> Pair[T, Self]?`: null means done,
+#   * any value whose type has `next(self) -> Option[Pair[T, Self]]`: `None` means
-#     otherwise `Pair(value, rest)` binds x to the value and continues with the
+#     done, otherwise `Some(Pair(value, rest))` binds x to the value and continues
-#     rest (`List`, the `Range` from `Int.until/to/downTo/stepBy`, and your own
+#     with the rest (`List`, the `Range` from `Int.until/to/downTo/stepBy`, and your own
 #     types);
 #   * a `Slice` or `Array` (by position).
 #
@@ -42,17 +43,17 @@ fun army() -> Slice[Soldier] =
 # A user iterator: from, from - 1, ... 1.
 struct Countdown(from: Int) =
-  fun next(self) -> Pair[Int, Countdown]? =
+  fun next(self) -> Option[Pair[Int, Countdown]] =
-    if self.from <= 0 then null else Pair(first: self.from, second: Countdown(from: self.from - 1))
+    if self.from <= 0 then None else Some(Pair(first: self.from, second: Countdown(from: self.from - 1)))
 # A lazy adapter: the first `n` elements of a list, pulling nothing past them.
 struct TakeList[T](src: List[T], n: Int) =
-  fun next(self) -> Pair[T, TakeList[T]]? =
+  fun next(self) -> Option[Pair[T, TakeList[T]]] =
     if self.n <= 0
-      return null
+      return None
-    step := self.src.next() ?: return null
+    step := self.src.next()?
-    Pair(first: step.first, second: TakeList(src: step.second, n: self.n - 1))
+    Some(Pair(first: step.first, second: TakeList(src: step.second, n: self.n - 1)))
 # The 8 neighbours of (x, y), as one list of (x, y) pairs.
 fun neighbours(x: Int, y: Int) -> List[Pair[Int, Int]] =

plum-examples/structs_records.plum CHANGED Viewed

@@ -5,6 +5,8 @@ import std/List
 import std/Float
 import std/Map
 import std/Slice
+import std/Option
+import std/Result
 # ==== structs records ====
@@ -65,14 +67,14 @@ fun sumAll(vs: List[Vec2]) -> Float =
     t = t + v.x
   t
-fun opt(c: Bool) -> Vec2? =
+fun opt(c: Bool) -> Option[Vec2] =
   if c
-    return Vec2(x: 1.0, y: 1.0)
+    return Some(Vec2(x: 1.0, y: 1.0))
-  return null
+  return None
-fun chain(c: Bool) -> Vec2? =
+fun chain(c: Bool) -> Option[Vec2] =
-  v := opt(c) ?: return null
+  v := opt(c)?
-  Vec2(x: v.x + 1.0, y: v.y)
+  Some(Vec2(x: v.x + 1.0, y: v.y))
 fun makeVec(x: Float, y: Float) -> Vec2 =
   Vec2(x: x, y: y)
@@ -158,14 +160,14 @@ enum V2 =
   | B2
   K1 = 40
-error S1 = E1 | E2
+enum S1 = E1 | E2
-fun fail(n: Int) -> S1!Int =
+fun fail(n: Int) -> Result[Int, S1] =
   if n == 1
-    return error.E1
+    return Err(E1)
   if n == 2
-    return error.E2
+    return Err(E2)
-  n
+  Ok(n)
 fun asInt(w: V2) -> Int =
   match w
@@ -186,22 +188,22 @@ fun isB2(w: V2) -> Int =
 # Annotated local declarations: `name: Type := value` fixes the local's type to
 # the annotation. The value converts to it exactly as it would for a parameter of
-# that type (a variant into its enum, `T` into `T?`, `null` into `T?`), and
+# that type (a variant into its enum, `Some(x)` or `None` into an `Option[T]`), and
 # a later `name = value` is checked and converted against the same type.
 enum Shape = Circle(r: Float) | Region(w: Float, h: Float)
-error LocalError = Bad | Worse
+enum LocalError = Bad | Worse
 fun area(s: Shape) -> Float =
   match s
     Circle(r) => r * r * 3.0
     Region(w, h) => w * h
-fun parseLocal(n: Int) -> LocalError!Int =
+fun parseLocal(n: Int) -> Result[Int, LocalError] =
   if n < 0
-    return error.Bad
+    return Err(Bad)
-  n * 2
+  Ok(n * 2)
 fun twice(x: Int) -> Int = x * 2
@@ -283,7 +285,7 @@ test "struct in a Map and an optional"
   assert m.get("a")!.y == 2.0
   assert opt(true)!.x == 1.0
   assert chain(true)!.x == 2.0
-  assert {chain(false) ?: Vec2.zero()}.x == 0.0
+  assert chain(false).unwrapOr(Vec2.zero()).x == 0.0
 test "struct field of a record is copied out"
   p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 3)
@@ -392,9 +394,9 @@ test "digit_variant_pattern_if"
   assert isB2(A1(n: 1)) == 0
 test "digit_error_names"
-  a := fail(3) catch 0
+  a := fail(3).unwrapOr(0)
   assert a == 3
-  b := fail(1) catch 9
+  b := fail(1).unwrapOr(9)
   assert b == 9
 test "digit_enum_const_still_works"
@@ -413,14 +415,14 @@ test "union_local_reassigned"
   assert area(s) == 6.0
 test "optional_local_present"
-  o: Int? := 4
+  o: Option[Int] := Some(4)
-  assert {o ?: 0} == 4
+  assert o.unwrapOr(0) == 4
-test "optional_local_null"
+test "optional_local_none"
-  o: Int? := null
+  o: Option[Int] := None
-  assert {o ?: 9} == 9
+  assert o.unwrapOr(9) == 9
-  o = 5
+  o = Some(5)
-  assert {o ?: 9} == 5
+  assert o.unwrapOr(9) == 5
 test "list_local"
   xs: Slice[Shape] := Slice[Shape]()
@@ -442,8 +444,8 @@ test "generic_param_annotation"
   assert same(7) == 7
   assert same("a") == "a"
-test "named_error_set_local"
+test "named_error_enum_local"
-  ok: LocalError!Int := parseLocal(4)
+  ok: Result[Int, LocalError] := parseLocal(4)
-  bad: LocalError!Int := parseLocal(-1)
+  bad: Result[Int, LocalError] := parseLocal(-1)
-  assert {ok catch 0} == 8
+  assert ok.unwrapOr(0) == 8
-  assert {bad catch 7} == 7
+  assert bad.unwrapOr(7) == 7

plum-examples/unions.plum CHANGED Viewed

@@ -8,6 +8,8 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
+import std/Result
 enum Shape =
   | Circle(r: Float)
@@ -121,17 +123,19 @@ fun showB(j: Jb) -> Str =
     BStr(_) => "s"
     BList(_) => "l"
+enum PosError = Neg
-fun pos(n: Int) -> !Slice[Jv] =
+fun pos(n: Int) -> Result[Slice[Jv], PosError] =
   if n < 0
-    return error.Neg
+    return Err(Neg)
   xs := Slice[Jv]()
   xs.push(JInt(v: n))
   xs.push(JStr(v: "a"))
-  xs
+  Ok(xs)
-fun posLen(n: Int) -> !Int =
+fun posLen(n: Int) -> Result[Int, PosError] =
-  xs := try pos(n)
+  xs := pos(n)?
-  xs.length()
+  Ok(xs.length())
 test "variant_field_by_pattern"
   s := make(false)
@@ -176,10 +180,10 @@ test "bool_variant"
   assert showB(BFloat(v: 1.5)) == "f"
   assert "{showB(BBool(v: true))}" == "T"
-test "variants_in_try"
+test "variants_with_result"
-  assert {posLen(3) catch 0} == 2
+  assert posLen(3).unwrapOr(0) == 2
-  assert {posLen(-1) catch 0} == 0
+  assert posLen(-1).unwrapOr(0) == 0
-  ys := pos(3) catch Slice[Jv]()
+  ys := pos(3).unwrapOr(Slice[Jv]())
   assert describeJv(JList(v: ys)) == "list"
 test "variants_with_for"

plum-game/web-test/fixtures/stress_pure_scene.plum CHANGED Viewed

@@ -9,6 +9,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/game/Vec2
 import std/game/Color
 import std/game/Affine
@@ -104,7 +105,7 @@ fun buildWorld(sheet: Int, white: Int) -> World =
     root.push(countLabel(30000 + i, i, Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)))
   top := Node.group(1, 0.0, 0.0, Float(Counts.WorldW), Float(Counts.WorldH), root)
   cam := Affine(a: 0.8, b: 0.0, c: 0.0, d: 0.8, e: 0.0, f: 0.0)
-  World(sheet: sheet, stage: Stage(root: top, camera: cam, captured: null, focus: null))
+  World(sheet: sheet, stage: Stage(root: top, camera: cam, captured: None, focus: None))
 fun whiteTexture(io: Io) -> Int =
   t := io.textureCreate(1, 1)
@@ -130,7 +131,7 @@ test "ten frames of update run"
   w := buildWorld(0, 0)
   for i := range 10
     update(w, 0.016)
-  if k := w.stage.root.children()
+  if Some(k) := w.stage.root.children()
     assert k.length() == 50 + 500 + 200 + 50
     assert {k.at(50).x - 20.0}.abs() < 0.000001
   else

plum-game/web-test/fixtures/stress_state_view.plum CHANGED Viewed

@@ -17,6 +17,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 import std/List
 import std/game/Vec2
 import std/game/Color
@@ -83,9 +84,9 @@ struct Pulser(id: Int, x: Float, y: Float, start: Float, srcX: Float)
 struct State(sheet: Int, white: Int, spinners: List[Spinner], drifters: List[Drifter], counters: List[Counter], pulsers: List[Pulser], anim: Anim, clock: Float, ui: UiState, clicks: Int)
 fun pulseAnim() -> Anim =
-  Forever(anim: Seq(steps: List(
+  Forever(anim: Seq(steps: [
-    Par(steps: List(MoveBy(dx: 30.0, dy: 0.0, secs: 1.0), RotateBy(radians: 3.14159, secs: 1.0), ScaleTo(sx: 1.5, sy: 1.5, secs: 1.0))),
+    Par(steps: [MoveBy(dx: 30.0, dy: 0.0, secs: 1.0), RotateBy(radians: 3.14159, secs: 1.0), ScaleTo(sx: 1.5, sy: 1.5, secs: 1.0)]),
-    Par(steps: List(MoveBy(dx: 0.0 - 30.0, dy: 0.0, secs: 1.0), ScaleTo(sx: 0.6666, sy: 0.6666, secs: 1.0))))))
+    Par(steps: [MoveBy(dx: 0.0 - 30.0, dy: 0.0, secs: 1.0), ScaleTo(sx: 0.6666, sy: 0.6666, secs: 1.0)])]))
 fun newPulser(i: Int) -> Pulser =
   Pulser(id: 50000 + i, x: Float(i * 97 % 1500), y: Float(i * 53 % 850), start: Float(i % 10) * 0.1, srcX: Float(i % 4 * 16))
@@ -144,7 +145,10 @@ fun countClicks(es: List[UiEvent]) -> Int = match es
 # Feeds one pointer input through Ui.step against the button layer.
 fun stepUi(s: State, input: Input) -> State =
-  pos := input.position() ?: return s
+  po := input.position()
+  if po.isNone()
+    return s
+  pos := po.unwrap()
   hit := buttonsView(s.ui).hitId(pos.x, pos.y)
   r := Ui.step(s.ui, input, hit)
   State(
@@ -192,7 +196,7 @@ fun view(s: State) -> SceneNode[Int] =
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
   pulses := toNodes(s.pulsers, |p| pulserView(s.sheet, s.anim, s.clock, p), drifts)
   world: SceneNode[Int] := Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), pulses))
-  Group(transform: Identity, children: List(world, buttonsView(s.ui)))
+  Group(transform: Identity, children: [world, buttonsView(s.ui)])
 fun whiteTexture(io: Io) -> Int =
   t := io.textureCreate(1, 1)

plum-std/Base64.plum CHANGED Viewed

@@ -4,6 +4,8 @@ import std/Str
 import std/Buffer
 import std/Int
 import std/Float
+import std/Option
+import std/Result
 # The Base64 package contains support for doing Base64 binary-to-text encodings.
 #
@@ -14,6 +16,9 @@ import std/Float
 # byte array here (see `libs/std/str.plum`), so this is a plain byte string,
 # not a claim that the content is valid UTF-8 text.
+# Why `Base64.decode` failed.
+enum Base64Error = InvalidBase64
 primitive Base64 =
   # Encode for PEM (RFC 1421): 64-character lines.
   fun encodePEM(data: Str) -> Str =
@@ -98,13 +103,13 @@ primitive Base64 =
     b == 32 || b == 9 || b == 10 || b == 13
   # Decode for URLs (RFC 4648).
-  fun decodeUrl(data: Str) -> error{InvalidBase64}!Str =
+  fun decodeUrl(data: Str) -> Result[Str, Base64Error] =
     return decode(data, "-", "_", "=")
   # Configurable decoding. The defaults are for RFC 4648. Missing padding is
   # not an error. Non-base64 data, other than whitespace (which can appear at
-  # any point), fails with `InvalidBase64`.
+  # any point), fails with `Err(InvalidBase64)`.
-  fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> error{InvalidBase64}!Str =
+  fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> Result[Str, Base64Error] =
     at62b := at62.byteAt(0)
     at63b := at63.byteAt(0)
     has_pad := pad.length() > 0
@@ -121,13 +126,13 @@ primitive Base64 =
         continue
       v := decodeByte(b, at62b, at63b)
       if v < 0
-        return error.InvalidBase64
+        return Err(InvalidBase64)
       bits = {bits << 6} | v
       nbits = nbits + 6
       if nbits >= 8
         nbits = nbits - 8
         res.writeByte(Byte({bits >> nbits} & 0xFF))
-    return res.toStr()
+    return Ok(res.toStr())
 test "statics are reached through the Base64 namespace and round-trip"
   assert Base64.decode(Base64.encodePEM("hello"))! == "hello"

plum-std/Bool.plum CHANGED Viewed

@@ -1,27 +1,32 @@
 module std
 import std/Str
+import std/Option
+import std/Result
 # The API of the built-in `Bool` type: `Bool.parse` and `toStr` (also used by
 # `"{b}"` interpolation). `true`/`false` and the operators are built in; the
 # methods need `import std/Bool`.
+# Why `Bool.parse` failed.
+enum BoolError = BadBoolStr
 primitive Bool =
   fun toStr(self) -> Str =
     if self then "true" else "false"
   # Parses exactly `"true"` or `"false"`.
-  fun parse(s: Str) -> error{BadBoolStr}!Bool =
+  fun parse(s: Str) -> Result[Bool, BoolError] =
     if s == "true"
-      true
+      Ok(true)
     else if s == "false"
-      false
+      Ok(false)
     else
-      return error.BadBoolStr
+      Err(BadBoolStr)
 test "Bool.parse accepts true/false and rejects everything else"
-  assert Bool.parse("true") catch false
+  assert Bool.parse("true").unwrapOr(false)
-  assert !{Bool.parse("false") catch true}
+  assert !Bool.parse("false").unwrapOr(true)
-  assert !{Bool.parse("yes") catch false}
+  assert !Bool.parse("yes").unwrapOr(false)
 test "Bool.toStr is true/false, also through interpolation"
   t := true

plum-std/Deque.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/Array
 import std/Slice
+import std/Option
 import std/Int
 import std/Float
@@ -47,27 +48,27 @@ struct Deque[T](mut buf: Array[T], mut head: Int, mut size: Int) =
     self.buf.set(self.head, v)
     self.size = self.size + 1
-  # Removes and returns the front element, or an error `DequeWasEmpty`.
+  # Removes and returns the front element, or None if empty.
-  fun popFront(self) -> error{DequeWasEmpty}!T =
+  fun popFront(self) -> Option[T] =
     if self.size == 0
-      return error.DequeWasEmpty
+      return None
     v := self.buf.get(self.head)
     self.head = {self.head + 1} % self.buf.length()
     self.size = self.size - 1
-    v
+    Some(v)
-  # Removes and returns the back element, or an error `DequeWasEmpty`.
+  # Removes and returns the back element, or None if empty.
-  fun popBack(self) -> error{DequeWasEmpty}!T =
+  fun popBack(self) -> Option[T] =
     if self.size == 0
-      return error.DequeWasEmpty
+      return None
     self.size = self.size - 1
-    self.buf.get({self.head + self.size} % self.buf.length())
+    Some(self.buf.get({self.head + self.size} % self.buf.length()))
-  # The `i`'th element from the front, or an error `OutOfBounds`.
+  # The `i`'th element from the front, or None if out of bounds.
-  fun get(self, i: Int) -> error{OutOfBounds}!T =
+  fun get(self, i: Int) -> Option[T] =
     if i < 0 || i >= self.size
-      return error.OutOfBounds
+      return None
-    self.buf.get({self.head + i} % self.buf.length())
+    Some(self.buf.get({self.head + i} % self.buf.length()))
   # the `i`'th element from the front, unchecked (the `for x := range deque` protocol)
   fun at(self, i: Int) -> T =
@@ -116,6 +117,6 @@ test "pushFront builds the front in reverse order"
 test "pop on empty is an error"
   d := Deque[Int]()
-  assert {d.popFront() catch -1} == -1
+  assert d.popFront().unwrapOr(-1) == -1
-  assert {d.popBack() catch -1} == -1
+  assert d.popBack().unwrapOr(-1) == -1
-  assert {d.get(0) catch -1} == -1
+  assert d.get(0).unwrapOr(-1) == -1

plum-std/Float.plum CHANGED Viewed

@@ -3,6 +3,8 @@ module std
 import std/Str
 import std/Int
 import std/Math
+import std/Option
+import std/Result
 # The API of the built-in `Float` type: associated constants, `Float.parse`
 # and the numeric methods (`x.abs()`, `x.sqrt()`, ...).
@@ -27,21 +29,21 @@ primitive Float =
   # Parses a decimal float, with an optional leading `+`/`-` and an optional
   # `.` fractional part (no exponent notation).
-  fun parse(s: Str) -> error{BadNumStr}!Float =
+  fun parse(s: Str) -> Result[Float, NumError] =
     len := s.length()
     if len == 0
-      return error.BadNumStr
+      return Err(BadNumStr)
     neg := s.byteAt(0) == 45
     start := if neg || s.byteAt(0) == 43 then 1 else 0
     if start >= len
-      return error.BadNumStr
+      return Err(BadNumStr)
     int_part := 0.0f
     saw_digit := false
     i := start
     while i < len && s.byteAt(i) != 46
       b := s.byteAt(i)
       if b < 48 || b > 57
-        return error.BadNumStr
+        return Err(BadNumStr)
       int_part = int_part * 10.0f + Float(b - 48)
       saw_digit = true
       i = i + 1
@@ -52,15 +54,15 @@ primitive Float =
       while i < len
         b := s.byteAt(i)
         if b < 48 || b > 57
-          return error.BadNumStr
+          return Err(BadNumStr)
         frac_scale = frac_scale / 10.0f
         frac_part = frac_part + Float(b - 48) * frac_scale
         saw_digit = true
         i = i + 1
     if !saw_digit
-      return error.BadNumStr
+      return Err(BadNumStr)
     value := int_part + frac_part
-    return if neg then -value else value
+    return Ok(if neg then -value else value)
   fun abs(self) -> Float =
     if self < 0.0f then -self else self

plum-std/Heap.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/Array
 import std/Slice
+import std/Option
 import std/Int
 import std/Float
@@ -60,22 +61,22 @@ struct Heap[T](items: Slice[T], key: fn(T) -> Float) =
     self.items.push(v)
     self.siftUp(self.items.length() - 1)
-  # The smallest element without removing it, or an error `HeapWasEmpty`.
+  # The smallest element without removing it, or None if empty.
-  fun peek(self) -> error{HeapWasEmpty}!T =
+  fun peek(self) -> Option[T] =
     if self.items.length() == 0
-      return error.HeapWasEmpty
+      return None
-    self.items.data.get(0)
+    Some(self.items.data.get(0))
-  # Removes and returns the smallest element, or an error `HeapWasEmpty`.
+  # Removes and returns the smallest element, or None if empty.
-  fun pop(self) -> error{HeapWasEmpty}!T =
+  fun pop(self) -> Option[T] =
     n := self.items.length()
     if n == 0
-      return error.HeapWasEmpty
+      return None
     top := self.items.data.get(0)
     self.items.data.set(0, self.items.data.get(n - 1))
     self.items.size = n - 1
     self.siftDown(0)
-    top
+    Some(top)
 test "heap_pop_order: 1000 pseudo-random keys pop in ascending order"
   h := Heap[Int](items: Slice[Int](), key: |x| Float(x))
@@ -94,7 +95,7 @@ test "heap_pop_order: 1000 pseudo-random keys pop in ascending order"
     prev = v
     i = i + 1
   assert h.isEmpty()
-  assert {h.pop() catch -1} == -1
+  assert h.pop().unwrapOr(-1) == -1
 test "peek shows the minimum and Float keys order records"
   h := Heap[Float](items: Slice[Float](), key: |x| 0.0 - x)

plum-std/Http.plum CHANGED Viewed

@@ -8,9 +8,18 @@ import std/Str
 import std/Int
 import std/Float
 import std/Io
+import std/Option
+import std/Result
 # Transport failure, or a response that is not valid HTTP.
+enum HttpError =
+  | HttpFailed
+  | BadResponse
+  fun name(self) -> Str =
+    match self
+      HttpFailed => "HttpFailed"
-error HttpError = HttpFailed | BadResponse
+      BadResponse => "BadResponse"
 # An HTTP response: status code, response headers, and the raw response
 # body as a `Str` (a byte array, so binary bodies round-trip intact).
@@ -26,8 +35,8 @@ struct Response(status: Int, headers: Map[Str, Str], body: Str) =
   # Parses `body` as JSON. Fails the same way `Json.fromStr` does for a
   # response body that isn't valid JSON.
-  fun json(self) -> error{InvalidJson}!Json =
+  fun json(self) -> Result[Json, JsonError] =
-    return try Json.fromStr(self.body)
+    return Json.fromStr(self.body)
 # A single blocking network round trip — this VM has no async/event-loop
 # mechanism, so `rawHttpRequest` runs to completion before returning (same
@@ -77,40 +86,41 @@ primitive Http =
   # successful round trip, returned as a `Response` with that status (check
   # `Response.ok()`). Fails with `HttpFailed` for a transport error and
   # `BadResponse` for a reply whose status line can't be read.
-  fun request(io: Io, method: Str, url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun request(io: Io, method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, HttpError] =
     raw := io.rawHttpRequest(method, url, encodeHeaders(headers), body)
     sep := raw.indexOf("\x00")
     meta := if sep >= 0 then raw.sub(0, sep) else raw
     resp_body := if sep >= 0 then raw.sub(sep + 1, raw.length()) else ""
     parts := meta.split("\x01", 3)
-    flag := parts.get(0) catch ""
+    flag := parts.get(0).unwrapOr("")
     if flag != "1"
-      return error.HttpFailed
+      return Err(HttpFailed)
-    status := Int.parse(parts.get(1) catch "") catch return error.BadResponse
+    match Int.parse(parts.get(1).unwrapOr(""))
-    return Response(status: status, headers: decodeHeaders(parts.get(2) catch ""), body: resp_body)
+      Ok(status) => Ok(Response(status: status, headers: decodeHeaders(parts.get(2).unwrapOr("")), body: resp_body))
+      Err(e) => Err(BadResponse)
-  fun get(io: Io, url: Str, headers: Map[Str, Str]) -> HttpError!Response =
+  fun get(io: Io, url: Str, headers: Map[Str, Str]) -> Result[Response, HttpError] =
     return request(io, "GET", url, headers, "")
-  fun head(io: Io, url: Str, headers: Map[Str, Str]) -> HttpError!Response =
+  fun head(io: Io, url: Str, headers: Map[Str, Str]) -> Result[Response, HttpError] =
     return request(io, "HEAD", url, headers, "")
-  fun delete(io: Io, url: Str, headers: Map[Str, Str]) -> HttpError!Response =
+  fun delete(io: Io, url: Str, headers: Map[Str, Str]) -> Result[Response, HttpError] =
     return request(io, "DELETE", url, headers, "")
-  fun post(io: Io, url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun post(io: Io, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, HttpError] =
     return request(io, "POST", url, headers, body)
-  fun put(io: Io, url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun put(io: Io, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, HttpError] =
     return request(io, "PUT", url, headers, body)
-  fun patch(io: Io, url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun patch(io: Io, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, HttpError] =
     return request(io, "PATCH", url, headers, body)
   # Convenience wrapper: sends `body` as a JSON `Str`, adding a
   # `Content-Type: application/json` header, and parses the response back as
   # JSON via `Response.json()`.
-  fun postJson(io: Io, url: Str, headers: Map[Str, Str], body: Json) -> HttpError!Response =
+  fun postJson(io: Io, url: Str, headers: Map[Str, Str], body: Json) -> Result[Response, HttpError] =
     headers.set("Content-Type", "application/json")
     return post(io, url, headers, body.toStr())
@@ -142,5 +152,5 @@ test "post sends a body and the server echoes it back"
   assert j.asMap()!.get("data")!.asStr()! == "hello world"
 test "request fails for an unreachable host"
-  resp := Http.get(io, "http://this-host-does-not-exist.invalid/", Http.emptyHeaders()) catch Response(status: 0, headers: Http.emptyHeaders(), body: "")
+  resp := Http.get(io, "http://this-host-does-not-exist.invalid/", Http.emptyHeaders()).unwrapOr(Response(status: 0, headers: Http.emptyHeaders(), body: ""))
   assert resp.status == 0

plum-std/Int.plum CHANGED Viewed

@@ -4,6 +4,11 @@ import std/Str
 import std/Float
 import std/Math
 import std/Pair
+import std/Option
+import std/Result
+# Why `Int.parse` / `Float.parse` failed.
+enum NumError = BadNumStr
 # The API of the built-in `Int` type: associated constants, `Int.parse`, the
 # numeric methods (`x.abs()`, `x.min(y)`, ...) and the `for i := range n` loop
@@ -13,23 +18,23 @@ primitive Int =
   Max = 0x7FFF_FFFF_FFFF_FFFF  # Highest value of Int
   # Parses a decimal integer, with an optional leading `+`/`-`.
-  fun parse(s: Str) -> error{BadNumStr}!Int =
+  fun parse(s: Str) -> Result[Int, NumError] =
     len := s.length()
     if len == 0
-      return error.BadNumStr
+      return Err(BadNumStr)
     neg := s.byteAt(0) == 45
     start := if neg || s.byteAt(0) == 43 then 1 else 0
     if start >= len
-      return error.BadNumStr
+      return Err(BadNumStr)
     value := 0
     i := start
     while i < len
       b := s.byteAt(i)
       if b < 48 || b > 57
-        return error.BadNumStr
+        return Err(BadNumStr)
       value = value * 10 + b - 48
       i = i + 1
-    return if neg then -value else value
+    return Ok(if neg then -value else value)
   fun abs(self) -> Int =
     if self < 0 then -self else self
@@ -197,9 +202,9 @@ primitive Int =
 # when `step` is negative. A `for x := range v` source via `next`.
 struct Range(start: Int, stop: Int, step: Int) =
-  fun next(self) -> Pair[Int, Range]? =
+  fun next(self) -> Option[Pair[Int, Range]] =
     more := if self.step > 0 then self.start < self.stop else self.start > self.stop
-    if more then Pair(first: self.start, second: Range(start: self.start + self.step, stop: self.stop, step: self.step)) else null
+    if more then Some(Pair(first: self.start, second: Range(start: self.start + self.step, stop: self.stop, step: self.step))) else None
   # Every `by`-th element, starting with the first (`by` > 0).
   fun stepBy(self, by: Int) -> Range =

plum-std/Json.plum CHANGED Viewed

@@ -7,6 +7,8 @@ import std/Int
 import std/Float
 import std/Str
 import std/Buffer
+import std/Option
+import std/Result
 # Placement rule for built-in `toJson` / `fromJson`: they live HERE, in this
 # file, as extension blocks at the bottom (`primitive Int =`, `primitive Slice[T] =`),
@@ -17,7 +19,16 @@ import std/Buffer
 # call `x.toJson()` / `T.fromJson(j)` per instantiation.
 # Why a JSON value could not be decoded into a type.
+enum JsonError =
+  | InvalidJson
+  | WrongJsonType
+  | MissingField
+  fun name(self) -> Str =
+    match self
+      InvalidJson => "InvalidJson"
-error JsonError = InvalidJson | WrongJsonType | MissingField
+      WrongJsonType => "WrongJsonType"
+      MissingField => "MissingField"
 # A parsed JSON value. Numbers are always stored as `Float` (JSON doesn't
@@ -36,7 +47,7 @@ enum Json =
   # from surrounding whitespace) to be consumed. Called as `Json.fromStr(s)`,
   # matching `Int.fromStr`/`Float.fromStr`'s naming. Errors carry no data: to
   # learn where and why a parse failed use `Json.parse(s)` instead.
-  fun fromStr(s: Str) -> error{InvalidJson}!Json =
+  fun fromStr(s: Str) -> Result[Json, JsonError] =
     parser := JsonParser(src: s, pos: 0, text: "")
     return parser.parseDocument()
@@ -44,9 +55,9 @@ enum Json =
   # document, or `Failed` with the position and message of the failure.
   fun parse(s: Str) -> JsonParse =
     parser := JsonParser(src: s, pos: 0, text: "")
-    v := parser.parseDocument() catch e
+    match parser.parseDocument()
+      Ok(v) => Parsed(value: v)
-      return Failed(pos: parser.pos, text: parser.text)
+      Err(e) => Failed(pos: parser.pos, text: parser.text)
-    return Parsed(value: v)
   # Renders `self` back to its JSON text form. A literal `{`/`}` is written
   # doubled (`{{`/`}}`) — a single, un-doubled brace in a Plum string starts
@@ -64,28 +75,28 @@ enum Json =
   fun encode(x: T) -> Str = x.toJson().toStr()
   # `T` comes from the result annotation: `h: JsonError!House := Json.decode(s)`.
-  fun decode(s: Str) -> JsonError!T =
+  fun decode(s: Str) -> Result[T, JsonError] =
-    j := try Json.fromStr(s)
+    j := Json.fromStr(s)?
     return T.fromJson(j)
   # Decodes an already-parsed value; `T` comes from the result type.
-  fun into(self) -> JsonError!T = T.fromJson(self)
+  fun into(self) -> Result[T, JsonError] = T.fromJson(self)
   # Explicit-decoder form: `Json.decodeWith(s, |j| House.fromJson(j))`.
-  fun decodeWith(s: Str, f: fn(Json) -> JsonError!T) -> JsonError!T =
+  fun decodeWith(s: Str, f: fn(Json) -> Result[T, JsonError]) -> Result[T, JsonError] =
-    j := try Json.fromStr(s)
+    j := Json.fromStr(s)?
     return f(j)
-  fun field(self, name: Str) -> JsonError!Json =
+  fun field(self, name: Str) -> Result[Json, JsonError] =
-    m := try self.asMap()
+    m := self.asMap()?
-    v := m.get(name) catch e
+    match m.get(name)
+      Some(v) => Ok(v)
-      return error.MissingField
+      None => Err(MissingField)
-    return v
-  fun optField(self, name: Str) -> Json? =
+  fun optField(self, name: Str) -> Option[Json] =
-    m := self.asMap() catch e
+    match self.asMap()
-      return null
-    return m.getOrNull(name)
+      Ok(m) => m.get(name)
+      Err(e) => None
   # `Json.object(["a" => x, "b" => y])`: a map literal is already a Json object.
   fun object(fields: Map[Str, Json]) -> Json =
@@ -100,37 +111,37 @@ enum Json =
   fun toJson(self) -> Json = self
-  fun fromJson(j: Json) -> JsonError!Json = j
+  fun fromJson(j: Json) -> Result[Json, JsonError] = Ok(j)
   fun isNull(self) -> Bool =
     match self
       JsonNull => true
       _ => false
-  fun asBool(self) -> error{WrongJsonType}!Bool =
+  fun asBool(self) -> Result[Bool, JsonError] =
     match self
-      JsonBool(value) => value
+      JsonBool(value) => Ok(value)
-      _ => error.WrongJsonType
+      _ => Err(WrongJsonType)
-  fun asFloat(self) -> error{WrongJsonType}!Float =
+  fun asFloat(self) -> Result[Float, JsonError] =
     match self
-      JsonNum(value) => value
+      JsonNum(value) => Ok(value)
-      _ => error.WrongJsonType
+      _ => Err(WrongJsonType)
-  fun asStr(self) -> error{WrongJsonType}!Str =
+  fun asStr(self) -> Result[Str, JsonError] =
     match self
-      JsonStr(value) => value
+      JsonStr(value) => Ok(value)
-      _ => error.WrongJsonType
+      _ => Err(WrongJsonType)
-  fun asList(self) -> error{WrongJsonType}!Slice[Json] =
+  fun asList(self) -> Result[Slice[Json], JsonError] =
     match self
-      JsonArr(items) => items
+      JsonArr(items) => Ok(items)
-      _ => error.WrongJsonType
+      _ => Err(WrongJsonType)
-  fun asMap(self) -> error{WrongJsonType}!Map[Str, Json] =
+  fun asMap(self) -> Result[Map[Str, Json], JsonError] =
     match self
-      JsonObj(fields) => fields
+      JsonObj(fields) => Ok(fields)
-      _ => error.WrongJsonType
+      _ => Err(WrongJsonType)
   # `Map` has no built-in `toStr`/`join` (unlike `Slice`, which uses `join` for
   # `Json.toStr`'s `JsonList` case above) — a static taking the
@@ -221,18 +232,23 @@ struct JsonParser(src: Str, mut pos: Int, mut text: Str) =
   fun note(self, text: Str) -> Unit =
     self.text = text
+  # Notes "invalid number" and gives the error to fail with.
+  fun badNumber(self) -> JsonError =
+    self.note("invalid number")
+    InvalidJson
   fun message(self) -> Str =
     "json parse error at position {self.pos}: {self.text}"
   # The whole document: one value, then only whitespace.
-  fun parseDocument(self) -> error{InvalidJson}!Json =
+  fun parseDocument(self) -> Result[Json, JsonError] =
     self.skipSpace()
-    v := try self.parseValue()
+    v := self.parseValue()?
     self.skipSpace()
     if self.pos < self.src.length()
       self.note("unexpected trailing characters")
-      return error.InvalidJson
+      return Err(InvalidJson)
-    return v
+    return Ok(v)
   # The raw byte at the current position, or 0 (never a valid JSON byte) past
   # the end of `src` — lets every caller test for "end of input" the same way
@@ -251,12 +267,12 @@ struct JsonParser(src: Str, mut pos: Int, mut text: Str) =
     while isSpace(self.peek())
       self.advance()
-  fun parseValue(self) -> error{InvalidJson}!Json =
+  fun parseValue(self) -> Result[Json, JsonError] =
     self.skipSpace()
     c := self.peek()
     if c == 34
-      str := try self.parseString()
+      str := self.parseString()?
-      return JsonStr(value: str)
+      return Ok(JsonStr(value: str))
     if c == 91
       return self.parseArray()
     if c == 123
@@ -270,30 +286,30 @@ struct JsonParser(src: Str, mut pos: Int, mut text: Str) =
     if c == 45 || isDigit(c)
       return self.parseNumber()
     self.note("unexpected character")
-    return error.InvalidJson
+    return Err(InvalidJson)
-  fun parseLiteral(self, lit: Str, value: Json) -> error{InvalidJson}!Json =
+  fun parseLiteral(self, lit: Str, value: Json) -> Result[Json, JsonError] =
     n := lit.length()
     if !Str.matchesAt(self.src, lit, self.pos, n)
       self.note("invalid literal, expected '{lit}'")
-      return error.InvalidJson
+      return Err(InvalidJson)
     self.pos = self.pos + n
-    return value
+    return Ok(value)
-  fun parseNumber(self) -> error{InvalidJson}!Json =
+  fun parseNumber(self) -> Result[Json, JsonError] =
     start := self.pos
     if self.peek() == 45
       self.advance()
     if !isDigit(self.peek())
       self.note("invalid number")
-      return error.InvalidJson
+      return Err(InvalidJson)
     while isDigit(self.peek())
       self.advance()
     if self.peek() == 46
       self.advance()
       if !isDigit(self.peek())
         self.note("invalid number")
-        return error.InvalidJson
+        return Err(InvalidJson)
       while isDigit(self.peek())
         self.advance()
     if self.peek() == 101 || self.peek() == 69
@@ -302,7 +318,7 @@ struct JsonParser(src: Str, mut pos: Int, mut text: Str) =
         self.advance()
       if !isDigit(self.peek())
         self.note("invalid number")
-        return error.InvalidJson
+        return Err(InvalidJson)
       while isDigit(self.peek())
         self.advance()
     return self.parseNumberText(self.src.sub(start, self.pos))
@@ -310,43 +326,37 @@ struct JsonParser(src: Str, mut pos: Int, mut text: Str) =
   # `Float.fromStr` (`libs/std/float.plum`) doesn't understand exponent
   # notation, so a number that has one is split into its mantissa and
   # exponent around the `e`/`E` and recombined here instead.
-  fun parseNumberText(self, text: Str) -> error{InvalidJson}!Json =
+  fun parseNumberText(self, text: Str) -> Result[Json, JsonError] =
     e_index := exponentIndex(text)
     if e_index < 0
-      f := Float.parse(text) catch e
+      f := Float.parse(text).mapErr(|e| self.badNumber())?
-        self.note("invalid number")
-        return error.InvalidJson
-      return JsonNum(value: f)
+      return Ok(JsonNum(value: f))
-    mv := Float.parse(text.sub(0, e_index)) catch e
+    mv := Float.parse(text.sub(0, e_index)).mapErr(|e| self.badNumber())?
-      self.note("invalid number")
-      return error.InvalidJson
-    ev := Int.parse(text.sub(e_index + 1, text.length())) catch e
+    ev := Int.parse(text.sub(e_index + 1, text.length())).mapErr(|e| self.badNumber())?
-      self.note("invalid number")
-      return error.InvalidJson
-    return JsonNum(value: mv * 10.pow(Float(ev)))
+    return Ok(JsonNum(value: mv * 10.pow(Float(ev))))
-  fun parseString(self) -> error{InvalidJson}!Str =
+  fun parseString(self) -> Result[Str, JsonError] =
     self.advance()
     buf := Buffer()
     while true
       c := self.peek()
       if c == 0
         self.note("unterminated string")
-        return error.InvalidJson
+        return Err(InvalidJson)
       if c == 34
         self.advance()
-        return buf.toStr()
+        return Ok(buf.toStr())
       if c == 92
-        try self.parseEscape(buf)
+        self.parseEscape(buf)?
       else
         n := self.src.codePointByteLength(self.pos)
         buf.write(self.src.sub(self.pos, self.pos + n))
         self.pos = self.pos + n
-    return buf.toStr()
+    return Ok(buf.toStr())
   # Handles one escape sequence (the cursor is on the backslash), writing the
   # decoded text into `buf`.
-  fun parseEscape(self, buf: Buffer) -> error{InvalidJson}!Unit =
+  fun parseEscape(self, buf: Buffer) -> Result[Unit, JsonError] =
     self.advance()
     esc := self.peek()
     if esc == 117
@@ -370,93 +380,95 @@ struct JsonParser(src: Str, mut pos: Int, mut text: Str) =
       buf.write("\t")
     else
       self.note("invalid escape character")
-      return error.InvalidJson
+      return Err(InvalidJson)
     self.advance()
+    Ok(Unit)
-  fun parseHex4(self) -> error{InvalidJson}!Int =
+  fun parseHex4(self) -> Result[Int, JsonError] =
     value := 0
     count := 0
     while count < 4
       d := hexDigitValue(self.peek())
       if d < 0
         self.note("invalid unicode escape")
-        return error.InvalidJson
+        return Err(InvalidJson)
       self.advance()
       value = value * 16 + d
       count = count + 1
-    return value
+    return Ok(value)
   # Decodes the four hex digits after `\u` (and, for a high surrogate
   # (`0xD800`..`0xDBFF`), the `\u` low surrogate (`0xDC00`..`0xDFFF`) that must
   # follow immediately; the pair encodes one codepoint above `0xFFFF`). Any
   # other codepoint is used as-is.
-  fun parseUnicodeEscape(self, buf: Buffer) -> error{InvalidJson}!Unit =
+  fun parseUnicodeEscape(self, buf: Buffer) -> Result[Unit, JsonError] =
-    cp := try self.parseHex4()
+    cp := self.parseHex4()?
     if cp >= 0xD800 && cp <= 0xDBFF && self.peek() == 92 && self.peekAt(1) == 117
       self.advance()
       self.advance()
-      low := try self.parseHex4()
+      low := self.parseHex4()?
       if low < 0xDC00 || low > 0xDFFF
         self.note("invalid low surrogate")
-        return error.InvalidJson
+        return Err(InvalidJson)
       combined := 0x10000 + {{cp - 0xD800} << 10} + {low - 0xDC00}
       buf.writeRune(combined)
-      return
+      return Ok(Unit)
     buf.writeRune(cp)
+    Ok(Unit)
-  fun parseArray(self) -> error{InvalidJson}!Json =
+  fun parseArray(self) -> Result[Json, JsonError] =
     self.advance()
     self.skipSpace()
     items := Slice[Json]()
     if self.peek() == 93
       self.advance()
-      return JsonArr(items: items)
+      return Ok(JsonArr(items: items))
     while true
       self.skipSpace()
-      v := try self.parseValue()
+      v := self.parseValue()?
       items.push(v)
       self.skipSpace()
       c := self.peek()
       if c == 93
         self.advance()
-        return JsonArr(items: items)
+        return Ok(JsonArr(items: items))
       if c != 44
         self.note("expected ',' or ']'")
-        return error.InvalidJson
+        return Err(InvalidJson)
       self.advance()
-    return JsonArr(items: items)
+    return Ok(JsonArr(items: items))
-  fun parseObject(self) -> error{InvalidJson}!Json =
+  fun parseObject(self) -> Result[Json, JsonError] =
     self.advance()
     self.skipSpace()
     pairs: Map[Str, Json] := Map.empty()
     if self.peek() == 125
       self.advance()
-      return JsonObj(fields: pairs)
+      return Ok(JsonObj(fields: pairs))
     while true
       self.skipSpace()
       if self.peek() != 34
         self.note("expected string key")
-        return error.InvalidJson
+        return Err(InvalidJson)
-      key := try self.parseString()
+      key := self.parseString()?
       self.skipSpace()
       if self.peek() != 58
         self.note("expected ':'")
-        return error.InvalidJson
+        return Err(InvalidJson)
       self.advance()
       self.skipSpace()
-      v := try self.parseValue()
+      v := self.parseValue()?
       pairs.set(key, v)
       self.skipSpace()
       c := self.peek()
       if c == 125
         self.advance()
-        return JsonObj(fields: pairs)
+        return Ok(JsonObj(fields: pairs))
       if c != 44
         self.note("expected ',' or '}}'")
-        return error.InvalidJson
+        return Err(InvalidJson)
       self.advance()
-    return JsonObj(fields: pairs)
+    return Ok(JsonObj(fields: pairs))
   fun exponentIndex(text: Str) -> Int =
     e := text.indexOf("e")
@@ -484,29 +496,29 @@ primitive Int =
   fun toJson(self) -> Json = JsonNum(value: Float(self))
   # Rejects a fraction and any magnitude of 2^53 or more (2^53+1 parses to 2^53, so the boundary is ambiguous).
-  fun fromJson(j: Json) -> JsonError!Int =
+  fun fromJson(j: Json) -> Result[Int, JsonError] =
-    f := try j.asFloat()
+    f := j.asFloat()?
     if f >= 9007199254740992.0f || f <= -9007199254740992.0f
-      return error.WrongJsonType
+      return Err(WrongJsonType)
     n := Int(f)
     if Float(n) != f
-      return error.WrongJsonType
+      return Err(WrongJsonType)
-    return n
+    return Ok(n)
 primitive Float =
   fun toJson(self) -> Json = JsonNum(value: self)
-  fun fromJson(j: Json) -> JsonError!Float = j.asFloat()
+  fun fromJson(j: Json) -> Result[Float, JsonError] = j.asFloat()
 primitive Bool =
   fun toJson(self) -> Json = JsonBool(value: self)
-  fun fromJson(j: Json) -> JsonError!Bool = j.asBool()
+  fun fromJson(j: Json) -> Result[Bool, JsonError] = j.asBool()
 primitive Str =
   fun toJson(self) -> Json = JsonStr(value: self)
-  fun fromJson(j: Json) -> JsonError!Str = j.asStr()
+  fun fromJson(j: Json) -> Result[Str, JsonError] = j.asStr()
 primitive Slice[T] =
   # A JSON array of the elements' own `toJson()`.
@@ -517,12 +529,12 @@ primitive Slice[T] =
     return JsonArr(items: out)
   # Decodes each element with `T.fromJson`.
-  fun fromJson(j: Json) -> JsonError!Slice[T] =
+  fun fromJson(j: Json) -> Result[Slice[T], JsonError] =
-    items := try j.asList()
+    items := j.asList()?
     out := Slice[T]()
     for x := range items
-      out.push(try T.fromJson(x))
+      out.push(T.fromJson(x)?)
-    return out
+    return Ok(out)
 primitive Map[K, V] =
   # A JSON object; keys must be `Str`.
@@ -532,20 +544,20 @@ primitive Map[K, V] =
       out.set(e.first, e.second.toJson())
     return JsonObj(fields: out)
-  fun fromJson(j: Json) -> JsonError!Map[Str, V] =
+  fun fromJson(j: Json) -> Result[Map[Str, V], JsonError] =
-    pairs := try j.asMap()
+    pairs := j.asMap()?
     out: Map[Str, V] := Map.empty()
     for e := range pairs.entries()
-      out.set(e.first, try V.fromJson(e.second))
+      out.set(e.first, V.fromJson(e.second)?)
-    return out
+    return Ok(out)
-fun jsonTestDecodeInt(s: Str) -> JsonError!Int = Json.decode(s)
+fun jsonTestDecodeInt(s: Str) -> Result[Int, JsonError] = Json.decode(s)
-fun jsonTestDecodeNested(s: Str) -> JsonError!Slice[Slice[Int]] = Json.decode(s)
+fun jsonTestDecodeNested(s: Str) -> Result[Slice[Slice[Int]], JsonError] = Json.decode(s)
-fun jsonTestDecodeMap(s: Str) -> JsonError!Map[Str, Int] = Json.decode(s)
+fun jsonTestDecodeMap(s: Str) -> Result[Map[Str, Int], JsonError] = Json.decode(s)
-fun jsonTestDecodeStr(s: Str) -> JsonError!Str = Json.decode(s)
+fun jsonTestDecodeStr(s: Str) -> Result[Str, JsonError] = Json.decode(s)
 # Fixture for the round-trip tests: a hand-written record codec (also a
 # worked example of the pattern), including a Slice of itself.
@@ -553,20 +565,20 @@ struct JsonTestHouse(name: Str, rooms: Int, kids: Slice[JsonTestHouse]) =
   fun toJson(self) -> Json =
     Json.object(["name" => self.name.toJson(), "rooms" => self.rooms.toJson(), "kids" => self.kids.toJson()])
-  fun fromJson(j: Json) -> JsonError!JsonTestHouse =
+  fun fromJson(j: Json) -> Result[JsonTestHouse, JsonError] =
-    name := try Str.fromJson(try j.field("name"))
+    name := Str.fromJson(j.field("name")?)?
-    rooms := try Int.fromJson(try j.field("rooms"))
+    rooms := Int.fromJson(j.field("rooms")?)?
-    kids := try jsonTestKidsOf(try j.field("kids"))
+    kids := jsonTestKidsOf(j.field("kids")?)?
-    return JsonTestHouse(name: name, rooms: rooms, kids: kids)
+    return Ok(JsonTestHouse(name: name, rooms: rooms, kids: kids))
-fun jsonTestKidsOf(j: Json) -> JsonError!Slice[JsonTestHouse] = j.into()
+fun jsonTestKidsOf(j: Json) -> Result[Slice[JsonTestHouse], JsonError] = j.into()
 fun jsonTestHouseError(s: Str) -> Str =
-  jsonTestDecodeHouse(s) catch e
+  match jsonTestDecodeHouse(s)
+    Ok(h) => "ok"
-    return e.name()
+    Err(e) => e.name()
-  "ok"
-fun jsonTestDecodeHouse(s: Str) -> JsonError!JsonTestHouse = Json.decode(s)
+fun jsonTestDecodeHouse(s: Str) -> Result[JsonTestHouse, JsonError] = Json.decode(s)
 test "parses null, true, and false"
   assert Json.fromStr("null")!.isNull()
@@ -604,9 +616,9 @@ test "parses a nested object"
   assert inner.get(2)!.asFloat()! == 3.0f
 test "reports an error on malformed input"
-  bad := Json.fromStr("{{\"a\": }}") catch JsonNull
+  bad := Json.fromStr("{{\"a\": }}").unwrapOr(JsonNull)
   assert bad.isNull()
-  assert {Json.fromStr("[1,") catch JsonNull}.isNull()
+  assert Json.fromStr("[1,").unwrapOr(JsonNull).isNull()
 test "parse reports where and why a document is invalid"
   match Json.parse("[1, x]")
@@ -690,20 +702,20 @@ test "api: field missing, wrong container, optField"
   o := Json.fromStr("{{\"a\":1}}")!
   l0 := Json.array([])
   assert o.field("a")!.asFloat()! == 1.0f
-  assert {o.field("x") catch JsonNull}.isNull()
+  assert o.field("x").unwrapOr(JsonNull).isNull()
-  assert {l0.field("x") catch JsonNull}.isNull()
+  assert l0.field("x").unwrapOr(JsonNull).isNull()
-  assert o.optField("a") != null
+  assert o.optField("a").isSome()
-  assert o.optField("x") == null
+  assert o.optField("x").isNone()
-  assert l0.optField("a") == null
+  assert l0.optField("a").isNone()
   assert Json.object(["a" => Json.array([])]).toStr() == "{{\"a\":[]}}"
 test "int_fraction_rejected and int_over_2_53_rejected"
-  assert {jsonTestDecodeInt("3.5") catch -1} == -1
+  assert jsonTestDecodeInt("3.5").unwrapOr(-1) == -1
-  assert {jsonTestDecodeInt("1e17") catch -1} == -1
+  assert jsonTestDecodeInt("1e17").unwrapOr(-1) == -1
-  assert {jsonTestDecodeInt("9007199254740993") catch -1} == -1
+  assert jsonTestDecodeInt("9007199254740993").unwrapOr(-1) == -1
-  assert {jsonTestDecodeInt("[1]") catch -1} == -1
+  assert jsonTestDecodeInt("[1]").unwrapOr(-1) == -1
   assert jsonTestDecodeInt("-7")! == -7
-  assert {jsonTestDecodeInt("9007199254740992") catch -1} == -1
+  assert jsonTestDecodeInt("9007199254740992").unwrapOr(-1) == -1
   assert jsonTestDecodeInt("9007199254740991")! == 9007199254740991
 test "nested_list_of_lists round-trips"
@@ -711,10 +723,10 @@ test "nested_list_of_lists round-trips"
   assert v.length() == 3
   assert v.get(0)!.get(1)! == 2
   assert Json.encode(v) == "[[1.0,2.0],[3.0],[]]"
-  assert {jsonTestDecodeNested("[[1,\"x\"]]") catch Slice[Slice[Int]]()}.length() == 0
+  assert jsonTestDecodeNested("[[1,\"x\"]]").unwrapOr(Slice[Slice[Int]]()).length() == 0
 test "map_non_object_rejected"
-  assert {jsonTestDecodeMap("[]") catch Map.empty()}.length() == 0
+  assert jsonTestDecodeMap("[]").unwrapOr(Map.empty()).length() == 0
   assert jsonTestDecodeMap("{{\"a\":2}}")!.get("a")! == 2
 test "str_unicode_roundtrip"
@@ -735,9 +747,9 @@ test "record round-trips including a list of itself"
   assert Json.encode(back) == text
 test "field_missing and decode_invalid"
-  assert {jsonTestDecodeHouse("{{\"name\":\"x\"}}") catch JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())}.name == "E"
+  assert jsonTestDecodeHouse("{{\"name\":\"x\"}}").unwrapOr(JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())).name == "E"
-  assert {jsonTestDecodeHouse("{{oops") catch JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())}.name == "E"
+  assert jsonTestDecodeHouse("{{oops").unwrapOr(JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())).name == "E"
-  assert {jsonTestDecodeHouse("[1]") catch JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())}.name == "E"
+  assert jsonTestDecodeHouse("[1]").unwrapOr(JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())).name == "E"
 test "decodeWith uses an explicit decoder"
   h := Json.decodeWith("{{\"name\":\"w\",\"rooms\":1,\"kids\":[]}}", |j| JsonTestHouse.fromJson(j))!

plum-std/List.plum CHANGED Viewed

@@ -3,6 +3,7 @@ module std
 import std/Array
 import std/Buffer
 import std/Int
+import std/Option
 import std/Pair
 import std/Slice
 import std/Str
@@ -25,13 +26,13 @@ enum List[T] =
   fun length(self) -> Int = self.lengthFrom(0)
-  # The element at index i, or null when out of range.
+  # The element at index i, or None when out of range.
-  fun get(self, i: Int) -> T? = match self
+  fun get(self, i: Int) -> Option[T] = match self
-    Nil => null
+    Nil => None
-    Cons(h, t) => if i < 0 then null else if i == 0 then h else t.get(i - 1)
+    Cons(h, t) => if i < 0 then None else if i == 0 then Some(h) else t.get(i - 1)
   # The element at index i (O(i) per call). Crashes out of range.
-  fun at(self, i: Int) -> T = self.get(i) ?: crash "List.at out of range"
+  fun at(self, i: Int) -> T = self.get(i)!
   fun map(self, f: fn(T) -> B) -> List[B] = mapCells(self, f)
@@ -57,10 +58,10 @@ enum List[T] =
   fun append(self, ys: List[T]) -> List[T] =
     self.reverse().revOnto(ys)
-  # The iterator step: `Pair(head, tail)`, or null once the list is done.
+  # The iterator step: `Some(Pair(head, tail))`, or None once the list is done.
-  fun next(self) -> Pair[T, List[T]]? = match self
+  fun next(self) -> Option[Pair[T, List[T]]] = match self
-    Nil => null
+    Nil => None
-    Cons(h, t) => Pair(first: h, second: t)
+    Cons(h, t) => Some(Pair(first: h, second: t))
   # The elements of `xs` as a cons list, in order.
   fun fromSlice(xs: Slice[T]) -> List[T] =

plum-std/Map.plum CHANGED Viewed

@@ -7,6 +7,7 @@ import std/Float
 import std/Str
 import std/Buffer
 import std/Pair
+import std/Option
 # A Map is an open-addressing hash table with an insertion-ordered dense entry
 # store (the layout of Python's dict):
@@ -74,16 +75,16 @@ struct Map[K, V](mut index: Array[Int], mut hashes: Array[Int], mut keys: Array[
       slot = {slot + 1} & mask
     return -1
-  # Gets the value for `k`, or fails with `KeyNotFound` if absent.
+  # Gets the value for `k`, or None if absent.
-  fun get(self, k: K) -> error{KeyNotFound}!V =
+  fun get(self, k: K) -> Option[V] =
     slot := self.findSlot(k, self.hashOf(k))
     if slot < 0
-      return error.KeyNotFound
+      return None
-    return self.vals.get(self.index.get(slot) - 2)
+    Some(self.vals.get(self.index.get(slot) - 2))
-  # Gets the value for `k`, or null if absent.
+  # Gets the value for `k`, or None if absent (same as `get`; kept for callers not yet ported).
-  fun getOrNull(self, k: K) -> V? =
+  fun getOrNull(self, k: K) -> Option[V] =
-    return self.get(k) catch return null
+    return self.get(k)
   fun has(self, k: K) -> Bool =
     return self.findSlot(k, self.hashOf(k)) >= 0

plum-std/Os.plum CHANGED Viewed

@@ -7,9 +7,17 @@ import std/Random
 import std/Int
 import std/Float
 import std/Io
+import std/Option
+import std/Result
 # What the file functions that may hit either problem can fail with.
+enum IoError =
+  | IoFailed
+  | NoSuchPath
+  fun name(self) -> Str = match self
+    IoFailed => "IoFailed"
-error IoError = IoFailed | NoSuchPath
+    NoSuchPath => "NoSuchPath"
 # Writes the specified data, followed by the current line terminator, to the
 # standard output stream. `extern` means this compiles to a genuine wasm import
@@ -48,29 +56,32 @@ primitive Os =
   # Reads the whole file at `path` as a `Str` (`Str` is a byte array here — see
   # `libs/std/str.plum` — so this works for binary content too, not just text).
-  fun readFile(io: Io, path: Str) -> error{NoSuchPath}!Str =
+  fun readFile(io: Io, path: Str) -> Result[Str, IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
-    return io.rawReadFile(path)
+    return Ok(io.rawReadFile(path))
   # Writes `data` to `path`, replacing its previous contents (or creating it).
-  fun writeFile(io: Io, path: Str, data: Str) -> error{IoFailed}!Unit =
+  fun writeFile(io: Io, path: Str, data: Str) -> Result[Unit, IoError] =
     if io.rawWriteFile(path, data) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   fun exists(io: Io, path: Str) -> Bool =
     return io.rawExists(path) == 1
-  fun mkdir(io: Io, path: Str) -> error{IoFailed}!Unit =
+  fun mkdir(io: Io, path: Str) -> Result[Unit, IoError] =
     if io.rawMkdir(path) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # Removes the file (not directory) at `path`.
-  fun remove(io: Io, path: Str) -> IoError!Unit =
+  fun remove(io: Io, path: Str) -> Result[Unit, IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
     if io.rawRemove(path) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # Whether `path` exists and is reachable — this VM has no notion of a
   # process' effective uid/gid, so (unlike POSIX `access(2)`) there is no mode
@@ -82,36 +93,36 @@ primitive Os =
   # contents) if it doesn't already exist. There's no host-level "open for
   # append" primitive, so this reads the existing bytes and writes the
   # concatenation back — not atomic, and O(existing file size) per call.
-  fun appendFile(io: Io, path: Str, data: Str) -> IoError!Unit =
+  fun appendFile(io: Io, path: Str, data: Str) -> Result[Unit, IoError] =
     if exists(io, path)
-      existing := try readFile(io, path)
+      existing := readFile(io, path)?
-      try writeFile(io, path, existing + data)
+      return writeFile(io, path, existing + data)
-      return
-    try writeFile(io, path, data)
+    writeFile(io, path, data)
   # Unix permission bits only (e.g. `0o644`) — this VM has no Windows ACL
   # equivalent to fall back to.
-  fun chmod(io: Io, path: Str, mode: Int) -> error{IoFailed}!Unit =
+  fun chmod(io: Io, path: Str, mode: Int) -> Result[Unit, IoError] =
     if io.rawChmod(path, mode) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # There is no host primitive for changing file ownership (it needs a uid/gid
   # syscall this VM doesn't expose), unlike the permission-bits-only `chmod`.
   fun chown(path: Str, uid: Int, gid: Int) =
     todo
-  fun copyFile(io: Io, src: Str, dest: Str) -> IoError!Unit =
+  fun copyFile(io: Io, src: Str, dest: Str) -> Result[Unit, IoError] =
-    data := try readFile(io, src)
+    data := readFile(io, src)?
-    try writeFile(io, dest, data)
+    writeFile(io, dest, data)
-  fun cp(io: Io, src: Str, dest: Str) -> IoError!Unit =
+  fun cp(io: Io, src: Str, dest: Str) -> Result[Unit, IoError] =
-    try copyFile(io, src, dest)
+    copyFile(io, src, dest)
   # Symlinks aren't modeled separately from regular files/dirs by this VM's
   # host primitives (`rawChmod` always follows them), so this is the same as
   # `chmod`.
-  fun lchmod(io: Io, path: Str, mode: Int) -> error{IoFailed}!Unit =
+  fun lchmod(io: Io, path: Str, mode: Int) -> Result[Unit, IoError] =
-    try chmod(io, path, mode)
+    chmod(io, path, mode)
   # See `chown` — no uid/gid syscall exposed by this VM.
   fun lchown(path: Str, uid: Int, gid: Int) =
@@ -122,9 +133,10 @@ primitive Os =
   fun lutimes(path: Str, atime: Int, mtime: Int) =
     todo
-  fun link(io: Io, existing_path: Str, new_path: Str) -> error{IoFailed}!Unit =
+  fun link(io: Io, existing_path: Str, new_path: Str) -> Result[Unit, IoError] =
     if io.rawLink(existing_path, new_path) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # Would need a real `Stat` struct type (size/mode/mtime/uid/gid/...) to
   # return anything useful — no such type exists in the stdlib yet.
@@ -134,12 +146,12 @@ primitive Os =
   # Creates a fresh directory named `prefix` followed by a random suffix,
   # retrying on the (astronomically unlikely) chance of a collision, and
   # returns the path actually created.
-  fun mkdtemp(io: Io, prefix: Str) -> error{IoFailed}!Str =
+  fun mkdtemp(io: Io, prefix: Str) -> Result[Str, IoError] =
     path := prefix + Uuid.v4(Random.seeded(io.randomSeed())).value.toStr()
     if exists(io, path)
       return mkdtemp(io, prefix)
-    try mkdir(io, path)
+    mkdir(io, path)?
-    return path
+    return Ok(path)
   # Would need a host-side open-file-descriptor table (this VM's other file
   # ops are all one-shot: open+read/write+close in a single host call) plus a
@@ -152,9 +164,9 @@ primitive Os =
     todo
   # The names of `path`'s directory entries (not full paths).
-  fun readdir(io: Io, path: Str) -> error{NoSuchPath}!Slice[Str] =
+  fun readdir(io: Io, path: Str) -> Result[Slice[Str], IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
     # skipping empty names handles both a genuinely empty directory (whose
     # joined `""` would otherwise split into one bogus `""` entry) and
     # `rawReadDir`'s "unreadable" fallback (already ruled out by the `exists`
@@ -163,30 +175,32 @@ primitive Os =
     for n := range io.rawReadDir(path).split("\n", 0)
       if n != ""
         names.push(n)
-    return names
+    return Ok(names)
-  fun readlink(io: Io, path: Str) -> error{NoSuchPath}!Str =
+  fun readlink(io: Io, path: Str) -> Result[Str, IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
-    return io.rawReadlink(path)
+    return Ok(io.rawReadlink(path))
-  fun realpath(io: Io, path: Str) -> error{NoSuchPath}!Str =
+  fun realpath(io: Io, path: Str) -> Result[Str, IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
-    return io.rawRealpath(path)
+    return Ok(io.rawRealpath(path))
-  fun rename(io: Io, old_path: Str, new_path: Str) -> IoError!Unit =
+  fun rename(io: Io, old_path: Str, new_path: Str) -> Result[Unit, IoError] =
     if !exists(io, old_path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
     if io.rawRename(old_path, new_path) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # Removes an empty directory. (`remove` above covers plain files.)
-  fun rmdir(io: Io, path: Str) -> IoError!Unit =
+  fun rmdir(io: Io, path: Str) -> Result[Unit, IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
     if io.rawRemoveDir(path) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # See `lstat` — needs a `Stat` struct type.
   fun stat(path: Str) =
@@ -196,17 +210,19 @@ primitive Os =
   fun statfs(path: Str) =
     todo
-  fun symlink(io: Io, target: Str, path: Str) -> error{IoFailed}!Unit =
+  fun symlink(io: Io, target: Str, path: Str) -> Result[Unit, IoError] =
     if io.rawSymlink(target, path) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # Resizes the file at `path` to exactly `len` bytes — truncated if shorter,
   # zero-padded if longer.
-  fun truncate(io: Io, path: Str, len: Int) -> IoError!Unit =
+  fun truncate(io: Io, path: Str, len: Int) -> Result[Unit, IoError] =
     if !exists(io, path)
-      return error.NoSuchPath
+      return Err(NoSuchPath)
     if io.rawTruncate(path, len) != 1
-      return error.IoFailed
+      return Err(IoFailed)
+    Ok(Unit)
   # See `lutimes` — same missing syscall.
   fun utimes(path: Str, atime: Int, mtime: Int) =
@@ -297,10 +313,10 @@ test "link creates a second name for the same file"
   Os.rmdir(io, dir)!
 test "readFile/remove/rmdir report errors for missing paths"
-  assert {Os.readFile(io, "/tmp/plum_os_test_does_not_exist.txt") catch "gone"} == "gone"
+  assert Os.readFile(io, "/tmp/plum_os_test_does_not_exist.txt").unwrapOr("gone") == "gone"
   failed := 0
-  Os.remove(io, "/tmp/plum_os_test_does_not_exist.txt") catch e
+  if Err(e) := Os.remove(io, "/tmp/plum_os_test_does_not_exist.txt")
     failed = failed + 1
-  Os.rmdir(io, "/tmp/plum_os_test_does_not_exist_dir") catch e
+  if Err(e) := Os.rmdir(io, "/tmp/plum_os_test_does_not_exist_dir")
     failed = failed + 1
   assert failed == 2

plum-std/Pair.plum CHANGED Viewed

@@ -1,11 +1,12 @@
 module std
 import std/Str
+import std/Option
 # A Pair groups two values (a key with its value in a Map) (`k => v` in a call is sugar for
 # `Pair(k, v)`). It is also the step of the loop protocol: a type with
-# `next(self) -> Pair[T, Self]?` is a `for x := range v` source (null = done,
+# `next(self) -> Option[Pair[T, Self]]` is a `for x := range v` source (None = done,
-# else `Pair(value, rest)`).
+# else `Some(Pair(value, rest))`).
 struct Pair[A, B](first: A, second: B) =
   fun toStr(self) -> Str =

plum-std/Slice.plum CHANGED Viewed

@@ -6,6 +6,7 @@ import std/Int
 import std/Float
 import std/Str
 import std/Random
+import std/Option
 # A growable list over a backing `Array[T]`: element `i` is `data[start + i]`,
 # `size` slots are in use and `cap` slots (from `start`) may be written. Capacity
@@ -25,18 +26,18 @@ struct Slice[T](mut data: Array[T], mut start: Int, mut size: Int, mut cap: Int)
     Slice(data: Array[T](), start: 0, size: 0, cap: 0)
   # gets the element at i'th index of the list
-  fun get(self, i: Int) -> error{OutOfBounds}!T =
+  fun get(self, i: Int) -> Option[T] =
     if i < 0 || i >= self.size
-      return error.OutOfBounds
+      return None
-    self.data.get(self.start + i)
+    Some(self.data.get(self.start + i))
-  # sets the element at i'th index of the list, returning the old value (or fails with `OutOfBounds` if i is out of bounds)
+  # sets the element at i'th index of the list, returning the old value (or None if i is out of bounds)
-  fun set(self, i: Int, v: T) -> error{OutOfBounds}!T =
+  fun set(self, i: Int, v: T) -> Option[T] =
     if i < 0 || i >= self.size
-      return error.OutOfBounds
+      return None
     old := self.data.get(self.start + i)
     self.data.set(self.start + i, v)
-    old
+    Some(old)
   # the element at index i, unchecked (the `for x := range list` protocol; i must be in range)
   fun at(self, i: Int) -> T =
@@ -111,12 +112,12 @@ struct Slice[T](mut data: Array[T], mut start: Int, mut size: Int, mut cap: Int)
     for v := range values
       self.push(v)
-  # removes and returns the last element, or fails with `ListWasEmpty` if empty
+  # removes and returns the last element, or None if empty
-  fun pop(self) -> error{ListWasEmpty}!T =
+  fun pop(self) -> Option[T] =
     if self.size == 0
-      return error.ListWasEmpty
+      return None
     self.size = self.size - 1
-    self.data.get(self.start + self.size)
+    Some(self.data.get(self.start + self.size))
   # removes the element at i'th index of the list (out of range is a no-op)
   fun removeAt(self, i: Int) =
@@ -170,15 +171,15 @@ struct Slice[T](mut data: Array[T], mut start: Int, mut size: Int, mut cap: Int)
       i = i + 1
     return result
-  # Returns the first element equal to `search`, or fails with `NotFound`.
+  # Returns the first element equal to `search`, or None.
-  fun findValue(self, search: T) -> error{NotFound}!T =
+  fun findValue(self, search: T) -> Option[T] =
     i := 0
     while i < self.size
       value := self.data.get(self.start + i)
       if value == search
-        return value
+        return Some(value)
       i = i + 1
-    return error.NotFound
+    return None
   fun contains(self, v: T) -> Bool =
     i := 0
@@ -189,22 +190,22 @@ struct Slice[T](mut data: Array[T], mut start: Int, mut size: Int, mut cap: Int)
     return false
   # returns the first element in the list
-  fun first(self) -> error{ListWasEmpty}!T =
+  fun first(self) -> Option[T] =
     if self.size == 0
-      return error.ListWasEmpty
+      return None
-    self.data.get(self.start + 0)
+    Some(self.data.get(self.start + 0))
-  # the first element, or null when the list is empty (the typed tail of `find`)
+  # the first element, or None when the list is empty (the typed tail of `find`)
-  fun head(self) -> T? =
+  fun head(self) -> Option[T] =
     if self.size == 0
-      return null
+      return None
-    return self.data.get(self.start + 0)
+    return Some(self.data.get(self.start + 0))
   # returns the last element in the list
-  fun last(self) -> error{ListWasEmpty}!T =
+  fun last(self) -> Option[T] =
     if self.size == 0
-      return error.ListWasEmpty
+      return None
-    self.data.get(self.start + self.size - 1)
+    Some(self.data.get(self.start + self.size - 1))
   # Returns a new list of the elements at index `[start, end)`, clamped into
   # range (a `start`/`end` outside `[0, length]` is clamped, not an error).
@@ -222,13 +223,13 @@ struct Slice[T](mut data: Array[T], mut start: Int, mut size: Int, mut cap: Int)
   fun drop(self, n: Int) -> Slice[T] =
     return self.sublist(n, self.size)
-  # Returns one uniformly random element and the advanced generator, or fails with
+  # Returns one uniformly random element and the advanced generator, or None
-  # `ListWasEmpty` if `self` is empty.
+  # if `self` is empty.
-  fun sample(self, rng: Random) -> error{ListWasEmpty}!Rolled[T] =
+  fun sample(self, rng: Random) -> Option[Rolled[T]] =
     if self.size == 0
-      return error.ListWasEmpty
+      return None
     d := rng.nextIntBelow(self.size)
-    return Rolled(value: self.data.get(self.start + d.value), rng: d.rng)
+    return Some(Rolled(value: self.data.get(self.start + d.value), rng: d.rng))
   # Returns a new list with `self`'s elements in random order (Fisher-Yates) and the
   # advanced generator.
@@ -317,7 +318,7 @@ test "removing every node in a loop leaves an empty correctly functioning list"
     l.removeAt(0)
     i = i + 1
   assert l.length() == 0
-  assert {l.get(0) catch -1000} == -1000
+  assert l.get(0).unwrapOr(-1000) == -1000
   l.add(Slice[Int]())
   l.push(42)
   assert l.get(0)! == 42
@@ -363,8 +364,8 @@ test "list sort orders elements correctly"
   l.push(1)
   l.push(5)
   sorted := l.sort(|a, b| a < b)
-  assert {sorted.get(0) catch -1000} == 1
+  assert sorted.get(0).unwrapOr(-1000) == 1
-  assert {sorted.get(4) catch -1000} == 5
+  assert sorted.get(4).unwrapOr(-1000) == 5
 test "list join renders elements correctly with separator"
   l := Slice[Int]()
@@ -404,7 +405,7 @@ test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty
     i = i + 1
   assert l.length() == 1000
   assert l.get(999)! == 999
-  assert {l.get(1000) catch -1000} == -1000
+  assert l.get(1000).unwrapOr(-1000) == -1000
   assert l.set(500, 7)! == 500
   assert l.get(500)! == 7
   assert l.pop()! == 999
@@ -412,10 +413,10 @@ test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty
   while l.length() > 0
     _ := l.pop()!
   assert l.length() == 0
-  assert {l.pop() catch -1} == -1
+  assert l.pop().unwrapOr(-1) == -1
-  assert {l.get(0) catch -1000} == -1000
+  assert l.get(0).unwrapOr(-1000) == -1000
   e := l.get(0)
-  assert {e catch -1} == -1
+  assert e.unwrapOr(-1) == -1
 test "list_growth: length stays exact across the doubling boundaries"
   l := Slice[Int]()
@@ -460,7 +461,7 @@ test "slice is a view: shares storage, no copy"
   assert ys.length() == 3
   assert ys.get(0)! == 2
   assert ys.get(2)! == 4
-  assert {ys.get(3) catch -1} == -1
+  assert ys.get(3).unwrapOr(-1) == -1
   _ := ys.set(0, 20)!
   assert xs.get(1)! == 20
   _ := xs.set(3, 40)!

plum-std/Testing.plum CHANGED Viewed

@@ -5,6 +5,8 @@ import std/Int
 import std/Float
 import std/Str
 import std/List
+import std/Option
+import std/Result
 # Small jest/rspec-style assertion helpers for use inside `test` blocks, e.g.
 #
@@ -18,9 +20,10 @@ import std/List
 # assertion instead of a raw comparison.
 #
 # `expectArray`/`expectSuccess`/`expectFailure` below take a container
-# type (`Slice[T]`/`!T`) whose OWN generic param is
+# type (`Slice[T]`/`Result[T, E]`) whose OWN generic param is
-# nested inside the param type. An error union is inspected with
+# nested inside the param type. A Result is inspected with
-# `catch` (`r catch 0`, `r!`); `expectFailureNamed` also checks which error it is.
+# `unwrapOr` (`r.unwrapOr(0)`, `r!`); `expectFailureNamed` also checks which error it is
+# (the error enum provides `fun name(self) -> Str`).
 #
 # CAVEAT on `expectEq`/`expectNotEq`/`expectObject`/`Slice.equals`: Plum's
 # `==`/`!=` have no operator-overloading mechanism. For Int/Str/Bool/Float
@@ -55,21 +58,27 @@ primitive Testing =
   fun expectArray(a: Slice[T], b: Slice[T]) -> Bool =
     a.equals(b)
-  fun expectSuccess(r: !T) -> Bool =
+  fun expectSuccess(r: Result[T, E]) -> Bool = match r
-    r catch e
+    Ok(_) => true
-      return false
+    Err(_) => false
-    true
-  fun expectFailure(r: !T) -> Bool =
+  fun expectFailure(r: Result[T, E]) -> Bool = match r
-    r catch e
+    Ok(_) => false
-      return true
+    Err(_) => true
-    false
   # True when `r` failed with the error named `name`.
-  fun expectFailureNamed(r: !T, name: Str) -> Bool =
+  fun expectFailureNamed(r: Result[T, E], name: Str) -> Bool = match r
-    r catch e
+    Ok(_) => false
-      return e.name() == name
+    Err(e) => e.name() == name
+# The error enum the tests below use.
+enum Oops =
+  | Bad
-    false
+  | Worse
+  fun name(self) -> Str = match self
+    Bad => "Bad"
+    Worse => "Worse"
 test "expectTrue and expectFalse"
   assert Testing.expectTrue(1 == 1)
@@ -87,11 +96,11 @@ test "list equality via the Slice.equals method"
   assert a.equals(b)
   assert Testing.expectFalse(a.equals(c))
-test "error unions are inspected with catch and !"
+test "Results are inspected with unwrapOr and !"
-  ok: error{Bad}!Int := 5
+  ok: Result[Int, Oops] := Ok(5)
-  bad: error{Bad}!Int := error.Bad
+  bad: Result[Int, Oops] := Err(Bad)
   assert ok! == 5
-  assert {bad catch -1} == -1
+  assert bad.unwrapOr(-1) == -1
 test "expectArray compares two Slice[T]s elementwise"
   a := [1, 2, 3].toSlice()
@@ -104,8 +113,8 @@ test "expectArray compares two Slice[T]s elementwise"
   assert Testing.expectArray(d, e)
 test "expectSuccess/expectFailure check the right variant"
-  ok: error{Bad}!Int := 5
+  ok: Result[Int, Oops] := Ok(5)
-  bad: error{Bad}!Int := error.Bad
+  bad: Result[Int, Oops] := Err(Bad)
   assert Testing.expectSuccess(ok)
   assert Testing.expectFalse(Testing.expectSuccess(bad))
   assert Testing.expectFailure(bad)

plum-std/Uuid.plum CHANGED Viewed

@@ -4,9 +4,14 @@ import std/Int
 import std/Float
 import std/Str
 import std/Random
+import std/Option
+import std/Result
 # A UUID, stored as its canonical 36-character
 # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.
+# Why `Uuid.fromStr` failed.
+enum UuidError = InvalidUuid
 struct Uuid(value: Str) =
   fun toStr(self) -> Str =
@@ -44,26 +49,25 @@ struct Uuid(value: Str) =
     return Uuid(value: Uuid.Nil)
   # Parses the canonical `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form
-  # (case-insensitive), failing with `InvalidUuid` if `s` isn't exactly that shape.
+  # (case-insensitive), failing with `Err(InvalidUuid)` if `s` isn't exactly that shape.
-  fun fromStr(s: Str) -> error{InvalidUuid}!Uuid =
+  fun fromStr(s: Str) -> Result[Uuid, UuidError] =
     if s.length() != 36
-      return error.InvalidUuid
+      return Err(InvalidUuid)
     i := 0
     while i < 36
       if i == 8 || i == 13 || i == 18 || i == 23
         # '-'
         if s.byteAt(i) != 45
-          return error.InvalidUuid
+          return Err(InvalidUuid)
       else
         if hexValue(s.byteAt(i)) < 0
-          return error.InvalidUuid
+          return Err(InvalidUuid)
       i = i + 1
-    return Uuid(value: s.toLower())
+    return Ok(Uuid(value: s.toLower()))
-  fun isValid(s: Str) -> Bool =
+  fun isValid(s: Str) -> Bool = match fromStr(s)
-    fromStr(s) catch e
+    Ok(_) => true
-      return false
+    Err(_) => false
-    return true
   # A random (version 4, RFC 4122) UUID drawn from `rng`, and the advanced generator.
   fun v4(rng: Random) -> Rolled[Uuid] =

plum-std/game/Affine.plum CHANGED Viewed

@@ -3,6 +3,7 @@ module std
 import std/Float
 import std/Math
 import std/game/Vec2
+import std/Option
 # A 2D affine transform: x' = a*x + c*y + e, y' = b*x + d*y + f.
 struct Affine(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) =
@@ -36,19 +37,19 @@ struct Affine(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) =
       e: 0.0 - {ia * self.e + ic * self.f},
       f: 0.0 - {ib * self.e + id * self.f})
-  # The transform that undoes this one, or null if it is singular.
+  # The transform that undoes this one, or None if it is singular.
-  fun invert(self) -> Affine? =
+  fun invert(self) -> Option[Affine] =
     det := self.a * self.d - self.b * self.c
     if det == 0.0 || {det * 0.0} != 0.0
-      return null
+      return None
     ia := self.d / det
     ib := 0.0 - self.b / det
     ic := 0.0 - self.c / det
     id := self.a / det
-    Affine(
+    Some(Affine(
       a: ia, b: ib, c: ic, d: id,
       e: 0.0 - {ia * self.e + ic * self.f},
-      f: 0.0 - {ib * self.e + id * self.f})
+      f: 0.0 - {ib * self.e + id * self.f}))
   fun scaleX(self) -> Float =
     Math.hypot(self.a, self.b)
@@ -59,13 +60,13 @@ struct Affine(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) =
   fun rotation(self) -> Float =
     Math.atan2(self.b, self.a)
-test "invert_singular_is_null"
+test "invert_singular_is_none"
   s := Affine(a: 0.0, b: 0.0, c: 0.0, d: 0.0, e: 1.0, f: 1.0)
-  assert s.invert() == null
+  assert s.invert().isNone()
 test "invert_round_trip"
   m := Affine(a: 2.0, b: 0.0, c: 0.0, d: 2.0, e: 4.0, f: 0.0)
-  if inv := m.invert()
+  if Some(inv) := m.invert()
     p := inv.apply(Vec2(x: 6.0, y: 2.0))
     assert {p.x - 1.0}.abs() < 1e-6
     assert {p.y - 1.0}.abs() < 1e-6

plum-std/game/Input.plum CHANGED Viewed

@@ -7,6 +7,7 @@ import std/game/Vec2
 import std/game/Affine
 import std/game/Game
 import std/Io
+import std/Option
 import std/List
 # Player input shared by every scene style. `Input.poll` is the only code that reads
@@ -64,12 +65,12 @@ enum Input =
     out.push(Key.LeftControl)
     out
-  # The pointer position, or null for a key.
+  # The pointer position, or None for a key.
-  fun position(self) -> Vec2? = match self
+  fun position(self) -> Option[Vec2] = match self
-    PointerDown(x, y) => Vec2(x: x, y: y)
+    PointerDown(x, y) => Some(Vec2(x: x, y: y))
-    PointerUp(x, y) => Vec2(x: x, y: y)
+    PointerUp(x, y) => Some(Vec2(x: x, y: y))
-    PointerMove(x, y) => Vec2(x: x, y: y)
+    PointerMove(x, y) => Some(Vec2(x: x, y: y))
-    _ => null
+    _ => None
   # The input with its position seen through `m` (a key is unchanged).
   fun through(self, m: Affine) -> Input = match self
@@ -85,7 +86,7 @@ enum Input =
     _ => PointerMove(x: p.x, y: p.y)
   fun isPointer(self) -> Bool =
-    self.position() != null
+    self.position().isSome()
 # What is held: the left mouse button and the keys that are down.
 struct Held(mouse: Bool, keys: Slice[Int]) =
@@ -158,11 +159,11 @@ test "key_codes_cover_every_key_constant"
 test "through_moves_pointers_only"
   m := Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 10.0, f: 0.0)
-  if p := PointerDown(x: 1.0, y: 2.0).through(m).position()
+  if Some(p) := PointerDown(x: 1.0, y: 2.0).through(m).position()
     assert p.x == 11.0
     assert p.y == 2.0
   else
     assert false
-  assert KeyDown(key: 5).through(m).position() == null
+  assert KeyDown(key: 5).through(m).position().isNone()
   assert !KeyDown(key: 5).isPointer()
   assert PointerMove(x: 0.0, y: 0.0).isPointer()

plum-std/game/functional/FunctionalScene.plum CHANGED Viewed

@@ -11,6 +11,7 @@ import std/game/Color
 import std/game/Affine
 import std/game/Game
 import std/Io
+import std/Option
 # The functional scene: a `SceneNode[M]` is plain data (shapes, sprites, text, groups
 # with a transform, filters, clickable areas), rebuilt every frame and never mutated.
@@ -69,8 +70,8 @@ struct Rect(x: Float, y: Float, w: Float, h: Float) =
     Rect.through(lx, ly, {x1 - x2}.abs() + thickness, {y1 - y2}.abs() + thickness, m)
   # The smallest box holding `a` (when there is one) and `b`.
-  fun union(a: Rect?, b: Rect) -> Rect =
+  fun union(a: Option[Rect], b: Rect) -> Rect =
-    if ra := a
+    if Some(ra) := a
       x0 := ra.x.min(b.x)
       y0 := ra.y.min(b.y)
       x1 := {ra.x + ra.w}.max(b.x + b.w)
@@ -103,32 +104,32 @@ enum SceneNode[M] =
   # The bounding box of the scene in its own space (all zero when empty).
   fun bounds(self) -> Rect =
-    if r := self.boundsWith(Affine.Identity)
+    if Some(r) := self.boundsWith(Affine.Identity)
       return r
     Rect(x: 0.0, y: 0.0, w: 0.0, h: 0.0)
   # Child indices from the root down to the topmost hit leaf; empty on a miss.
   fun hitPath(self, x: Float, y: Float) -> Slice[Int] =
-    if p := self.hitWith(x, y)
+    if Some(p) := self.hitWith(x, y)
       return p
     Slice[Int]()
-  # The id of the innermost Clickable node under (x, y), or null. Later siblings win.
+  # The id of the innermost Clickable node under (x, y), or None. Later siblings win.
-  fun hitId(self, x: Float, y: Float) -> Int? =
+  fun hitId(self, x: Float, y: Float) -> Option[Int] =
-    self.hitIdWith(null, x, y)
+    self.hitIdWith(None, x, y)
-  # The message of the first Clickable with `id`, depth first, or null.
+  # The message of the first Clickable with `id`, depth first, or None.
-  fun msgOf(self, id: Int) -> M? = match self
+  fun msgOf(self, id: Int) -> Option[M] = match self
-    Clickable(cid, msg, child) => if cid == id then msg else child.msgOf(id)
+    Clickable(cid, msg, child) => if cid == id then Some(msg) else child.msgOf(id)
     Group(_, kids) => SceneNode.msgOfKids(kids, id)
     Filter(_, child, _) => child.msgOf(id)
-    _ => null
+    _ => None
-  fun msgOfKids(kids: List[SceneNode[M]], id: Int) -> M? = match kids
+  fun msgOfKids(kids: List[SceneNode[M]], id: Int) -> Option[M] = match kids
-    Nil => null
+    Nil => None
     Cons(head, tail) =>
-      if m := head.msgOf(id)
+      if Some(m) := head.msgOf(id)
-        m
+        Some(m)
       else
         SceneNode.msgOfKids(tail, id)
@@ -172,7 +173,7 @@ enum SceneNode[M] =
       child.drawWith(io, m, alpha, target)
       io.blendMode(Blend.Normal)
     _ =>
-      if b := child.boundsWith(m)
+      if Some(b) := child.boundsWith(m)
         if tex >= 0
           w := {Int(b.w) + 1}.min(io.textureWidth(tex))
           h := {Int(b.h) + 1}.min(io.textureHeight(tex))
@@ -185,98 +186,98 @@ enum SceneNode[M] =
   # --- bounds ---
-  # The bounds of the node drawn under `m`, or null when it has no extent.
+  # The bounds of the node drawn under `m`, or None when it has no extent.
-  fun boundsWith(self, m: Affine) -> Rect? = match self
+  fun boundsWith(self, m: Affine) -> Option[Rect] = match self
-    RectShape(x, y, w, h, _) => Rect.through(x, y, w, h, m)
+    RectShape(x, y, w, h, _) => Some(Rect.through(x, y, w, h, m))
-    CircleShape(cx, cy, r, _) => Rect.through(cx - r, cy - r, r * 2.0, r * 2.0, m)
+    CircleShape(cx, cy, r, _) => Some(Rect.through(cx - r, cy - r, r * 2.0, r * 2.0, m))
-    LineShape(x1, y1, x2, y2, th, _) => Rect.throughLine(x1, y1, x2, y2, th, m)
+    LineShape(x1, y1, x2, y2, th, _) => Some(Rect.throughLine(x1, y1, x2, y2, th, m))
-    Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => Rect.through(sx, sy, sw, sh, m)
+    Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => Some(Rect.through(sx, sy, sw, sh, m))
-    Text(txt, tx, ty, size, _) => Rect.through(tx, ty, size * 0.6 * Float(txt.length()), size, m)
+    Text(txt, tx, ty, size, _) => Some(Rect.through(tx, ty, size * 0.6 * Float(txt.length()), size, m))
-    Group(tr, kids) => SceneNode.boundsKids(kids, m.mul(tr.matrix()), null)
+    Group(tr, kids) => SceneNode.boundsKids(kids, m.mul(tr.matrix()), None)
     Filter(_, child, _) => child.boundsWith(m)
     Clickable(_, _, child) => child.boundsWith(m)
-  fun boundsKids(kids: List[SceneNode[M]], m: Affine, acc: Rect?) -> Rect? = match kids
+  fun boundsKids(kids: List[SceneNode[M]], m: Affine, acc: Option[Rect]) -> Option[Rect] = match kids
     Nil => acc
     Cons(head, tail) =>
-      if cr := head.boundsWith(m)
+      if Some(cr) := head.boundsWith(m)
-        SceneNode.boundsKids(tail, m, Rect.union(acc, cr))
+        SceneNode.boundsKids(tail, m, Some(Rect.union(acc, cr)))
       else
         SceneNode.boundsKids(tail, m, acc)
   # --- hit testing ---
-  # The child indices from the node down to the hit leaf, or null on a miss. A leaf
+  # The child indices from the node down to the hit leaf, or None on a miss. A leaf
   # that is hit is an empty path. (px, py) is in the node's own space.
-  fun hitWith(self, px: Float, py: Float) -> Slice[Int]? = match self
+  fun hitWith(self, px: Float, py: Float) -> Option[Slice[Int]] = match self
     RectShape(x, y, w, h, _) => hitLeaf(Rect(x: x, y: y, w: w, h: h).contains(px, py))
     CircleShape(cx, cy, r, _) => hitLeaf(Math.hypot(px - cx, py - cy) <= r)
     LineShape(x1, y1, x2, y2, th, _) => hitLeaf(nearLine(x1, y1, x2, y2, th, px, py))
     Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => hitLeaf(Rect(x: sx, y: sy, w: sw, h: sh).contains(px, py))
     Text(txt, tx, ty, size, _) => hitLeaf(Rect(x: tx, y: ty, w: size * 0.6 * Float(txt.length()), h: size).contains(px, py))
     Group(tr, kids) =>
-      if gi := tr.matrix().invert()
+      if Some(gi) := tr.matrix().invert()
         lp := gi.apply(Vec2(x: px, y: py))
         SceneNode.hitKids(kids, 0, lp.x, lp.y)
       else
-        null
+        None
     Filter(_, child, _) =>
-      if fp := child.hitWith(px, py)
+      if Some(fp) := child.hitWith(px, py)
-        hitPrepend(0, fp)
+        Some(hitPrepend(0, fp))
       else
-        null
+        None
     Clickable(_, _, child) =>
-      if tp := child.hitWith(px, py)
+      if Some(tp) := child.hitWith(px, py)
-        hitPrepend(0, tp)
+        Some(hitPrepend(0, tp))
       else
-        null
+        None
   # Tries the later children first (they are drawn on top); `i` is the index of
   # `kids`' head. The first hit found from the back wins.
-  fun hitKids(kids: List[SceneNode[M]], i: Int, px: Float, py: Float) -> Slice[Int]? = match kids
+  fun hitKids(kids: List[SceneNode[M]], i: Int, px: Float, py: Float) -> Option[Slice[Int]] = match kids
-    Nil => null
+    Nil => None
     Cons(head, tail) =>
-      if later := SceneNode.hitKids(tail, i + 1, px, py)
+      if Some(later) := SceneNode.hitKids(tail, i + 1, px, py)
-        later
+        Some(later)
       else
-        if sub := head.hitWith(px, py)
+        if Some(sub) := head.hitWith(px, py)
-          hitPrepend(i, sub)
+          Some(hitPrepend(i, sub))
         else
-          null
+          None
-  # The id of the innermost Clickable node whose subtree is hit at (px, py), or null.
+  # The id of the innermost Clickable node whose subtree is hit at (px, py), or None.
-  # `outer` is the id of the nearest enclosing tag (null at the root).
+  # `outer` is the id of the nearest enclosing tag (None at the root).
-  fun hitIdWith(self, outer: Int?, px: Float, py: Float) -> Int? = match self
+  fun hitIdWith(self, outer: Option[Int], px: Float, py: Float) -> Option[Int] = match self
     Group(tr, kids) =>
-      if gi := tr.matrix().invert()
+      if Some(gi) := tr.matrix().invert()
         lp := gi.apply(Vec2(x: px, y: py))
         SceneNode.hitIdKids(kids, outer, lp.x, lp.y)
       else
-        null
+        None
     Filter(_, child, _) => child.hitIdWith(outer, px, py)
-    Clickable(id, _, child) => child.hitIdWith(id, px, py)
+    Clickable(id, _, child) => child.hitIdWith(Some(id), px, py)
     _ =>
-      if self.hitWith(px, py) != null
+      if self.hitWith(px, py).isSome()
         outer
       else
-        null
+        None
   # Later siblings are drawn on top, so they are tried first.
-  fun hitIdKids(kids: List[SceneNode[M]], outer: Int?, px: Float, py: Float) -> Int? = match kids
+  fun hitIdKids(kids: List[SceneNode[M]], outer: Option[Int], px: Float, py: Float) -> Option[Int] = match kids
-    Nil => null
+    Nil => None
     Cons(head, tail) =>
-      if later := SceneNode.hitIdKids(tail, outer, px, py)
+      if Some(later) := SceneNode.hitIdKids(tail, outer, px, py)
-        later
+        Some(later)
       else
         head.hitIdWith(outer, px, py)
 # Hit-test helpers that do not mention `M`. They are not static methods of
 # `SceneNode[M]` because a call like `SceneNode.leaf(..)` could not tell which `M`.
-fun hitLeaf(hit: Bool) -> Slice[Int]? =
+fun hitLeaf(hit: Bool) -> Option[Slice[Int]] =
   if hit
-    return Slice[Int]()
+    return Some(Slice[Int]())
-  null
+  None
 # `i` followed by the path `sub`.
 fun hitPrepend(i: Int, sub: Slice[Int]) -> Slice[Int] =
@@ -362,23 +363,23 @@ test "hit_id_innermost_and_topmost"
   top := Clickable(id: 3, msg: 3 * 10, child: picRect(15.0, 15.0, 10.0, 10.0, Color.Red))
   g := Group(transform: Translate(dx: 1.0, dy: 0.0), children: Cons(head: outer, tail: Cons(head: top, tail: Nil)))
   a := g.hitId(6.0, 5.0)
-  if va := a
+  if Some(va) := a
     assert va == 2
   else
     assert false
   b := g.hitId(19.0, 5.0)
-  if vb := b
+  if Some(vb) := b
     assert vb == 1
   else
     assert false
   c := g.hitId(17.0, 17.0)
-  if vc := c
+  if Some(vc) := c
     assert vc == 3
   else
     assert false
-  assert g.hitId(100.0, 100.0) == null
+  assert g.hitId(100.0, 100.0).isNone()
 test "msg_of_finds_the_clickable_message"
   g := Group(transform: Identity, children: [picRect(0.0, 0.0, 1.0, 1.0, Color.Red), Clickable(id: 4, msg: 40, child: picRect(0.0, 0.0, 1.0, 1.0, Color.Red))])
-  assert {g.msgOf(4) ?: -1} == 40
+  assert g.msgOf(4).unwrapOr(-1) == 40
-  assert g.msgOf(5) == null
+  assert g.msgOf(5).isNone()

plum-std/game/functional/Ui.plum CHANGED Viewed

@@ -5,6 +5,7 @@ import std/Float
 import std/Str
 import std/Slice
 import std/List
+import std/Option
 import std/game/Color
 import std/game/functional/FunctionalScene
 import std/game/Input
@@ -17,53 +18,56 @@ import std/game/Input
 # button rules as PureScene: Down captures the pressed id; while captured only
 # that id gets Enter/Exit; Up releases (Click only when still over it).
-struct UiState(x: Float, y: Float, down: Bool, hot: Int?, captured: Int?)
+struct UiState(x: Float, y: Float, down: Bool, hot: Option[Int], captured: Option[Int])
 struct UiStep(ui: UiState, events: List[UiEvent])
-fun uiSame(a: Int?, b: Int?) -> Bool =
+fun uiSame(a: Option[Int], b: Option[Int]) -> Bool =
-  if va := a
+  if Some(va) := a
-    if vb := b
+    if Some(vb) := b
       return va == vb
     return false
-  if vb := b
+  if Some(vb) := b
     return false
   true
 # Exit for the old hot id and Enter for the new one when they differ.
-fun uiHover(out: Slice[UiEvent], old: Int?, now: Int?) =
+fun uiHover(out: Slice[UiEvent], old: Option[Int], now: Option[Int]) =
   if !uiSame(old, now)
-    if o := old
+    if Some(o) := old
       out.push(UiEvent(id: o, kind: Exit))
-    if n := now
+    if Some(n) := now
       out.push(UiEvent(id: n, kind: Enter))
 primitive Ui =
   fun init() -> UiState =
-    UiState(x: 0.0, y: 0.0, down: false, hot: null, captured: null)
+    UiState(x: 0.0, y: 0.0, down: false, hot: None, captured: None)
   # A key changes nothing here (keys go to the game).
-  fun step(ui: UiState, input: Input, hit: Int?) -> UiStep =
+  fun step(ui: UiState, input: Input, hit: Option[Int]) -> UiStep =
+    maybePos := input.position()
+    if maybePos.isNone()
-    pos := input.position() ?: return UiStep(ui: ui, events: Nil)
+      return UiStep(ui: ui, events: Nil)
+    pos := maybePos!
     out := Slice[UiEvent]()
     # a capture left over without a held button is stale
-    cap: Int? := ui.captured
+    cap: Option[Int] := ui.captured
     if !ui.down
-      cap = null
+      cap = None
-    hot: Int? := ui.hot
+    hot: Option[Int] := ui.hot
     down := ui.down
     match input
       PointerDown(_, _) =>
-        cap = null
+        cap = None
         uiHover(out, hot, hit)
         hot = hit
         down = true
-        if h := hit
+        if Some(h) := hit
           out.push(UiEvent(id: h, kind: Press))
-          cap = h
+          cap = Some(h)
       PointerMove(_, _) =>
-        if c := cap
+        if Some(c) := cap
-          now: Int? := null
+          now: Option[Int] := None
           if uiSame(hit, cap)
             now = cap
           uiHover(out, hot, now)
@@ -72,11 +76,11 @@ primitive Ui =
           uiHover(out, hot, hit)
           hot = hit
       PointerUp(_, _) =>
-        if c := cap
+        if Some(c) := cap
           out.push(UiEvent(id: c, kind: Release))
           if uiSame(hit, cap)
             out.push(UiEvent(id: c, kind: Click))
-          cap = null
+          cap = None
           hot = hit
         else
           uiHover(out, hot, hit)
@@ -86,12 +90,12 @@ primitive Ui =
     UiStep(ui: UiState(x: pos.x, y: pos.y, down: down, hot: hot, captured: cap), events: List.fromSlice(out))
   fun pressed(ui: UiState, id: Int) -> Bool =
-    if c := ui.captured
+    if Some(c) := ui.captured
       return c == id && uiSame(ui.hot, ui.captured)
     false
   fun hovered(ui: UiState, id: Int) -> Bool =
-    if h := ui.hot
+    if Some(h) := ui.hot
       return h == id
     false
@@ -103,7 +107,7 @@ primitive Ui =
       later := Ui.messages(view, rest)
       if e.kind != Click
         return later
-      if m := view.msgOf(e.id)
+      if Some(m) := view.msgOf(e.id)
         return Cons(head: m, tail: later)
       later
@@ -148,12 +152,12 @@ fun uiButtonColor(n: SceneNode[Int]) -> Color = match n
   _ => Color.Black
 test "press_sets_capture"
-  s1 := Ui.step(Ui.init(), uiDown(1.0), 5)
+  s1 := Ui.step(Ui.init(), uiDown(1.0), Some(5))
   assert s1.events.length() == 2
   assert uiIs(s1.events.at(0), 5, Enter)
   assert uiIs(s1.events.at(1), 5, Press)
   assert Ui.pressed(s1.ui, 5)
-  s2 := Ui.step(s1.ui, uiUp(1.0), 5)
+  s2 := Ui.step(s1.ui, uiUp(1.0), Some(5))
   assert s2.events.length() == 2
   assert uiIs(s2.events.at(0), 5, Release)
   assert uiIs(s2.events.at(1), 5, Click)
@@ -161,53 +165,53 @@ test "press_sets_capture"
   assert Ui.hovered(s2.ui, 5)
 test "release_elsewhere_no_click"
-  s1 := Ui.step(Ui.init(), uiDown(1.0), 5)
+  s1 := Ui.step(Ui.init(), uiDown(1.0), Some(5))
-  s2 := Ui.step(s1.ui, uiMove(99.0), null)
+  s2 := Ui.step(s1.ui, uiMove(99.0), None)
   assert s2.events.length() == 1
   assert uiIs(s2.events.at(0), 5, Exit)
-  s3 := Ui.step(s2.ui, uiUp(99.0), null)
+  s3 := Ui.step(s2.ui, uiUp(99.0), None)
   assert s3.events.length() == 1
   assert uiIs(s3.events.at(0), 5, Release)
   assert uiCount(s3, Click) == 0
 test "drag_off_and_back_one_click"
-  s1 := Ui.step(Ui.init(), uiDown(1.0), 5)
+  s1 := Ui.step(Ui.init(), uiDown(1.0), Some(5))
-  s2 := Ui.step(s1.ui, uiMove(99.0), null)
+  s2 := Ui.step(s1.ui, uiMove(99.0), None)
-  s3 := Ui.step(s2.ui, uiMove(1.0), 5)
+  s3 := Ui.step(s2.ui, uiMove(1.0), Some(5))
   assert s3.events.length() == 1
   assert uiIs(s3.events.at(0), 5, Enter)
-  s4 := Ui.step(s3.ui, uiUp(1.0), 5)
+  s4 := Ui.step(s3.ui, uiUp(1.0), Some(5))
   assert uiCount(s4, Click) == 1
   assert uiCount(s4, Release) == 1
 test "stale_capture_dropped"
-  stale := UiState(x: 0.0, y: 0.0, down: false, hot: null, captured: 5)
+  stale := UiState(x: 0.0, y: 0.0, down: false, hot: None, captured: Some(5))
-  s := Ui.step(stale, uiMove(50.0), null)
+  s := Ui.step(stale, uiMove(50.0), None)
   assert s.events.length() == 0
-  if c := s.ui.captured
+  if Some(c) := s.ui.captured
     assert false
   assert !Ui.pressed(s.ui, 5)
 test "hover_without_press_routes_move"
-  s1 := Ui.step(Ui.init(), uiMove(1.0), 5)
+  s1 := Ui.step(Ui.init(), uiMove(1.0), Some(5))
   assert s1.events.length() == 1
   assert uiIs(s1.events.at(0), 5, Enter)
   assert Ui.hovered(s1.ui, 5)
-  s2 := Ui.step(s1.ui, uiMove(2.0), 5)
+  s2 := Ui.step(s1.ui, uiMove(2.0), Some(5))
   assert s2.events.length() == 0
-  s3 := Ui.step(s2.ui, uiMove(99.0), null)
+  s3 := Ui.step(s2.ui, uiMove(99.0), None)
   assert s3.events.length() == 1
   assert uiIs(s3.events.at(0), 5, Exit)
   assert !Ui.hovered(s3.ui, 5)
 test "button_visual_reflects_state"
   idle := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.init())
-  hov := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiMove(1.0), 3).ui)
+  hov := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiMove(1.0), Some(3)).ui)
-  prs := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiDown(1.0), 3).ui)
+  prs := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiDown(1.0), Some(3)).ui)
   assert uiButtonColor(idle).eq(uiIdleColor())
   assert uiButtonColor(hov).eq(uiHoverColor())
   assert uiButtonColor(prs).eq(uiPressedColor())
-  if hid := idle.hitId(20.0, 30.0)
+  if Some(hid) := idle.hitId(20.0, 30.0)
     assert hid == 3
   else
     assert false
@@ -217,5 +221,5 @@ test "messages_are_the_clicked_buttons_messages"
   evs := [UiEvent(id: 4, kind: Press), UiEvent(id: 4, kind: Click), UiEvent(id: 9, kind: Click), UiEvent(id: 3, kind: Click)]
   ms := Ui.messages(view, evs)
   assert ms.length() == 2
-  assert {ms.get(0) ?: -1} == 40
+  assert ms.get(0).unwrapOr(-1) == 40
-  assert {ms.get(1) ?: -1} == 30
+  assert ms.get(1).unwrapOr(-1) == 30

plum-std/game/imperative/Scene.plum CHANGED Viewed

@@ -4,6 +4,7 @@ import std/Int
 import std/Float
 import std/Str
 import std/Slice
+import std/Option
 import std/Math
 import std/game/Vec2
 import std/game/Color
@@ -57,7 +58,7 @@ struct Actor(
   mut color: Color,
   mut visible: Bool,
   mut children: Slice[Actor],
-  mut parent: Actor?,
+  mut parent: Option[Actor],
   mut scratch: Slice[Actor],
   mut cull: Bool, mut cullX: Float, mut cullY: Float, mut cullW: Float, mut cullH: Float) =
@@ -76,7 +77,7 @@ struct Actor(
     self.color = Color.White
     self.visible = true
     self.children = Slice[Actor]()
-    self.parent = null
+    self.parent = None
     self.scratch = Slice[Actor]()
     self.cull = false
     self.cullX = 0.0
@@ -134,9 +135,9 @@ struct Actor(
   # Appends a child (taking it from its previous parent) so it draws after its siblings.
   fun add(self, child: Actor) =
-    if p := child.parent
+    if Some(p) := child.parent
       p.detach(child)
-    child.parent = self
+    child.parent = Some(self)
     self.children.push(child)
   fun detach(self, child: Actor) =
@@ -145,26 +146,26 @@ struct Actor(
       self.children.removeAt(i)
   fun remove(self, child: Actor) =
-    if p := child.parent
+    if Some(p) := child.parent
       if p == self
         self.detach(child)
-        child.parent = null
+        child.parent = None
   fun clear(self) =
     for i := range self.children.length()
-      self.children.at(i).parent = null
+      self.children.at(i).parent = None
     self.children.clear()
   # The actor's index among its siblings (its draw order), -1 without a parent.
   fun zIndex(self) -> Int =
-    if p := self.parent
+    if Some(p) := self.parent
       return p.childIndex(self)
     -1
   # Moves the actor to index `i` of its parent's children (clamped to the valid
   # range), shifting the siblings in between. Without a parent it does nothing.
   fun setZIndex(self, i: Int) =
-    if p := self.parent
+    if Some(p) := self.parent
       src := self.zIndex()
       dst := i
       if dst < 0
@@ -184,7 +185,7 @@ struct Actor(
   # Draws last (on top) and is hit first.
   fun toFront(self) =
-    if p := self.parent
+    if Some(p) := self.parent
       self.setZIndex(p.children.length() - 1)
   # Draws first (underneath) and is hit last.
@@ -297,20 +298,20 @@ struct Actor(
   # The topmost visible actor under `p`, a point in the parent's coordinates:
   # children before the actor itself, later siblings before earlier ones.
-  fun hitTree(self, p: Vec2) -> Actor? =
+  fun hitTree(self, p: Vec2) -> Option[Actor] =
     if !self.visible
-      return null
+      return None
     q := self.local().inverse().apply(p)
     n := self.children.length()
     for i := range n
       child := self.children.at(n - 1 - i)
       if !self.culls(child)
-        if found := child.hitTree(q)
+        if Some(found) := child.hitTree(q)
-          return found
+          return Some(found)
     if self.hit(q)
       me: Actor := self
-      return me
+      return Some(me)
-    null
+    None
   # A point in this actor's coordinates, in the stage's.
   fun localToStage(self, p: Vec2) -> Vec2 =
@@ -451,7 +452,7 @@ fun localMatrix(n: Actor) -> Affine =
 # The actor's transform into stage coordinates.
 fun worldMatrix(n: Actor) -> Affine =
-  if p := n.parent
+  if Some(p) := n.parent
     worldMatrix(p) * n.local()
   else
     n.local()
@@ -473,18 +474,18 @@ fun actNode(n: Actor, dt: Float) =
   n.act(dt)
 # The topmost visible actor under `p`, a point in the actor's parent's coordinates.
-fun hitNode(n: Actor, p: Vec2) -> Actor? =
+fun hitNode(n: Actor, p: Vec2) -> Option[Actor] =
   n.hitTree(p)
 # A root actor plus a camera (the world point at the screen's top-left and the
 # pixels per world unit, as in `setCamera`).
-struct Stage(mut camX: Float, mut camY: Float, mut camScale: Float, mut focus: Actor?) =
+struct Stage(mut camX: Float, mut camY: Float, mut camScale: Float, mut focus: Option[Actor]) =
   fun init(self) =
     self.root: Actor = Group()
   fun create() -> Stage =
-    Stage(camX: 0.0, camY: 0.0, camScale: 1.0, focus: null)
+    Stage(camX: 0.0, camY: 0.0, camScale: 1.0, focus: None)
   # Runs every actor's `act`, parents before children, in insertion order.
   fun act(self, dt: Float) =
@@ -496,7 +497,7 @@ struct Stage(mut camX: Float, mut camY: Float, mut camScale: Float, mut focus: A
     io.resetCamera()
   # The topmost visible actor at a stage point.
-  fun hit(self, x: Float, y: Float) -> Actor? =
+  fun hit(self, x: Float, y: Float) -> Option[Actor] =
     self.root.hitTree(Vec2(x: x, y: y))
   # Delivers one input and says whether an actor consumed it. A pointer input goes
@@ -504,24 +505,24 @@ struct Stage(mut camX: Float, mut camY: Float, mut camScale: Float, mut focus: A
   # returns true; a press also gives that actor the keyboard focus. A key goes to the
   # focused actor, then its parents. Unconsumed input is the game's to handle.
   fun input(self, e: Input) -> Bool =
-    if p := e.position()
+    if Some(p) := e.position()
       sp := self.screenToStage(p.x, p.y)
       target := self.hit(sp.x, sp.y)
       match e
         PointerDown(_, _) =>
           self.focus = target
         _ => 0
-      if a := target
+      if Some(a) := target
         return Stage.bubble(a, Input.pointerAt(e, sp))
       return false
-    if f := self.focus
+    if Some(f) := self.focus
       return Stage.bubble(f, e)
     false
   # Offers `e` (in stage coordinates) to `a`, then each parent, until one consumes it.
   fun bubble(a: Actor, e: Input) -> Bool =
-    cur: Actor? := a
+    cur: Option[Actor] := Some(a)
-    while c := cur
+    while Some(c) := cur
       if c.onInput(e.through(worldMatrix(c).inverse()))
         return true
       cur = c.parent
@@ -537,7 +538,7 @@ struct Stage(mut camX: Float, mut camY: Float, mut camScale: Float, mut focus: A
 struct Catcher(Actor(width, height), mut got: Int, mut lastX: Float, eat: Bool) =
   override fun onInput(self, e: Input) -> Bool =
     self.got = self.got + 1
-    if p := e.position()
+    if Some(p) := e.position()
       self.lastX = p.x
     self.eat
@@ -597,16 +598,16 @@ test "add reparents, remove and clear detach"
   b.add(k)
   assert a.children.length() == 0
   assert b.children.length() == 1
-  assert same({k.parent ?: crash "no parent"}, b)
+  assert same(k.parent.unwrap(), b)
   b.remove(k)
   assert b.children.length() == 0
-  assert k.parent == null
+  assert k.parent.isNone()
   b.add(k)
   extra := Group()
   b.add(extra)
   b.clear()
   assert b.children.length() == 0
-  assert k.parent == null
+  assert k.parent.isNone()
 test "draw order is parent first, then children in insertion order"
   root := Group()
@@ -660,15 +661,15 @@ test "hit finds the topmost actor through rotated and scaled groups"
   g.add(top)
   stage := Stage.create()
   stage.root.add(g)
-  assert same({stage.hit(90.0, 30.0) ?: crash "miss"}, top)
+  assert same(stage.hit(90.0, 30.0).unwrap(), top)
-  assert same({stage.hit(70.0, 10.0) ?: crash "miss"}, low)
+  assert same(stage.hit(70.0, 10.0).unwrap(), low)
-  assert same({stage.hit(60.0, 30.0) ?: crash "miss"}, low)
+  assert same(stage.hit(60.0, 30.0).unwrap(), low)
-  assert stage.hit(10.0, 10.0) == null
+  assert stage.hit(10.0, 10.0).isNone()
-  assert stage.hit(150.0, 30.0) == null
+  assert stage.hit(150.0, 30.0).isNone()
   top.visible = false
-  assert same({stage.hit(90.0, 30.0) ?: crash "miss"}, low)
+  assert same(stage.hit(90.0, 30.0).unwrap(), low)
   g.visible = false
-  assert stage.hit(90.0, 30.0) == null
+  assert stage.hit(90.0, 30.0).isNone()
 test "hit prefers later siblings and a child over its parent"
   stage := Stage.create()
@@ -678,10 +679,10 @@ test "hit prefers later siblings and a child over its parent"
   stage.root.add(b)
   inner := Rect.create(10.0, 10.0, Color.Green)
   b.add(inner)
-  assert same({stage.hit(10.0, 10.0) ?: crash "miss"}, a)
+  assert same(stage.hit(10.0, 10.0).unwrap(), a)
-  assert same({stage.hit(30.0, 5.0) ?: crash "miss"}, inner)
+  assert same(stage.hit(30.0, 5.0).unwrap(), inner)
-  assert same({stage.hit(60.0, 40.0) ?: crash "miss"}, b)
+  assert same(stage.hit(60.0, 40.0).unwrap(), b)
-  assert same({stage.hit(40.0, 10.0) ?: crash "miss"}, b)
+  assert same(stage.hit(40.0, 10.0).unwrap(), b)
 test "the default act runs the children's act, invisible ones included"
   stage := Stage.create()
@@ -748,7 +749,7 @@ test "sortChildren sorts 5000 random actors and updates hit order"
   assert g.children.length() == 5000
   for i := range 4999
     assert g.children.at(i).y <= g.children.at(i + 1).y
-  assert same({g.children.at(10).parent ?: crash "orphan"}, g)
+  assert same(g.children.at(10).parent.unwrap(), g)
 test "sorting a nearly sorted list takes about n comparisons and reuses the scratch buffer"
   g := Group()
@@ -804,16 +805,16 @@ test "hit does not return culled children, and a scaled child near the edge is k
   k := Rect.create(10.0, 10.0, Color.Red).at(105.0, 5.0)
   stage.root.add(k)
   stage.root.setCullingArea(0.0, 0.0, 100.0, 100.0)
-  assert stage.hit(107.0, 7.0) == null
+  assert stage.hit(107.0, 7.0).isNone()
   k.scaleX = 4.0
   k.originX = 10.0
-  assert same({stage.hit(90.0, 7.0) ?: crash "miss"}, k)
+  assert same(stage.hit(90.0, 7.0).unwrap(), k)
   assert flatten(stage.root).length() == 2
   k.scaleX = 1.0
   k.originX = 0.0
-  assert stage.hit(107.0, 7.0) == null
+  assert stage.hit(107.0, 7.0).isNone()
   stage.root.clearCullingArea()
-  assert same({stage.hit(107.0, 7.0) ?: crash "miss"}, k)
+  assert same(stage.hit(107.0, 7.0).unwrap(), k)
 test "a child without a size is never culled"
   g := Group()

plum-std/game/pure/Actions.plum CHANGED Viewed

@@ -4,6 +4,7 @@ import std/Slice
 import std/Int
 import std/Float
 import std/List
+import std/Option
 # scene2d-style actions as plain data plus a step method. `Action.step`
 # steps an action IN PLACE on its own record (a running action allocates nothing:
@@ -16,27 +17,27 @@ import std/List
 # The animated part of an actor's transform.
 struct Pose(x: Float, y: Float, rotation: Float, scaleX: Float, scaleY: Float)
-# One action. `elapsed` and `current` (the running lap of a `Forever`, null
+# One action. `elapsed` and `current` (the running lap of a `Forever`, None
 # before it starts) are the mutable state; `kind` is the immutable description.
 # A `Forever`'s `template` is the pristine action restarted each lap.
-struct Action(mut elapsed: Float, mut current: Action?, kind: ActionKind) =
+struct Action(mut elapsed: Float, mut current: Option[Action], kind: ActionKind) =
   fun moveBy(dx: Float, dy: Float, secs: Float) -> Action =
-    Action(elapsed: 0.0, current: null, kind: MoveBy(dx: dx, dy: dy, duration: secs))
+    Action(elapsed: 0.0, current: None, kind: MoveBy(dx: dx, dy: dy, duration: secs))
   fun rotateBy(radians: Float, secs: Float) -> Action =
-    Action(elapsed: 0.0, current: null, kind: RotateBy(radians: radians, duration: secs))
+    Action(elapsed: 0.0, current: None, kind: RotateBy(radians: radians, duration: secs))
   fun delay(secs: Float) -> Action =
-    Action(elapsed: 0.0, current: null, kind: Delay(duration: secs))
+    Action(elapsed: 0.0, current: None, kind: Delay(duration: secs))
   fun sequence(steps: Slice[Action]) -> Action =
-    Action(elapsed: 0.0, current: null, kind: Sequence(steps: steps))
+    Action(elapsed: 0.0, current: None, kind: Sequence(steps: steps))
   fun parallel(steps: Slice[Action]) -> Action =
-    Action(elapsed: 0.0, current: null, kind: Parallel(steps: steps))
+    Action(elapsed: 0.0, current: None, kind: Parallel(steps: steps))
   fun forever(a: Action) -> Action =
-    Action(elapsed: 0.0, current: a, kind: Forever(template: a.fresh()))
+    Action(elapsed: 0.0, current: Some(a), kind: Forever(template: a.fresh()))
   # An unstarted copy (elapsed 0, all steps present).
   fun fresh(self) -> Action =
@@ -54,7 +55,7 @@ struct Action(mut elapsed: Float, mut current: Action?, kind: ActionKind) =
         for i := range steps.length()
           out.push(steps.at(i).fresh())
         Action.parallel(out)
-      Forever(template) => Action(elapsed: 0.0, current: template.fresh(), kind: Forever(template: template))
+      Forever(template) => Action(elapsed: 0.0, current: Some(template.fresh()), kind: Forever(template: template))
   # Steps this action by `dt` in place, from pose `p`.
   fun step(self, p: Pose, dt: Float) -> Step =
@@ -88,10 +89,10 @@ struct Action(mut elapsed: Float, mut current: Action?, kind: ActionKind) =
       Forever(template) =>
         # Restarts at most once per step, with the spare time, so a zero-length
         # template cannot spin forever inside one step.
-        if a.current == null
+        if a.current.isNone()
-          a.current = template.fresh()
+          a.current = Some(template.fresh())
         lap := template
-        if c := a.current
+        if Some(c) := a.current
           lap = c
         s := lap.step(p, dt)
         if !s.done
@@ -99,9 +100,9 @@ struct Action(mut elapsed: Float, mut current: Action?, kind: ActionKind) =
         next := template.fresh()
         r := next.step(s.pose, s.spare)
         if r.done
-          a.current = template.fresh()
+          a.current = Some(template.fresh())
         else
-          a.current = next
+          a.current = Some(next)
         Step(pose: r.pose, spare: 0.0, done: false)
   # Steps every action side by side in place and drops the finished ones by

plum-std/game/pure/PureScene.plum CHANGED Viewed

@@ -4,6 +4,7 @@ import std/Int
 import std/Float
 import std/Str
 import std/Slice
+import std/Option
 import std/Math
 import std/game/Vec2
 import std/game/Color
@@ -101,17 +102,17 @@ struct Node(
   # --- reading ---
-  # The children of a group, or null for anything else.
+  # The children of a group, or None for anything else.
-  fun children(self) -> Slice[Node]? =
+  fun children(self) -> Option[Slice[Node]] =
     match self.kind
-      Group(children) => children
+      Group(children) => Some(children)
-      _ => null
+      _ => None
-  # The actor of a Custom node, or null for anything else.
+  # The actor of a Custom node, or None for anything else.
-  fun actor(self) -> Actor? =
+  fun actor(self) -> Option[Actor] =
     match self.kind
-      Custom(actor) => actor
+      Custom(actor) => Some(actor)
-      _ => null
+      _ => None
   # Whether `p`, in the node's own coordinates, is on it.
   fun hit(self, p: Vec2) -> Bool =
@@ -119,28 +120,28 @@ struct Node(
   # The path (child indexes from this node) to the topmost actor under `p`, which
   # is in the coordinates of the parent; `parent` is that parent's stage matrix.
-  fun findHit(self, parent: Affine, p: Vec2) -> Slice[Int]? =
+  fun findHit(self, parent: Affine, p: Vec2) -> Option[Slice[Int]] =
     if !self.visible || self.touchable == Disabled
-      return null
+      return None
     m := parent * self.localMatrix()
     inv := m.invert()
-    if inv == null
+    if inv.isNone()
-      return null
+      return None
     lp := Vec2(x: 0.0, y: 0.0)
-    if q := inv
+    if Some(q) := inv
       lp = q.apply(p)
     match self.kind
       Group(ks) =>
         i := ks.length() - 1
         while i >= 0
           sub := ks.at(i).findHit(m, p)
-          if s := sub
+          if Some(s) := sub
-            return Node.prepend(i, s)
+            return Some(Node.prepend(i, s))
           i = i - 1
       _ => 0
     if self.hit(lp)
-      return Slice[Int]()
+      return Some(Slice[Int]())
-    null
+    None
   # The id of the actor at `path` below this node, or -1 if the path leads nowhere.
   fun idAt(self, path: Slice[Int], depth: Int) -> Int =
@@ -154,18 +155,18 @@ struct Node(
       _ => 0
     -1
-  # The path to the first actor with `id`, depth first; null if none.
+  # The path to the first actor with `id`, depth first; None if none.
-  fun findPath(self, id: Int) -> Slice[Int]? =
+  fun findPath(self, id: Int) -> Option[Slice[Int]] =
     if self.id == id
-      return Slice[Int]()
+      return Some(Slice[Int]())
     match self.kind
       Group(ks) =>
         for i := range ks.length()
           sub := ks.at(i).findPath(id)
-          if s := sub
+          if Some(s) := sub
-            return Node.prepend(i, s)
+            return Some(Node.prepend(i, s))
       _ => 0
-    null
+    None
   # `i` followed by the path `rest`.
   fun prepend(i: Int, rest: Slice[Int]) -> Slice[Int] =
@@ -215,7 +216,7 @@ struct Node(
   # A Custom node's actor acts on it; every other node is itself.
   fun acted(self, dt: Float) -> Node =
-    if actor := self.actor()
+    if Some(actor) := self.actor()
       return actor.act(self, dt)
     self
@@ -234,7 +235,7 @@ struct Node(
   # The tree where the first actor with `id` is replaced by `f` of it.
   fun modify(self, id: Int, f: fn(Node) -> Node) -> Node =
     path := self.findPath(id)
-    if p := path
+    if Some(p) := path
       return self.modifyAt(p, 0, f)
     self
@@ -297,7 +298,7 @@ struct Node(
   # `route`, appending the raised events to `events` (the returned Handled holds it).
   fun routeInto(self, path: Slice[Int], depth: Int, e: Input, over: Bool, events: Slice[UiEvent]) -> Handled =
     local := e
-    if q := self.localMatrix().invert()
+    if Some(q) := self.localMatrix().invert()
       local = e.through(q)
     consumed := false
     if depth < path.length()
@@ -388,11 +389,11 @@ fun ttFixture() -> Node =
   me: Node := root
   me
-fun ttNoPath(r: Slice[Int]?) -> Bool =
+fun ttNoPath(r: Option[Slice[Int]]) -> Bool =
-  r == null
+  r.isNone()
-fun ttPathEq(r: Slice[Int]?, want: Slice[Int]) -> Bool =
+fun ttPathEq(r: Option[Slice[Int]], want: Slice[Int]) -> Bool =
-  if p := r
+  if Some(p) := r
     if p.length() != want.length()
       return false
     for i := range p.length()
@@ -555,8 +556,8 @@ test "hit_box_and_children_of"
   s := Node.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
   assert s.hit(Vec2(x: 5.0, y: 5.0))
   assert !s.hit(Vec2(x: 11.0, y: 5.0))
-  assert s.children() == null
+  assert s.children().isNone()
-  assert Node.group(2, 0.0, 0.0, 1.0, 1.0, [s].toSlice()).children() != null
+  assert Node.group(2, 0.0, 0.0, 1.0, 1.0, [s].toSlice()).children().isSome()
 test "button_move_raises_enter_then_exit"
   b := Node.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)

plum-std/game/pure/SceneInput.plum CHANGED Viewed

@@ -13,6 +13,7 @@ import std/game/pure/Actions
 import std/game/pure/PureScene
 import std/game/Input
 import std/List
+import std/Option
 # The root of a pure scene tree, its camera, pointer capture and keyboard focus. A
 # Stage is an unique value: `input` and `frame` take it, change it in place and hand
@@ -43,55 +44,58 @@ struct StageHandled(stage: Stage, events: Slice[UiEvent], keys: Slice[Input]) =
     match self
       StageHandled(s, _, _) => s
-struct Stage(root: Node, camera: Affine, captured: Capture?, focus: Int?) =
+struct Stage(root: Node, camera: Affine, captured: Option[Capture], focus: Option[Int]) =
   # A stage over `root` with no camera transform, nothing captured and no focus.
   fun create(root: Node) -> Stage =
-    Stage(root: root, camera: Affine.Identity, captured: null, focus: null)
+    Stage(root: root, camera: Affine.Identity, captured: None, focus: None)
   # Handles one input: routes it, returns the new stage and the events raised.
   fun input(self, e: Input) -> StageHandled =
     if !e.isPointer()
       return self.key(e)
     none := Slice[UiEvent]()
+    inv := self.camera.invert()
+    if inv.isNone()
-    q := self.camera.invert() ?: return StageHandled(stage: self, events: none, keys: Slice[Input]())
+      return StageHandled(stage: self, events: none, keys: Slice[Input]())
+    q := inv.unwrap()
     world := e.through(q)
-    at := world.position() ?: Vec2(x: 0.0, y: 0.0)
+    at := world.position().unwrapOr(Vec2(x: 0.0, y: 0.0))
     hit := self.root.findHit(Affine.Identity, at)
     # A capture is valid only while its path still leads to its actor.
-    cap: Capture? := null
+    cap: Option[Capture] := None
-    if c := self.captured
+    if Some(c) := self.captured
       if self.root.idAt(c.path, 0) == c.id
-        cap = c
+        cap = Some(c)
     match world
       PointerDown(_, _) =>
-        if p := hit
+        if Some(p) := hit
           id := self.root.idAt(p, 0)
-          return Stage(..self, focus: id).deliver(p, world, true, Capture(path: p, id: id))
+          return Stage(..self, focus: Some(id)).deliver(p, world, true, Some(Capture(path: p, id: id)))
-        return StageHandled(stage: Stage(..self, captured: null, focus: null), events: none, keys: Slice[Input]())
+        return StageHandled(stage: Stage(..self, captured: None, focus: None), events: none, keys: Slice[Input]())
       _ => 0
-    if c := cap
+    if Some(c) := cap
       over := false
-      if p := hit
+      if Some(p) := hit
         over = c.within(p)
       match world
         PointerUp(_, _) =>
-          return self.deliver(c.path, world, over, null)
+          return self.deliver(c.path, world, over, None)
         _ => 0
-      return self.deliver(c.path, world, over, c)
+      return self.deliver(c.path, world, over, Some(c))
     # Hover without a press: route to whatever is under the pointer.
     match world
       PointerMove(_, _) =>
-        if p := hit
+        if Some(p) := hit
-          return self.deliver(p, world, true, null)
+          return self.deliver(p, world, true, None)
       _ => 0
-    StageHandled(stage: self.withCapture(null), events: none, keys: Slice[Input]())
+    StageHandled(stage: self.withCapture(None), events: none, keys: Slice[Input]())
   # A key goes to the focused actor (then its ancestors); unconsumed, it is returned.
   fun key(self, e: Input) -> StageHandled =
     left := [e].toSlice()
-    if f := self.focus
+    if Some(f) := self.focus
-      if p := self.root.findPath(f)
+      if Some(p) := self.root.findPath(f)
         events := Slice[UiEvent]()
         match self
           Stage(root, camera, captured, focus) =>
@@ -101,10 +105,10 @@ struct Stage(root: Node, camera: Affine, captured: Capture?, focus: Int?) =
             return StageHandled(stage: Stage(root: h.intoNode(), camera: camera, captured: captured, focus: focus), events: events, keys: left)
     StageHandled(stage: self, events: Slice[UiEvent](), keys: left)
-  fun withCapture(self, c: Capture?) -> Stage =
+  fun withCapture(self, c: Option[Capture]) -> Stage =
     Stage(..self, captured: c)
-  fun deliver(self, path: Slice[Int], e: Input, over: Bool, c: Capture?) -> StageHandled =
+  fun deliver(self, path: Slice[Int], e: Input, over: Bool, c: Option[Capture]) -> StageHandled =
     events := Slice[UiEvent]()
     match self
       Stage(root, camera, _, focus) =>
@@ -137,12 +141,12 @@ fun inBtnTree() -> Node =
   g
 fun inBtnPressed(s: Stage) -> Bool =
-  if k := s.root.children()
+  if Some(k) := s.root.children()
     return psIsPressed(k.at(0))
   false
 fun inBtnOver(s: Stage) -> Bool =
-  if k := s.root.children()
+  if Some(k) := s.root.children()
     return inOverOf(k.at(0))
   false
@@ -194,7 +198,7 @@ fun inMoverTree() -> Node =
   g
 fun inFirstX(s: Stage) -> Float =
-  if k := s.root.children()
+  if Some(k) := s.root.children()
     return k.at(0).x
   0.0 - 1.0
@@ -203,7 +207,7 @@ test "press_sets_capture"
   assert h.events.length() == 1
   assert h.events.at(0).kind == Press
   assert h.events.at(0).id == 5
-  if c := h.stage.captured
+  if Some(c) := h.stage.captured
     assert c.id == 5
   else
     assert false
@@ -214,7 +218,7 @@ test "release_elsewhere_no_click"
   assert h2.events.length() == 1
   assert h2.events.at(0).kind == Release
   assert h2.events.at(0).id == 5
-  assert h2.stage.captured == null
+  assert h2.stage.captured.isNone()
   assert !inBtnPressed(h2.stage)
 test "drag_off_and_back_one_click"
@@ -230,19 +234,19 @@ test "drag_off_and_back_one_click"
 test "stale_capture_dropped"
   h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
   empty: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Node]())
-  swapped := Stage(root: empty, camera: h1.stage.camera, captured: h1.stage.captured, focus: null)
+  swapped := Stage(root: empty, camera: h1.stage.camera, captured: h1.stage.captured, focus: None)
   h2 := swapped.input(inUp(20.0, 20.0))
   assert h2.events.length() == 0
-  assert h2.stage.captured == null
+  assert h2.stage.captured.isNone()
 test "hover_without_press_routes_move"
   h := Stage.create(inBtnTree()).input(inMove(20.0, 20.0))
   assert inBtnOver(h.stage)
-  assert h.stage.captured == null
+  assert h.stage.captured.isNone()
 test "camera_maps_screen_to_world"
   cam := Affine(a: 2.0, b: 0.0, c: 0.0, d: 2.0, e: 0.0, f: 0.0)
-  s := Stage(root: inBtnTree(), camera: cam, captured: null, focus: null)
+  s := Stage(root: inBtnTree(), camera: cam, captured: None, focus: None)
   h := s.input(inDown(40.0, 40.0))
   assert h.events.length() == 1
   assert h.events.at(0).kind == Press
@@ -262,7 +266,7 @@ test "frame_handles_inputs_then_updates"
   assert h.events.at(0).kind == Press
   assert h.events.at(1).kind == Release
   assert h.events.at(2).kind == Click
-  if k := h.stage.root.children()
+  if Some(k) := h.stage.root.children()
     assert {k.at(1).x - 305.0}.abs() < 0.000001
   else
     assert false
@@ -271,23 +275,23 @@ test "hit_and_route_agree_for_rotated_scaled_group"
   # local (20,20) in the button's parent maps to world (100 - 2*20, 2*20) = (60,40)
   t := inXformTree()
   hit := t.findHit(Affine.Identity, Vec2(x: 60.0, y: 40.0))
-  assert hit != null
+  assert hit.isSome()
-  h := Stage(root: t, camera: Affine.Identity, captured: null, focus: null).input(inDown(60.0, 40.0))
+  h := Stage(root: t, camera: Affine.Identity, captured: None, focus: None).input(inDown(60.0, 40.0))
   assert h.events.length() == 1
   assert h.events.at(0).id == 5
-  miss := Stage(root: inXformTree(), camera: Affine.Identity, captured: null, focus: null).input(inDown(20.0, 20.0))
+  miss := Stage(root: inXformTree(), camera: Affine.Identity, captured: None, focus: None).input(inDown(20.0, 20.0))
   assert miss.events.length() == 0
 test "input_changes_stage_in_place"
   h := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  assert h.stage.captured != null
+  assert h.stage.captured.isSome()
   assert inBtnPressed(h.stage)
 test "custom_actor_gets_pointer_through_on_input"
   h := Stage.create(inMoverTree()).input(inDown(20.0, 20.0))
   assert h.events.length() == 1
   assert h.events.at(0).id == 8
-  assert {h.stage.focus ?: -1} == 8
+  assert h.stage.focus.unwrapOr(-1) == 8
 test "focused_actor_consumes_its_key"
   h1 := Stage.create(inMoverTree()).input(inDown(20.0, 20.0))

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

@@ -6650,7 +6650,43 @@ fn compileEnumUnwrap(
             .func_ids
             .get(CRASH_FN_KEY)
             .ok_or_else(|| "internal codegen error: crash import missing".to_string())?;
+        // `x!`: "unwrap on None at f.plum:l:c" / "unwrap on Err(Name) at ..".
+        let at = match expr {
+            ast::Expr::Bang(b) => {
+                let file = withGen(|s| s.err_info.file.clone());
+                let file = if file.is_empty() { "main.plum".to_string() } else { file };
+                format!(" at {}:{}:{}", file, b.line, b.column)
+            }
+            _ => String::new(),
+        };
+        if kind == "Result" {
+            // An enum error names its variant: test the payload against each one.
+            let base = match &targs[1] {
+                PlumType::TNamed(n) | PlumType::TApp(n, _) => Some(n.clone()),
+                _ => None,
+            };
+            let err_variants: Vec<(String, u32)> = ctx
+                .enum_variants
+                .iter()
+                .filter(|(_, info)| Some(&info.enum_name) == base.as_ref() && !info.is_value)
+                .filter_map(|(v, _)| Some((v.clone(), ctx.gc_types.variantIdx(&targs[1], v)?)))
+                .collect();
+            if !err_variants.is_empty() {
+                let err_idx = variant(bad)?;
+                for (v, vidx) in &err_variants {
+                    Instruction::LocalGet(scratch).encode(body);
+                    Instruction::RefCastNonNull(HeapType::Concrete(err_idx)).encode(body);
+                    Instruction::StructGet { struct_type_index: err_idx, field_index: 0 }.encode(body);
+                    Instruction::RefTestNonNull(HeapType::Concrete(*vidx)).encode(body);
+                    Instruction::If(BlockType::Empty).encode(body);
+                    compileStaticString(&format!("unwrap on Err({}){}", v, at), body, state);
+                    Instruction::Call(crash_idx).encode(body);
+                    Instruction::Unreachable.encode(body);
+                    Instruction::End.encode(body);
+                }
+            }
+        }
-        compileStaticString(&format!("unwrap on {}", bad), body, state);
+        compileStaticString(&format!("unwrap on {}{}", bad, at), body, state);
         Instruction::Call(crash_idx).encode(body);
         Instruction::Unreachable.encode(body);
     }
@@ -8109,6 +8145,12 @@ fn compileDefaultArgs(
                 };
                 emitAbsent(d, &e.name, body)?
             }
+            // A payload-free variant default (`o: Option[Int] = None`): the clone has
+            // no recorded type, so take the singleton of the param's declared type.
+            Some(d) if defaultSingleton(default_expr, d, ctx).is_some() => {
+                let g = defaultSingleton(default_expr, d, ctx).expect("checked");
+                Instruction::GlobalGet(g).encode(body);
+            }
             Some(d) => compileExprInto(default_expr, d, body, ctx, state)?,
             None => compileExpr(default_expr, body, ctx, state)?,
         }
@@ -8116,6 +8158,17 @@ fn compileDefaultArgs(
     Ok(())
 }
+/// The singleton global of a payload-free variant default `n` of the param type `d`.
+fn defaultSingleton(default_expr: &ast::Expr, d: &PlumType, ctx: &LocalCtx) -> Option<u32> {
+    let ast::Expr::TypeName(n) = default_expr else { return None };
+    let info = ctx.enum_variants.get(n).filter(|i| i.field_types.is_empty())?;
+    match d {
+        PlumType::TNamed(e) | PlumType::TApp(e, _) if *e == info.enum_name => {}
+        _ => return None,
+    }
+    ctx.singleton_globals.get(&(canonTy(d), n.clone())).copied()
+}
 /// Constructs a value enum by pushing its flattened fields in declaration order. Each
 /// field comes from the same-named keyword argument, else the positional argument at its
 /// index, else (`Vec2(..v, x: 1.0)`) the spread source's field.

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -1368,15 +1368,16 @@ import std/Str
 import std/Int
 import std/Float
 import std/Slice
+import std/Option
 fun main() -> Int =
   l := Slice[Bool]()
   l.push(true)
   l.push(false)
   l.push(true)
-  a := l.get(0) catch false
+  a := l.get(0).unwrapOr(false)
-  b := l.get(1) catch true
+  b := l.get(1).unwrapOr(true)
-  c := l.get(2) catch false
+  c := l.get(2).unwrapOr(false)
   if a && !b && c && l.length() == 3
     return 1
   return 0
@@ -1407,27 +1408,30 @@ fun main() -> Int =
 }
 #[test]
-fn builtin_bool_in_error_union_with_question_and_catch() {
+fn builtin_bool_in_result_with_question_and_unwrap_or() {
     let src = "\
 import std/Str
 import std/Bool
 import std/Int
 import std/Float
+import std/Result
+enum NopeError = Nope | Other
-fun yes(ok: Bool) -> error{Nope}!Bool =
+fun yes(ok: Bool) -> Result[Bool, NopeError] =
   if ok
-    true
+    Ok(true)
   else
-    return error.Nope
+    return Err(Nope)
-fun chain(ok: Bool) -> error{Nope}!Bool =
+fun chain(ok: Bool) -> Result[Bool, NopeError] =
-  v := try yes(ok)
+  v := yes(ok)?
-  !v
+  Ok(!v)
 fun main() -> Int =
-  a := chain(true) catch true
+  a := chain(true).unwrapOr(true)
-  b := chain(false) catch true
+  b := chain(false).unwrapOr(true)
-  p := Bool.parse(\"true\") catch false
+  p := Bool.parse(\"true\").unwrapOr(false)
   if !a && b && p
     return 1
   return 0
@@ -2210,8 +2214,8 @@ fun main() -> Int =
 }
 #[test]
-fn bang_message_names_the_file_of_the_callee_fn() {
+fn bang_on_none_crashes_with_unwrap_message() {
-    // A `!` inside a std fn would name that file; here the user file's own fn does.
+    // `!` on an Option unwraps it and crashes with the std unwrap message.
     let src = "\
 import std/Str
 import std/Int
@@ -2228,11 +2232,41 @@ fun main() -> Int =
     assert!(r.is_err());
     assert_eq!(msgs.len(), 1, "{msgs:?}");
     assert!(
-        msgs[0].starts_with("first failed with ListWasEmpty at "),
+        msgs[0].starts_with("unwrap on None at "),
         "{}",
         msgs[0]
     );
-    assert!(msgs[0].contains("main.plum:"), "{}", msgs[0]);
+    assert!(msgs[0].contains("main.plum:7:"), "{}", msgs[0]);
+}
+#[test]
+fn bang_on_err_names_the_variant_and_location() {
+    let src = "\
+import std/Str
+import std/Int
+import std/Result
+enum Oops =
+  | ListWasEmpty
+  | Other(code: Int)
+fun get(n: Int) -> Result[Int, Oops] =
+  if n == 0
+    Err(ListWasEmpty)
+  else
+    Err(Other(n))
+fun main() -> Int =
+  get(0)!
+";
+    let (r, msgs) = runWithCrash("bangerr", src);
+    assert!(r.is_err());
+    assert_eq!(msgs.len(), 1, "{msgs:?}");
+    assert!(msgs[0].starts_with("unwrap on Err(ListWasEmpty) at "), "{}", msgs[0]);
+    assert!(msgs[0].contains("main.plum:16:"), "{}", msgs[0]);
+    let (r, msgs) = runWithCrash("bangerr2", &src.replace("get(0)!", "get(3)!"));
+    assert!(r.is_err());
+    assert!(msgs[0].starts_with("unwrap on Err(Other) at "), "{}", msgs[0]);
 }
 #[test]

plum-wasm-codegen/tests/e2e_tail/error_tail.rs CHANGED Viewed

@@ -51,3 +51,30 @@ fn different_error_sets_normal_call() {
     assert_eq!(runInt("different_error_sets_normal_call", &src), 7);
 }
+// Result twins of the error-union tests above (the old `error{..}!T` forms go in D3).
+const RHEAD: &str = "import std/Int\nimport std/Result\n\nenum NegError = Neg | Other\n\n";
+#[test]
+fn result_self_loop_million() {
+    let src = format!("{RHEAD}fun down(n: Int) -> Result[Int, NegError] =\n  if n < 0\n    return Err(Neg)\n  if n == 0\n    return Ok(5)\n  down(n - 1)\n\nfun main() -> Int = down(1000000).unwrapOr(99)\n");
+    assert_eq!(runInt("result_self_loop_million", &src), 5);
+}
+#[test]
+fn result_self_loop_returns_err() {
+    let src = format!("{RHEAD}fun down(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Err(Neg)\n  down(n - 1)\n\nfun main() -> Int = down(1000000).unwrapOr(42)\n");
+    assert_eq!(runInt("result_self_loop_returns_err", &src), 42);
+}
+#[test]
+fn result_mutual_million() {
+    let src = format!("{RHEAD}fun ping(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Ok(1)\n  pong(n - 1)\n\nfun pong(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Ok(2)\n  ping(n - 1)\n\nfun main() -> Int = ping(1000000).unwrapOr(99)\n");
+    assert_eq!(runInt("result_mutual_million", &src), 1);
+}
+#[test]
+fn question_in_tail_not_tail_call() {
+    let src = format!("{RHEAD}fun down(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Ok(5)\n  v := down(n - 1)?\n  Ok(v)\n\nfun main() -> Int = down(100).unwrapOr(99)\n");
+    assert_eq!(runInt("question_in_tail_not_tail_call", &src), 5);
+}

plum-wasm-codegen/tests/e2e_tail/tail.rs CHANGED Viewed

@@ -247,9 +247,9 @@ fn tail_call_in_match_arm() {
 #[test]
 fn non_tail_union_wrap_not_tail() {
-    // The callee returns Int but the fn returns Int?: the call is wrapped on the way
+    // The callee returns Int but the fn returns Option[Int]: the call is wrapped on the way
     // out, so it must stay a normal call and still produce the right value.
-    let src = format!("{HEAD}fun inner(n: Int) -> Int = n + 1\n\nfun outer(n: Int) -> Int? = inner(n)\n\nfun main() -> Int =\n  v := outer(41)\n  v ?: 0\n");
+    let src = format!("{HEAD}import std/Option\n\nfun inner(n: Int) -> Int = n + 1\n\nfun outer(n: Int) -> Option[Int] = Some(inner(n))\n\nfun main() -> Int =\n  v := outer(41)\n  v.unwrapOr(0)\n");
     assert_eq!(runInt("wrap", &src), 42);
 }

plum-wasm-codegen/tests/e2e_types/closure_optional.rs CHANGED Viewed

@@ -1,28 +1,28 @@
-//! F-T3-2: closures whose expected return is `T?` / `!T`, calls through an fn-typed
+//! F-T3-2: closures whose expected return is `Option[T]` / `Result[T, E]`, calls through an fn-typed
 //! field returning `T?`, and static methods of a generic type that never pin `T`.
 use plum_test_support::*;
 #[test]
 fn closure_coerced_into_optional_return() {
-    let src = "import std/Int\n\nfun ap(f: fn() -> Int?) -> Int =\n  f() ?: 0\n\nfun main() -> Int =\n  ap(|| 3)\n";
+    let src = "import std/Int\nimport std/Option\n\nfun ap(f: fn() -> Option[Int]) -> Int =\n  f().unwrapOr(0)\n\nfun main() -> Int =\n  ap(|| Some(3))\n";
     assert_eq!(runInt("opt_present", src), 3);
 }
 #[test]
-fn closure_returning_null_into_optional() {
+fn closure_returning_none_into_optional() {
-    let src = "import std/Int\n\nfun ap(f: fn() -> Int?) -> Int =\n  f() ?: 7\n\nfun main() -> Int =\n  ap(|| null)\n";
+    let src = "import std/Int\nimport std/Option\n\nfun ap(f: fn() -> Option[Int]) -> Int =\n  f().unwrapOr(7)\n\nfun main() -> Int =\n  ap(|| None)\n";
     assert_eq!(runInt("opt_null", src), 7);
 }
 #[test]
-fn closure_into_ref_optional_and_error_union() {
-    let src = "import std/Int\nimport std/Str\n\nfun s(f: fn(Int) -> Str?) -> Str =\n  f(1) ?: \"none\"\n\nfun e(f: fn(Int) -> error{Bad}!Int) -> Int =\n  f(1) catch 9\n\nfun main() -> Int =\n  b := s(|x| {if x > 0 then \"yes\" else null}).length()\n  b2 := s(|x| \"ab\").length()\n  c := e(|x| x + 1)\n  d := e(|x| error.Bad)\n  b * 1000 + b2 * 100 + c * 10 + d\n";
+fn closure_into_ref_option_and_result() {
+    let src = "import std/Int\nimport std/Str\nimport std/Option\nimport std/Result\n\nenum BadError = Bad | Worse\n\nfun s(f: fn(Int) -> Option[Str]) -> Str =\n  f(1).unwrapOr(\"none\")\n\nfun e(f: fn(Int) -> Result[Int, BadError]) -> Int =\n  f(1).unwrapOr(9)\n\nfun main() -> Int =\n  b := s(|x| {if x > 0 then Some(\"yes\") else None}).length()\n  b2 := s(|x| Some(\"ab\")).length()\n  c := e(|x| Ok(x + 1))\n  d := e(|x| Err(Bad))\n  b * 1000 + b2 * 100 + c * 10 + d\n";
     assert_eq!(runInt("opt_mixed", src), 3229);
 }
 #[test]
 fn fn_field_returning_optional() {
-    let src = "import std/Int\n\nstruct Gen(next: fn() -> Int?)\n\nfun count(g: Gen) -> Int =\n  g.next() ?: 0\n\nfun main() -> Int =\n  k := 5\n  count(Gen(next: || k))\n";
+    let src = "import std/Int\nimport std/Option\n\nstruct Gen(next: fn() -> Option[Int])\n\nfun count(g: Gen) -> Int =\n  g.next().unwrapOr(0)\n\nfun main() -> Int =\n  k := 5\n  count(Gen(next: || Some(k)))\n";
     assert_eq!(runInt("field_opt", src), 5);
 }
@@ -34,6 +34,6 @@ fn static_method_of_generic_type_not_pinning_t() {
 #[test]
 fn seq_with_optional_next() {
-    let src = "import std/Int\n\nstruct Seq[T](next: fn(Int) -> T?) =\n  fun upTo(n: Int) -> Seq[Int] = Seq(next: |i| {if i < n then i * 2 else null})\n  fun sum(self) -> Int =\n    total := 0\n    i := 0\n    while v := self.next(i)\n      total = total + v\n      i = i + 1\n    total\n\nfun main() -> Int =\n  Seq.upTo(4).sum()\n";
+    let src = "import std/Int\nimport std/Option\n\nstruct Seq[T](next: fn(Int) -> Option[T]) =\n  fun upTo(n: Int) -> Seq[Int] = Seq(next: |i| {if i < n then Some(i * 2) else None})\n  fun sum(self) -> Int =\n    total := 0\n    i := 0\n    while Some(v) := self.next(i)\n      total = total + v\n      i = i + 1\n    total\n\nfun main() -> Int =\n  Seq.upTo(4).sum()\n";
     assert_eq!(runInt("seq_opt", src), 12);
 }

plum-wasm-codegen/tests/e2e_types/question.rs CHANGED Viewed

@@ -134,3 +134,19 @@ fn specialised_arm_keeps_result_type() {
     );
     assert_eq!(runInt("q_spec_arm", &src), 1038);
 }
+#[test]
+fn none_as_param_default() {
+    let src = prog(
+        "fun f(n: Option[Int] = None) -> Option[Int] = n\n\nfun main() -> Int =\n  a := f().unwrapOr(7)\n  b := f(Some(3)).unwrapOr(0)\n  a * 10 + b\n",
+    );
+    assert_eq!(runInt("q_none_default", &src), 73);
+}
+#[test]
+fn none_as_generic_param_default() {
+    let src = prog(
+        "fun g(x: T, o: Option[T] = None) -> Option[T] = o\n\nfun main() -> Int =\n  a := g(1).unwrapOr(7)\n  b := g(1, Some(3)).unwrapOr(0)\n  a * 10 + b\n",
+    );
+    assert_eq!(runInt("q_none_generic_default", &src), 73);
+}

plum-wasm-codegen/tests/e2e_types/type_param_static.rs CHANGED Viewed

@@ -70,8 +70,7 @@ fun buildAll(ns: Slice[Int]) -> Slice[T] =
 fun main() -> Int =
   ps: Slice[Pt] := buildAll([1, 2, 3].toSlice())
-  p := ps.get(2) catch e
+  p := ps.get(2).unwrapOr(Pt(x: 0))
-    return 0
   return p.x
 ";
     assert_eq!(runInt("nested", src), 4);
@@ -83,14 +82,14 @@ fn static_on_builtin_method_and_json_cycle() {
 import std/Int
 import std/Str
 import std/Json
+import std/Result
-fun parseIt(s: Str) -> error{BadNumStr}!T =
+fun parseIt(s: Str) -> Result[T, NumError] =
   T.parse(s)
 fun main() -> Int =
-  r: error{BadNumStr}!Int := parseIt(\"41\")
+  r: Result[Int, NumError] := parseIt(\"41\")
-  n := r catch e
+  n := r.unwrapOr(0)
-    return 0
   j := n.toJson()
   return n + 1
 ";