5e995b7 | plum | pyrossh

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

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

5e995b7 — Peter John 2026-09-04T21:13:18+05:30

docs: reformat README code blocks to match real plum format output

Files changed (1) hide show

README.md +53 -53

README.md CHANGED Viewed

@@ -95,16 +95,15 @@ Top-level only, `SCREAMING_SNAKE_CASE`, one expression.
 dec = 42
 hex = 0xFF
 bin = 0b1010
+big = 1_000_000
-big = 1_000_000       # underscores allowed as digit separators
+# underscores allowed as digit separators
 flt = 3.14
+flt2 = 12.0f
-flt2 = 12.0f          # trailing f/F suffix
+# trailing f/F suffix
 exp = 6.022e23
 name = "plum"
 empty = ""
 escaped = "line one\nline two\ttabbed \"quoted\""
 yes = True
 no = False
 ```
@@ -138,7 +137,8 @@ There's no range operator — `for i := range n` (see [Control flow](#control-fl
 `!` binds **looser** than comparisons — `!a == b` means `!(a == b)`, not `(!a) == b`. Whenever you mix categories (especially with `!`), group explicitly rather than relying on memorized precedence:
 ```plum
+grouped = {1 + 2} * {3 - 1}
-grouped = {1 + 2} * {3 - 1}    # {expr} groups, like (expr) in most languages
+# {expr} groups, like (expr) in most languages
 picked = cmp ? sum : bits
 negated = -sum
 inverted = !cmp
@@ -151,10 +151,12 @@ Full example: [`examples/basics.plum`](examples/basics.plum).
 ### Variables and assignment
 ```plum
+x := 1
-x := 1                # declares a new binding — errors if `x` is already in scope
+# declares a new binding — errors if `x` is already in scope
+a, b := 1, 2
-a, b := 1, 2          # multiple targets, positionally paired with multiple values
+# multiple targets, positionally paired with multiple values
+x = 2
-x = 2                 # reassigns an existing binding — type-checked against x's declared type
+# reassigns an existing binding — type-checked against x's declared type
 ```
 `:=` (Go-style) always declares a fresh binding, and it's an error to `:=` a name that's already in scope. Bare `=` is kept for backward compatibility: on a name's first use it still declares (exactly like `:=`), but on every subsequent use it reassigns and is type-checked against the existing binding's type — it can no longer silently change a variable's type out from under it. New code should prefer `:=` for declarations and reserve `=` for reassignment, but both spellings work in either position on a first use.
@@ -172,16 +174,16 @@ else
 i := start
 while i > 0
   i = i - 1
 for i := range limit
   if i == 3
     continue
   if i == 8
     break
   total = total + i
+assert n > 0
-assert n > 0    # traps at runtime if false
+# traps at runtime if false
+todo
-todo            # traps at runtime — marks a body as not yet implemented
+# traps at runtime — marks a body as not yet implemented
 ```
 `for i := range n` is the only `for`-loop form — it iterates `i` from `0` up to (excluding) `n`, where `n` is an `Int`-valued expression, and binds `i` as `Int`. There's no `in`/`..` range syntax and no general iterator protocol; the one other thing `range` accepts is a variadic function parameter (`fun sumAll(nums: ...Int) = for n := range nums ...`), which iterates its actual arguments and binds `n` as the variadic's element type instead of `Int`.
@@ -194,13 +196,13 @@ Full example: [`examples/control_flow.plum`](examples/control_flow.plum).
 fun addInts(a: Int, b: Int) -> Int =
   a + b
-fun greet() =                        # no return type => Unit
+fun greet() = # no return type => Unit
   todo
 fun withDefault(a: Int, step: Int = 1) -> Int =
   a + step
-fun sumAll(nums: ...Int) -> Int =    # variadic param
+fun sumAll(nums: ...Int) -> Int = # variadic param
   todo
 ```
@@ -218,7 +220,8 @@ fun add(a: Int, b: Int) -> Int =
 test "add works"
   assert add(1, 2) == 3
