be00b92 | plum | pyrossh

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

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

be00b92 — Peter John 2026-11-01T17:31:34+05:30

T4: README

Files changed (1) hide show

README.md +39 -28

README.md CHANGED Viewed

@@ -29,9 +29,7 @@ enum Shape =                               # a sum type; payload fields are name
       Circle(r) => r * r * 3.14
       Rect(w, h) => w * h
-value enum Vec2 =                          # small copy-semantics value type
+struct Vec2(x: Float, y: Float) =          # small copy-semantics value type
-  | Vec2(x: Float, y: Float)
   ZERO = Vec2(x: 0.0, y: 0.0)              # Vec2.ZERO
   fun add(self, o: Vec2) -> Vec2 =         # `a + b` calls a.add(b)
@@ -77,7 +75,8 @@ test "glance"
 | a conditional expression | `if c then a else b` (there is no `?:` ternary) |
 | loop | `while c`, `for x := range src`, `for i := range n` |
 | a sum type / record | `enum Shape = \| Circle(r: Float) \| Rect(w: Float, h: Float)` |
-| a small value type | `value enum Vec2 = \| Vec2(x: Float, y: Float)` |
+| a small value type | `struct Vec2(x: Float, y: Float)` |
+| a record (reference type) | `record User(name: Str, age: Int)` |
 | a method / static / constant | `fun area(self)` / `fun origin()` / `NAME = expr` inside the type body |
 | generics | `fun id(x: T) -> T`, `enum Box[T]`, duck-typed, one copy per type |
 | operators on your types | define `add`, `sub`, `mul`, `div`, `neg`, `eq`, `lt`, `le`, `gt`, `ge` |
