3e4d318 | plum | pyrossh

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

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

3e4d318 — Peter John 2026-11-03T15:31:42+05:30

examples: functional.plum operations as enum methods; loops section

Files changed (1) hide show

plum-examples/functional.plum +314 -241

plum-examples/functional.plum CHANGED Viewed

@@ -4,16 +4,19 @@
 # of recursive sum types (`enum`) whose variants are declared inline with named
 # fields, `Cons(head: T, tail: Link[T])`. A variant is a constructor and a
 # pattern only; `Link[T]` is the only type, and fields are read by matching.
-# Every operation is a recursive function whose body is `= match x` with the
+# Every operation is a method on its enum, a recursive function whose body is
-# arms indented below, returning a new value. Unchanged parts are shared.
+# `= match self` with the arms indented below, returning a new value. Unchanged
+# parts are shared.
 #
-#   1. Link[T]: a cons list (`Nil` or `Cons(head, tail)`) and its combinators
+#   1. Link[T]: a cons list (`Nil` or `Cons(head, tail)`), combinators as methods on the enum
 #   2. Functions as values: closures, composition, currying, pipelines
-#   3. Tree[T]: a persistent binary search tree
+#   3. Tree: a persistent binary search tree, operations as methods on the enum
 #   4. Pattern matching: nested patterns, guards, pattern `if`, optionals
 #   5. A pure scene graph: a recursive `Node` tree whose groups hold a
 #      `Link[Node]` of children; acting, drawing, hit testing and event routing
-#      are all functions from an old tree to a new one
+#      are all methods from an old tree to a new one
+#
+#   6. Loops, functionally: the same job as methods, a `for` and a `while`
 #
 # Recursion is not tail call optimised yet, so very long lists (hundreds of
 # thousands of elements) would overflow the stack. Scene trees are shallow.
@@ -21,13 +24,92 @@ module functional
 import std/Str
 import std/Int
 import std/Float
+import std/List
 # ---------------------------------------------------------------------------
 # 1. Link[T]: a cons list
 # ---------------------------------------------------------------------------
 # A list is either empty (`Nil`, a tag) or a head value in front of another list.
+# Its operations are methods on the enum.
+enum Link[T] =
+  | Nil
-enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+  | Cons(head: T, tail: Link[T])
+  fun length(self) -> Int = match self
+    Nil => 0
+    Cons(_, t) => 1 + t.length()
+  fun isEmpty(self) -> Bool = match self
+    Nil => true
+    Cons(_, _) => false
+  # Runs `f` on every element, in order, for its effect.
+  fun each(self, f: fn(T)) -> Unit =
+    if Cons(h, t) := self
+      f(h)
+      t.each(f)
+  # A `for` source: walks the list with a local cursor and yields each head.
+  fun* items(self) *T =
+    cur := self
+    while true
+      if Cons(h, t) := cur
+        cur = t
+        yield h
+      else
+        break
+  # Structural recursion: rebuild the list with `f` applied to every element.
+  fun map(self, f: fn(T) -> B) -> Link[B] = match self
+    Nil => Nil
+    Cons(h, t) => Cons(head: f(h), tail: t.map(f))
+  fun filter(self, keep: fn(T) -> Bool) -> Link[T] = match self
+    Nil => Nil
+    Cons(h, t) =>
+      rest := t.filter(keep)
+      if keep(h) then cons(h, rest) else rest
+  # Left fold: `f(f(f(acc, x0), x1), x2)`. Tail recursive in shape.
+  fun foldl(self, acc: A, f: fn(A, T) -> A) -> A = match self
+    Nil => acc
+    Cons(h, t) => t.foldl(f(acc, h), f)
+  # Right fold: `f(x0, f(x1, f(x2, acc)))`. Keeps the list's order when rebuilding.
+  fun foldr(self, acc: A, f: fn(T, A) -> A) -> A = match self
+    Nil => acc
+    Cons(h, t) => f(h, t.foldr(acc, f))
+  fun reverse(self) -> Link[T] =
+    self.foldl(Nil, |acc, x| cons(x, acc))
+  # `self` followed by `ys`. Only `self` is rebuilt; `ys` is shared.
+  fun append(self, ys: Link[T]) -> Link[T] =
+    self.foldr(ys, |x, acc| cons(x, acc))
+  fun any(self, p: fn(T) -> Bool) -> Bool = match self
+    Nil => false
+    Cons(h, t) => p(h) || t.any(p)
+  fun all(self, p: fn(T) -> Bool) -> Bool = match self
+    Nil => true
+    Cons(h, t) => p(h) && t.all(p)
+  fun take(self, n: Int) -> Link[T] = match self
+    Nil => Nil
+    Cons(h, t) => if n <= 0 then Nil else cons(h, t.take(n - 1))
+  fun drop(self, n: Int) -> Link[T] = match self
+    Nil => Nil
+    Cons(_, t) => if n <= 0 then self else t.drop(n - 1)
+  # The first element, or null for an empty list.
+  fun first(self) -> T? = match self
+    Nil => null
+    Cons(h, _) => h
+  # Pairs up two lists, stopping at the shorter one.
+  fun zip(self, ys: Link[B]) -> Link[Pair[T, B]] = match self
+    Nil => Nil
+    Cons(x, xt) =>
+      match ys
+        Nil => Nil
+        Cons(y, yt) => cons(Pair[T, B](fst: x, snd: y), xt.zip(yt))
+record Pair[A, B](fst: A, snd: B)
 # Prepends `h`: O(1), and `t` is shared, not copied.
 fun cons(h: T, t: Link[T]) -> Link[T] = Cons(head: h, tail: t)
