ff759b0 | plum | pyrossh

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

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

ff759b0 — Peter John 2026-10-27T17:48:08+05:30

chore: audit docs, comments and editor support against the current language

Files changed (22) hide show

README.md +21 -21
plum-checker/src/lib.rs +5 -5
plum-core/src/ast.rs +1 -1
plum-core/src/forms.rs +1 -1
plum-examples/dop_visitor.plum +4 -4
plum-examples/numbers.plum +3 -7
plum-examples/oop_visitor.plum +12 -13
plum-lsp/src/completion.rs +11 -3
plum-lsp/src/main.rs +26 -0
plum-std/Json.plum +2 -4
plum-std/List.plum +1 -1
plum-std/Str.plum +3 -3
plum-tooling/tree-sitter-plum/queries/plum/format.scm +3 -3
plum-tooling/tree-sitter-plum/queries/plum/highlights.scm +12 -8
plum-tooling/tree-sitter-plum/queries/plum/tags.scm +3 -0
plum-tooling/tree-sitter-plum/test/aa.plum +19 -12
plum-tooling/tree-sitter-plum/test/corpus/function.txt +2 -2
plum-tooling/tree-sitter-plum/test/corpus/safe_attribute.txt +1 -1
plum-tooling/tree-sitter-plum/test/corpus/try.txt +5 -14
plum-tooling/tree-sitter-plum/test/highlight/sample.plum +4 -4
plum-tooling/vscode-plum/syntaxes/plum.tmLanguage.json +1 -1
plum-wasm-codegen/src/lib.rs +3 -10

README.md CHANGED Viewed

@@ -51,7 +51,7 @@ Blocks are indentation-sensitive (2 spaces), like Python — there's no `{ }` fo
 ```plum
 # this is a comment
 fun main() =
-  x = 1
+  x := 1
   if x > 0
     x = x + 1
 ```
@@ -71,7 +71,7 @@ fun main() =
 ```plum
 module basics
-import std/io
+import std/Os
 ```
 ## Constants
@@ -85,17 +85,17 @@ GREETING = "hello"
 ## Literals
 ```plum
-dec = 42
+dec := 42
-hex = 0xFF
+hex := 0xFF
-bin = 0b1010
+bin := 0b1010
-big = 1_000_000
+big := 1_000_000
-flt = 3.14
+flt := 3.14
-flt2 = 12.0f
+flt2 := 12.0f
-exp = 6.022e23
+exp := 6.022e23
-name = "plum"
+name := "plum"
-escaped = "line one\nline two\ttabbed \"quoted\""
+escaped := "line one\nline two\ttabbed \"quoted\""
-yes = true
+yes := true
-no = false
+no := false
 ```
 ## Operators
@@ -122,10 +122,10 @@ From tightest to loosest binding:
 There's no range operator — every `for` is `for <binders> := range <source>`: `for i := range n` counts 0 to n-1, and the `Int` methods `a.until(b)` (a to b-1), `a.to(b)` (inclusive) and `a.downTo(b)` give other ranges (`for i := range 1.to(10)`). `{ }` is used to group a sub-expression (not `( )`, which is reserved for calls):
 ```plum
-grouped = {1 + 2} * {3 - 1}
+grouped := {1 + 2} * {3 - 1}
-picked = if cmp then sum else bits
+picked := if cmp then sum else bits
-negated = -sum
+negated := -sum
-inverted = !cmp
+inverted := !cmp
 ```
 ### Operators on your own types
@@ -407,7 +407,7 @@ Generic types, methods, and free functions are duck-typed and compiled once per
 Generics are duck-typed and compiled per type, as in Zig. A generic body is type-checked once per concrete instantiation, and each instantiation gets its own compiled copy with unboxed values: `List[Int]` and `List[Str]` are different code, and a `List[Float]` stores raw `f64`s.
