82b552d | plum | pyrossh

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

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

82b552d — Peter John 2026-10-25T16:30:41+05:30

docs(examples): migrate examples, LSP, editor syntax and README to Try + tags

Files changed (10) hide show

README.md +41 -18
plum-examples/dop_visitor.plum +2 -2
plum-examples/error_propagation.plum +80 -44
plum-examples/match.plum +13 -18
plum-examples/oop_visitor.plum +2 -2
plum-examples/safe_navigation.plum +13 -31
plum-examples/types.plum +17 -14
plum-lsp/src/completion.rs +1 -1
plum-tooling/vscode-plum/syntaxes/plum.tmLanguage.json +5 -5
plum-wasm-codegen/tests/examples_test.rs +8 -0

README.md CHANGED Viewed

@@ -218,9 +218,9 @@ enum Color =
   | Green
   | Blue
-enum Option =
+enum Maybe =
-  | Some(Int) # unnamed positional payload — Some(5)
+  | Just(Int) # unnamed positional payload — Just(5)
-  | None
+  | Nothing
 enum Shape =
   | Circle(radius: Int) # named payload fields — Circle(radius: 5) or Circle(5)
@@ -308,9 +308,9 @@ match n
     else
       2
-match opt
+match maybe
-  Some(v) => v
+  Just(v) => v
-  None => 0
+  Nothing => 0
 match book
   FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures =>
@@ -318,7 +318,7 @@ match book
   FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
 ```
-Patterns can be literals, a bare identifier (binds), a bare capitalized tag (compared), a constructor pattern (`Some(v)`, binding its argument), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard.
+Patterns can be literals, a bare identifier (binds), a bare capitalized tag (compared), a constructor pattern (`Just(v)`, binding its argument), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard.
 ## String interpolation
@@ -342,30 +342,52 @@ $ plum run plum-examples/io.plum
 hello from plum
 ```
-## Error propagation
+## Error handling
-`expr?` unwraps a `Result`'s `Ok` or an `Option`'s `Some`, or exits the enclosing function early with the `Err`/`None` value as-is otherwise — Rust's `?`:
+There is no `Option` and no exceptions. A fallible function returns `Try[T, E]`, which is either `Ok(T)` or `Err(E)`. `E` is normally a *tag union* — a set of bare tags (optionally carrying a payload) that needs no declaration:
 ```plum
-fun sumTwo(a: Str, b: Str) -> Result[Int, Str] =
+fun parsePositive(s: Str) -> Try[Int, [BadNumStr, NegativeNum]] =
-  x := parsePositive(a)?
+  n := parseInt(s)?
+  if n < 0
-  y := parsePositive(b)?
+    return Err(NegativeNum)
-  return Ok(x + y)
+  return Ok(n)
 ```
-`left ?: right` (elvis) is the plain-expression counterpart — no early return, just a fallback value if `left` is `Err`/`None`:
+A "missing value" is just an error tag: `List.get` fails with `[OutOfBounds]`, `first`/`last`/`pop` with `[ListWasEmpty]`, `Map.get` with `[KeyNotFound]`, `parseInt`/`parseFloat` with `[BadNumStr]`, `Json.fromStr` with `[InvalidJson(Str)]`.
+`expr?` unwraps an `Ok`, or exits the enclosing function early with the `Err` value — Rust's `?`. Tag unions merge automatically across `?`: the function's declared union just has to cover every union it propagates:
+```plum
+fun numAt(s: Str, i: Int) -> Try[Int, [BadNumStr, OutOfBounds]] =
+  n := parseInt(s)?        # [BadNumStr]
+  x := List(10, 20, 30).get(i)?   # [OutOfBounds]
+  return Ok(n + x)
+```
+`expr ? |e| Tag` maps the error to a different tag before propagating it:
+```plum
+fun parseOrInvalid(s: Str) -> Try[Int, [InvalidInput]] =
+  n := parseInt(s) ? |e| InvalidInput
+  return Ok(n)
+```
+`left ?? right` is the plain-expression counterpart — no early return, just a fallback value if `left` is an `Err`:
 ```plum
 fun sumOrZero(a: Str, b: Str) -> Int =
-  x := parsePositive(a) ?: 0
+  x := {parsePositive(a) ?? 0}
-  y := parsePositive(b) ?: 0
+  y := {parsePositive(b) ?? 0}
   x + y
 ```
