@dallaylaen/ski-interpreter 2.1.0 → 2.2.0

package/lib/extras.js

@@ -1,140 +0,0 @@
-'use strict';
-
-const { Expr } = require('./expr')
-
-/**
- * @desc  Extra utilities that do not belong in the core.
- */
-
-/**
- * @experimental
- * @desc  Look for an expression that matches the predicate,
- *        starting with the seed and applying the terms to one another.
- *
- *        A predicate returning 0 (or nothing) means "keep looking",
- *        a positive number stands for "found",
- *        and a negative means "discard this term from further applications".
- *
- *        The order of search is from shortest to longest expressions.
- *
- * @param {Expr[]} seed
- * @param {object} options
- * @param {number} [options.depth] - maximum generation to search for
- * @param {number} [options.tries] - maximum number of tries before giving up
- * @param {boolean} [options.infer] - whether to call infer(), default true.
- * @param {number} [options.maxArgs] - arguments in infer()
- * @param {number} [options.max] - step limit in infer()
- * @param {boolean} [options.noskip] - prevents skipping equivalent terms. Always true if infer is false.
- * @param {boolean} [retain] - if true. also add the whole cache to returned value
- * @param {({gen: number, total: number, probed: number, step: boolean}) => void} [options.progress]
- * @param {number} [options.progressInterval] - minimum number of tries between calls to options.progress, default 1000.
- * @param {(e: Expr, props: {}) => number?} predicate
- * @return {{expr?: Expr, total: number, probed: number, gen: number, cache?: Expr[][]}}
- */
-function search (seed, options, predicate) {
-  const {
-    depth = 16,
-    infer = true,
-    progressInterval = 1000,
-  } = options;
-  const hasSeen = infer && !options.noskip;
-
-  // cache[i] = ith generation, 0 is empty
-  const cache = [[]];
-  let total = 0;
-  let probed = 0;
-  const seen = {};
-
-  const maybeProbe = term => {
-    total++;
-    const props = infer ? term.infer({ max: options.max, maxArgs: options.maxArgs }) : null;
-    if (hasSeen && props.expr) {
-      if (seen[props.expr])
-        return { res: -1 };
-      seen[props.expr] = true;
-    }
-    probed++;
-    const res = predicate(term, props);
-    return { res, props };
-  };
-
-  // sieve through the seed
-  for (const term of seed) {
-    const { res } = maybeProbe(term);
-    if (res > 0)
-      return { expr: term, total, probed, gen: 1 };
-    else if (res < 0)
-      continue;
-
-    cache[0].push(term);
-  }
-
-  let lastProgress;
-
-  for (let gen = 1; gen < depth; gen++) {
-    if (options.progress) {
-      options.progress({ gen, total, probed, step: true });
-      lastProgress = total;
-    }
-    for (let i = 0; i < gen; i++) {
-      for (const a of cache[gen - i - 1] || []) {
-        for (const b of cache[i] || []) {
-          if (total >= options.tries)
-            return { total, probed, gen, ...(options.retain ? { cache } : {}) };
-          if (options.progress && total - lastProgress >= progressInterval) {
-            options.progress({ gen, total, probed, step: false });
-            lastProgress = total;
-          }
-          const term = a.apply(b);
-          const { res, props } = maybeProbe(term);
-
-          if (res > 0)
-            return { expr: term, total, probed, gen, ...(options.retain ? { cache } : {}) };
-          else if (res < 0)
-            continue;
-
-          // if the term is not reducible, it is more likely to be a dead end, so we push it further away
-          const offset = infer
-            ? ((props.expr ? 0 : 3) + (props.dup ? 1 : 0) + (props.proper ? 0 : 1))
-            : 0;
-          if (!cache[gen + offset])
-            cache[gen + offset] = [];
-          cache[gen + offset].push(term);
-        }
-      }
-    }
-  }
-
-  return { total, probed, gen: depth, ...(options.retain ? { cache } : {}) };
-}
-
-/**
- * @desc Recursively replace all instances of Expr in a data structure with
- *       respective string representation using the format() options.
- *       Objects of other types and primitive values are eft as is.
- *
- *       May be useful for debugging or diagnostic output.
- *
- * @experimental
- *
- * @param {any} obj
- * @param {object} [options] - see Expr.format()
- * @returns {any}
- */
-function deepFormat (obj, options = {}) {
-  if (obj instanceof Expr)
-    return obj.format(options);
-  if (Array.isArray(obj))
-    return obj.map(deepFormat);
-  if (typeof obj !== 'object' || obj === null || obj.constructor !== Object)
-    return obj;
-
-  // default = plain object
-  const out = {};
-  for (const key in obj)
-    out[key] = deepFormat(obj[key]);
-
-  return out;
-}
-
-module.exports = { search, deepFormat };

