@mark1russell7/coeval 0.2.1 → 0.3.0

package/package.json

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

package/src/deref.ts

@@ -259,14 +259,21 @@ function mayBeRef(thing: unknown): boolean {
   return typeof thing === "object" && thing !== null && (thing as { readonly type?: unknown }).type === "ref";
 }
 
+/** This function tells if each step of a path from an index is a key. */
+function keysFrom(path: readonly unknown[], start: number): boolean {
+  for (let index = start; index < path.length; index += 1) if (!isKey(path[index])) return false;
+  return true;
+}
+
 /**
- * This function resolves the common path without a record of hops: a root, then keys, through plain values. It
- * gives `undefined` when the path needs the full algorithm. Examples are a host thing, an envelope, a reference to
- * follow, a step document and a failure (for its exact reason).
+ * This function resolves the common path without a record of hops: a root, then keys. Plain values answer the
+ * keys, or a host thing answers all of them in one call. It gives `undefined` when the path needs the full
+ * algorithm. Examples are a host thing without `resolve`, an envelope, a reference to follow, a step document and a
+ * failure of a step (for its exact reason).
  */
 function resolveQuick(nav: Navigator, ctx: Context, path: readonly unknown[]): Resolution | undefined {
   const root = path[0];
-  if (root !== "names" && root !== "self" && root !== "event") return undefined;
+  if (root !== "names" && root !== "self" && root !== "event" && root !== "world") return undefined;
   if (nav.roots !== undefined && !(nav.roots as readonly string[]).includes(root)) return undefined;
   if (nav.adopt !== undefined) return undefined;
   let here: unknown = ctx[root];
@@ -274,7 +281,15 @@ function resolveQuick(nav: Navigator, ctx: Context, path: readonly unknown[]): R
   for (let index = 1; index < path.length; index += 1) {
     if (typeof here !== "object" || here === null) return undefined;
     if (!plain && mayBeRef(here)) return undefined;
-    if ((here as Partial<HostThing>)[THING] === true) return undefined;
+    if ((here as Partial<HostThing>)[THING] === true) {
+      const thing = here as HostThing;
+      if (thing.resolve === undefined || !keysFrom(path, index)) return undefined;
+      const keys = path.slice(index) as readonly Key[];
+      const reached = thing.resolve(keys);
+      if (reached === undefined) return { ok: false, code: "#N/A", reason: `The path ${keys.join(".")} reaches nothing.`, hops: NO_HOPS };
+      if (!plain && mayBeRef(reached.thing)) return undefined;
+      return { ok: true, thing: reached.thing, hops: NO_HOPS };
+    }
     const step = path[index];
     if (Array.isArray(here)) {
       if (typeof step !== "number" || !Number.isInteger(step) || step < 0 || step >= here.length) return undefined;

package/src/evaluate.ts

@@ -445,9 +445,14 @@ export interface EvalOptions {
   readonly effects?: Effect[];
 }
 
+/** The options of a resolution without a record of hops, and with one. One object of each serves each call. */
+const WITHOUT_HOPS: ResolveOptions = Object.freeze({ hops: false });
+const WITH_HOPS: ResolveOptions = Object.freeze({ hops: true });
+
 /** This class holds the state of one evaluation or run: the machine, the effects, the clock and the trace. */
 class Session implements Runtime {
-  readonly effects: Effect[];
+  /** The list of the effects. It is made at the first effect, thus an evaluation without effects makes no list. */
+  private list: Effect[] | undefined;
   tick = 0;
   nextId = 0;
   current: Building | undefined;
@@ -461,13 +466,19 @@ class Session implements Runtime {
     readonly signal: StopSignal | undefined,
     effects: Effect[] | undefined,
   ) {
-    this.effects = effects ?? [];
+    this.list = effects;
     this.holder = traced ? holderNode() : undefined;
     this.current = this.holder;
   }
 
+  /** The effects of the evaluation, in their order. */
+  get effects(): Effect[] {
+    return (this.list ??= []);
+  }
+
   resolve(ctx: Context, path: readonly unknown[], options?: ResolveOptions): Resolution {
-    return resolve(this.machine, ctx, path, { hops: options?.hops ?? this.traced });
+    const hops = options?.hops ?? this.traced;
+    return resolve(this.machine, ctx, path, hops ? WITH_HOPS : WITHOUT_HOPS);
   }
 
   private permitted(ctx: Context, keys: readonly Key[]): boolean {
@@ -479,8 +490,9 @@ class Session implements Runtime {
     const text = keys.join(".");
     if (!this.permitted(ctx, keys)) return fail("#CAP!", `The context has no capability for the effect ${text}.`, { place });
     const node = this.current;
-    const effect: Effect = { index: this.effects.length, kind: text, path: keys, payload, node: node?.id ?? -1, at: this.tick, place, context: ctx };
-    this.effects.push(effect);
+    const list = this.effects;
+    const effect: Effect = { index: list.length, kind: text, path: keys, payload, node: node?.id ?? -1, at: this.tick, place, context: ctx };
+    list.push(effect);
     if (node !== undefined) node.effects.push(effect.index);
     return effect;
   }

package/src/formula.ts

@@ -24,7 +24,8 @@ export type ExtFn = (data: Json) => Result;
  * - `ext`: the extensions of the namespace `ext`, by their name. The kit has `ext.undefined` and `ext.number`.
  * - `truthy`: the truth of a value for `if`, `and` and `or`. `undefined` is an error `#VALUE!`. The default
  *   accepts only `true` and `false`.
- * - `otherwise`: the value of an `if` without `else`. The default is `null`.
+ * - `otherwise`: the value of an `if` without `else`. The default is `null`. A profile with this key gives its value,
+ *   also `undefined`.
  * - `logic`: what `and` and `or` give: a truth value (the default), or the value that decided.
  * - `omit`: the errors that leave a field out of a `record`, as an absent value.
  * - `missing`: the values that a reference cannot give. Such a value gives `#N/A`.
@@ -150,7 +151,7 @@ export function formulaKinds(): Readonly<Record<string, WorldEntry>> {
  */
 export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record<string, Evaluator>> {
   const truthy = profile.truthy ?? strictTruthy;
-  const otherwise = ok(profile.otherwise ?? null);
+  const otherwise = ok(Object.hasOwn(profile, "otherwise") ? profile.otherwise : null);
   const logicValue = profile.logic === "value";
   const omit = profile.omit;
   const missing = profile.missing;