ea9b8c1 | plum | pyrossh

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

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

ea9b8c1 — Peter John 2026-09-04T17:05:20+05:30

feat(plum): add generic Array[T] primitive, rewrite Map as a real hash table

Files changed (6) hide show

libs/std/array.plum +56 -0
libs/std/int.plum +5 -0
libs/std/json.plum +1 -1
libs/std/map.plum +137 -90
libs/std/str.plum +13 -0
plum-wasm-codegen/src/lib.rs +153 -2

libs/std/array.plum ADDED Viewed

@@ -0,0 +1,56 @@
+module std
+# A fixed-length, O(1)-indexable array of `T`, backed directly by a wasm-gc
+# `array<anyref>` — every `Array[T]` specialization (`Array$Int`, `Array$Str`,
+# ...) shares the SAME 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` are compiler
+# intrinsics (see `compileIntrinsicFnBody`) — there's no way to express raw
+# array allocation/indexing in Plum source itself.
+#
+# LIMITATION: `T` must be a reference type (a `type`/`enum` value, `Str`,
+# `List`, etc.) — every element is stored as a boxed `anyref` and `get`
+# narrows it back to `T` via `ref.cast`. A primitive `T` (`Int`/`Float`/`Bool`/
+# `Byte`) is NOT supported (no boxing/unboxing exists yet) and will not
+# codegen correctly. Nothing in `libs/std` instantiates `Array` with a
+# primitive `T` today — the only user is `Map[K, V]`'s bucket array,
+# `Array[List[Pair[K, V]]]`.
+#
+# `init()` is deliberately zero-arg (no `Array[T](n)` constructor exists) —
+# `class_call`'s grammar (`Type[Generics](...)`) only ever accepts `name:
+# value` field arguments or an empty arg list, never bare positional ones
+# (see `tooling/tree-sitter-plum/grammar.js`'s `class_argument_list`), and
+# `Array` has no real fields for a keyword arg to bind to. Building a
+# specific-length array is `push`ing onto an empty one `n` times instead
+# (`Map`'s bucket array does exactly this at construction) — `push` itself
+# has no in-place "grow" to fall back on either (a wasm-gc `array` is a
+# 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 `None`-shaped — really a null `anyref` under the
+# 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`
+# generically).
+type 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`.
+  fun get(self, i: Int) -> T =
+    todo
+  # Overwrites the element at index `i` with `v`. Traps if `i` is out of range.
+  fun set(self, i: Int, v: T) -> Unit =
+    todo
+  # Number of slots in the array.
+  fun length(self) -> Int =
+    todo
+  # Returns a NEW array, one longer than `self`, with `v` appended at the end
+  # — `self` itself is left untouched (this allocates and copies, it does not
+  # mutate in place). Callers grow in a loop by reassigning: `arr =
+  # arr.push(v)`.
+  fun push(self, v: T) -> Array[T] =
+    todo

libs/std/int.plum CHANGED Viewed

@@ -12,6 +12,11 @@ type Int =
   fun abs(self) -> Int =
     self < 0 ? -self : self
+  # An `Int` already IS its own well-distributed bit pattern — used by
+  # `Map[K: Hashable, V]` (see `map.plum`) to bucket `Int` keys.
+  fun hash(self) -> Int =
+    self
   # An Int is always already whole, so ceil/floor/round/trunc are all just
   # the value itself widened to Float.
   fun ceil(self) -> Float =

libs/std/json.plum CHANGED Viewed

@@ -333,7 +333,7 @@ type JsonParser =
   fun parseObject(self) -> Result[Json, JsonParseError] =
     self.advance()
     self.skipSpace()
-    pairs := Map[Str, Json](items: List[Pair[Str, Json]](head: None, tail: None, size: 0))
+    pairs := Map[Str, Json]()
     if self.peek() == 125
       self.advance()
       return Ok(JsonMap(pairs))

libs/std/map.plum CHANGED Viewed

@@ -1,6 +1,21 @@
 module std
 import std/list
 import std/option
