401e713 | plum | pyrossh

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

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

401e713 — Peter John 2026-11-01T20:52:26+05:30

T8: migrate inline payload variants to record members; legacy syntax errors on

Files changed (16) hide show

plum-core/src/loader.rs +31 -0
plum-core/tests/loader_test.rs +29 -0
plum-examples/constants.plum +2 -4
plum-examples/control_flow.plum +3 -3
plum-examples/digit_names.plum +3 -1
plum-examples/dop_visitor.plum +11 -9
plum-examples/error_propagation.plum +3 -4
plum-examples/functions.plum +3 -3
plum-examples/match.plum +44 -26
plum-examples/oop_visitor.plum +4 -3
plum-examples/pattern_if.plum +8 -9
plum-examples/shapes.plum +15 -6
plum-examples/types.plum +8 -6
plum-examples/values.plum +1 -2
plum-wasm-codegen/tests/codegen_tests.rs +22 -34
plum-wasm-codegen/tests/examples_test.rs +1 -1

plum-core/src/loader.rs CHANGED Viewed

@@ -253,6 +253,37 @@ fn mergeItems(
     names: &mut HashMap<String, PathBuf>,
     prims: &mut Vec<PrimitiveDecl>,
 ) -> Result<(), String> {
+    // Removed forms (inline variant payloads, lone self-named variant).
+    // TODO(T9): remove Json exemption
+    if !file.to_string_lossy().ends_with("plum-std/Json.plum") {
+        // A payload-less self-named single variant (`enum Array[T] = | Array`)
+        // is an opaque builtin handle and stays legal.
+        let opaque: Vec<String> = source
+            .items
+            .iter()
+            .filter_map(|i| match i {
+                Item::Enum(e)
+                    if e.variants.len() == 1
+                        && e.variants[0].name == e.name
+                        && e.variants[0].fields.is_empty()
+                        && e.variants[0].values.is_empty() =>
+                {
+                    Some(format!(
+                        "enum {0} has a single variant named {0} — write record {0}(...)",
+                        e.name
+                    ))
+                }
+                _ => None,
+            })
+            .collect();
+        let legacy: Vec<String> = crate::unions::legacyErrors(source)
+            .into_iter()
+            .filter(|m| !opaque.contains(m))
+            .collect();
+        if !legacy.is_empty() {
+            return Err(legacy.join("\n"));
+        }
+    }
     // Parse-time literal errors (out-of-range integers) of every merged file.
     MERGED_LIT_ERRORS.with(|e| e.borrow_mut().extend(source.formErrors.iter().cloned()));
     // Namespaces (a `primitive` whose name is no built-in) travel with the

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -378,3 +378,32 @@ fn outOfRangeLiteralInEntryOrImportSurvivesTheMerge() {
     let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");
     assert!(merged.formErrors.iter().any(|e| e.2.contains("out of range")), "{:?}", merged.formErrors);
 }
+#[test]
+fn legacyInlinePayloadIsAnError() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    let entry = writeLibFile(
+        &lib_path,
+        "main",
+        "module fixtures\n\nenum Shape =\n  | Circle(r: Unit)\n  | Dot\n",
+    );
+    let err = loadAndMerge(&entry, &lib_path).unwrap_err();
+    assert_eq!(
+        err,
+        "inline variant payloads are removed: declare record Circle(...) and list Circle in enum Shape"
+    );
+}
+#[test]
+fn legacySingleSelfVariantIsAnError() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    let entry = writeLibFile(
+        &lib_path,
+        "main",
+        "module fixtures\n\nenum User =\n  | User(name: Unit)\n",
+    );
+    let err = loadAndMerge(&entry, &lib_path).unwrap_err();
+    assert_eq!(err, "enum User has a single variant named User — write record User(...)");
+}

plum-examples/constants.plum CHANGED Viewed

@@ -20,8 +20,7 @@ primitive Grid =
   fun cells() -> Int =
     W * H
