@mark1russell7/coeval 0.24.0 → 0.25.0

package/src/merge.ts

@@ -7,14 +7,30 @@ import { type Kind, type World, type WorldEntry, isAlias, isKind, isNamespace }
 /** The keys from a part of a merge to one of its entries, for example `["kinds", "ref"]`. */
 export type MergePath = readonly Key[];
 
+/** The entries of one kind of another part (COMPOSE.EXTEND-VERB). */
+export interface VerbEntries {
+  /**
+   * The path of the kind, as `replaces` names it, for example `["kinds", "ref"]`, `["kinds", "ops", "kinds", "mul"]`,
+   * `["kinds", "ops", "fallback"]` or `["fallback"]`.
+   */
+  readonly kind: MergePath;
+  /** The evaluator names, by verb, as in `verbs` of a kind. */
+  readonly verbs: Readonly<Record<string, string>>;
+}
+
 /**
  * A world as a part of a merge. Each field is optional. `replaces` names the paths of the entries that this part
- * replaces, for example `["kinds", "ref"]` or `["defaults", "view"]`. The result of a merge has no `replaces`.
+ * replaces, for example `["kinds", "ref"]` or `["defaults", "view"]`. The result of a merge has no `replaces`, no
+ * `verbs` and no `extends`.
  */
 export interface WorldPart {
   readonly kinds?: Readonly<Record<string, WorldEntry>>;
   readonly defaults?: Readonly<Record<string, string>>;
   readonly fallback?: Kind;
+  /** The verbs that this part owns. A part can add an entry of such a verb to a kind of another part. */
+  readonly verbs?: readonly string[];
+  /** The entries that this part adds to kinds. The merge adds them after each part (COMPOSE.EXTEND-VERB). */
+  readonly extends?: readonly VerbEntries[];
   readonly replaces?: readonly MergePath[];
 }
 
@@ -58,6 +74,8 @@ type Known = NonNullable<Machine["known"]>;
 type Facts = NonNullable<Machine["facts"]>;
 
 const NONE: ReadonlySet<string> = /* @__PURE__ */ new Set();
