43e5250 | plum | pyrossh

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

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

43e5250 — Peter John 2026-09-08T15:22:00+05:30

feat: add Groovy/Kotlin-style safe navigation operator (?.)

Files changed (10) hide show

README.md +10 -1
plum-core/src/parser.rs +48 -0
plum-examples/safe_navigation.plum +58 -0
plum-tooling/tree-sitter-plum/grammar.js +20 -0
plum-tooling/tree-sitter-plum/queries/plum/highlights.scm +2 -0
plum-tooling/tree-sitter-plum/src/grammar.json +0 -0
plum-tooling/tree-sitter-plum/src/node-types.json +0 -0
plum-tooling/tree-sitter-plum/src/parser.c +0 -0
plum-tooling/tree-sitter-plum/test/corpus/safe_attribute.txt +142 -0
plum-tooling/vscode-plum/syntaxes/plum.tmLanguage.json +6 -1

README.md CHANGED Viewed

@@ -82,7 +82,7 @@ From tightest to loosest binding:
 | Precedence | Operators | Notes |
 |---|---|---|
-| highest | `.` | attribute access / method call |
+| highest | `.` `?.` | attribute access / method call, safe navigation |
 | | `+` `-` | unary |
 | | `*` `/` `%` | |
 | | `+` `-` | |
@@ -340,6 +340,15 @@ fun sumOrZero(a: Str, b: Str) -> Int =
   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:
+```plum
+fun cityName(person: Option[Person]) -> Option[Str] =
+  person?.city?.name
+```
+It's sugar for `obj.map(|v| v.field)` — nothing more than that; chain it as many times as needed.
 ## Standard library highlights
 - **`Bool`** (`import std/Bool`) — ordinary `enum Bool = | True | False`

plum-core/src/parser.rs CHANGED Viewed