+import std/array
+# Any type usable as a `Map` key needs a `hash`, so keys landing in different
+# buckets (`hash(k) % BUCKET_COUNT`) can be told apart in O(1) without a full
+# linear scan of the whole map — see `Str.hash`/`Int.hash` in `str.plum`/
+# `int.plum` for the two implementations `libs/std` provides today. Declared
+# here (rather than alongside `ToStr`/`Comparable` in `str.plum`) since `Map`
+# is its only real consumer; like `Comparable`/`Readable`/`Writable`
+# elsewhere in `libs/std`, `Str`/`Int` don't formally list it in their own
+# `implements` clause (that would need them to import `map.plum`, an
+# unwanted dependency direction for such foundational types) — this is
+# checked the same "unenforced, trust the method exists" way those already
+# are (see the README's note on `checkTraitConformance`).
+trait Hashable =
+  hash() -> Int
 # A Pair is a grouping of a key with a value.
 #
@@ -18,29 +33,45 @@ type Pair[K, V](ToStr) =
   fun toStr(self) -> Str =
     return "{self.key.toStr()}: {self.val.toStr()}"
-# A Map is an association list — O(n) `get`/`set`/`remove` via a linear scan
+# Number of buckets every `Map` allocates at construction — fixed for the
-# over `items`, not a real hash table (there's no hashing primitive to build
+# map's whole lifetime, no rehashing/resizing as it grows. A real hash table
-# one on). Fine for small maps; a real hash-based `Map` is future work.
-#
-# No `Map`-level `init` constructor here (unlike `List`'s own variadic
+# would grow this as `size` outpaces it (keeping average bucket length, and
-# `init`, or `Buffer`'s no-arg one) — a generic method's own type params can
+# so average `get`/`set` cost, roughly constant); that's future work; for now
+# a big-enough fixed count keeps small-to-medium maps fast in practice.
+BUCKET_COUNT = 16
+# A Map is a hash table: `BUCKET_COUNT` buckets, each an association-list
-# only be inferred from a param whose DECLARED type is directly a bare
+# chain (`List[Pair[K, V]]`) of every key hashing into it — O(1) average
-# letter (`k: K`), not one nested
-# inside another generic type like `...Pair[K, V]` (see
-# `resolveFnInstantiation` in `plum-checker/src/monomorphize.rs`), so a
+# `get`/`set`/`remove` (versus the single, whole-map linear scan a plain
-# variadic-pairs constructor can't be written. Construct a `Map` directly
+# association list costs), degrading to O(n) only if many keys collide into
-# with explicit generics instead:
+# the same bucket.
-#   m := Map[Str, Int](items: List[Pair[Str, Int]](head: None, tail: None, size: 0))
-type Map[K, V] =
+type Map[K: Hashable, V] =
-  items: List[Pair[K, V]]
+  buckets: Array[List[Pair[K, V]]]
+  size: Int
+  # `Map[Str, Int]()` — explicit generics required (nothing in a no-arg call
+  # pins down `K`/`V`), builds `BUCKET_COUNT` empty bucket lists up front via
+  # `Array`'s own `push`-to-grow (see `libs/std/array.plum`'s header comment
+  # on why `Array` itself has no direct "make me length N" constructor).
+  fun init() -> Map[K, V] =
+    b := Array[List[Pair[K, V]]]()
+    i := 0
+    while i < BUCKET_COUNT
+      b = b.push(List[Pair[K, V]]())
+      i = i + 1
+    return Map(buckets: b, size: 0)
+  # `k`'s bucket index — `hash`'s sign is unconstrained (a plain `%` on a
+  # negative `Int` stays negative in Plum, matching wasm's signed
+  # `i64.rem_s`), so this folds a negative result back into `[0,
+  # BUCKET_COUNT)` rather than indexing `buckets` out of range.
+  fun bucketIndex(self, k: K) -> Int =
+    m := k.hash() % BUCKET_COUNT
+    return m < 0 ? m + BUCKET_COUNT : m
-  # Gets the value for `k`, or `None` if absent. NOT written with `for p :=
+  # Gets the value for `k`, or `None` if absent.
-  # range self.items` (a `for`/`range` loop only supports ranging over an
-  # `Int` count or a `...T` variadic pack — `items` is neither, it's a
-  # `List`) — a plain `while`/`match` traversal over the list's own nodes
-  # instead, matching `List`'s own internal methods' idiom.
   fun get(self, k: K) -> Option[V] =
