cfed449 | plum | pyrossh

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

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

cfed449 — Peter John 2026-11-01T23:05:13+05:30

examples: one file per concept, visitors removed, game_loop added; duplicate Plum tests removed (434 -> 375)

Files changed (28) hide show

README.md +6 -6
plum-examples/chains.plum +0 -115
plum-examples/constants.plum +0 -4
plum-examples/dop_visitor.plum +0 -114
plum-examples/error_propagation.plum +1 -1
plum-examples/forms.plum +2 -126
plum-examples/functions.plum +3 -78
plum-examples/game_loop.plum +102 -0
plum-examples/generics.plum +35 -0
plum-examples/loops.plum +0 -10
plum-examples/map_struct_values.plum +0 -21
plum-examples/maps.plum +15 -14
plum-examples/match.plum +226 -77
plum-examples/methods.plum +0 -31
plum-examples/oop_visitor.plum +0 -117
plum-examples/optionals.plum +70 -0
plum-examples/pattern_if.plum +0 -153
plum-examples/safe_navigation.plum +0 -91
plum-examples/seq.plum +92 -2
plum-examples/shapes.plum +0 -30
plum-examples/strings.plum +54 -2
plum-examples/{values.plum → structs_records.plum} +104 -51
plum-examples/typed_arrays.plum +0 -6
plum-examples/types.plum +0 -199
plum-examples/unions.plum +87 -17
plum-lsp/src/main.rs +1 -1
plum-std/Str.plum +0 -43
plum-wasm-codegen/tests/examples_test.rs +10 -7

README.md CHANGED Viewed