+  assert add(2, 2) == 5
-  assert add(2, 2) == 5    # fails, but the test keeps going
+  # fails, but the test keeps going
 ```
 ```sh
@@ -244,7 +247,7 @@ type Point =
   x: Int
   y: Int
-type Named(ToStr) =    # implements ToStr
+type Named(ToStr) = # implements ToStr
   name: Str
 trait Shape =
@@ -257,15 +260,15 @@ enum Color =
   | Blue
 enum Option =
-  | Some[Int]              # positional/generic payload — Some(5)
+  | Some[Int] # positional/generic payload — Some(5)
   | None
 enum Shape =
-  | Circle(radius: Int)          # named payload fields — Circle(radius: 5) or Circle(5)
+  | Circle(radius: Int) # named payload fields — Circle(radius: 5) or Circle(5)
-  | Square(x: Int, y: Int)       # Square(x: 1, y: 2) or Square(1, 2)
+  | Square(x: Int, y: Int) # Square(x: 1, y: 2) or Square(1, 2)
-enum Step(n: Int) =              # a shared param on the whole enum ...
+enum Step(n: Int) = # a shared param on the whole enum ...
-  | ReadMin(10)                  # ... each variant supplies its own discriminant value for it
+  | ReadMin(10) # ... each variant supplies its own discriminant value for it
   | ReadMax(20)
 ```
@@ -283,11 +286,12 @@ Generic type **parameters** are single uppercase letters (`T`, `K`, `V`, ...)
 type Box[T] =
   value: T
-trait Comparable[T: Ord] =    # bounded generic param
+trait Comparable[T: Ord] = # bounded generic param
   compareTo(other: T) -> Int
-fun wrap(value: T) -> Bool =      # a bare uppercase letter in a param/return type is enough —
+fun wrap(value: T) -> Bool = # a bare uppercase letter in a param/return type is enough
+  True
-  True                            # free functions have no `[T]` declaration of their own
+  # free functions have no `[T]` declaration of their own
 ```
 Generic **arguments** (instantiating a generic type) accept either bracket or paren syntax: `List[Int]` and `List(Int)` both parse. User-defined generics (classes, their methods, free functions, and enums) are monomorphized: each concrete-type-argument combination actually used in the program gets its own specialized, fully-concrete copy, which then type-checks and compiles to wasm through the normal, unmodified pipeline. See `useWrap`/`usePair` in [`examples/functions.plum`](examples/functions.plum) and `makeIntBox`/`makeStrBox` in [`examples/types.plum`](examples/types.plum) for real instantiation sites. Generic enums support any number of concrete instantiations coexisting in one program (variant names are mangled per instantiation, e.g. `Some` -> `Some$Int`/`Some$Str`, internally — invisible to user code). One narrower residual limitation: a payload-free variant (e.g. `None`) used as a bare value *outside* of a `match` pattern can't be disambiguated between multiple concrete instantiations of its enum from that expression alone; constructing via a payload-carrying sibling (`Some(5)`) and matching (`Some(v) => ...`, `None => ...`) is fully supported and is the overwhelmingly common usage pattern.
@@ -303,8 +307,8 @@ fun each(cb: fn(Int) -> Int) -> Int =
   cb(5)
 fun useCapturingClosure() -> Int =
-  offset = 100
+  offset := 100
-  cb = |v|
+  cb := |v|
     v + offset
   cb(5)
@@ -318,7 +322,7 @@ A `fn(...)` / `fn(...) -> T` type annotates a closure-typed parameter or field:
 Capture is **snapshot-by-value**: any outer variable a closure body references is copied into the closure's environment at the moment the closure literal is evaluated, not re-read live later. Reassigning the captured variable afterward does not change what the closure sees.
-Closures parse and compile in two shapes: passed directly as a call argument (`each(|v| v * 3)`), or assigned to a local first and called or passed on later (`cb = |v|\n  v + offset` followed by `cb(5)` or `each(cb)`). Both support a multi-line indented body.
+Closures parse and compile in two shapes: passed directly as a call argument (`each(|v| v * 3)`), or assigned to a local first and called or passed on later (`cb := |v|\n  v + offset` followed by `cb(5)` or `each(cb)`). Both support a multi-line indented body.
 Full example: [`examples/closures.plum`](examples/closures.plum).