-- **No bounds, no traits.** `[T]` carries no constraint. `fun show(x: T) -> Str = x.toStr()` works for every type that has a `toStr` method and fails at the use site otherwise. The old `trait`/`implements` syntax and `[T: X]` bounds are a parse error with a migration hint.
+- **No bounds.** `[T]` carries no constraint. `fun show(x: T) -> Str = x.toStr()` works for every type that has a `toStr` method and fails at the use site otherwise.
 - **Errors point at the use site.** A missing method is reported against the concrete type, with the chain of instantiations that led there:
 ```
@@ -418,7 +418,7 @@ in outer[Plain] (called at main.plum:9:3):
 - **Unreachable generics are not emitted.** A generic that no root (a non-generic fn or a test) reaches is neither checked per type nor compiled.
 - **Typed arrays are native.** Each instantiation stores its elements in an array of its own element type, with no boxing at generic edges.
-- **Explicit "trait values".** When a generic needs behavior that is not a method on `T`, pass it explicitly, like a Zig comptime parameter or a Haskell dictionary:
+- **Explicit behavior values.** When a generic needs behavior that is not a method on `T`, pass it explicitly, like a Zig comptime parameter or a Haskell dictionary:
 ```plum
 enum Num[T] =
@@ -536,7 +536,7 @@ fun greet(name: Str) -> Str =
   "Hello, {name}!"
 ```
-`{expr}` interpolates a variable, literal, attribute access, `&&`/`||`/comparison, an inline `if`, or a closure-taking method call.
+`{expr}` interpolates any expression: a variable, literal, attribute access, method call, `&&`/`||`/comparison or an inline `if`.
 ## `extern` functions and printing
@@ -544,7 +544,7 @@ fun greet(name: Str) -> Str =
 extern fun printLn(s: Str)
 ```
