378ab1a | plum | pyrossh

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

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

378ab1a — Peter John 2026-10-26T20:31:02+05:30

refactor(std): drop closure iteration methods from List and Map

Files changed (12) hide show

README.md +7 -4
plum-examples/chains.plum +1 -1
plum-examples/generics.plum +18 -8
plum-std/Http.plum +17 -8
plum-std/Iter.plum +25 -0
plum-std/Json.plum +9 -1
plum-std/List.plum +0 -92
plum-std/Map.plum +5 -65
plum-std/Os.plum +6 -2
plum-std/Set.plum +10 -1
plum-std/Str.plum +2 -2
plum-wasm-codegen/tests/codegen_tests.rs +60 -34

README.md CHANGED Viewed

@@ -246,7 +246,7 @@ A parameter typed `src: *T` is a sequence: the caller passes a list or another `
 #### Chains without closures
-A closure chain such as `units.filter(|u| u.team == me.team).map(|u| u.hp).sum()` is written as a single `for`:
+`List` and `Map` have no closure-taking iteration methods (no `each`/`map`/`filter`/`reduce`/`find`/`any`/`partition`): transformation is written with `for` forms from `std/Iter`. A chain such as "keep my team's units, take their hp, sum it" is a single `for`:
 - per-element stages are header clauses: filter is `, if cond`, map is `, name := expr`;
 - the terminal step is the outer form plus its body (`fold`, `map`, `find`, `count`, `any`, `all`);
@@ -271,7 +271,7 @@ lines := for i, u := map(indexed(take(5, units))), if u.hp > 0.0
   "{i}: {u.name}"
 ```
-The closure methods (`units.map(|u| ...)`) stay for passing behavior around as values. See [`plum-examples/chains.plum`](plum-examples/chains.plum), [`plum-examples/forms.plum`](plum-examples/forms.plum) and [`plum-std/Iter.plum`](plum-std/Iter.plum).
+Closures remain in the language for passing behavior around as values (`Num` below, `Try.map`). Walk a `Map` with `for k, v := entries(m)` (`keys(m)`, `values(m)` for one side; all from `std/Iter`). See [`plum-examples/chains.plum`](plum-examples/chains.plum), [`plum-examples/forms.plum`](plum-examples/forms.plum) and [`plum-std/Iter.plum`](plum-std/Iter.plum).
 ## Testing
@@ -355,7 +355,10 @@ enum Num[T] =
   | Num(add: fn(T, T) -> T, zero: T)
 fun sumWith(xs: List[T], num: Num[T]) -> T =
+  acc := num.zero
+  for x := xs
-  xs.reduce(num.zero, |acc, x| num.add(acc, x))
+    acc = num.add(acc, x)
+  acc
 intNum := Num(add: |a, b| a + b, zero: 0)
 floatNum := Num(add: |a, b| a + b, zero: 0.0)
@@ -597,6 +600,6 @@ It's sugar for `obj.andThen(|v| v.field)` (the plain field value is auto-wrapped
 - **`Buffer`** (`import std/Buffer`) — a growable, mutable byte sequence for building up a `Str`, amortized O(n) writes
 - **`Array[T]`** (`import std/Array`) — the compiler-intrinsic generic array that `List` and `Map` are written on
 - **`Map[K, V]`** (`import std/Map`) — a real bucketed hash table
-- **`List[T]`** (`import std/List`) — a growable list built on `Array`, with `get`/`add`/`set`/`removeAt`/`remove`/`each`/`map`/`reduce`/`sort`/`join`/`chunk`/`partition`
+- **`List[T]`** (`import std/List`) — a growable list built on `Array`, with `get`/`add`/`set`/`removeAt`/`remove`/`sort`/`join`/`chunk` (iteration and transformation via `for`)
 See [`plum-examples/`](plum-examples) for a runnable file per feature above, and [`plum-std/`](plum-std) for the standard library source.

plum-examples/chains.plum CHANGED Viewed

@@ -6,7 +6,7 @@ import std/Iter
 # Closure-free chains. A method chain such as
 #
-#   units.filter(|u| u.team == me.team).map(|u| u.hp).sum()
+#   keep my team's units, take their hp, sum it
 #
 # becomes ONE `for` over the sequence:
 #

plum-examples/generics.plum CHANGED Viewed

@@ -75,7 +75,10 @@ enum Num[T] =
   | Num(add: fn(T, T) -> T, zero: T)
 fun sumWith(xs: List[T], num: Num[T]) -> T =