@@ -38,75 +120,8 @@ fun single(x: T) -> Link[T] = cons(x, Nil)
 fun fromTo(a: Int, b: Int) -> Link[Int] =
   if a >= b then Nil else cons(a, fromTo(a + 1, b))
-fun length(xs: Link[T]) -> Int = match xs
-  Nil => 0
-  Cons(_, t) => 1 + length(t)
-fun isEmpty(xs: Link[T]) -> Bool = match xs
-  Nil => true
-  Cons(_, _) => false
-# Structural recursion: rebuild the list with `f` applied to every element.
-fun map(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
-  Nil => Nil
-  Cons(h, t) => Cons(head: f(h), tail: map(t, f))
-fun filter(xs: Link[T], keep: fn(T) -> Bool) -> Link[T] = match xs
-  Nil => Nil
-  Cons(h, t) =>
-    rest := filter(t, keep)
-    if keep(h) then cons(h, rest) else rest
-# Left fold: `f(f(f(acc, x0), x1), x2)`. Tail recursive in shape.
-fun foldl(xs: Link[T], acc: A, f: fn(A, T) -> A) -> A = match xs
-  Nil => acc
-  Cons(h, t) => foldl(t, f(acc, h), f)
-# Right fold: `f(x0, f(x1, f(x2, acc)))`. Keeps the list's order when rebuilding.
-fun foldr(xs: Link[T], acc: A, f: fn(T, A) -> A) -> A = match xs
-  Nil => acc
-  Cons(h, t) => f(h, foldr(t, acc, f))
-fun reverse(xs: Link[T]) -> Link[T] =
-  foldl(xs, Nil, |acc, x| cons(x, acc))
-# `xs` followed by `ys`. Only `xs` is rebuilt; `ys` is shared.
-fun append(xs: Link[T], ys: Link[T]) -> Link[T] =
-  foldr(xs, ys, |x, acc| cons(x, acc))
 fun sum(xs: Link[Int]) -> Int =
-  foldl(xs, 0, |a, x| a + x)
+  xs.foldl(0, |a, x| a + x)
-fun any(xs: Link[T], p: fn(T) -> Bool) -> Bool = match xs
-  Nil => false
-  Cons(h, t) => p(h) || any(t, p)
-fun all(xs: Link[T], p: fn(T) -> Bool) -> Bool = match xs
-  Nil => true
-  Cons(h, t) => p(h) && all(t, p)
-fun take(xs: Link[T], n: Int) -> Link[T] = match xs
-  Nil => Nil
-  Cons(h, t) => if n <= 0 then Nil else cons(h, take(t, n - 1))
-fun drop(xs: Link[T], n: Int) -> Link[T] = match xs
-  Nil => Nil
-  Cons(_, t) => if n <= 0 then xs else drop(t, n - 1)
-# The first element, or null for an empty list.
-fun first(xs: Link[T]) -> T? = match xs
-  Nil => null
-  Cons(h, _) => h
-# Pairs up two lists, stopping at the shorter one.
-record Pair[A, B](fst: A, snd: B)
-fun zip(xs: Link[A], ys: Link[B]) -> Link[Pair[A, B]] = match xs
-  Nil => Nil
-  Cons(x, xt) =>
-    match ys
-      Nil => Nil
-      Cons(y, yt) => cons(Pair[A, B](fst: x, snd: y), zip(xt, yt))
 fun joinInts(xs: Link[Int], sep: Str) -> Str = match xs
   Nil => ""
@@ -144,62 +159,65 @@ fun iterate(f: fn(T) -> T, n: Int, x: T) -> T =
 # ---------------------------------------------------------------------------
 # `insert` returns a new tree that shares every subtree it did not walk through:
-# inserting into a tree of n nodes allocates about log n new branches.
+# inserting into a tree of n nodes allocates about log n new branches. Its
+# operations are methods on the enum.
+enum Tree =
+  | Leaf
-enum Tree = Leaf | Branch(left: Tree, value: Int, right: Tree)
+  | Branch(left: Tree, value: Int, right: Tree)
-fun insert(t: Tree, v: Int) -> Tree = match t
+  fun insert(self, v: Int) -> Tree = match self
-  Leaf => Branch(left: Leaf, value: v, right: Leaf)
+    Leaf => Branch(left: Leaf, value: v, right: Leaf)
-  Branch(l, x, r) =>
+    Branch(l, x, r) =>
-    if v < x
+      if v < x
-      Branch(left: insert(l, v), value: x, right: r)
+        Branch(left: l.insert(v), value: x, right: r)
-    else if v > x
+      else if v > x
-      Branch(left: l, value: x, right: insert(r, v))
+        Branch(left: l, value: x, right: r.insert(v))
-    else
+      else
-      t
+        self
+  fun member(self, v: Int) -> Bool = match self
+    Leaf => false
+    Branch(l, x, r) => if v < x then l.member(v) else if v > x then r.member(v) else true
+  fun size(self) -> Int = match self
+    Leaf => 0
+    Branch(l, _, r) => l.size() + 1 + r.size()
+  fun depth(self) -> Int = match self
+    Leaf => 0
+    Branch(l, _, r) => 1 + l.depth().max(r.depth())
+  # In-order traversal as a fold, so `inOrder` comes out sorted.
+  fun fold(self, acc: A, f: fn(Int, A) -> A) -> A = match self
+    Leaf => acc
+    Branch(l, x, r) => l.fold(f(x, r.fold(acc, f)), f)
+  fun inOrder(self) -> Link[Int] =
+    self.fold(Nil, |x, acc| cons(x, acc))
+  fun smallest(self) -> Int? = match self
+    Leaf => null
+    Branch(Leaf, x, _) => x
+    Branch(l, _, _) => l.smallest()
 fun fromLink(xs: Link[Int]) -> Tree =
-  foldl(xs, Leaf, |t, x| insert(t, x))
+  xs.foldl(Leaf, |t, x| t.insert(x))
-fun member(t: Tree, v: Int) -> Bool = match t
-  Leaf => false
-  Branch(l, x, r) => if v < x then member(l, v) else if v > x then member(r, v) else true
-fun size(t: Tree) -> Int = match t
-  Leaf => 0
-  Branch(l, _, r) => size(l) + 1 + size(r)
-fun depth(t: Tree) -> Int = match t
-  Leaf => 0
-  Branch(l, _, r) => 1 + depth(l).max(depth(r))
-# In-order traversal as a fold, so `inOrder` comes out sorted.
-fun foldTree(t: Tree, acc: A, f: fn(Int, A) -> A) -> A = match t
-  Leaf => acc
-  Branch(l, x, r) => foldTree(l, f(x, foldTree(r, acc, f)), f)
-fun inOrder(t: Tree) -> Link[Int] =
-  foldTree(t, Nil, |x, acc| cons(x, acc))
-fun smallest(t: Tree) -> Int? = match t
-  Leaf => null
-  Branch(Leaf, x, _) => x
-  Branch(l, _, _) => smallest(l)
 # ---------------------------------------------------------------------------
 # 4. Pattern matching
 # ---------------------------------------------------------------------------
+enum Shape =
+  | Circle(r: Float)
-enum Shape = Circle(r: Float) | Rect(w: Float, h: Float)
+  | Rect(w: Float, h: Float)
-fun describe(s: Shape) -> Str = match s
-  Circle(r) when r == 0.0 => "point"
-  Circle(_) => "circle"
-  Rect(w, h) when w == h => "square"
-  Rect(_, _) => "rect"
+  fun describe(self) -> Str = match self
+    Circle(r) when r == 0.0 => "point"
+    Circle(_) => "circle"
+    Rect(w, h) when w == h => "square"
+    Rect(_, _) => "rect"
-# Pattern `if` with a guard after the comma.
+  # Pattern `if` with a guard after the comma.
-fun wide(s: Shape) -> Bool =
+  fun wide(self) -> Bool =
-  if Rect(w, h) := s, w > h then true else false
+    if Rect(w, h) := self, w > h then true else false
 # Nested patterns look two levels into a list.
 fun firstTwo(xs: Link[Int]) -> Str = match xs
@@ -226,47 +244,8 @@ fun undo(xf: Xf, px: Float, py: Float) -> Pt =
 record Pt(x: Float, y: Float)
-# The node kinds, declared inline. Every node has an `id` and a local transform
-# `xf`. A Group's children are a cons list of nodes: the tree is a recursive type
-# all the way down.
-enum Node =
-  | Sprite(id: Int, xf: Xf, w: Float, h: Float, image: Str, spin: Float)
-  | Label(id: Int, xf: Xf, text: Str)
-  | Button(id: Int, xf: Xf, w: Float, h: Float, text: Str, pressed: Bool)
-  | Group(id: Int, xf: Xf, children: Link[Node])
-fun nodeId(n: Node) -> Int = match n
-  Sprite(id, _, _, _, _, _) => id
-  Label(id, _, _) => id
-  Button(id, _, _, _, _, _) => id
-  Group(id, _, _) => id
-fun nodeXf(n: Node) -> Xf = match n
-  Sprite(_, xf, _, _, _, _) => xf
-  Label(_, xf, _) => xf
-  Button(_, xf, _, _, _, _) => xf
-  Group(_, xf, _) => xf
-# The number of nodes in the tree.
-fun count(n: Node) -> Int = match n
-  Group(_, _, kids) => 1 + foldl(kids, 0, |a, k| a + count(k))
-  _ => 1
-# A generic bottom-up rewrite: rebuild the children first, then apply `f`.
-fun mapNodes(n: Node, f: fn(Node) -> Node) -> Node = match n
-  Group(id, xf, kids) => f(Group(id: id, xf: xf, children: map(kids, |k| mapNodes(k, f))))
-  _ => f(n)
-# Replaces the node with id `target` by `f(node)`; every other node is kept.
-fun update(n: Node, target: Int, f: fn(Node) -> Node) -> Node =
-  mapNodes(n, |m| if nodeId(m) == target then f(m) else m)
-# One step of behaviour: a sprite moves by its `spin` per second to the right.
-# Returns a new tree; the old one is untouched.
-fun act(n: Node, dt: Float) -> Node = match n
+fun inBox(p: Pt, w: Float, h: Float) -> Bool =
-  Sprite(id, xf, w, h, image, spin) => Sprite(id: id, xf: Xf(x: xf.x + spin * dt, y: xf.y, s: xf.s), w: w, h: h, image: image, spin: spin)
-  Group(gid, gxf, kids) => Group(id: gid, xf: gxf, children: map(kids, |k| act(k, dt)))
+  p.x >= 0.0 && p.x <= w && p.y >= 0.0 && p.y <= h
-  _ => n
 # What drawing would paint, as data: a pure list of commands for a host to run.
 record DrawCmd(kind: Str, id: Int, x: Float, y: Float, s: Float)
@@ -274,38 +253,75 @@ record DrawCmd(kind: Str, id: Int, x: Float, y: Float, s: Float)
 fun cmd(kind: Str, id: Int, xf: Xf) -> DrawCmd =
   DrawCmd(kind: kind, id: id, x: xf.x, y: xf.y, s: xf.s)
-# Depth first, parents before children, so later commands draw on top.
+# The node kinds, declared inline. Every node has an `id` and a local transform
+# `xf`. A Group's children are a cons list of nodes: the tree is a recursive type
-fun draw(n: Node, parent: Xf) -> Link[DrawCmd] =
+# all the way down. Its operations are methods on the enum.
-  xf := thenXf(parent, nodeXf(n))
-  match n
+enum Node =
-    Sprite(id, _, _, _, _, _) => single(cmd("sprite", id, xf))
+  | Sprite(id: Int, xf: Xf, w: Float, h: Float, image: Str, spin: Float)
-    Label(id, _, _) => single(cmd("label", id, xf))
+  | Label(id: Int, xf: Xf, text: Str)
-    Button(id, _, _, _, _, pressed) => single(cmd(if pressed then "button-down" else "button", id, xf))
-    Group(_, _, kids) => foldr(kids, Nil, |k, acc| append(draw(k, xf), acc))
-fun inBox(p: Pt, w: Float, h: Float) -> Bool =
+  | Button(id: Int, xf: Xf, w: Float, h: Float, text: Str, pressed: Bool)
-  p.x >= 0.0 && p.x <= w && p.y >= 0.0 && p.y <= h
+  | Group(id: Int, xf: Xf, children: Link[Node])
+  fun id(self) -> Int = match self
+    Sprite(id, _, _, _, _, _) => id
+    Label(id, _, _) => id
+    Button(id, _, _, _, _, _) => id
+    Group(id, _, _) => id
+  fun xf(self) -> Xf = match self
+    Sprite(_, xf, _, _, _, _) => xf
+    Label(_, xf, _) => xf
+    Button(_, xf, _, _, _, _) => xf
+    Group(_, xf, _) => xf
+  # The number of nodes in the tree.
+  fun count(self) -> Int = match self
+    Group(_, _, kids) => 1 + kids.foldl(0, |a, k| a + k.count())
+    _ => 1
+  # A generic bottom-up rewrite: rebuild the children first, then apply `f`.
+  fun mapNodes(self, f: fn(Node) -> Node) -> Node = match self
+    Group(id, xf, kids) => f(Group(id: id, xf: xf, children: kids.map(|k| k.mapNodes(f))))
+    _ => f(self)
+  # Replaces the node with id `target` by `f(node)`; every other node is kept.
+  fun update(self, target: Int, f: fn(Node) -> Node) -> Node =
+    self.mapNodes(|m| if m.id() == target then f(m) else m)
+  # One step of behaviour: a sprite moves by its `spin` per second to the right.
+  # Returns a new tree; the old one is untouched.
+  fun act(self, dt: Float) -> Node = match self
+    Sprite(id, xf, w, h, image, spin) => Sprite(id: id, xf: Xf(x: xf.x + spin * dt, y: xf.y, s: xf.s), w: w, h: h, image: image, spin: spin)
+    Group(gid, gxf, kids) => Group(id: gid, xf: gxf, children: kids.map(|k| k.act(dt)))
+    _ => self
+  # Depth first, parents before children, so later commands draw on top.
+  fun draw(self, parent: Xf) -> Link[DrawCmd] =
+    xf := thenXf(parent, self.xf())
+    match self
+      Sprite(id, _, _, _, _, _) => single(cmd("sprite", id, xf))
+      Label(id, _, _) => single(cmd("label", id, xf))
+      Button(id, _, _, _, _, pressed) => single(cmd(if pressed then "button-down" else "button", id, xf))
+      Group(_, _, kids) => kids.foldr(Nil, |k, acc| k.draw(xf).append(acc))
-# The id of the topmost node under stage point (px, py), or null. Children drawn
+  # The id of the topmost node under stage point (px, py), or null. Children drawn
-# later are on top, so they are tried first (in reverse order).
+  # later are on top, so they are tried first (in reverse order).
-fun findHit(n: Node, parent: Xf, px: Float, py: Float) -> Int? =
+  fun findHit(self, parent: Xf, px: Float, py: Float) -> Int? =
-  xf := thenXf(parent, nodeXf(n))
+    xf := thenXf(parent, self.xf())
-  p := undo(xf, px, py)
+    p := undo(xf, px, py)
-  match n
+    match self
-    Sprite(_, _, w, h, _, _) => hitBox(n, p, w, h)
+      Sprite(_, _, w, h, _, _) => hitBox(self, p, w, h)
-    Button(_, _, bw, bh, _, _) => hitBox(n, p, bw, bh)
+      Button(_, _, bw, bh, _, _) => hitBox(self, p, bw, bh)
-    Label(_, _, _) => null
+      Label(_, _, _) => null
-    Group(_, _, kids) => firstHit(reverse(kids), xf, px, py)
+      Group(_, _, kids) => firstHit(kids.reverse(), xf, px, py)
+  fun press(self) -> Node = match self
+    Button(id, xf, w, h, text, _) => Button(id: id, xf: xf, w: w, h: h, text: text, pressed: true)
+    _ => self
 fun hitBox(n: Node, p: Pt, w: Float, h: Float) -> Int? =
   if inBox(p, w, h)
-    return nodeId(n)
+    return n.id()
   null
 fun firstHit(kids: Link[Node], xf: Xf, px: Float, py: Float) -> Int? = match kids
   Nil => null
   Cons(k, rest) =>
-    if hit := findHit(k, xf, px, py)
+    if hit := k.findHit(xf, px, py)
       hit
     else
       firstHit(rest, xf, px, py)
@@ -318,13 +334,9 @@ record UiEvent(id: Int, kind: UiKind)
 record Routed(node: Node, events: Link[UiEvent])
-fun press(n: Node) -> Node = match n
-  Button(id, xf, w, h, text, _) => Button(id: id, xf: xf, w: w, h: h, text: text, pressed: true)
-  _ => n
 fun click(root: Node, px: Float, py: Float) -> Routed =
-  if id := findHit(root, identityXf(), px, py)
+  if id := root.findHit(identityXf(), px, py)
-    Routed(node: update(root, id, press), events: single(UiEvent(id: id, kind: Clicked)))
+    Routed(node: root.update(id, |n| n.press()), events: single(UiEvent(id: id, kind: Clicked)))
   else
     Routed(node: root, events: Nil)
@@ -337,28 +349,72 @@ fun demoScene() -> Node =
   menu := Group(id: 4, xf: Xf(x: 0.0, y: 100.0, s: 0.5), children: single(play))
   Group(id: 1, xf: Xf(x: 100.0, y: 50.0, s: 1.0), children: cons(ship, cons(title, single(menu))))
+# ---------------------------------------------------------------------------
+# 6. Loops, functionally
+# ---------------------------------------------------------------------------
+# One job (the sum of the even numbers), written three ways. They all agree.
+#
+# 1. Methods: `filter` then `foldl`, each a recursive method on the list.
+fun sumEvensMethods(xs: Link[Int]) -> Int =
+  xs.filter(|x| x % 2 == 0).foldl(0, |a, x| a + x)
+# 2. A `for` over the list's `items()` form, with an `if` clause as the filter.
+fun sumEvensFor(xs: Link[Int]) -> Int =
+  total := 0
+  for x := range xs.items(), if x % 2 == 0
+    total = total + x
+  total
+# 3. A `while` loop with a local cursor, taking the list apart with a pattern.
+fun sumEvensWhile(xs: Link[Int]) -> Int =
+  total := 0
+  cur := xs
+  while true
+    if Cons(h, t) := cur
+      if h % 2 == 0
+        total = total + h
+      cur = t
+    else
+      break
+  total
+# A `for` is an expression when its source has a result: this form rebuilds a
+# list from the body's values, like `map`. (Written for Int lists: a generic
+# `Link[T]` result type is not substituted inside a form body yet.)
+fun* collect(xs: Link[Int]) *Int -> Link[Int] =
+  out: Link[Int] := Nil
+  for x := range xs.items()
+    v := yield x
+    out = cons(v, out)
+  out.reverse()
+# The x of the ship (id 2) in a tree's draw commands.
+fun shipX(root: Node) -> Float =
+  root.draw(identityXf()).foldl(0.0, |a, c| if c.id == 2 then c.x else a)
 # ---------------------------------------------------------------------------
 # Tests
 # ---------------------------------------------------------------------------
 test "link basics"
   xs := fromTo(1, 6)
-  assert length(xs) == 5
+  assert xs.length() == 5
   assert joinInts(xs, ",") == "1,2,3,4,5"
   empty: Link[Int] := Nil
-  assert isEmpty(empty)
+  assert empty.isEmpty()
-  assert !isEmpty(xs)
+  assert !xs.isEmpty()
   assert sum(xs) == 15
 test "link combinators"
   xs := fromTo(1, 6)
-  assert joinInts(map(xs, |x| x * x), ",") == "1,4,9,16,25"
+  assert joinInts(xs.map(|x| x * x), ",") == "1,4,9,16,25"
-  assert joinInts(filter(xs, |x| x % 2 == 0), ",") == "2,4"
+  assert joinInts(xs.filter(|x| x % 2 == 0), ",") == "2,4"
-  assert joinInts(reverse(xs), ",") == "5,4,3,2,1"
+  assert joinInts(xs.reverse(), ",") == "5,4,3,2,1"
-  assert joinInts(append(take(xs, 2), drop(xs, 3)), ",") == "1,2,4,5"
+  assert joinInts(xs.take(2).append(xs.drop(3)), ",") == "1,2,4,5"
-  assert any(xs, |x| x > 4)
+  assert xs.any(|x| x > 4)
-  assert !all(xs, |x| x > 4)
+  assert !xs.all(|x| x > 4)
-  assert foldr(xs, 0, |x, a| x - a) == 3
+  assert xs.foldr(0, |x, a| x - a) == 3
 test "link sharing"
   tail := fromTo(2, 4)
@@ -369,11 +425,11 @@ test "link sharing"
   assert joinInts(tail, " ") == "2 3"
 test "link first and zip"
-  assert {first(fromTo(7, 9)) ?: 0} == 7
+  assert {fromTo(7, 9).first() ?: 0} == 7
-  assert {first(fromTo(7, 7)) ?: 0} == 0
+  assert {fromTo(7, 7).first() ?: 0} == 0
-  ps := zip(fromTo(1, 4), fromTo(10, 20))
+  ps := fromTo(1, 4).zip(fromTo(10, 20))
-  assert length(ps) == 3
+  assert ps.length() == 3
-  assert foldl(ps, 0, |a, p| a + p.fst * p.snd) == 1 * 10 + 2 * 11 + 3 * 12
+  assert ps.foldl(0, |a, p| a + p.fst * p.snd) == 1 * 10 + 2 * 11 + 3 * 12
 test "functions as values"
   inc := adder(1)
@@ -382,70 +438,87 @@ test "functions as values"
   assert incThenDouble.run(4) == 10
   assert compose(inc, double).run(4) == 9
   assert iterate(double.run, 10, 1) == 1024
-  assert joinInts(map(fromTo(0, 3), adder(100).run), ",") == "100,101,102"
+  assert joinInts(fromTo(0, 3).map(adder(100).run), ",") == "100,101,102"
 test "persistent tree"
   t := fromLink(cons(5, cons(3, cons(8, cons(1, cons(4, cons(9, Nil)))))))
-  assert size(t) == 6
+  assert t.size() == 6
-  assert depth(t) == 3
+  assert t.depth() == 3
-  assert member(t, 4)
+  assert t.member(4)
-  assert !member(t, 7)
+  assert !t.member(7)
-  assert joinInts(inOrder(t), " ") == "1 3 4 5 8 9"
+  assert joinInts(t.inOrder(), " ") == "1 3 4 5 8 9"
-  t2 := insert(t, 7)
+  t2 := t.insert(7)
-  assert member(t2, 7)
+  assert t2.member(7)
-  assert !member(t, 7)
+  assert !t.member(7)
-  assert size(t) == 6
+  assert t.size() == 6
-  assert size(t2) == 7
+  assert t2.size() == 7
-  assert {smallest(t2) ?: -1} == 1
+  assert {t2.smallest() ?: -1} == 1
-  assert {smallest(Leaf) ?: -1} == -1
+  assert {Leaf.smallest() ?: -1} == -1
 test "pattern matching"
-  assert describe(Circle(r: 0.0)) == "point"
+  assert Circle(r: 0.0).describe() == "point"
-  assert describe(Circle(r: 2.0)) == "circle"
+  assert Circle(r: 2.0).describe() == "circle"
-  assert describe(Rect(w: 3.0, h: 3.0)) == "square"
+  assert Rect(w: 3.0, h: 3.0).describe() == "square"
-  assert describe(Rect(w: 4.0, h: 3.0)) == "rect"
+  assert Rect(w: 4.0, h: 3.0).describe() == "rect"
-  assert wide(Rect(w: 4.0, h: 3.0))
+  assert Rect(w: 4.0, h: 3.0).wide()
-  assert !wide(Circle(r: 1.0))
+  assert !Circle(r: 1.0).wide()
   assert firstTwo(fromTo(1, 5)) == "1,2"
   assert firstTwo(single(7)) == "7"
   assert firstTwo(Nil) == "empty"
 test "scene count and draw"
   scene := demoScene()
-  assert count(scene) == 5
+  assert scene.count() == 5
-  cmds := draw(scene, identityXf())
+  cmds := scene.draw(identityXf())
-  assert length(cmds) == 3
+  assert cmds.length() == 3
-  kinds := foldr(cmds, "", |c, acc| c.kind + " " + acc)
+  kinds := cmds.foldr("", |c, acc| c.kind + " " + acc)
   assert kinds == "sprite label button "
-  btn := foldl(cmds, cmd("none", 0, identityXf()), |a, c| if c.id == 5 then c else a)
+  btn := cmds.foldl(cmd("none", 0, identityXf()), |a, c| if c.id == 5 then c else a)
   assert btn.x == 110.0
   assert btn.y == 160.0
   assert btn.s == 0.5
 test "scene act is pure"
   before := demoScene()
-  after := act(before, 0.5)
+  after := before.act(0.5)
-  shipX := |root|
-    foldl(draw(root, identityXf()), 0.0, |a, c| if c.id == 2 then c.x else a)
   assert shipX(before) == 100.0
   assert shipX(after) == 105.0
 test "scene hit test"
   scene := demoScene()
-  assert {findHit(scene, identityXf(), 105.0, 55.0) ?: 0} == 2
+  assert {scene.findHit(identityXf(), 105.0, 55.0) ?: 0} == 2
-  assert {findHit(scene, identityXf(), 115.0, 165.0) ?: 0} == 5
+  assert {scene.findHit(identityXf(), 115.0, 165.0) ?: 0} == 5
-  assert {findHit(scene, identityXf(), 0.0, 0.0) ?: 0} == 0
+  assert {scene.findHit(identityXf(), 0.0, 0.0) ?: 0} == 0
 test "scene click routes an event"
   scene := demoScene()
   r := click(scene, 115.0, 165.0)
-  assert length(r.events) == 1
+  assert r.events.length() == 1
   if Cons(e, _) := r.events
     assert e.id == 5
     assert e.kind == Clicked
-  kinds := foldr(draw(r.node, identityXf()), "", |c, acc| c.kind + " " + acc)
+  kinds := r.node.draw(identityXf()).foldr("", |c, acc| c.kind + " " + acc)
   assert kinds == "sprite label button-down "
-  old := foldr(draw(scene, identityXf()), "", |c, acc| c.kind + " " + acc)
+  old := scene.draw(identityXf()).foldr("", |c, acc| c.kind + " " + acc)
   assert old == "sprite label button "
   miss := click(scene, 0.0, 0.0)
-  assert isEmpty(miss.events)
+  assert miss.events.isEmpty()
+test "loops three ways"
+  xs := fromTo(1, 11)
+  assert sumEvensMethods(xs) == 30
+  assert sumEvensFor(xs) == 30
+  assert sumEvensWhile(xs) == 30
+  empty: Link[Int] := Nil
+  assert sumEvensFor(empty) == 0
+  assert sumEvensWhile(empty) == 0
+test "loops build lists too"
+  xs := fromTo(1, 5)
+  seen := List()
+  xs.each(|x| seen.push(x * 2))
+  assert seen.length() == 4
+  doubled := for x := range collect(xs), if x > 1
+    x * 2
+  assert joinInts(doubled, ",") == joinInts(xs.filter(|x| x > 1).map(|x| x * 2), ",")
+  assert joinInts(doubled, ",") == "4,6,8"