+/** The verbs that the kernel reads. Thus no language owns them (COMPOSE.PIRACY). */
+const KERNEL_VERBS: ReadonlySet<string> = /* @__PURE__ */ new Set(["eval", "deref", "step"]);
 
 function keyOf(path: MergePath): string {
   return JSON.stringify(path.map(String));
@@ -283,15 +301,112 @@ function mergeEntry(m: Merger, earlier: WorldEntry, later: WorldEntry, path: Mer
   return earlier;
 }
 
+/** One entry of `extends`, with what the merge knows from its part. */
+interface VerbEntry {
+  readonly kind: MergePath;
+  readonly verb: string;
+  readonly code: string;
+  readonly path: MergePath;
+  readonly part: number;
+  /** The part owns the verb, or it gives the kind. Thus the entry is not piracy. */
+  readonly allowed: boolean;
+  readonly replaced: boolean;
+}
+
 interface WorldDraft {
   readonly kinds: Record<string, WorldEntry>;
   readonly defaults: Record<string, string>;
   fallback?: Kind;
+  /** The part that owns each verb. */
+  readonly owners: Map<string, WorldPart>;
+  readonly entries: VerbEntry[];
+}
+
+function worldDraft(): WorldDraft {
+  return { kinds: {}, defaults: {}, owners: new Map(), entries: [] };
+}
+
+interface KindTable {
+  readonly kinds: Readonly<Record<string, WorldEntry>>;
+  readonly fallback?: Kind;
+}
+
+/**
+ * This function gives a copy of a table with a change to the kind at a path, as `replaces` names the path. It gives
+ * `undefined` when no kind is at the path. An alias is not a kind.
+ */
+function changeKind<T extends KindTable>(table: T, path: MergePath, change: (kind: Kind) => Kind): T | undefined {
+  const [first, key, ...rest] = path;
+  if (String(first) === "fallback" && key === undefined) return table.fallback === undefined ? undefined : { ...table, fallback: change(table.fallback) };
+  if (String(first) !== "kinds" || key === undefined) return undefined;
+  const entry = own(table.kinds, String(key));
+  const next = rest.length === 0 ? (isKind(entry) ? change(entry) : undefined) : isNamespace(entry) ? changeKind(entry, rest, change) : undefined;
+  if (next === undefined) return undefined;
+  const kinds = { ...table.kinds };
+  setOwn(kinds, String(key), next);
+  return { ...table, kinds };
 }
 
-function worldOf(draft: WorldDraft): World {
-  const world = { kinds: { ...draft.kinds }, defaults: { ...draft.defaults } };
-  return draft.fallback === undefined ? world : { ...world, fallback: draft.fallback };
+/**
+ * This function adds the entries of `extends` to the kinds of a draft. A later part can give the kind, thus this step
+ * reads the whole draft. Without `m`, it reports no conflict: a function part sees the entries of the parts before it.
+ */
+function addVerbs(draft: WorldDraft, m?: Merger): KindTable {
+  let table: KindTable = draft.fallback === undefined ? { kinds: draft.kinds } : { kinds: draft.kinds, fallback: draft.fallback };
+  for (const entry of draft.entries) {
+    if (!entry.allowed && !entry.replaced) {
+      m?.clash(entry.path, entry.part, "A part adds a verb that it does not own to a kind that it does not give.");
+      continue;
+    }
+    const next = changeKind(table, entry.kind, (kind) => {
+      const verbs: Record<string, string> = { ...kind.verbs };
+      const earlier = own(verbs, entry.verb);
+      if (earlier === undefined) m?.give(entry.path, entry.part);
+      else if (entry.replaced) m?.replace(entry.path, entry.part);
+      else if (earlier !== entry.code) m?.clash(entry.path, entry.part, "Two parts give two different evaluators for this verb of this kind.");
+      if (earlier === undefined || entry.replaced) setOwn(verbs, entry.verb, entry.code);
+      return { ...kind, verbs };
+    });
+    if (next !== undefined) table = next;
+    else if (!entry.replaced) m?.clash(entry.path, entry.part, "A part adds a verb to a path without a kind.");
+  }
+  return table;
+}
+
+function worldOf(draft: WorldDraft, m?: Merger): World {
+  const table = addVerbs(draft, m);
+  const world = { kinds: { ...table.kinds }, defaults: { ...draft.defaults } };
+  return table.fallback === undefined ? world : { ...world, fallback: table.fallback };
+}
+
+/** This function records the verbs that a part owns, and the entries that it adds to kinds. */
+function mergeVerbs(m: Merger, draft: WorldDraft, part: WorldPart, index: number, replaces: ReadonlySet<string>, base: MergePath): void {
+  const owned = part.verbs ?? [];
+  for (const verb of owned) {
+    const path = [...base, "verbs", verb];
+    const owner = draft.owners.get(verb);
+    if (replaces.has(keyOf(path))) {
+      draft.owners.set(verb, part);
+      m.replace(path, index);
+    } else if (KERNEL_VERBS.has(verb)) {
+      m.clash(path, index, "The kernel owns this verb.");
+    } else if (owner === undefined) {
+      draft.owners.set(verb, part);
+      m.give(path, index);
+    } else if (!same(owner, part)) {
+      m.clash(path, index, "Two parts own this verb.");
+    }
+  }
+  const table: KindTable = part.fallback === undefined ? { kinds: part.kinds ?? {} } : { kinds: part.kinds ?? {}, fallback: part.fallback };
+  for (const { kind, verbs } of part.extends ?? []) {
+    const gives = changeKind(table, kind, (found) => found) !== undefined;
+    for (const verb of Object.keys(verbs)) {
+      const code = verbs[verb];
+      if (code === undefined) continue;
+      const path = [...base, ...kind, "verbs", verb];
+      draft.entries.push({ kind, verb, code, path, part: index, allowed: gives || owned.includes(verb), replaced: replaces.has(keyOf(path)) });
+    }
+  }
 }
 
 function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefined, index: number, replaces: ReadonlySet<string>, base: MergePath): void {
@@ -303,6 +418,7 @@ function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefine
   }
   const fallback = mergeFallback(m, draft.fallback, part.fallback, [...base, "fallback"], index, replaces);
   if (fallback !== undefined) draft.fallback = fallback;
+  mergeVerbs(m, draft, part, index, replaces, base);
 }
 
 /**
@@ -313,6 +429,8 @@ function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefine
  * - The defaults merge verb by verb, and the world keeps one fallback.
  * - Each other pair of entries at one path is a conflict, unless the later part names the path in `replaces`.
  *   Then the later entry wins, with no merge below it.
+ * - The entries of `extends` join their kinds after each part, thus the order of the parts does not change them. A
+ *   verb that a part does not own on a kind that it does not give is a conflict (COMPOSE.PIRACY).
  *
  * A part can be a function of the merge of the parts before it (`prev`, as an overlay of Nix). Thus a part can read
  * the entry that it replaces.
@@ -323,13 +441,14 @@ function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefine
  */
 export function mergeWorlds(...parts: readonly (WorldPart | ((prev: World) => WorldPart))[]): World {
   const m = new Merger();
-  const draft: WorldDraft = { kinds: {}, defaults: {} };
+  const draft = worldDraft();
   parts.forEach((input, index) => {
     const part = typeof input === "function" ? input(worldOf(draft)) : input;
     mergeWorldInto(m, draft, part, index, new Set((part.replaces ?? []).map(keyOf)), []);
   });
+  const world = worldOf(draft, m);
   if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-  return worldOf(draft);
+  return world;
 }
 
 /** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
@@ -392,12 +511,12 @@ function composeFacts(hooks: readonly { readonly part: number; readonly facts: F
   };
 }
 
-function machineOf(draft: MachineDraft): Machine {
+function machineOf(draft: MachineDraft, m?: Merger): Machine {
   const known = composeKnown(draft.hooks, draft.replaced);
   const facts = composeFacts(draft.factHooks, draft.replaced);
   return {
     ...draft.rest,
-    world: worldOf(draft.world),
+    world: worldOf(draft.world, m),
     evaluators: { ...draft.evaluators },
     ...(draft.runners === undefined ? {} : { runners: { ...draft.runners } }),
     ...(draft.derefs === undefined ? {} : { derefs: { ...draft.derefs } }),
@@ -474,7 +593,7 @@ function checkHidden(m: Merger, draft: MachineDraft): void {
  */
 export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine) => MachinePart))[]): Machine {
   const m = new Merger();
-  const draft: MachineDraft = { world: { kinds: {}, defaults: {} }, evaluators: {}, hooks: [], factHooks: [], replaced: new Map(), rest: {}, parts: [] };
+  const draft: MachineDraft = { world: worldDraft(), evaluators: {}, hooks: [], factHooks: [], replaced: new Map(), rest: {}, parts: [] };
   parts.forEach((input, index) => {
     const part = typeof input === "function" ? input(machineOf(draft)) : input;
     draft.parts.push(part);
@@ -502,8 +621,9 @@ export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine)
     }
   });
   checkHidden(m, draft);
