1de3be3 | plum | pyrossh

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

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

1de3be3 — Peter John 2026-10-26T14:09:33+05:30

feat(std): Array.filled, Grid, Set, Deque, Heap, seeded Random; typed consts

Files changed (10) hide show

plum-checker/src/lib.rs +15 -1
plum-examples/constants.plum +33 -0
plum-examples/typed_arrays.plum +41 -0
plum-std/Array.plum +10 -0
plum-std/Deque.plum +109 -0
plum-std/Grid.plum +49 -0
plum-std/Heap.plum +105 -0
plum-std/Random.plum +78 -0
plum-std/Set.plum +68 -0
plum-wasm-codegen/tests/examples_test.rs +55 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -1225,7 +1225,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     // Generic items are checked once, structurally (`TApp`/`TParam`), on the
     // ORIGINAL source.
     let mut errors: Vec<CheckError> = checkBareGenericTypes(source);
-    let (global_env, methods, enum_variants, enum_params) = buildGlobalTables(source);
+    let (mut global_env, methods, enum_variants, enum_params) = buildGlobalTables(source);
     let min_required = buildMinRequiredArgs(source);
     let ctx = CheckCtx {
         methods: &methods,
@@ -1233,6 +1233,20 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
         enum_params: &enum_params,
         min_required: &min_required,
     };
+    // Constants are inlined at their use sites, so their type is whatever their
+    // initializer infers to (`FLAG = True`, `N = LIMIT * 2 + 1`, `T = List(1, 2)`).
+    // `buildGlobalTables` only had literals to go on; now that every method/enum
+    // table exists, re-infer each one with the full inferer. Two passes let a const
+    // reference one declared later.
+    for _ in 0..2 {
+        for item in &source.items {
+            if let ast::Item::Const(c) = item {
+                if let Ok(ty) = inferExpr(&c.value, &global_env, &ctx) {
+                    global_env.insert(c.name.clone(), TypeScheme::mono(ty));
+                }
+            }
+        }
+    }
     // A discriminant enum (`enum Foo(n: Int) = ...`) requires every variant to supply
     // exactly one value per declared param, unified against that param's type. An

plum-examples/constants.plum ADDED Viewed

@@ -0,0 +1,33 @@
+module constants
+import std/Number
+import std/Str
+# Top-level constants may appear anywhere at top level (before or after enums
+# and fns), hold Int/Float/Str/Bool literals or expressions over other
+# constants, and are usable inside fns, methods and generics. They are inlined
+# at each use. NOTE: constant names are global across imported modules.
+GRID_W = 8
+GRID_H = GRID_W * 2
+CELL_SCALE = 2.5
+GAME_NAME = "plum"
+DEBUG_DRAW = True
+enum Tile =
+  | Tile(x: Int)
+  fun offset(self) -> Int = GRID_W + self.x
+enum Wrap[T] =
+  | Wrap(v: T)
+  fun area(self) -> Int = GRID_W * GRID_H
+fun scaled(n: Float) -> Float = n * CELL_SCALE
+test "consts are usable in fns, methods, generics and derived consts"
+  assert GRID_H == 16
+  assert Tile(x: 1).offset() == 9
+  assert Wrap(v: 3.5).area() == 128
+  assert scaled(2.0) == 5.0
+  assert GAME_NAME == "plum"
+  assert DEBUG_DRAW

plum-examples/typed_arrays.plum ADDED Viewed

@@ -0,0 +1,41 @@
+module typed_arrays
+import std/Number
+import std/Array
+import std/Grid
+# Tile-grid style data: Array[Int] / Array[Float] / Array[Bool] are native
+# unboxed wasm arrays (i64 / f64 / i32 elements), not boxed anyref arrays.
+fun sumInts(n: Int) -> Int =
+  a := Array.filled(n, 3)
+  total := 0
+  for i := range n
+    total = total + a.get(i)
+  return total
+fun sumFloats(n: Int) -> Float =
+  a := Array.filled(n, 0.5)
+  total := 0.0
+  for i := range n
+    total = total + a.get(i)
+  return total
+fun countTrue(n: Int) -> Int =
+  a := Array.filled(n, False)
+  a.set(1, True)
+  a.set(3, True)
+  c := 0
+  for i := range n
+    if a.get(i)
+      c = c + 1
+  return c
+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-std/Array.plum CHANGED Viewed