@@ -368,7 +368,7 @@ Details:
 - `else if` chains can mix plain conditions, optional bindings (`if x := opt`, see [Optionals](#optionals)) and patterns. A plain lowercase name over a `T?` is the optional binding; any other pattern is a pattern test.
 - It works on error values too: inside a `catch e` block, `if TooBig := e` tests the error name.
-See [`plum-examples/pattern_if.plum`](plum-examples/pattern_if.plum).
+See [`plum-examples/match.plum`](plum-examples/match.plum).
 ## Functions
@@ -418,7 +418,7 @@ u2 := u
 u2.age = 4         # u.age is now 4: a record is a heap object, shared on assignment
 ```
-A `struct` has no generics; its fields are only `Int`, `Float`, `Bool`, `Byte` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed inside `T?` and other generic slots. Arrays of structs (`Array[Vec2]`, and so `List[Vec2]` and `Grid[Tile]`) are stored field by field, one native array per field, with no per-element allocation. A `record` may have any field types and may be generic (`record Pair[K, V](key: K, val: V)`). Methods and `match` work as for any enum. See [`plum-examples/values.plum`](plum-examples/values.plum).
+A `struct` has no generics; its fields are only `Int`, `Float`, `Bool`, `Byte` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed inside `T?` and other generic slots. Arrays of structs (`Array[Vec2]`, and so `List[Vec2]` and `Grid[Tile]`) are stored field by field, one native array per field, with no per-element allocation. A `record` may have any field types and may be generic (`record Pair[K, V](key: K, val: V)`). Methods and `match` work as for any enum. See [`plum-examples/structs_records.plum`](plum-examples/structs_records.plum).
 ### Enums
@@ -485,7 +485,7 @@ fun areaOf(s: Shape) -> Float =
   s.area()
 ```
-See [`plum-examples/shapes.plum`](plum-examples/shapes.plum) and [`plum-examples/types.plum`](plum-examples/types.plum).
+See [`plum-examples/unions.plum`](plum-examples/unions.plum).
 One type can be a member of several enums. A `Circle` is a `Shape` and also a `Round`, and converts to whichever the context asks for:
@@ -563,7 +563,7 @@ match book
   FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
 ```
-Patterns can be literals, a bare identifier (binds), a bare capitalized name (a member or tag of an enum, or an error name when matching an error value, also written `error.Name`; compared), a constructor pattern (`Circle(r)`, binding its fields, possibly nested), a bare member name (`Float`, which narrows the subject to that type, see [Enums](#enums)), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard. A `match` over an enum must be exhaustive. See [`plum-examples/match.plum`](plum-examples/match.plum), [`plum-examples/dop_visitor.plum`](plum-examples/dop_visitor.plum) and [`plum-examples/oop_visitor.plum`](plum-examples/oop_visitor.plum).
+Patterns can be literals, a bare identifier (binds), a bare capitalized name (a member or tag of an enum, or an error name when matching an error value, also written `error.Name`; compared), a constructor pattern (`Circle(r)`, binding its fields, possibly nested), a bare member name (`Float`, which narrows the subject to that type, see [Enums](#enums)), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard. A `match` over an enum must be exhaustive. See [`plum-examples/match.plum`](plum-examples/match.plum).
 ## Generics
@@ -775,7 +775,7 @@ while i < units.length()
   seen = seen + 1
 ```
-See [`plum-examples/seq.plum`](plum-examples/seq.plum) (one test per adapter and terminal), [`plum-examples/chains.plum`](plum-examples/chains.plum), [`plum-examples/forms.plum`](plum-examples/forms.plum) and [`plum-examples/loops.plum`](plum-examples/loops.plum).
+See [`plum-examples/seq.plum`](plum-examples/seq.plum) (one test per adapter and terminal, plus fused chains), [`plum-examples/forms.plum`](plum-examples/forms.plum) (user-defined `fun*` forms) and [`plum-examples/loops.plum`](plum-examples/loops.plum).
 ### Iteration cheat sheet
@@ -847,7 +847,7 @@ fun targetName(u: User?) -> Str? =
   u?.target?.name
 ```
-It's sugar for `obj.andThen(|v| v.field)` -- nothing more than that; chain it as many times as needed. See [`plum-examples/optionals.plum`](plum-examples/optionals.plum) and [`plum-examples/safe_navigation.plum`](plum-examples/safe_navigation.plum).
+It's sugar for `obj.andThen(|v| v.field)` -- nothing more than that; chain it as many times as needed. See [`plum-examples/optionals.plum`](plum-examples/optionals.plum).
 ## Error handling

plum-examples/chains.plum DELETED Viewed

@@ -1,115 +0,0 @@
-# Sequence chaining: combines collection adapters (skip, take, map, filter)
-# into single-pass loops via `std/Seq`.
-import std/Str
-import std/Int
-import std/Float
-import std/List
-import std/Testing
-import std/Seq
-# Closure-free chains. A method chain such as
-#
-#   keep my team's units, take their hp, sum it
-#
-# becomes ONE `for` over the sequence:
-#
-#   * per-element stages are header clauses: filter = `, if cond`,
-#     map = `, name := expr`;
-#   * the terminal step is the outer form plus its body (fold, map, find, count,
-#     any, all);
-#   * body-less stages nest as `fun*` sources (take, skip, zip, reversed,
-#     chunks, stepBy), and always fuse into the same single loop;
-#   * materializing stages (sort, group) are separate statements.
-#
-# No closure is allocated and there is no call_indirect: the wasm is the loop you
-# would have written by hand. See plum-std/Seq.plum.
-record Soldier(name: Str, team: Int, hp: Float, x: Float, y: Float)
-fun dist2(ax: Float, ay: Float, bx: Float, by: Float) -> Float =
-  dx := ax - bx
-  dy := ay - by
-  dx * dx + dy * dy
-fun army() -> List[Soldier] =
-  List(
-    Soldier(name: "a", team: 1, hp: 10.0, x: 0.0, y: 0.0),
-    Soldier(name: "b", team: 2, hp: 0.0, x: 1.0, y: 1.0),
-    Soldier(name: "c", team: 1, hp: 7.0, x: 5.0, y: 5.0),
-    Soldier(name: "d", team: 2, hp: 3.0, x: 2.0, y: 0.0),
-    Soldier(name: "e", team: 1, hp: 4.0, x: 9.0, y: 9.0),
-    Soldier(name: "f", team: 2, hp: 8.0, x: 1.0, y: 0.0),
-  )
-test "sum of hp of my team: filter + map + sum is a fold with clauses"
-  units := army()
-  me := units.at(0)
-  # units.filter(team == me).map(hp).sum()
-  total := for acc, u := range units.fold(0.0), if u.team == me.team, hp := u.hp
-    acc + hp
-  assert total == 21.0
-test "names of living units within range: filter + map + filter + map"
-  units := army()
-  me := units.at(0)
-  reach := 5.0
-  names := for u := range units.map(), if u.hp > 0.0, d := dist2(u.x, u.y, me.x, me.y), if d < reach
-    u.name
-  assert names.length() == 3
-  assert names.at(0) == "a"
-  assert names.at(1) == "d"
-  assert names.at(2) == "f"
-test "first enemy in range: filter + find"
-  units := army()
-  me := units.at(0)
-  near := for u := range units.find(), if u.team != me.team
-    dist2(u.x, u.y, me.x, me.y) < 4.0
-  first := near ?: me
-  assert first.name == "b"
-test "take + map: the first five living units"
-  units := army()
-  lines := for u := range units.take(5).map(), if u.hp > 0.0
-    u.name
-  assert lines.length() == 4
-  assert lines.at(0) == "a"
-  assert lines.at(3) == "e"
-test "two binders over a list are (position, element)"
-  units := army()
-  hits := 0
-  for i, u := range units, if u.hp > 0.0
-    hits = hits + i
-  assert hits > 0
-test "count and any over a chain"
-  units := army()
-  alive := for u := range units.skip(1).count(), if u.team == 2
-    u.hp > 0.0
-  assert alive == 2
-  anyBig := for u := range units.stepBy(2).any()
-    u.hp > 9.0
-  assert anyBig
-test "reversed and chunks"
-  units := army()
-  last := for u := range units.reversed().take(2).map()
-    u.name
-  assert last.at(0) == "f"
-  assert last.at(1) == "e"
-  sizes := for c := range units.chunks(4).map()
-    c.length()
-  assert sizes.length() == 2
-  assert sizes.at(0) == 4
-  assert sizes.at(1) == 2
-test "materializing stages are separate statements"
-  units := army()
-  alive := for u := range units.filter()
-    u.hp > 0.0
-  assert alive.length() == 5
-  # a later stage runs over the materialized list
-  hps := for u := range alive.map(), if u.team == 1
-    u.hp
-  assert hps.length() == 3

plum-examples/constants.plum CHANGED Viewed

@@ -55,7 +55,3 @@ test "the same const name can live on two types"
 test "a struct can hold a constant instance of itself"
   assert Vec2.ZERO.x == 0.0
   assert Tile.origin().x == 0
-test "built-in types carry their constants"
-  assert Float.PI > 3.14 && Float.PI < 3.15
-  assert Int.MAX > 0

plum-examples/dop_visitor.plum DELETED Viewed

@@ -1,114 +0,0 @@
-# Data-oriented alternative to the Visitor pattern.
-# Based on: https://wimdetroyer.com/blog/visitor-pattern-in-dop
-#
-# Instead of a Visitable/BookVisitor double-dispatch hierarchy, the shape of
-# the data is declared once with a sealed `enum` and every operation on it is
-# a single exhaustive `match`. Two features make this read close to the
-# article's Java (sealed interfaces implemented directly by records, switch
-# with `when` guards and deconstruction):
-#
-#   - Each variant is its own `record` declaration (e.g. `record
-#     FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)`), listed
-#     as a member of the union enum (`enum Book = FantasyBook | ScifiBook | ...`).
-#     Construct with named fields (`FantasyBook(title: ..., ...)`) or
-#     positionally, and a match arm destructures each member by position
-#     (`FantasyBook(title, pages, hasMythicalCreatures)`) or by name.
-#   - A `when <expr>` guard on a match case (`FantasyBook(title, _,
-#     hasMythicalCreatures) when hasMythicalCreatures => ...`) stands in for
-#     Java's guarded switch patterns; a guard that evaluates false falls
-#     through to the next case, same as a genuine pattern mismatch.
-#
-# 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 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
-#     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 `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 an interface (see
-#     `oop_visitor.plum`'s header), which tilts things further toward DOP
-#     for anything that needs to treat the shapes polymorphically.
-import std/Os
-import std/Int
-import std/Float
-import std/Str
-enum Rating = Good | Bad
-record Good(name: Str)
-record Bad(name: Str)
-enum Book = FantasyBook | ScifiBook | ChildrensTaleBook | NonFictionBook
-record FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
-record ScifiBook(title: Str, pages: Int, theme: Str)
-record ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
-record NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)
-fun collectInterestingInfo(book: Book) -> Str =
-  match book
-    FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures => "Fantasy book \"{title}\" features mythical creatures"
-    FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
-    ScifiBook(title, _, theme) when theme == "space exploration" => "Scifi book \"{title}\" explores space exploration"
-    ScifiBook(title, _, theme) => "Scifi book \"{title}\" has theme {theme}"
-    ChildrensTaleBook(title, pages, _) when pages == 0 => "Childrens book \"{title}\" is empty"
-    ChildrensTaleBook(title, _, moralLesson) => "Childrens book \"{title}\" teaches: {moralLesson}"
-    NonFictionBook(title, _, rating1, rating2) =>
-      match rating1, rating2
-        Good(name1), Good(name2) => "Non-fiction book \"{title}\" praised by {name1} and {name2}"
-        _, _ => "Non-fiction book \"{title}\" has mixed reviews"
-fun describeFantasy() -> Str =
-  collectInterestingInfo(FantasyBook(title: "Dragon Tales", pages: 200, hasMythicalCreatures: true))
-fun main() =
-  printLn(describeFantasy())
-test "fantasy book with mythical creatures is called out"
-  assert describeFantasy() == "Fantasy book \"Dragon Tales\" features mythical creatures"
-test "fantasy book without mythical creatures is called out"
-  book := FantasyBook(title: "Plain Fantasy", pages: 150, hasMythicalCreatures: false)
-  assert collectInterestingInfo(book) == "Fantasy book \"Plain Fantasy\" has no mythical creatures"
-test "scifi book with space exploration theme is called out"
-  book := ScifiBook(title: "Starbound", pages: 300, theme: "space exploration")
-  assert collectInterestingInfo(book) == "Scifi book \"Starbound\" explores space exploration"
-test "scifi book with other theme falls through to generic case"
-  book := ScifiBook(title: "Timeloop", pages: 250, theme: "time travel")
-  assert collectInterestingInfo(book) == "Scifi book \"Timeloop\" has theme time travel"
-test "empty childrens book is handled via a when guard on pages"
-  book := ChildrensTaleBook(title: "Nothing", pages: 0, moralLesson: "none")
-  assert collectInterestingInfo(book) == "Childrens book \"Nothing\" is empty"
-test "childrens book with pages reports its moral lesson"
-  book := ChildrensTaleBook(title: "The Tortoise", pages: 40, moralLesson: "patience wins")
-  assert collectInterestingInfo(book) == "Childrens book \"The Tortoise\" teaches: patience wins"
-test "non fiction book praised by both reviewers via nested deconstruction"
-  book := NonFictionBook(
-    title: "Hidden Facts",
-    pages: 120,
-    rating1: Good(name: "Alice"),
-    rating2: Good(name: "Bob"),
-  )
-  assert collectInterestingInfo(book) == "Non-fiction book \"Hidden Facts\" praised by Alice and Bob"
-test "non fiction book with a bad rating reports mixed reviews"
-  book := NonFictionBook(
-    title: "Shaky Claims",
-    pages: 80,
-    rating1: Good(name: "Alice"),
-    rating2: Bad(name: "Carol"),
-  )
-  assert collectInterestingInfo(book) == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/error_propagation.plum CHANGED Viewed

@@ -10,7 +10,7 @@ import std/List
 # front of the `!`: `error{A, B}!T` inline, `ParseError!T` for a set declared
 # with `error ParseError = A | B`, or `(A || B)!T` to merge sets. Pin the set on
 # a public API, on a recursive function and on an `extern fun`. There is no
-# `Option`: an optional `T?` (see safe_navigation.plum) is not an error.
+# `Option`: an optional `T?` (see optionals.plum) is not an error.
 #
 # A plain `T` (a tail value or `return n`) is the success value; an error value
 # (`return error.X`) is the failure. A bare name is never an implicit failure.

plum-examples/forms.plum CHANGED Viewed

@@ -1,5 +1,5 @@
-# Fused loop forms: `for` loops with `, if cond` filter clauses and inline
+# User-defined `fun*` forms with `yield`: sources, folds and methods written in
-# mapping expressions, plus custom `fun*` generators with `yield`.
+# plum and expanded at the call site (the built-in forms are in seq.plum).
 import std/Str
 import std/Int
 import std/Float
@@ -73,69 +73,6 @@ record Countdown(from: Int) =
       i = i - 1
       yield cur, cur * cur
-test "filter_form: keeps the elements whose body is true"
-  fighters := sampleFighters()
-  alive := for u := range fighters.filter()
-    !u.dead
-  assert alive.length() == 2
-  assert alive.at(1).name == "c"
-test "map_with_clauses_fused: clauses filter, the body maps"
-  xs := List(1, 2, 3, 4, 5, 6)
-  squares := for x := range xs.map(), if x % 2 == 0, sq := x * x
-    sq + 1
-  assert squares.length() == 3
-  assert squares.at(0) == 5
-  assert squares.at(2) == 37
-test "fold_two_binders: acc, x"
-  xs := List(1, 2, 3, 4)
-  total := for acc, x := range xs.fold(100)
-    acc + x
-  assert total == 110
-  best := for acc, x := range xs.fold(0), if x != 3
-    if acc > x then acc else x
-  assert best == 4
-test "find_returns_nullable: first match or null"
-  xs := List(5, 8, 12, 20)
-  big := for x := range xs.find()
-    x > 10
-  got := big ?: -1
-  assert got == 12
-  none := for x := range xs.find()
-    x > 100
-  missing := none ?: -1
-  assert missing == -1
-test "any, all, count"
-  xs := List(1, 2, 3, 4)
-  some3 := for x := range xs.any()
-    x == 3
-  assert some3
-  allSmall := for x := range xs.all()
-    x < 4
-  assert !allSmall
-  n := for x := range xs.count(), if x > 1
-    x % 2 == 0
-  assert n == 2
-test "zip and each, and two binders over a list give (position, element)"
-  xs := List(10, 20, 30)
-  ys := List(1, 2, 3, 4)
-  acc := 0
-  for i, x := range xs
-    acc = acc + i * x
-  assert acc == 80
-  dot := 0
-  for a, b := range xs.zip(ys)
-    dot = dot + a * b
-  assert dot == 140
-  seen := 0
-  for x := range xs.each()
-    seen = seen + 1
-  assert seen == 3
 test "user_form_sumBy"
   fighters := sampleFighters()
   hp := for u := range sumBy(fighters)
@@ -195,54 +132,6 @@ test "return for-form: the form's value is returned"
 test "tail for-form: the last statement of a fn is its value"
   assert tailForm(List(1, 2, 3)) == 12
-test "until: start inclusive, end exclusive, continue still advances"
-  total := 0
-  for i := range 2.until(6)
-    total = total + i
-  assert total == 14
-  odd := 0
-  for i := range 10, if i % 2 == 1
-    odd = odd + 1
-  assert odd == 5
-  skipped := 0
-  for i := range 6
-    if i % 2 == 0
-      continue
-    skipped = skipped + i
-  assert skipped == 9
-  none := 0
-  for i := range 5.until(5)
-    none = none + 1
-  assert none == 0
-test "yield_value_drives_filter: the body's value decides"
-  xs := List(1, 2, 3, 4, 5, 6)
-  even := for x := range xs.filter()
-    x % 2 == 0
-  assert even.length() == 3
-  assert even.at(2) == 6
-test "fold_yield_two: yield acc, x"
-  xs := List(1, 2, 3, 4)
-  product := for acc, x := range xs.fold(1)
-    acc * x
-  assert product == 24
-test "nested_fun_star_forms: adapters take sequences"
-  xs := List(10, 20, 30, 40, 50)
-  got := for p := range xs.take(3).map()
-    p + 1
-  assert got.length() == 3
-  assert got.at(2) == 31
-  idx := 0
-  for x := range xs.skip(2)
-    idx = idx + x
-  assert idx == 30 + 40 + 50
-  names := for x := range xs.take(2).map(), if x > 10
-    x * 2
-  assert names.length() == 1
-  assert names.at(0) == 40
 test "fun_star_method_uses_self"
   c := Countdown(from: 4)
   seen := 0
@@ -264,16 +153,3 @@ test "two_binder_uses_entries_method: a custom type's entries()"
     total = total + sq
   assert total == 6014 + 14
-test "two_binder_defaults_to_position: List gives (i, x)"
-  xs := List(10, 20, 30)
-  acc := 0
-  for i, x := range xs
-    acc = acc + i * x
-  assert acc == 80
-  n := 0
-  for _, x := range xs
-    n = n + x
-  assert n == 60
-  for _ := range 3
-    n = n + 1
-  assert n == 63

plum-examples/functions.plum CHANGED Viewed

@@ -1,5 +1,5 @@
-# Functions: top-level function declarations, typed arguments, return expressions,
+# Functions: top-level function declarations, typed arguments, default and
-# and recursion.
+# variadic parameters, return expressions, and recursion.
 import std/Str
 import std/Int
 import std/Float
@@ -31,7 +31,7 @@ fun useWrap() -> Bool =
 fun usePair() -> Bool =
   pair(1, "x")
-# ---- generics, variadics, and misc regression tests ----
+# ---- recursion, defaults and variadics ----
 fun factorial(x: Int) -> Int =
   if x < 2
@@ -45,56 +45,6 @@ fun factorial(x: Int) -> Int =
 fun double(n: Int) -> Int =
   n * 2
-record GenericBox[T](value: T) =
-  fun getIntValue() -> T =
-    self.value
-fun useGenericBox() -> Int =
-  b := GenericBox(value: 7)
-  b.getIntValue()
-fun identity(value: T) -> T =
-  value
-record GenericBox2[T](value: T) =
-  fun getValue() -> T =
-    self.value
-fun doubled(value: Int) -> Int =
-  identity(value) + identity(value)
-enum Parcel[T] = Delivered[T] | Lost
-record Delivered[T](v: T)
-fun contentsOr(p: Parcel[Int], default: Int) -> Int =
-  match p
-    Delivered(v) => v
-    Lost => default
-# `Str.length()` is not a real, working method — the point of this test is
-# that `Parcel[Str]` coexists with `Parcel[Int]` and both run correctly, not
-# string processing, so the Str arm returns a fixed literal.
-fun intContentsOr(p: Parcel[Int], default: Int) -> Int =
-  match p
-    Delivered(v) => v
-    Lost => default
-fun strContentsOr(p: Parcel[Str], default: Int) -> Int =
-  match p
-    Delivered(v) => 4
-    Lost => default
-record GenericBox3[T](value: T) =
-  fun getBoxValue() -> T =
-    self.value
-fun sumBox(b: GenericBox3[Int]) -> Int =
-  b.getBoxValue()
 fun combineVariadic(prefix: Int, rest: ...Int) -> Int =
   prefix
@@ -104,31 +54,6 @@ test "factorial runs correctly"
 test "lowercase single word function call runs correctly"
   assert double(21) == 42
-test "generic class specialized at two types does not alias"
-  assert useGenericBox() == 7
-test "generic function called at multiple concrete types runs correctly"
-  assert identity(5) + identity(37) == 42
-test "generic method on generic class runs correctly"
-  b := GenericBox2(value: 9)
-  assert b.getValue() == 9
-test "transitively generic call chain runs correctly"
-  assert doubled(21) == 42
-test "generic enum specialized and matched runs correctly"
-  assert contentsOr(Delivered(13), 0) == 13
-test "generic enum multiple instantiations coexist and run correctly"
-  assert intContentsOr(Delivered(13), 0) + strContentsOr(Delivered("abcd"), 0) == 17
-test "same bare generic enum param function called multiple times runs correctly"
-  assert contentsOr(Delivered(5), 0) + contentsOr(Delivered(37), 0) == 42
-test "ordinary function with bare generic class param runs correctly"
-  assert sumBox(GenericBox3(value: 11)) == 11
 test "variadic call with varying trailing arg counts runs correctly"
   a := combineVariadic(10)
   b := combineVariadic(20, 1)

plum-examples/game_loop.plum ADDED Viewed

@@ -0,0 +1,102 @@
+# A tiny game update loop. Particles are structs in a `List`, which stores them
+# field by field (struct-of-arrays), so 100 frames of updates allocate nothing per
+# particle; dead ones are removed by swap-remove. Entities live in a `Map[Int,
+# Entity]` and are changed by events handled with `match`.
+module game_loop
+import std/Str
+import std/Int
+import std/Float
+import std/List
+import std/Map
+struct Vec2(x: Float, y: Float) =
+  fun add(self, o: Vec2) -> Vec2 =
+    Vec2(x: self.x + o.x, y: self.y + o.y)
+  fun mul(self, s: Float) -> Vec2 =
+    Vec2(x: self.x * s, y: self.y * s)
+struct Particle(pos: Vec2, vel: Vec2, life: Int)
+record Entity(id: Int, name: Str, hp: Int)
+record Spawn(id: Int, name: Str)
+record Damage(id: Int, amount: Int)
+record Despawn(id: Int)
+enum Event = Spawn | Damage | Despawn
+record Stats(spawned: Int, removed: Int)
+# Move every particle one step; remove the dead by swap-remove (the last
+# particle takes the freed slot, so the list never shifts). Returns how many died.
+fun step(ps: List[Particle], dt: Float) -> Int =
+  removed := 0
+  i := 0
+  while i < ps.length()
+    p := ps.at(i)
+    p.pos = p.pos.add(p.vel.mul(dt))
+    p.life = p.life - 1
+    if p.life <= 0
+      last := ps.at(ps.length() - 1)
+      ps.set(i, last)!
+      ps.pop()!
+      removed = removed + 1
+    else
+      ps.set(i, p)!
+      i = i + 1
+  removed
+fun run(frames: Int, ps: List[Particle]) -> Stats =
+  spawned := 0
+  removed := 0
+  for frame := range frames
+    if frame % 10 == 0
+      ps.push(Particle(pos: Vec2(x: 0.0, y: 0.0), vel: Vec2(x: 2.0, y: 1.0), life: 25))
+      spawned = spawned + 1
+    removed = removed + step(ps, 0.5)
+  Stats(spawned: spawned, removed: removed)
+fun handle(world: Map[Int, Entity], e: Event) =
+  match e
+    Spawn(id, name) =>
+      world.set(id, Entity(id: id, name: name, hp: 100))
+    Damage(id, amount) =>
+      if ent := world.getOrNull(id)
+        ent.hp = ent.hp - amount
+    Despawn(id) =>
+      world.remove(id)
+test "100 frames: particles spawn, move and are swap-removed when dead"
+  ps := List[Particle]()
+  stats := run(100, ps)
+  assert stats.spawned == 10
+  assert stats.removed == 8
+  assert ps.length() == 2
+test "survivors have moved and aged the expected amount"
+  ps := List[Particle]()
+  run(100, ps)
+  x := 0.0
+  life := 0
+  for p := range ps
+    x = x + p.pos.x
+    life = life + p.life
+  # spawned on frames 80 and 90: 20 and 10 steps of +1.0, 5 and 15 life left
+  assert x == 30.0
+  assert life == 20
+test "events change the entity map"
+  world := Map[Int, Entity]()
+  handle(world, Spawn(id: 1, name: "orc"))
+  handle(world, Spawn(id: 2, name: "elf"))
+  handle(world, Damage(id: 1, amount: 30))
+  handle(world, Damage(id: 9, amount: 5))
+  assert world.get(1)!.hp == 70
+  assert world.get(2)!.name == "elf"
+  handle(world, Despawn(id: 2))
+  assert world.length() == 1
+  assert !world.has(2)

plum-examples/generics.plum CHANGED Viewed

@@ -78,6 +78,30 @@ fun sumWith(xs: List[T], num: Num[T]) -> T =
     acc = num.add(acc, x)
   acc
+# --- generic records and enums ----------------------------------------------
+record GenericBox[T](value: T) =
+  fun getValue(self) -> T =
+    self.value
+fun unboxed(b: GenericBox[Int]) -> Int =
+  b.getValue()
+enum Parcel[T] = Delivered[T] | Lost
+record Delivered[T](v: T)
+fun intContentsOr(p: Parcel[Int], default: Int) -> Int =
+  match p
+    Delivered(v) => v
+    Lost => default
+fun strContentsOr(p: Parcel[Str], default: Int) -> Int =
+  match p
+    Delivered(v) => v.length()
+    Lost => default
 test "Int extremes survive a generic fn"
   big := 9223372036854775807
   small := 0 - 9223372036854775807 - 1
@@ -244,3 +268,14 @@ test "nested generic constructor call as an argument"
   assert r.at(0).length() == 2
   s := List(List("a"))
   assert s.at(0).at(0) == "a"
+test "a generic record is specialized per type and its methods run"
+  assert GenericBox(value: 9).getValue() == 9
+  assert GenericBox(value: "s").getValue() == "s"
+  assert unboxed(GenericBox(value: 11)) == 11
+test "a generic enum is specialized per type and matched"
+  assert intContentsOr(Delivered(13), 0) == 13
+  assert intContentsOr(Lost, 5) == 5
+  assert strContentsOr(Delivered("abcd"), 0) == 4
+  assert intContentsOr(Delivered(13), 0) + strContentsOr(Delivered("abcd"), 0) == 17

plum-examples/loops.plum CHANGED Viewed

@@ -63,16 +63,6 @@ test "break_continue_return_semantics"
   assert firstOver(xs, 3) == 4
   assert firstOver(xs, 9) == -1
-test "times and until loops"
-  total := 0
-  for i := range 5
-    total = total + i
-  assert total == 10
-  count := 0
-  for i := range 4, if i == 1
-    count = count + 1
-  assert count == 1
 test "nested iterable loops"
   xs := List(1, 2)
   ys := List(10, 20)

plum-examples/map_struct_values.plum DELETED Viewed

@@ -1,21 +0,0 @@
-# Map with struct values (moved out of plum-std/Map.plum so MapPoint
-# does not become a global type for every importer of std/Map).
-import std/Map
-import std/Int
-import std/Float
-import std/Str
-struct MapPoint(x: Float, y: Float)
-test "Map[Int, MapPoint] struct values"
-  m := Map[Int, MapPoint]()
-  i := 0
-  while i < 500
-    m.set(i, MapPoint(x: Float(i), y: Float(i) * 2.0))
-    i = i + 1
-  v := m.get(499)!
-  assert v.x == 499.0
-  assert v.y == 998.0
-  m.set(499, MapPoint(x: 1.0, y: 2.0))
-  assert m.get(499)!.y == 2.0
-  assert m.length() == 500

plum-examples/maps.plum CHANGED Viewed

@@ -3,6 +3,9 @@
 import std/Int
 import std/Str
 import std/Map
+import std/Float
+struct MapPoint(x: Float, y: Float)
 test "maps_example_arrow_form"
   m := Map("ann" => 3, "bob" => 5)
@@ -12,17 +15,15 @@ test "maps_example_arrow_form"
 test "maps_mixed_pair_and_arrow"
   assert Map(Pair("a", 1), "b" => 2).length() == 2
-test "maps_duplicate_last_wins"
+test "Map[Int, MapPoint] struct values"
+  m := Map[Int, MapPoint]()
+  i := 0
+  while i < 500
-  m := Map("a" => 1, "a" => 2)
+    m.set(i, MapPoint(x: Float(i), y: Float(i) * 2.0))
+    i = i + 1
+  v := m.get(499)!
+  assert v.x == 499.0
+  assert v.y == 998.0
+  m.set(499, MapPoint(x: 1.0, y: 2.0))
-  assert m.get("a")! == 2
+  assert m.get(499)!.y == 2.0
-  assert m.length() == 1
+  assert m.length() == 500
-test "maps_nested"
-  m := Map("a" => Map("x" => 1))
-  assert m.get("a")!.get("x")! == 1
-test "maps_int_keys"
-  assert Map(1 => "one", 2 => "two").get(1)! == "one"
-test "maps_empty_with_explicit_generics"
-  assert Map[Str, Int]().isEmpty()

plum-examples/match.plum CHANGED Viewed

@@ -1,5 +1,8 @@
-# Pattern matching: exhaustive `match` expressions over enum variants, integer
+# Pattern matching. `match` is exhaustive over an enum and supports literals,
+# bindings, wildcards, constructor patterns (nested), multiple subjects and
+# `when` guards. Pattern `if` (`if Circle(r) := shape`) tests one case with the
+# same patterns and reads like an ordinary `if` chain; use `match` when every
-# values, and wildcard `_` patterns with guards.
+# case needs handling and you want the exhaustiveness check.
 import std/Int
 import std/Float
 import std/Str
@@ -20,18 +23,13 @@ fun describeBool(b: Bool) -> Int =
     true => 1
     false => 0
-fun bindExample(n: Int) -> Int =
-  match n
-    x => x
 fun describeColor(c: Color) -> Str =
   match c
     Red => "red"
     Green => "green"
     Blue => "blue"
-# A dedicated, non-generic "maybe an Int", as opposed to the generic
+# A non-generic "maybe an Int", next to the generic `Reading[T]` below.
-# generic `Reading[T]` (used elsewhere in this file).
 enum IntOpt = Present | Absent
 record Present(v: Int)
@@ -41,11 +39,6 @@ fun describeOption(opt: IntOpt) -> Int =
     Present(v) => v
     Absent => 0
-fun main() -> Int =
-  describeOption(Present(5))
-# ---- pattern matching regression tests ----
 enum Nested = Wrap | Empty
 record Wrap(v: IntOpt)
@@ -84,25 +77,12 @@ fun unwrapTwice(o: RecOption) -> Int =
     RNone => 3
     _ => 0
-fun classifyForWildcardTest(a: Int) -> Int =
-  match a
-    1 => 100
-    2 => 200
-    _ => 0
-fun colorCode(c: Color) -> Int =
-  match c
-    Red => 1
-    Green => 2
-    Blue => 3
 fun isSome(o: Reading[Int]) -> Int =
   match o
     Sample(_) => 1
     NoSignal => 0
-# Mirrors libs/std/bool.plum's `and`/`or`: `match a, b` against two Bool
-# subjects, each case naming a tag pattern per position.
+# `match a, b` against two subjects, each case giving one pattern per position.
 fun and(a: Bool, b: Bool) -> Bool =
   match a, b
     true, true => true
@@ -146,37 +126,143 @@ record Point(x: Int, y: Int) =
       Point(x, 0) => "on x axis"
       Point(_, _) => "elsewhere"
-enum Shape =
-  | Circle
-  | Square
-  fun measure(self) -> Int =
-    match self
-      Circle(Point(x, y)) => x + y
-      Square(Point(x, y)) => x * y
-record Circle(v: Point)
-record Square(v: Point)
-# Named payload fields (`Ring(radius: Int)`) alongside the
-# unnamed-positional-payload form (`Circle(Point)` above) — lets a
-# multi-field variant like `Rect` name each field instead of leaving them as
-# anonymous positional types. Pattern matching is unaffected either way
-# (still positional, by declaration order — `Rect(w, h)`, not `Rect(w:, h:)`).
-enum Figure =
-  | Ring
-  | Rect
-  fun area(self) -> Int =
-    match self
-      Ring(radius) => radius * radius
-      Rect(w, h) => w * h
-record Ring(radius: Int)
-record Rect(w: Int, h: Int)
-test "match example computes correctly"
-  assert main() == 5
+enum Placed = Disc | Plate
+record Disc(v: Point)
+record Plate(v: Point)
+fun measure(p: Placed) -> Int =
+  match p
+    Disc(Point(x, y)) => x + y
+    Plate(Point(x, y)) => x * y
+# ---- pattern `if` ----
+# Pattern `if`: `if Pattern := expr` binds the pattern's names for that branch.
+#
+#   if Circle(r) := shape          # one case, bindings scoped to this branch
+#   if Rect(w, h) := shape, w > h  # `, cond` also sees the bindings
+#   while Busy(t) := worker.state  # loops while the pattern matches
+#   if Circle(r) := s then r else 0.0
+#
+# A plain name over an optional (`x := opt`) keeps its meaning: bind when present.
+enum Shape = Circle | Rect | Dot
+record Circle(radius: Float)
+record Rect(w: Float, h: Float)
+struct Vec2(x: Int, y: Int)
+enum Job = Idle | Busy
+record Busy(left: Int)
+record Soldier(hp: Int, shape: Shape)
+fun area(s: Shape) -> Float =
+  if Circle(r) := s
+    return 3.0 * r * r
+  else if Rect(w, h) := s
+    return w * h
+  0.0
+fun wide(s: Shape) -> Str =
+  if Rect(w, h) := s, w > h
+    "wide"
+  else if Rect(w, h) := s, h > w
+    "tall"
+  else
+    "other"
+fun pick(s: Shape, o: Int?, n: Int) -> Str =
+  if Circle(r) := s
+    "circle"
+  else if v := o
+    "opt {v}"
+  else if n > 10
+    "big"
+  else if Rect(w, h) := s
+    "rect"
+  else
+    "none"
+fun radiusOr(s: Shape) -> Float =
+  if Circle(r) := s then r else 0.0
+fun shapeOf(u: Soldier) -> Str =
+  if Soldier(hp, Circle(r)) := u, hp > 0
+    "live circle {hp}"
+  else
+    "other"
+fun countDown(j: Job) -> Int =
+  steps := 0
+  state := j
+  while Busy(n) := state
+    steps = steps + 1
+    if n > 1
+      state = Busy(left: n - 1)
+    else
+      state = Idle
+  steps
+fun sumXY(v: Vec2) -> Int =
+  if Vec2(x, y) := v
+    return x + y
+  0
+fun parseSmall(s: Str) -> error{TooBig, NotNum}!Int =
+  n := Int.parse(s) catch return error.NotNum
+  if n > 9
+    return error.TooBig
+  n
+fun describe(s: Str) -> Str =
+  n := parseSmall(s) catch e
+    if TooBig := e
+      return "too big"
+    return "not a number"
+  "ok {n}"
+fun firstSome(a: Int?, b: Int?) -> Int =
+  if x := a
+    return x
+  else if y := b
+    return y + 1
+  -1
+fun bigOnly(a: Int?) -> Int =
+  if x := a, x > 3
+    return x
+  0
+# ---- guards: `when <expr>` ----
+enum Rating = Good | Bad
+record Good(name: Str)
+record Bad(name: Str)
+enum Book = FantasyBook | ScifiBook | ChildrensTaleBook | NonFictionBook
+record FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
+record ScifiBook(title: Str, pages: Int, theme: Str)
+record ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
+record NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)
+fun bookInfo(book: Book) -> Str =
+  match book
+    FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures => "Fantasy book \"{title}\" features mythical creatures"
+    FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
+    ScifiBook(title, _, theme) when theme == "space exploration" => "Scifi book \"{title}\" explores space exploration"
+    ScifiBook(title, _, theme) => "Scifi book \"{title}\" has theme {theme}"
+    ChildrensTaleBook(title, pages, _) when pages == 0 => "Childrens book \"{title}\" is empty"
+    ChildrensTaleBook(title, _, moralLesson) => "Childrens book \"{title}\" teaches: {moralLesson}"
+    NonFictionBook(title, _, rating1, rating2) =>
+      match rating1, rating2
+        Good(name1), Good(name2) => "Non-fiction book \"{title}\" praised by {name1} and {name2}"
+        _, _ => "Non-fiction book \"{title}\" has mixed reviews"
 test "nested constructor pattern matches and binds runs correctly"
   assert unwrapNested(Wrap(Present(5))) == 5