+  const machine = machineOf(draft, m);
   if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-  return machineOf(draft);
+  return machine;
 }
 
 /** This function removes the entry at a path from a table of entries. It gives the same table when no entry is there. */

package/src/reference.ts

@@ -1336,11 +1336,22 @@ const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath
   }
 };
 
+/**
+ * The definition of the standard evaluator `ref.resolve` (REF.RESOLVE, D133). It resolves the steps of the path at each
+ * evaluation. The plan compiles the same path one time.
+ */
+const refDefinition: EvalFn = ({ data, resolve: walk }) => {
+  if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", 'The value of ref is a path: a list that starts with a root, for example ["names", "a"].');
+  const found = walk(data as readonly Json[]);
+  return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+};
+
 /**
  * The definitions of the reference for the evaluators of the standard machine that need their own reading. The
- * reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node`.
+ * reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node` and
+ * `ref.resolve`. A host that wraps `ref.resolve` wraps this function, because the standard evaluator is compiled.
  */
-export const STD_DEFINITIONS: Definitions = { evaluators: { "tree.node": treeDefinition } };
+export const STD_DEFINITIONS: Definitions = { evaluators: { "tree.node": treeDefinition, "ref.resolve": refDefinition } };
 
 /* The definitions of the formula kit: one function evaluator for each construct, written from docs/SPEC.md. */
 

package/src/schedule.ts