-enum Tile =
-  | Tile(x: Int)
+record Tile(x: Int) =
   W = 100
@@ -30,8 +29,7 @@ enum Tile =
   fun origin() -> Tile =
     Tile(x: 0)
-enum Wrap[T] =
+record Wrap[T](v: T) =
-  | Wrap(v: T)
   fun area(self) -> Int = Grid.W * Grid.H

plum-examples/control_flow.plum CHANGED Viewed

@@ -61,9 +61,9 @@ fun describeMagnitude(n: Int) -> Int =
       return 100
     x => x * 2
-enum TailOption =
+enum TailOption = TailSome | TailNone
-  | TailSome(Int)
+record TailSome(v: Int)
-  | TailNone
 fun unwrapTailOr(o: TailOption, default: Int) -> Int =
   match o

plum-examples/digit_names.plum CHANGED Viewed

@@ -7,10 +7,12 @@ import std/Int
 # `MAX`-style consts keep working.
 enum V2 =
-  | A1(n: Int)
+  | A1
   | B2
   K1 = 40
+record A1(n: Int)
 error S1 = E1 | E2
 fun fail(n: Int) -> S1!Int =

plum-examples/dop_visitor.plum CHANGED Viewed

@@ -41,15 +41,17 @@ import std/Int
 import std/Float
 import std/Str
-enum Rating =
+enum Rating = Good | Bad
-  | Good(name: Str)
+record Good(name: Str)
-  | Bad(name: Str)
+record Bad(name: Str)
-enum Book =
+enum Book = FantasyBook | ScifiBook | ChildrensTaleBook | NonFictionBook
-  | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
+record FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
-  | ScifiBook(title: Str, pages: Int, theme: Str)
+record ScifiBook(title: Str, pages: Int, theme: Str)
-  | ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
+record ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
-  | NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)
+record NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)
 fun collectInterestingInfo(book: Book) -> Str =
   match book

plum-examples/error_propagation.plum CHANGED Viewed

@@ -97,10 +97,9 @@ fun describeAge(s: Str) -> Str =
   "age {n}"
 # A plain list of cases is an ordinary enum.
-enum Failure =
+enum Failure = Timeout | Refused | BadRequest
-  | Timeout
-  | Refused
-  | BadRequest(Str)
+record BadRequest(v: Str)
 fun isRetryable(f: Failure) -> Bool =
   match f

plum-examples/functions.plum CHANGED Viewed

@@ -65,9 +65,9 @@ record GenericBox2[T](value: T) =
 fun doubled(value: Int) -> Int =
   identity(value) + identity(value)
-enum Parcel[T] =
+enum Parcel[T] = Delivered[T] | Lost
-  | Delivered(T)
+record Delivered[T](v: T)
-  | Lost
 fun contentsOr(p: Parcel[Int], default: Int) -> Int =
   match p

plum-examples/match.plum CHANGED Viewed

@@ -32,9 +32,9 @@ fun describeColor(c: Color) -> Str =
 # A dedicated, non-generic "maybe an Int", as opposed to the generic
 # generic `Reading[T]` (used elsewhere in this file).
-enum IntOpt =
+enum IntOpt = Present | Absent
-  | Present(Int)
+record Present(v: Int)
-  | Absent
 fun describeOption(opt: IntOpt) -> Int =
   match opt
@@ -46,33 +46,38 @@ fun main() -> Int =
 # ---- pattern matching regression tests ----
-enum Nested =
+enum Nested = Wrap | Empty
-  | Wrap(IntOpt)
+record Wrap(v: IntOpt)
-  | Empty
 fun unwrapNested(n: Nested) -> Int =
   match n
     Wrap(Present(v)) => v
     Wrap(Absent) => -1
+    Wrap(_) => -2
     Empty => 0