@@ -190,20 +276,18 @@ test "nested constructor pattern against a specialized generic enum runs correct
 test "doubly nested constructor pattern runs correctly"
   assert unwrapTwice(RSome(RSome(RNone))) == 1
-test "match int and wildcard run correctly"
+test "match literals, bool and wildcard"
-  assert classifyForWildcardTest(2) == 200
-test "match bool variant pattern runs correctly"
   assert describeBool(false) == 0
-test "non bool bare tag pattern runs correctly"
+  assert describeNumber(0) == "zero"
-  assert colorCode(Green) == 2
+  assert describeNumber(1) == "one"
+  assert describeNumber(2) == "many"
 test "constructor pattern wildcard field runs correctly"
   assert isSome(Sample(99)) == 1
+  assert isSome(NoSignal) == 0
-test "constructor pattern does not misfire on payload free sibling"
+  assert describeOption(Present(5)) == 5
   assert describeOption(Absent) == 0
+  assert describeColor(Green) == "green"
 test "multi subject match with enum tags runs correctly"
   assert andOrCheck() == 1
@@ -229,16 +313,8 @@ test "match on a plain class supports literal/wildcard sub-patterns and case fal
   assert Point(x: 5, y: 5).classify() == "elsewhere"
 test "a plain class nested inside an enum variant pattern destructures correctly"