-`extern fun` declares a function backed by a host-provided wasm import, with no Plum body. At the boundary `Int` is narrowed to a wasm `i32` (the rest of the language uses 64-bit `Int`), so extern parameters and results are 32-bit. `plum-std/Os.plum` declares `printLn` for use via `import std/os`.
+`extern fun` declares a function backed by a host-provided wasm import, with no Plum body. At the boundary `Int` is narrowed to a wasm `i32` (the rest of the language uses 64-bit `Int`), so extern parameters and results are 32-bit. `plum-std/Os.plum` declares `printLn` for use via `import std/Os`.
 ```sh
 $ plum run plum-examples/io.plum

plum-checker/src/lib.rs CHANGED Viewed

@@ -39,7 +39,7 @@ thread_local! {
     static ERR_ACC: RefCell<BTreeSet<String>> = const { RefCell::new(BTreeSet::new()) };
     /// Call edges `(caller key, callee key)` seen while collecting error sets.
     static ERR_EDGES: RefCell<BTreeSet<(String, String)>> = const { RefCell::new(BTreeSet::new()) };
-    /// Error-union sites (`?`, `!`, `catch`, `fail`) recorded for codegen; `None` while collecting.
+    /// Error-union sites (`?`, `!`, `catch`) recorded for codegen; `None` while collecting.
     static ERR_SITES: RefCell<Option<HashMap<usize, ErrSite>>> = const { RefCell::new(None) };
     static OP_CALLS: RefCell<HashMap<usize, std::rc::Rc<ast::FnCall>>> = RefCell::new(HashMap::new());
 }
@@ -138,7 +138,7 @@ pub struct TypedInfo {
     /// The program with its `for` loops lowered (see `plum_core::forms`): the
     /// source the types above belong to, and the one codegen must compile.
     pub lowered: Option<std::rc::Rc<ast::Source>>,
-    /// `?` / `!` / `catch` / `fail` expression address -> its error-union facts.
+    /// `?` / `!` / `catch` expression address -> its error-union facts.
     pub err_sites: HashMap<usize, ErrSite>,
     /// Final error set (sorted names) of every fn returning `!T`, keyed `"f"` / `"Recv.f"`.
     pub fn_error_sets: BTreeMap<String, Vec<String>>,
@@ -459,7 +459,7 @@ pub fn variantFields(info: &EnumVariantInfo, ty: &PlumType) -> Vec<PlumType> {
     }
 }
-/// `Ok(3)`-style result type of a variant of enum `info.enum_name`.
+/// `Just(3)`-style result type of a variant of enum `info.enum_name`.
 fn enumTypeWith(info: &EnumVariantInfo, owner: &BTreeMap<String, PlumType>) -> PlumType {
     if info.generics.is_empty() {
         PlumType::TNamed(info.enum_name.clone())
@@ -1968,7 +1968,7 @@ fn checkFn(
         .as_ref()
         .map(|r| bindFnSet(plumTypeFromAstG(r), f))
         .unwrap_or(PlumType::TUnit);
-    // Reserved env key read by `?` (see `inferExpr`'s `Try` arm); closures remove it.
+    // Reserved env key read by `?` (see `inferExpr`'s `Expr::Try` arm); closures remove it.
     env.insert(RETURN_KEY.to_string(), TypeScheme::mono(declared_ret.clone()));
     if f.is_star {
         env.insert(STAR_KEY.to_string(), TypeScheme::mono(PlumType::TNamed(f.name.clone())));
@@ -2406,7 +2406,7 @@ fn patCatchAll(p: &ast::CasePattern) -> bool {
     }
 }
-/// A constructor pattern: `Ok(n)` / `Red` / `#Tag` -> (name, sub-patterns).
+/// A constructor pattern: `Just(n)` / `Red` -> (name, sub-patterns).
 fn patCtor(p: &ast::CasePattern) -> Option<(&str, &[ast::CasePattern])> {
     match p {
         ast::CasePattern::Class { name, fields } => Some((name.as_str(), fields.as_slice())),

plum-core/src/ast.rs CHANGED Viewed

@@ -11,7 +11,7 @@ pub struct Source {
     /// the end of the file.
     pub topLevelOrder: Vec<TopLevelKind>,
     /// Errors found while expanding `for` forms (see `forms.rs`): block escapes,
-    /// recursive inline funs, misuse of an inline fun. The checker reports them.
+    /// recursive `fun*`s, misuse of a `fun*`. The checker reports them.
     pub formErrors: Vec<(usize, usize, String)>,
     /// Every expanded for-form: (hygiene prefix of its renamed locals, form name,
     /// line, column of the `for`), so checker errors can name the form.

plum-core/src/forms.rs CHANGED Viewed

@@ -1720,7 +1720,7 @@ fn convertExpr(e: &mut Expr, uses: &mut YieldUses) {
 }
 /// Locals are function-wide and typed once, so two `match` arms that bind the
-/// same name (`Ok(v)` of an `Int` in one match, of a `Str` in the next) would
+/// same name (`Circle(v)` of an `Int` in one match, of a `Str` in the next) would
 /// share one wasm local of the wrong type. Every pattern binder that was
 /// already bound earlier in the fn is renamed (in its arm only) to a fresh
 /// `name__N`.

plum-examples/dop_visitor.plum CHANGED Viewed

@@ -21,18 +21,18 @@
 # The checker's exhaustiveness check on enums stands in for the compile-time
 # guarantee sealed interfaces + switch give in Java.
 #
-# DOP vs. OOP (see the `trait`/`type`-per-shape rewrite in
+# DOP vs. OOP (see the one-`enum`-per-shape rewrite in
 # `oop_visitor.plum`):
 #   - Adding a new operation (a new function that matches on `Book`) touches
 #     one place here, and the exhaustiveness checker forces every variant to
 #     be handled. In the OOP version it means adding a new method to every
-#     `type`, with nothing catching a variant you forgot to update.
+#     shape enum, with nothing catching a variant you forgot to update.
 #   - Adding a new variant instead means touching every `match` on `Book`
 #     here (again caught by exhaustiveness if missed); the OOP version adds
-#     it in one new, self-contained `type`, untouched elsewhere.
+#     it in one new, self-contained `enum`, untouched elsewhere.
 #   - So DOP fits best when operations change often and the shapes are
 #     stable; OOP fits best when shapes multiply and operations are stable.
-#     plum has no dynamic dispatch through a trait type (see
+#     plum has no dynamic dispatch through an interface (see
 #     `oop_visitor.plum`'s header), which tilts things further toward DOP
 #     for anything that needs to treat the shapes polymorphically.

plum-examples/numbers.plum CHANGED Viewed

@@ -95,11 +95,7 @@ test "string interpolation of a Float value works, via Number.toStr"
   assert "computed is {y}" == "computed is 3.0"
 test "assert of two directly-chained Float method calls renders a real failure message"
-  # Previously crashed the whole compile with "interpolating a Float value is
-  # not yet supported" instead of a normal pass/fail report — `looksLikeFloat`
+  # `"{expr}"` interpolation of any Float-typed expression works (via
-  # only caught an OBVIOUS float literal on either side of the comparison,
-  # missing any Float-typed expression that wasn't written as one (like these
-  # chained method calls). Fixed at the root: `"{expr}"` interpolation of a
-  # Float now genuinely works (via `Number.toStr`), so the "Expected/Actual"
+  # `Number.toStr`), so the "Expected/Actual" failure message renders even for
-  # failure-message machinery no longer needs to special-case Float at all.
+  # chained method calls like these.
   assert 8.log2() == 8.0.log2()

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -1,14 +1,13 @@
 # Classic OOP alternative to the DOP version in `dop_visitor.plum`: instead of
 # one sealed `enum` + one exhaustive `match`, each book shape gets its own
+# single-variant `enum` and defines its own `collectInterestingInfo` method —
-# `type`, declares it implements the `Book` trait, and defines its own
+# the direct translation of the blog post's Java (sealed interface implemented
-# `collectInterestingInfo` method — the direct translation of the blog post's
-# Java (sealed interface implemented by records, each overriding a method).
+# by records, each overriding a method).
 # Based on: https://wimdetroyer.com/blog/visitor-pattern-in-dop
 #
-# One real limitation this example runs into: plum's `trait` is a
+# One real limitation this example runs into: plum has no interfaces and no
-# compile-time structural check only ("does this type declare these
-# methods with matching signatures?") — there is no vtable or runtime
+# runtime dispatch. Generics are duck-typed per instantiation, so a function
-# dispatch. A function can't take a bare `book: Book` parameter and call
+# can't take a bare `book: Book` parameter and call
 # `book.collectInterestingInfo()` polymorphically across different concrete
 # types, and there's no way to hold a heterogeneous list of `Book`s. So
 # unlike the Java original (or the enum/match version), there's no single
@@ -16,16 +15,16 @@
 # called directly at its own call site.
 #
 # OOP vs. DOP (see the `enum`/`match` version in `dop_visitor.plum`):
-#   - Adding a new variant (a new `type(Book) = ...`) is self-contained here
+#   - Adding a new variant (a new single-variant `enum`) is self-contained
-#     and doesn't touch existing types. In the DOP version it means adding
+#     here and doesn't touch existing types. In the DOP version it means
-#     a new arm to every `match` on `Book` (caught by the checker's
+#     adding a new arm to every `match` on `Book` (caught by the checker's
 #     exhaustiveness check if missed).
-#   - Adding a new operation instead means adding a method to every `type`
+#   - Adding a new operation instead means adding a method to every shape
-#     here, with nothing enforcing that you updated all of them; the DOP
+#     enum here, with nothing enforcing that you updated all of them; the DOP
 #     version adds one new function with one exhaustive `match`.
 #   - So OOP fits best when shapes multiply and operations are stable; DOP
 #     fits best when operations change often and the shapes are stable.
-#     plum's lack of dynamic dispatch through a trait type (see above)
+#     plum's lack of dynamic dispatch through an interface (see above)
 #     removes OOP's usual "call through one interface" benefit entirely,
 #     which is a real cost specific to this language.

plum-lsp/src/completion.rs CHANGED Viewed

@@ -25,7 +25,7 @@ use plum_core::ast;
 use tower_lsp::lsp_types::*;
 const KEYWORDS: &[&str] = &[
-    "fun", "fun*", "yield", "crash", "error", "catch", "value", "enum", "extend", "import", "module", "extern", "if", "then", "else", "while", "for", "range", "match",
+    "fun", "fun*", "fn", "yield", "crash", "error", "catch", "value", "enum", "extend", "import", "module", "extern", "if", "then", "else", "while", "for", "range", "match",
     "when", "break", "continue", "return", "todo", "assert", "test", "self", "true",
     "false",
 ];
@@ -285,9 +285,17 @@ pub fn memberItems(
         return Vec::new();
     };
+    // A primitive's methods may live on the "union" enum that bare-wraps it
+    // (`Int` / `Float` -> `Number`), exactly as the checker's method fallback.
-    let mut items = Vec::new();
+    let mut owners = vec![recv_name.clone()];
+    if let Some(info) = ctx.enum_variants.get(recv_name.as_str()) {
+        if info.enum_name != recv_name {
+            owners.push(info.enum_name.to_string());
+        }
+    }
+    let mut items: Vec<CompletionItem> = Vec::new();
     for ((r, name), fn_ty) in ctx.methods.iter() {
-        if r != &recv_name {
+        if !owners.contains(r) || (r != &recv_name && items.iter().any(|i| i.label == *name)) {
             continue;
         }
         let detail = match fn_ty {

plum-lsp/src/main.rs CHANGED Viewed

@@ -432,6 +432,32 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
+    /// `.` on Float / Str / Map offers their current methods (and none of the removed ones).
+    #[test]
+    fn memberCompletionOnFloatStrMap() {
+        let dir = std::env::temp_dir().join(format!("plum-lsp-fsm-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("t.plum");
+        let text = "module t\nimport std/Number\nimport std/Str\nimport std/List\nimport std/Map\n\nfun main() =\n  f := 1.5\n  f.zzzzzz\n  s := \"x\"\n  s.zzzzzz\n  m := Map[Str, Int]()\n  m.zzzzzz\n";
+        std::fs::write(&path, text).unwrap();
+        let cases: [(usize, &str, &[&str]); 3] = [
+            (9, "f", &["sqrt", "toStr"]),
+            (11, "s", &["length", "split", "parseBool"]),
+            (13, "m", &["get", "keys", "values", "entries"]),
+        ];
+        for (line, recv, wants) in cases {
+            let items = memberCompletionFor(&path, &repoRoot(), text, line, recv);
+            let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+            for want in wants {
+                assert!(labels.contains(want), "missing {want} for {recv} in {labels:?}");
+            }
+            for gone in ["andThen", "unwrapOr", "orElse"] {
+                assert!(!labels.contains(&gone), "stale {gone} for {recv}: {labels:?}");
+            }
+        }
+        let _ = std::fs::remove_dir_all(&dir);
+    }
     #[test]
     fn keywordsCurrent() {
         let labels: Vec<String> = completion::keywordItems().into_iter().map(|i| i.label).collect();

plum-std/Json.plum CHANGED Viewed

@@ -82,10 +82,8 @@ enum JsonParse =
   | JsonParseFailed(pos: Int, text: Str)
 # A recursive-descent parser over a `Str` source, tracking its read position
-# in `pos`. (The original design threaded a `Readable` stream through here,
+# in `pos`. It reads directly from a `Str`, the same way every other stdlib
-# but `Readable` is an undefined trait with no methods anywhere in `libs/std`
-# — there is nothing to call on it — so this reads directly from a `Str`
-# instead, the same way every other stdlib parser, e.g. `Int.fromStr`, does.)
+# parser (e.g. `parseInt`) does.
 enum JsonParser =
   | JsonParser(src: Str, pos: Int, text: Str)

plum-std/List.plum CHANGED Viewed

@@ -330,7 +330,7 @@ test "chunk splits into sublists of at most size elements each"
   assert chunks.get(2)!.join(",") == "5"
   assert l.chunk(0).length() == 0
-test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty is Err"
+test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty is an error"
   l := List[Int]()
   i := 0
   while i < 1000

plum-std/Str.plum CHANGED Viewed

@@ -4,8 +4,8 @@ import std/List
 import std/Buffer
 import std/Number
-# A Str is an immutable byte sequence, backed by a real `Buffer` — a genuine
+# A Str is an immutable byte sequence, backed by a real `Buffer` in its
-# `type`/`data` field, not a compiler special case: `Str` is an ordinary
+# `data` field, not a compiler special case: `Str` is an ordinary
 # wasm-gc struct wrapping a `Buffer` (itself a wasm-gc struct wrapping a raw
 # `[]Byte`), the same generic struct-of-fields codegen every other class
 # gets. Only `byteToStr` (build a length-1 `Str` from a raw byte) and the
@@ -591,7 +591,7 @@ test "string interpolation supports a method call taking a closure literal"
   assert "{l.findValue(3)!}" == "3"
   assert "{l.contains(100)}" == "false"
-test "string interpolation supports a ternary expression"
+test "string interpolation supports an inline if expression"
   n := 5
   assert "{if n > 0 then "positive" else "non-positive"}" == "positive"

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

@@ -226,9 +226,9 @@
   (_) @append_indent_end
   .)
-; `enum_field` (a variant like `| Some[T]`) is ALIASED to the same visible
+; `enum_field` (a variant like `| Circle(r: Float)`) is ALIASED to the visible
-; node kind ("field") as the old trait_field, but only it has a literal
+; node kind "field"; only it has a literal "|" — safe to target unscoped by
-; "|" — safe to target unscoped by parent.
+; parent.
 (field
   "|" @append_space)

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

@@ -7,6 +7,16 @@
 ((var_identifier) @variable.builtin
   (#eq? @variable.builtin "_"))
+; Error names: `error.Name` and the members of `error Set = A | B` are constants
+; (these must come before the generic `(type_identifier) @type`).
+(error_value "." @punctuation.delimiter)
+(error_value (type_identifier) @constant)
+(error_decl name: (type_identifier) @type)
+(error_decl member: (type_identifier) @constant)
 ; (mod_identifier) @constant
 (type_identifier) @type
 (fn_identifier) @function
@@ -82,14 +92,6 @@
 "error" @keyword
-(error_value "." @punctuation.delimiter)
-(error_value (type_identifier) @constant)
-(error_decl (type_identifier) @type)
-(error_decl member: (type_identifier) @constant)
 (safe_attribute "?." @operator)
@@ -108,6 +110,8 @@
   "value"
   "fun"
   "fun*"
+  "extern"
+  "fn"
   "test"
 ] @keyword

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

@@ -15,3 +15,6 @@
 (extend
   name: (type_identifier) @name) @definition.class
+(error_decl
+  name: (type_identifier) @name) @definition.class

plum-tooling/tree-sitter-plum/test/aa.plum CHANGED Viewed

@@ -1,31 +1,38 @@
 module std
-import std/int
+import std/Number
-import std/str
+import std/Str
+import std/Os
-PI = 3.14
+PI_APPROX = 3.14
 MSG = "Hello World"
 SUM = 1 + {{2 * 3} / 4}
 ENABLED = !false
+error CatError = Hungry | Asleep
 # Cat is an animal that meows always
+enum Cat =
-type Cat(IAnimal, IToStr) =
+  | Cat(name: Str, age: Int)
-  name: Str
-  age: Int
-  fun withName(name: Str) -> Cat =
+  fun withName(self, name: Str) -> Cat =
     Cat(name: name, age: self.age)
-  fun withAge(age: Int) -> Cat =
+  fun withAge(self, age: Int) -> Cat =
     Cat(name: self.name, age: age)
-  fun speak() -> Str =
+  fun speak(self) -> Str =
     "meow"
+  fun feed(self, food: Int) -> CatError!Int =
+    if food < 0
+      return error.Hungry
+    food
-  fun toStr() -> Str =
+  fun toStr(self) -> Str =
-    for i in 0..10
+    for i := range 10
       printLn("delta")
-    if dog > 1
+    if self.age > 1
       printLn("Hellow")
     else
       printLn("New")

plum-tooling/tree-sitter-plum/test/corpus/function.txt CHANGED Viewed

@@ -204,7 +204,7 @@ fun bothTrue(a: Bool, b: Bool) -> Bool =
               (var_identifier))))))))
 ================================================================================
-function - bare ternary as body's trailing statement
+function - bare inline if as body's trailing statement
 ================================================================================
 fun pick(cond: Bool, a: Int, b: Int) -> Int =
@@ -309,7 +309,7 @@ fun useClosure() -> Bool =
             (fn_argument_list)))))))
 ================================================================================