package/lib/internal.js

@@ -1,105 +0,0 @@
-class Tokenizer {
-  /**
-   * @desc Create a tokenizer that splits strings into tokens according to the given terms.
-   * The terms are interpreted as regular expressions, and are sorted by length
-   * to ensure that longer matches are preferred over shorter ones.
-   * @param {...string|RegExp} terms
-   */
-  constructor (...terms) {
-    const src = '$|(\\s+)|' + terms
-      .map(s => '(?:' + s + ')')
-      .sort((a, b) => b.length - a.length)
-      .join('|');
-    this.rex = new RegExp(src, 'gys');
-  }
-
-  /**
-   * @desc Split the given string into tokens according to the terms specified in the constructor.
-   * @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');
-
-/**
- * @desc Add ot remove tokens from a set according to a spec string.
- * The spec string is a sequence of tokens, with each group optionally prefixed
- * by one of the operators '=', '+', or '-'.
- * The '=' operator resets the set to contain only the following token(s).
- * @param {Set<string>} set
- * @param {string} [spec]
- * @returns {Set<string>}
- */
-function restrict (set, spec) {
-  if (!spec)
-    return set;
-  let out = new Set([...set]);
-  const act = {
-    '=': sym => { out = new Set([sym]); mode = '+'; },
-    '+': sym => { out.add(sym); },
-    '-': sym => { out.delete(sym); },
-  };
-
-  let mode = '=';
-  for (const sym of tokRestrict.split(spec)) {
-    if (act[sym])
-      mode = sym;
-    else
-      act[mode](sym);
-  }
-  return out;
-}
-
-class ActionWrapper {
-  /**
-   * @template T
-   * @param {T} value
-   * @param {string} action
-   */
-  constructor (value, action) {
-    this.value = value;
-    this.action = action;
-  }
-}
-
-/**
- * @private
- * @template T
- * @param {T|ActionWrapper<T>} value
- * @returns {[T?, string|undefined]}
- */
-function unwrap (value) {
-  if (value instanceof ActionWrapper)
-    return [value.value ?? undefined, value.action];
-  return [value ?? undefined, undefined];
-}
-
-/**
- *
- * @private
- * @template T
- * @param {string} action
- * @returns {function(T): ActionWrapper<T>}
- */
-function prepareWrapper (action) {
-  return value => new ActionWrapper(value, action);
-}
-
-module.exports = { Tokenizer, restrict, unwrap, prepareWrapper };

package/lib/parser.js

@@ -1,434 +0,0 @@
-/**
- * Combinatory logic simulator
- */
-'use strict';
-
-const { Tokenizer, restrict } = require('./internal');
-const classes = require('./expr');
-
-const { Expr, Named, Native, Alias, FreeVar, Lambda, Church } = classes;
-const { native, declare } = 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 ?? '???');
-  } */
-}
-
-function postParse (expr) {
-  return expr.postParse ? expr.postParse() : expr;
-}
-
-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} | 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
-    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
-    // 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);
-  }
-
-  /**
-   * @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 {String|Expr|function(Expr):Partial} [impl]
-   * @param {String} [note]
-   * @return {SKI} chainable
-   */
-  add (term, impl, note ) {
-    term = this._named(term, impl);
-
-    if (this.annotate && note === undefined) {
-      const guess = term.infer();
-      if (guess.expr)
-        note = guess.expr.format({ terse: true, html: true, lambda: ['', ' ↦ ', ''] });
-    }
-    if (note !== undefined)
-      term.note = note;
-
-    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);
-    else
-      this.add(name, impl);
-    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.
-   * @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;
-  }
-
-  /**
-   * 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
-   * @param {Object} [options]
-   * @param {{[keys: string]: Expr}} [options.env]
-   * @param {any} [options.scope]
-   * @param {boolean} [options.numbers]
-   * @param {boolean} [options.lambdas]
-   * @param {string} [options.allow]
-   * @return {Expr}
-   */
-  parse (source, options = {}) {
-    if (typeof source !== 'string')
-      throw new Error('parse: source must be a string, got ' + typeof source);
-
-    const lines = source.replace(/\/\/[^\n]*$/gm, '')
-      .split(/\s*;[\s;]*/).filter( s => s.match(/\S/));
-
-    const jar = { ...options.env };
-
-    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 = (str === '' && save !== undefined)
-        ? new FreeVar(save, options.scope)
-        : this.parseLine(str, jar, options);
-
-      if (save !== undefined) {
-        if (jar[save] !== undefined)
-          throw new Error('Attempt to redefine a known term: ' + save);
-        expr = maybeAlias(save, expr);
-        jar[save] = expr;
-      }
-
-      // console.log('parsed line:', item, '; got:', expr,'; jar now: ', jar);
-    }
-
-    expr.context = {
-      env:    jar, // also contains pre-parsed terms
-      scope:  options.scope,
-      src:    source,
-      parser: this,
-    };
-    return expr;
-  }
-
-  /**
-   *
-   * @param {String} source S(KI)I
-   * @param {{[keys: string]: Expr}} env
-   * @param {Object} [options]
-   * @param {{[keys: string]: Expr}} [options.env] - unused, see 'env' argument
-   * @param {any} [options.scope]
-   * @param {boolean} [options.numbers]
-   * @param {boolean} [options.lambdas]
-   * @param {string} [options.allow]
-   * @return {Expr} parsed expression
-   */
-  parseLine (source, env = {}, 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];
-    const context = options.scope || SKI; // default is global unbound vars
-
-    // 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 = postParse(stack.pop());
-        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(), env));
-      } 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 (!env[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 = env[c] ?? this.known[c] ?? (env[c] = new FreeVar(c, context));
-        stack.push(f.apply(x));
-      }
-    }
-
-    if (stack.length !== 1) {
-      throw new Error('unbalanced input: missing '
-          + (stack.length - 1) + ' closing parenthesis:' + source);
-    }
-
-    return postParse(stack.pop());
-  }
-
-  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,
-      annotate: this.annotate,
-      terms:    this.declare(),
-    }
-  }
-}
-
-function maybeAlias (name, expr) {
-  if (expr instanceof Named && expr.name === name)
-    return expr;
-  return new Alias(name, expr);
-}
-
-// Create shortcuts for common terms
-
-SKI.classes = classes;
-
-/**
- * @desc Create a proxy object that generates variables on demand,
- *       with names corresponding to the property accessed.
- *       Different invocations will return distinct variables,
- *       even if with the same name.
- *
- *
- * @example const {x, y, z} = SKI.vars();
- *          x.name; // 'x'
- *          x instanceof FreeVar; // true
- *          x.apply(y).apply(z); // x(y)(z)
- *
- * @return {{[key: string]: FreeVar}}
- */
-
-SKI.vars = function (context = {}) {
-  const cache = {};
-  return new Proxy({}, {
-    get: (target, name) => {
-      if (!(name in cache))
-        cache[name] = new FreeVar(name, context);
-      return cache[name];
-    }
-  });
-};
-
-/**
- * Convert a number to Church encoding
- * @param {number} n
- * @return {Church}
- */
-SKI.church = n => new Church(n);
-
-/**
- *
- * @type {{[key: string]: Native}}
- */
-
-for (const name in native)
-  SKI[name] = native[name];
-SKI.native = native;
-SKI.declare = declare;
-SKI.control = Expr.control;
-
-module.exports = { SKI };