@dallaylaen/ski-interpreter 1.1.0 → 1.3.0

package/lib/parser.js

@@ -3,7 +3,7 @@
  */
 
 const { Tokenizer, restrict } = require('./util');
-const { globalOptions, Expr, App, FreeVar, Lambda, Native, Alias, Church, native } = require('./expr');
+const { globalOptions, Expr, App, FreeVar, Lambda, Native, Alias, Church, native, declare } = require('./expr');
 
 class Empty extends Expr {
   apply (...args) {
@@ -55,11 +55,11 @@ class SKI {
   /**
    *
    * @param {{
-   *    allow: string?,
-   *    numbers: boolean?,
-   *    lambdas: boolean?,
-   *    terms: { [key: string]: Expr|string}?,
-   *    annotate: boolean?,
+   *    allow?: string,
+   *    numbers?: boolean,
+   *    lambdas?: boolean,
+   *    terms?: { [key: string]: Expr|string} | string[],
+   *    annotate?: boolean,
    * }} [options]
    */
   constructor (options = {}) {
@@ -70,10 +70,14 @@ class SKI {
     this.allow = new Set(Object.keys(this.known));
 
     // Import terms, if any. Omit native ones
-    for (const name in options.terms ?? {}) {
-      // Native terms already handled by allow
-      if (!options.terms[name].match(/^Native:/))
-        this.add(name, options.terms[name]);
+    if (Array.isArray(options.terms))
+      this.bulkAdd(options.terms);
+    else if (options.terms) {
+      for (const name in options.terms) {
+        // Native terms already handled by allow
+        if (!options.terms[name].match(/^Native:/))
+          this.add(name, options.terms[name]);
+      }
     }
 
     // Finally, impose restrictions
@@ -85,38 +89,60 @@ class SKI {
   }
 
   /**
+   * @desc Declare a new term
+   * If the first argument is an Alias, it is added as is.
+   * Otherwise, a new Alias or Native term (depending on impl type) is created.
+   * If note is not provided and this.annotate is true, an automatic note is generated.
+   *
+   * If impl is a function, it should have signature (Expr) => ... => Expr
+   * (see typedef Partial at top of expr.js)
+   *
+   * @example ski.add('T', 'S(K(SI))K', 'swap combinator')
+   * @example ski.add( ski.parse('T = S(K(SI))K') ) // ditto but one-arg form
+   * @example ski.add('T', x => y => y.apply(x), 'swap combinator') // heavy artillery
+   * @example ski.add('Y', function (f) { return f.apply(this.apply(f)); }, 'Y combinator')
    *
    * @param {Alias|String} term
-   * @param {Expr|String|[number, function(...Expr): Expr, {note: string?, fast: boolean?}]} [impl]
+   * @param {String|Expr|function(Expr):Partial} [impl]
    * @param {String} [note]
    * @return {SKI} chainable
    */
   add (term, impl, note ) {
-    if (typeof term === 'string') {
-      if (typeof impl === 'string')
-        term = new Alias(term, this.parse(impl), { canonize: true });
-      else if (impl instanceof Expr)
-        term = new Alias(term, impl, { canonize: true });
-      else
-        throw new Error('add: term must be an Alias or a string and impl must be an Expr or a string');
-    } else if (term instanceof Alias)
-      term = new Alias(term.name, term.impl, { canonize: true });
-
-    // This should normally be unreachable but let's keep just in case
-    if (!(term instanceof Alias))
-      throw new Error('add: term must be an Alias or a string (accompanied with an implementation)');
+    term = this._named(term, impl);
 
-    if (this.annotate && note === undefined && term.canonical)
-      note = term.canonical.toString({ terse: true, html: true });
+    if (this.annotate && note === undefined) {
+      const guess = term.guess();
+      if (guess.expr)
+        note = guess.expr.format({ terse: true, html: true, lambda: ['', ' ↦ ', ''] });
+    }
     if (note !== undefined)
       term.note = note;
 
-    this.known['' + term] = term;
-    this.allow.add('' + term);
+    if (this.known[term.name])
+      this.known[term.name].outdated = true;
+    this.known[term.name] = term;
+    this.allow.add(term.name);
 
     return this;
   }
 
+  _named (term, impl) {
+    if (term instanceof Alias)
+      return new Alias(term.name, term.impl, { canonize: true });
+    if (typeof term !== 'string')
+      throw new Error('add(): term must be an Alias or a string');
+    if (impl === undefined)
+      throw new Error('add(): impl must be provided when term is a string');
+    if (typeof impl === 'string')
+      return new Alias(term, this.parse(impl), { canonize: true });
+    if (impl instanceof Expr)
+      return new Alias(term, impl, { canonize: true });
+    if (typeof impl === 'function')
+      return new Native(term, impl);
+    // idk what this is
+    throw new Error('add(): impl must be an Expr, a string, or a function with a signature Expr => ... => Expr');
+  }
+
   maybeAdd (name, impl) {
     if (this.known[name])
       this.allow.add(name);
@@ -125,6 +151,28 @@ class SKI {
     return this;
   }
 
+  /**
+   * @desc Declare and remove multiple terms at once
+   *       term=impl adds term
+   *       term= removes term
+   * @param {string[]]} list
+   * @return {SKI} chainable
+   */
+  bulkAdd (list) {
+    for (const item of list) {
+      const m = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\s*=\s*(.*)$/s);
+      // TODO check all declarations before applying any (but we might need earlier terms for parsing later ones)
+      if (!m)
+        throw new Error('bulkAdd: invalid declaration: ' + item);
+      if (m[2] === '')
+        this.remove(m[1]);
+      else
+        this.add(m[1], this.parse(m[2]));
+    }
+
+    return this;
+  }
+
   /**
    * Restrict the interpreter to given terms. Terms prepended with '+' will be added
    * and terms preceeded with '-' will be removed.
@@ -183,6 +231,15 @@ class SKI {
     return out;
   }
 
+  /**
+   * Export term declarations for use in bulkAdd().
+   * @returns {string[]}
+   */
+  declare () {
+    // TODO accept argument to declare specific terms only
+    return declare(this.getTerms());
+  }
+
   /**
    *
    * @param {string} source
@@ -290,11 +347,12 @@ class SKI {
 
   toJSON () {
     return {
+      version:  '1.1.1', // set to incremented package.json version whenever SKI serialization changes
       allow:    this.showRestrict('+'),
       numbers:  this.hasNumbers,
       lambdas:  this.hasLambdas,
-      terms:    this.getTerms(),
       annotate: this.annotate,
+      terms:    this.declare(),
     }
   }
 }

package/lib/quest.js

@@ -225,16 +225,25 @@ class Quest {
 }
 
 class Case {
+  /**
+   * @param {FreeVar[]} input
+   * @param {{
+   *   max?: number,
+   *   note?: string,
+   *   vars?: {string: Expr},
+   *   engine: SKI
+   * }} options
+   */
   constructor (input, options) {
     this.max = options.max ?? 1000;
     this.note = options.note;
-    this.vars = { ...(options.vars ?? {}) }; // shallow copy to avoid modifying the original
+    this.vars = { ...(options.vars ?? {}) }; // note: context already contains input placeholders
     this.input = input;
     this.engine = options.engine;
   }
 
   parse (src) {
-    return new Lambda(this.input, this.engine.parse(src, this.vars));
+    return new Subst(this.engine.parse(src, this.vars), this.input);
   }
 
   /**
@@ -263,17 +272,15 @@ class ExprCase extends Case {
 
     super(input, options);
 
-    [this.e1, this.e2] = terms.map(src => this.parse(src));
+    [this.e1, this.e2] = terms.map( s => this.parse(s) );
   }
 
-  check (...expr) {
-    // we do it the fancy way and instead of just "apply" to avoid
-    // displaying (foo->foo this that)(user input) as 1st step
-    const subst = (outer, inner) => outer.reduce(inner) ?? outer.apply(...inner);
+  check (...args) {
+    const e1 = this.e1.apply(args);
+    const r1 = e1.run({ max: this.max });
+    const e2 = this.e2.apply(args);
+    const r2 = e2.run({ max: this.max });
 
-    const start = subst(this.e1, expr);
-    const r1 = start.run({ max: this.max });
-    const r2 = subst(this.e2, expr).run({ max: this.max });
     let reason = null;
     if (!r1.final || !r2.final)
       reason = 'failed to reach normal form in ' + this.max + ' steps';
@@ -285,11 +292,11 @@ class ExprCase extends Case {
       pass:     !reason,
       reason,
       steps:    r1.steps,
-      start,
+      start:    e1,
       found:    r1.expr,
       expected: r2.expr,
       note:     this.note,
-      args:     expr,
+      args,
       case:     this,
     };
   }
@@ -335,7 +342,7 @@ class PropertyCase extends Case {
   }
 
   check (...expr) {
-    const start = this.expr.apply(...expr);
+    const start = this.expr.apply(expr);
     const r = start.run({ max: this.max });
     const guess = r.expr.guess({ max: this.max });
 
@@ -358,6 +365,29 @@ class PropertyCase extends Case {
   }
 }
 
+class Subst {
+  /**
+   * @descr A placeholder object with exactly n free variables to be substituted later.
+   * @param {Expr} expr
+   * @param {FreeVar[]} vars
+   */
+  constructor (expr, vars) {
+    this.expr = expr;
+    this.vars = vars;
+  }
+
+  apply (list) {
+    if (list.length !== this.vars.length)
+      throw new Error('Subst: expected ' + this.vars.length + ' terms, got ' + list.length);
+
+    let expr = this.expr;
+    for (let i = 0; i < this.vars.length; i++)
+      expr = expr.subst(this.vars[i], list[i]) ?? expr;
+
+    return expr;
+  }
+}
+
 function list2str (str) {
   if (str === undefined)
     return str;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dallaylaen/ski-interpreter",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Simple Kombinator Interpreter - a combinatory logic & lambda calculus parser and interpreter. Supports SKI, BCKW, Church numerals, and setting up assertions ('quests') involving all of the above.",
   "keywords": [
     "combinatory logic",
@@ -19,7 +19,8 @@
     "types": "npx -p typescript tsc index.js --declaration --allowJs --emitDeclarationOnly --outDir types",
     "test": "npx nyc mocha",
     "minify": "npx esbuild --bundle ./index.js --outfile=docs/build/js/ski-interpreter.min.js --minify --sourcemap",
-    "build": "npm run lint && npm run types && npm run test && npm run minify"
+    "build-site": "npx esbuild --bundle ./site-src/index.js --outfile=docs/build/js/util.min.js --minify --sourcemap",
+    "build": "npm run lint && npm run types && npm run test && npm run minify && npm run build-site"
   },
   "files": [
     "package.json",