@dallaylaen/ski-interpreter 1.0.0

package/lib/parser.js

@@ -0,0 +1,326 @@
+/**
+ * Combinatory logic simulator
+ */
+
+const { Tokenizer, restrict } = require('./util');
+const { globalOptions, Expr, App, FreeVar, Lambda, Native, Alias, Church, native } = require('./expr');
+
+class Empty extends Expr {
+  apply (...args) {
+    return args.length ? args.shift().apply(...args) : this;
+  }
+
+  postParse () {
+    throw new Error('Attempt to use empty expression () as a term');
+  }
+}
+
+class PartialLambda extends Empty {
+  // TODO mutable! rewrite ro when have time
+  constructor (term, known = {}) {
+    super();
+    this.impl = new Empty();
+    if (term instanceof FreeVar)
+      this.terms = [term];
+    else if (term instanceof PartialLambda) {
+      if (!(term.impl instanceof FreeVar))
+        throw new Error('Expected FreeVar->...->FreeVar->Expr');
+      this.terms = [...term.terms, term.impl];
+    } else
+      throw new Error('Expected FreeVar or PartialLambda');
+  }
+
+  apply (term, ...tail) {
+    if (term === null || tail.length !== 0 )
+      throw new Error('bad syntax in partial lambda expr');
+    this.impl = this.impl.apply(term);
+    return this;
+  }
+
+  postParse () {
+    return new Lambda(this.terms, this.impl);
+  }
+
+  // uncomment if debugging with prints
+  /* toString () {
+    return this.terms.join('->') + '->' + (this.impl ?? '???');
+  } */
+}
+
+const combChars = new Tokenizer(
+  '[()]', '[A-Z]', '[a-z_][a-z_0-9]*', '\\b[0-9]+\\b', '->', '\\+'
+);
+
+class SKI {
+  /**
+   *
+   * @param {{
+   *    allow: string?,
+   *    numbers: boolean?,
+   *    lambdas: boolean?,
+   *    terms: { [key: string]: Expr|string}?,
+   *    annotate: boolean?,
+   * }} [options]
+   */
+  constructor (options = {}) {
+    this.annotate = options.annotate ?? false;
+    this.known = { ...native };
+    this.hasNumbers = true;
+    this.hasLambdas = true;
+    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]);
+    }
+
+    // Finally, impose restrictions
+    // We must do it after recreating terms, or else terms reliant on forbidden terms will fail
+    this.hasNumbers = options.numbers ?? true;
+    this.hasLambdas = options.lambdas ?? true;
+    if (options.allow)
+      this.restrict(options.allow);
+  }
+
+  /**
+   *
+   * @param {Alias|String} term
+   * @param {Expr|String|[number, function(...Expr): Expr, {note: string?, fast: boolean?}]} [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)');
+
+    if (this.annotate && note === undefined && term.canonical)
+      note = term.canonical.toString({ terse: true, html: true });
+    if (note !== undefined)
+      term.note = note;
+
+    this.known['' + term] = term;
+    this.allow.add('' + term);
+
+    return this;
+  }
+
+  maybeAdd (name, impl) {
+    if (this.known[name])
+      this.allow.add(name);
+    else
+      this.add(name, impl);
+    return this;
+  }
+
+  /**
+   * Restrict the interpreter to given terms. Terms prepended with '+' will be added
+   * and terms preceeded with '-' will be removed.
+   * @example ski.restrict('SK') // use the basis
+   * @example ski.restrict('+I') // allow I now
+   * @example ski.restrict('-SKI +BCKW' ); // switch basis
+   * @example ski.restrict('-foo -bar'); // forbid some user functions
+   * @param {string} spec
+   * @return {SKI} chainable
+   */
+  restrict (spec) {
+    this.allow = restrict(this.allow, spec);
+    return this;
+  }
+
+  /**
+   *
+   * @param {string} spec
+   * @return {string}
+   */
+  showRestrict (spec = '+') {
+    const out = [];
+    let prevShort = true;
+    for (const term of [...restrict(this.allow, spec)].sort()) {
+      const nextShort = term.match(/^[A-Z]$/);
+      if (out.length && !(prevShort && nextShort))
+        out.push(' ');
+      out.push(term);
+      prevShort = nextShort;
+    }
+    return out.join('');
+  }
+
+  /**
+   *
+   * @param {String} name
+   * @return {SKI}
+   */
+  remove (name) {
+    this.known[name].outdated = true;
+    delete this.known[name];
+    this.allow.delete(name);
+    return this;
+  }
+
+  /**
+   *
+   * @return {{[key:string]: Native|Alias}}
+   */
+  getTerms () {
+    const out = {};
+    for (const name of Object.keys(this.known)) {
+      if (this.allow.has(name))
+        out[name] = this.known[name];
+    }
+    return out;
+  }
+
+  /**
+   *
+   * @param {string} source
+   * @param {{[keys: string]: Expr}} vars
+   * @param {{numbers: boolean?, lambdas: boolean?, allow: string?}} options
+   * @return {Expr}
+   */
+  parse (source, vars = {}, options = {}) {
+    const lines = source.replace(/\/\/[^\n]*$/gm, '')
+      .split(/\s*;[\s;]*/).filter( s => s.match(/\S/));
+
+    const jar = { ...vars };
+
+    let expr = new Empty();
+    for (const item of lines) {
+      const [_, save, str] = item.match(/^(?:\s*([A-Z]|[a-z][a-z_0-9]*)\s*=\s*)?(.*)$/s);
+      if (expr instanceof Alias)
+        expr.outdated = true;
+      expr = this.parseLine(str, jar, options);
+
+      if (save !== undefined) {
+        if (jar[save] !== undefined)
+          throw new Error('Attempt to redefine a known term: ' + save);
+        expr = new Alias(save, expr);
+        jar[save] = expr;
+      }
+
+      // console.log('parsed line:', item, '; got:', expr,'; jar now: ', jar);
+    }
+
+    // reimport free variables, so that co-parsing x(y(z)) and z(x(y)) with the same jar
+    //     results in _equal_ free vars and not just ones with the same name
+    for (const name in jar) {
+      if (!vars[name] && jar[name] instanceof SKI.classes.FreeVar)
+        vars[name] = jar[name];
+    }
+
+    return expr;
+  }
+
+  /**
+   *
+   * @param {String} source S(KI)I
+   * @param {{[keys: string]: Expr}} vars
+   * @param {{numbers: boolean?, lambdas: boolean?, allow: string?}} options
+   * @return {Expr} parsed expression
+   */
+  parseLine (source, vars = {}, options = {}) {
+    const opt = {
+      numbers: options.numbers ?? this.hasNumbers,
+      lambdas: options.lambdas ?? this.hasLambdas,
+      allow:   restrict(this.allow, options.allow),
+    };
+    // make sure '+' usage is in sync with numerals
+    opt.numbers ? opt.allow.add('+') : opt.allow.delete('+');
+
+    const tokens = combChars.split(source);
+
+    const empty = new Empty();
+    /** @type {Expr[]} */
+    const stack = [empty];
+
+    // TODO each token should carry along its position in source
+    for (const c of tokens) {
+      // console.log("parseLine: found "+c+"; stack =", stack.join(", "));
+      if (c === '(')
+        stack.push(empty);
+      else if (c === ')') {
+        if (stack.length < 2)
+          throw new Error('unbalanced input: extra closing parenthesis' + source);
+        const x = stack.pop().postParse();
+        const f = stack.pop();
+        stack.push(f.apply(x));
+      } else if (c === '->') {
+        if (!opt.lambdas)
+          throw new Error('Lambdas not supported, allow them explicitly');
+        stack.push(new PartialLambda(stack.pop(), vars));
+      } else if (c.match(/^[0-9]+$/)) {
+        if (!opt.numbers)
+          throw new Error('Church numbers not supported, allow them explicitly');
+        const f = stack.pop();
+        stack.push(f.apply(new Church(c)));
+      } else {
+        const f = stack.pop();
+        if (!vars[c] && this.known[c] && !opt.allow.has(c)) {
+          throw new Error('Term \'' + c + '\' is not in the restricted set '
+            + [...opt.allow].sort().join(' '));
+        }
+        // look in temp vars first, then in known terms, then fallback to creating free var
+        const x = vars[c] ?? this.known[c] ?? (vars[c] = new FreeVar(c));
+        stack.push(f.apply(x));
+      }
+    }
+
+    if (stack.length !== 1) {
+      throw new Error('unbalanced input: missing '
+          + (stack.length - 1) + ' closing parenthesis:' + source);
+    }
+
+    return stack.pop().postParse();
+  }
+
+  toJSON () {
+    return {
+      allow:    this.showRestrict('+'),
+      numbers:  this.hasNumbers,
+      lambdas:  this.hasLambdas,
+      terms:    this.getTerms(),
+      annotate: this.annotate,
+    }
+  }
+}
+
+// Create shortcuts for common terms
+/**
+ * Create free var(s) for subsequent use
+ * @param {String} names
+ * @return {FreeVar[]}
+ */
+SKI.free = (...names) => names.map(s => new FreeVar(s));
+
+/**
+ * Convert a number to Church encoding
+ * @param {number} n
+ * @return {Church}
+ */
+SKI.church = n => new Church(n);
+SKI.classes = { Expr, Native, Alias, FreeVar, Lambda, Church };
+
+/**
+ *
+ * @type {{[key: string]: Native}}
+ */
+
+for (const name in native)
+  SKI[name] = native[name];
+SKI.native = native;
+SKI.options = globalOptions;
+SKI.lambdaPlaceholder = Expr.lambdaPlaceholder;
+
+module.exports = { SKI };