@@ -59,3 +59,13 @@ enum Array[T] =
   # grows by doubling through this.
   fun resize(self, n: Int) -> Array[T] =
     todo
+  # A new array of length `n` with every slot set to `v`:
+  # `Array[Int].filled(100, 0)`. Ordinary Plum on top of the intrinsics; for
+  # `Int`/`Float`/`Bool` the per-instantiation copy stores the values unboxed
+  # in a native `array (mut i64)` / `(mut f64)` / `(mut i32)`.
+  fun filled(n: Int, v: T) -> Array[T] =
+    a := Array[T]().resize(n)
+    for i := range n
+      a.set(i, v)
+    return a

plum-std/Deque.plum ADDED Viewed

@@ -0,0 +1,109 @@
+module std
+import std/Array
+import std/List
+import std/Try
+import std/Number
+# A double-ended queue: a ring buffer over `Array[T]`. `buf`'s length is the
+# capacity, `head` the index of the front element, `size` the number in use;
+# 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)
+  fun init() -> Deque[T] =
+    b := Array[T]().resize(8)
+    return Deque(buf: b, head: 0, size: 0)
+  fun length(self) -> Int =
+    return self.size
+  fun isEmpty(self) -> Bool =
+    return self.size == 0
+  # Doubles capacity when full, relinearizing the ring so `head` becomes 0.
+  fun grow(self) -> Unit =
+    if self.size < self.buf.length()
+      return
+    cap := self.buf.length()
+    nb := Array[T]().resize(cap * 2)
+    for i := range self.size
+      nb.set(i, self.buf.get({self.head + i} % cap))
+    self.buf = nb
+    self.head = 0
+  fun pushBack(self, v: T) -> Unit =
+    self.grow()
+    self.buf.set({self.head + self.size} % self.buf.length(), v)
+    self.size = self.size + 1
+  fun pushFront(self, v: T) -> Unit =
+    self.grow()
+    cap := self.buf.length()
+    self.head = {self.head + cap - 1} % cap
+    self.buf.set(self.head, v)
+    self.size = self.size + 1
+  # Removes and returns the front element, or `Err(DequeWasEmpty)`.
+  fun popFront(self) -> T ! [DequeWasEmpty] =
+    if self.size == 0
+      return Err(DequeWasEmpty)
+    v := self.buf.get(self.head)
+    self.head = {self.head + 1} % self.buf.length()
+    self.size = self.size - 1
+    Ok(v)
+  # Removes and returns the back element, or `Err(DequeWasEmpty)`.
+  fun popBack(self) -> T ! [DequeWasEmpty] =
+    if self.size == 0
+      return Err(DequeWasEmpty)
+    self.size = self.size - 1
+    Ok(self.buf.get({self.head + self.size} % self.buf.length()))
+  # The `i`'th element from the front, or `Err(OutOfBounds)`.
+  fun get(self, i: Int) -> T ! [OutOfBounds] =
+    if i < 0 || i >= self.size
+      return Err(OutOfBounds)
+    Ok(self.buf.get({self.head + i} % self.buf.length()))
+  fun clear(self) -> Unit =
+    self.head = 0
+    self.size = 0
+test "deque_wraparound: head wraps past the end of the ring and growth unwraps it"
+  d := Deque[Int]()
+  # keep size small so head keeps advancing around the 8-slot ring
+  for i := range 50
+    d.pushBack(i)
+    d.pushBack(i + 1000)
+    assert d.popFront().unwrap() == i
+    assert d.popFront().unwrap() == i + 1000
+  assert d.isEmpty()
+  assert d.head != 0 || d.buf.length() > 8
+  # fill beyond capacity while head is mid-ring
+  d.pushBack(1)
+  d.pushBack(2)
+  d.popFront()
+  for i := range 20
+    d.pushBack(10 + i)
+  assert d.length() == 21
+  assert d.get(0).unwrap() == 2
+  assert d.get(20).unwrap() == 29
+  assert d.popBack().unwrap() == 29
+test "pushFront builds the front in reverse order"
+  d := Deque[Int]()
+  for i := range 12
+    d.pushFront(i)
+  assert d.get(0).unwrap() == 11
+  assert d.get(11).unwrap() == 0
+  assert d.popFront().unwrap() == 11
+  assert d.popBack().unwrap() == 0
+  assert d.length() == 10
+test "pop on empty is an error"
+  d := Deque[Int]()
+  assert d.popFront().isErr()
+  assert d.popBack().isErr()
+  assert d.get(0).isErr()