-    current := self.items.head
+    current := self.buckets.get(self.bucketIndex(k)).head
     while current != None
       match current
         Some(Node(Pair(key, val), _, next)) =>
@@ -56,13 +87,11 @@ type Map[K, V] =
   # Sets `k`'s value to `v` — replacing an existing entry for `k` in place
   # (mutating the stored `Pair`'s `val` field) rather than appending a
-  # duplicate, so a repeated `set` on the same key doesn't grow `items`
+  # duplicate, so a repeated `set` on the same key doesn't grow its bucket
-  # unboundedly or leave a stale value reachable by `get`. Destructures only
+  # unboundedly or leave a stale value reachable by `get`.
-  # as far as the `Pair` itself (not its own `key`/`val` fields) — `val` is
-  # MUTATED below, which needs the `Pair` reference kept, not a copy of its
-  # field pulled out by value.
   fun set(self, k: K, v: V) -> Unit =
+    bucket := self.buckets.get(self.bucketIndex(k))
-    current := self.items.head
+    current := bucket.head
     while current != None
       match current
         Some(Node(pair, _, next)) =>
@@ -72,95 +101,91 @@ type Map[K, V] =
           current = next
         None =>
           break
-    self.items.add(Pair(key: k, val: v))
+    bucket.add(Pair(key: k, val: v))
+    self.size = self.size + 1
   # Sets `k`'s value to `v` only if `k` isn't already present.
   fun putIfAbsent(self, k: K, v: V) -> Unit =
     if !self.has(k)
       self.set(k, v)
-  # Removes `k`'s entry, if present. Keeps `node` itself bound (rather than
+  # Removes `k`'s entry, if present.
-  # destructuring further) — `unlink` needs the actual `Node` reference, not
-  # just a copy of its `value` field.
   fun remove(self, k: K) -> Unit =
+    bucket := self.buckets.get(self.bucketIndex(k))
-    current := self.items.head
+    current := bucket.head
     while current != None
       match current
         Some(node) =>
           if node.value.key == k
-            self.items.unlink(node)
+            bucket.unlink(node)
+            self.size = self.size - 1
             return
           current = node.next
         None =>
           break
   fun length(self) -> Int =
-    return self.items.length()
+    return self.size
   fun isEmpty(self) -> Bool =
-    return self.items.length() == 0
+    return self.size == 0
   fun clear(self) -> Unit =
+    i := 0
+    while i < self.buckets.length()
-    self.items.clear()
+      self.buckets.get(i).clear()
+      i = i + 1
+    self.size = 0
-  # Calls `cb` with each key and value in the map, in insertion order.
+  # Calls `cb` with each key and value in the map. Order is bucket order,
+  # then insertion order within a bucket — NOT overall insertion order (that
+  # would need a separate side list to track, which nothing here needs today).
   fun each(self, cb: fn(K, V)) -> Unit =
+    i := 0
+    while i < self.buckets.length()
-    current := self.items.head
+      current := self.buckets.get(i).head
-    while current != None
+      while current != None
-      match current
+        match current
-        Some(Node(Pair(key, val), _, next)) =>
+          Some(Node(Pair(key, val), _, next)) =>
-          cb(key, val)
+            cb(key, val)
-          current = next
+            current = next
-        None =>
+          None =>
-          break
+            break
+      i = i + 1
-  # `keys`/`values` build a `List` of `K`/`V` alone — no NEW generic param
-  # beyond `Map[K, V]`'s own, so (unlike `map` below) these don't need
-  # `resolveMethodOwnGenerics` at all; the class's own already-known `K`/`V`
-  # is enough for the bare `List(...)` construction to resolve (via the
-  # ordinary `current_return_type` fallback every other bare-`List(...)`-
-  # returning method already uses).
   fun keys(self) -> List[K] =
     result := List(head: None, tail: None, size: 0)