-`obj?.field` / `obj?.method(args)` (safe navigation, Groovy/Kotlin-style) reaches into a `Result`/`Option` value without unwrapping it — `Some`/`Ok` maps the field or method access over the inner value and re-wraps it, `None`/`Err` passes through untouched:
+`crash "msg"` aborts the program with a message. Use it for bugs (a broken invariant), not for expected failures; `unwrap()` on an `Err` crashes the same way.
+`obj?.field` / `obj?.method(args)` (safe navigation, Groovy/Kotlin-style) reaches into a `Try` value without unwrapping it — `Ok` maps the field or method access over the inner value and re-wraps it, `Err` passes through untouched:
 ```plum
-fun cityName(person: Option[Person]) -> Option[Str] =
+fun cityName(person: Try[Person, [Missing]]) -> Try[Str, [Missing]] =
   person?.city?.name
 ```
@@ -374,6 +396,7 @@ It's sugar for `obj.map(|v| v.field)` — nothing more than that; chain it as ma
 ## Standard library highlights
 - **`Bool`** (`import std/Bool`) — ordinary `enum Bool = | True | False`
+- **`Try[T, E]`** (`import std/Try`) — `Ok(T)` or `Err(E)`; `isOk`/`isErr`/`unwrap`/`unwrapOr`/`unwrapOrElse`/`map`/`mapErr`/`andThen`
 - **`Str`** (`import std/Str`) — a byte array with a codepoint-aware layer for Unicode correctness: `runeLength`, `runeAt`, `codePointAt`, `codePointToStr`
 - **`Byte`** / **`[]Byte`** (`import std/Byte`) — a scalar unsigned 8-bit value and a fixed-length mutable byte slice
 - **`Buffer`** (`import std/Buffer`) — a growable, mutable byte sequence for building up a `Str`, amortized O(n) writes

plum-examples/dop_visitor.plum CHANGED Viewed

@@ -43,7 +43,7 @@ import std/Str
 enum Rating =
   | Good(name: Str)
-  | Bad(name: Str)
+  | Poor(name: Str)
 enum Book =
   | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
@@ -107,6 +107,6 @@ test "non fiction book with a bad rating reports mixed reviews"
     title: "Shaky Claims",
     pages: 80,
     rating1: Good(name: "Alice"),
-    rating2: Bad(name: "Carol"),
+    rating2: Poor(name: "Carol"),
   )
   assert collectInterestingInfo(book) == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/error_propagation.plum CHANGED Viewed

@@ -1,57 +1,66 @@
-import std/Result
+import std/Try
-import std/Option
 import std/Bool
 import std/Number
 import std/Str
 import std/List
-# `expr?` unwraps a `Result`'s `Ok` or an `Option`'s `Some`, or exits the
+# `Try[T, E]` is either `Ok(T)` or `Err(E)`. `E` is normally a tag union such
-# enclosing function early with the `Err`/`None` value as-is otherwise — same
+# as `[NegativeNum, BadNumStr]`: a set of bare tags (optionally carrying a
-# idea as Rust's `?`. The enclosing function's own return type must accept
-# whatever gets returned early; that isn't checked until codegen (see
+# payload, e.g. `InvalidJson(Str)`) that needs no declaration. There is no
-# `plum-checker`'s `inferExpr` on `Expr::Try`), so a mismatch there still
-# surfaces as a clear compile error, just a less precise one.
+# `Option`: a missing value is just an error tag like `[OutOfBounds]`.
 #
+# `expr?` unwraps an `Ok`, or exits the enclosing function early with the
+# `Err` value. The error unions of different calls merge automatically into
+# the enclosing function's declared union, so `parseInt(s)?` (`[BadNumStr]`)
+# and `xs.get(i)?` (`[OutOfBounds]`) can share one function.
+#
+# `expr ? |e| Tag` maps the error to a different tag before propagating it.
+#
-# `left ?: right` (elvis) is the plain-expression counterpart: same Ok/Some
+# `left ?? right` is the plain-expression counterpart: no early return,
+# `right` is the fallback used when `left` is an `Err`.
+#
-# vs Err/None narrowing, but no early return — `right` is a fallback value,
+# `crash "msg"` aborts the program with a message; use it for bugs, not for
-# fully checked (unlike `?`) since there's no enclosing-return-type
-# uncertainty to be permissive about.
+# expected failures.
-fun parsePositive(s: Str) -> Result[Int, Str] =
+fun parsePositive(s: Str) -> Try[Int, [BadNumStr, NegativeNum]] =
   n := parseInt(s)?
   if n < 0