plum-std/Grid.plum ADDED Viewed

@@ -0,0 +1,49 @@
+module std
+import std/Array
+import std/Number
+# A fixed-size 2D grid stored row-major in ONE flat `Array[T]` (so a
+# `Grid[Int]`/`Grid[Float]`/`Grid[Bool]` is a single native unboxed wasm
+# array). Cell `(x, y)` lives at `y * w + x`; `x` is the column in `[0, w)`,
+# `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])
+  # `Grid.filled(w, h, v)` — a `w` x `h` grid with every cell set to `v`
+  # (`T` is inferred from `v`).
+  fun filled(w: Int, h: Int, v: T) -> Grid[T] =
+    return Grid(w: w, h: h, data: Array.filled(w * h, v))
+  # Flat index of cell `(x, y)`.
+  fun index(self, x: Int, y: Int) -> Int =
+    return y * self.w + x
+  fun inBounds(self, x: Int, y: Int) -> Bool =
+    return x >= 0 && y >= 0 && x < self.w && y < self.h
+  fun get(self, x: Int, y: Int) -> T =
+    return self.data.get(y * self.w + x)
+  fun set(self, x: Int, y: Int, v: T) -> Unit =
+    self.data.set(y * self.w + x, v)
+test "Grid get/set address cells row-major and fill covers every cell"
+  g := Grid.filled(4, 3, 0)
+  assert g.w == 4
+  assert g.h == 3
+  g.set(3, 2, 9)
+  g.set(0, 1, 5)
+  assert g.get(3, 2) == 9
+  assert g.get(0, 1) == 5
+  assert g.get(1, 1) == 0
+  assert g.index(3, 2) == 11
+  assert g.data.get(11) == 9
+test "Grid inBounds rejects negative and too-large coordinates"
+  g := Grid.filled(2, 2, 1.5)
+  assert g.inBounds(1, 1)
+  assert g.inBounds(2, 0) == False
+  assert g.inBounds(0, -1) == False
+  assert g.get(1, 1) == 1.5

plum-std/Heap.plum ADDED Viewed

@@ -0,0 +1,105 @@
+module std
+import std/Array
+import std/List
+import std/Try
+import std/Number
+# A binary MIN-heap ordered by a key function: `pop` returns the element whose
+# `key(x)` is smallest. Ordering by an explicit `fn(T) -> Float` (rather than a
+# duck-typed `lt` method) lets one type be queued under different priorities and
+# fits A* directly: `Heap[Node](key: |n| n.f)`. The key is recomputed on each
+# 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)
+  fun length(self) -> Int =
+    return self.items.length()
+  fun isEmpty(self) -> Bool =
+    return self.items.length() == 0
+  fun clear(self) -> Unit =
+    self.items.clear()
+  fun swap(self, i: Int, j: Int) -> Unit =
+    a := self.items.data.get(i)
+    self.items.data.set(i, self.items.data.get(j))
+    self.items.data.set(j, a)
+  fun less(self, i: Int, j: Int) -> Bool =
+    a := self.items.data.get(i)
+    b := self.items.data.get(j)
+    return self.key(a) < self.key(b)
+  fun siftUp(self, start: Int) -> Unit =
+    i := start
+    while i > 0
+      p := {i - 1} / 2
+      if !self.less(i, p)
+        return
+      self.swap(i, p)
+      i = p
+  fun siftDown(self, start: Int) -> Unit =
+    i := start
+    n := self.items.length()
+    while True
+      l := 2 * i + 1
+      r := l + 1
+      m := i
+      if l < n && self.less(l, m)
+        m = l
+      if r < n && self.less(r, m)
+        m = r
+      if m == i
+        return
+      self.swap(i, m)
+      i = m
+  fun push(self, v: T) -> Unit =
+    self.items.push(v)
+    self.siftUp(self.items.length() - 1)
+  # The smallest element without removing it, or `Err(HeapWasEmpty)`.
+  fun peek(self) -> T ! [HeapWasEmpty] =
+    if self.items.length() == 0
+      return Err(HeapWasEmpty)
+    Ok(self.items.data.get(0))
+  # Removes and returns the smallest element, or `Err(HeapWasEmpty)`.
+  fun pop(self) -> T ! [HeapWasEmpty] =
+    n := self.items.length()
+    if n == 0
+      return Err(HeapWasEmpty)
+    top := self.items.data.get(0)
+    self.items.data.set(0, self.items.data.get(n - 1))
+    self.items.size = n - 1
+    self.siftDown(0)
+    Ok(top)
+test "heap_pop_order: 1000 pseudo-random keys pop in ascending order"
+  h := Heap[Int](items: List[Int](), key: |x| Float(x))
+  x := 12345
+  for i := range 1000
+    x = {x * 1103515245 + 12345} % 2147483648
+    h.push(x % 100000)
+  assert h.length() == 1000
+  prev := -1
+  for i := range 1000
+    v := h.pop().unwrap()
+    assert v >= prev
+    prev = v
+  assert h.isEmpty()
+  assert h.pop().isErr()
+test "peek shows the minimum and Float keys order records"
+  h := Heap[Float](items: List[Float](), key: |x| 0.0 - x)
+  h.push(1.5)
+  h.push(9.5)
+  h.push(4.0)
+  assert h.peek().unwrap() == 9.5
+  assert h.pop().unwrap() == 9.5
+  assert h.pop().unwrap() == 4.0
+  assert h.length() == 1