-    current := self.items.head
-    while current != None
-      match current
-        Some(Node(Pair(key, _), _, next)) =>
-          result.add(key)
+    self.each(|k, v| result.add(k))
-          current = next
-        None =>
-          break
     return result
   fun values(self) -> List[V] =
     result := List(head: None, tail: None, size: 0)
-    current := self.items.head
-    while current != None
-      match current
-        Some(Node(Pair(_, val), _, next)) =>
-          result.add(val)
+    self.each(|k, v| result.add(v))
-          current = next
-        None =>
-          break
     return result
   fun map(self, cb: fn(K, V) -> Pair[X, Y]) -> Map[X, Y] =
+    b := Array[List[Pair[X, Y]]]()
+    i := 0
+    while i < BUCKET_COUNT
+      b = b.push(List[Pair[X, Y]]())
+      i = i + 1
-    result := Map[X, Y](items: List[Pair[X, Y]](head: None, tail: None, size: 0))
+    result := Map(buckets: b, size: 0)
+    j := 0
+    while j < self.buckets.length()
-    current := self.items.head
+      current := self.buckets.get(j).head
-    while current != None
+      while current != None
-      match current
+        match current
-        Some(Node(Pair(key, val), _, next)) =>
+          Some(Node(Pair(key, val), _, next)) =>
+            pair := cb(key, val)
-          result.items.add(cb(key, val))
+            result.set(pair.key, pair.val)
-          current = next
+            current = next
-        None =>
+          None =>
-          break
+            break
+      j = j + 1
     return result
-fun makeStrIntMapForTest() -> Map[Str, Int] =
-  return Map[Str, Int](items: List[Pair[Str, Int]](head: None, tail: None, size: 0))
 test "get/set/has round-trip and set replaces an existing key in place"
-  m := makeStrIntMapForTest()
+  m := Map[Str, Int]()
   assert m.has("a") == False
   m.set("a", 1)
   assert m.has("a") == True
@@ -171,13 +196,13 @@ test "get/set/has round-trip and set replaces an existing key in place"
   assert m.length() == 1
 test "putIfAbsent only sets a key that isn't already present"
-  m := makeStrIntMapForTest()
+  m := Map[Str, Int]()
   m.putIfAbsent("a", 1)
   m.putIfAbsent("a", 2)
   assert m.get("a").unwrap() == 1
 test "remove deletes an entry and clear empties the map"
-  m := makeStrIntMapForTest()
+  m := Map[Str, Int]()
   m.set("a", 1)
   m.set("b", 2)
   m.remove("a")
@@ -186,15 +211,18 @@ test "remove deletes an entry and clear empties the map"
   m.clear()
   assert m.isEmpty() == True
-test "keys/values list every entry's key/value in insertion order"
+test "keys/values list every entry's key/value"
-  m := makeStrIntMapForTest()
+  m := Map[Str, Int]()
   m.set("a", 1)
   m.set("b", 2)
+  assert m.length() == 2
-  assert m.keys().join(",") == "a,b"
+  assert m.keys().contains("a")
-  assert m.values().join(",") == "1,2"
+  assert m.keys().contains("b")
+  assert m.values().contains(1)
+  assert m.values().contains(2)
 test "each calls the callback with every key and value"
-  m := makeStrIntMapForTest()
+  m := Map[Str, Int]()
   m.set("a", 1)
   m.set("b", 2)
   # A closure captures its outer variables BY VALUE at creation time, so
@@ -202,13 +230,32 @@ test "each calls the callback with every key and value"
   # here — mutate a captured `List` (a class, reference semantics) instead.
   seen := List[Int]()
   m.each(|k, v| seen.add(v))
-  assert seen.join(",") == "1,2"
+  assert seen.length() == 2
+  assert seen.contains(1)
+  assert seen.contains(2)
 test "map transforms every key/value pair into a new map, changing the value type"