-  assert Circle(Point(x: 3, y: 4)).measure() == 7
+  assert measure(Disc(Point(x: 3, y: 4))) == 7
-  assert Square(Point(x: 3, y: 4)).measure() == 12
+  assert measure(Plate(Point(x: 3, y: 4))) == 12
-test "named-payload enum variant constructs via named args and destructures by position"
-  assert Ring(radius: 5).area() == 25
-  assert Rect(w: 3, h: 4).area() == 12
-test "named-payload enum variant still supports positional construction too"
-  assert Ring(5).area() == 25
-  assert Rect(3, 4).area() == 12
 test "a pattern name reused with different types in one fn"
   r := Sample(1)
@@ -253,3 +329,76 @@ test "a pattern name reused with different types in one fn"
       assert v == "z"
     _ =>
       assert false
+test "if_pattern_enum_variant"
+  assert area(Circle(radius: 2.0)) == 12.0
+  assert area(Rect(w: 2.0, h: 3.0)) == 6.0
+  assert area(Dot) == 0.0
+test "else_if_pattern_chain"
+  assert pick(Circle(radius: 1.0), null, 0) == "circle"
+  assert pick(Dot, 4, 0) == "opt 4"
+  assert pick(Dot, null, 11) == "big"
+  assert pick(Rect(w: 1.0, h: 1.0), null, 0) == "rect"
+  assert pick(Dot, null, 0) == "none"
+test "pattern_with_trailing_condition"
+  assert wide(Rect(w: 3.0, h: 1.0)) == "wide"
+  assert wide(Rect(w: 1.0, h: 3.0)) == "tall"
+  assert wide(Rect(w: 1.0, h: 1.0)) == "other"
+  assert wide(Dot) == "other"
+test "nested_pattern_if"
+  assert shapeOf(Soldier(hp: 5, shape: Circle(radius: 1.0))) == "live circle 5"
+  assert shapeOf(Soldier(hp: 0, shape: Circle(radius: 1.0))) == "other"
+  assert shapeOf(Soldier(hp: 5, shape: Dot)) == "other"
+test "inline_pattern_if"
+  assert radiusOr(Circle(radius: 2.5)) == 2.5
+  assert radiusOr(Dot) == 0.0
+test "while_pattern"
+  assert countDown(Busy(left: 3)) == 3
+  assert countDown(Idle) == 0
+test "else_if_optional_binding"
+  assert firstSome(null, 7) == 8
+  assert firstSome(2, 7) == 2
+  assert firstSome(null, null) == -1
+test "irrefutable_pattern_if_allowed"
+  assert sumXY(Vec2(x: 3, y: 4)) == 7
+test "error_name_pattern_in_catch_block"
+  assert describe("5") == "ok 5"
+  assert describe("50") == "too big"
+  assert describe("x") == "not a number"
+test "optional_binding_with_trailing_condition"
+  assert bigOnly(5) == 5
+  assert bigOnly(2) == 0
+  assert bigOnly(null) == 0
+test "when guard picks between two cases of the same member"
+  mythic := FantasyBook(title: "Dragon Tales", pages: 200, hasMythicalCreatures: true)
+  plain := FantasyBook(title: "Plain Fantasy", pages: 150, hasMythicalCreatures: false)
+  assert bookInfo(mythic) == "Fantasy book \"Dragon Tales\" features mythical creatures"
+  assert bookInfo(plain) == "Fantasy book \"Plain Fantasy\" has no mythical creatures"
+test "a false guard falls through to the next case"
+  space := ScifiBook(title: "Starbound", pages: 300, theme: "space exploration")
+  other := ScifiBook(title: "Timeloop", pages: 250, theme: "time travel")
+  assert bookInfo(space) == "Scifi book \"Starbound\" explores space exploration"
+  assert bookInfo(other) == "Scifi book \"Timeloop\" has theme time travel"
+test "a guard can test a field of the matched member"
+  empty := ChildrensTaleBook(title: "Nothing", pages: 0, moralLesson: "none")
+  tale := ChildrensTaleBook(title: "The Tortoise", pages: 40, moralLesson: "patience wins")
+  assert bookInfo(empty) == "Childrens book \"Nothing\" is empty"
+  assert bookInfo(tale) == "Childrens book \"The Tortoise\" teaches: patience wins"
+test "nested constructor patterns and a nested multi-subject match"
+  good := NonFictionBook(title: "Hidden Facts", pages: 120, rating1: Good(name: "Alice"), rating2: Good(name: "Bob"))
+  mixed := NonFictionBook(title: "Shaky Claims", pages: 80, rating1: Good(name: "Alice"), rating2: Bad(name: "Carol"))
+  assert bookInfo(good) == "Non-fiction book \"Hidden Facts\" praised by Alice and Bob"
+  assert bookInfo(mixed) == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/methods.plum DELETED Viewed

@@ -1,31 +0,0 @@
-# Methods: defining methods inside type bodies with `self`, accessing and
-# mutating fields, and calling methods on instances.
-import std/Str
-import std/Int
-import std/Float
-record Cat(name: Str, age: Int) =
-  fun getAge(self) -> Int =
-    self.age
-  fun birthday(self) -> Int =
-    self.age + 1
-record Wrapper(inner: Cat, tag: Int) =
-  fun innerAge(self) -> Int =
-    self.inner.age
-fun makeCat() -> Cat =
-  Cat(name: "Whiskers", age: 3)
-fun main() -> Int =
-  c := makeCat()
-  a := c.getAge()
-  b := c.birthday()
-  w := Wrapper(inner: c, tag: 1)
-  a + b + w.innerAge()
-test "methods example computes correctly"
-  assert main() == 10

plum-examples/oop_visitor.plum DELETED Viewed