-function - closure with an inline ternary body
+function - closure with an inline if body
 ================================================================================
 fun useClosure() -> Str =

plum-tooling/tree-sitter-plum/test/corpus/safe_attribute.txt CHANGED Viewed

@@ -66,7 +66,7 @@ fun greetCall(person: Option[Person]) -> Option[Str] =
                     (string_end)))))))))))
 ================================================================================
-safe navigation operator - coexists with ternary, and try, all sharing `?`-prefixed tokens
+safe navigation operator - coexists with inline if and try, all sharing `?`-prefixed tokens
 ================================================================================
 fun classify(n: Int) -> Int =

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

@@ -2,9 +2,9 @@
 try operator - postfix ? unwraps or returns early
 ================================================================================
-fun parsePositive(s: Str) -> Result[Int, Str] =
+fun parsePositive(s: Str) -> !Int =
   n := parseInt(s)?
-  return Ok(n)
+  return n
 --------------------------------------------------------------------------------
@@ -16,11 +16,7 @@ fun parsePositive(s: Str) -> Result[Int, Str] =
       type: (type
         (type_identifier)))
     returns: (type
-      (type_identifier)
-      generics: (type
-        (type_identifier))
+      (type_identifier))
-      generics: (type
-        (type_identifier)))
     body: (body
       (assign
         (var_identifier)
@@ -37,15 +33,10 @@ fun parsePositive(s: Str) -> Result[Int, Str] =
       (return
         (expression
           (primary_expression
-            (fn_call
-              function: (type_identifier)
-              arguments: (fn_argument_list
-                (expression
-                  (primary_expression
-                    (var_identifier)))))))))))
+            (var_identifier)))))))
 ================================================================================