package/lib/quest.js

@@ -0,0 +1,311 @@
+const { SKI } = require('./parser');
+const { Expr, FreeVar, Alias, Lambda } = SKI.classes;
+
+/**
+ * @typedef {{
+ *   pass: boolean,
+ *   reason: string?,
+ *   steps: number,
+ *   start: Expr,
+ *   found: Expr,
+ *   expected: Expr,
+ *   note: string?,
+ *   args: Expr[],
+ *   case: Case
+ * }} CaseResult
+ */
+
+class Quest {
+  /**
+   * @description A combinator problem with a set of test cases for the proposed solution.
+   * @param {{
+   *    title: string?,
+   *    descr: string?,
+   *    subst: string?,
+   *    allow: string?,
+   *    numbers: boolean?,
+   *    vars: string[]?,
+   *    engine: SKI?,
+   *    engineFull: SKI?,
+   *    cases: [{max: number?, note: string?, feedInput: boolean, lambdas: boolean?}|string[], ...string[][]]?
+   * }} options
+   */
+  constructor (options = {}) {
+    const { input, vars, cases, allow, numbers, lambdas, subst, engine, engineFull, ...meta } = options;
+
+    //
+    this.engine = engine ?? new SKI();
+    this.engineFull = engineFull ?? new SKI();
+    this.restrict = { allow, numbers: numbers ?? false, lambdas: lambdas ?? false };
+    this.vars = {};
+    this.subst = Array.isArray(subst) ? subst : [subst ?? 'phi'];
+
+    const jar = {};
+
+    // options.vars is a list of expressions.
+    // we suck all free variables + all term declarations from there into this.vars
+    // to feed it later to every case's parser.
+    for (const term of vars ?? []) {
+      const expr = this.engineFull.parse(term, jar);
+      if (expr instanceof SKI.classes.Alias)
+        this.vars[expr.name] = new Alias(expr.name, expr.impl, { terminal: true, canonize: false });
+        // Canonized aliases won't expand with insufficient arguments,
+        // causing correct solutions to fail, so alas...
+      else if (expr instanceof SKI.classes.FreeVar)
+        this.vars[expr.name] = expr;
+      else
+        throw new Error('Unsupported given variable type: ' + term);
+    }
+
+    this.input = [];
+    for (const term of Array.isArray(input) ? input : [input])
+      this.addInput(term);
+    if (!this.input.length)
+      throw new Error('Quest needs at least one input placeholder');
+    if (subst)
+      this.input[0].fancy = this.subst[0];
+
+    this.varsFull = { ...this.vars, ...jar };
+    for (const term of this.input) {
+      if (term.name in this.varsFull)
+        throw new Error('input placeholder name is duplicated or clashes with vars: ' + term.name);
+      this.varsFull[term.name] = term.placeholder;
+    }
+
+    this.cases = [];
+    this.title = meta.title;
+    meta.descr = list2str(meta.descr);
+    this.descr = meta.descr;
+    this.meta = meta;
+
+    for (const c of cases ?? [])
+      this.add(...c);
+  }
+
+  /**
+   *   Display allowed terms based on what engine thinks of this.vars + this.restrict.allow
+   *   @return {string}
+   */
+  allowed () {
+    const allow = this.restrict.allow ?? '';
+    const vars = Object.keys(this.vars).sort();
+    // In case vars are present and restrictions aren't, don't clutter the output with all the known terms
+    return allow
+      ? this.engine.showRestrict(allow + '+' + vars.join(' '))
+      : vars.map( s => '+' + s).join(' ');
+  }
+
+  addInput (term) {
+    if (typeof term !== 'object')
+      term = { name: term };
+    if (typeof term.name !== 'string')
+      throw new Error("quest 'input' field must be a string or a {name: string, ...} object");
+
+    [term.placeholder] = SKI.free(term.name);
+    // TODO more checks
+    this.input.push(term);
+  }
+
+  /**
+   *
+   * @param {{} | string} opt
+   * @param {string} terms
+   * @return {Quest}
+   */
+  add (opt, ...terms) {
+    if (typeof opt === 'string') {
+      terms.unshift(opt);
+      opt = {};
+    } else
+      opt = { ...opt };
+
+    opt.engine = opt.engine  ?? this.engineFull;
+    opt.vars = opt.vars ?? this.varsFull;
+
+    const input = this.input.map( t => t.placeholder );
+    this.cases.push(
+      opt.linear
+        ? new LinearCase(input, opt, terms)
+        : new ExprCase(input, opt, terms)
+    );
+    return this;
+  }
+
+  /**
+   * @description Statefully parse a list of strings into expressions or fancy aliases thereof.
+   * @param {string[]} input
+   * @return {{terms: Expr[], weight: number}}
+   */
+  prepare (...input) {
+    if (input.length !== this.input.length)
+      throw new Error('Solutions provided ' + input.length + ' terms where ' + this.input.length + ' are expected');
+
+    let weight = 0;
+    const prepared = [];
+    const jar = { ...this.vars };
+    for (let i = 0; i < input.length; i++) {
+      const spec = this.input[i];
+      const impl = this.engine.parse(input[i], jar, {
+        allow:   spec.allow ?? this.restrict.allow,
+        numbers: spec.numbers ?? this.restrict.numbers,
+        lambdas: spec.lambdas ?? this.restrict.lambdas,
+      });
+      weight += impl.weight();
+      const expr = impl instanceof FreeVar
+        ? impl
+        : new Alias(spec.fancy ?? spec.name, impl, { terminal: true, canonize: false });
+      jar[spec.name] = expr;
+      prepared.push(expr);
+    }
+    return {
+      prepared,
+      weight,
+    };
+  }
+
+  /**
+   *
+   * @param {string} input
+   * @return {{
+   *             expr: Expr?,
+   *             pass: boolean,
+   *             details: CaseResult[],
+   *             exception: Error?,
+   *             steps: number,
+   *             input: Expr[]|string[],
+   *             weight: number?
+   *         }}
+   */
+  check (...input) {
+    try {
+      const { prepared, weight } = this.prepare(...input);
+      const details = this.cases.map( c => c.check(...prepared) );
+      const pass = details.reduce((acc, val) => acc && val.pass, true);
+      const steps = details.reduce((acc, val) => acc + val.steps, 0);
+      return {
+        expr:  prepared[0],
+        input: prepared,
+        pass,
+        steps,
+        details,
+        weight,
+      };
+    } catch (e) {
+      return { pass: false, details: [], exception: e, steps: 0, input };
+    }
+  }
+
+  /**
+     *
+     * @return {TestCase[]}
+     */
+  show () {
+    return [...this.cases];
+  }
+}
+
+class Case {
+  constructor (input, options) {
+    this.max = options.max ?? 1000;
+    this.note = options.note;
+    this.vars = { ...(options.vars ?? {}) }; // shallow copy to avoid modifying the original
+    this.input = input;
+    this.engine = options.engine;
+  }
+
+  parse (src) {
+    return new Lambda(this.input, this.engine.parse(src, this.vars));
+  }
+
+  /**
+   * @param {Expr} expr
+   * @return {CaseResult}
+   */
+  check ( ...expr ) {
+    throw new Error('not implemented');
+  }
+}
+
+class ExprCase extends Case {
+  /**
+   * @param {FreeVar[]} input
+   * @param {{
+   *    max: number?,
+   *    note: string?,
+   *    vars: {string: Expr}?,
+   *    engine: SKI?
+   * }} options
+   * @param {[e1: string, e2: string]} terms
+   */
+  constructor (input, options, terms) {
+    if (terms.length !== 2)
+      throw new Error('Case accepts exactly 2 strings');
+
+    super(input, options);
+
+    [this.e1, this.e2] = terms.map(src => this.parse(src));
+  }
+
+  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);
+
+    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';
+    else if (!r1.expr.equals(r2.expr))
+      reason = 'expected: ' + r2.expr;
+    // NOTE maybe there should be expand() on both sides of equal() but we'll see.
+
+    return {
+      pass:     !reason,
+      reason,
+      steps:    r1.steps,
+      start,
+      found:    r1.expr,
+      expected: r2.expr,
+      note:     this.note,
+      args:     expr,
+      case:     this,
+    };
+  }
+}
+
+class LinearCase extends Case {
+  // test that an expression uses all of its inputs exactly once
+  constructor (input, options, terms) {
+    super(input, options);
+    this.expr = this.parse(terms[0]);
+  }
+
+  check (...expr) {
+    const start = this.expr.apply(...expr);
+    const r = start.run({ max: this.max });
+    const arity = r.expr.canonize();
+    const reason = arity.linear
+      ? null
+      : 'expected a linear expression, i.e. such that uses all inputs exactly once';
+    return {
+      pass:  !reason,
+      reason,
+      steps: r.steps,
+      start,
+      found: r.expr,
+      case:  this,
+      note:  this.note,
+      args:  expr,
+    }
+  }
+}
+
+function list2str (str) {
+  if (str === undefined)
+    return str;
+  return Array.isArray(str) ? str.join(' ') : '' + str;
+}
+
+module.exports = { Quest };

