@dallaylaen/ski-interpreter 2.2.1 → 2.3.0

package/lib/ski-interpreter.cjs.js

@@ -101,12 +101,19 @@ var require_expr = __commonJS({
       max: 1e3,
       maxArgs: 32
     };
+    var ORDER = {
+      "leftmost-outermost": "LO",
+      "leftmost-innermost": "LI",
+      LO: "LO",
+      LI: "LI"
+    };
     var control = {
       descend: prepareWrapper("descend"),
       prune: prepareWrapper("prune"),
       redo: prepareWrapper("redo"),
       stop: prepareWrapper("stop")
     };
+    var native = {};
     var Expr = class _Expr {
       /**
        *  @descr A combinatory logic expression.
@@ -121,10 +128,43 @@ var require_expr = __commonJS({
        *    src?: string,
        *    parser: object,
        *  }} [context]
+       * @property {number} [arity] - number of arguments the term is waiting for (if known)
+       * @property {string} [note] - a brief description what the term does
+       * @property {string} [fancyName] - how to display in html mode, e.g. φ instead of 'f'
+       *                Typically only applicable to descendants of Named.
+       * @property {TermInfo} [props] - properties inferred from the term's behavior
        */
-      constructor() {
-        if (new.target === _Expr)
-          throw new Error("Attempt to instantiate abstract class Expr");
+      /**
+       *
+       * @desc Define properties of the term based on user supplied options and/or inference results.
+       *       Typically useful for declaring Native and Alias terms.
+       * @private
+       * @param {Object} options
+       * @param {string} [options.note] - a brief description what the term does
+       * @param {number} [options.arity] - number of arguments the term is waiting for (if known)
+       * @param {string} [options.fancy] - how to display in html mode, e.g. φ instead of 'f'
+       * @param {boolean} [options.canonize] - whether to try to infer the properties
+       * @param {number} [options.max] - maximum number of steps for inference, if canonize is true
+       * @param {number} [options.maxArgs] - maximum number of arguments for inference, if canonize is true
+       * @return {this}
+       */
+      _setup(options = {}) {
+        if (options.fancy !== void 0)
+          this.fancyName = options.fancyName;
+        if (options.note !== void 0)
+          this.note = options.note;
+        if (options.arity !== void 0)
+          this.arity = options.arity;
+        if (options.canonize) {
+          const guess = this.infer(options);
+          if (guess.normal) {
+            this.arity = this.arity ?? guess.arity;
+            this.note = this.note ?? guess.expr.format({ html: true, lambda: ["", " ↦ ", ""] });
+            delete guess.steps;
+            this.props = guess;
+          }
+        }
+        return this;
       }
       /**
        * @desc apply self to zero or more terms and return the resulting term,
@@ -158,18 +198,67 @@ var require_expr = __commonJS({
       /**
        * @desc Traverse the expression tree, applying change() to each node.
        *       If change() returns an Expr, the node is replaced with that value.
-       *       Otherwise, the node is descended further (if applicable)
-       *       or left unchanged.
+       *       A null/undefined value is interpreted as
+       *       "descend further if applicable, or leave the node unchanged".
+       *
+       *       Returned values may be decorated:
+       *
+       *       SKI.control.prune will suppress further descending even if nothing was returned
+       *       SKI.control.stop will terminate further changes.
+       *       SKI.control.redo will apply the callback to the returned subtree, recursively.
        *
-       *       The traversal order is leftmost-outermost (LO), i.e. the same order as reduction steps are taken.
+       *       Note that if redo was applied at least once to a subtree, a null return from the same subtree
+       *       will be replaced by the last non-null value returned.
+       *
+       *       The traversal order is leftmost-outermost, unless options.order = 'leftmost-innermost' is specified.
+       *       Short aliases 'LO' and 'LI' (case-sensitive) are also accepted.
        *
        *       Returns null if no changes were made, or the new expression otherwise.
        *
-       * @param {(e:Expr) => (Expr|null)} change
+       * @param {{
+       *   order?: 'LO' | 'LI' | 'leftmost-outermost' | 'leftmost-innermost',
+       * }} [options]
+       * @param {(e:Expr) => TraverseValue<Expr>} change
        * @returns {Expr|null}
        */
-      traverse(change) {
-        return change(this);
+      traverse(options, change) {
+        if (typeof options === "function") {
+          change = options;
+          options = {};
+        }
+        const order = ORDER[options.order ?? "LO"];
+        if (order === void 0)
+          throw new Error("Unknown traversal order: " + options.order);
+        const [expr, _] = unwrap(this._traverse_redo({ order }, change));
+        return expr;
+      }
+      /**
+       * @private
+       * @param {Object} options
+       * @param {(e:Expr) => TraverseValue<Expr>} change
+       * @returns {TraverseValue<Expr>}
+       */
+      _traverse_redo(options, change) {
+        let action;
+        let expr = this;
+        let prev;
+        do {
+          prev = expr;
+          const next = options.order === "LI" ? expr._traverse_descend(options, change) ?? change(expr) : change(expr) ?? expr._traverse_descend(options, change);
+          [expr, action] = unwrap(next);
+        } while (expr && action === control.redo);
+        if (!expr && prev !== this)
+          expr = prev;
+        return action ? action(expr) : expr;
+      }
+      /**
+       * @private
+       * @param {Object} options
+       * @param {(e:Expr) => TraverseValue<Expr>} change
+       * @returns {TraverseValue<Expr>}
+       */
+      _traverse_descend(options, change) {
+        return null;
       }
       /**
        * @desc Returns true if predicate() is true for any subterm of the expression, false otherwise.
@@ -233,60 +322,61 @@ var require_expr = __commonJS({
        *       Use toLambda() if you want to get a lambda term in any case.
        *
        * @param {{max?: number, maxArgs?: number}} options
-       * @return {{
-       *    normal: boolean,
-       *    steps: number,
-       *    expr?: Expr,
-       *    arity?: number,
-       *    proper?: boolean,
-       *    discard?: boolean,
-       *    duplicate?: boolean,
-       *    skip?: Set<number>,
-       *    dup?: Set<number>,
-       * }}
+       * @return {TermInfo}
        */
       infer(options = {}) {
-        const max = options.max ?? DEFAULTS.max;
-        const maxArgs = options.maxArgs ?? DEFAULTS.maxArgs;
-        const out = this._infer({ max, maxArgs, index: 0 });
-        return out;
+        return this._infer({
+          max: options.max ?? DEFAULTS.max,
+          maxArgs: options.maxArgs ?? DEFAULTS.maxArgs
+        }, 0);
       }
       /**
-       *
-       * @param {{max: number, maxArgs: number, index: number}} options
-       * @param {FreeVar[]} preArgs
-       * @param {number} steps
-       * @returns {{
-       *    normal: boolean,
-       *    steps: number,
-       *    expr?: Expr,
-       *    arity?: number,
-       *    skip?: Set<number>,
-       *    dup?: Set<number>,
-       *    duplicate, discard, proper: boolean
-       * }
+       * @desc Internal method for infer(), which performs the actual inference.
+       * @param {{max: number, maxArgs: number}} options
+       * @param {number} nargs - var index to avoid name clashes
+       * @returns {TermInfo}
        * @private
        */
-      _infer(options, preArgs = [], steps = 0) {
-        if (preArgs.length > options.maxArgs || steps > options.max)
-          return { normal: false, steps };
-        if (this.freeOnly()) {
-          return {
-            normal: true,
-            steps,
-            ...maybeLambda(preArgs, this)
-          };
+      _infer(options, nargs) {
+        const probe = [];
+        let steps = 0;
+        let expr = this;
+        main: for (let i = 0; i < options.maxArgs; i++) {
+          const next = expr.run({ max: options.max - steps });
+          steps += next.steps;
+          if (!next.final)
+            break;
+          if (firstVar(next.expr)) {
+            expr = next.expr;
+            if (!expr.any((e) => !(e instanceof FreeVar || e instanceof App)))
+              return maybeLambda(probe, expr, { steps });
+            const list = expr.unroll();
+            let discard = false;
+            let duplicate = false;
+            const acc = [];
+            for (let j = 1; j < list.length; j++) {
+              const sub = list[j]._infer(
+                { maxArgs: options.maxArgs - nargs, max: options.max - steps },
+                // limit recursion
+                nargs + i
+                // avoid variable name clashes
+              );
+              steps += sub.steps;
+              if (!sub.expr)
+                break main;
+              if (sub.discard)
+                discard = true;
+              if (sub.duplicate)
+                duplicate = true;
+              acc.push(sub.expr);
+            }
+            return maybeLambda(probe, list[0].apply(...acc), { discard, duplicate, steps });
+          }
+          const push = nthvar(nargs + i);
+          probe.push(push);
+          expr = next.expr.apply(push);
         }
-        const next = this.run({ max: (options.max - steps) / 3 });
-        steps += next.steps;
-        if (!next.final)
-          return { normal: false, steps };
-        if (next.steps !== 0)
-          return next.expr._infer(options, preArgs, steps);
-        if (this.unroll()[0] instanceof FreeVar)
-          return { normal: false, steps };
-        const push = nthvar(preArgs.length + options.index);
-        return this.apply(push)._infer(options, [...preArgs, push], steps);
+        return { normal: false, proper: false, steps };
       }
       /**
        * @desc Expand an expression into a list of terms
@@ -324,7 +414,7 @@ var require_expr = __commonJS({
        * @return {IterableIterator<{expr: Expr, steps?: number, comment?: string}>}
        */
       *toLambda(options = {}) {
-        const expr = this.traverse((e) => {
+        let expr = this.traverse((e) => {
           if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)
             return null;
           const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });
@@ -332,7 +422,25 @@ var require_expr = __commonJS({
             throw new Error("Failed to infer an equivalent  lambda term for " + e);
           return guess.expr;
         }) ?? this;
-        yield* simplifyLambda(expr, options);
+        const seen = /* @__PURE__ */ new Set();
+        let steps = 0;
+        while (expr) {
+          const next = expr.traverse({ order: "LI" }, (e) => {
+            if (seen.has(e))
+              return null;
+            if (e instanceof App && e.fun instanceof Lambda) {
+              const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });
+              steps += guess.steps;
+              if (!guess.normal) {
+                seen.add(e);
+                return null;
+              }
+              return control.stop(guess.expr);
+            }
+          });
+          yield { expr, steps };
+          expr = next;
+        }
       }
       /**
        * @desc Rewrite the expression into S, K, and I combinators step by step.
@@ -345,28 +453,31 @@ var require_expr = __commonJS({
        * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}
        */
       *toSKI(options = {}) {
+        let expr = this.traverse((e) => {
+          if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)
+            return null;
+          return e.infer().expr;
+        }) ?? this;
         let steps = 0;
-        let expr = this;
-        while (true) {
-          const opt = { max: options.max ?? 1, steps: 0 };
-          const next = expr._rski(opt);
-          const final = opt.steps === 0;
-          yield { expr, steps, final };
-          if (final)
-            break;
+        while (expr) {
+          const next = expr.traverse({ order: "LI" }, (e) => {
+            if (!(e instanceof Lambda) || e.impl instanceof Lambda)
+              return null;
+            if (e.impl === e.arg)
+              return control.stop(native.I);
+            if (!e.impl.any((t) => t === e.arg))
+              return control.stop(native.K.apply(e.impl));
+            if (!(e.impl instanceof App))
+              throw new Error("toSKI: assert failed: lambda body is of unexpected type " + e.impl.constructor.name);
+            if (e.impl.arg === e.arg && !e.impl.fun.any((t) => t === e.arg))
+              return control.stop(e.impl.fun);
+            return control.stop(native.S.apply(new Lambda(e.arg, e.impl.fun), new Lambda(e.arg, e.impl.arg)));
+          });
+          yield { expr, steps, final: !next };
+          steps++;
           expr = next;
-          steps += opt.steps;
         }
       }
-      /**
-       * @desc Internal method for toSKI, which performs one step of the conversion.
-       * @param {{max: number, steps: number}} options
-       * @returns {Expr}
-       * @private
-       */
-      _rski(options) {
-        return this;
-      }
       /**
        * Replace all instances of plug in the expression with value and return the resulting expression,
        * or null if no changes could be made.
@@ -506,19 +617,24 @@ var require_expr = __commonJS({
       }
       /**
        * @desc Assert expression equality. Can be used in tests.
-       * @param {Expr} expected
+       *
+       * `this` is the expected value and the argument is the actual one.
+       * Mnemonic: the expected value is always a combinator, the actual one may be anything.
+       *
+       * @param {Expr} actual
        * @param {string} comment
        */
-      expect(expected, comment = "") {
+      expect(actual, comment = "") {
         comment = comment ? comment + ": " : "";
-        if (!(expected instanceof _Expr))
-          throw new Error(comment + "attempt to expect a combinator to equal something else: " + expected);
-        const diff = this.diff(expected);
+        if (!(actual instanceof _Expr)) {
+          throw new Error(comment + "Expected a combinator but found " + (actual?.constructor?.name ?? typeof actual));
+        }
+        const diff = this.diff(actual);
         if (!diff)
           return;
         const poorMans = new Error(comment + diff);
-        poorMans.expected = expected + "";
-        poorMans.actual = this + "";
+        poorMans.expected = this.diag();
+        poorMans.actual = actual.diag();
         throw poorMans;
       }
       /**
@@ -646,7 +762,7 @@ var require_expr = __commonJS({
           if (e instanceof Lambda)
             return [`${indent}Lambda (${e.arg}[${e.arg.id}]):`, ...rec(e.impl, indent + "  ")];
           if (e instanceof Alias)
-            return [`Alias (${e.name}):`, ...rec(e.impl, indent + "  ")];
+            return [`${indent}Alias (${e.name}): \\`, ...rec(e.impl, indent)];
           if (e instanceof FreeVar)
             return [`${indent}FreeVar: ${e.name}[${e.id}]`];
           return [`${indent}${e.constructor.name}: ${e}`];
@@ -673,57 +789,20 @@ var require_expr = __commonJS({
         super();
         this.arg = arg;
         this.fun = fun;
-        this.final = false;
-        this.arity = this.fun.arity > 0 ? this.fun.arity - 1 : 0;
       }
+      /** @property {boolean} [final] */
       weight() {
         return this.fun.weight() + this.arg.weight();
       }
-      _infer(options, preArgs = [], steps = 0) {
-        if (preArgs.length > options.maxArgs || steps > options.max)
-          return { normal: false, steps };
-        const proxy = super._infer(options, preArgs, steps);
-        if (proxy.normal)
-          return proxy;
-        steps = proxy.steps;
-        const [first, ...list] = this.unroll();
-        if (!(first instanceof FreeVar))
-          return { normal: false, steps };
-        let discard = false;
-        let duplicate = false;
-        const out = [];
-        for (const term of list) {
-          const guess = term._infer({
-            ...options,
-            maxArgs: options.maxArgs - preArgs.length,
-            max: options.max - steps,
-            index: preArgs.length + options.index
-          });
-          steps += guess.steps;
-          if (!guess.normal)
-            return { normal: false, steps };
-          out.push(guess.expr);
-          discard = discard || guess.discard;
-          duplicate = duplicate || guess.duplicate;
-        }
-        return {
-          normal: true,
-          steps,
-          ...maybeLambda(preArgs, first.apply(...out), {
-            discard,
-            duplicate
-          })
-        };
-      }
-      traverse(change) {
-        const replaced = change(this);
-        if (replaced instanceof Expr)
-          return replaced;
-        const fun = this.fun.traverse(change);
-        const arg = this.arg.traverse(change);
-        if (!fun && !arg)
-          return null;
-        return (fun ?? this.fun).apply(arg ?? this.arg);
+      _traverse_descend(options, change) {
+        const [fun, fAction] = unwrap(this.fun._traverse_redo(options, change));
+        if (fAction === control.stop)
+          return control.stop(fun ? fun.apply(this.arg) : null);
+        const [arg, aAction] = unwrap(this.arg._traverse_redo(options, change));
+        const final = fun || arg ? (fun ?? this.fun).apply(arg ?? this.arg) : null;
+        if (aAction === control.stop)
+          return control.stop(final);
+        return final;
       }
       any(predicate) {
         return predicate(this) || this.fun.any(predicate) || this.arg.any(predicate);
@@ -782,11 +861,6 @@ var require_expr = __commonJS({
       unroll() {
         return [...this.fun.unroll(), this.arg];
       }
-      _rski(options) {
-        if (options.steps >= options.max)
-          return this;
-        return this.fun._rski(options).apply(this.arg._rski(options));
-      }
       diff(other, swap = false) {
         if (!(other instanceof _App))
           return super.diff(other, swap);
@@ -848,6 +922,8 @@ var require_expr = __commonJS({
        * If a scope object is given, however, two variables with the same name and scope
        * are considered identical.
        *
+       * By convention, FreeVar.global is a constant denoting a global unbound variable.
+       *
        * @param {string} name - name of the variable
        * @param {any} scope - an object representing where the variable belongs to.
        */
@@ -878,6 +954,7 @@ var require_expr = __commonJS({
         return options.var[0] + name + options.var[1];
       }
     };
+    FreeVar.global = ["global"];
     var Native = class extends Named {
       /**
        * @desc A named term with a known rewriting rule.
@@ -893,29 +970,14 @@ var require_expr = __commonJS({
        *
        * @param {String} name
        * @param {Partial} impl
-       * @param {{note?: string, arity?: number, canonize?: boolean, apply?: function(Expr):(Expr|null) }} [opt]
+       * @param {{note?: string, arity?: number, canonize?: boolean }} [opt]
        */
       constructor(name, impl, opt = {}) {
         super(name);
         this.invoke = impl;
-        const guess = opt.canonize ?? true ? this.infer() : { normal: false };
-        this.arity = opt.arity || guess.arity || 1;
-        this.note = opt.note ?? guess.expr?.format({ terse: true, html: true, lambda: ["", " &mapsto; ", ""] });
-      }
-      _rski(options) {
-        if (this === native.I || this === native.K || this === native.S || options.steps >= options.max)
-          return this;
-        const canon = this.infer().expr;
-        if (!canon)
-          return this;
-        options.steps++;
-        return canon._rski(options);
+        this._setup({ canonize: true, ...opt });
       }
     };
-    var native = {};
-    function addNative(name, impl, opt) {
-      native[name] = new Native(name, impl, opt);
-    }
     var Lambda = class _Lambda extends Expr {
       /**
        * @desc Lambda abstraction of arg over impl.
@@ -956,23 +1018,13 @@ var require_expr = __commonJS({
       weight() {
         return this.impl.weight() + 1;
       }
-      _infer(options, preArgs = [], steps = 0) {
-        if (preArgs.length > options.maxArgs)
-          return { normal: false, steps };
-        const push = nthvar(preArgs.length + options.index);
-        return this.invoke(push)._infer(options, [...preArgs, push], steps + 1);
-      }
       invoke(arg) {
         return this.impl.subst(this.arg, arg) ?? this.impl;
       }
-      traverse(change) {
-        const replaced = change(this);
-        if (replaced instanceof Expr)
-          return replaced;
-        const impl = this.impl.traverse(change);
-        if (!impl)
-          return null;
-        return new _Lambda(this.arg, impl);
+      _traverse_descend(options, change) {
+        const [impl, iAction] = unwrap(this.impl._traverse_redo(options, change));
+        const final = impl ? new _Lambda(this.arg, impl) : null;
+        return iAction === control.stop ? control.stop(final) : final;
       }
       any(predicate) {
         return predicate(this) || this.impl.any(predicate);
@@ -994,26 +1046,6 @@ var require_expr = __commonJS({
         const change = this.impl.subst(search, replace);
         return change ? new _Lambda(this.arg, change) : null;
       }
-      _rski(options) {
-        const impl = this.impl._rski(options);
-        if (options.steps >= options.max)
-          return new _Lambda(this.arg, impl);
-        options.steps++;
-        if (impl === this.arg)
-          return native.I;
-        if (!impl.any((e) => e === this.arg))
-          return native.K.apply(impl);
-        if (impl instanceof App) {
-          const { fun, arg } = impl;
-          if (arg === this.arg && !fun.any((e) => e === this.arg))
-            return fun._rski(options);
-          return native.S.apply(
-            new _Lambda(this.arg, fun)._rski(options),
-            new _Lambda(this.arg, arg)._rski(options)
-          );
-        }
-        throw new Error("Don't know how to convert to SKI" + this);
-      }
       diff(other, swap = false) {
         if (!(other instanceof _Lambda))
           return super.diff(other, swap);
@@ -1030,25 +1062,24 @@ var require_expr = __commonJS({
         return true;
       }
     };
-    var Church = class _Church extends Native {
+    var Church = class _Church extends Expr {
       /**
        * @desc Church numeral representing non-negative integer n:
        *      n f x = f(f(...(f x)...)) with f applied n times.
        * @param {number} n
        */
       constructor(n) {
-        const p = Number.parseInt(n);
-        if (!(p >= 0))
+        n = Number.parseInt(n);
+        if (!(n >= 0))
           throw new Error("Church number must be a non-negative integer");
-        const name = "" + p;
-        const impl = (x) => (y) => {
+        super();
+        this.invoke = (x) => (y) => {
           let expr = y;
-          for (let i = p; i-- > 0; )
+          for (let i = n; i-- > 0; )
             expr = x.apply(expr);
           return expr;
         };
-        super(name, impl, { arity: 2, canonize: false, note: name });
-        this.n = p;
+        this.n = n;
         this.arity = 2;
       }
       diff(other, swap = false) {
@@ -1061,6 +1092,9 @@ var require_expr = __commonJS({
       _unspaced(arg) {
         return false;
       }
+      _format(options, nargs) {
+        return nargs >= 2 ? options.redex[0] + this.n + options.redex[1] : this.n + "";
+      }
     };
     function waitn(expr, n) {
       return (arg) => n <= 1 ? expr.apply(arg) : waitn(expr.apply(arg), n - 1);
@@ -1087,14 +1121,9 @@ var require_expr = __commonJS({
         if (!(impl instanceof Expr))
           throw new Error("Attempt to create an alias for a non-expression: " + impl);
         this.impl = impl;
-        if (options.note)
-          this.note = options.note;
-        const guess = options.canonize ? impl.infer({ max: options.max, maxArgs: options.maxArgs }) : { normal: false };
-        this.arity = guess.proper && guess.arity || 0;
-        this.proper = guess.proper ?? false;
-        this.terminal = options.terminal ?? this.proper;
-        this.canonical = guess.expr;
-        this.invoke = waitn(impl, this.arity);
+        this._setup(options);
+        this.terminal = options.terminal ?? this.props?.proper;
+        this.invoke = waitn(impl, this.arity ?? 0);
       }
       /**
        * @property {boolean} [outdated] - whether the alias is outdated
@@ -1108,8 +1137,8 @@ var require_expr = __commonJS({
       weight() {
         return this.terminal ? 1 : this.impl.weight();
       }
-      traverse(change) {
-        return change(this) ?? this.impl.traverse(change);
+      _traverse_descend(options, change) {
+        return this.impl._traverse_redo(options, change);
       }
       any(predicate) {
         return predicate(this) || this.impl.any(predicate);
@@ -1130,9 +1159,6 @@ var require_expr = __commonJS({
           return replace;
         return this.impl.subst(search, replace);
       }
-      _infer(options, preArgs = [], steps = 0) {
-        return this.impl._infer(options, preArgs, steps);
-      }
       // DO NOT REMOVE TYPE or tsc chokes with
       //       TS2527: The inferred type of 'Alias' references an inaccessible 'this' type.
       /**
@@ -1148,9 +1174,6 @@ var require_expr = __commonJS({
           return null;
         return other.diff(this.impl, !swap);
       }
-      _rski(options) {
-        return this.impl._rski(options);
-      }
       _braced(first) {
         return this.outdated ? this.impl._braced(first) : false;
       }
@@ -1159,6 +1182,9 @@ var require_expr = __commonJS({
         return outdated ? this.impl._format(options, nargs) : super._format(options, nargs);
       }
     };
+    function addNative(name, impl, opt) {
+      native[name] = new Native(name, impl, opt);
+    }
     addNative("I", (x) => x);
     addNative("K", (x) => (_) => x);
     addNative("S", (x) => (y) => (z) => x.apply(z, y.apply(z)));
@@ -1172,6 +1198,11 @@ var require_expr = __commonJS({
         note: "Increase a Church numeral argument by 1, otherwise n => f => x => f(n f x)"
       }
     );
+    function firstVar(expr) {
+      while (expr instanceof App)
+        expr = expr.fun;
+      return expr instanceof FreeVar;
+    }
     function maybeLambda(args, expr, caps = {}) {
       const count = new Array(args.length).fill(0);
       let proper = true;
@@ -1195,8 +1226,10 @@ var require_expr = __commonJS({
           dup.add(i);
       }
       return {
+        normal: true,
+        steps: caps.steps,
         expr: args.length ? new Lambda(args, expr) : expr,
-        ...caps.synth ? {} : { arity: args.length },
+        arity: args.length,
         ...skip.size ? { skip } : {},
         ...dup.size ? { dup } : {},
         duplicate: !!dup.size || caps.duplicate || false,
@@ -1207,43 +1240,6 @@ var require_expr = __commonJS({
     function nthvar(n) {
       return new FreeVar("abcdefgh"[n] ?? "x" + n);
     }
-    function* simplifyLambda(expr, options = {}, state = { steps: 0 }) {
-      yield { expr, steps: state.steps, comment: "(self)" };
-      if (expr.freeOnly())
-        return;
-      let maxWeight = expr.weight();
-      if (expr instanceof Lambda) {
-        for (const term of simplifyLambda(expr.impl, options, state)) {
-          const candidate = new Lambda(expr.arg, term.expr);
-          if (candidate.weight() < maxWeight) {
-            maxWeight = candidate.weight();
-            yield { expr: candidate, steps: state.steps, comment: "(lambda)" + term.comment };
-          }
-        }
-      }
-      if (expr instanceof App) {
-        let { fun, arg } = expr;
-        for (const term of simplifyLambda(fun, options, state)) {
-          const candidate = term.expr.apply(arg);
-          if (candidate.weight() < maxWeight) {
-            maxWeight = candidate.weight();
-            fun = term.expr;
-            yield { expr: candidate, steps: state.steps, comment: "(fun)" + term.comment };
-          }
-        }
-        for (const term of simplifyLambda(arg, options, state)) {
-          const candidate = fun.apply(term.expr);
-          if (candidate.weight() < maxWeight) {
-            maxWeight = candidate.weight();
-            yield { expr: candidate, steps: state.steps, comment: "(arg)" + term.comment };
-          }
-        }
-      }
-      const canon = expr.infer({ max: options.max, maxArgs: options.maxArgs });
-      state.steps += canon.steps;
-      if (canon.expr && canon.expr.weight() < maxWeight)
-        yield { expr: canon.expr, steps: state.steps, comment: "(canonical)" };
-    }
     function toposort(list, env) {
       if (list instanceof Expr)
         list = [list];
@@ -1347,7 +1343,7 @@ var require_parser = __commonJS({
       "->",
       "\\+"
     );
-    var SKI2 = class _SKI {
+    var SKI2 = class {
       /**
        *
        * @param {{
@@ -1393,18 +1389,18 @@ var require_parser = __commonJS({
        *
        * @param {Alias|String} term
        * @param {String|Expr|function(Expr):Partial} [impl]
-       * @param {String} [note]
+       * @param {object|string} [options]
+       * @param {string} [options.note] - optional annotation for the term, default is auto-generated if this.annotate is true
+       * @param {boolean} [options.canonize] - whether to canonize the term's implementation, default is this.annotate
+       * @param {boolean} [options.fancy] - alternative HTML-friendly name for the term
+       * @param {number} [options.arity] - custom arity for the term, default is inferred from the implementation
        * @return {SKI} chainable
        */
-      add(term, impl, note) {
+      add(term, impl, options) {
         term = this._named(term, impl);
-        if (this.annotate && note === void 0) {
-          const guess = term.infer();
-          if (guess.expr)
-            note = guess.expr.format({ terse: true, html: true, lambda: ["", " &mapsto; ", ""] });
-        }
-        if (note !== void 0)
-          term.note = note;
+        if (typeof options === "string")
+          options = { note: options, canonize: false };
+        term._setup({ canonize: this.annotate, ...options });
         if (this.known[term.name])
           this.known[term.name].outdated = true;
         this.known[term.name] = term;
@@ -1596,7 +1592,7 @@ var require_parser = __commonJS({
             expr.outdated = true;
           const def = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\s*=(.*)$/s);
           if (def && def[2] === "")
-            expr = new FreeVar(def[1], options.scope ?? _SKI);
+            expr = new FreeVar(def[1], options.scope ?? FreeVar.global);
           else
             expr = this.parseLine(item, jar, options);
           if (def) {
@@ -1641,7 +1637,7 @@ var require_parser = __commonJS({
         const tokens = combChars.split(source);
         const empty = new Empty();
         const stack = [empty];
-        const context = options.scope || _SKI;
+        const context = options.scope || FreeVar.global;
         for (const c of tokens) {
           if (c === "(")
             stack.push(empty);
@@ -1859,6 +1855,62 @@ var require_quest = __commonJS({
           return { pass: false, details: [], exception: e, steps: 0, input };
         }
       }
+      verify(options) {
+        const findings = this.verifyMeta(options);
+        if (options.solutions) {
+          const solCheck = this.verifySolutions(options.solutions);
+          if (solCheck)
+            findings.solutions = solCheck;
+        }
+        if (options.seen) {
+          if (!this.id)
+            findings.seen = "No id in quest " + (this.name ?? "(unnamed)");
+          if (options.seen.has(this.id))
+            findings.seen = "Duplicate quest id " + this.id;
+          options.seen.add(this.id);
+        }
+        return Object.keys(findings).length ? findings : null;
+      }
+      /**
+       * @desc Verify that solutions that are expected to pass/fail do so.
+       * @param {SelfCheck|{[key: string]: SelfCheck}} dataset
+       * @return {{shouldPass: {input: string[], result: QuestResult}[], shouldFail: {input: string[], result: QuestResult}[]} | null}
+       */
+      verifySolutions(dataset) {
+        if (typeof dataset === "object" && !Array.isArray(dataset?.accepted) && !Array.isArray(dataset?.rejected)) {
+          if (!this.id || !dataset[this.id])
+            return null;
+        }
+        const { accepted = [], rejected = [] } = dataset[this.id] ?? dataset;
+        const ret = { shouldPass: [], shouldFail: [] };
+        for (const input of accepted) {
+          const result = this.check(...input);
+          if (!result.pass)
+            ret.shouldPass.push({ input, result });
+        }
+        for (const input of rejected) {
+          const result = this.check(...input);
+          if (result.pass)
+            ret.shouldFail.push({ input, result });
+        }
+        return ret.shouldFail.length + ret.shouldPass.length ? ret : null;
+      }
+      verifyMeta(options = {}) {
+        const findings = {};
+        for (const field of ["name", "intro"]) {
+          const found = checkHtml(this[field]);
+          if (found)
+            findings[field] = found;
+        }
+        if (options.date) {
+          const date = new Date(this.meta.created_at);
+          if (isNaN(date))
+            findings.date = "invalid date format: " + this.meta.created_at;
+          else if (date < /* @__PURE__ */ new Date("2024-07-15") || date > /* @__PURE__ */ new Date())
+            findings.date = "date out of range: " + this.meta.created_at;
+        }
+        return findings;
+      }
       /**
          *
          * @return {TestCase[]}
@@ -2009,11 +2061,67 @@ var require_quest = __commonJS({
         return expr;
       }
     };
+    var Group = class {
+      constructor(options) {
+        this.name = options.name;
+        this.intro = list2str(options.intro);
+        this.id = options.id;
+        if (options.content)
+          this.content = options.content.map((c) => c instanceof Quest2 ? c : new Quest2(c));
+      }
+      verify(options) {
+        const findings = {};
+        const id = checkId(this.id, options.seen);
+        if (id)
+          findings[this.id] = id;
+        for (const field of ["name", "intro"]) {
+          const found = checkHtml(this[field]);
+          if (found)
+            findings[field] = found;
+        }
+        findings.content = this.content.map((q) => q.verify(options));
+        return findings;
+      }
+    };
     function list2str(str) {
       if (str === void 0 || typeof str === "string")
         return str;
       return Array.isArray(str) ? str.join(" ") : "" + str;
     }
+    function checkId(id, seen) {
+      if (id === void 0)
+        return "missing";
+      if (typeof id !== "string" && typeof id !== "number")
+        return "is a " + typeof id;
+      if (seen) {
+        if (seen.has(id))
+          return "duplicate id " + id;
+        seen.add(id);
+      }
+    }
+    function checkHtml(str) {
+      if (str === void 0)
+        return "missing";
+      if (typeof str !== "string")
+        return "not a string but " + typeof str;
+      const tagStack = [];
+      const tagRegex = /<\/?([a-z]+)(?:\s[^>]*)?>/gi;
+      let match;
+      while ((match = tagRegex.exec(str)) !== null) {
+        const [fullTag, tagName] = match;
+        if (fullTag.startsWith("</")) {
+          if (tagStack.length === 0 || tagStack.pop() !== tagName)
+            return `Unmatched closing tag: </${tagName}>`;
+        } else {
+          tagStack.push(tagName);
+        }
+      }
+      if (tagStack.length > 0)
+        return `Unclosed tags: ${tagStack.join(", ")}`;
+      return null;
+    }
+    Quest2.Group = Group;
+    Quest2.Case = Case;
     module2.exports = { Quest: Quest2 };
   }
 });
@@ -2023,6 +2131,7 @@ var require_extras = __commonJS({
   "src/extras.js"(exports2, module2) {
     "use strict";
     var { Expr, Alias, FreeVar } = require_expr();
+    var { Quest: Quest2 } = require_quest();
     function search(seed, options, predicate) {
       const {
         depth = 16,
@@ -2088,6 +2197,10 @@ var require_extras = __commonJS({
     function deepFormat(obj, options = {}) {
       if (obj instanceof Expr)
         return obj.format(options);
+      if (obj instanceof Quest2)
+        return "Quest(" + obj.name + ")";
+      if (obj instanceof Quest2.Case)
+        return "Quest.Case";
       if (Array.isArray(obj))
         return obj.map(deepFormat);
       if (typeof obj !== "object" || obj === null || obj.constructor !== Object)