+  acc := num.zero
+  for x := xs
-  xs.reduce(num.zero, |acc, x| num.add(acc, x))
+    acc = num.add(acc, x)
+  acc
 test "Int extremes survive a generic fn"
   big := 9223372036854775807
@@ -170,14 +173,16 @@ test "List[List[Map[Str, Try[Int, [A]]]]] builds and reads back"
   assert {readDeep(outer, 1, 0, "big") ?? 0} == 9223372036854775807
   assert {readDeep(outer, 2, 0, "big") ?? 97} == 97
-test "a method's own generic is chosen per call on a generic receiver"
+test "a generic receiver's methods are chosen per element type"
   ints := List(1, 22, 333)
+  strs := List[Str]()
+  for n := ints
-  strs := ints.map(|n| "n{n}")
+    strs.push("n{n}")
   assert strs.join(",") == "n1,n22,n333"
+  lens := List[Int]()
+  for s := strs
-  lens := strs.map(|s| s.length())
+    lens.push(s.length())
   assert lens.join(",") == "2,3,4"
-  back := lens.map(|n| n * 10)
-  assert back.reduce(0, |a, b| a + b) == 90
 test "closures nested three deep capture Int and Str locals through generic params"
   k := 5
@@ -198,8 +203,13 @@ test "a duck-typed generic fn dispatches statically per instantiation"
   shapes := List[Circle]()
   shapes.push(Circle(r: 2.0))
   shapes.push(Circle(r: 3.0))
+  names := List[Str]()
+  total := 0.0
+  for s := shapes
+    names.push(s.name())
+    total = total + s.area()
-  assert shapes.map(|s| s.name()).join(",") == "circle,circle"
+  assert names.join(",") == "circle,circle"
-  assert shapes.reduce(0.0, |acc, s| acc + s.area()) == 39.0
+  assert total == 39.0
 test "one generic fn serves Int, Str and a class in the same program"
   assert id(3) == 3

plum-std/Http.plum CHANGED Viewed

@@ -46,12 +46,21 @@ extern fun rawHttpRequest(method: Str, url: Str, headers: Str, body: Str) -> Str
 # expects for its own `headers` argument.
 fun encodeHeaders(headers: Map[Str, Str]) -> Str =
   buf := Buffer()
+  i := 0
+  while i < headers.buckets.length()
-  headers.each(|k, v|
+    bucket := headers.buckets.get(i)
+    j := 0
+    while j < bucket.size
+      pair := bucket.data.get(j)
+      k := pair.key
+      v := pair.val
-    if buf.length() > 0
+      if buf.length() > 0
-      buf.write("\n")
+        buf.write("\n")
-    buf.write(k)
+      buf.write(k)
-    buf.write(": ")
+      buf.write(": ")
-    buf.write(v))
+      buf.write(v)
+      j = j + 1
+    i = i + 1
   return buf.toStr()
 # The reverse of `encodeHeaders`, for the response headers `rawHttpRequest`
@@ -60,12 +69,12 @@ fun decodeHeaders(raw: Str) -> Map[Str, Str] =
   result := emptyHeaders()
   if raw == ""
     return result
-  raw.split("\n", 0).each(|line|
+  for line := raw.split("\n", 0)
     idx := line.indexOf(": ")
     if idx >= 0
       key := line.sub(0, idx)
       val := line.sub(idx + 2, line.length())
-      result.set(key, val))
+      result.set(key, val)
   return result
 # Performs a single HTTP request and waits for the full response. Fails

plum-std/Iter.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/Number
 import std/List
+import std/Map
 import std/Try
 # Iterators: `for u := filter(units)` expands the `fun*`'s body at the call
@@ -161,3 +162,27 @@ fun* chunks(size: Int, xs: List[T]) *List[T] =
     piece := xs.sublist(start, stop)
     start = stop
     yield piece
+# ---- Map: bucket order, then insertion order within a bucket ---------------
+# `for k, v := entries(m)`: every key with its value.
+fun* entries(m: Map[K, V]) *(K, V) =
+  i := 0
+  while i < m.buckets.length()
+    bucket := m.buckets.at(i)
+    j := 0
+    while j < bucket.size
+      pair := bucket.data.get(j)
+      j = j + 1
+      yield pair.key, pair.val
+    i = i + 1
+# `for k := keys(m)`.
+fun* keys(m: Map[K, V]) *K =
+  for k, v := entries(m)
+    yield k
+# `for v := values(m)`.
+fun* values(m: Map[K, V]) *V =
+  for k, v := entries(m)
+    yield v