@@ -244,9 +243,7 @@ On `Int`, `Float`, `Byte` and `Str` operators are built in. On any other (declar
 Each operator needs its own method (no derivation from `lt`/`eq`). The right operand may have a different type: `v * 2.0` calls `mul(self, s: Float)`. Using an operator without the method is an error such as `Vec2 has no operator '+' (define add)`, with the instantiation chain when it happens inside a generic. `==`/`!=` on a type with no `eq` keep their built-in meaning (variant identity).
 ```plum
-enum Vec2 =
-  | Vec2(x: Float, y: Float)
+struct Vec2(x: Float, y: Float) =
   fun add(self, o: Vec2) -> Vec2 =
     Vec2(x: self.x + o.x, y: self.y + o.y)
@@ -340,7 +337,7 @@ match job
 Details:
 - The bindings exist only in that branch's block (and in the `, cond`s after the pattern); using them after the `if`, or in a later `else` branch, is an error.
-- A pattern that cannot fail on its type (`Vec2(x, y) := v` on a value enum) is allowed and always takes the branch.
+- A pattern that cannot fail on its type (`Vec2(x, y) := v` on a struct) is allowed and always takes the branch.
 - `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.
@@ -367,16 +364,20 @@ fun sumAll(nums: ...Int) -> Int = # variadic param
 A function without a return type returns `Unit`; the last expression of a body is its value. A call can name its arguments only for constructors (`Cat(name: "Whiskers", age: 3)`); functions take positional arguments.
-## Types: enums, records and value enums
+## Types: struct, record and enum
-`enum` is the one declaration form for data. A record type is just a single-variant enum whose one variant shares the enum's own name:
+`enum` is a sum type: a value that is one of several variants. `struct` and `record` are product types: one variant named like the type, with named fields. A `struct` is a value type and a `record` is a reference type.
 ```plum
-enum Point =
+struct Vec2(x: Float, y: Float) =
-  | Point(x: Int, y: Int)
+  ZERO = Vec2(x: 0.0, y: 0.0)
-enum Named =
+  fun add(self, o: Vec2) -> Vec2 =
+    Vec2(x: self.x + o.x, y: self.y + o.y)
-  | Named(name: Str)
+record User(name: Str, age: Int)
+record Pair[K, V](key: K, val: V)
 enum Color =
   | Red
@@ -396,7 +397,20 @@ enum Step(n: Int) = # a shared field on every variant ...
   | ReadMax(20)
 ```
-The other declaration forms are `value enum` (below), `error Name = A | B` ([Error handling](#error-handling)) and `primitive Name =` ([Constants, statics and `primitive`](#constants-statics-and-primitive)).
+The header ends with `=` only when an indented body follows: `struct Vec2(x: Float, y: Float)` with no body has no `=`.
+A `struct` is a value type: copied on assignment and when passed, with fields only `Int`, `Float`, `Bool` or other structs. A `record` is a reference type: a heap object shared on assignment, with any field types, and it may be generic.
+```plum
+a := Vec2(x: 1.0, y: 2.0)
+b := a
+b.x = 9.0          # a.x is still 1.0: a struct is copied
+u := User(name: "ann", age: 3)
+u2 := u
+u2.age = 4         # u.age is now 4: a record is shared
+```
+The other declaration forms are `struct` and `record` (below), `error Name = A | B` ([Error handling](#error-handling)) and `primitive Name =` ([Constants, statics and `primitive`](#constants-statics-and-primitive)).
 ### Methods, `self` and field access
@@ -476,22 +490,21 @@ enum Shape =
 See [`plum-examples/shapes.plum`](plum-examples/shapes.plum) and [`plum-examples/types.plum`](plum-examples/types.plum).
-### `value enum`
+### `struct` and `record`
-`value enum` declares a small, copy-semantics value type (a vector, a color, a rectangle) that is flattened into wasm locals instead of being heap-allocated:
+`struct` declares a small, copy-semantics value type (a vector, a color, a rectangle) that is flattened into wasm locals instead of being heap-allocated. `record` declares a reference type. Both have one variant named like the type:
 ```plum
-value enum Vec2 =
-  | Vec2(x: Float, y: Float)
+struct Vec2(x: Float, y: Float) =
   fun add(self, o: Vec2) -> Vec2 =
     Vec2(x: self.x + o.x, y: self.y + o.y)
-value enum Rect =
-  | Rect(pos: Vec2, size: Vec2)  # a field may be another value enum
+struct Rect(pos: Vec2, size: Vec2)  # a field may be another struct
+record User(name: Str, age: Int)
 ```
-It has exactly one constructor, named like the type; no generics; fields are only `Int`, `Float`, `Bool` or other value enums, and a value enum can't contain itself. Values are copied on assignment and when passed, and are boxed only inside generic containers (`List[Vec2]`, `Vec2?`). Methods 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` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed only inside generic containers (`List[Vec2]`, `Vec2?`). 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).
 ## Generics
@@ -545,7 +558,7 @@ sumWith(List(1.5, 2.5), floatNum)   # 4.0
 ## Constants, statics and `primitive`
-There are no top-level constants and no free-standing statics. A constant lives inside a type's body (`enum`, `value enum`) or a `primitive`; `NAME = expr` declares an associated constant, and a `fun` without `self` is a static function. Both are reached through the type, `Type.NAME` and `Type.f(args)`, from anywhere, and by their bare name inside the same body. A constant is evaluated lazily, once (a heap value such as a `List` is cached and shared), and names are unique per type, so `Alpha.X` and `Beta.X` coexist.
+There are no top-level constants and no free-standing statics. A constant lives inside a type's body (`enum`, `struct`, `record`) or a `primitive`; `NAME = expr` declares an associated constant, and a `fun` without `self` is a static function. Both are reached through the type, `Type.NAME` and `Type.f(args)`, from anywhere, and by their bare name inside the same body. A constant is evaluated lazily, once (a heap value such as a `List` is cached and shared), and names are unique per type, so `Alpha.X` and `Beta.X` coexist.
 ```plum
 enum Level =
@@ -557,9 +570,7 @@ enum Level =
   fun cap(self, n: Int) -> Int =
     if n > LIMIT then LIMIT else n
-value enum Vec2 =
-  | Vec2(x: Float, y: Float)
+struct Vec2(x: Float, y: Float) =
   ZERO = Vec2(x: 0.0, y: 0.0)     # Vec2.ZERO
   fun unit() -> Vec2 =            # a static: Vec2.unit()
@@ -732,7 +743,7 @@ See [`plum-examples/seq.plum`](plum-examples/seq.plum) (one test per adapter and
 ## Optionals
-An optional is `T?`: a `T`, or `null`. It is its own type, not an error: it carries no error name, and `catch` and `try` do not apply to it. A plain `T` in a `T?` slot is the present value, and `null` is the absent value wherever a `T?` is expected (a call or constructor argument, a `return`, a tail, a list element, a parameter default such as `n: Int? = null`). `null` with nothing to say what it is an optional of is an error (`x := null`: `cannot infer the type of null`). For a reference type (a class, enum, `Str`, `List`, ...) a `T?` is stored as a nullable reference, so a present value costs no allocation; for `Int`, `Float`, `Bool` and value enums it is the value plus a present flag. A doubled `T??` is not allowed.
+An optional is `T?`: a `T`, or `null`. It is its own type, not an error: it carries no error name, and `catch` and `try` do not apply to it. A plain `T` in a `T?` slot is the present value, and `null` is the absent value wherever a `T?` is expected (a call or constructor argument, a `return`, a tail, a list element, a parameter default such as `n: Int? = null`). `null` with nothing to say what it is an optional of is an error (`x := null`: `cannot infer the type of null`). For a reference type (a class, enum, `Str`, `List`, ...) a `T?` is stored as a nullable reference, so a present value costs no allocation; for `Int`, `Float`, `Bool` and structs it is the value plus a present flag. A doubled `T??` is not allowed.
 ```plum
 enum Person =