plum-std/Random.plum ADDED Viewed

@@ -0,0 +1,78 @@
+module std
+import std/Number
+# A seeded, deterministic pseudo-random generator (xorshift64*): the same seed
+# always yields the same sequence, so AI and simulation replay exactly. Not
+# cryptographically secure. For wall-clock randomness use `random()` from
+# `std/Number` instead.
+#
+# `Random(seed: 42)` — `seed` holds the generator's CURRENT state and advances
+# on every draw (a seed of 0 is a fixed point of xorshift, so it is silently
+# replaced by a non-zero constant on first use).
+#
+# `Int` is signed 64-bit and `>>` is arithmetic, so the logical right shifts
+# xorshift needs are done as `{x >> k} & mask`.
+enum Random =
+  | Random(seed: Int)
+  # Advances the state and returns 64 well-mixed bits (may be negative).
+  fun nextInt(self) -> Int =
+    x := self.seed
+    if x == 0
+      x = 88172645463325252
+    x = x ^ { {x >> 12} & 0xFFFFFFFFFFFFF }
+    x = x ^ { x << 25 }
+    x = x ^ { {x >> 27} & 0x1FFFFFFFFF }
+    self.seed = x
+    return x * 2685821657736338717
+  # A uniformly distributed Int in [0, n). Returns 0 for n <= 0.
+  fun nextIntBelow(self, n: Int) -> Int =
+    if n <= 0
+      return 0
+    return { self.nextInt() & 0x7FFFFFFFFFFFFFFF } % n
+  # A uniformly distributed Float in [0.0, 1.0) with 53 bits of precision.
+  fun nextFloat(self) -> Float =
+    bits := {self.nextInt() >> 11} & 0x1FFFFFFFFFFFFF
+    return Float(bits) / 9007199254740992.0
+test "random_seed_deterministic: same seed gives the same first 100 values"
+  a := Random(seed: 12345)
+  b := Random(seed: 12345)
+  for i := range 100
+    assert a.nextInt() == b.nextInt()
+test "different seeds diverge and the stream is not constant"
+  a := Random(seed: 1)
+  b := Random(seed: 2)
+  assert a.nextInt() != b.nextInt()
+  c := Random(seed: 7)
+  first := c.nextInt()
+  assert c.nextInt() != first
+test "nextIntBelow stays in range and covers the range"
+  r := Random(seed: 99)
+  seen := 0
+  for i := range 1000
+    v := r.nextIntBelow(10)
+    assert v >= 0
+    assert v < 10
+    seen = seen | {1 << v}
+  assert seen == 1023
+  assert r.nextIntBelow(0) == 0
+test "nextFloat is in [0, 1) with a sane mean"
+  r := Random(seed: 5)
+  total := 0.0
+  for i := range 1000
+    f := r.nextFloat()
+    assert f >= 0.0
+    assert f < 1.0
+    total = total + f
+  assert total > 400.0
+  assert total < 600.0
+test "seed 0 still produces a varying stream"
+  r := Random(seed: 0)
+  assert r.nextInt() != r.nextInt()

plum-std/Set.plum ADDED Viewed

