@mark1russell7/coeval 0.3.1 → 0.3.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "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",

package/src/doc.ts

@@ -106,6 +106,7 @@ export function typePath(type: TypeRef): readonly Key[] | undefined {
  * @returns The text, for example `git.push`.
  */
 export function typeName(type: TypeRef): string {
+  if (typeof type === "string") return type;
   return typePath(type)?.join(".") ?? "(computed)";
 }
 
@@ -126,9 +127,12 @@ function headerFits(value: JsonRecord): boolean {
  * @returns `true` when the value has the form of an envelope.
  */
 export function isEnvelope(value: unknown): value is JsonRecord & Envelope {
-  if (!isRecord(value) || !headerFits(value)) return false;
-  for (const key in value) if (Object.hasOwn(value, key) && !(ENVELOPE_KEYS as readonly string[]).includes(key)) return false;
-  return true;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  // The keys come first: most values that are not envelopes have another key, thus the check stops early.
+  for (const key in value) {
+    if (key !== "type" && key !== "value" && key !== "name" && key !== "own" && Object.hasOwn(value, key)) return false;
+  }
+  return isRecord(value) && headerFits(value);
 }
 
 /** A stored document: an envelope, and the keys of its store beside it, for example `_id`. */

package/src/evaluate.ts

@@ -1,7 +1,7 @@
-import { type Envelope, type Json, type Key, type TypeRef, isEnvelope, isRecord, typeName } from "./doc.ts";
-import { splitParts } from "./parts.ts";
+import { type Envelope, type Json, type Key, type TypeRef, isEnvelope, typeName } from "./doc.ts";
+import { type Split, splitParts } from "./parts.ts";
 import { ask, type Answer } from "./ladder.ts";
-import { type Side, lookupKind } from "./world.ts";
+import { type Lookup, type Side, type World, lookupKind } from "./world.ts";
 import { type ErrorCode, type EvalError, type Result, fail, ok, placed, thrown, describe } from "./errors.ts";
 import {
   type Cap,
@@ -830,23 +830,50 @@ function finish(c: Compiler, meta: Meta, code: Code, run: RunCode): { readonly c
   return { code: tracedCode, run: tracedRun };
 }
 
+/**
+ * This function finds the evaluator of the verb `eval` without the record of the rungs, for a compilation without a
+ * trace. It gives the same evaluator as `ask`: the own entry, then the kind, then the default of the world.
+ */
+function evaluatorOf(world: World, envelope: Envelope | undefined, found: Lookup): { readonly name?: string; readonly unknown: boolean } {
+  const own = envelope?.own;
+  const ownName = own !== undefined && Object.hasOwn(own, "eval") ? own["eval"] : undefined;
+  if (ownName !== undefined) return { name: ownName, unknown: false };
+  if (!found.ok) return { unknown: true };
+  const verbs = found.kind.verbs;
+  const name = Object.hasOwn(verbs, "eval") ? verbs["eval"] : Object.hasOwn(world.defaults, "eval") ? world.defaults["eval"] : undefined;
+  return name === undefined ? { unknown: false } : { name, unknown: false };
+}
+
+/** The meta of a node of a compilation without a trace. Only a trace reads the meta of a node. */
+const NO_META: Meta = Object.freeze({ path: [], doc: { type: "?", value: null }, declared: false, answer: NO_ANSWER, side: "derive" });
+
 function compileNode(c: Compiler, value: unknown, place: readonly Key[], declared: string | undefined, depth: number): { readonly code: Code; readonly run: RunCode } {
   const envelope = isEnvelope(value) ? (value as Envelope) : undefined;
   const doc: Envelope = envelope ?? { type: declared ?? "?", value: value as Json };
-  const path = place.map(String);
-  const meta0: Meta = { path, doc, declared: envelope === undefined, answer: NO_ANSWER, side: "derive" };
+  const meta0: Meta = c.traced ? { path: place.map(String), doc, declared: envelope === undefined, answer: NO_ANSWER, side: "derive" } : NO_META;
   if (envelope === undefined && declared === undefined) {
     return failing(c, meta0, place, "#PART?", "The value has no envelope, and its position declares no type.");
   }
   if (depth > c.maxDepth) return failing(c, meta0, place, "#DEPTH!", `The nesting is deeper than ${c.maxDepth} documents.`);
 
-  const answer = ask(c.machine.world, envelope ?? {}, "eval", declared === undefined ? {} : { declaredType: declared });
-  const found = lookupKind(c.machine.world, doc.type);
+  const world = c.machine.world;
+  const found = lookupKind(world, doc.type);
   const kind = found.ok ? found.kind : undefined;
-  const meta: Meta = { ...meta0, answer, side: kind?.side ?? "derive" };
+  let meta = meta0;
+  let name: string | undefined;
+  let unknown: boolean;
+  if (c.traced) {
+    const answer = ask(world, envelope ?? {}, "eval", declared === undefined ? {} : { declaredType: declared });
+    meta = { ...meta0, answer, side: kind?.side ?? "derive" };
+    name = answer.evaluator;
+    unknown = answer.error === "unknown-kind";
+  } else {
+    const quick = evaluatorOf(world, envelope, found);
+    name = quick.name;
+    unknown = quick.unknown;
+  }
   const kindText = typeName(doc.type);
-  if (answer.error === "unknown-kind") return failing(c, meta, place, "#KIND?", `The world has no kind ${kindText}.`);
-  const name = answer.evaluator;
+  if (unknown) return failing(c, meta, place, "#KIND?", `The world has no kind ${kindText}.`);
   const runners = c.machine.runners ?? {};
   const runner = name !== undefined && Object.hasOwn(runners, name) ? runners[name] : undefined;
   const evaluator = name !== undefined && Object.hasOwn(c.machine.evaluators, name) ? c.machine.evaluators[name] : undefined;
@@ -860,9 +887,13 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
     return failing(c, meta, place, "#VALUE!", `${split.reason}${at} The kind is ${kindText}.`);
   }
   const parts: CompiledPart[] = split.parts.map((slot) => {
-    const compiled = compileNode(c, slot.item, [...place, ...slot.path], slot.of, depth + 1);
-    const header = isEnvelope(slot.item) && isRecord(slot.item) && typeof slot.item["name"] === "string" ? slot.item["name"] : undefined;
-    return { key: slot.key, path: slot.path, ...(header === undefined ? {} : { name: header }), code: compiled.code, run: compiled.run };
+    const item = slot.item;
+    const compiled = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1);
+    // The binding name is in the header of an envelope. Most parts have no name, thus the cheap test comes first.
+    const header = typeof (item as { readonly name?: unknown } | null)?.name === "string" && isEnvelope(item) ? (item as { readonly name: string }).name : undefined;
+    return header === undefined
+      ? { key: slot.key, path: slot.path, code: compiled.code, run: compiled.run }
+      : { key: slot.key, path: slot.path, name: header, code: compiled.code, run: compiled.run };
   });
   const typePath = found.ok ? found.path : [];
   const input: CompileInput = {
@@ -874,41 +905,70 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
     parts,
     place,
     machine: c.machine,
-    fill: (items) => (split.parts.length === 0 ? doc.value : split.fill(items)),
+    fill: fillOf(split, doc),
   };
-  const who = `the evaluator ${name}`;
-
   if (runner !== undefined) {
     const inner: RunCode = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill);
-    const run: RunCode = function* (ctx, rt) {
-      try {
-        return placed(yield* inner(ctx, rt), place);
-      } catch (error) {
-        return placed(thrown(error, `the runner ${name}`), place);
-      }
-    };
-    const code: Code = (ctx, rt) =>
-      rt.running
-        ? fail("#CALC!", `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`, { place })
-        : drive(run(ctx, rt));
-    return finish(c, meta, code, run);
+    const run = placedRun(inner, place, name);
+    return finish(c, meta, runnerCode(run, place, kindText), run);
   }
 
   const inner: Code = isCompiledEvaluator(evaluator as Evaluator)
     ? (evaluator as CompiledEvaluator).compile(input)
     : interpret(evaluator as EvalFn, input, split.fill);
-  const code: Code = (ctx, rt) => {
+  const code = placedCode(inner, place, name);
+  return finish(c, meta, code, runOf(code));
+}
+
+/*
+ * The helpers below make the closures that a plan keeps. Each one has its own small scope. A closure that a
+ * compilation made in its own scope keeps each variable of that scope that any closure there reads, for example
+ * the split of the value. Thus a plan with these helpers keeps only its code.
+ */
+
+/** This function gives the code of a document: the code of its evaluator, with the place of each error and of each exception. */
+function placedCode(inner: Code, place: readonly Key[], name: string): Code {
+  return (ctx, rt) => {
     try {
       return placed(inner(ctx, rt), place);
     } catch (error) {
-      return placed(thrown(error, who), place);
+      return placed(thrown(error, `the evaluator ${name}`), place);
     }
   };
-  return finish(c, meta, code, function* (ctx, rt) {
+}
+
+/** This function gives the steps of a runner, with the place of each error and of each exception. */
+function placedRun(inner: RunCode, place: readonly Key[], name: string): RunCode {
+  return function* (ctx, rt) {
+    try {
+      return placed(yield* inner(ctx, rt), place);
+    } catch (error) {
+      return placed(thrown(error, `the runner ${name}`), place);
+    }
+  };
+}
+
+/** This function gives the code of a runner in an evaluation: its steps, which cannot wait. */
+function runnerCode(run: RunCode, place: readonly Key[], kindText: string): Code {
+  return (ctx, rt) =>
+    rt.running
+      ? fail("#CALC!", `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`, { place })
+      : drive(run(ctx, rt));
+}
+
+/** This function gives the steps of a run of an evaluator. The code runs at the first step, and it does not wait. */
+function runOf(code: Code): RunCode {
+  return function* (ctx, rt) {
     return code(ctx, rt);
-  });
+  };
+}
+
+/** This function gives the fill of a compile input: the value with an item in the place of each part. */
+function fillOf(split: Extract<Split, { readonly ok: true }>, doc: Envelope): <P>(items: readonly P[]) => unknown {
+  return (items) => (split.parts.length === 0 ? doc.value : split.fill(items));
 }
 
+
 function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly P[]) => unknown): Code {
   const { kind, typePath, doc, data, place } = input;
   const compiled = input.parts;
@@ -992,16 +1052,21 @@ export function prepare(machine: Machine, doc: unknown, options: PrepareOptions
     };
   }
   const compiled: CompiledPart = { key: "", path: [], code: root.code, run: root.run };
