a1704af | plum | pyrossh

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

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

a1704af — Peter John 2026-11-02T19:50:25+05:30

T8: docs and examples

Files changed (3) hide show

README.md +37 -0
plum-examples/trait_scene.plum +50 -0
plum-examples/traits.plum +80 -0

README.md CHANGED Viewed

@@ -528,6 +528,43 @@ enum Step(n: Int) =
   | ReadMax(20)
 ```
+### Traits
+A `trait` bundles fields and methods. A method without a body is required; one with a body is a default that a record may replace. A `record` embeds traits by listing them first in its field list, gains their fields (set in its constructor like its own) and default methods, and converts to each trait wherever one is expected:
+```plum
+trait Entity(pos: Vec2, z: Int) =
+  fun update(self, dt: Float)       # required: every embedding record defines it
+  fun draw(self)
+  fun moveBy(self, d: Vec2) =       # default
+    self.pos = self.pos + d
+  fun drawTwice(self) =
+    self.draw()                     # runs the record's own draw
+    self.draw()
+record House(Entity, Clickable, kind: Int) =
+  fun update(self, dt: Float) = ...
+  fun draw(self) = ...
+es := List[Entity]()
+es.push(House(pos: p, z: 0, hits: 0, kind: 1))   # House converts to Entity
+for e := range es
+  e.update(dt)                      # runs House.update
+  e.pos = e.pos + drift             # fields read and write through the trait
+```
+Writes through a trait are seen by the record value (`e.pos = p` changes the `House`); a nested write such as `e.pos.x = 1` is rejected, assign the whole field. `match` narrows a trait value back to a record and always needs a `_` case; a record pattern binds all of the record's fields, trait fields first:
+```plum
+match e
+  House(_, _, _, kind) => kind
+  _ => -1
+```
+Everything is resolved statically from the whole program; there are no vtables. Compile errors: a missing required method, two traits (or a trait and the record) declaring the same field, two traits with the same default method that the record doesn't define itself, embedding something that isn't a trait, a trait in a `struct`, a method call the trait doesn't declare, and a `match` on a trait without `_`.
+Not in v1: generic traits, traits embedding traits, `fun*` in traits, struct embedding, and `==` on trait values. See `plum-examples/traits.plum` and `plum-examples/trait_scene.plum`.
 ### Methods, `self` and field access
 A `fun` declared indented directly inside an `enum`, `struct` or `record` body whose first parameter is `self` is a method, called on a value (`c.getAge()`). One without `self` is a static function, called on the type (`Cat.named("Tom")`), and can't use `self`. Calling a static on a value, or a method on the type, is an error:

plum-examples/trait_scene.plum ADDED Viewed

@@ -0,0 +1,50 @@
+# A tiny pure scene: a `Scene` holds `List[Entity]`; the engine side knows only
+# the trait, the records fill it in. No game host needed.
+module trait_scene
+import std/Str
+import std/Int
+import std/List
+trait Entity(x: Int, y: Int) =
+  fun update(self, dt: Int)
+  fun draw(self) -> Int
+  fun hit(self, px: Int, py: Int) -> Bool = px == self.x && py == self.y
+record House(Entity, floors: Int) =
+  fun update(self, dt: Int) =
+    return
+  fun draw(self) -> Int = self.floors * 10
+record Walker(Entity, speed: Int) =
+  fun update(self, dt: Int) =
+    self.x = self.x + self.speed * dt
+  fun draw(self) -> Int = self.x
+record Scene(entities: List[Entity]) =
+  fun update(self, dt: Int) =
+    for e := range self.entities
+      e.update(dt)
+  fun drawAll(self) -> Int =
+    total := 0
+    for e := range self.entities
+      total = total + e.draw()
+    total
+fun makeScene() -> Scene =
+  es: List[Entity] := List[Entity]()
+  es.push(House(x: 0, y: 0, floors: 2))
+  es.push(Walker(x: 3, y: 1, speed: 2))
+  Scene(entities: es)
+test "scene_updates_and_draws"
+  s := makeScene()
+  assert s.drawAll() == 23
+  s.update(5)
+  assert s.drawAll() == 33
+test "scene_hit_default"
+  s := makeScene()
+  assert s.entities.at(1).hit(3, 1)
+  s.update(1)
+  assert s.entities.at(1).hit(5, 1)
+  assert !s.entities.at(0).hit(1, 1)

plum-examples/traits.plum ADDED Viewed

@@ -0,0 +1,80 @@
+# Traits: `trait Entity(pos: Vec2, z: Int) = ...` bundles fields and methods. A
+# `record` embeds traits by listing them first in its field list, gains their
+# fields and default methods, and converts to each trait where one is expected.
+# A method without a body is required; one with a body is a default.
+module traits
+import std/Str
+import std/Int
+import std/Float
+import std/List
+struct Vec2(x: Int, y: Int) =
+  fun add(self, o: Vec2) -> Vec2 = Vec2(x: self.x + o.x, y: self.y + o.y)
+trait Entity(pos: Vec2, z: Int) =
+  fun update(self, dt: Int) -> Int
+  fun draw(self) -> Int
+  fun moveBy(self, d: Vec2) =
+    self.pos = self.pos + d
+  fun drawTwice(self) -> Int = self.draw() * 2
+trait Clickable(hits: Int) =
+  fun onClick(self) -> Int
+record House(Entity, Clickable, kind: Int) =
+  fun update(self, dt: Int) -> Int = self.kind * dt
+  fun draw(self) -> Int = 100 + self.pos.x
+  fun onClick(self) -> Int = 7
+record Tree(Entity, age: Int) =
+  fun update(self, dt: Int) -> Int = self.age + dt
+  fun draw(self) -> Int = 200 + self.pos.x
+  fun drawTwice(self) -> Int = 1
+fun house() -> House = House(pos: Vec2(x: 1, y: 2), z: 0, hits: 0, kind: 3)
+fun tree() -> Tree = Tree(pos: Vec2(x: 5, y: 5), z: 1, age: 10)
+fun clickIt(c: Clickable) -> Int = c.onClick() + c.hits
+fun describe(e: Entity) -> Int =
+  match e
+    House(_, _, _, kind) => kind
+    _ => -1
+test "fields_through_trait"
+  h := house()
+  e: Entity := h
+  assert e.z == 0
+  e.pos = Vec2(x: 9, y: 9)
+  assert h.pos.x == 9
+  e.z = 4
+  assert h.z == 4
+test "list_of_entities_dispatch"
+  es: List[Entity] := List[Entity]()
+  es.push(house())
+  es.push(tree())
+  assert es.at(0).update(2) == 6
+  assert es.at(1).update(2) == 12
+  assert es.at(0).draw() == 101
+  assert es.at(1).draw() == 205
+test "default_changes_pos"
+  h := house()
+  e: Entity := h
+  e.moveBy(Vec2(x: 10, y: 20))
+  assert h.pos.x == 11
+  assert e.pos.y == 22
+test "default_calls_override"
+  assert house().drawTwice() == 202
+  e: Entity := tree()
+  assert e.drawTwice() == 1
+test "match_with_wildcard"
+  assert describe(house()) == 3
+  assert describe(tree()) == -1
+test "record_in_two_traits"
+  assert clickIt(house()) == 7