-    return Err("negative")
+    return Err(NegativeNum)
   return Ok(n)
-fun sumTwo(a: Str, b: Str) -> Result[Int, Str] =
+fun sumTwo(a: Str, b: Str) -> Try[Int, [BadNumStr, NegativeNum]] =
   x := parsePositive(a)?
   y := parsePositive(b)?
   return Ok(x + y)
+# Two calls with different error unions merge into [BadNumStr, OutOfBounds].
-fun firstPositive(list: List[Int]) -> Option[Int] =
+fun numAt(s: Str, i: Int) -> Try[Int, [BadNumStr, OutOfBounds]] =
+  n := parseInt(s)?
+  xs := List(10, 20, 30)
-  match list.get(0)
+  x := xs.get(i)?
-    Some(v) =>
-      if v > 0
-        return Some(v)
+  return Ok(n + x)
-      return None
-    None =>
-      return None
+# `? |e| Tag` renames the error on the way out.
-fun doubledFirstPositive(list: List[Int]) -> Option[Int] =
+fun parseOrInvalid(s: Str) -> Try[Int, [InvalidInput]] =
-  a := firstPositive(list)?
+  n := parseInt(s) ? |e| InvalidInput
-  return Some(a * 2)
+  return Ok(n)
-# `left ?: right` — same Ok/Some-vs-Err/None narrowing as `?`, but a plain
-# expression (no early return): `right` is the fallback value, unified against
+fun doubledFirst(list: List[Int]) -> Try[Int, [ListWasEmpty]] =
-# the success field's type by the checker.
+  a := list.first()?
+  return Ok(a * 2)
 fun sumOrZero(a: Str, b: Str) -> Int =
-  x := parsePositive(a) ?: 0
+  x := {parsePositive(a) ?? 0}
-  y := parsePositive(b) ?: 0
+  y := {parsePositive(b) ?? 0}
   x + y
 fun firstOrDefault(list: List[Int], default: Int) -> Int =
-  list.get(0) ?: default
+  {list.first() ?? default}
+fun mustBePositive(n: Int) -> Int =
+  if n < 0
+    crash "n must not be negative"
+  n
 test "try operator unwraps Ok and propagates the value through two calls"
   r := sumTwo("2", "3")
@@ -61,23 +70,50 @@ test "try operator unwraps Ok and propagates the value through two calls"
 test "try operator exits early with Err, skipping the rest of the function"
   r := sumTwo("2", "-3")
   assert r.isErr()
+  match r
+    Ok(_) =>
+      assert False
-  assert r.unwrapErr() == "negative"
+    Err(NegativeNum) =>
+      assert True
+    Err(BadNumStr) =>
+      assert False
-test "try operator unwraps Some and propagates the value"
+test "try operator merges two different error unions"
-  l := List(5)
+  assert numAt("5", 1).unwrap() == 25
-  r := doubledFirstPositive(l)
+  match numAt("x", 1)
+    Ok(_) =>
-  assert r.isSome()
+      assert False
+    Err(BadNumStr) =>
+      assert True
-  assert r.unwrap() == 10
+    Err(OutOfBounds) =>
+      assert False
+  match numAt("5", 9)
+    Ok(_) =>
+      assert False
+    Err(BadNumStr) =>
+      assert False
+    Err(OutOfBounds) =>
+      assert True
-test "try operator exits early with None, skipping the rest of the function"
+test "try with a closure maps the error to another tag"
-  l := List[Int]()
+  assert parseOrInvalid("7").unwrap() == 7
-  r := doubledFirstPositive(l)
+  match parseOrInvalid("x")
+    Ok(_) =>
-  assert r.isNone()
+      assert False
+    Err(InvalidInput) =>
+      assert True
+test "try operator on a list that is empty yields ListWasEmpty"
+  assert doubledFirst(List(5)).unwrap() == 10
+  assert doubledFirst(List[Int]()).isErr()
-test "elvis operator unwraps Ok and falls back to 0 on Err"
+test "default operator unwraps Ok and falls back to 0 on Err"
   assert sumOrZero("2", "3") == 5
   assert sumOrZero("2", "-3") == 2