-  m := makeStrIntMapForTest()
+  m := Map[Str, Int]()
   m.set("a", 1)
   m.set("b", 2)
   stringified := m.map(|k, v| Pair(key: k, val: v.toStr()))
   assert stringified.get("a").unwrap() == "1"
   assert stringified.get("b").unwrap() == "2"
   assert stringified.length() == 2
+test "many keys landing in the same bucket still resolve correctly (collision chaining)"
+  m := Map[Int, Int]()
+  i := 0
+  while i < 40
+    m.set(i, i * i)
+    i = i + 1
+  assert m.length() == 40
+  j := 0
+  while j < 40
+    assert m.get(j).unwrap() == j * j
+    j = j + 1
+  m.remove(5)
+  assert m.has(5) == False
+  assert m.get(4).unwrap() == 16
+  assert m.get(21).unwrap() == 441
+  assert m.length() == 39

libs/std/str.plum CHANGED Viewed

@@ -22,6 +22,19 @@ type Str(Comparable, ToStr, Readable, Writable) =
   fun byteAt(self, i: Int) -> Int =
     todo
+  # FNV-1a over the raw UTF-8 bytes — used by `Map[K: Hashable, V]` (see
+  # `map.plum`) to bucket `Str` keys. Not cryptographic, just a well-known,
+  # decently-distributed general-purpose hash; wraps silently on overflow
+  # (ordinary 64-bit multiplication), which is fine — only the bit pattern
+  # matters, not the numeric value itself.
+  fun hash(self) -> Int =
+    h := 0xcbf29ce484222325
+    i := 0
+    while i < self.length()
+      h = {h ^ self.byteAt(i)} * 0x100000001b3
+      i = i + 1
+    return h
   # The single-character substring at index `i`. (Was declared to return a
   # `Char` type, but `Char` was never actually defined anywhere in `libs/std` —
   # returning a length-1 `Str` instead makes it immediately usable with every

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -623,6 +623,22 @@ pub struct GcTypeRegistry {
     /// `[count][elem...]` blob — `array.len` replaces the explicit count). Populated
     /// alongside `closure_type_idx`, from every `ParamType::Variadic` in the program.
     pub variadic_array_type_idx: HashMap<ValType, u32>,
+    /// The single shared `array<anyref>` type index every `Array[T]`
+    /// specialization (`Array$Int`, `Array$Str`, ...) uses regardless of its own
+    /// `T` — see `libs/std/array.plum`'s header comment. `0` (the `Str` slot,
+    /// harmlessly never read as such) until/unless the program actually
+    /// instantiates `Array` at least once.
+    pub array_type_idx: u32,
+}
+/// Whether `name` is `Array` itself or one of its monomorphized specializations
+/// (`Array$Int`, `Array$List$Pair$Str$Int`, ...) — every such class shares one
+/// physical wasm-gc array type (`GcTypeRegistry::array_type_idx`) instead of
+/// getting its own struct type, and its `init`/`get`/`set`/`length` methods are
+/// compiler intrinsics rather than compiled `todo` bodies (see
+/// `compileIntrinsicFnBody`).
+fn isArraySpecialization(name: &str) -> bool {
+    name == "Array" || name.starts_with("Array$")
 }
 /// Resolves a plum type to the wasm-gc `ValType` its values are represented as, given
@@ -683,6 +699,9 @@ fn buildGcTypeRegistry(
         Class(String),
         EnumSuper(String),
         Variant(String),
+        /// The single shared `array<anyref>` type every `Array[T]`
+        /// specialization aliases — see `isArraySpecialization`.
+        ArrayRef,
     }
     // Pass 1: assign every entry a slot (and therefore a type index) up front, before