@@ -1,117 +0,0 @@
-# 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 —
-# the direct translation of the blog post's Java (sealed interface implemented
-# by records, each overriding a method).
-# Based on: https://wimdetroyer.com/blog/visitor-pattern-in-dop
-#
-# One real limitation this example runs into: plum has no interfaces and no
-# runtime dispatch. Generics are duck-typed per instantiation, so a function
-# 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
-# `describe(book: Book)` entry point here — each concrete type's method is
-# 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 single-variant `enum`) is self-contained
-#     here and doesn't touch existing types. In the DOP version it means
-#     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 shape
-#     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 an interface (see above)
-#     removes OOP's usual "call through one interface" benefit entirely,
-#     which is a real cost specific to this language.
-import std/Os
-import std/Int
-import std/Float
-import std/Str
-enum Rating = Good | Bad
-record Good(name: Str)
-record Bad(name: Str)
-record FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool) =
-  fun collectInterestingInfo(self) -> Str =
-    if self.hasMythicalCreatures
-      "Fantasy book \"{self.title}\" features mythical creatures"
-    else
-      "Fantasy book \"{self.title}\" has no mythical creatures"
-record ScifiBook(title: Str, pages: Int, theme: Str) =
-  fun collectInterestingInfo(self) -> Str =
-    if self.theme == "space exploration"
-      "Scifi book \"{self.title}\" explores space exploration"
-    else
-      "Scifi book \"{self.title}\" has theme {self.theme}"
-record ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str) =
-  fun collectInterestingInfo(self) -> Str =
-    if self.pages == 0
-      "Childrens book \"{self.title}\" is empty"
-    else
-      "Childrens book \"{self.title}\" teaches: {self.moralLesson}"
-record NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating) =
-  fun collectInterestingInfo(self) -> Str =
-    match self.rating1, self.rating2
-      Good(name1), Good(name2) => "Non-fiction book \"{self.title}\" praised by {name1} and {name2}"
-      _, _ => "Non-fiction book \"{self.title}\" has mixed reviews"
-fun describeFantasy() -> Str =
-  FantasyBook(title: "Dragon Tales", pages: 200, hasMythicalCreatures: true).collectInterestingInfo()
-fun main() =
-  printLn(describeFantasy())
-test "fantasy book with mythical creatures is called out"
-  assert describeFantasy() == "Fantasy book \"Dragon Tales\" features mythical creatures"
-test "fantasy book without mythical creatures is called out"
-  book := FantasyBook(title: "Plain Fantasy", pages: 150, hasMythicalCreatures: false)
-  assert book.collectInterestingInfo() == "Fantasy book \"Plain Fantasy\" has no mythical creatures"
-test "scifi book with space exploration theme is called out"
-  book := ScifiBook(title: "Starbound", pages: 300, theme: "space exploration")
-  assert book.collectInterestingInfo() == "Scifi book \"Starbound\" explores space exploration"
-test "scifi book with other theme falls through to generic case"
-  book := ScifiBook(title: "Timeloop", pages: 250, theme: "time travel")
-  assert book.collectInterestingInfo() == "Scifi book \"Timeloop\" has theme time travel"
-test "empty childrens book is handled via a plain if on pages"
-  book := ChildrensTaleBook(title: "Nothing", pages: 0, moralLesson: "none")
-  assert book.collectInterestingInfo() == "Childrens book \"Nothing\" is empty"
-test "childrens book with pages reports its moral lesson"
-  book := ChildrensTaleBook(title: "The Tortoise", pages: 40, moralLesson: "patience wins")
-  assert book.collectInterestingInfo() == "Childrens book \"The Tortoise\" teaches: patience wins"
-test "non fiction book praised by both reviewers via nested match"
-  book := NonFictionBook(
-    title: "Hidden Facts",
-    pages: 120,
-    rating1: Good(name: "Alice"),
-    rating2: Good(name: "Bob"),
-  )
-  assert book.collectInterestingInfo() == "Non-fiction book \"Hidden Facts\" praised by Alice and Bob"
-test "non fiction book with a bad rating reports mixed reviews"
-  book := NonFictionBook(
-    title: "Shaky Claims",
-    pages: 80,
-    rating1: Good(name: "Alice"),
-    rating2: Bad(name: "Carol"),
-  )
-  assert book.collectInterestingInfo() == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/optionals.plum CHANGED Viewed

@@ -1,10 +1,16 @@
 import std/Int
 import std/Str
 import std/List
+import std/Float
 # Optionals: `T?` is a `T` or `null`. A plain `T` in a `T?` slot is the present
 # value. An optional is handled with `?:` (Kotlin elvis), `if x := opt`,
 # `while x := opt`, `opt!` (crashes on null) and `opt == null`; `catch` and `try`
 # are for errors only. `!T?` is an error union whose success value is an optional.
+#
+# `obj?.field` / `obj?.method(args)` is safe navigation: it reaches into an
+# optional without unwrapping it and passes null through. A field that is itself
+# a `T?` flattens, so `u?.target?.name` is one `Str?`. It is sugar for
+# `obj.andThen(|v| v.field)`.
 record Box(label: Str)
@@ -56,6 +62,39 @@ fun sparse() -> List[Int?] =
 fun sumBig() -> Int =
   Int.MAX + Int.MIN
+record Person(name: Str, age: Int) =
+  fun birthday(self) -> Int =
+    self.age + 1
+record Target(name: Str)
+record User(name: Str, target: Target?)
+fun personName(p: Person?) -> Str? =
+  p?.name
+fun personBirthday(p: Person?) -> Int? =
+  p?.birthday()
+fun somePerson() -> Person? =
+  Person(name: "Ann", age: 3)
+fun noPerson() -> Person? =
+  return null
+fun noTarget() -> Target? =
+  return null
+fun maybeCount(n: Int? = null) -> Int? =
+  n
+fun noUser() -> User? =
+  return null
+fun targetName(u: User?) -> Str? =
+  u?.target?.name
 test "null_return_absent"
   assert maybeBox(false) == null
   assert maybeBox(true) != null
@@ -160,3 +199,34 @@ test "reassigning an optional local or field to null or a value"
   h.item = Box(label: "y")
   assert h.count! == 5
   assert h.item!.label == "y"
+test "safe navigation maps a field access over a present value, passes absence through"
+  assert personName(somePerson())! == "Ann"
+  assert {personName(noPerson()) ?: "gone"} == "gone"
+test "safe navigation maps a method call over a present value"
+  assert personBirthday(somePerson())! == 4
+  assert {personBirthday(noPerson()) ?: -1} == -1
+test "safe navigation chains through a nullable field"
+  full := User(name: "u", target: Target(name: "home"))
+  assert {targetName(full) ?: "none"} == "home"
+  assert {targetName(User(name: "v", target: noTarget())) ?: "none"} == "none"
+  assert {targetName(noUser()) ?: "none"} == "none"
+test "?: handles a nullable with a diverging or computed default"
+  p := somePerson() ?: crash "missing"
+  assert p.age == 3
+  q := noPerson() ?: Person(name: "gone", age: 1)
+  assert q.name == "gone"
+test "null is the absent value in an argument, a list element and a default"
+  u := User(name: "w", target: null)
+  assert {targetName(u) ?: "none"} == "none"
+  xs := sparse()
+  second := xs.get(1)!
+  assert {second ?: 9} == 9
+  first := xs.get(0)!
+  assert first! == 1
+  assert {maybeCount() ?: 5} == 5
+  assert maybeCount(7)! == 7

plum-examples/pattern_if.plum DELETED Viewed

@@ -1,153 +0,0 @@
-import std/Int
-import std/Float
-import std/Str
-# Pattern `if`: `if Pattern := expr` tests one case of an enum (or a literal, an
-# error name, a nested pattern) and binds the pattern's names for that branch.
-# It reads like an ordinary `if`/`else if`/`else` chain. Use `match` when every
-# case needs handling and you want the exhaustiveness check.
-#
-#   if Circle(r) := shape          # one case, bindings scoped to this branch
-#   if Rect(w, h) := shape, w > h  # `, cond` also sees the bindings
-#   while Busy(t) := worker.state  # loops while the pattern matches
-#   if Circle(r) := s then r else 0.0
-#
-# A plain name over an optional (`x := opt`) keeps its meaning: bind when present.
-enum Shape = Circle | Rect | Dot
-record Circle(radius: Float)
-record Rect(w: Float, h: Float)
-struct Vec2(x: Int, y: Int)
-enum Job = Idle | Busy
-record Busy(left: Int)
-record Soldier(hp: Int, shape: Shape)
-fun area(s: Shape) -> Float =
-  if Circle(r) := s
-    return 3.0 * r * r
-  else if Rect(w, h) := s
-    return w * h
-  0.0
-fun wide(s: Shape) -> Str =
-  if Rect(w, h) := s, w > h
-    "wide"
-  else if Rect(w, h) := s, h > w
-    "tall"
-  else
-    "other"
-fun pick(s: Shape, o: Int?, n: Int) -> Str =
-  if Circle(r) := s
-    "circle"
-  else if v := o
-    "opt {v}"
-  else if n > 10
-    "big"
-  else if Rect(w, h) := s
-    "rect"
-  else
-    "none"
-fun radiusOr(s: Shape) -> Float =
-  if Circle(r) := s then r else 0.0
-fun shapeOf(u: Soldier) -> Str =
-  if Soldier(hp, Circle(r)) := u, hp > 0
-    "live circle {hp}"
-  else
-    "other"
-fun countDown(j: Job) -> Int =
-  steps := 0
-  state := j
-  while Busy(n) := state
-    steps = steps + 1
-    if n > 1
-      state = Busy(left: n - 1)
-    else
-      state = Idle
-  steps
-fun sumXY(v: Vec2) -> Int =
-  if Vec2(x, y) := v
-    return x + y
-  0
-fun parseSmall(s: Str) -> error{TooBig, NotNum}!Int =
-  n := Int.parse(s) catch return error.NotNum
-  if n > 9
-    return error.TooBig
-  n
-fun describe(s: Str) -> Str =
-  n := parseSmall(s) catch e
-    if TooBig := e
-      return "too big"
-    return "not a number"
-  "ok {n}"
-fun firstSome(a: Int?, b: Int?) -> Int =
-  if x := a
-    return x
-  else if y := b
-    return y + 1
-  -1
-fun bigOnly(a: Int?) -> Int =
-  if x := a, x > 3
-    return x
-  0
-test "if_pattern_enum_variant"
-  assert area(Circle(radius: 2.0)) == 12.0
-  assert area(Rect(w: 2.0, h: 3.0)) == 6.0
-  assert area(Dot) == 0.0
-test "else_if_pattern_chain"
-  assert pick(Circle(radius: 1.0), null, 0) == "circle"
-  assert pick(Dot, 4, 0) == "opt 4"
-  assert pick(Dot, null, 11) == "big"
-  assert pick(Rect(w: 1.0, h: 1.0), null, 0) == "rect"
-  assert pick(Dot, null, 0) == "none"
-test "pattern_with_trailing_condition"
-  assert wide(Rect(w: 3.0, h: 1.0)) == "wide"
-  assert wide(Rect(w: 1.0, h: 3.0)) == "tall"
-  assert wide(Rect(w: 1.0, h: 1.0)) == "other"
-  assert wide(Dot) == "other"
-test "nested_pattern_if"
-  assert shapeOf(Soldier(hp: 5, shape: Circle(radius: 1.0))) == "live circle 5"
-  assert shapeOf(Soldier(hp: 0, shape: Circle(radius: 1.0))) == "other"
-  assert shapeOf(Soldier(hp: 5, shape: Dot)) == "other"
-test "inline_pattern_if"
-  assert radiusOr(Circle(radius: 2.5)) == 2.5
-  assert radiusOr(Dot) == 0.0
-test "while_pattern"
-  assert countDown(Busy(left: 3)) == 3
-  assert countDown(Idle) == 0
-test "else_if_optional_binding"
-  assert firstSome(null, 7) == 8
-  assert firstSome(2, 7) == 2
-  assert firstSome(null, null) == -1
-test "irrefutable_pattern_if_allowed"
-  assert sumXY(Vec2(x: 3, y: 4)) == 7
-test "error_name_pattern_in_catch_block"
-  assert describe("5") == "ok 5"
-  assert describe("50") == "too big"
-  assert describe("x") == "not a number"
-test "optional_binding_with_trailing_condition"
-  assert bigOnly(5) == 5
-  assert bigOnly(2) == 0
-  assert bigOnly(null) == 0