-enum Reading[T] =
+enum Reading[T] = Sample[T] | NoSignal
-  | Sample(T)
+record Sample[T](v: T)
+enum GenericBox[T] = GFull[T] | GEmpty
-  | NoSignal
+record GFull[T](v: T)
-enum GenericBox[T] =
+fun sampleOf(n: Int) -> Reading[Int] =
-  | GFull(T)
+  Sample(n)
-  | GEmpty
 fun unwrapGenericBox(b: GenericBox[Reading[Int]]) -> Int =
   match b
     GFull(Sample(v)) => v
     GFull(NoSignal) => -1
+    GFull(_) => -2
     GEmpty => 0
-enum RecOption =
+enum RecOption = RSome | RNone
-  | RSome(RecOption)
+record RSome(v: RecOption)
-  | RNone
 fun unwrapTwice(o: RecOption) -> Int =
   match o
@@ -144,13 +149,17 @@ record Point(x: Int, y: Int) =
       Point(_, _) => "elsewhere"
 enum Shape =
-  | Circle(Point)
+  | Circle
-  | Square(Point)
+  | Square
   fun measure(self) -> Int =
     match self
       Circle(Point(x, y)) => x + y
       Square(Point(x, y)) => x * y
+      _ => 0
+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
@@ -158,14 +167,23 @@ enum Shape =
 # anonymous positional types. Pattern matching is unaffected either way
 # (still positional, by declaration order — `Rect(w, h)`, not `Rect(w:, h:)`).
 enum Figure =
-  | Ring(radius: Int)
+  | Ring
-  | Rect(w: Int, h: Int)
+  | 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)
+fun measureOf(s: Shape) -> Int =
+  s.measure()
+fun areaOf(f: Figure) -> Int =
+  f.area()
 test "match example computes correctly"
   assert main() == 5
@@ -176,7 +194,7 @@ test "nested constructor pattern mismatch falls through to next case runs correc
   assert unwrapNested(Wrap(Absent)) == -1
 test "nested constructor pattern against a specialized generic enum runs correctly"
-  assert unwrapGenericBox(GFull(Sample(7))) == 7
+  assert unwrapGenericBox(GFull(sampleOf(7))) == 7
 test "doubly nested constructor pattern runs correctly"
   assert unwrapTwice(RSome(RSome(RNone))) == 1