@@ -0,0 +1,68 @@
+module std
+import std/Map
+import std/List
+import std/Number
+# 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])
+  fun init() -> Set[T] =
+    return Set(map: Map[T, Bool]())
+  # Adds `v`; adding a value already present changes nothing.
+  fun add(self, v: T) -> Unit =
+    self.map.set(v, True)
+  fun has(self, v: T) -> Bool =
+    return self.map.has(v)
+  fun remove(self, v: T) -> Unit =
+    self.map.remove(v)
+  fun length(self) -> Int =
+    return self.map.length()
+  fun isEmpty(self) -> Bool =
+    return self.map.isEmpty()
+  fun clear(self) -> Unit =
+    self.map.clear()
+  # Every member, in no particular order.
+  fun toList(self) -> List[T] =
+    return self.map.keys()
+test "set_dedup: adding duplicates keeps one copy"
+  s := Set[Int]()
+  for i := range 100
+    s.add(i % 10)
+  assert s.length() == 10
+  assert s.has(3)
+  assert s.has(10) == False
+  s.add(3)
+  assert s.length() == 10
+test "remove and clear"
+  s := Set[Int]()
+  s.add(1)
+  s.add(2)
+  s.remove(1)
+  assert s.has(1) == False
+  assert s.has(2)
+  assert s.length() == 1
+  s.remove(99)
+  assert s.length() == 1
+  s.clear()
+  assert s.isEmpty()
+test "toList returns each member once"
+  s := Set[Int]()
+  s.add(5)
+  s.add(5)
+  s.add(7)
+  l := s.toList()
+  assert l.length() == 2
+  assert l.get(0).unwrap() + l.get(1).unwrap() == 12

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

@@ -210,3 +210,58 @@ fn ioExampleCompilesAndRunsCorrectly() {
         vec!["hello from plum".to_string(), "hello, world!".to_string()]
     );
 }
+/// L1 `array_int_native`: `Array[Int]`/`Array[Float]`/`Array[Bool]` lower to
+/// native unboxed wasm-gc arrays (`array (mut i64)` / `(mut f64)` / `(mut i32)`),
+/// not the boxed `array (mut anyref)`.
+#[test]
+fn array_int_native() {
+    use wasmparser::{CompositeInnerType, Parser, Payload, StorageType, ValType};
+    let bytes = assertCompiles("typed_arrays.plum");
+    let mut elems: Vec<ValType> = Vec::new();
+    for payload in Parser::new(0).parse_all(&bytes) {
+        if let Payload::TypeSection(reader) = payload.unwrap() {
+            for rec in reader {
+                for sub in rec.unwrap().into_types() {
+                    if let CompositeInnerType::Array(a) = &sub.composite_type.inner {
+                        if a.0.mutable {
+                            if let StorageType::Val(v) = a.0.element_type {
+                                elems.push(v);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assert!(elems.contains(&ValType::I64), "no (mut i64) array in {:?}", elems);
+    assert!(elems.contains(&ValType::F64), "no (mut f64) array in {:?}", elems);
+    assert!(elems.contains(&ValType::I32), "no (mut i32) array in {:?}", elems);
+}
+/// L1 `const_table_1000_entries`: 1000 top-level consts (placed before and
+/// between other decls) plus a 1000-element list literal parse, type-check and
+/// are usable inside methods.
+#[test]
+fn const_table_1000_entries() {
+    let mut src = String::from("module t\nimport std/Number\nimport std/List\n\n");
+    for i in 0..500 {
+        src.push_str(&format!("E{} = {}\n", i, i * 3 + 1));
+    }
+    src.push_str("enum Holder =\n  | Holder(n: Int)\n\n  fun at(self) -> Int = E499 + self.n\n\n");
+    for i in 500..1000 {
+        src.push_str(&format!("E{} = {}\n", i, i * 3 + 1));
+    }
+    src.push_str("FLAG = True\nDOUBLE = E999 * 2 + 1\n\nfun table() -> List[Int] =\n  return List(");
+    let items: Vec<String> = (0..1000).map(|i| (i * i).to_string()).collect();
+    src.push_str(&items.join(", "));
+    src.push_str(")\n\nfun probe() -> Int =\n  return E999 + DOUBLE\n");
+    let dir = std::env::temp_dir().join(format!("plum_const_table_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("t.plum");
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &libPath()).expect("1000-const file should load");
+    let bytes = compileSource(&source).expect("1000-const file should compile");
+    assert!(wasmparser::validate(&bytes).is_ok());
+    std::fs::remove_dir_all(&dir).ok();
+}