plum-std/Json.plum CHANGED Viewed

@@ -368,7 +368,15 @@ fun jsonStrValue(j: Json) -> Str =
 # reference (as `appendJsonPair` does to `buf`) does.
 fun jsonMapToStr(pairs: Map[Str, Json]) -> Str =
   buf := Buffer()
+  i := 0
+  while i < pairs.buckets.length()
+    bucket := pairs.buckets.get(i)
+    j := 0
+    while j < bucket.size
+      pair := bucket.data.get(j)
-  pairs.each(|k, v| appendJsonPair(buf, k, v))
+      appendJsonPair(buf, pair.key, pair.val)
+      j = j + 1
+    i = i + 1
   return buf.toStr()
 fun appendJsonPair(buf: Buffer, k: Str, v: Json) -> Unit =

plum-std/List.plum CHANGED Viewed

@@ -146,76 +146,6 @@ enum List[T] =
   fun contains(self, v: T) -> Bool =
     return self.find(v).isOk()
-  # calls f for each elem in the list
-  fun each(self, cb: fn(T)) -> Unit =
-    i := 0
-    while i < self.size
-      cb(self.data.get(i))
-      i = i + 1
-  # Returns a new list with each element transformed by `cb`. `U` is a
-  # generic param of `map` itself, separate from `List[T]`'s own `T`.
-  fun map(self, cb: fn(T) -> U) -> List[U] =
-    result := List[U]()
-    i := 0
-    while i < self.size
-      result.push(cb(self.data.get(i)))
-      i = i + 1
-    return result
-  # returns a new list with each element flat-mapped
-  fun flatMap(self) =
-    todo
-  # Returns a new list with only the elements `predicate` holds for.
-  fun retain(self, predicate: fn(T) -> Bool) -> List[T] =
-    result := List[T]()
-    i := 0
-    while i < self.size
-      value := self.data.get(i)
-      if predicate(value)
-        result.push(value)
-      i = i + 1
-    return result
-  # Returns a new list with the elements `predicate` holds for removed.
-  fun reject(self, predicate: fn(T) -> Bool) -> List[T] =
-    result := List[T]()
-    i := 0
-    while i < self.size
-      value := self.data.get(i)
-      if !predicate(value)
-        result.push(value)
-      i = i + 1
-    return result
-  fun any(self, predicate: fn(T) -> Bool) -> Bool =
-    i := 0
-    while i < self.size
-      if predicate(self.data.get(i))
-        return True
-      i = i + 1
-    return False
-  fun every(self, predicate: fn(T) -> Bool) -> Bool =
-    i := 0
-    while i < self.size
-      if !predicate(self.data.get(i))
-        return False
-      i = i + 1
-    return True
-  # Folds `self`'s elements into a single value, starting from `acc` and
-  # combining each element in with `cb(accumulatedSoFar, element)`. `U` is
-  # `reduce`'s own generic param (the accumulator's type).
-  fun reduce(self, acc: U, cb: fn(U, T) -> U) -> U =
-    result := acc
-    i := 0
-    while i < self.size
-      result = cb(result, self.data.get(i))
-      i = i + 1
-    return result
   # returns the first element in the list
   fun first(self) -> T ! [ListWasEmpty] =
     if self.size == 0
@@ -287,15 +217,6 @@ enum List[T] =
       i = i + size
     return result
-  # Splits into two lists: elements `predicate` holds for, then the rest —
-  # in that order. Returns them as a 2-element `List[List[T]]` (`[matched,
-  # unmatched]`) since this language has no tuple type.
-  fun partition(self, predicate: fn(T) -> Bool) -> List[List[T]] =
-    result := List[List[T]]()
-    result.push(self.retain(predicate))
-    result.push(self.reject(predicate))
-    return result
   # Grouping by an arbitrary key type would need `Map[K, List[T]]`, but
   # `Map.plum` depends on this file. Not implemented.
   fun groupBy(self) =
@@ -382,12 +303,6 @@ test "List[Int]() with no args runs init() and produces a working empty list"
 test "List(values) with positional args runs init(values) directly, infers T from args"
   assert exerciseListInitWithValues() == 43
-test "list map and reduce work correctly"
-  l = List(1, 2, 3, 4)
-  doubled = l.map(|v| v * 2)
-  total = doubled.reduce(0, |acc, v| acc + v)
-  assert total == 20
 test "list equals compares elementwise"
   a = List(1, 2, 3)
   b = List(1, 2, 3)
