@mark1russell7/coeval 0.27.0 → 0.27.1

package/package.json

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

@@ -1199,6 +1199,11 @@ class Session implements Runtime {
   declare work?: number;
   /** The count of the applications of closures that run at this time. `formula.fn` writes it (FORMULA.CALL-DEPTH). */
   declare applying?: number;
+  /**
+   * The count of the applications of closures that run at this time, on the root and on each runtime of an equation
+   * (WORK.AFTER). `formula.fn` writes it on the runtime of the root. The first application adds the field.
+   */
+  declare active?: number;
   readonly machine: Machine;
   /**
    * The epoch of the evaluation: the list of capabilities that the host gave the root (CAP.NARROW-KEPT). A context
@@ -1268,14 +1273,14 @@ class Session implements Runtime {
   /**
    * This function adds work to the count of the evaluation (WORK.LIMIT). One count is on the runtime of the root, thus
    * each equation of a tree adds to it. After the end of the evaluation, each entry from the host starts a new count
-   * (WORK.AFTER).
+   * (WORK.AFTER). An entry is a point with no application of a closure that runs, on any runtime of the evaluation.
    *
    * @param points - The work.
    * @throws {Failure} The error `#WORK!`, when the count is over the limit of the machine.
    */
   spend(points: number): void {
     const root = this.top ?? this;
-    const entry = root.top === root && (this.applying ?? 0) === 0;
+    const entry = root.top === root && (root.active ?? 0) === 0;
     const work = (entry ? 0 : (root.work ?? 0)) + points;
     root.work = work;
     const limit = this.machine.maxWork ?? WORK_LIMIT;

package/src/formula.ts

@@ -139,7 +139,7 @@ export function isClosure(value: unknown): value is Closure {
  * The runtime of an evaluation with the clock of `call` (FORMULA.CALL-DEPTH, D125): the count of the applications of
  * closures that run at this time. The first application adds the field, thus an evaluation without one has no field.
  */
-type Clocked = Runtime & { applying?: number };
+type Clocked = Runtime & { applying?: number; active?: number; top?: Clocked | undefined };
 
 /**
  * The standard extensions: the values that JSON cannot write. `ext.domain` reads a member of a domain through the
@@ -1047,7 +1047,11 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
           if (level > limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
           // WORK.LIMIT: an application is a place where work can multiply, thus each one counts one point (D134).
           rt.spend?.(1);
+          // WORK.AFTER: the runtime of the root counts the applications of each runtime of the evaluation. An equation of
+          // a tree in the body has its own runtime, and its work does not start a new count.
+          const root = clock.top ?? clock;
           clock.applying = level;
+          root.active = (root.active ?? 0) + 1;
           try {
             const scope: Record<string, unknown> = { ...ctx.names };
             names.forEach((name, index) => setOwn(scope, name, args[index]));
@@ -1056,6 +1060,7 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
             return result.value;
           } finally {
             clock.applying = level - 1;
+            root.active = (root.active ?? 1) - 1;
           }
         };
         Object.defineProperty(closure, CLOSURE, { value: { params: names } });

package/src/generate.ts

@@ -198,7 +198,12 @@ export function generate(world: World, options: GenerateOptions): unknown {
   const envelope = (type: readonly Key[], value: Json, header?: string): Json => {
     const out: Record<string, Json> = { type: renderType(type), value };
     if (header !== undefined) out["name"] = header;
-    if (options.own !== undefined && options.own.length > 0 && rng.chance(0.03)) out["own"] = { eval: rng.pick(options.own) };
+    if (options.own !== undefined && options.own.length > 0 && rng.chance(0.03)) {
+      const code = rng.pick(options.own);
+      // The code of a kind binds the names of its scope rules (C7). An own entry of other code does not, thus a kind
+      // with scope rules gets no own entry (GEN.CONTRACTS). The draws stay, thus each other document stays the same.
+      if ((kindOf(type)?.scope ?? []).length === 0) out["own"] = { eval: code };
+    }
     return out;
   };
 

package/src/index.ts

@@ -91,7 +91,7 @@ export {
   restrictMachine,
   restrictWorld,
 } from "./merge.ts";
-export { type Language, type LanguageCode, type LanguageDefinition, compose, defineLanguage } from "./language.ts";
+export { type Language, type LanguageCode, type LanguageDefinition, boundary, compose, defineLanguage } from "./language.ts";
 export {
   type Answer,
   type AskOptions,

package/src/language.ts

@@ -1,5 +1,6 @@
 import { type Key, isRecord } from "./doc.ts";
-import type { Machine } from "./evaluate.ts";
+import { type InputWithRuntime, type Machine, type Plan, RUNTIME, evaluateWithin, makeContext, planner } from "./evaluate.ts";
+import { fail } from "./errors.ts";
 import { type MachinePart, type MergeConflict, type WorldPart, MergeError, mergeMachines } from "./merge.ts";
 
 /** The code half of a language: each field of a machine part, without the world. */
@@ -145,3 +146,52 @@ export function compose(...languages: readonly Language[]): Machine {
   if (conflicts.length > 0) throw new MergeError(conflicts);
   return mergeMachines(...parts);
 }
+
+/**
+ * This function makes the language of the boundary kind `lang` (K38, D193). A document of the kind holds the name of a
+ * language and a document in that language: `{ type: "lang", value: { language, doc } }`. The machine of the named
+ * language prepares and evaluates the inner document, as a module of another language (COMPOSE.BOUNDARY).
+ *
+ * The boundary is closed. The inner document gets no names, no capabilities and no node as `self`. Only its result
+ * crosses the boundary. Thus an effect in the inner document fails with `#CAP!`, and the inner machine cannot read the
+ * names of the outer document.
+ *
+ * @param machines - The machine of each language, by the name that a document gives.
+ * @returns The language, for `compose`.
+ */
+export function boundary(machines: Readonly<Record<string, Machine>>): Language {
+  const plans = new Map<string, (doc: unknown) => Plan>();
+  const planOf = (name: string): ((doc: unknown) => Plan) | undefined => {
+    let found = plans.get(name);
+    if (found === undefined && Object.hasOwn(machines, name)) {
+      found = planner(machines[name] as Machine);
+      plans.set(name, found);
+    }
+    return found;
+  };
+  return defineLanguage({
+    name: "boundary",
+    version: "1.0.0",
+    world: {
+      kinds: {
+        lang: {
+          verbs: { eval: "boundary.lang" },
+          summary: "A document in another language. The machine of that language evaluates it, with no names and no capabilities.",
+        },
+      },
+    },
+    code: {
+      evaluators: {
+        "boundary.lang": (input) => {
+          const { data, place } = input;
+          if (!isRecord(data) || typeof data["language"] !== "string" || !("doc" in data)) {
+            return fail("#VALUE!", "A document of the kind lang has the value { language, doc }.", { place });
+          }
+          const plans = planOf(data["language"]);
+          if (plans === undefined) return fail("#NAME?", `The boundary knows no language ${JSON.stringify(data["language"])}.`, { place });
+          return evaluateWithin(plans(data["doc"]), makeContext(), (input as InputWithRuntime)[RUNTIME]);
+        },
+      },
+    },
+  });
+}

package/src/reference.ts

@@ -119,6 +119,8 @@ interface Meter {
   spent: number;
   /** `true` after the end of the evaluation. Then each entry from the host starts a new count (WORK.AFTER). */
   ended: boolean;
+  /** The count of the applications of closures that run at this time, in each state of the evaluation (WORK.AFTER). */
+  active: number;
 }
 
 /** The state of one evaluation of the reference. */
@@ -731,7 +733,7 @@ function evaluateRoot(machine: Machine, doc: unknown, context: Context, options:
  */
 function spend(env: Pick<Env, "maxWork" | "meter" | "applying">, points: number): void {
   const meter = env.meter;
-  if (meter.ended && env.applying === 0) meter.spent = 0;
+  if (meter.ended && meter.active === 0) meter.spent = 0;
   meter.spent += points;
   if (meter.spent > env.maxWork) throw new Failure(workFailure(env.maxWork));
 }
@@ -781,7 +783,7 @@ function envOf(machine: Machine, options: ReferenceOptions, running: boolean, ro
     held: 0,
     applying: 0,
     maxWork: machine.maxWork ?? WORK_LIMIT,
-    meter: meter ?? { spent: 0, ended: false },
+    meter: meter ?? { spent: 0, ended: false, active: 0 },
     nested: meter !== undefined,
     reading: outer ?? (options.reads === undefined ? undefined : { list: options.reads, root }),
   };
@@ -1521,22 +1523,28 @@ export function formulaDefinitions(profile: FormulaProfile = {}): Definitions {
     const names = params as readonly string[];
     const body = partNamed(parts, "body") as Part;
     // FORMULA.CALL-DEPTH: the evaluation that makes the closure counts its applications. A quarter of maxDepth is the limit.
-    const clock = activeEnvs[activeEnvs.length - 1] ?? { applying: 0, maxDepth: 1000, maxWork: WORK_LIMIT, meter: { spent: 0, ended: false } };
+    const maker = activeEnvs[activeEnvs.length - 1];
+    const clock = maker ?? { applying: 0, maxDepth: 1000, maxWork: WORK_LIMIT, meter: { spent: 0, ended: false, active: 0 } };
     const limit = Math.ceil(clock.maxDepth / 4);
     const closure = (...args: readonly unknown[]): unknown => {
       if (clock.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
       // WORK.LIMIT: each application counts one point, after the clock of its depth.
       spend(clock, 1);
       clock.applying += 1;
+      clock.meter.active += 1;
       try {
         const scope: Record<string, unknown> = {};
         for (const key of Object.keys(context.names)) setField(scope, key, context.names[key]);
         names.forEach((name, index) => setField(scope, name, args[index]));
-        const result = body.evaluate({ ...context, names: scope });
+        // The body evaluates in the state of the evaluation that made the closure, also for a host after the end. Thus a
+        // node of a tree in the body has the machine for its equations (WORK.AFTER).
+        const scoped: Context = { ...context, names: scope };
+        const result = maker === undefined ? body.evaluate(scoped) : within(maker, () => body.evaluate(scoped));
         if (!result.ok) throw new Failure(result.error);
         return result.value;
       } finally {
         clock.applying -= 1;
+        clock.meter.active -= 1;
       }
     };
     Object.defineProperty(closure, CLOSURE, { value: { params: names } });

package/src/stepper.ts

@@ -1,11 +1,12 @@
 import { type Envelope, type Json, type Key, type TypeRef, docEquals, field, isEnvelope, isRecord, typeName } from "./doc.ts";
 import { type Cap, type Context, type Resolution, type ResolveOptions, type Thing, isHostThing, worldThing } from "./deref.ts";
 import { type EvalError, type Result, Failure, describe, fail, ok, placed, thrown } from "./errors.ts";
-import { type Effect, type EvalInput, type Machine, type Part, type Perform, intersectCaps, makeContext, permits, placeText } from "./evaluate.ts";
+import { type Effect, type EvalInput, type Machine, type Part, type Perform, WORK_LIMIT, intersectCaps, makeContext, permits, placeText, workFailure } from "./evaluate.ts";
 import { type FormulaProfile, type OpFn, Held, STD_EXT } from "./formula.ts";
 import type { World } from "./ladder.ts";
 import { pathMatches } from "./parts.ts";
-import type { Definitions } from "./reference.ts";
+import { type Definitions, STD_DEFINITIONS } from "./reference.ts";
+import { STD_EVALUATORS } from "./stdlib.ts";
 import { type CapsRule, type Kind, type Shape, type WorldEntry, isAlias, isKind, isNamespace } from "./world.ts";
 
 /**
@@ -111,6 +112,12 @@ interface Shared {
   readonly applying: number;
   /** `true` after a closure or a held error goes in a value. Only then does a value need a change for the host. */
   readonly marked: boolean;
+  /** The work of the evaluation after the last call of `stepperNext` (WORK.LIMIT). A configuration without it has done no work. */
+  readonly work?: number;
+  /** The number of earlier effects at each place, after the last call of `stepperNext` (RUN.ADDRESS). */
+  readonly counts?: Readonly<Record<string, number>>;
+  /** The number of effects of the evaluation, after the last call of `stepperNext`. */
+  readonly effected?: number;
 }
 
 /**
@@ -164,8 +171,16 @@ interface Program {
   readonly perform: Perform | undefined;
   /** The number of earlier effects at each place, by the text of the place (RUN.ADDRESS). */
   readonly counts: Map<string, number>;
+  /** The number of effects of the evaluation before the list `effects`. */
+  before: number;
   /** The count of the applications at the last call of host code. */
   applying: number;
+  /** The most work of one evaluation (WORK.LIMIT). */
+  readonly maxWork: number;
+  /** The work of the evaluation: one point for each application of a closure (WORK.LIMIT). */
+  work: number;
+  /** `true` after the end of the evaluation. Then each application from the host starts a new count (WORK.AFTER). */
+  ended: boolean;
 }
 
 const CLOSURE_MARK = "coeval.closure";
@@ -555,6 +570,9 @@ function apply(p: Program, c: Configuration, target: unknown, args: readonly unk
   }
   const limit = Math.ceil(p.maxDepth / 4);
   if (c.applying >= limit) return back(c, fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`));
+  // WORK.LIMIT: each application counts one point, after the clock of its depth.
+  p.work += 1;
+  if (p.work > p.maxWork) return back(c, { ok: false, error: workFailure(p.maxWork) });
   const frame: Frame = { f: "return", place: closure.place.concat(closure.body.path) };
   pushed(c, frame);
   const start = enter(c, { at: NO_KEYS }, closure.site, closure.body, scopeOf(closure, args));
@@ -576,6 +594,11 @@ function hostClosure(p: Program, value: object, closure: Closure): unknown {
   const fn = (...args: readonly unknown[]): unknown => {
     const limit = Math.ceil(p.maxDepth / 4);
     if (p.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+    // WORK.AFTER: after the end of the evaluation, each application from the host starts a new count.
+    p.work = (p.ended && p.applying === 0 ? 0 : p.work) + 1;
+    if (p.work > p.maxWork) throw new Failure(workFailure(p.maxWork));
+    // Host code in the nested stepper writes the count of the applications, thus the call puts back the count of its start.
+    const before = p.applying;
     p.applying += 1;
     try {
       const place = closure.place.concat(closure.body.path);
@@ -584,7 +607,7 @@ function hostClosure(p: Program, value: object, closure: Closure): unknown {
       if (!end.result.ok) throw new Failure(end.result.error);
       return forHost(p, end, end.result.value);
     } finally {
-      p.applying -= 1;
+      p.applying = before;
     }
   };
   Object.defineProperty(fn, CLOSURE, { value: { params: closure.params } });
@@ -856,7 +879,7 @@ function cause(p: Program, ctx: Context, kind: Cap, payload: unknown, place: rea
   const count = counts.get(at) ?? 0;
   counts.set(at, count + 1);
   const effect: { -readonly [K in keyof Effect]: Effect[K] } = {
-    index: effects.length,
+    index: p.before + effects.length,
     kind: text,
     path: keys,
     payload,
@@ -948,7 +971,9 @@ function evaluateDoc(p: Program, c: Evaluating): Configuration {
       return back(c, thrown(error, `the evaluator ${name}`));
     }
   }
-  const defined = own(p.definitions.evaluators, name);
+  // A standard evaluator gets the definition of the reference, unless the options give another definition (REF.TREE).
+  const standard = code === own(STD_EVALUATORS, name) ? own(STD_DEFINITIONS.evaluators, name) : undefined;
+  const defined = own(p.definitions.evaluators, name) ?? standard;
   if (defined !== undefined) return hostEvaluator(p, c, name, defined, doc, keys, read.data, read.slots, site);
   return back(c, fail("#NOEVAL", `The stepper has no definition of the compiled evaluator ${name}.`));
 }
@@ -1087,7 +1112,11 @@ function programOf(machine: Machine, options: StepperOptions): Program {
     effects: options.effects ?? [],
     perform: options.perform,
     counts: new Map(),
+    before: 0,
     applying: 0,
+    maxWork: machine.maxWork ?? WORK_LIMIT,
+    work: 0,
+    ended: false,
   };
 }
 
@@ -1124,7 +1153,20 @@ export function stepperNext(machine: Machine, configuration: Configuration, opti
     else if (f === "let") stack[stack.length - 1] = { ...top, names: { ...top.names } };
     else stack[stack.length - 1] = { ...top };
   }
-  return advance(programOf(machine, options), { ...configuration, stack });
+  const p = programOf(machine, options);
+  // Each call has a new program. Thus the configuration holds the state of the evaluation that a later step needs.
+  p.work = configuration.work ?? 0;
+  for (const [at, count] of Object.entries(configuration.counts ?? {})) p.counts.set(at, count);
+  // A list of effects from the host holds the earlier effects. Without it, the configuration holds their number.
+  p.before = options.effects === undefined ? (configuration.effected ?? 0) : 0;
+  const next = advance(p, { ...configuration, stack });
+  const effected = p.before + p.effects.length;
+  return {
+    ...next,
+    ...(p.work === 0 ? {} : { work: p.work }),
+    ...(p.counts.size === 0 ? {} : { counts: Object.fromEntries(p.counts) }),
+    ...(effected === 0 ? {} : { effected }),
+  };
 }
 
 /**
@@ -1143,6 +1185,7 @@ export function stepper(machine: Machine, doc: unknown, context: Context = makeC
   const p = programOf(machine, options);
   try {
     const end = drive(p, stepperStart(machine, doc, context, options));
+    p.ended = true;
     return end.result.ok ? ok(forHost(p, end, end.result.value)) : end.result;
   } catch (error) {
     return placed(thrown(error, "the stepper"), []);