@mark1russell7/coeval 0.27.1 → 0.28.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.27.1",
+  "version": "0.28.0",
   "description": "coeval: the kernel of declarative languages. Documents in envelopes, a ladder that finds the evaluator, kind contracts, compiled plans, a static kit, a formula kit and a run side with capabilities.",
   "type": "module",
   "main": "./build/index.js",
@@ -39,6 +39,7 @@
     "@mark1russell7/rigor-bench": "^0.2.29",
     "@mark1russell7/rigor-statistics": "^0.1.16",
     "@types/node": "^26.6.4",
+    "@vitest/coverage-v8": "5.0.5",
     "esbuild": "^0.28.2",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3"
@@ -47,6 +48,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@mark1russell7/collections": "^0.9.11",
     "@mark1russell7/rigor-generators": "^0.1.8"
   },
   "scripts": {

package/src/graph.ts

@@ -1,3 +1,4 @@
+import { strongComponentsCompact } from "@mark1russell7/collections/graph";
 import type { Side } from "./world.ts";
 
 /*
@@ -110,72 +111,12 @@ interface Strong {
 }
 
 /**
- * This function finds the strongly connected components with the algorithm of Tarjan. It keeps its own stack of
- * calls in two arrays, thus a long chain does not overflow the stack of the host. Each component comes after each
- * component that its nodes reach: the deepest component comes first.
+ * This function finds the strongly connected components with `strongComponentsCompact` of
+ * `@mark1russell7/collections` (K249). The search keeps its own stack, thus a long chain does not overflow the stack
+ * of the host. Each component comes after each component that its nodes reach: the deepest component comes first.
  */
 function strong(graph: Indexed<unknown>): Strong {
-  const { size, start, targets } = graph;
-  const order = new Int32Array(size).fill(-1);
-  const low = new Int32Array(size);
-  const of = new Int32Array(size).fill(-1);
-  // The nodes of the components that are still open.
-  const open = new Int32Array(size);
-  const onOpen = new Uint8Array(size);
-  // The stack of calls: a node, and the position of its next edge.
-  const calls = new Int32Array(size);
-  const next = new Int32Array(size);
-  const list: number[][] = [];
-  let top = 0;
-  let count = 0;
-  const enter = (node: number, depth: number): void => {
-    order[node] = count;
-    low[node] = count;
-    count += 1;
-    open[top] = node;
-    top += 1;
-    onOpen[node] = 1;
-    calls[depth] = node;
-    next[depth] = start[node] as number;
-  };
-  for (let root = 0; root < size; root += 1) {
-    if (order[root] !== -1) continue;
-    enter(root, 0);
-    let depth = 1;
-    while (depth > 0) {
-      const node = calls[depth - 1] as number;
-      const edge = next[depth - 1] as number;
-      if (edge < (start[node + 1] as number)) {
-        next[depth - 1] = edge + 1;
-        const to = targets[edge] as number;
-        if (order[to] === -1) {
-          enter(to, depth);
-          depth += 1;
-        } else if (onOpen[to] === 1 && (order[to] as number) < (low[node] as number)) {
-          low[node] = order[to] as number;
-        }
-        continue;
-      }
-      depth -= 1;
-      if (low[node] === order[node]) {
-        const members: number[] = [];
-        let member: number;
-        do {
-          top -= 1;
-          member = open[top] as number;
-          onOpen[member] = 0;
-          of[member] = list.length;
-          members.push(member);
-        } while (member !== node);
-        list.push(members.sort((a, b) => a - b));
-      }
-      if (depth > 0) {
-        const reader = calls[depth - 1] as number;
-        if ((low[node] as number) < (low[reader] as number)) low[reader] = low[node] as number;
-      }
-    }
-  }
-  return { of, list };
+  return strongComponentsCompact(graph.size, graph.start, graph.targets);
 }
 
 /** This function tells if a component has a cycle: two or more nodes, or one node with an edge to itself. */

package/src/schedule.ts

@@ -362,8 +362,14 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
    */
   const hostDemand = (id: string): Result => {
     const before = overflowCount();
+    const size = current().values.size;
     const result = visit(id);
-    return overflowCount() === before && current().walk === undefined ? result : settle(id, result);
+    if (overflowCount() === before) return current().walk === undefined ? result : settle(id, result, []);
+    // A map keeps the order of its new keys. Thus the entries after the first `size` are the nodes of this demand (S2b).
+    const touched: string[] = [];
+    let index = 0;
+    for (const node of current().values.keys()) if (index++ >= size) touched.push(node);
+    return settle(id, result, touched);
   };
 
   /** This function demands one node, with the algorithm of Tarjan over the demands for the cycles of D31. */
@@ -490,20 +496,26 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
    * Each evaluation enters a new node or finishes a node. Thus the walks of a data epoch do at most `2V` evaluations
    * for `V` entered nodes. They keep one result and one entry in each list for each such node.
    *
-   * A walk that reaches no cycle changes nothing, thus a chain keeps its `#DEPTH!`. After a cycle, each entered node
-   * keeps only its error. A node with a value evaluates again at its next demand, because a value can hold the root of
-   * the walk.
+   * After a cycle, each entered node keeps only its error. A result of the overflowed demand depends on the depth of
+   * the stack, thus each such node loses its result too (S2b). A node with a value does not take the value of the walk,
+   * because a value can hold the root of the walk. The schedule demands these nodes again, in the order in which the
+   * walk finished them. Thus each read of such a demand finds a result, and a long chain through lazy reads gives its
+   * value.
    *
    * @param id - The node of the demand.
    * @param given - The result of the demand.
+   * @param touched - The nodes that the overflowed demand gave a result. A demand with no overflow gives none.
    * @returns The final result of the demand.
    */
-  const settle = (id: string, given: Result): Result => {
+  const settle = (id: string, given: Result, touched: readonly string[]): Result => {
     const epoch = current();
     const walk = (epoch.walk ??= startWalk());
     const { results } = walk;
-    if (results.has(id) || cache.facts(docs.get(id)).side === "run") return given;
+    if (cache.facts(docs.get(id)).side === "run") return given;
+    if (results.has(id) && touched.length === 0) return given;
     const entered: string[] = [];
+    // The entered nodes in the order in which the walk finished them. Each node finishes after the nodes that it reads.
+    const finished: string[] = [];
     const starts: number[] = [];
     const enter = (node: string): void => {
       const mine = count++;
@@ -537,6 +549,7 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
         const self = looped.delete(node);
         const onCycle = reached < (order.get(node) as number) || close(from) > 1 || self;
         results.set(node, onCycle ? cycleOf(node) : result);
+        finished.push(node);
         // A node behind a cycle of an earlier walk finds that cycle too.
         found ||= onCycle || (!result.ok && result.error.code === "#CYCLE!");
         const reader = stack[stack.length - 1];
@@ -549,14 +562,22 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
       looped.clear();
       close(0);
     }
-    if (!found) return given;
-    for (const node of entered) {
-      const result = results.get(node) as Result;
+    if (!found && touched.length === 0) return given;
+    for (const node of touched) {
       cache.forget(node);
-      if (result.ok) epoch.values.delete(node);
-      else epoch.values.set(node, result);
+      epoch.values.delete(node);
     }
-    return visit(id);
+    if (found) {
+      for (const node of entered) {
+        const result = results.get(node) as Result;
+        cache.forget(node);
+        if (result.ok) epoch.values.delete(node);
+        else epoch.values.set(node, result);
+      }
+    }
+    // Each demand starts with no node in evaluation, and the nodes that it reads already have their results.
+    for (const node of finished) if (!epoch.values.has(node)) visit(node);
+    return epoch.values.get(id) ?? visit(id);
   };
 
   /** This function gives the record of the derive nodes, for a path that ends at the root `world`. */