@@ -672,6 +672,7 @@ impl<'a> AstParser<'a> {
             "unary_operator" => self.parseUnary(node),
             "attribute" => self.parseAttribute(node),
             "try_expression" => self.parseTryExpression(node),
+            "safe_attribute" => self.parseSafeAttribute(node),
             "fn_call" => Expr::FnCall(self.parseFnCall(node)),
             "class_call" => Expr::ClassCall(self.parseClassCall(node)),
             "parenthesized_expression" => {
@@ -824,6 +825,52 @@ impl<'a> AstParser<'a> {
         Expr::Try(Box::new(value))
     }
+    /// safe_attribute: primary_expression "?." fn_identifier fn_argument_list?
+    ///
+    /// Desugars entirely here into `object.map(|v| v.member(...))` — reusing
+    /// Option/Result's existing generic `.map` method for the actual
+    /// unwrap/transform/rewrap, so nothing past the parser (checker,
+    /// monomorphizer, codegen, formatters) needs to know `?.` exists at all.
+    /// The synthesized param name can't collide with a real variable in scope:
+    /// the closure body only ever references this one param, never anything
+    /// from the surrounding scope, so shadowing an outer name of the same
+    /// text (if that ever happened) would still be correct.
+    fn parseSafeAttribute(&self, node: Node) -> Expr {
+        const SAFE_NAV_PARAM: &str = "__safe_nav";
+        let named: Vec<Node> = self.namedChildren(node);
+        let object = named.first()
+            .map(|n| { let u = self.unwrapExprNode(*n); self.parsePrimaryExpression(u) })
+            .unwrap_or(Expr::Int(0));
+        let member = named.get(1).map(|n| self.text(*n)).unwrap_or_default();
+        let attr = match named.get(2) {
+            Some(args_node) => {
+                let mut acursor = args_node.walk();
+                let args = args_node.named_children(&mut acursor)
+                    .map(|n| self.parseArg(n))
+                    .collect();
+                AttrKind::Method(FnCall { name: member, args })
+            }
+            None => AttrKind::Field(member),
+        };
+        let inner = Expr::Attribute(Box::new(AttributeExpr {
+            object: Expr::Var(SAFE_NAV_PARAM.to_string()),
+            attr,
+        }));
+        let closure = Closure {
+            params: vec![SAFE_NAV_PARAM.to_string()],
+            body: Block { stmts: vec![Stmt::Expr(inner)] },
+        };
+        Expr::Attribute(Box::new(AttributeExpr {
+            object,
+            attr: AttrKind::Method(FnCall {
+                name: "map".to_string(),
+                args: vec![Arg::Positional(Expr::Closure(Box::new(closure)))],
+            }),
+        }))
+    }
     fn parseFnCall(&self, node: Node) -> FnCall {
         // fn_call: var_identifier fn_argument_list (the callee lexes as var_identifier
         // to avoid an identifier-token tie with all-lowercase, no-underscore names)
@@ -1076,6 +1123,7 @@ fn isExpressionKind(kind: &str) -> bool {
             | "elvis_expression"
             | "attribute"
             | "try_expression"
+            | "safe_attribute"
             | "fn_call"
             | "class_call"
             | "parenthesized_expression"

plum-examples/safe_navigation.plum ADDED Viewed

@@ -0,0 +1,58 @@
+import std/Option
+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,
+# mapping the field/method access over the inner value and re-wrapping the
+# result; `Err`/`None` 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.
+enum Person =
+  | Person(name: Str, age: Int)
+  fun birthday(self) -> Int =
+    self.age + 1
+fun personName(p: Option[Person]) -> Option[Str] =
+  p?.name
+fun personBirthday(p: Option[Person]) -> Option[Int] =
+  p?.birthday()
+fun personNameResult(p: Result[Person, Str]) -> Result[Str, Str] =
+  p?.name
+fun somePerson() -> Option[Person] =
+  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] =
+  Err("missing")
+test "safe navigation maps a field access over Some, passes None through unchanged"
+  a := personName(somePerson())
+  assert a.isSome()
+  assert a.unwrap() == "Ann"
+  b := personName(noPerson())
+  assert b.isNone()
+test "safe navigation maps a method call over Some"
+  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"
+  b := personNameResult(errPerson())
+  assert b.isErr()
+  assert b.unwrapErr() == "missing"

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

@@ -403,6 +403,7 @@ module.exports = grammar({
         $.unary_operator,
         $.attribute,
         $.try_expression,
+        $.safe_attribute,
         $.fn_call,
         $.class_call,
         $.parenthesized_expression,
@@ -525,6 +526,25 @@ module.exports = grammar({
     try_expression: ($) =>
       seq(field("value", $.primary_expression), "?"),
+    // Groovy/Kotlin-style safe navigation: `obj?.member` / `obj?.method(args)`
+    // on a `Result`/`Option` value — same shape as `attribute` just above, but
+    // with a `?.` token in place of `.`. `?.` is its own literal token, so the
+    // lexer's usual longest-match rule already picks it over a bare `?` (the
+    // `try_expression` token) with no extra grammar conflict needed, the same
+    // way `elvis_expression`'s `?:` needed none. Desugars entirely in
+    // `parser.rs` (into `.map(|v| v.member(...))`, reusing Option/Result's
+    // existing generic `.map`) — nothing past the parser ever sees this node.
+    safe_attribute: ($) =>
+      prec(
+        PREC.call,
+        seq(
+          field("object", $.primary_expression),
+          "?.",
+          field("member", $.fn_identifier),
+          field("arguments", optional($.fn_argument_list)),
+        ),
+      ),
     // The callee name lexes as `var_identifier` (widened to a superset of
     // `fn_identifier`'s charset below) rather than `fn_identifier` — using two
     // different identifier tokens here was ambiguous for any all-lowercase,

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

@@ -66,6 +66,8 @@
 (elvis_expression "?:" @operator)
+(safe_attribute "?." @operator)
 [
   "->"
   "=>"

plum-tooling/tree-sitter-plum/src/grammar.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/node-types.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/parser.c CHANGED Viewed

Binary file

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

@@ -0,0 +1,142 @@
+================================================================================
+safe navigation operator - field access on an Option/Result value
+================================================================================
+fun greet(person: Option[Person]) -> Option[Str] =
+  person?.name
+--------------------------------------------------------------------------------
+(source
+  (fn
+    name: (fn_identifier)
+    params: (param
+      name: (var_identifier)
+      type: (type
+        (type_identifier)
+        generics: (type
+          (type_identifier))))
+    returns: (type
+      (type_identifier)
+      generics: (type
+        (type_identifier)))
+    body: (body
+      (expression
+        (primary_expression
+          (safe_attribute
+            object: (primary_expression
+              (var_identifier))
+            member: (fn_identifier)))))))
+================================================================================
+safe navigation operator - method call on an Option/Result value
+================================================================================
+fun greetCall(person: Option[Person]) -> Option[Str] =
+  person?.greeting("hi")
+--------------------------------------------------------------------------------
+(source
+  (fn
+    name: (fn_identifier)
+    params: (param
+      name: (var_identifier)
+      type: (type
+        (type_identifier)
+        generics: (type
+          (type_identifier))))
+    returns: (type
+      (type_identifier)
+      generics: (type
+        (type_identifier)))
+    body: (body
+      (expression
+        (primary_expression
+          (safe_attribute
+            object: (primary_expression
+              (var_identifier))
+            member: (fn_identifier)
+            arguments: (fn_argument_list
+              (expression
+                (primary_expression
+                  (string
+                    (string_start)
+                    (string_content)
+                    (string_end)))))))))))
+================================================================================
+safe navigation operator - coexists with ternary, elvis, and try, all sharing `?`-prefixed tokens
+================================================================================
+fun classify(n: Int) -> Int =
+  a = n > 0 ? n : 0
+  b = n ?: 0
+  c = n?
+  d = opt?.field
+  a + b + c
+--------------------------------------------------------------------------------
+(source
+  (fn
+    name: (fn_identifier)
+    params: (param
+      name: (var_identifier)
+      type: (type
+        (type_identifier)))
+    returns: (type
+      (type_identifier))
+    body: (body
+      (assign
+        (var_identifier)
+        (expression
+          (ternary_expression
+            (expression
+              (comparison_operator
+                (primary_expression
+                  (var_identifier))
+                (primary_expression
+                  (integer))))
+            (expression
+              (primary_expression
+                (var_identifier)))
+            (expression
+              (primary_expression
+                (integer))))))
+      (assign
+        (var_identifier)
+        (expression
+          (elvis_expression
+            (expression
+              (primary_expression
+                (var_identifier)))
+            (expression
+              (primary_expression
+                (integer))))))
+      (assign
+        (var_identifier)
+        (expression
+          (primary_expression
+            (try_expression
+              value: (primary_expression
+                (var_identifier))))))
+      (assign
+        (var_identifier)
+        (expression
+          (primary_expression
+            (safe_attribute
+              object: (primary_expression
+                (var_identifier))
+              member: (fn_identifier)))))
+      (expression
+        (primary_expression
+          (binary_operator
+            left: (primary_expression
+              (binary_operator
+                left: (primary_expression
+                  (var_identifier))
+                right: (primary_expression
+                  (var_identifier))))
+            right: (primary_expression
+              (var_identifier))))))))

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

@@ -63,10 +63,15 @@
           "name": "keyword.operator.elvis.plum",
           "match": "\\?:"
         },
+        {
+          "comment": "safe navigation (Result/Option `.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",
           "name": "keyword.operator.try.plum",
-          "match": "(?<=[A-Za-z0-9_\\)\\]])\\?(?!:)"
+          "match": "(?<=[A-Za-z0-9_\\)\\]])\\?(?!:)(?!\\.)"
         },
         {
           "name": "keyword.operator.logical.plum",