-test "elvis operator unwraps Some and falls back to the given default on None"
+test "default operator falls back to the given default on an empty list"
   assert firstOrDefault(List(5), 99) == 5
   assert firstOrDefault(List[Int](), 99) == 99
+test "crash is not reached on the happy path"
+  assert mustBePositive(3) == 3

plum-examples/match.plum CHANGED Viewed

@@ -1,4 +1,4 @@
-import std/Option
+import std/Try
 import std/Bool
 import std/Number
 import std/Str
@@ -29,16 +29,8 @@ fun describeColor(c: Color) -> Str =
     Green => "green"
     Blue => "blue"
-# A dedicated, non-generic "maybe an Int" — as opposed to the real, generic
+# A dedicated, non-generic "maybe an Int", as opposed to the generic
-# `Option[T]` (`import std/option` above, used elsewhere in this file):
+# `Try[T, E]` (used elsewhere in this file).
-# constructing a bare payload-free variant (`Absent` here, `None` for a real
-# generic enum) outside of a `match` pattern can't be disambiguated between
-# multiple concrete instantiations of ITS enum from that expression alone
-# (see the README's Generics section) — and since this file's forced-in
-# stdlib prelude (`plum-core::loader::loadAndMerge`) uses `Option` at several
-# OTHER concrete types internally, a bare `None` here genuinely IS
-# ambiguous. `IntOpt` sidesteps that entirely by only ever having ONE
-# possible instantiation to begin with.
 enum IntOpt =
   | Present(Int)
   | Absent
@@ -100,10 +92,10 @@ fun colorCode(c: Color) -> Int =
     Green => 2
     Blue => 3
-fun isSome(o: Option) -> Int =
+fun isSome(o: Try[Int, [Missing]]) -> Int =
   match o
-    Some(_) => 1
+    Ok(_) => 1
-    None => 0
+    Err(_) => 0
 # Mirrors libs/std/bool.plum's `and`/`or`: `match a, b` against two Bool
 # subjects, each case naming a tag pattern per position.
@@ -133,9 +125,12 @@ fun combine(a: Int, b: Int) -> Int =
     x, 0 => x
     x, y => x + y
+fun okInt(n: Int) -> Try[Int, [Missing]] =
+  return Ok(n)
-fun bothOptions(a: Option, b: Option) -> Int =
+fun bothOptions(a: Try[Int, [Missing]], b: Try[Int, [Missing]]) -> Int =
   match a, b
-    Some(x), Some(y) => x + y
+    Ok(x), Ok(y) => x + y
     _, _ => 0
 enum Point =
@@ -199,7 +194,7 @@ test "non bool bare tag pattern runs correctly"
   assert colorCode(Green) == 2
 test "constructor pattern wildcard field runs correctly"
-  assert isSome(Some(99)) == 1
+  assert isSome(okInt(99)) == 1
 test "constructor pattern does not misfire on payload free sibling"
   assert describeOption(Absent) == 0
@@ -217,7 +212,7 @@ test "multi subject match with binding and wildcard runs correctly"
   assert combine(3, 4) == 7
 test "multi subject match with generic enum variant runs correctly"
-  assert bothOptions(Some(3), Some(4)) == 7
+  assert bothOptions(okInt(3), okInt(4)) == 7
 test "match destructures a plain class the same way it destructures an enum variant"
   assert Point(x: 3, y: 4).sum() == 7

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -36,7 +36,7 @@ import std/Str
 enum Rating =
   | Good(name: Str)
-  | Bad(name: Str)
+  | Poor(name: Str)
 trait Book =
   collectInterestingInfo() -> Str
@@ -119,6 +119,6 @@ test "non fiction book with a bad rating reports mixed reviews"
     title: "Shaky Claims",
     pages: 80,
     rating1: Good(name: "Alice"),
-    rating2: Bad(name: "Carol"),
+    rating2: Poor(name: "Carol"),
   )
   assert book.collectInterestingInfo() == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/safe_navigation.plum CHANGED Viewed

@@ -1,12 +1,11 @@
-import std/Option
+import std/Try
-import std/Result
 import std/Bool
 import std/Number
 import std/Str
 # `obj?.field` / `obj?.method(args)` — Groovy/Kotlin-style safe navigation.
