@mark1russell7/coeval 0.16.0 → 0.17.0

package/src/static.ts

@@ -619,9 +619,9 @@ const FOLD_NAMES: readonly string[] = /* @__PURE__ */ Object.freeze(["acc", "ite
 
 /**
  * This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
- * `equations`, a `unit` and a `default` see no names.
+ * `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
  */
-function equationsOf(kind: Kind): readonly { readonly label: string; readonly term: Json; readonly names: readonly string[] }[] {
+export function equationsOf(kind: Kind): readonly { readonly label: string; readonly term: Json; readonly names: readonly string[] }[] {
   const tree = kind.tree;
   if (tree === undefined) return [];
   const out: { readonly label: string; readonly term: Json; readonly names: readonly string[] }[] = [];

package/src/stdlib.ts

@@ -2,12 +2,15 @@ import { type Json, type Key, field, isRecord } from "./doc.ts";
 import {
   type EvalInput,
   type Evaluator,
+  type InputWithRuntime,
   type Machine,
   type Plan,
   type Result,
   type RunPart,
   type Runner,
   type Steps,
+  RUNTIME,
+  evaluateWithin,
   fail,
   ok,
   planner,
@@ -17,6 +20,7 @@ import { type Cap, type HostThing, type Thing, type Walker, THING, isHostThing,
 import type { World } from "./ladder.ts";
 import { type AttributeDeclaration, type TreeContract, equationType, lookupKind } from "./world.ts";
 import { STD_DOMAINS } from "./types.ts";
+import type { SyntaxProfile } from "./syntax.ts";
 
 /**
  * The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
@@ -127,6 +131,52 @@ export const STD_WORLD: World = {
   defaults: { view: "view.card" },
 };
 
+/**
+ * The text syntax of the standard world (K162, D64). The syntax kit (D41) reads it, thus a host of `STD_WORLD` does
+ * not write its own profile. The operators `>`, `+` and `*` make `greater`, `add` and `multiply`. A call form makes
+ * each other kind, and `ref` uses the reference syntax of the kit.
+ *
+ * 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).
+ *
+ * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
+ * the formula kit.
+ */
+export const WORLD_SYNTAX: SyntaxProfile = /* @__PURE__ */ Object.freeze({
+  operators: [
+    { symbol: ">", fixity: "infix", prec: 4, assoc: "none", kind: "greater" },
+    { symbol: "+", fixity: "infix", prec: 5, assoc: "flat", kind: "add" },
+    { symbol: "*", fixity: "infix", prec: 6, assoc: "flat", kind: "multiply" },
+  ],
+  calls: {
+    ops: [],
+    forms: [
+      { name: "if", kind: "if", fields: ["test", "then", "else"], min: 2, wrap: true },
+      { name: "list", kind: "list", wrap: true },
+      { name: "seq", kind: "seq", wrap: true },
+      { name: "pure", kind: "pure", min: 1, wrap: true },
+      { name: "log", kind: "log", min: 1 },
+      { name: "write", kind: "write", fields: ["key", "value"], wrap: ["value"] },
+      { name: "math.sum", kind: "math.sum" },
+      { name: "math.product", kind: "math.product" },
+      { name: "number", kind: "number", args: "literal" },
+      { name: "text", kind: "text", args: "literal" },
+      { name: "bool", kind: "bool", args: "literal" },
+      { name: "panel", kind: "panel", args: "named", fields: ["width", "height", "children"] },
+      { name: "box", kind: "box", args: "named", fields: ["width", "height", "children"] },
+      { name: "nearest", kind: "nearest", args: "named", fields: ["type", "follow", "self"] },
+      // An operator document with fewer terms than its operator takes, for example add(5) (K163, D65).
+      { name: "add", kind: "add" },
+      { name: "multiply", kind: "multiply" },
+      { name: "greater", kind: "greater" },
+    ],
+  },
+  literals: { envelopes: { number: "number", text: "text", bool: "bool" } },
+  header: { bind: "=" },
+} satisfies SyntaxProfile);
+
 function isNumber(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value);
 }
@@ -234,7 +284,8 @@ interface NodeState {
    */
   read(key: string): Result | undefined;
   /**
-   * This function evaluates an equation of the kind of the node, with the node as `self` and no capabilities.
+   * This function evaluates an equation of the kind of the node, with the node as `self` and no capabilities. Its
+   * reads go in the list of the evaluation that made the node (READS.EQUATION).
    *
    * @param term - The equation.
    * @param names - The names that the equation sees.
@@ -403,6 +454,8 @@ function plainOf(value: unknown, path: Set<object>): Result {
  */
 function treeThing(input: EvalInput, build: TreeBuild, outer: Thing | undefined): HostThing {
   const { parts, context, kind: type, place, machine } = input;
+  // The equations evaluate in the evaluation that made the node, thus their reads go in its list (READS.EQUATION).
+  const runtime = (input as InputWithRuntime)[RUNTIME];
   const { tree, of } = contractOf(machine, input.typePath);
   const above = stateOf(outer);
   // Only a node of the same tree is a parent for the rungs `parent` and `copy`.
@@ -481,7 +534,7 @@ function treeThing(input: EvalInput, build: TreeBuild, outer: Thing | undefined)
     read,
     equation(term, names) {
       if (machine === undefined) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
-      return equationPlan(machine, of, term).evaluate({ ...context, names, caps: NO_CAPS, self: node });
+      return evaluateWithin(equationPlan(machine, of, term), { ...context, names, caps: NO_CAPS, self: node }, runtime);
     },
     childNames(child) {
       const children = read("children");