@@ -220,16 +238,16 @@ 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 measureOf(Circle(Point(x: 3, y: 4))) == 7
-  assert Square(Point(x: 3, y: 4)).measure() == 12
+  assert measureOf(Square(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 areaOf(Ring(radius: 5)) == 25
-  assert Rect(w: 3, h: 4).area() == 12
+  assert areaOf(Rect(w: 3, h: 4)) == 12
 test "named-payload enum variant still supports positional construction too"
-  assert Ring(5).area() == 25
+  assert areaOf(Ring(5)) == 25
-  assert Rect(3, 4).area() == 12
+  assert areaOf(Rect(3, 4)) == 12
 test "a pattern name reused with different types in one fn"
   r := Sample(1)

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -33,9 +33,10 @@ import std/Int
 import std/Float
 import std/Str
-enum Rating =
+enum Rating = Good | Bad
-  | Good(name: Str)
+record Good(name: Str)
-  | Bad(name: Str)
+record Bad(name: Str)
 record FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool) =

plum-examples/pattern_if.plum CHANGED Viewed

@@ -13,19 +13,18 @@ import std/Str
 #
 # A plain name over an optional (`x := opt`) keeps its meaning: bind when present.
-enum Shape =
+enum Shape = Circle | Rect | Dot
-  | Circle(radius: Float)
+record Circle(radius: Float)
-  | Rect(w: Float, h: Float)
+record Rect(w: Float, h: Float)
-  | Dot
 struct Vec2(x: Int, y: Int)
-enum Job =
+enum Job = Idle | Busy
-  | Idle
-  | Busy(left: Int)
+record Busy(left: Int)
-enum Soldier =
-  | Soldier(hp: Int, shape: Shape)
+record Soldier(hp: Int, shape: Shape)
 fun area(s: Shape) -> Float =
   if Circle(r) := s

plum-examples/shapes.plum CHANGED Viewed

@@ -5,8 +5,8 @@ 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(r: Float)
+  | Circle
-  | Rect(w: Float, h: Float)
+  | Rect
   fun area(self) -> Float =
     match self
@@ -18,10 +18,19 @@ enum Shape =
       Circle(r) => "circle"
       Rect(w, h) => "rect"
+record Circle(r: Float)
+record Rect(w: Float, h: Float)
+fun areaOf(s: Shape) -> Float =
+  s.area()
+fun nameOf(s: Shape) -> Str =
+  s.name()
 test "area dispatches on the variant"
-  assert Circle(r: 1.5).area() == 6.75
+  assert areaOf(Circle(r: 1.5)) == 6.75
-  assert Rect(w: 2.0, h: 3.0).area() == 6.0
+  assert areaOf(Rect(w: 2.0, h: 3.0)) == 6.0
 test "name dispatches on the variant"
-  assert Circle(r: 1.0).name() == "circle"
+  assert nameOf(Circle(r: 1.0)) == "circle"
-  assert Rect(w: 1.0, h: 1.0).name() == "rect"
+  assert nameOf(Rect(w: 1.0, h: 1.0)) == "rect"

plum-examples/types.plum CHANGED Viewed

@@ -70,9 +70,10 @@ fun stepToNumber(s: Step) -> Int =
 fun unwrapOrDefault(o: Int?, default: Int) -> Int =
   o ?: default
-enum ShapeKind =
+enum ShapeKind = Rect | Circle
-  | Rect(Int, Int)
+record Rect(v0: Int, v1: Int)
-  | Circle(Int)
+record Circle(v: Int)
 fun area(s: ShapeKind) -> Int =
   match s
@@ -83,9 +84,10 @@ fun area(s: ShapeKind) -> Int =
 record Vec2(x: Int, y: Int)
-enum ShapeWithFields =
+enum ShapeWithFields = CircleField | SquareField
-  | CircleField(radius: Int)
+record CircleField(radius: Int)
-  | SquareField(side: Int)
+record SquareField(side: Int)
 record MaybeBox(value: Int?) =

plum-examples/values.plum CHANGED Viewed

@@ -36,8 +36,7 @@ struct Color(r: Int, g: Int, b: Int, a: Int)
 struct Cell(pos: Vec2, solid: Bool, tint: Color)
-enum Player =
-  | Player(pos: Vec2, hp: Int)
+record Player(pos: Vec2, hp: Int)
 fun applyTo(v: Vec2, cb: fn(Vec2) -> Vec2) -> Vec2 =
   cb(v)

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

@@ -230,8 +230,7 @@ fn floatArithmeticAndNegationCompile() {
 #[test]
 fn classFieldAndMethodCompile() {
     let src = "\
-enum Cat =
-  | Cat(name: Str, age: Int)
+record Cat(name: Str, age: Int) =
   fun getAge() -> Int =
     self.age
@@ -246,11 +245,9 @@ fun makeCat() -> Int =
 #[test]
 fn nestedClassCallCompiles() {
     let src = "\
-enum Pair =
-  | Pair(a: Int, b: Int)
+record Pair(a: Int, b: Int)
-enum Wrapper =
-  | Wrapper(inner: Pair, tag: Int)
+record Wrapper(inner: Pair, tag: Int)
 fun make() -> Int =
   w = Wrapper(inner: Pair(a: 1, b: 2), tag: 9)
@@ -1113,14 +1110,17 @@ import std/Float
 import std/List
 enum Shape =
-  | Circle(r: Float)
+  | Circle
-  | Square(s: Float)
+  | Square
   fun area(self) -> Float =
     match self
       Circle(r) => r * r * 3.0
       Square(s) => s * s
+record Circle(r: Float)
+record Square(s: Float)
 fun total(xs: List[Shape]) -> Float =
   sum := 0.0
   for x := range xs
@@ -1611,8 +1611,7 @@ fun main() -> Int =
 #[test]
 fn fn_typed_field_call() {
     let src = format!("{}\
-enum Ops =
-  | Ops(inc: fn(Int) -> Int, base: Int)
+record Ops(inc: fn(Int) -> Int, base: Int)
 fun main() -> Int =
   o := Ops(inc: |n| n + 1, base: 40)
@@ -1624,8 +1623,7 @@ fun main() -> Int =
 #[test]
 fn method_beats_field_precedence() {
     let src = format!("{}\
-enum Combo =
-  | Combo(add: fn(Int, Int) -> Int)
+record Combo(add: fn(Int, Int) -> Int) =
   fun add(self, a: Int, b: Int) -> Int =
     a * b
@@ -1652,8 +1650,7 @@ fun main() -> Int =
 #[test]
 fn record_of_fns_passed_explicitly() {
     let src = format!("{}{}\
-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 =
   reduceList(xs, num.zero, |a, b| num.add(a, b))
@@ -1672,8 +1669,7 @@ fun main() -> Int =
 }
 const NULLABLE_SRC: &str = "\
-enum Person =
-  | Person(name: Str, age: Int)
+record Person(name: Str, age: Int)
 fun findNullable(n: Int) -> Person? =
   if n < 0
@@ -1734,8 +1730,7 @@ fun main() -> Int =
 #[test]
 fn nullable_turns_into_an_error_with_elvis() {
     let src = format!("{}{}", STD_HEAD, "\
-enum Person =
-  | Person(name: Str, age: Int)
+record Person(name: Str, age: Int)
 fun findIt(n: Int) -> Person? =
   if n < 0
@@ -1897,8 +1892,7 @@ fn fn_field_nested_call_arg() {
     let src = format!("{}\
 import std/Array
-enum Keyed[T] =
-  | Keyed(items: List[T], key: fn(T) -> Int)
+record Keyed[T](items: List[T], key: fn(T) -> Int) =
   fun first(self) -> Int =
     self.key(self.items.data.get(0))
@@ -1947,7 +1941,7 @@ fn local_value_subfield_assign() {
 #[test]
 fn heap_field_value_subfield_assign() {
     let src = format!(
-        "{VEC2}enum Player =\n  | Player(pos: Vec2, hp: Int)\n\nstruct Rect(pos: Vec2, size: Vec2)\n\nenum Body =\n  | Body(bounds: Rect, id: Int)\n\nfun main() -> Int =\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 5)\n  p.pos.x = 8.0\n  b := Body(bounds: Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0)), id: 1)\n  b.bounds.size.y = 6.0\n  if p.pos.x == 8.0 && p.pos.y == 2.0 && p.hp == 5 && b.bounds.size.y == 6.0 && b.bounds.size.x == 3.0 && b.bounds.pos.y == 2.0\n    return 1\n  return 0\n"
+        "{VEC2}record Player(pos: Vec2, hp: Int)\n\nstruct Rect(pos: Vec2, size: Vec2)\n\nrecord Body(bounds: Rect, id: Int)\n\nfun main() -> Int =\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 5)\n  p.pos.x = 8.0\n  b := Body(bounds: Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0)), id: 1)\n  b.bounds.size.y = 6.0\n  if p.pos.x == 8.0 && p.pos.y == 2.0 && p.hp == 5 && b.bounds.size.y == 6.0 && b.bounds.size.x == 3.0 && b.bounds.pos.y == 2.0\n    return 1\n  return 0\n"
     );
     assert_eq!(runMerged::<i64>("heap_field_value_subfield_assign", &src), 1);
 }
@@ -1957,7 +1951,7 @@ fn value_nested_pattern_mixed() {
     // Whole-value binding next to a nested destructure, and a heap container
     // (class-like enum) holding a value-enum field.
     let src = format!(
-        "{VEC2}struct Rect(pos: Vec2, size: Vec2)\n\nenum Player =\n  | Player(pos: Vec2, hp: Float)\n\nfun f(r: Rect) -> Float =\n  match r\n    Rect(p, Vec2(w, h)) => p.x + p.y * 10.0 + w * 100.0 + h * 1000.0\n\nfun g(p: Player) -> Float =\n  match p\n    Player(Vec2(x, y), hp) => x + y * 10.0 + hp * 100.0\n\nfun main() -> Int =\n  r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 3.0)\n  if f(r) == 4321.0 && g(p) == 321.0\n    return 1\n  return 0\n"
+        "{VEC2}struct Rect(pos: Vec2, size: Vec2)\n\nrecord Player(pos: Vec2, hp: Float)\n\nfun f(r: Rect) -> Float =\n  match r\n    Rect(p, Vec2(w, h)) => p.x + p.y * 10.0 + w * 100.0 + h * 1000.0\n\nfun g(p: Player) -> Float =\n  match p\n    Player(Vec2(x, y), hp) => x + y * 10.0 + hp * 100.0\n\nfun main() -> Int =\n  r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 3.0)\n  if f(r) == 4321.0 && g(p) == 321.0\n    return 1\n  return 0\n"
     );
     assert_eq!(runMerged::<i64>("value_nested_pattern_mixed", &src), 1);
 }
@@ -2192,8 +2186,7 @@ fun main() -> Int =
 fn fun_star_method_no_closure() {
     // A `fun*` method is expanded at the use site: no closure, no call_indirect, `self` bound once.
     let src = format!("{}\
-enum Bag =
-  | Bag(items: List[Int])
+record Bag(items: List[Int]) =
   fun* doubled(self) *Int =
     for x := range self.items
@@ -2595,8 +2588,7 @@ fun main() -> Int =
 #[test]
 fn error_union_in_class_field() {
     let src = "\
-enum Box =
-  | Box(v: !Int)
+record Box(v: !Int)
 fun f(n: Int) -> !Int =
   if n < 0
@@ -2614,8 +2606,7 @@ fun main() -> Int =
 #[test]
 fn safe_nav_on_error_union() {
     let src = "\
-enum User =
-  | User(age: Int)
+record User(age: Int)
 fun load(n: Int) -> !User =
   if n < 0
@@ -2638,8 +2629,7 @@ import std/Str
 import std/Int
 import std/Float
-enum Item =
-  | Item(v: Int)
+record Item(v: Int)
 fun find(n: Int) -> Item? =
   if n < 0
@@ -2704,8 +2694,7 @@ import std/Str
 import std/Int
 import std/Float
-enum Person =
-  | Person(name: Str, age: Int)
+record Person(name: Str, age: Int)
 fun nameOf(p: Person?) -> Str? =
   p?.name
@@ -2809,8 +2798,7 @@ import std/Str
 import std/Int
 import std/Float
-enum Item =
-  | Item(v: Int)
+record Item(v: Int)
 fun mi(n: Int) -> Int? =
   if n > 0

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

@@ -249,7 +249,7 @@ fn const_table_1000_entries() {
         src.push_str(&format!("  E{} = {}\n", i, i * 3 + 1));
     }
     src.push('\n');
-    src.push_str("enum Holder =\n  | Holder(n: Int)\n\n  fun at(self) -> Int = Table.E499 + self.n\n\nprimitive More =\n");
+    src.push_str("record Holder(n: Int) =\n\n  fun at(self) -> Int = Table.E499 + self.n\n\nprimitive More =\n");
     for i in 500..1000 {
         src.push_str(&format!("  E{} = {}\n", i, i * 3 + 1));
     }