0aa74fb | plum | pyrossh

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

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

0aa74fb — Peter John 2026-10-26T21:20:45+05:30

docs(editors): iteration cheat sheet, value enum docs; highlight/LSP for for/extend/Seq

Files changed (8) hide show

README.md +35 -0
plum-lsp/src/completion.rs +25 -1
plum-lsp/src/main.rs +139 -44
plum-tooling/tree-sitter-plum/queries/plum/highlights.scm +10 -1
plum-tooling/tree-sitter-plum/queries/plum/indents.scm +2 -0
plum-tooling/tree-sitter-plum/queries/plum/tags.scm +3 -0
plum-tooling/tree-sitter-plum/queries/plum/textobjects.scm +2 -0
plum-tooling/vscode-plum/syntaxes/plum.tmLanguage.json +21 -2

README.md CHANGED Viewed

@@ -285,6 +285,24 @@ while i < units.length()
 List and Map have no closure-taking iteration methods; closures remain in the language for passing behavior around as values (`Num` below, `Try.map`). See [`plum-examples/seq.plum`](plum-examples/seq.plum) (one test per adapter and terminal), [`plum-examples/chains.plum`](plum-examples/chains.plum) and [`plum-examples/forms.plum`](plum-examples/forms.plum).
+#### Iteration cheat sheet
+| Go / Rust / streams | Plum |
+|---|---|
+| `for _, u := range units` / `for u in &units` | `for u := units` |
+| `for i, u := range units` / `.iter().enumerate()` | `for i, u := units` |
+| `for k, v := range m` / `for (k, v) in &m` | `for k, v := m` |
+| `for i := 0; i < n; i++` / `for i in 0..n` | `for i := range(0, n)` |
+| `.iter().filter(p).collect()` / `stream.filter(p)` | `for u := units.filter()` then the predicate as the body |
+| `.iter().map(f).collect()` / `stream.map(f)` | `for u := units.map()` then the mapped value as the body |
+| `.iter().find(p)` / `findFirst(p)` | `for u := units.find()` (`-> T?`) |
+| `.iter().fold(0, f)` / `reduce(0, f)` | `for acc, u := units.fold(0)` |
+| `.iter().take(n).skip(m)` / `limit(n).skip(m)` | `units.skip(m).take(n)` |
+| `.iter().step_by(n)` / `.rev()` / `.zip(o)` / `chunks(n)` | `stepBy(n)` / `reversed()` / `zip(o)` / `chunks(n)` |
+| `.count()` / `.any(p)` / `.all(p)` / `forEach(f)` | `count()` / `any()` / `all()` / `each()` |
+| `if p(x) { continue }` | `, if cond` clause after the source |
+| generator / `yield` | `fun* name(..) *T` with `yield` |
 #### `extend`
 `extend <Type> =` followed by indented methods adds methods (`fun` and `fun*`) to a compiler primitive without declaring a dummy `enum X = | X` just to hang them on. It is only allowed in `plum-std`, and only for built-in types (`Seq`, `Int`, `Float`, `Bool`, `Str`, `Byte`, `ByteSlice`, `Array`); anywhere else it is an error (`extend is only allowed for built-in types in std`).
@@ -343,6 +361,23 @@ enum Step(n: Int) = # a shared field on every variant ...
   | ReadMax(20)
 ```
+### `value enum`
+`value enum` declares a small, copy-semantics value type (a vector, a color, a rectangle) that is flattened into wasm locals instead of being heap-allocated:
+```plum
+value enum Vec2 =
+  | Vec2(x: Float, y: Float)
+  fun add(self, o: Vec2) -> Vec2 =
+    Vec2(x: self.x + o.x, y: self.y + o.y)
+value enum Rect =
+  | Rect(pos: Vec2, size: Vec2)  # a field may be another value enum
+```
+It has exactly one constructor, named like the type; no generics; fields are only `Int`, `Float`, `Bool` or other value enums, and a value enum can't contain itself. Values are copied on assignment and when passed, and are boxed only inside generic containers (`List[Vec2]`, `Vec2?`). Methods, `match` and `?` work as for any enum. See [`plum-examples/values.plum`](plum-examples/values.plum).
 ## Generics
 ```plum

plum-lsp/src/completion.rs CHANGED Viewed

