Hazel reports · ^report(27) · performance · started 2026-10-22 · work in progress · about 7 minutes to read

The World Rule in Hazel and in Fumola

Matthew, after ^report(25): do the same game logic that we've exported to Hazel in ^report(25), but now do a Hazel (best PRs for performance) against Fumola in Wasm, doing the same logic ... I especially want to compare the map-based version in Fumola (store world data in maps, not lists) --- so there's a chance at O(log N). This is the World room's rule (a step to the square beside), written in Fumola, and timed against Hazel with every performance change we have, at map sizes from 3x3 to 64x64 (^ticket(542)). The syntax of the two side by side is ^report(28).

What was measured#copy link

• Hazel at its best: its JS library built by GitHub from trial/r25-best (bce9b4e5d1): all 14 performance PRs, #2681's memo limited to depth 1 (proposed), and the library binding a call's argument in the environment (^ticket(539)). Timed with ^report(25)'s driver and rules: passed is the shipped rule, held the map held in a closure, neighbours the neighbours-only rule.
• Fumola: its wasm build (fumola_wasm_bg.wasm, from 667a34d), in node through initSync, one instance per size. The rules are below; each call is fumola_eval_top of a call written as text, its answer read back from JSON and checked.

The Fumola rules#copy link

The World rule, as the game's Hazel one reads (both, side by side): a step in a direction, the square there found, and a GoSquare if it has a way back. step stays in Nat: it checks an edge before stepping off it, since Fumola keeps Nat and Int apart (^report(28)'s traps).

func no_way(kind, d) { kind == "waterfall" and d == "N" };
func member(s, xs) { var found = false; for (x in xs.vals()) { if (x == s) { found := true } }; found };
func opp(d) { if (d == "N") { "S" } else if (d == "NE") { "SW" } else if (d == "E") { "W" } else if (d == "SE") { "NW" } else if (d == "S") { "N" } else if (d == "SW") { "NE" } else if (d == "W") { "E" } else if (d == "NW") { "SE" } else { "" } };
func step(c, r, d, cols, rows) {
  let up = d == "N" or d == "NE" or d == "NW";
  let down = d == "S" or d == "SE" or d == "SW";
  let left = d == "W" or d == "NW" or d == "SW";
  let right = d == "E" or d == "NE" or d == "SE";
  if ((up and r == 0) or (left and c == 0)) { null }
  else {
    let c2 = if (left) { c - 1 } else if (right) { c + 1 } else { c };
    let r2 = if (up) { r - 1 } else if (down) { r + 1 } else { r };
    if (c2 < cols and r2 < rows) { ?(c2, r2) } else { null }
  }
};
func decide(x, back, c, r) { if (member(back, x.ways) and (no_way(x.kind, back) == false)) { #GoSquare((c, r, back, #Done)) } else { #Done } };
func find_at(cs, i, n, c, r) { if (i == n) { null } else { let x = cs[i]; if (x.col == c and x.row == r) { ?x } else { find_at(cs, i + 1, n, c, r) } } };
func world_list(g, e) {
  switch (e) {
    case (#Way(d)) {
      switch (step(g.at_col, g.at_row, d, g.cols, g.rows)) {
        case (?(c, r)) { switch (find_at(g.cells, 0, g.cells.size(), c, r)) { case (?x) { decide(x, opp(d), c, r) }; case null { #Done } } };
        case null { #Done }
      }
    };
    case _ { #Done }
  }
}

The held versions: the world bound once in the instance, as a list (wl) and as a HashMap keyed by (col, row) (wm). A move passes four numbers and a direction.

let wl = [ ...every cell, as written for a passed call... ];
func world_held_list(ac, ar, cols, rows, d) {
  switch (step(ac, ar, d, cols, rows)) {
    case (?(c, r)) { switch (find_at(wl, 0, wl.size(), c, r)) { case (?x) { decide(x, opp(d), c, r) }; case null { #Done } } };
    case null { #Done }
  }
};
var wm0 = HashMap.new();
for (x in wl.vals()) { let (m2, _) = HashMap.put(wm0, (x.col, x.row), x); wm0 := m2 };
let wm = wm0;
func world_held_map(ac, ar, cols, rows, d) {
  switch (step(ac, ar, d, cols, rows)) {
    case (?(c, r)) { switch (HashMap.get(wm, (c, r))) { case (?x) { decide(x, opp(d), c, r) }; case null { #Done } } };
    case null { #Done }
  }
}

The numbers#copy link

ms per call, the median of each round, the mean of 2 rounds (Hazel) and 2 (Fumola). Growth exponents from 64 to 4,096 cells (1 is linear, 0 flat): Hazel best passed 1.01, held 1.02, neighbours 0.07; Fumola passed 0.95, held list 0.80, held map 0.00, neighbours 0.06.

What Hazel would need#copy link

For the world's size to leave a move's cost alone, the rule must find a square without walking to it. Hazel's rules have lists and records, and no map. Three ways there:

1. Pass only what the rule reads: the neighbours. Flat today, in both languages (answer 4), but the game must know what each rule reads.
2. A map in Hazel, written in Hazel: a balanced tree keyed by (col, row), held as the world is held now. O(log N) evaluator steps a lookup. An estimate, not measured: a 64x64 world is twelve levels deep, and at a few dozen steps a level and about 3 µs a step (^report(25)), a lookup would cost about a millisecond, at any size near this one.
3. A map built in, as Fumola's HashMap is a primitive over a persistent hash trie: one step a lookup.

That is ^ticket(540)'s question, every handler in O(1) or O(log N), now with a measured target.

What next#copy link

1. Look at the game playing under Fumola: every room's rules are now in Fumola in matthewhammer/kids-choice-games#4 (a draft on top of #2), with ?logic=fumola (the world held in a HashMap, rebuilt when its cells change) and ?logic=fumola-list (the map passed in). A node check compares its answers with the Hazel rules' on 20,653 cases, and GitHub's browser checks pass (run 39823022799, its only failures the same nine as its base's). One run on GitHub's computer, for the order of things only: a rule call, median, 2.9 ms in Hazel, 1.1 ms in Fumola with the map held and 1.4 ms with it passed in; Fumola defines its rules in 4 ms, where Hazel compiles in 514 ms. Fumola's modes are not in the speed probe yet.
2. A map for Hazel's rules (above), and the World rule timed with it.
3. Fumola's boundary without source text: a JSON value in as a Fumola value, so a passed map is not parsed every call.
4. The same comparison in the game, in GitHub's browsers.

How this was put together#copy link

Node v22 on the Ubuntu laptop (Intel i7), one process at a time, pinned to two threads and niced. Fumola: drivers/measure.mjs (world.fum, held.fum.js), per size a fresh instance, three warm-up calls, then up to 60 timed (stopping after 2.5 s and at least 9), the median; its answer checked against the game's (GoSquare(c + 1, r, "W", Done)). Hazel: 025/drivers/r25.mjs on trial/r25-best's library, the same sizes. Two rounds each. The target cell is mid-map, moving east, as in ^report(25).

The data#copy link

• The numbers, for programs too: every table in this report, and what its numbers measure, is also in this page as JSON, in its <script type="application/json" id="report-data"> element, so a reader or an agent that fetches the page alone has the dataset. The same, with any raw files that survive, is in 027/data/.