@@ -420,13 +335,6 @@ test "chunk splits into sublists of at most size elements each"
   assert chunks.get(2).unwrap().join(",") == "5"
   assert l.chunk(0).length() == 0
-test "partition splits into elements matching a predicate, then the rest"
-  l := List(1, 2, 3, 4, 5, 6)
-  parts := l.partition(|v| v % 2 == 0)
-  assert parts.length() == 2
-  assert parts.get(0).unwrap().join(",") == "2,4,6"
-  assert parts.get(1).unwrap().join(",") == "1,3,5"
 test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty is Err"
   l := List[Int]()
   i := 0

plum-std/Map.plum CHANGED Viewed

@@ -109,44 +109,6 @@ enum Map[K, V] =
       i = i + 1
     self.size = 0
-  # 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()
-      bucket := self.buckets.get(i)
-      j := 0
-      while j < bucket.size
-        pair := bucket.data.get(j)
-        cb(pair.key, pair.val)
-        j = j + 1
-      i = i + 1
-  fun keys(self) -> List[K] =
-    result := List[K]()
-    self.each(|k, v| result.add(k))
-    return result
-  fun values(self) -> List[V] =
-    result := List[V]()
-    self.each(|k, v| result.add(v))
-    return result
-  fun map(self, cb: fn(K, V) -> Pair[X, Y]) -> Map[X, Y] =
-    result := Map[X, Y]()
-    i := 0
-    while i < self.buckets.length()
-      bucket := self.buckets.get(i)
-      j := 0
-      while j < bucket.size
-        pair := bucket.data.get(j)
-        mapped := cb(pair.key, pair.val)
-        result.set(mapped.key, mapped.val)
-        j = j + 1
-      i = i + 1
-    return result
 test "get/set/has round-trip and set replaces an existing key in place"
   m := Map[Str, Int]()
   assert m.has("a") == False
@@ -174,37 +136,15 @@ 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"
+test "removing then re-adding keys keeps lookups correct"
   m := Map[Str, Int]()
   m.set("a", 1)
   m.set("b", 2)
+  m.remove("a")
+  m.set("a", 3)
+  assert m.get("a").unwrap() == 3
+  assert m.get("b").unwrap() == 2
   assert m.length() == 2
-  assert m.keys().contains("a")
-  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 := Map[Str, Int]()
-  m.set("a", 1)
-  m.set("b", 2)
-  # A closure captures its outer variables BY VALUE at creation time, so
-  # reassigning a captured `Int` inside the callback wouldn't be visible out
-  # here — mutate a captured `List` (a class, reference semantics) instead.
-  seen := List[Int]()
-  m.each(|k, v| seen.add(v))
-  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 := 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]()

plum-std/Os.plum CHANGED Viewed

@@ -175,11 +175,15 @@ fun opendir(path: Str) =
 fun readdir(path: Str) -> Try[List[Str], Str] =
   if !exists(path)
     return Err("no such directory: '{path}'")
-  # `reject`ing empty names handles both a genuinely empty directory (whose
+  # skipping empty names handles both a genuinely empty directory (whose
   # joined `""` would otherwise split into one bogus `""` entry) and
   # `rawReadDir`'s "unreadable" fallback (already ruled out by the `exists`
   # check above) the same way — no directory entry is ever named `""`.
+  names := List[Str]()
-  return Ok(rawReadDir(path).split("\n", 0).reject(|n| n == ""))
+  for n := rawReadDir(path).split("\n", 0)
+    if n != ""
+      names.push(n)
+  return Ok(names)
 fun readlink(path: Str) -> Try[Str, Str] =
   if !exists(path)

plum-std/Set.plum CHANGED Viewed

@@ -33,7 +33,16 @@ enum Set[T] =
   # Every member, in no particular order.
   fun toList(self) -> List[T] =
+    result := List[T]()
+    i := 0
+    while i < self.map.buckets.length()
-    return self.map.keys()
+      bucket := self.map.buckets.get(i)
+      j := 0
+      while j < bucket.size
+        result.push(bucket.data.get(j).key)
+        j = j + 1
+      i = i + 1
+    return result
 test "set_dedup: adding duplicates keeps one copy"
   s := Set[Int]()

plum-std/Str.plum CHANGED Viewed

@@ -589,8 +589,8 @@ test "string interpolation supports a boolean expression, not just a bare variab
 test "string interpolation supports a method call taking a closure literal"
   l := List(1, 2, 3, 4)
