141b67a | plum | pyrossh

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

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

141b67a — Peter John 2026-11-01T17:36:38+05:30

T3: record migration

Files changed (32) hide show

plum-checker/tests/error_union_tests.rs +4 -8
plum-cli/tests/assert_once_test.rs +1 -2
plum-core/tests/loader_test.rs +2 -4
plum-examples/chains.plum +1 -2
plum-examples/closures.plum +1 -2
plum-examples/forms.plum +2 -4
plum-examples/functions.plum +3 -6
plum-examples/generics.plum +3 -6
plum-examples/match.plum +1 -2
plum-examples/methods.plum +2 -4
plum-examples/oop_visitor.plum +4 -8
plum-examples/operators.plum +2 -4
plum-examples/optionals.plum +2 -4
plum-examples/safe_navigation.plum +3 -6
plum-examples/types.plum +10 -20
plum-std/Buffer.plum +1 -2
plum-std/Deque.plum +1 -2
plum-std/Grid.plum +1 -2
plum-std/Heap.plum +1 -2
plum-std/Http.plum +1 -2
plum-std/Json.plum +1 -2
plum-std/List.plum +1 -2
plum-std/Map.plum +2 -4
plum-std/Random.plum +1 -2
plum-std/Set.plum +1 -2
plum-std/Str.plum +1 -2
plum-std/Time.plum +3 -6
plum-std/Uuid.plum +1 -2
plum-tooling/tree-sitter-plum/test/aa.plum +1 -2
plum-tooling/tree-sitter-plum/test/corpus/const.txt +10 -13
plum-tooling/tree-sitter-plum/test/corpus/type.txt +26 -35
plum-tooling/tree-sitter-plum/test/highlight/sample.plum +1 -2

plum-checker/tests/error_union_tests.rs CHANGED Viewed

