25dce5c | plum | pyrossh

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

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

25dce5c — Peter John 2026-11-01T22:39:21+05:30

docs/test: Array[T] value arrays are unboxed (i64/f64/i32); stale anyref comment fixed

Files changed (3) hide show

plum-std/Array.plum +24 -15
plum-std/List.plum +9 -0
plum-wasm-codegen/tests/examples_test.rs +33 -0

plum-std/Array.plum CHANGED Viewed

@@ -4,16 +4,17 @@ import std/Float
 import std/Str
 # A fixed-length, O(1)-indexable array of `T`, backed directly by a wasm-gc
+# array. `T` is NOT erased: codegen allocates one wasm array type per distinct
+# element representation (see `plum-wasm-codegen`'s native-arrays loop):
+# `Array[Int]` is `array<mut i64>`, `Array[Float]` is `array<mut f64>`,
+# `Array[Bool]`/`Array[Byte]` are `array<mut i32>`, and a reference `T` is
-# `array<anyref>` — `Array[T]` is erased, so every `T` shares the SAME
+# `array<mut ref null T>` (all reference types of the same wasm type share one
-# underlying wasm array type (see
-# `plum-wasm-codegen::GcTypeRegistry::array_type_idx`), exactly like `[]Byte`
-# reuses `Str`'s own array type. `init`/`get`/`set`/`length`/`push`/`resize` are compiler
+# array type). `get`/`set`/`push`/`resize`/`length`/`filled` on the value
+# arrays are plain `array.get`/`array.set`/`array.copy` on the raw elements —
-# intrinsics (see `compileIntrinsicFnBody`) — there's no way to express raw
+# nothing is boxed or allocated per element. `init`/`get`/`set`/`length`/
+# `push`/`resize` are compiler intrinsics (see `compileIntrinsicFnBody`) —
-# array allocation/indexing in Plum source itself.
+# there's no way to express raw array allocation/indexing in Plum source itself.
-#
-# Elements are stored as `anyref`; `T` is erased, so a primitive `T` (`Int`,
-# `Float`, ...) is boxed on `set`/`push` and unboxed on `get` at the call
-# site, like any other generic edge. `List[T]` is built on this.
+# `List[T]` is built on this.
 #
 # `init()` is deliberately zero-arg (no `Array[T](n)` constructor exists) —
 # `class_call`'s grammar (`Type[Generics](...)`) only ever accepts `name:
@@ -26,16 +27,14 @@ import std/Str
 # fixed-length allocation once made), so it allocates a new, one-longer array
 # and copies, same amortized-growth idea as `Buffer`'s own `write`.
 #
-# New elements start out null-shaped — really a null `anyref` under the
+# New slots are the wasm default: null for a reference `T` (so `get` on a
-# hood — so `get` on an index that was never `set` traps rather than
-# returning some default `T` value (there is no way to conjure a default `T`
+# never-`set` index traps), zero for a value `T` (`Int`/`Float`/`Bool`/`Byte`).
-# generically).
 primitive Array[T] =
   # A new, empty array.
   fun init() -> Array[T] =
     todo
-  # The element at index `i`. Traps if `i` is out of range or was never `set`.
+  # The element at index `i`. Traps if `i` is out of range (or, for a reference `T`, was never `set`).
   fun get(self, i: Int) -> T =
     todo
@@ -82,3 +81,13 @@ test "Array is a primitive with working generic methods"
   assert a.get(1) == "y"
   b := Array.filled(3, 7)
   assert b.at(2) == 7
+test "Array[Int] holds a million elements unboxed"
+  a := Array.filled(1000000, 0)
+  i := 0
+  while i < 1000000
+    a.set(i, i * 2)
+    i = i + 1
+  assert a.length() == 1000000
+  assert a.get(999999) == 1999998
+  assert a.get(0) == 0

plum-std/List.plum CHANGED Viewed

@@ -373,3 +373,12 @@ test "list of strings keeps its elements through growth"
     i = i + 1
   assert l.get(39)! == "s39"
   assert l.get(16)! == "s16"
+test "List[Float] push/get round-trips"
+  l := List[Float]()
+  i := 0
+  while i < 1000
+    l.push(Float(i) + 0.5)
+    i = i + 1
+  assert l.length() == 1000
+  assert l.get(999)! == 999.5

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

@@ -231,6 +231,39 @@ fn array_int_native() {
     assert!(elems.contains(&ValType::I32), "no (mut i32) array in {:?}", elems);
 }
+/// Game-perf 1: no mutable array is an erased abstract-ref array, and
+/// `Array[Int]`/`Array[Float]` element storage is exactly i64/f64.
+#[test]
+fn array_elements_are_never_erased_anyref() {
+    use wasmparser::{CompositeInnerType, HeapType, Parser, Payload, StorageType, ValType};
+    let bytes = assertCompiles("typed_arrays.plum");
+    let mut mut_elems: Vec<StorageType> = 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 {
+                            mut_elems.push(a.0.element_type);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for e in &mut_elems {
+        if let StorageType::Val(ValType::Ref(r)) = e {
+            assert!(
+                !matches!(r.heap_type(), HeapType::Abstract { .. }),
+                "mutable array of erased abstract ref: {:?}",
+                mut_elems
+            );
+        }
+    }
+    assert!(mut_elems.contains(&StorageType::Val(ValType::I64)));
+    assert!(mut_elems.contains(&StorageType::Val(ValType::F64)));
+}
 /// L1 `const_table_1000_entries`: 1000 associated consts (spread over two
 /// bodies, before and between other decls) plus a 1000-element list literal
 /// parse, type-check and are usable inside methods.