-  assert "{l.any(|x| x % 2 == 0)}" == "True"
+  assert "{l.find(3).unwrap()}" == "3"
-  assert "{l.any(|x| x > 100)}" == "False"
+  assert "{l.contains(100)}" == "False"
 test "string interpolation supports a ternary expression"
   n := 5

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

@@ -1613,7 +1613,10 @@ enum Shape =
       Square(s) => s * s
 fun total(xs: List[Shape]) -> Float =
+  sum := 0.0
+  for x := xs
-  xs.reduce(0.0, |acc, x| acc + x.area())
+    sum = sum + x.area()
+  sum
 fun main() -> Float =
   xs := List[Shape]()
@@ -1659,10 +1662,11 @@ import std/Try
 import std/List
 fun main() -> Int =
-  xs := List(1, 2, 3).map(|n| n * 2)
+  xs := mapList(List(1, 2, 3), |n| n * 2)
-  xs.reduce(0, |acc, x| acc + x)
+  reduceList(xs, 0, |acc, x| acc + x)
 ";
+    let src = format!("{src}\n{LIST_FNS}");
-    assert_eq!(runMerged::<i64>("thunk", src), 12);
+    assert_eq!(runMerged::<i64>("thunk", &src), 12);
 }
 #[test]
@@ -1707,6 +1711,28 @@ fn compiledKeys(name: &str, src: &str) -> (Vec<u8>, Vec<String>) {
     r
 }
+const LIST_FNS: &str = "\
+fun mapList(xs: List[T], cb: fn(T) -> U) -> List[U] =
+  result := List[U]()
+  for x := xs
+    result.push(cb(x))
+  result
+fun reduceList(xs: List[T], acc: U, cb: fn(U, T) -> U) -> U =
+  result := acc
+  for x := xs
+    result = cb(result, x)
+  result
+fun retainList(xs: List[T], keep: fn(T) -> Bool) -> List[T] =
+  result := List[T]()
+  for x := xs
+    if keep(x)
+      result.push(x)
+  result
+";
 const STD_HEAD: &str = "\
 import std/Str
 import std/Number