@@ -294,6 +294,8 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
   // The nodes that finished in a kept read, and if that read met a node in evaluation below it (D143).
   const keptNodes: string[] = [];
   let keptMet = false;
+  // The count of the visits at the start of the kept read. A node with a lower number started below the read.
+  let keptFrom = 0;
   let count = 0;
   let ahead = 0;
   // The node that stopped the evaluation of a walk, because the walk has no result for it.
@@ -370,8 +372,12 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
     const reader = stack[stack.length - 1];
     const known = epoch.values.get(id);
     if (known !== undefined) {
-      // A finished node of an open component is on a cycle with its reader too.
-      if (reader !== undefined && onOpen.has(id)) lower(reader, order.get(id) as number);
+      if (reader !== undefined && onOpen.has(id)) {
+        // The path from that component to a kept read has a read that no evaluation asked for (SCHED.KEPT-OPEN).
+        if (keptAt >= 0 && (order.get(id) as number) < keptFrom) keptMet = true;
+        // A finished node of an open component is on a cycle with its reader too.
+        else lower(reader, order.get(id) as number);
+      }
       return known;
     }
     if (busy.has(id)) {
@@ -592,9 +598,11 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
     keeping(read) {
       const outer = keptAt;
       const outerMet = keptMet;
+      const outerFrom = keptFrom;
       const from = keptNodes.length;
       keptAt = stack.length;
       keptMet = false;
+      keptFrom = count;
       try {
         return read();
       } finally {
@@ -609,6 +617,7 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
         }
         keptAt = outer;
         keptMet = outerMet;
+        keptFrom = outerFrom;
       }
     },
   });

package/src/static.ts

@@ -258,11 +258,14 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
       continue;
     }
     const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