@@ -26,7 +26,7 @@ use tower_lsp::lsp_types::*;
 const KEYWORDS: &[&str] = &[
     "fun", "fun*", "yield", "crash", "??", "value", "enum", "extend", "import", "module", "extern", "if", "else", "while", "for", "match",
-    "case", "when", "break", "continue", "return", "todo", "assert", "test", "self", "True",
+    "when", "break", "continue", "return", "todo", "assert", "test", "self", "True",
     "False",
 ];
@@ -250,6 +250,7 @@ pub fn memberItems(
     receiver: &str,
     global_env: &TypeEnv,
     ctx: &CheckCtx,
+    stars: &[ast::Fn],
 ) -> Vec<CompletionItem> {
     let Some(f) = cursor_fn else {
         return Vec::new();
@@ -297,6 +298,29 @@ pub fn memberItems(
             ..Default::default()
         });
     }
+    // `fun*` methods are expanded by the loop lowering and are not in the
+    // checker's method tables; they come from the source's `stars`. An
+    // iterable (`length()`+`at(i)`, or an `entries()` method) also reaches the
+    // `extend Seq[T]` ones through the checker's method fallback.
+    let has = |m: &str| {
+        ctx.methods.contains_key(&(recv_name.clone(), m.to_string()))
+            || stars.iter().any(|f| f.type_param.as_deref() == Some(recv_name.as_str()) && f.name == m)
+    };
+    let iterable = recv_name != "Seq" && ((has("length") && has("at")) || has("entries"));
+    for f in stars {
+        let owner = f.type_param.as_deref();
+        let own = owner == Some(recv_name.as_str());
+        let seq = iterable && owner == Some("Seq");
+        if (!own && !seq) || items.iter().any(|i| i.label == f.name) {
+            continue;
+        }
+        items.push(CompletionItem {
+            label: f.name.clone(),
+            kind: Some(CompletionItemKind::METHOD),
+            detail: Some(if own { "fun*".to_string() } else { "fun* (Seq)".to_string() }),
+            ..Default::default()
+        });
+    }
     for info in ctx.enum_variants.values() {
         if info.enum_name != recv_name {
             continue;

plum-lsp/src/main.rs CHANGED Viewed

@@ -23,7 +23,7 @@
 #![allow(non_snake_case)]
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 use tokio::sync::Mutex;
@@ -104,37 +104,7 @@ impl Backend {
     /// flash a bogus diagnostic.
     fn typeDiagnostics(&self, uri: &Url, text: &str) -> Option<Vec<Diagnostic>> {
         let path = uri.to_file_path().ok()?;
-        let canon = std::fs::canonicalize(&path).unwrap_or(path.clone());
-        let mut overrides = HashMap::new();
-        overrides.insert(canon, text.to_string());
-        let ast = plum_core::loadAndMergeWithOverrides(&path, &self.libPath, &overrides).ok()?;
+        typeDiagnosticsFor(&path, &self.libPath, text)
-        let lastLine = text.lines().count().max(1) as u32 - 1;
-        match plum_checker::checkSource(&ast) {
-            Ok(()) => Some(Vec::new()),
-            Err(errors) => Some(
-                errors
-                    .into_iter()
-                    .map(|e| {
-                        // `CheckError`'s position is 1-based and points at the
-                        // enclosing declaration, not a sub-expression — clamp
-                        // to the document and cover the whole line so an
-                        // editor still shows something sensible even if the
-                        // line itself is short/blank.
-                        let line = e.line.saturating_sub(1).min(lastLine as usize) as u32;
-                        Diagnostic {
-                            range: Range {
-                                start: Position::new(line, 0),
-                                end: Position::new(line, u32::MAX),
-                            },
-                            severity: Some(DiagnosticSeverity::ERROR),
-                            source: Some("plum-check".into()),
-                            message: e.message,
-                            ..Default::default()
-                        }
-                    })
-                    .collect(),
-            ),
-        }
     }
     /// Builds `plum_checker`'s global tables for the live buffer, the same
@@ -160,20 +130,16 @@ impl Backend {
         let own_source = plum_core::AstParser::new(&sanitized).parseSource(tree.root_node());
         if let Some(receiver) = completion::receiverBeforeDot(line_text, pos.character as usize) {
-            let Some(merged) = self.mergedSource(uri, &sanitized) else {
+            let Ok(path) = uri.to_file_path() else {
                 return Vec::new();
             };
-            let (global_env, methods, enum_variants, enum_params) =
-                plum_checker::buildGlobalTables(&merged);
-            let min_required = plum_checker::buildMinRequiredArgs(&merged);
-            let ctx = plum_checker::CheckCtx {
-                methods: &methods,
-                enum_variants: &enum_variants,
-                enum_params: &enum_params,
+            return memberCompletionFor(
+                &path,
+                &self.libPath,
+                &sanitized,
-                min_required: &min_required,
+                pos.line as usize + 1,
+                &receiver,
-            };
+            );
-            let cursor_fn = completion::enclosingFn(&own_source, pos.line as usize + 1);
-            return completion::memberItems(cursor_fn, &receiver, &global_env, &ctx);
         }
         let mut items = completion::keywordItems();
@@ -303,6 +269,72 @@ impl LanguageServer for Backend {
     }
 }
+/// `Backend::typeDiagnostics` without the `Backend` (so it is unit-testable):
+/// loads `path` with `text` overriding what's on disk, then runs the checker.
+fn typeDiagnosticsFor(path: &Path, libPath: &Path, text: &str) -> Option<Vec<Diagnostic>> {
+    let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
+    let mut overrides = HashMap::new();
+    overrides.insert(canon, text.to_string());
+    let ast = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides).ok()?;
+    let lastLine = text.lines().count().max(1) as u32 - 1;
+    match plum_checker::checkSource(&ast) {
+        Ok(()) => Some(Vec::new()),
+        Err(errors) => Some(
+            errors
+                .into_iter()
+                .map(|e| {
+                    // `CheckError`'s position is 1-based and points at the
+                    // enclosing declaration, not a sub-expression — clamp
+                    // to the document and cover the whole line so an
+                    // editor still shows something sensible even if the
+                    // line itself is short/blank.
+                    let line = e.line.saturating_sub(1).min(lastLine as usize) as u32;
+                    Diagnostic {
+                        range: Range {
+                            start: Position::new(line, 0),
+                            end: Position::new(line, u32::MAX),
+                        },
+                        severity: Some(DiagnosticSeverity::ERROR),
+                        source: Some("plum-check".into()),
+                        message: e.message,
+                        ..Default::default()
+                    }
+                })
+                .collect(),
+        ),
+    }
+}
+/// Member completion for `receiver.` at `cursor_line` (1-based) of the
+/// (sanitized) buffer `text`; `Backend::completionItems`' member branch.
+fn memberCompletionFor(
+    path: &Path,
+    libPath: &Path,
+    text: &str,
+    cursor_line: usize,
+    receiver: &str,
+) -> Vec<CompletionItem> {
+    let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
+    let mut overrides = HashMap::new();
+    overrides.insert(canon, text.to_string());
+    let Ok(merged) = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides) else {
+        return Vec::new();
+    };
+    let tree = Backend::parseTree(text);
+    let own_source = plum_core::AstParser::new(text).parseSource(tree.root_node());
+    let (global_env, methods, enum_variants, enum_params) =
+        plum_checker::buildGlobalTables(&merged);
+    let min_required = plum_checker::buildMinRequiredArgs(&merged);
+    let ctx = plum_checker::CheckCtx {
+        methods: &methods,
+        enum_variants: &enum_variants,
+        enum_params: &enum_params,
+        min_required: &min_required,
+    };
+    let cursor_fn = completion::enclosingFn(&own_source, cursor_line);
+    completion::memberItems(cursor_fn, receiver, &global_env, &ctx, &merged.stars)
+}
 #[tokio::main]
 async fn main() {
     // `--lib-path` mirrors `plum-cli`'s own required flag (see
@@ -329,3 +361,66 @@ async fn main() {
     });
     Server::new(stdin, stdout, socket).serve(service).await;
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn repoRoot() -> PathBuf {
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("..")
+    }
+    /// The whole diagnostic path (`publishAll`: syntax diagnostics, then the
+    /// two-pass checker) must find nothing wrong in the Seq/fun*/for example.
+    #[test]
+    fn seqExampleHasNoDiagnostics() {
+        let path = repoRoot().join("plum-examples/seq.plum");
+        let text = std::fs::read_to_string(&path).unwrap();
+        let tree = Backend::parseTree(&text);
+        assert!(Backend::syntaxDiagnostics(&tree).is_empty());
+        let diags = typeDiagnosticsFor(&path, &repoRoot(), &text).expect("seq.plum loads");
+        assert!(diags.is_empty(), "unexpected diagnostics: {:?}", diags.iter().map(|d| &d.message).collect::<Vec<_>>());
+    }
+    #[test]
+    fn valuesAndLoopsExamplesHaveNoDiagnostics() {
+        for f in ["values.plum", "loops.plum", "chains.plum", "forms.plum"] {
+            let path = repoRoot().join("plum-examples").join(f);
+            let text = std::fs::read_to_string(&path).unwrap();
+            let tree = Backend::parseTree(&text);
+            assert!(Backend::syntaxDiagnostics(&tree).is_empty(), "{f}: syntax");
+            let diags = typeDiagnosticsFor(&path, &repoRoot(), &text).expect("loads");
+            assert!(diags.is_empty(), "{f}: {:?}", diags.iter().map(|d| &d.message).collect::<Vec<_>>());
+        }
+    }
+    /// `xs.` on a List offers List's own methods AND the Seq methods reached
+    /// through the iterable fallback.
+    #[test]
+    fn memberCompletionOnListIncludesSeqMethods() {
+        let dir = std::env::temp_dir().join(format!("plum-lsp-test-{}", 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/List\nimport std/Seq\n\nfun main() =\n  xs := List(1, 2, 3)\n  xs.zzzzzz\n";
+        std::fs::write(&path, text).unwrap();
+        let items = memberCompletionFor(&path, &repoRoot(), text, 8, "xs");
+        let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+        for want in ["length", "at", "filter", "map", "take", "fold", "toList"] {
+            assert!(labels.contains(&want), "missing {want} in {labels:?}");
+        }
+        let n = labels.iter().filter(|l| **l == "length").count();
+        assert_eq!(n, 1, "no duplicates");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+    #[test]
+    fn keywordsCurrent() {
+        let labels: Vec<String> = completion::keywordItems().into_iter().map(|i| i.label).collect();
+        for want in ["extend", "value", "fun*", "yield"] {
+            assert!(labels.iter().any(|l| l == want), "missing {want}");
+        }
+        for gone in ["inline", "block", "indexed", "case"] {
+            assert!(!labels.iter().any(|l| l == gone), "stale {gone}");
+        }
+    }
+}

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

@@ -1,3 +1,12 @@
+; Earlier patterns win on the same range (tree-sitter-highlight / Helix), so the
+; specific rules come first.
+; `*T` / `*(A, B)` after a `fun*` signature: what each `yield` hands to the `for`.
+(yield_type "*" @punctuation.special)
+; `for _, v := m`: `_` is aliased to a var_identifier, so match it by text.
+((var_identifier) @variable.builtin
+  (#eq? @variable.builtin "_"))
 ; (mod_identifier) @constant
 (type_identifier) @type
 (fn_identifier) @function
@@ -112,4 +121,4 @@
 (tag_type (type_identifier) @constructor)
-"match" @keyword
+"match" @keyword

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

@@ -1,5 +1,6 @@
 [
   (enum)
+  (extend)
   (fn)
   (for)
   (while)
@@ -15,6 +16,7 @@
   (while)
   (fn)
   (enum)
+  (extend)
 ] @extend
 [

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

@@ -12,3 +12,6 @@
 (fn_call
   function: (type_identifier) @name) @reference.call
+(extend
+  name: (type_identifier) @name) @definition.class

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

@@ -9,3 +9,5 @@
 (comment) @comment.inside
 (comment) @comment.around
+(extend) @class.around

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

@@ -5,6 +5,9 @@
     {
       "include": "#comments"
     },
+    {
+      "include": "#yield-type"
+    },
     {
       "include": "#keywords"
     },
@@ -36,6 +39,22 @@
         }
       ]
     },
+    "yield-type": {
+      "comment": "the `*T` / `*(A, B)` yield type after a `fun*` signature (so it is not styled as multiplication)",
+      "match": "^(\\s*(?:fun\\*)\\s+[A-Za-z_][A-Za-z0-9_]*\\s*\\(.*\\)\\s*)(\\*)",
+      "captures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "$self"
+            }
+          ]
+        },
+        "2": {
+          "name": "storage.type.yield.plum"
+        }
+      }
+    },
     "keywords": {
       "patterns": [
         {
@@ -44,7 +63,7 @@
         },
         {
           "name": "keyword.control.plum",
-          "match": "\\b(import|in|return|continue|break|match|when|if|else|while|for|yield|assert|todo|crash)\\b"
+          "match": "\\b(import|return|continue|break|match|when|if|else|while|for|yield|assert|todo|crash)\\b"
         },
         {
           "name": "keyword.operator.range.plum",
@@ -83,7 +102,7 @@
         },
         {
           "name": "keyword.operator.assignment.plum",
-          "match": "="
+          "match": ":?="
         }
       ]
     },