plum-examples/safe_navigation.plum DELETED Viewed

@@ -1,91 +0,0 @@
-import std/Int
-import std/Float
-import std/Str
-import std/List
-# `T?` is an optional: a `T` or `null`. A plain `T` where a `T?` is expected is
-# the present value. For a reference type (class, enum, Str, List, ...) a `T?` is
-# stored as a nullable reference, so a present value costs no allocation. An
-# optional is handled with `?:`, `!`, `if x := opt` and `== null`; `catch` and
-# `try` are for errors only.
-#
-# `null` is a plain VALUE wherever a `T?` is expected (a call or constructor
-# argument, a list element, a default, `return null`).
-#
-# `obj?.field` / `obj?.method(args)` -- Groovy/Kotlin-style safe navigation.
-# Reaches into an optional's value without unwrapping it and re-wraps the
-# result; null passes through untouched. A field that is itself a `T?`
-# flattens, so `u?.target?.name` is one `Str?`, not a nested one.
-# Pure sugar for `obj.andThen(|v| v.field)`, desugared entirely in the parser
-# (see `plum-core`'s `parseSafeAttribute`).
-record Person(name: Str, age: Int) =
-  fun birthday(self) -> Int =
-    self.age + 1
-record Target(name: Str)
-record User(name: Str, target: Target?)
-fun personName(p: Person?) -> Str? =
-  p?.name
-fun personBirthday(p: Person?) -> Int? =
-  p?.birthday()
-fun somePerson() -> Person? =
-  Person(name: "Ann", age: 3)
-fun noPerson() -> Person? =
-  return null
-fun noTarget() -> Target? =
-  return null
-fun maybeCount(n: Int? = null) -> Int? =
-  n
-fun sparse() -> List[Int?] =
-  List(1, null, 3)
-fun noUser() -> User? =
-  return null
-fun targetName(u: User?) -> Str? =
-  u?.target?.name
-test "safe navigation maps a field access over a present value, passes absence through"
-  assert personName(somePerson())! == "Ann"
-  assert {personName(noPerson()) ?: "gone"} == "gone"
-test "safe navigation maps a method call over a present value"
-  assert personBirthday(somePerson())! == 4
-  assert {personBirthday(noPerson()) ?: -1} == -1
-test "safe navigation chains through a nullable field"
-  full := User(name: "u", target: Target(name: "home"))
-  assert {targetName(full) ?: "none"} == "home"
-  assert {targetName(User(name: "v", target: noTarget())) ?: "none"} == "none"
-  assert {targetName(noUser()) ?: "none"} == "none"
-test "?: gives a default for a missing value"
-  assert {personName(noPerson()) ?: "nobody"} == "nobody"
-  assert {personName(somePerson()) ?: "nobody"} == "Ann"
-test "?: handles a nullable with a diverging or computed default"
-  p := somePerson() ?: crash "missing"
-  assert p.age == 3
-  q := noPerson() ?: Person(name: "gone", age: 1)
-  assert q.name == "gone"
-test "null is the absent value in an argument, a list element and a default"
-  u := User(name: "w", target: null)
-  assert {targetName(u) ?: "none"} == "none"
-  xs := sparse()
-  assert xs.length() == 3
-  second := xs.get(1)!
-  assert {second ?: 9} == 9
-  first := xs.get(0)!
-  assert first! == 1
-  assert {maybeCount() ?: 5} == 5
-  assert maybeCount(7)! == 7

plum-examples/seq.plum CHANGED Viewed

@@ -1,5 +1,5 @@
-# Sequence adapters and terminals: using `std/Seq` methods (`take`, `skip`,
+# Sequence adapters, terminals and chains: using `std/Seq` methods (`take`,
-# `map`, `filter`, `find`, `fold`) to process collections in `for` loops.
+# `skip`, `map`, `filter`, `find`, `fold`) to process collections in `for` loops.
 import std/Int
 import std/Float
 import std/List
@@ -13,6 +13,40 @@ import std/Str
 # count, any, all, each, firstN, toList) take the `for` body and end the chain.
 # A whole chain is ONE loop: no closure, no intermediate List.
+# Closure-free chains. A method chain such as
+#
+#   keep my team's units, take their hp, sum it
+#
+# becomes ONE `for` over the sequence:
+#
+#   * per-element stages are header clauses: filter = `, if cond`,
+#     map = `, name := expr`;
+#   * the terminal step is the outer form plus its body (fold, map, find, count,
+#     any, all);
+#   * body-less stages nest as `fun*` sources (take, skip, zip, reversed,
+#     chunks, stepBy), and always fuse into the same single loop;
+#   * materializing stages (sort, group) are separate statements.
+#
+# No closure is allocated and there is no call_indirect: the wasm is the loop you
+# would have written by hand. See plum-std/Seq.plum.
+record Soldier(name: Str, team: Int, hp: Float, x: Float, y: Float)
+fun dist2(ax: Float, ay: Float, bx: Float, by: Float) -> Float =
+  dx := ax - bx
+  dy := ay - by
+  dx * dx + dy * dy
+fun army() -> List[Soldier] =
+  List(
+    Soldier(name: "a", team: 1, hp: 10.0, x: 0.0, y: 0.0),
+    Soldier(name: "b", team: 2, hp: 0.0, x: 1.0, y: 1.0),
+    Soldier(name: "c", team: 1, hp: 7.0, x: 5.0, y: 5.0),
+    Soldier(name: "d", team: 2, hp: 3.0, x: 2.0, y: 0.0),
+    Soldier(name: "e", team: 1, hp: 4.0, x: 9.0, y: 9.0),
+    Soldier(name: "f", team: 2, hp: 8.0, x: 1.0, y: 0.0),
+  )
 test "seq_method_filter: a List has no filter of its own, so Seq.filter is used"
   xs := List(1, 2, 3, 4, 5, 6)
   evens := for x := range xs.filter()
@@ -144,3 +178,59 @@ test "range_map_entries: two binders over a Map"
   for k, v := range m
     total = total + k * v
   assert total == 50
+# ---- chains: several stages fused into one loop ----
+test "sum of hp of my team: filter + map + sum is a fold with clauses"
+  units := army()
+  me := units.at(0)
+  # units.filter(team == me).map(hp).sum()
+  total := for acc, u := range units.fold(0.0), if u.team == me.team, hp := u.hp
+    acc + hp
+  assert total == 21.0
+test "names of living units within range: filter + map + filter + map"
+  units := army()
+  me := units.at(0)
+  reach := 5.0
+  names := for u := range units.map(), if u.hp > 0.0, d := dist2(u.x, u.y, me.x, me.y), if d < reach
+    u.name
+  assert names.length() == 3
+  assert names.at(0) == "a"
+  assert names.at(1) == "d"
+  assert names.at(2) == "f"
+test "first enemy in range: filter + find"
+  units := army()
+  me := units.at(0)
+  near := for u := range units.find(), if u.team != me.team
+    dist2(u.x, u.y, me.x, me.y) < 4.0
+  first := near ?: me
+  assert first.name == "b"
+test "take + map: the first five living units"
+  units := army()
+  lines := for u := range units.take(5).map(), if u.hp > 0.0
+    u.name
+  assert lines.length() == 4
+  assert lines.at(0) == "a"
+  assert lines.at(3) == "e"
+test "count and any over a chain"
+  units := army()
+  alive := for u := range units.skip(1).count(), if u.team == 2
+    u.hp > 0.0
+  assert alive == 2
+  anyBig := for u := range units.stepBy(2).any()
+    u.hp > 9.0
+  assert anyBig
+test "materializing stages are separate statements"
+  units := army()
+  alive := for u := range units.filter()
+    u.hp > 0.0
+  assert alive.length() == 5
+  # a later stage runs over the materialized list
+  hps := for u := range alive.map(), if u.team == 1
+    u.hp
+  assert hps.length() == 3

plum-examples/shapes.plum DELETED Viewed

@@ -1,30 +0,0 @@
-import std/Str
-import std/Int
-import std/Float
-# A closed set of shapes as one enum: mixed kinds live in a single type and
-# `match` picks the behavior per variant.
-enum Shape =
-  | Circle
-  | Rect
-  fun area(self) -> Float =
-    match self
-      Circle(r) => r * r * 3.0
-      Rect(w, h) => w * h
-  fun name(self) -> Str =
-    match self
-      Circle(r) => "circle"
-      Rect(w, h) => "rect"
-record Circle(r: Float)
-record Rect(w: Float, h: Float)
-test "area dispatches on the variant"
-  assert Circle(r: 1.5).area() == 6.75
-  assert Rect(w: 2.0, h: 3.0).area() == 6.0
-test "name dispatches on the variant"
-  assert Circle(r: 1.0).name() == "circle"
-  assert Rect(w: 1.0, h: 1.0).name() == "rect"

plum-examples/strings.plum CHANGED Viewed

@@ -1,8 +1,9 @@
-# Strings: string literals, interpolation `"{var}"`, and Unicode codepoint/rune
+# Strings: string literals and interpolation `"{expr}"`, which accepts any
-# inspection methods.
+# expression (a variable, `&&`/`||`, a method call, an inline `if`).
 import std/Int
 import std/Float
 import std/Str
+import std/List
 fun greet(name: Str) -> Str =
   "Hello, {name}!"
@@ -15,3 +16,54 @@ fun empty() -> Str =
 fun escaped() -> Str =
   "line one\nline two\ttabbed \"quoted\""
+test "string interpolation of an int runs correctly"
+  x := 42
+  assert "{x}" == "42"
+test "string interpolation of a negative int runs correctly"
+  x := -7
+  assert "{x}" == "-7"
+test "string interpolation of zero runs correctly"
+  x := 0
+  assert "{x}" == "0"
+test "string interpolation with surrounding text and multiple interps runs correctly"
+  count := 3
+  total := 10
+  assert "{count} of {total} complete" == "3 of 10 complete"
+test "string interpolation of a str runs correctly"
+  assert greet("World") == "Hello, World!"
+test "string interpolation of a bool runs correctly"
+  b := true
+  assert "is {b}" == "is true"
+test "string interpolation supports a boolean expression, not just a bare variable"
+  c1 := true
+  c2 := true
+  c3 := false
+  assert "{c1 && c2}" == "true"
+  assert "{c1 && c3}" == "false"
+  assert "{c1 || c3}" == "true"
+test "string interpolation supports a method call taking a closure literal"
+  l := List(1, 2, 3, 4)
+  assert "{l.findValue(3)!}" == "3"
+  assert "{l.contains(100)}" == "false"
+test "string interpolation supports an inline if expression"
+  n := 5
+  assert "{if n > 0 then "positive" else "non-positive"}" == "positive"
+# ---- Str method regression tests ----

plum-examples/{values.plum → structs_records.plum} RENAMED Viewed

@@ -1,15 +1,15 @@
-# Structs: small copy-semantics value types declared with `struct`,
+# Structs and records: `struct` is a small copy-semantics value type (flattened
-# lowered without heap allocation, supporting duck-typed operators.
+# into wasm locals, no heap allocation); `record` is a reference type shared on
+# assignment. Both have named fields, methods, constants, positional or named
+# construction, field mutation and spread update (`Point(..p, x: 1)`).
-module values
+module structs_records
 import std/Str
 import std/Int
 import std/Float