+    // The rules of a grant are read one time for each kind, not for each part. A kind without such a rule gives no list (K238).
+    const grantRules = kind.caps !== undefined && kind.caps.some((rule) => rule.rule === "grant") ? kind.caps : undefined;
     for (let index = split.parts.length - 1; index >= 0; index -= 1) {
       const slot = split.parts[index] as PartSlot;
       const extra = sees[index] ?? [];
       const hidden = later[index] ?? [];
-      const grants = partGrants(kind.caps, slot.path, doc.value);
+      const grants = grantRules === undefined ? undefined : partGrants(grantRules, slot.path, doc.value);
+      const granted = grants !== undefined && grants.length > 0 ? grants : undefined;
       stack.push({
         value: slot.item,
         place: slot.path.length === 0 ? item.place : { up: item.place, keys: slot.path },
@@ -274,8 +277,14 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
         address: slot.address === true,
         slot: slot.path,
         parent: here,
-        caps: item.caps === undefined || kind.caps === undefined ? item.caps : [...partCaps(kind.caps, slot.path, item.caps), ...grants],
-        handled: grants.length === 0 ? item.handled : [...(item.handled ?? []), ...grants],
+        // A part with no grant keeps the list of partCaps, with no copy (K238).
+        caps:
+          item.caps === undefined || kind.caps === undefined
+            ? item.caps
+            : granted === undefined
+              ? partCaps(kind.caps, slot.path, item.caps)
+              : [...partCaps(kind.caps, slot.path, item.caps), ...granted],
+        handled: granted === undefined ? item.handled : [...(item.handled ?? []), ...granted],
         bound: extra,
         expect: slot.expect,
       });
@@ -371,6 +380,45 @@ export function mapRefs(world: World, doc: unknown, change: (use: RefUse) => unk
   return out;
 }
 
+/**
+ * The answer of the function of `mapDocs` for one document.
+ *
+ * - `undefined`: keep the document and go into its parts.
+ * - `"skip"`: keep the document and stop there.
+ * - `{ to }`: put `to` in the place of the document and stop there.
+ * - `{ to, into: true }`: put `to` in the place of the document, then go into the parts of the old document. Thus
+ *   `to` must keep the path of each such part.
+ */
+export type DocChange = undefined | "skip" | { readonly to: unknown; readonly into?: boolean };
+
+/**
+ * This function changes the documents of a document, from the root to the parts (STATIC.MAPDOCS). The function
+ * `change` reads only the original documents. It decides at each node, and it can stop at a node. The kinds of a
+ * position come from the world, thus this function names no kind. The document is not changed: the function gives a
+ * new document that shares each part without a change.
+ *
+ * @param world - The world of the kinds.
+ * @param doc - The document, as JSON.
+ * @param change - The function that gives the answer for each visit. See `DocChange`.
+ * @param options - The type of a bare root value, and the names that the host binds at the root.
+ * @returns The new document, or `doc` itself when no document changes.
+ */
+export function mapDocs(world: World, doc: unknown, change: (visit: DocVisit) => DocChange, options: WalkOptions = {}): unknown {
+  let out = doc;
+  walk(
+    world,
+    doc,
+    (visit) => {
+      const next = change(visit);
+      if (next === undefined || next === "skip") return next;
+      out = setAt(out, visit.at, next.to);
+      return next.into === true ? undefined : "skip";
+    },
+    options,
+  );
+  return out;
+}
+
 /** A problem that a check finds before a document runs. */
 export interface Issue {
   readonly code: ErrorCode;
@@ -593,7 +641,8 @@ export function check(machine: Machine, doc: unknown, options: CheckOptions = {}
 export function typeCheck(machine: Machine, doc: unknown, options: CheckOptions = {}): Typing {
   const nodes: TypeNode[] = [];
   const issues = checkAll(machine, doc, options, nodes);
-  const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
+  const verb = options.verb ?? "eval";
+  const pass = typePass(machine, nodes, verb, options.expect, options.rootTypes, (node) => declaredEffects(node.visit, verb, machine, node.evaluator).length > 0);
   return { type: pass.type, issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues], places: pass.places };
 }
 

package/src/stdlib.ts

@@ -15,9 +15,10 @@ import {
   fail,
   ok,
   planner,
+  resolveCompiled,
 } from "./evaluate.ts";
 import { Failure } from "./errors.ts";
-import { type Cap, type HostThing, type Thing, type Walker, THING, isHostThing, valueOfThing } from "./deref.ts";
+import { type Cap, type HostThing, type Thing, type Walker, THING, compilePath, isHostThing, valueOfThing } from "./deref.ts";
 import type { World } from "./ladder.ts";
 import {
   type AttributeDeclaration,
@@ -192,7 +193,8 @@ export const STD_WORLD: World = {
  * A literal in a place that takes a document gets its data envelope (K159, D65). Such a place is a part of `if`,
  * `list`, `seq` or `pure`, the value of `write`, or the whole text. The document after a header name is such a place
  * too. Thus `list(1, "a")` evaluates to `[1, "a"]`. The forms `add`, `multiply` and `greater` write an operator document that its operator
- * does not write, for example `add(5)` (K163).
+ * does not write, for example `add(5)` (K163). The field `with` of `handle` is a field of data, thus each clause is a
+ * record between braces in a list between brackets (D177).
  *
  * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
  * the formula kit.
@@ -223,6 +225,8 @@ export const WORLD_SYNTAX: SyntaxProfile = /* @__PURE__ */ Object.freeze({
       { name: "tree.named", kind: "tree.named", args: "named", fields: ["name", "in"] },
       { name: "tree.at", kind: "tree.at", args: "named", fields: ["attr", "args"] },
       { name: "tree.quote", kind: "tree.quote", args: "literal" },
+      // The clauses are data with documents in it, for example handle(with: [{op: "log", do: payload + 1}], body: log(2)) (D177).
+      { name: "handle", kind: "handle", args: "named", fields: ["with", "return", "body"], data: ["with"], wrap: ["return", "body"] },
       // An operator document with fewer terms than its operator takes, for example add(5) (K163, D65).
       { name: "add", kind: "add" },
       { name: "multiply", kind: "multiply" },
@@ -286,12 +290,19 @@ export const STD_EVALUATORS: Readonly<Record<string, Evaluator>> = {
     const [a, b] = values as readonly number[];
     return ok((a ?? 0) > (b ?? 0));
   },
-  "ref.resolve": ({ data, resolve }) => {
-    if (!Array.isArray(data) || data.length === 0) {
-      return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
-    }
-    const found = resolve(data as readonly Json[]);
-    return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+  // The path is data of the document, thus it compiles one time for the machine of the plan (PLAN.PATH-STD, D133).
+  "ref.resolve": {
+    compile: ({ data, machine }) => {
+      if (!Array.isArray(data) || data.length === 0) {
+        const bad = fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+        return () => bad;
+      }
+      const path = compilePath(machine, data);
+      return (ctx, rt) => {
+        const found = resolveCompiled(rt, ctx, path);
+        return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+      };
+    },
   },
   "tree.node": (input) => treeNode(input, undefined),
 };
@@ -835,6 +846,7 @@ function leaderOnHost(n: LoopNode, key: string, rule: CircularRule & { readonly
 /**
  * This function gives an attribute of a node with circular attributes, or an attribute in an open fixed point (D113).
  * The memo and the marks of the node do not hold the attribute. An open fixed point does not use the cells of the host.
+ * With the cells of a host, only a circular attribute comes here outside a fixed point. A plain attribute takes its cell.
  */
 function circularRead(n: LoopNode, key: string): Result | undefined {
   const rule = circularRule(n.tree, key);
@@ -1221,7 +1233,8 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
           const text = attributeText(key, type, place);
           if (marks.has(key)) return busyAt(state, key);
           if (tree === undefined && up?.tree === undefined && !parts.some((item) => item.key === key)) return undefined;
-          if (circular || openPoint !== undefined) return circularRead(state, key);
+          // Outside a fixed point, a plain attribute of a node with a circular attribute also takes the cell of the host.
+          if (openPoint !== undefined || (circular && circularRule(tree, key) !== undefined)) return circularRead(state, key);
           marks.set(key, BUSY);
           demands.push({ cells: marks, key, text });
           let thrown: unknown = NOT_THROWN;
@@ -1527,6 +1540,27 @@ function isOp(value: unknown): value is Cap {
   return typeof value === "string" || (Array.isArray(value) && value.every(isKey));
 }
 
+/**
+ * This function gives the runner of an `if` with its own truth (RUN.IF-TRUTH). A branch can wait for the host, thus a
+ * language with the function `truthy` of a profile does not need a copy of `if`. A missing test and a test without a
+ * truth give `#VALUE!`, a failed test gives its failure, and a missing branch gives `null`.
+ *
+ * @param truth - The function that gives the truth of a value, or `undefined` for a value without a truth.
+ * @returns The runner.
+ */
+export function ifRunner(truth: (value: unknown) => boolean | undefined): Runner {
+  return function* ({ parts }) {
+    const test = parts.find((part) => part.key === "test");
+    if (test === undefined) return fail("#VALUE!", "if needs a test.");
+    const chosen = yield* test.evaluate();
+    if (!chosen.ok) return chosen;
+    const held = truth(chosen.value);
+    if (held === undefined) return fail("#VALUE!", "The test of if must give a truth value.");
+    const branch = parts.find((part) => part.key === (held ? "then" : "else"));
+    return branch === undefined ? ok(null) : yield* branch.evaluate();
+  };
+}
+
 /**
  * The runners of the standard world, by name: the kinds that can hold effects. Each one evaluates its parts in
  * order. In a run, an effect ends before the next step starts.
@@ -1576,15 +1610,7 @@ export const STD_RUNNERS: Readonly<Record<string, Runner>> = {
     if (!result.ok || after === undefined) return result;
     return yield* after.evaluate({ ...context, names: { ...context.names, result: result.value } });
   },
-  "control.if": function* ({ parts }) {
-    const test = parts.find((part) => part.key === "test");
-    if (test === undefined) return fail("#VALUE!", "if needs a test.");
-    const chosen = yield* test.evaluate();
-    if (!chosen.ok) return chosen;
-    if (typeof chosen.value !== "boolean") return fail("#VALUE!", "The test of if must give a truth value.");
-    const branch = parts.find((part) => part.key === (chosen.value === true ? "then" : "else"));
-    return branch === undefined ? ok(null) : yield* branch.evaluate();
-  },
+  "control.if": /* @__PURE__ */ ifRunner((value) => (typeof value === "boolean" ? value : undefined)),
   "list.all": function* ({ parts }) {
     const all = yield* inOrder(parts);
     return "error" in all ? all.error : ok(all.values);