@@ -691,11 +710,21 @@ fn buildGcTypeRegistry(
     let mut class_type_idx: HashMap<String, u32> = HashMap::new();
     let mut enum_super_type_idx: HashMap<String, u32> = HashMap::new();
     let mut variant_type_idx: HashMap<String, u32> = HashMap::new();
+    let mut array_ref_slot: Option<u32> = None;
     for item in &source.items {
         if let ast::Item::Class(c) = item {
+            if isArraySpecialization(&c.name) {
+                let idx = *array_ref_slot.get_or_insert_with(|| {
+                    let idx = slots.len() as u32;
+                    slots.push(Slot::ArrayRef);
+                    idx
+                });
+                class_type_idx.insert(c.name.clone(), idx);
+            } else {
-            class_type_idx.insert(c.name.clone(), slots.len() as u32);
+                class_type_idx.insert(c.name.clone(), slots.len() as u32);
-            slots.push(Slot::Class(c.name.clone()));
+                slots.push(Slot::Class(c.name.clone()));
+            }
         }
     }
@@ -743,6 +772,7 @@ fn buildGcTypeRegistry(
         str_type_idx: 0,
         closure_type_idx: 0,
         variadic_array_type_idx: HashMap::new(),
+        array_type_idx: array_ref_slot.unwrap_or(0),
     };
     // Pass 2: build the real SubType for every slot, now that every cross-reference
@@ -808,6 +838,17 @@ fn buildGcTypeRegistry(
                 composite_type: CompositeType { inner: CompositeInnerType::Struct(StructType { fields: field_types.into() }), shared: false },
             }
         }
+        Slot::ArrayRef => SubType {
+            is_final: true,
+            supertype_idx: None,
+            composite_type: CompositeType {
+                inner: CompositeInnerType::Array(ArrayType(FieldType {
+                    element_type: StorageType::Val(ValType::Ref(RefType::ANYREF)),
+                    mutable: true,
+                })),
+                shared: false,
+            },
+        },
     }).collect();
     module.addGcTypes(subtypes);
@@ -1708,6 +1749,11 @@ fn registerIntToStringHelper(module: &mut WasmModule, str_type_idx: u32) -> u32
 /// here — by `fnKey` — instead of compiling their `todo` body to `unreachable`.
 /// Returns `None` for any other function, meaning "compile it normally."
 fn compileIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
+    if let Some(recv) = f.type_param.as_deref() {
+        if isArraySpecialization(recv) {
+            return compileArrayIntrinsicFnBody(f);
+        }
+    }
     let str_type_idx = withGcTypes(|r| r.str_type_idx);
     match (f.type_param.as_deref(), f.name.as_str()) {
         // Str.length(self) -> Int
@@ -1838,6 +1884,111 @@ fn compileIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
     }
 }