+  return planOf(machine, c.traced, compiled);
+}
+
+/** This function makes the object of a plan. Its closures keep only the machine and the compiled root. */
+function planOf(machine: Machine, traced: boolean, root: CompiledPart): Plan {
   return {
     machine,
-    traced: c.traced,
-    root: compiled,
-    evaluate(context: Context = makeContext(), evalOptions: EvalOptions = {}): Result {
-      const s = new Session(machine, false, c.traced, undefined, undefined, evalOptions.effects);
+    traced,
+    root,
+    evaluate(context: Context = makeContext(), evalOptions?: EvalOptions): Result {
+      const s = new Session(machine, false, traced, undefined, undefined, evalOptions?.effects);
       return root.code(rootContext(machine, context), s);
     },
     run(context: Context = makeContext(), runOptions: RunOptions = {}): Promise<Result> {
-      const s = new Session(machine, true, c.traced, runOptions.perform, runOptions.signal, undefined);
+      const s = new Session(machine, true, traced, runOptions.perform, runOptions.signal, undefined);
       return driveWaiting(root.run(rootContext(machine, context), s), runOptions.signal);
     },
   };

package/src/formula.ts

@@ -84,8 +84,13 @@ function strictTruthy(value: unknown): boolean | undefined {
   return typeof value === "boolean" ? value : undefined;
 }
 
+/**
+ * This function sets an own data property. Only the key `__proto__` needs `defineProperty`: an assignment to it
+ * changes the prototype. An assignment is faster for each other key of a new plain object.
+ */
 function setOwn(target: Record<string, unknown>, key: string, value: unknown): void {
-  Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+  if (key === "__proto__") Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+  else target[key] = value;
 }
 
 function compiled(compile: (input: CompileInput) => Code): CompiledEvaluator {
@@ -193,16 +198,18 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
     }),
 
     "formula.record": compiled(({ value }) => {
-      const fields = Object.entries(partsOf(value));
+      const fields = partsOf(value);
+      const keys = Object.keys(fields);
+      const codes = keys.map((key) => (fields[key] as CompiledPart).code);
       return (ctx, rt) => {
         const out: Record<string, unknown> = {};
-        for (const [key, part] of fields) {
-          const result = part.code(ctx, rt);
+        for (let index = 0; index < keys.length; index += 1) {
+          const result = (codes[index] as Code)(ctx, rt);
           if (!result.ok) {
             if (omit !== undefined && omit(result.error)) continue;
             return result;
           }
-          setOwn(out, key, result.value);
+          setOwn(out, keys[index] as string, result.value);
         }
         return ok(out);
       };

package/src/parts.ts

@@ -42,10 +42,14 @@ class Bad {
   ) {}
 }
 
+/** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
 function setOwn(target: Record<string, unknown>, key: string, value: unknown): void {
-  Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+  if (key === "__proto__") Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+  else target[key] = value;
 }
 
+const NO_SLOTS: readonly PartSlot[] = Object.freeze([]);
+
 function hasSlots(template: Template): boolean {
   return template.t !== "data";
 }
@@ -59,6 +63,8 @@ function hasSlots(template: Template): boolean {
  * @returns The parts and a way to fill their places, or the reason why the value does not have the shape.
  */
 export function splitParts(shape: Shape | undefined, value: Json): Split {
+  // A value without parts is data: the split needs no template.
+  if (shape === undefined || shape.shape === "none") return { ok: true, parts: NO_SLOTS, data: value, fill: () => value };
   const parts: PartSlot[] = [];
   const slot = (item: Json, path: readonly Key[], of: string | undefined): Template => {
     parts.push({ path, key: path.join("."), item, ...(of === undefined ? {} : { of }) });

package/src/static.ts

@@ -111,6 +111,15 @@ function scopesOf(rules: readonly ScopeRule[] | undefined, value: unknown, slots
   return { sees, later };
 }
 
+/** The names of a walk without names. A walk does not change a set at any time: it makes a new set to add names. */
+const NO_NAMES: ReadonlySet<string> = new Set();
+
+/** This function gives the options of a walk without the names of the host. */
+function withoutNames(options: WalkOptions): WalkOptions {
+  const { names: _host, ...rest } = options;
+  return rest;
+}
+
 /**
  * This function visits each document of a document: the root and each part at each depth, by the contracts of the
  * kinds. A part of a kind that the world does not have is not visited. The walk uses no stack of the host for the
@@ -131,9 +140,8 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
     readonly names: ReadonlySet<string>;
     readonly later: ReadonlySet<string>;
   }
-  const stack: Item[] = [
-    { value: doc, place: [], at: [], declared: options.declaredType, depth: 0, names: new Set(options.names ?? []), later: new Set() },
-  ];
+  const names: ReadonlySet<string> = options.names === undefined || options.names.length === 0 ? NO_NAMES : new Set(options.names);
+  const stack: Item[] = [{ value: doc, place: [], at: [], declared: options.declaredType, depth: 0, names, later: NO_NAMES }];
   while (stack.length > 0) {
     const item = stack.pop() as Item;
     const envelope = isEnvelope(item.value) ? (item.value as Envelope) : undefined;
@@ -144,16 +152,21 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
     const doc: Envelope = envelope ?? { type: item.declared ?? "?", value: item.value as Json };
     const found = lookupKind(world, doc.type);
     const kind = found.ok ? found.kind : undefined;
-    const answer = visit({
-      place: item.place,
-      at: item.at,
-      doc,
-      declared: envelope === undefined,
-      ...(kind === undefined ? {} : { kind, typePath: found.ok ? found.path : [] }),
-      depth: item.depth,
-      names: item.names,
-      later: item.later,
-    });
+    const seen: DocVisit =
+      kind === undefined
+        ? { place: item.place, at: item.at, doc, declared: envelope === undefined, depth: item.depth, names: item.names, later: item.later }
+        : {
+            place: item.place,
+            at: item.at,
+            doc,
+            declared: envelope === undefined,
+            kind,
+            typePath: found.ok ? found.path : [],
+            depth: item.depth,
+            names: item.names,
+            later: item.later,
+          };
+    const answer = visit(seen);
     if (answer === "skip" || kind === undefined) continue;
     const split = splitParts(kind.parts, doc.value);
     if (!split.ok) {
@@ -206,7 +219,7 @@ export interface RefUse {
 export function refsOf(world: World, doc: unknown, options: WalkOptions = {}): readonly RefUse[] {
   const out: RefUse[] = [];
   // The walk gets no names of the host: a name that the host binds is a dependency, thus its reference is free.
-  const { names: _host, ...rest } = options;
+  const rest: WalkOptions = options.names === undefined ? options : withoutNames(options);
   walk(
     world,
     doc,