@@ -330,18 +334,18 @@ A `fun` declared indented directly inside a `type`/`enum` body is a method on th
 type Cat =
   name: Str
   age: Int
   fun getAge(self) -> Int =
     self.age
   fun birthday(self) -> Int =
     self.age + 1
 fun main() -> Int =
-  c = Cat(name: "Whiskers", age: 3)
+  c := Cat(name: "Whiskers", age: 3)
-  a = c.getAge()        # method call
+  a := c.getAge()
+  # method call
-  w = Wrapper(inner: c, tag: 1)
+  w := Wrapper(inner: c, tag: 1)
+  w.inner.age
-  w.inner.age            # chained field access
+  # chained field access
 ```
 Methods are dispatched by declared receiver type, not by name alone — two types can each define a method with the same name without colliding.
@@ -360,32 +364,28 @@ Construct a `type` value by calling its name with `field: value` pairs (any orde
 ```plum
 match n
-  0 => "zero"       # inline body
+  0 => 1 # single-expression body — always written inline
-  1 =>
+  x =>
-    "one"           # indented block body — both forms are accepted
+    if x < 0 # a body that needs more than one line (here, an if/else)
-  _ =>
+      -1
-    "many"
+      # is written as an indented block instead
+    else
+      2
 match b
-  True =>
+  True => 1
-    1
-  False =>
+  False => 0
-    0
 match opt
-  Some(v) =>
+  Some(v) => v
-    v
-  None =>
+  None => 0
-    0
 match book
-  FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures =>
+  FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures => "Fantasy book \"{title}\" features mythical creatures"
-    "Fantasy book \"{title}\" features mythical creatures"
-  FantasyBook(title, _, _) =>
-    "Fantasy book \"{title}\" has no mythical creatures"
+  FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
 ```
-A case body can be a single inline expression right after `=>`, or an indented block — pick whichever reads better for that arm. Patterns can be: integer/float/string literals, a bare identifier (binds a new local to the subject's value), a bare capitalized tag (`True`, `False`, or any declared `enum` variant with no payload — compared, not bound), a constructor pattern (`Some(v)`, binding its argument — sub-patterns can themselves be constructor patterns, e.g. `Wrap(Some(v))`), or `_` (wildcard). `match a, b, ...` against multiple comma-separated subjects is also supported — each case supplies one pattern per subject, and every position must match for that case to apply. A case's pattern can also carry a `when <expr>` guard: the pattern must still match positionally for the guard to run at all, and a matching pattern whose guard evaluates `False` falls through to the *next* case (the same fallthrough an outright pattern mismatch gets), not to a different position within the same case. See [`examples/dop_visitor.plum`](examples/dop_visitor.plum) for a realistic use of guards.
+A case body is a single inline expression right after `=>` whenever that's all it needs; an indented block is for anything that doesn't fit on one line (an `if`/`else`, a `return`, a nested `match`, several statements). Patterns can be: integer/float/string literals, a bare identifier (binds a new local to the subject's value), a bare capitalized tag (`True`, `False`, or any declared `enum` variant with no payload — compared, not bound), a constructor pattern (`Some(v)`, binding its argument — sub-patterns can themselves be constructor patterns, e.g. `Wrap(Some(v))`), or `_` (wildcard). `match a, b, ...` against multiple comma-separated subjects is also supported — each case supplies one pattern per subject, and every position must match for that case to apply. A case's pattern can also carry a `when <expr>` guard: the pattern must still match positionally for the guard to run at all, and a matching pattern whose guard evaluates `False` falls through to the *next* case (the same fallthrough an outright pattern mismatch gets), not to a different position within the same case. See [`examples/dop_visitor.plum`](examples/dop_visitor.plum) for a realistic use of guards.
 Full example: [`examples/match.plum`](examples/match.plum).