@@ -341,8 +341,7 @@ fun d(n: Int) -> !Str =
 #[test]
 fn safe_nav_on_error_union() {
     let src = "\
-enum User =
-  | User(name: Str)
+record User(name: Str)
 fun load(n: Int) -> !User =
   return error.NoUser
@@ -353,8 +352,7 @@ fun name(n: Int) -> !Str =
     // Same set; `?.` flattens.
     assert!(check(src).is_ok(), "{:?}", check(src));
     let src2 = "\
-enum User =
-  | User(name: Str)
+record User(name: Str)
 fun load(n: Int) -> !User =
   return error.NoUser
@@ -369,8 +367,7 @@ fun name(n: Int) -> Str =
 fn pinned_set_vs_generic_unambiguous() {
     // Generics next to a pinned set: the set comes first, in front of the `!`.
     let src = "\
-enum Box[T] =
-  | Box(item: T)
+record Box[T](item: T)
 fun unbox(b: Box[Int]) -> error{Empty}!Box[Int] =
   return error.Empty
@@ -412,8 +409,7 @@ fn null_is_absent_anywhere() {
     // Constructor argument of type `Int?`: not an early return, and legal in a
     // fn that returns a plain value.
     let src = "\
-enum Cfg =
-  | Cfg(port: Int?)
+record Cfg(port: Int?)
 fun mk() -> Cfg =
   Cfg(port: null)

plum-cli/tests/assert_once_test.rs CHANGED Viewed

@@ -24,8 +24,7 @@ fn assert_operands_evaluated_once() {
 import std/Int
 import std/Float
-enum Counter =
-  | Counter(n: Int)
+record Counter(n: Int) =
   fun bump(self) -> Int =
     self.n = self.n + 1

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -213,8 +213,7 @@ fn sameMethodNameOnDifferentReceiversAcrossFilesIsNotACollision() {
         "\
 module fixtures
-enum Cat =
-  | Cat(age: Unit)
+record Cat(age: Unit) =
   fun length(self) -> Unit =
     self.age
@@ -228,8 +227,7 @@ module fixtures
 import cat
-enum Box =
-  | Box(items: Unit)
+record Box(items: Unit) =
   fun length(self) -> Unit =
     self.items

plum-examples/chains.plum CHANGED Viewed

@@ -24,8 +24,7 @@ import std/Seq
 # 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.
-enum Soldier =
-  | Soldier(name: Str, team: Int, hp: Float, x: Float, y: Float)
+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

plum-examples/closures.plum CHANGED Viewed

@@ -32,8 +32,7 @@ fun useFloatClosure() -> Float =
     offset + v
   eachF(floatCb)
-enum ClosureCat =
-  | ClosureCat(age: Int)
+record ClosureCat(age: Int)
 fun eachCat(cb: fn(ClosureCat) -> Int) -> Int =
   cb(ClosureCat(age: 7))

plum-examples/forms.plum CHANGED Viewed

@@ -12,8 +12,7 @@ import std/Seq
 # thing is expanded at the call site, so there are no closures. See
 # plum-std/Seq.plum and plum-core/src/forms.rs.
-enum Fighter =
-  | Fighter(name: Str, hp: Int, dead: Bool)
+record Fighter(name: Str, hp: Int, dead: Bool)
 fun sampleFighters() -> List[Fighter] =
   List(Fighter(name: "a", hp: 10, dead: false), Fighter(name: "b", hp: 0, dead: true), Fighter(name: "c", hp: 7, dead: false))
@@ -57,8 +56,7 @@ fun tailForm(xs: List[Int]) -> Int =
 # A type with a fun* method: `self` is bound to the receiver at the use site.
-enum Countdown =
-  | Countdown(from: Int)
+record Countdown(from: Int) =
   fun* ticks(self) *Int =
     i := self.from

plum-examples/functions.plum CHANGED Viewed

@@ -45,8 +45,7 @@ fun factorial(x: Int) -> Int =
 fun double(n: Int) -> Int =
   n * 2
-enum GenericBox[T] =
-  | GenericBox(value: T)
+record GenericBox[T](value: T) =
   fun getIntValue() -> T =
     self.value
@@ -58,8 +57,7 @@ fun useGenericBox() -> Int =
 fun identity(value: T) -> T =
   value
-enum GenericBox2[T] =
-  | GenericBox2(value: T)
+record GenericBox2[T](value: T) =
   fun getValue() -> T =
     self.value
@@ -89,8 +87,7 @@ fun strContentsOr(p: Parcel[Str], default: Int) -> Int =
     Delivered(v) => 4
     Lost => default
-enum GenericBox3[T] =
-  | GenericBox3(value: T)
+record GenericBox3[T](value: T) =
   fun getBoxValue() -> T =
     self.value

plum-examples/generics.plum CHANGED Viewed

@@ -45,8 +45,7 @@ fun readDeep(outer: List[List[Map[Str, Int]]], r: Int, c: Int, key: Str) -> erro
   v := try m.get(key)
   return v
-enum Circle =
-  | Circle(r: Float)
+record Circle(r: Float) =
   fun area(self) -> Float =
     self.r * self.r * 3.0
@@ -54,8 +53,7 @@ enum Circle =
   fun name(self) -> Str =
     "circle"
-enum Square =
-  | Square(s: Float)
+record Square(s: Float) =
   fun area(self) -> Float =
     self.s * self.s
@@ -72,8 +70,7 @@ fun nameOf(s: T) -> Str =
 # "Trait values": there are no traits, so the behavior a generic needs is passed
 # explicitly as a record of functions (a "Num dictionary"). `num.add(a, b)` calls
 # the closure stored in the `add` field (a method named `add` would win).
-enum Num[T] =
-  | Num(add: fn(T, T) -> T, zero: T)
+record Num[T](add: fn(T, T) -> T, zero: T)
 fun sumWith(xs: List[T], num: Num[T]) -> T =
   acc := num.zero

plum-examples/match.plum CHANGED Viewed

@@ -131,8 +131,7 @@ fun bothOptions(a: Reading[Int], b: Reading[Int]) -> Int =
     Sample(x), Sample(y) => x + y
     _, _ => 0
-enum Point =
-  | Point(x: Int, y: Int)
+record Point(x: Int, y: Int) =
   fun sum(self) -> Int =
     match self

plum-examples/methods.plum CHANGED Viewed

@@ -4,8 +4,7 @@ import std/Str
 import std/Int
 import std/Float
-enum Cat =
-  | Cat(name: Str, age: Int)
+record Cat(name: Str, age: Int) =
   fun getAge(self) -> Int =
     self.age
@@ -13,8 +12,7 @@ enum Cat =
   fun birthday(self) -> Int =
     self.age + 1
-enum Wrapper =
-  | Wrapper(inner: Cat, tag: Int)
+record Wrapper(inner: Cat, tag: Int) =
   fun innerAge(self) -> Int =
     self.inner.age

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -37,8 +37,7 @@ enum Rating =
   | Good(name: Str)
   | Bad(name: Str)
-enum FantasyBook =
-  | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
+record FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool) =
   fun collectInterestingInfo(self) -> Str =
     if self.hasMythicalCreatures
@@ -46,8 +45,7 @@ enum FantasyBook =
     else
       "Fantasy book \"{self.title}\" has no mythical creatures"
-enum ScifiBook =
-  | ScifiBook(title: Str, pages: Int, theme: Str)
+record ScifiBook(title: Str, pages: Int, theme: Str) =
   fun collectInterestingInfo(self) -> Str =
     if self.theme == "space exploration"
@@ -55,8 +53,7 @@ enum ScifiBook =
     else
       "Scifi book \"{self.title}\" has theme {self.theme}"
-enum ChildrensTaleBook =
-  | ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
+record ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str) =
   fun collectInterestingInfo(self) -> Str =
     if self.pages == 0
@@ -64,8 +61,7 @@ enum ChildrensTaleBook =
     else
       "Childrens book \"{self.title}\" teaches: {self.moralLesson}"
-enum NonFictionBook =
-  | NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)
+record NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating) =
   fun collectInterestingInfo(self) -> Str =
     match self.rating1, self.rating2

plum-examples/operators.plum CHANGED Viewed

@@ -5,8 +5,7 @@ import std/Float
 # Operators on non-primitive operands call methods: `a + b` is `a.add(b)`,
 # `-a` is `a.neg()`, `a == b` is `a.eq(b)`, `a < b` is `a.lt(b)`.
-enum Vec2 =
-  | Vec2(x: Float, y: Float)
+record Vec2(x: Float, y: Float) =
   fun toStr(self) -> Str =
     "Vec2({self.x}, {self.y})"
@@ -29,8 +28,7 @@ enum Vec2 =
   fun le(self, o: Vec2) -> Bool =
     self.x <= o.x
-enum Plain =
-  | Plain(v: Int)
+record Plain(v: Int)
 fun double(a: T) -> T =
   a + a

plum-examples/optionals.plum CHANGED Viewed

@@ -6,11 +6,9 @@ import std/List
 # `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.
-enum Box =
-  | Box(label: Str)
+record Box(label: Str)
-enum Holder =
-  | Holder(item: Box?, count: Int?)
+record Holder(item: Box?, count: Int?)
 fun maybeBox(c: Bool) -> Box? =
   if c

plum-examples/safe_navigation.plum CHANGED Viewed

@@ -18,17 +18,14 @@ import std/List
 # Pure sugar for `obj.andThen(|v| v.field)`, desugared entirely in the parser
 # (see `plum-core`'s `parseSafeAttribute`).
-enum Person =
-  | Person(name: Str, age: Int)
+record Person(name: Str, age: Int) =
   fun birthday(self) -> Int =
     self.age + 1
-enum Target =
-  | Target(name: Str)
+record Target(name: Str)
-enum User =
-  | User(name: Str, target: Target?)
+record User(name: Str, target: Target?)
 fun personName(p: Person?) -> Str? =
   p?.name

plum-examples/types.plum CHANGED Viewed

@@ -5,17 +5,14 @@ import std/Int
 import std/Float
 import std/Seq
-enum Point =
-  | Point(x: Int, y: Int)
+record Point(x: Int, y: Int)
-enum Named =
-  | Named(name: Str)
+record Named(name: Str) =
   fun toStr(self) -> Str =
     self.name
-enum Box[T] =
-  | Box(value: T)
+record Box[T](value: T)
 enum Color =
   | Red
@@ -35,26 +32,21 @@ fun makeStrBox() -> Box[Str] =
 # ---- record-shaped and sum-type enum regression tests ----
-enum Cat =
-  | Cat(name: Str, age: Int)
+record Cat(name: Str, age: Int) =
   fun getAge() -> Int =
     self.age
-enum Dog =
-  | Dog(name: Str, age: Int)
+record Dog(name: Str, age: Int) =
   fun getAge(self) -> Int =
     self.age
-enum IntPair =
-  | IntPair(a: Int, b: Int)
+record IntPair(a: Int, b: Int)
-enum Wrapper =
-  | Wrapper(inner: IntPair, tag: Int)
+record Wrapper(inner: IntPair, tag: Int)
-enum LoopBox =
-  | LoopBox(v: Int)
+record LoopBox(v: Int)
 fun sumLoopBoxes() -> Int =
   total := 0
@@ -89,15 +81,13 @@ fun area(s: ShapeKind) -> Int =
     Circle(r) =>
       return r * r
-enum Vec2 =
-  | Vec2(x: Int, y: Int)
+record Vec2(x: Int, y: Int)
 enum ShapeWithFields =
   | CircleField(radius: Int)
   | SquareField(side: Int)
-enum MaybeBox =
-  | MaybeBox(value: Int?)
+record MaybeBox(value: Int?) =
   fun unwrap(default: Int) -> Int =
     self.value ?: default

plum-std/Buffer.plum CHANGED Viewed

@@ -14,8 +14,7 @@ import std/Float
 # `bytes.Buffer`'s asymptotic behavior — unlike the previous `Str`-backed
 # version of this type, which recopied everything written so far on every
 # write.
-enum Buffer =
-  | Buffer(data: []Byte, len: Int)
+record Buffer(data: []Byte, len: Int) =
   # A no-param `init` nested in the type is `Buffer()`'s constructor — a
   # zero-arg `Buffer()` call desugars to `Buffer.init()` (see `plum-checker`'s

plum-std/Deque.plum CHANGED Viewed

@@ -9,8 +9,7 @@ import std/Float
 # element `i` (0 = front) lives at `(head + i) % capacity`. Pushes at either end
 # are O(1) amortized — when full, capacity doubles and the elements are copied
 # out in front-to-back order (so the ring unwraps).
-enum Deque[T] =
-  | Deque(buf: Array[T], head: Int, size: Int)
+record Deque[T](buf: Array[T], head: Int, size: Int) =
   fun init() -> Deque[T] =
     b := Array[T]().resize(8)

plum-std/Grid.plum CHANGED Viewed

@@ -9,8 +9,7 @@ import std/Float
 # `y` the row in `[0, h)`. `get`/`set` do no bounds check of their own beyond
 # the underlying array's trap — use `inBounds` first when coordinates may stray
 # off the map (neighbour scans, pathfinding).
-enum Grid[T] =
-  | Grid(w: Int, h: Int, data: Array[T])
+record Grid[T](w: Int, h: Int, data: Array[T]) =
   # `Grid.filled(w, h, v)` — a `w` x `h` grid with every cell set to `v`
   # (`T` is inferred from `v`).

plum-std/Heap.plum CHANGED Viewed

@@ -11,8 +11,7 @@ import std/Float
 # comparison, so keep it cheap and don't mutate an element's key while it is in
 # the heap. `push`/`pop` are O(log n); `peek`/`length` are O(1). Equal keys pop in
 # no guaranteed order.
-enum Heap[T] =
-  | Heap(items: List[T], key: fn(T) -> Float)
+record Heap[T](items: List[T], key: fn(T) -> Float) =
   fun length(self) -> Int =
     return self.items.length()

plum-std/Http.plum CHANGED Viewed

@@ -13,8 +13,7 @@ error HttpError = HttpFailed | BadResponse
 # An HTTP response: status code, response headers, and the raw response
 # body as a `Str` (a byte array, so binary bodies round-trip intact).
-enum Response =
-  | Response(status: Int, headers: Map[Str, Str], body: Str)
+record Response(status: Int, headers: Map[Str, Str], body: Str) =
   # 2xx status codes are success; everything else (redirects, 4xx, 5xx) is
   # surfaced here rather than as an error from `request` — a non-2xx

plum-std/Json.plum CHANGED Viewed

@@ -85,8 +85,7 @@ enum JsonParse =
 # A recursive-descent parser over a `Str` source, tracking its read position
 # in `pos`. It reads directly from a `Str`, the same way every other stdlib
 # parser (e.g. `Int.parse`) does.
-enum JsonParser =
-  | JsonParser(src: Str, pos: Int, text: Str)
+record JsonParser(src: Str, pos: Int, text: Str) =
   # Records why parsing is about to fail at the current position; the caller
   # then fails with `InvalidJson`.

plum-std/List.plum CHANGED Viewed

@@ -12,8 +12,7 @@ import std/Str
 # `get`/`set` are O(1). The core operations (`init`, `length`, `get`, `set`,
 # `push`, `pop`, `clear`) sit directly on the `Array` intrinsics; everything
 # else (`map`, `retain`, `reduce`, `chunk`, ...) is ordinary Plum on top of them.
-enum List[T] =
-  | List(data: Array[T], size: Int)
+record List[T](data: Array[T], size: Int) =
   # `List[T](1, 2, 3)` (or, for an empty list, `List[T]()` — explicit
   # generics required either way, since nothing else in a call this shape

plum-std/Map.plum CHANGED Viewed

@@ -9,8 +9,7 @@ import std/Str
 #
 # `toStr` exists because `List[T]` calls `toStr` on its elements (duck-typed)
 # and `Map` stores `List[Pair[K, V]]` buckets.
-enum Pair[K, V] =
-  | Pair(key: K, val: V)
+record Pair[K, V](key: K, val: V) =
   fun toStr(self) -> Str =
     return "{self.key.toStr()}: {self.val.toStr()}"
@@ -21,8 +20,7 @@ enum Pair[K, V] =
 # association list costs), degrading to O(n) only if many keys collide into
 # the same bucket.
 # `K` must have a `hash() -> Int` method (duck-typed, checked per instantiation).
-enum Map[K, V] =
-  | Map(buckets: Array[List[Pair[K, V]]], size: Int)
+record Map[K, V](buckets: Array[List[Pair[K, V]]], size: Int) =
   # Number of buckets every `Map` allocates at construction — fixed for the
   # map's whole lifetime, no rehashing/resizing as it grows. A real hash table

plum-std/Random.plum CHANGED Viewed

@@ -16,8 +16,7 @@ import std/Float
 # One raw 32-bit half of the host's pseudo-random generator.
 extern fun rawRandomHalf() -> Int
-enum Random =
-  | Random(seed: Int)
+record Random(seed: Int) =
   # A raw, host-provided pseudo-random 64-bit Int (xorshift64*, seeded from the
   # wall clock — not cryptographically secure). Every other wall-clock random

plum-std/Set.plum CHANGED Viewed

@@ -7,8 +7,7 @@ import std/Float
 # A set of unique `T`s, a thin layer over `Map[T, Bool]` (so `T` needs the same
 # duck-typed `hash() -> Int` and `==` that `Map`'s keys do). `Set[Int]()`
 # builds an empty one.
-enum Set[T] =
-  | Set(map: Map[T, Bool])
+record Set[T](map: Map[T, Bool]) =
   fun init() -> Set[T] =
     return Set(map: Map[T, Bool]())

plum-std/Str.plum CHANGED Viewed

@@ -22,8 +22,7 @@ import std/Float
 # means constructing a brand new `Str`/`Buffer` pair (`Buffer.write`'s own
 # callers are always building up a FRESH buffer before wrapping it, never
 # mutating an already-published `Str`'s backing storage).
-enum Str =
-  | Str(data: Buffer)
+record Str(data: Buffer) =
   # Number of bytes in the string — `self.data` (a `Buffer`) already tracks
   # this, so unlike `byteAt`/`byteToStr` this needs no compiler intrinsic of

plum-std/Time.plum CHANGED Viewed

@@ -8,8 +8,7 @@ import std/Str
 extern fun rawNowMillis() -> Float
 # A single point in time, stored as milliseconds since the Unix epoch.
-enum Time =
-  | Time(value: Int)
+record Time(value: Int) =
   MILLIS_PER_DAY = 86400000
@@ -82,8 +81,7 @@ enum Time =
       + "." + self.millisecond().toStr().padStart("0", 3) + "Z"
 # A Gregorian calendar date, decomposed from a day count by `civilFromDays`.
-enum Civil =
-  | Civil(year: Int, month: Int, day: Int)
+record Civil(year: Int, month: Int, day: Int)
 # Days-since-epoch to proleptic Gregorian year/month/day, via Howard
 # Hinnant's `civil_from_days` (http://howardhinnant.github.io/date_algorithms.html) —
@@ -116,8 +114,7 @@ fun floorMod(a: Int, b: Int) -> Int =
 # A span of time, stored as milliseconds. Negative values are meaningful
 # (e.g. the result of `Time.since` when `self` is earlier than `other`).
-enum Duration =
-  | Duration(value: Int)
+record Duration(value: Int) =
   fun millis(n: Int) -> Duration =
     return Duration(value: n)

plum-std/Uuid.plum CHANGED Viewed

@@ -6,8 +6,7 @@ import std/Random
 # A UUID, stored as its canonical 36-character
 # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.
-enum Uuid =
-  | Uuid(value: Str)
+record Uuid(value: Str) =
   fun toStr(self) -> Str =
     return self.value

plum-tooling/tree-sitter-plum/test/aa.plum CHANGED Viewed

@@ -14,8 +14,7 @@ primitive Defaults =
 error CatError = Hungry | Asleep
 # Cat is an animal that meows always
-enum Cat =
-  | Cat(name: Str, age: Int)
+record Cat(name: Str, age: Int) =
   fun withName(self, name: Str) -> Cat =
     Cat(name: name, age: self.age)

plum-tooling/tree-sitter-plum/test/corpus/const.txt CHANGED Viewed

@@ -121,8 +121,7 @@ primitive Consts =
 associated consts in an enum body and Type.NAME access
 ================================================================================
-enum Vec2 =
-  | Vec2(x: Float, y: Float)
+record Vec2(x: Float, y: Float) =
   ZERO = Vec2(x: 0.0, y: 0.0)
@@ -134,18 +133,16 @@ fun main() =
 --------------------------------------------------------------------------------
 (source
-  (enum
+  (record
     (type_identifier)
-    (field
-      (type_identifier)
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (type_identifier)))
+        (type_identifier)))
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (type_identifier))))
+        (type_identifier)))
     (const
       (const_identifier)
       (expression

plum-tooling/tree-sitter-plum/test/corpus/type.txt CHANGED Viewed

@@ -2,11 +2,9 @@
 type
 ================================================================================
-enum Dog =
-  | Dog(name: Str, age: B)
+record Dog(name: Str, age: B)
-enum Cat =
-  | Cat(name: Str, age: Int)
+record Cat(name: Str, age: Int) =
   fun init(name: Str) -> Cat =
     Cat(name: name, age: 0)
@@ -23,30 +21,26 @@ enum Cat =
 --------------------------------------------------------------------------------
 (source
-  (enum
+  (record
     (type_identifier)
-    (field
-      (type_identifier)
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (type_identifier)))
+        (type_identifier)))
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (generic)))))
+        (generic))))
-  (enum
+  (record
     (type_identifier)
-    (field
-      (type_identifier)
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (type_identifier)))
+        (type_identifier)))
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (type_identifier))))
+        (type_identifier)))
     (fn
       (fn_identifier)
       (param
@@ -153,8 +147,7 @@ enum Cat =
 type - nested method declaration
 ================================================================================
-enum Cat =
-  | Cat(name: Str)
+record Cat(name: Str) =
   fun getName(self) -> Str =
     self.name
@@ -162,14 +155,12 @@ enum Cat =
 --------------------------------------------------------------------------------
 (source
-  (enum
+  (record
     (type_identifier)
-    (field
-      (type_identifier)
-      (enum_named_field
+    (enum_named_field
-        (var_identifier)
+      (var_identifier)
-        (type
+      (type
-          (type_identifier))))
+        (type_identifier)))
     (fn
       (fn_identifier)
       (self)

plum-tooling/tree-sitter-plum/test/highlight/sample.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module std
-enum Cat =
-  | Cat(name: Str, age: Int)
+record Cat(name: Str, age: Int) =
   fun withName(self, name: Str) -> Cat =
     Cat(name: name, age: self.age)