-import std/List
 import std/Map
-# `struct`: one constructor named like the type, fields Int/Float/Bool or
-# other structs. Values are copied on assignment/pass and flattened into
+# ---- struct: value semantics ----
-# wasm locals; they are boxed only inside generic containers.
 struct Vec2(x: Float, y: Float) =
   fun add(self, o: Vec2) -> Vec2 =
@@ -79,19 +79,51 @@ fun bump(v: Vec2) -> Float =
   v.x = v.x + 100.0
   v.x
+# ---- record: reference semantics ----
+record Point(x: Int, y: Int)
+# `self` is implicit inside a record body, or can be written out.
+record Cat(name: Str, age: Int) =
+  fun getAge() -> Int =
+    self.age
+  fun birthday(self) -> Int =
+    self.age + 1
+record Wrapper(inner: Cat, tag: Int) =
+  fun innerAge(self) -> Int =
+    self.inner.age
+record LoopBox(v: Int)
+fun sumLoopBoxes() -> Int =
+  total := 0
+  for i := range 5
+    b := LoopBox(v: i)
+    total = total + b.v
+  return total
+fun methodsTotal() -> Int =
+  c := Cat(name: "Whiskers", age: 3)
+  w := Wrapper(inner: c, tag: 1)
+  c.getAge() + c.birthday() + w.innerAge()
-test "value_copy_semantics"
+test "struct assignment copies"
   a := Vec2(x: 1.0, y: 2.0)
   b := a
   b.x = 9.0
   assert a.x == 1.0
   assert b.x == 9.0
-test "value_param_is_a_copy"
+test "struct param is a copy"
   a := Vec2(x: 1.0, y: 2.0)
   assert bump(a) == 101.0
   assert a.x == 1.0
-test "value_multi_value_return"
+test "struct returns"
   v := makeVec(3.0, 4.0)
   assert v.x == 3.0
   assert v.y == 4.0
@@ -99,37 +131,27 @@ test "value_multi_value_return"
   assert s.x == 4.0
   assert s.y == 3.0
-test "value_method_calls"
+test "struct methods and statics"
   v := Vec2(x: 3.0, y: 4.0)
   assert v.len2() == 25.0
   assert v.add(Vec2(x: 1.0, y: 1.0)).x == 4.0
+  assert Vec2.zero().x == 0.0
-test "value_in_list_roundtrip"
-  l := List[Vec2]()
-  l.push(Vec2(x: 1.0, y: 2.0))
-  l.push(Vec2(x: 3.0, y: 4.0))
-  assert l.length() == 2
-  first := l.get(0)!
-  second := l.get(1)!
-  assert first.x == 1.0
-  assert second.y == 4.0
-test "value_eq_fieldwise"
+test "struct equality is field-wise"
   a := Vec2(x: 1.0, y: 2.0)
   assert a == Vec2(x: 1.0, y: 2.0)
   assert a != Vec2(x: 1.0, y: 3.0)
-test "value_nested_flatten"
+test "nested structs flatten and copy deeply"
   r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))
   assert r.pos.y == 2.0
-  assert r.size.x == 3.0
   assert r.area() == 12.0
   r2 := r
   r2.pos.x = 7.0
   assert r.pos.x == 1.0
   assert r2.pos.x == 7.0
-test "value_mixed_fields"
+test "struct with Int, Bool and struct fields"
   c := Cell(pos: Vec2(x: 1.0, y: 2.0), solid: true, tint: Color(r: 1, g: 2, b: 3, a: 4))
   assert c.solid
   assert c.tint.b == 3
@@ -138,37 +160,32 @@ test "value_mixed_fields"
   assert c.tint.b == 3
   assert d.tint.b == 30
-test "value_operator_add_mul"
+test "struct operators call add and mul"
-  a := Vec2(x: 1.0, y: 2.0)
+  r := Vec2(x: 1.0, y: 2.0) + Vec2(x: 3.0, y: 4.0) * 2.0
-  b := Vec2(x: 3.0, y: 4.0)
-  r := a + b * 2.0
   assert r.x == 7.0
   assert r.y == 10.0
-test "if_and_ternary"
+test "struct through if, ternary, match, variadic and closure"
   a := Vec2(x: 1.0, y: 2.0)
   b := Vec2(x: 3.0, y: 4.0)
   assert pick(true, a, b).x == 1.0
   assert pick(false, a, b).x == 3.0
   assert pickT(false, a, b).y == 4.0
-test "match_destructure"
-  assert viaMatch(Vec2(x: 1.0, y: 2.0)) == 3.0
+  assert viaMatch(a) == 3.0
-test "variadic"
   assert sumAll(Vec2(x: 1.0, y: 0.0), Vec2(x: 2.0, y: 0.0)) == 3.0
-test "static_and_zero"
-  z := Vec2.zero()
-  assert z.x == 0.0
-test "closure_value"
   base := Vec2(x: 10.0, y: 0.0)
   r := applyTo(Vec2(x: 1.0, y: 5.0), |v| v + base)
   assert r.x == 11.0
   assert r.y == 5.0
-test "heap_field"
+test "struct in a Map and an optional"
+  m := Map("a" => Vec2(x: 1.0, y: 2.0))
+  assert m.get("a")!.y == 2.0
+  assert opt(true)!.x == 1.0
+  assert chain(true)!.x == 2.0
+  assert {chain(false) ?: Vec2.zero()}.x == 0.0
+test "struct field of a record is copied out"
   p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 3)
   q := p.pos
   q.x = 50.0
@@ -177,12 +194,48 @@ test "heap_field"
   assert p.pos.x == 50.0
   assert p.hp == 3
+test "record assignment shares the object"
+  p := Point(x: 1, y: 2)
+  q := p
+  q.x = 5
+  assert p.x == 5
-test "map_value"
+test "record field mutation and spread update"
-  m := Map("a" => Vec2(x: 1.0, y: 2.0))
+  p := Point(x: 1, y: 2)
+  p.x = 10
+  assert p.x == 10
-  assert m.get("a")!.y == 2.0
+  assert p.y == 2
-test "nullable"
+  p2 := Point(..p, x: 100)
-  assert opt(true)!.x == 1.0
+  assert p2.x == 100
+  assert p2.y == 2
+  # the spread source is untouched by the update it fed
+  assert p.x == 10
+test "struct field mutation and spread update"
+  v := Vec2(x: 1.0, y: 2.0)
+  v.x = 10.0
+  v2 := Vec2(..v, x: 100.0)
+  assert v2.x == 100.0
-  assert chain(true)!.x == 2.0
+  assert v2.y == 2.0
-  z := chain(false) ?: Vec2.zero()
-  assert z.x == 0.0
+  assert v.x == 10.0
+test "record construction is named or positional"
+  assert Point(x: 3, y: 4).y == 4
+  assert Point(3, 4).y == 4
+test "record methods, with and without an explicit self"
+  c := Cat(name: "x", age: 7)
+  assert c.getAge() == 7
+  assert c.birthday() == 8
+  assert methodsTotal() == 3 + 4 + 3
+test "nested record field access"
+  w := Wrapper(inner: Cat(name: "x", age: 7), tag: 99)
+  assert w.inner.age == 7
+  assert w.tag == 99
+test "records built in a loop do not alias"
+  # Regression test: records are bump-allocated at *runtime*, not at a
+  # compile-time-fixed address; otherwise every iteration's `LoopBox(...)`
+  # would alias the same memory and this would sum to 20 instead of 10.
+  assert sumLoopBoxes() == 10

plum-examples/typed_arrays.plum CHANGED Viewed

@@ -37,9 +37,3 @@ test "array_int_native: filled arrays hold their values"
   assert sumInts(10) == 30
   assert sumFloats(4) == 2.0
   assert countTrue(5) == 2
-test "Grid[Int] indexes (x, y) row-major"
-  g := Grid.filled(3, 2, 0)
-  g.set(2, 1, 7)
-  assert g.get(2, 1) == 7
-  assert g.data.get(5) == 7

plum-examples/types.plum DELETED Viewed

@@ -1,199 +0,0 @@
-# Types: algebraic data types via `enum`, named and positional payload fields,
-# and shared fields across variants.
-import std/Str
-import std/Int
-import std/Float
-import std/Seq
-record Point(x: Int, y: Int)
-record Named(name: Str) =
-  fun toStr(self) -> Str =
-    self.name
-record Box[T](value: T)
-enum Color =
-  | Red
-  | Green
-  | Blue
-# A bare enum variant name can be used directly as a type: `v: Red` means
-# "a `Color` value that is specifically the `Red` variant".
-fun stringifyColor(v: Red) -> Str =
-  "Red"
-fun makeIntBox() -> Box[Int] =
-  Box(value: 5)
-fun makeStrBox() -> Box[Str] =
-  Box(value: "x")
-# ---- record-shaped and sum-type enum regression tests ----
-record Cat(name: Str, age: Int) =
-  fun getAge() -> Int =
-    self.age
-record Dog(name: Str, age: Int) =
-  fun getAge(self) -> Int =
-    self.age
-record IntPair(a: Int, b: Int)
-record Wrapper(inner: IntPair, tag: Int)
-record LoopBox(v: Int)
-fun sumLoopBoxes() -> Int =
-  total := 0
-  for i := range 5
-    b := LoopBox(v: i)
-    total = total + b.v
-  return total
-enum Step(n: Int) =
-  | ReadMin(10)
-  | ReadMax(20)
-  fun toNumber(self) -> Int =
-    self.n
-fun stepToNumber(s: Step) -> Int =
-  match s
-    ReadMin => 1
-    ReadMax => 2
-fun unwrapOrDefault(o: Int?, default: Int) -> Int =
-  o ?: default
-enum ShapeKind = Rect | Circle
-record Rect(v0: Int, v1: Int)
-record Circle(v: Int)
-fun area(s: ShapeKind) -> Int =
-  match s
-    Rect(w, h) =>
-      return w * h
-    Circle(r) =>
-      return r * r
-record Vec2(x: Int, y: Int)
-enum ShapeWithFields = CircleField | SquareField
-record CircleField(radius: Int)
-record SquareField(side: Int)
-record MaybeBox(value: Int?) =
-  fun unwrap(default: Int) -> Int =
-    self.value ?: default
-test "class field and method run correctly"
-  c := Cat(name: "x", age: 7)
-  assert c.getAge() == 7
-test "nested method declaration runs correctly"
-  d := Dog(name: "x", age: 7)
-  assert d.getAge() == 7
-test "nested class call runs correctly"
-  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"
-  # Regression test: class instances are bump-allocated at *runtime* (via a
-  # mutable wasm global), not at a compile-time-fixed address — otherwise
-  # every iteration's `LoopBox(...)` would alias the same memory and this
-  # would sum to 5*4=20 instead of 0+1+2+3+4=10.
-  assert sumLoopBoxes() == 10
-test "enum discriminant value field access runs correctly for each variant"
-  assert ReadMin.toNumber() * 100 + ReadMax.toNumber() == 1020
-test "enum discriminant value matches by variant name correctly"
-  assert stepToNumber(ReadMin) * 10 + stepToNumber(ReadMax) == 12
-test "a nullable Int parameter compiles and runs"
-  assert unwrapOrDefault(7, 0) == 7
-test "multi field variant construction compiles and runs"
-  assert area(Rect(3, 4)) == 12
-test "single-variant named-payload enum field access works like a class"
-  # `Vec2` has exactly one variant, so its fields unambiguously describe
-  # every `Vec2` value — `.x`/`.y` resolve directly, no `match` needed,
-  # for both named and positional construction.
-  named := Vec2(x: 1, y: 2)
-  positional := Vec2(3, 4)
-  assert named.x == 1
-  assert named.y == 2
-  assert positional.x == 3
-  assert positional.y == 4
-test "named-payload field access on a multi-variant enum value works via a checked downcast"
-  # Unlike `Vec2` above, `ShapeWithFields` has more than one variant — `.field`
-  # here isn't statically provable to always succeed the way it is on a
-  # single-variant enum. It's still allowed because `radius`/`side` each
-  # belong to exactly one variant (no ambiguity) — codegen compiles it as a
-  # ref.cast down to that one variant's own struct, which would trap at
-  # runtime if the value were ever the OTHER variant instead.
-  c := CircleField(radius: 5)
-  s := SquareField(side: 9)
-  assert c.radius == 5
-  assert s.side == 9
-test "enum variant used directly as a type checks and runs correctly"
-  assert stringifyColor(Red) == "Red"
-test "enum class field construct and destructure runs correctly"
-  b := MaybeBox(value: 42)
-  assert b.unwrap(0) == 42
-test "class field mutation and spread update run correctly"
-  p := Point(x: 1, y: 2)
-  p.x = 10
-  assert p.x == 10
-  assert p.y == 2
-  p2 := Point(..p, x: 100)
-  assert p2.x == 100
-  assert p2.y == 2
-  # the spread source is untouched by the update it fed
-  assert p.x == 10
-test "single-variant named-payload enum field mutation and spread update run correctly"
-  v := Vec2(x: 1, y: 2)
-  v.x = 10
-  assert v.x == 10
-  assert v.y == 2
-  v2 := Vec2(..v, x: 100)
-  assert v2.x == 100
-  assert v2.y == 2
-  assert v.x == 10
-test "multi-variant enum field mutation and spread update run correctly"
-  # Same checked-downcast idiom `.field` reads already use on a
-  # multi-variant enum's uniquely-owned field name (see the test above
-  # about `ShapeWithFields`) — traps at runtime if the value is ever the
-  # OTHER variant, no static proof required.
-  c := CircleField(radius: 5)
-  c.radius = 9
-  assert c.radius == 9
-  c2 := CircleField(..c, radius: 50)
-  assert c2.radius == 50
-  assert c.radius == 9
-test "gc type registry produces a well formed type section alongside bump allocator codegen"
-  # Task 1 Step 5 of the wasm-gc migration plan: the wasm-gc type registry
-  # emits a well-formed type section — a struct type per class, a
-  # supertype+subtypes set per enum, and a shared Str array type — even
-  # though the rest of a compiled module uses a different representation.
-  # This proves the still-untouched bump-allocator codegen actually runs
-  # correctly alongside it, not just that it compiles.
-  c := Cat(name: "x", age: 7)
-  assert c.getAge() == 7