@@ -1716,27 +1742,27 @@ import std/List
 #[test]
 fn one_copy_per_distinct_type() {
-    let src = format!("{}\
+    let src = format!("{}{}\
 fun main() -> Int =
-  a := List(1, 2).map(|n| n + 1)
+  a := mapList(List(1, 2), |n| n + 1)
-  b := List(\"x\", \"y\").map(|s| s + \"!\")
+  b := mapList(List(\"x\", \"y\"), |s| s + \"!\")
   a.length() + b.length()
-", STD_HEAD);
+", STD_HEAD, LIST_FNS);
     let (_, keys) = compiledKeys("copy2", &src);
-    let maps: Vec<&String> = keys.iter().filter(|k| k.starts_with("List[") && k.contains("].map")).collect();
+    let maps: Vec<&String> = keys.iter().filter(|k| k.starts_with("mapList")).collect();
     assert_eq!(maps.len(), 2, "got {:?}", maps);
-    assert!(keys.iter().any(|k| k.starts_with("List[Int].map")), "{:?}", maps);
+    assert!(keys.iter().any(|k| k.starts_with("mapList") && k.contains("Int")), "{:?}", maps);
-    assert!(keys.iter().any(|k| k.starts_with("List[Str].map")), "{:?}", maps);
+    assert!(keys.iter().any(|k| k.starts_with("mapList") && k.contains("Str")), "{:?}", maps);
     assert!(!keys.iter().any(|k| k.contains('$')), "mangled names remain");
-    let src = format!("{}\
+    let src = format!("{}{}\
 fun main() -> Int =
-  a := List(1, 2).map(|n| n + 1)
+  a := mapList(List(1, 2), |n| n + 1)
-  b := List(3).map(|n| n * 2)
+  b := mapList(List(3), |n| n * 2)
   a.length() + b.length()
-", STD_HEAD);
+", STD_HEAD, LIST_FNS);
     let (_, keys) = compiledKeys("copy1", &src);
-    let maps: Vec<&String> = keys.iter().filter(|k| k.starts_with("List[") && k.contains("].map")).collect();
+    let maps: Vec<&String> = keys.iter().filter(|k| k.starts_with("mapList")).collect();
     assert_eq!(maps.len(), 1, "got {:?}", maps);
 }
@@ -1795,16 +1821,16 @@ fn namedBodies(bytes: &[u8]) -> Vec<(String, Vec<String>)> {
 #[test]
 fn no_boxes_in_list_int_map() {
-    let src = format!("{}\
+    let src = format!("{}{}\
 fun main() -> Int =
-  List(1, 2).map(|n| n + 1).length()
+  mapList(List(1, 2), |n| n + 1).length()
-", STD_HEAD);
+", STD_HEAD, LIST_FNS);
     let (bytes, _) = compiledKeys("nobox", &src);
     let bodies = namedBodies(&bytes);
     let (name, ops) = bodies
         .iter()
-        .find(|(n, _)| n.starts_with("List[Int].map"))
+        .find(|(n, _)| n.starts_with("mapList"))
-        .expect("List[Int].map compiled");
+        .expect("mapList compiled");
     assert!(!ops.is_empty(), "{name}");
     let box_idx: Vec<u32> = {
         // function indices of the box helpers
@@ -2125,24 +2151,24 @@ fun main() -> Int =
 #[test]
 fn closure_calls_fn_param() {
-    let src = format!("{}\
+    let src = format!("{}{}\
 fun apply(xs: List[Int], cb: fn(Int) -> Int) -> List[Int] =
-  xs.map(|x| cb(x))
+  mapList(xs, |x| cb(x))
 fun main() -> Int =
-  apply(List(1, 2, 3), |n| n * 10).reduce(0, |a, b| a + b)
+  reduceList(apply(List(1, 2, 3), |n| n * 10), 0, |a, b| a + b)
-", STD_HEAD);
+", STD_HEAD, LIST_FNS);
     assert_eq!(runMerged::<i64>("closurefnparam", &src), 60);
 }
 #[test]
 fn record_of_fns_passed_explicitly() {
-    let src = format!("{}\
+    let src = format!("{}{}\
 enum Num[T] =
   | Num(add: fn(T, T) -> T, zero: T)
 fun sumWith(xs: List[T], num: Num[T]) -> T =
-  xs.reduce(num.zero, |a, b| num.add(a, b))
+  reduceList(xs, num.zero, |a, b| num.add(a, b))
 fun main() -> Int =
   intNum := Num(add: |a, b| a + b, zero: 0)
@@ -2150,7 +2176,7 @@ fun main() -> Int =
   if sumWith(List(1, 2, 3), intNum) == 6 && sumWith(List(1.5, 2.5), floatNum) == 4.0
     return 1
   return 0
-", STD_HEAD);
+", STD_HEAD, LIST_FNS);
     assert_eq!(runMerged::<i64>("recfns", &src), 1);
     let (_, keys) = compiledKeys("recfnskeys", &src);
     let inst: Vec<&String> = keys.iter().filter(|k| k.starts_with("sumWith")).collect();
@@ -2405,16 +2431,16 @@ fun main() -> Int =
 #[test]
 fn const_list_table() {
-    let src = format!("{}\
+    let src = format!("{}{}\
 TABLE = List(10, 20, 30)
 fun total() -> Int =
-  TABLE.reduce(0, |a, b| a + b)
+  reduceList(TABLE, 0, |a, b| a + b)
 fun main() -> Int =
   TABLE.push(4)
   TABLE.get(1).unwrap() + TABLE.length() + total() - 78 + 4
-", STD_HEAD);
+", STD_HEAD, LIST_FNS);
     // TABLE is a single shared object, initialised once: push(4) persists, so
     // total() sees 64 (60 + 4), length 4, get(1) 20 -> 20 + 4 + 64 - 78 + 4 = 14
     assert_eq!(runMerged::<i64>("constlist", &src), 14);
@@ -2487,14 +2513,14 @@ fun main() -> Int =
     let closure = format!("{STD_HEAD}\
 fun main() -> Int =
   units := List(1, 2, 3, 4)
-  alive := units.retain(|u| u > 2)
+  alive := retainList(units, |u| u > 2)
   alive.length()
-");
+{LIST_FNS}");
     let (cbytes, _) = compiledKeys("closurefilter", &closure);
     let cops = opsOf(&cbytes, "main");
     assert_eq!(countOps(&ops, "StructNew"), 0, "form main allocates nothing itself: {ops:?}");
     assert!(countOps(&cops, "StructNew") >= 1, "closure main builds a closure struct: {cops:?}");
-    let retain = opsOf(&cbytes, "List[Int].retain");
+    let retain = opsOf(&cbytes, "retainList[Int]");
     assert!(countOps(&retain, "CallRef") + countOps(&retain, "CallIndirect") >= 1, "{retain:?}");
 }