-try operator - coexists with the unrelated ternary operator, same `?` token
+try operator - coexists with the inline if expression
 ================================================================================
 fun classify(n: Int) -> Int =

plum-tooling/tree-sitter-plum/test/highlight/sample.plum CHANGED Viewed

@@ -1,15 +1,15 @@
 module std
-enum Cat(ToStr) =
+enum Cat =
   | Cat(name: Str, age: Int)
-  fun withName(name: Str) -> Cat =
+  fun withName(self, name: Str) -> Cat =
     Cat(name: name, age: self.age)
-  fun withAge(age: Int) -> Cat =
+  fun withAge(self, age: Int) -> Cat =
     Cat(name: self.name, age: age)
-  fun toStr() -> Str =
+  fun toStr(self) -> Str =
     "Cat({self.name}, {self.age})"
 fun main() =

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

@@ -67,7 +67,7 @@
           }
         },
         {
-          "match": "\\b(module|value|enum|error|extend|fun\\*?|extern|self|test)(?![A-Za-z0-9_])",
+          "match": "\\b(module|value|enum|error|extend|fun\\*?|fn|extern|self|test)(?![A-Za-z0-9_])",
           "name": "keyword.const.plum"
         },
         {

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

@@ -485,7 +485,7 @@ struct LocalCtx<'a> {
     /// `plum_compiler_bugs_found_2026_08` memory.
     loop_extra_depth: Cell<u32>,
     /// The declared return type of the function being compiled (`None` inside a
-    /// closure body) — `?` builds the OUTER function's `Err` variant from it.
+    /// closure body) — `?` builds the OUTER function's error result from it.
     ret_type: Option<PlumType>,
     /// Match-subject scratch local -> its error-name type, for subjects whose
     /// static type is a `TErrName` (their `Name` arms test the i32 code).
@@ -6378,15 +6378,8 @@ fn compileExprCore(
         ast::Expr::Paren(inner) => {
             compileExpr(inner, body, ctx, state)?;
         }
-        // `expr?` — `ref.test` decides Ok (fall through, extract the
+        // `expr?` — if the error code is non-zero, return it from the enclosing
-        // field) vs Err (return the already-constructed value AS-IS,
-        // no reconstruction needed). The `then`/`else` branches don't need to
-        // agree in wasm's usual sense: after `return`, the rest of that
-        // branch is unreachable, so the validator accepts the `if`'s single
+        // function (see `compileErrTry`); otherwise the success value is the result.
-        // declared result type (the success field's) coming only from the
-        // `else` branch — the same stack-polymorphism-after-`return` rule
-        // `compileStmt`'s own `Return` arm relies on, just reached from
-        // inside an expression here for the first time.
         ast::Expr::Try(inner) => compileErrTry(expr, inner, body, ctx, state)?,
         ast::Expr::Unary(u) if isOpCall(expr, &u.operand, ctx) => {
             let call = &ctx.op_calls[&(expr as *const ast::Expr as usize)];