plum-examples/unions.plum CHANGED Viewed

@@ -2,7 +2,10 @@
 # A member converts to the enum where one is expected, a bare member name in a
 # pattern narrows the subject, and a method every member defines is callable on
 # the enum (auto-dispatch). Members can be structs, records, primitives
-# (`Int | Float | Str`), generic instances (`List[Jv]`) or bare tags.
+# (`Int | Float | Str`), generic instances (`List[Jv]`) or bare tags. An enum
+# can also define its own methods (a `match self` body), carry a shared
+# discriminant field (`enum Step(n: Int)`), and one type can belong to several
+# enums.
 module unions
 import std/Str
 import std/Int
@@ -40,7 +43,7 @@ fun leaf(v: Int) -> Tree[Int] = Leaf(v: v)
 fun node(l: Tree[Int], r: Tree[Int]) -> Tree[Int] = Node[Int](left: l, right: r)
-fun describe(j: Jv) -> Str =
+fun describeJv(j: Jv) -> Str =
   match j
     JvNull => "null"
     Int => "int"
@@ -61,6 +64,57 @@ fun make(big: Bool) -> Shape =
   else
     Circle(r: 1.0)
+# Tags and variant-as-type: a bare name that is not a declared type is a tag, and
+# a tag can be used as a parameter type (`v: Red` accepts only `Red`).
+enum Color = Red | Green | Blue
+fun redName(v: Red) -> Str = "Red"
+# A discriminant enum gives every tag a shared number.
+enum Step(n: Int) =
+  | ReadMin(10)
+  | ReadMax(20)
+  fun toNumber(self) -> Int =
+    self.n
+fun stepIndex(s: Step) -> Int =
+  match s
+    ReadMin => 1
+    ReadMax => 2
+# An enum may define a method itself with a `match self` body.
+record Ball(r: Float)
+record Slab(w: Float, h: Float)
+enum Body =
+  | Ball
+  | Slab
+  fun area(self) -> Float =
+    match self
+      Ball(r) => r * r * 3.0
+      Slab(w, h) => w * h
+# One example, two ways: auto-dispatch (every member defines `describe`, so it is
+# callable on the enum) and an explicit `match` over the members.
+record Novel(title: Str, pages: Int) =
+  fun describe(self) -> Str = "novel {self.title}"
+record Atlas(title: Str, regions: Int) =
+  fun describe(self) -> Str = "atlas {self.title}"
+enum Book = Novel | Atlas
+fun describeAuto(b: Book) -> Str =
+  b.describe()
+fun describeMatch(b: Book) -> Str =
+  match b
+    Novel(title, _) => "novel {title}"
+    Atlas(title, _) => "atlas {title}"
 enum Jb = BNull | Bool | Float | Str | List[Jb]
 fun showB(j: Jb) -> Str =
@@ -102,24 +156,18 @@ test "list_of_shapes"
     sum = sum + x.area()
   assert sum == 9.0
-test "push_converts"
-  xs := List[Shape]()
-  xs.push(Circle(r: 2.0))
-  xs.push(Rectangle(w: 1.0, h: 1.0))
-  assert xs.length() == 2
 test "tree_generic"
   assert total(node(leaf(1), node(leaf(2), leaf(3)))) == 6
 test "json_like_primitives"
-  assert describe(JvNull) == "null"
+  assert describeJv(JvNull) == "null"
-  assert describe(7) == "int"
+  assert describeJv(7) == "int"
-  assert describe(1.5) == "float"
+  assert describeJv(1.5) == "float"
-  assert describe("hi") == "str hi"
+  assert describeJv("hi") == "str hi"
   js := List[Jv]()
   js.push(1.0)
   js.push(7)
-  assert describe(js) == "list"
+  assert describeJv(js) == "list"
 test "two_enums_one_type"
   c := Circle(r: 2.0)
@@ -149,7 +197,7 @@ test "union_in_try"
   assert {posLen(3) catch 0} == 2
   assert {posLen(-1) catch 0} == 0
   ys := pos(3) catch List[Jv]()
-  assert describe(ys) == "list"
+  assert describeJv(ys) == "list"
 test "union_with_for"
   xs := List[Jv]()
@@ -158,8 +206,30 @@ test "union_with_for"
   xs.push(2.5)
   n := 0
   for x := range xs
-    n = n + describe(x).length()
+    n = n + describeJv(x).length()
   assert n == 3 + 5 + 5
-test "union_toplevel_plain"
+test "tags, tag as a parameter type, and discriminant values"
-  assert describe(JvNull) == "null"
+  assert redName(Red) == "Red"
+  c: Color := Green
+  if Green := c
+    assert true
+  else
+    assert false
+  assert ReadMin.toNumber() * 100 + ReadMax.toNumber() == 1020
+  assert stepIndex(ReadMin) * 10 + stepIndex(ReadMax) == 12
+test "enum defines its own method over its members"
+  assert Ball(r: 1.5).area() == 6.75
+  assert Slab(w: 2.0, h: 3.0).area() == 6.0
+  b: Body := Slab(w: 1.0, h: 2.0)
+  assert b.area() == 2.0
+test "Book both ways: auto-dispatch and match agree"
+  books: List[Book] := List[Book]()
+  books.push(Novel(title: "Dune", pages: 600))
+  books.push(Atlas(title: "World", regions: 7))
+  for b := range books
+    assert describeAuto(b) == describeMatch(b)
+  assert describeAuto(Novel(title: "Dune", pages: 600)) == "novel Dune"
+  assert describeMatch(Atlas(title: "World", regions: 7)) == "atlas World"

plum-lsp/src/main.rs CHANGED Viewed

@@ -390,7 +390,7 @@ mod tests {
     #[test]
     fn valuesAndLoopsExamplesHaveNoDiagnostics() {
-        for f in ["values.plum", "loops.plum", "chains.plum", "forms.plum"] {
+        for f in ["structs_records.plum", "loops.plum", "seq.plum", "forms.plum", "match.plum", "unions.plum", "game_loop.plum"] {
             let path = repoRoot().join("plum-examples").join(f);
             let text = std::fs::read_to_string(&path).unwrap();
             let tree = Backend::parseTree(&text);

plum-std/Str.plum CHANGED Viewed

@@ -646,30 +646,6 @@ fun bigAscii(n: Int, b: Int) -> Str =
     i = i + 1
   return buf.toStr()
-test "string interpolation of an int runs correctly"
-  x := 42
-  assert "{x}" == "42"
-test "string interpolation of a negative int runs correctly"
-  x := -7
-  assert "{x}" == "-7"
-test "string interpolation of zero runs correctly"
-  x := 0
-  assert "{x}" == "0"
-test "string interpolation with surrounding text and multiple interps runs correctly"
-  count := 3
-  total := 10
-  assert "{count} of {total} complete" == "3 of 10 complete"
-test "string interpolation of a str runs correctly"
-  assert greetForInterpolationTest("World") == "Hello, World!"
-test "string interpolation of a bool runs correctly"
-  b := true
-  assert "is {b}" == "is true"
 test "split divides on every occurrence of the separator"
   parts := "a,b,c".split(",", 0)
   assert parts.length() == 3
@@ -695,25 +671,6 @@ test "split of an empty string returns a single empty element"
   assert parts.length() == 1
   assert parts.join("|") == ""
-test "string interpolation supports a boolean expression, not just a bare variable"
-  c1 := true
-  c2 := true
-  c3 := false
-  assert "{c1 && c2}" == "true"
-  assert "{c1 && c3}" == "false"
-  assert "{c1 || c3}" == "true"
-test "string interpolation supports a method call taking a closure literal"
-  l := List(1, 2, 3, 4)
-  assert "{l.findValue(3)!}" == "3"
-  assert "{l.contains(100)}" == "false"
-test "string interpolation supports an inline if expression"
-  n := 5
-  assert "{if n > 0 then "positive" else "non-positive"}" == "positive"
-# ---- Str method regression tests ----
 test "endsWith matches a real suffix and rejects a non-suffix or an over-long search"
   assert "hello.plum".endsWith(".plum") == true
   assert "hello.plum".endsWith(".rs") == false

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

@@ -62,20 +62,23 @@ fn functionsCompiles() {
 }
 #[test]
-fn typesCompiles() {
+fn structsRecordsCompiles() {
-    // Only class/trait/enum declarations, no function bodies to lower — should still
-    // produce a valid (if unexciting) module.
-    assertCompiles("types.plum");
+    assertCompiles("structs_records.plum");
 }
-// methods.plum/match.plum/closures.plum's actual runtime-correctness checks
+// unions.plum/match.plum/closures.plum's actual runtime-correctness checks
 // now live as native `test`/`expect` blocks inside those example files
 // themselves (run via `plum test plum-examples/<name>.plum`, see
 // scripts/test-plum.sh) — `assertCompiles` below still exercises that each
 // still compiles to valid wasm via this crate's direct (non-CLI) path.
 #[test]
-fn methodsCompiles() {
+fn unionsCompiles() {
-    assertCompiles("methods.plum");
+    assertCompiles("unions.plum");
+}
+#[test]
+fn gameLoopCompiles() {
+    assertCompiles("game_loop.plum");
 }
 #[test]