-# Reaches into a `Result`'s `Ok`/an `Option`'s `Some` without unwrapping it,
+# Reaches into a `Try`'s `Ok` without unwrapping it,
 # mapping the field/method access over the inner value and re-wrapping the
-# result; `Err`/`None` passes through untouched. Pure sugar for
+# result; `Err` passes through untouched. Pure sugar for
 # `obj.map(|v| v.field)` — desugared entirely in the parser (see
 # `plum-core`'s `parseSafeAttribute`), so nothing past it needs to know this
 # syntax exists.
@@ -17,43 +16,26 @@ enum Person =
   fun birthday(self) -> Int =
     self.age + 1
-fun personName(p: Option[Person]) -> Option[Str] =
+fun personName(p: Try[Person, [Missing]]) -> Try[Str, [Missing]] =
   p?.name
-fun personBirthday(p: Option[Person]) -> Option[Int] =
+fun personBirthday(p: Try[Person, [Missing]]) -> Try[Int, [Missing]] =
   p?.birthday()
-fun personNameResult(p: Result[Person, Str]) -> Result[Str, Str] =
-  p?.name
-fun somePerson() -> Option[Person] =
+fun somePerson() -> Try[Person, [Missing]] =
-  Some(Person(name: "Ann", age: 3))
-fun noPerson() -> Option[Person] =
-  None
-fun okPerson() -> Result[Person, Str] =
   Ok(Person(name: "Ann", age: 3))
-fun errPerson() -> Result[Person, Str] =
+fun noPerson() -> Try[Person, [Missing]] =
-  Err("missing")
+  Err(Missing)
-test "safe navigation maps a field access over Some, passes None through unchanged"
+test "safe navigation maps a field access over Ok, passes Err through unchanged"
   a := personName(somePerson())
-  assert a.isSome()
+  assert a.isOk()
   assert a.unwrap() == "Ann"
   b := personName(noPerson())
-  assert b.isNone()
+  assert b.isErr()
-test "safe navigation maps a method call over Some"
+test "safe navigation maps a method call over Ok"
   a := personBirthday(somePerson())
-  assert a.isSome()
-  assert a.unwrap() == 4
-test "safe navigation maps a field access over Ok, passes Err through unchanged"
-  a := personNameResult(okPerson())
   assert a.isOk()
-  assert a.unwrap() == "Ann"
+  assert a.unwrap() == 4
-  b := personNameResult(errPerson())
-  assert b.isErr()
-  assert b.unwrapErr() == "missing"

plum-examples/types.plum CHANGED Viewed

@@ -1,4 +1,4 @@
-import std/Option
+import std/Try
 import std/Bool
 import std/Str
 import std/Number
@@ -60,11 +60,11 @@ enum Dog =
   fun getAge(self) -> Int =
     self.age
-enum Pair =
+enum IntPair =
-  | Pair(a: Int, b: Int)
+  | IntPair(a: Int, b: Int)
 enum Wrapper =
-  | Wrapper(inner: Pair, tag: Int)
+  | Wrapper(inner: IntPair, tag: Int)
 enum LoopBox =
   | LoopBox(v: Int)
@@ -88,11 +88,14 @@ fun stepToNumber(s: Step) -> Int =
     ReadMin => 1
     ReadMax => 2
+fun okIntForTypes(n: Int) -> Try[Int, [Missing]] =
+  return Ok(n)
-fun unwrapOptionOr(o: Option[Int], default: Int) -> Int =
+fun unwrapTryOr(o: Try[Int, [Missing]], default: Int) -> Int =
   match o
-    Some(v) =>
+    Ok(v) =>
       return v
-    None =>
+    Err(_) =>
       return default
 enum ShapeKind =
@@ -116,14 +119,14 @@ enum ShapeWithFields =
 fun numberKind(n: Number) -> Str =
   n.kind()
-enum OptionBox =
+enum TryBox =
-  | OptionBox(value: Option[Int])
+  | TryBox(value: Try[Int, [Missing]])
   fun unwrap(default: Int) -> Int =
     match self.value
-      Some(v) =>
+      Ok(v) =>
         return v
-      None =>
+      Err(_) =>
         return default
 test "class field and method run correctly"
@@ -135,7 +138,7 @@ test "nested method declaration runs correctly"
   assert d.getAge() == 7
 test "nested class call runs correctly"
-  w := Wrapper(inner: Pair(a: 11, b: 22), tag: 99)
+  w := Wrapper(inner: IntPair(a: 11, b: 22), tag: 99)
   assert w.inner.b == 22
 test "repeated class call in a loop does not alias"