package/lib/util.js

@@ -0,0 +1,74 @@
+class Tokenizer {
+  constructor (...terms) {
+    const src = '$|(\\s+)|' + terms
+      .map(s => '(?:' + s + ')')
+      .sort((a, b) => b.length - a.length)
+      .join('|');
+    this.rex = new RegExp(src, 'gys');
+  }
+
+  /**
+     *
+     * @param {string} str
+     * @return {string[]}
+     */
+  split (str) {
+    this.rex.lastIndex = 0;
+    const list = [...str.matchAll(this.rex)];
+
+    // did we parse everything?
+    const eol = list.pop();
+    const last = eol?.index ?? 0;
+
+    if (last !== str.length) {
+      throw new Error('Unknown tokens at pos ' + last + '/' + str.length
+                + ' starting with ' + str.substring(last));
+    }
+
+    // skip whitespace
+    return list.filter(x => x[1] === undefined).map(x => x[0]);
+  }
+}
+
+const tokRestrict = new Tokenizer('[-=+]', '[A-Z]', '\\b[a-z_][a-z_0-9]*\\b');
+function restrict (set, spec) {
+  if (!spec)
+    return set;
+  let out = new Set([...set]);
+  let mode = 0;
+  const act = [
+    sym => { out = new Set([sym]); mode = 1; },
+    sym => { out.add(sym); },
+    sym => { out.delete(sym); },
+  ];
+  for (const sym of tokRestrict.split(spec)) {
+    if (sym === '=')
+      mode = 0;
+    else if (sym === '+')
+      mode = +1;
+    else if (sym === '-')
+      mode = 2;
+    else
+      act[mode](sym);
+  }
+  return out;
+}
+
+function missingIndices (arr, set) {
+  const out = new Set();
+  for (let n = 0; n < arr.length; n++) {
+    if (!set.has(arr[n]))
+      out.add(n);
+  }
+  return out;
+}
+
+function isSubset (a, b) {
+  for (const x of a) {
+    if (!b.has(x))
+      return false;
+  }
+  return true;
+}
+
+module.exports = { Tokenizer, restrict, missingIndices, isSubset };