+/// `Array[T]`'s `init`/`get`/`set`/`length` — every specialization (`Array$Int`,
+/// `Array$List$Pair$Str$Int`, ...) shares ONE wasm-gc `array<anyref>` type
+/// (`GcTypeRegistry::array_type_idx`, see `isArraySpecialization`), so these
+/// compile identically regardless of which concrete `T` this specialization is
+/// for. Every `type_param`-bearing `Fn` — methods AND non-`self` nested
+/// "static" constructors like `init` (see `fnWasmParamTypes`) — gets an
+/// implicit receiver as wasm param 0, so a declared plum param at position `k`
+/// is always wasm local `k + 1`. `get` is the one case that also needs a
+/// `ref.cast` back from the raw stored `anyref` down to `T`'s own concrete
+/// type; `set`/`init` need no such cast the other way, since any concrete ref
+/// is already a valid subtype wherever `anyref` is expected.
+fn compileArrayIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
+    let array_type_idx = withGcTypes(|r| r.array_type_idx);
+    match f.name.as_str() {
+        // init() -> Array[T] — always starts empty; see `push` for how a
+        // specific length is actually built up.
+        "init" => {
+            let mut body = vec![0u8];
+            Instruction::I32Const(0).encode(&mut body);
+            Instruction::ArrayNewDefault(array_type_idx).encode(&mut body);
+            Instruction::End.encode(&mut body);
+            Some(body)
+        }
+        // push(self, v: T) -> Array[T] — a new array one longer than `self`,
+        // `self`'s elements copied in, `v` appended at the end. `self` itself
+        // is left untouched (wasm-gc arrays are fixed-length once allocated).
+        "push" => {
+            const SELF: u32 = 0;
+            const V: u32 = 1;
+            const OLD_LEN: u32 = 2;
+            const NEW_ARR: u32 = 3;
+            let array_ref = gcRef(array_type_idx);
+            let mut body = Vec::new();
+            body.extend(encodeLeb128U32(2)); // two locals groups
+            body.extend(encodeLeb128U32(1)); // old_len: i32
+            ValType::I32.encode(&mut body);
+            body.extend(encodeLeb128U32(1)); // new_arr: ref
+            array_ref.encode(&mut body);
+            Instruction::LocalGet(SELF).encode(&mut body);
+            Instruction::ArrayLen.encode(&mut body);
+            Instruction::LocalSet(OLD_LEN).encode(&mut body);
+            Instruction::LocalGet(OLD_LEN).encode(&mut body);
+            Instruction::I32Const(1).encode(&mut body);
+            Instruction::I32Add.encode(&mut body);
+            Instruction::ArrayNewDefault(array_type_idx).encode(&mut body);
+            Instruction::LocalSet(NEW_ARR).encode(&mut body);
+            // array.copy(dst=new_arr, dst_offset=0, src=self, src_offset=0, len=old_len)
+            Instruction::LocalGet(NEW_ARR).encode(&mut body);
+            Instruction::I32Const(0).encode(&mut body);
+            Instruction::LocalGet(SELF).encode(&mut body);
+            Instruction::I32Const(0).encode(&mut body);
+            Instruction::LocalGet(OLD_LEN).encode(&mut body);
+            Instruction::ArrayCopy { array_type_index_dst: array_type_idx, array_type_index_src: array_type_idx }.encode(&mut body);
+            // new_arr[old_len] = v
+            Instruction::LocalGet(NEW_ARR).encode(&mut body);
+            Instruction::LocalGet(OLD_LEN).encode(&mut body);
+            Instruction::LocalGet(V).encode(&mut body);
+            Instruction::ArraySet(array_type_idx).encode(&mut body);
+            Instruction::LocalGet(NEW_ARR).encode(&mut body);
+            Instruction::End.encode(&mut body);
+            Some(body)
+        }
+        "get" => {
+            let mut body = vec![0u8];
+            Instruction::LocalGet(0).encode(&mut body); // self
+            Instruction::LocalGet(1).encode(&mut body); // i
+            Instruction::I32WrapI64.encode(&mut body);
+            Instruction::ArrayGet(array_type_idx).encode(&mut body);
+            // Narrow the raw `anyref` element back to `T`'s own concrete type —
+            // skipped when `T` itself resolves to a bare `anyref` (nothing to cast to).
+            if let Some(ValType::Ref(RefType { heap_type: HeapType::Concrete(idx), .. })) =
+                f.returns.as_ref().and_then(|t| astTypeToWasm(&t.name))
+            {
+                Instruction::RefCastNullable(HeapType::Concrete(idx)).encode(&mut body);
+            }
+            Instruction::End.encode(&mut body);
+            Some(body)
+        }
+        "set" => {
+            let mut body = vec![0u8];
+            Instruction::LocalGet(0).encode(&mut body); // self
+            Instruction::LocalGet(1).encode(&mut body); // i
+            Instruction::I32WrapI64.encode(&mut body);
+            Instruction::LocalGet(2).encode(&mut body); // v
+            Instruction::ArraySet(array_type_idx).encode(&mut body);
+            Instruction::End.encode(&mut body);
+            Some(body)
+        }
+        "length" => {
+            let mut body = vec![0u8];
+            Instruction::LocalGet(0).encode(&mut body); // self
+            Instruction::ArrayLen.encode(&mut body);
+            Instruction::I64ExtendI32U.encode(&mut body);
+            Instruction::End.encode(&mut body);
+            Some(body)
+        }
+        _ => None,
+    }
+}
 /// The `PlumType` of a declared parameter, including `fn(...)`-typed params as `TFun`.
 fn paramPlumType(pt: &ast::ParamType) -> PlumType {
     match pt {