@@ -152,7 +155,7 @@ test "enum discriminant value matches by variant name correctly"
   assert stepToNumber(ReadMin) * 10 + stepToNumber(ReadMax) == 12
 test "payload variant construction compiles and runs"
-  assert unwrapOptionOr(Some(7), 0) == 7
+  assert unwrapTryOr(okIntForTypes(7), 0) == 7
 test "multi field variant construction compiles and runs"
   assert area(Rect(3, 4)) == 12
@@ -194,7 +197,7 @@ test "a bare Int/Float value dispatches a method defined only on Number, via fal
   assert {2.5}.kind() == "Float"
 test "enum class field construct and destructure runs correctly"
-  b := OptionBox(value: Some(42))
+  b := TryBox(value: okIntForTypes(42))
   assert b.unwrap(0) == 42
 test "class field mutation and spread update run correctly"

plum-lsp/src/completion.rs CHANGED Viewed

@@ -25,7 +25,7 @@ use plum_core::ast;
 use tower_lsp::lsp_types::*;
 const KEYWORDS: &[&str] = &[
-    "fun", "enum", "trait", "import", "module", "extern", "if", "else", "while", "for", "match",
+    "fun", "crash", "??", "enum", "trait", "import", "module", "extern", "if", "else", "while", "for", "match",
     "case", "when", "break", "continue", "return", "todo", "assert", "test", "self", "True",
     "False",
 ];

plum-tooling/vscode-plum/syntaxes/plum.tmLanguage.json CHANGED Viewed

@@ -44,7 +44,7 @@
         },
         {
           "name": "keyword.control.plum",
-          "match": "\\b(import|in|return|continue|break|match|when|if|else|while|for|assert|todo)\\b"
+          "match": "\\b(import|in|return|continue|break|match|when|if|else|while|for|assert|todo|crash)\\b"
         },
         {
           "name": "keyword.operator.range.plum",
@@ -59,17 +59,17 @@
           "match": "(==|!=|<=|>=|<|>)"
         },
         {
-          "comment": "elvis (Result/Option unwrap-or-fallback) — checked before the bare `?` try-operator below, since `?:` must win the longer match",
+          "comment": "default operator (Try unwrap-or-fallback) — checked before the bare `?` try-operator below, since `??` must win the longer match",
           "name": "keyword.operator.elvis.plum",
-          "match": "\\?:"
+          "match": "\\?\\?"
         },
         {
-          "comment": "safe navigation (Result/Option `.map` sugar) — checked before the bare `?` try-operator below, since `?.` must win the longer match",
+          "comment": "safe navigation (Try `.map` sugar) — checked before the bare `?` try-operator below, since `?.` must win the longer match",
           "name": "keyword.operator.safenav.plum",
           "match": "\\?\\."
         },
         {
-          "comment": "postfix try-operator (Result/Option unwrap-or-early-return) — matched only when `?` glues directly to the preceding token with no space, `plum format`'s own convention for this postfix operator (unlike ternary's `?`, always spaced); ternary's own `?`/`:` are deliberately left unstyled here too, matching the tree-sitter highlights.scm, since a regex can't reliably tell them apart",
+          "comment": "postfix try-operator (Try unwrap-or-early-return) — matched only when `?` glues directly to the preceding token with no space, `plum format`'s own convention for this postfix operator (unlike ternary's `?`, always spaced); ternary's own `?`/`:` are deliberately left unstyled here too, matching the tree-sitter highlights.scm, since a regex can't reliably tell them apart",
           "name": "keyword.operator.try.plum",
           "match": "(?<=[A-Za-z0-9_\\)\\]])\\?(?!:)(?!\\.)"
         },

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

@@ -183,6 +183,14 @@ fn ioExampleCompilesAndRunsCorrectly() {
                     },
                 ))
             }
+            ("plum", "crash") => {
+                let func_ty = imp.ty().func().cloned().expect("crash import should be a function");
+                wasmtime::Extern::Func(wasmtime::Func::new(
+                    &mut store,
+                    func_ty,
+                    |_caller, _params, _results| Err(wasmtime::Error::msg("crash")),
+                ))
+            }
             (m, n) => panic!(
                 "io.plum test needs a stub for unexpected import {}::{}",
                 m, n