@dallaylaen/ski-interpreter 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.0] - 2026-03-15
+
+### BREAKING CHANGES
+
+- `affine: true` in quests now means "has no duplicating subterms" rather than "non-duplicating as a whole." 
+Aliases are exempted from this check, so a solution `SK`
+will not pass as S is duplicating, but `false=SK; false`
+will because `false` (as a whole term) _is_ affine.
+
+### Added
+
+- `SKI.schemas.FormatOptions`: zod schema for validating format options.
+- `bin/ski.js`: global `--format` option.
+- `bin/ski.js`: `!format` command in the REPL.
+- `bin/ski.js`: `--verbose` is now a global flag with a toggle in the REPL.
+- `bin/ski.js`: `--max`, `--max-size`, and `--max-args` arguments.
+- `bin/ski.js search`: `--max-depth` and `--max-tries` options.
+- New quest: affine extract from list.
+- `zod` added as a dependency.
+
+### Fixed
+
+- `infer()` now adheres to `maxSize`.
+- Avoid adding context to parsed saved terms.
+- `TraverseValue` signature now includes `void` so that `return undefined` in `traverse`/`fold` is no longer necessary.
+
+## [2.4.1] - 2026-03-06
+
+### Added
+
+- expr.run({maxSize: number ?? 1_000_000}) to prevent runaway reductions (fixes #14).
+- `ski.js infer <expression>` command to infer properties of an expression.
+
+### Fixed
+
+- quests use shorter Y combinator form internally (#13)
+- history in the playground is scrolled to the bottom.
+
 ## [2.4.0] - 2026-03-06
 
 ### BREAKING CHANGES

package/README.md

@@ -99,12 +99,14 @@ npm install @dallaylaen/ski-interpreter
   * `--verbose` - Show all evaluation steps
   * Example: `ski file script.ski`
 
+* **`infer <expression>`** - try to find equivalent lambda expression and display its properties if found. 
+
 * **`extract <expression> <known term> ...`** - 
   Replace parts of the expression that are equivalent to the known terms with the respective terms. Known terms must be normalizable.
 
 * **`search <expression> <known term> ...`** - 
   Attempt to brute force an equivalent of the _expression_ using only the _known terms_.  
-  Only normalizing terms are currently supported. 
+  Only normalizable terms are currently supported. 
 
 * **`quest-lint <files...>`** - Validate quest definition files
   * `--solution <file>` - Load solutions from a JSON file for verification
@@ -150,7 +152,7 @@ const final = expr.run({max: 1000}); // { steps: 42, expr: '...' }
 const iterator = expr.walk();
 
 // applying expressions
-const result = expr.run({max: 1000}, arg1, arg2 ...);
+const result = expr.run({max: 1000}, arg1, arg2, ...);
 // same sa
 expr.apply(arg1).apply(arg2).run();
 // or simply

package/bin/ski.js

@@ -7,46 +7,67 @@ const { SKI } = require('../lib/ski-interpreter.cjs');
 const { Quest } = SKI;
 const { version } = require('../package.json');
 
+const runOptions = {};
+let format = {};
+let verbose = false;
+
 const program = new Command();
 
 program
   .name('ski')
   .description('Simple Kombinator Interpreter - a combinatory logic & lambda calculus parser and interpreter')
-  .version(version);
+  .version(version)
+  .option('-v, --verbose', 'Show all evaluation steps', () => { verbose = true; })
+  .option('--format <json>', 'Format for output expressions', setFormat)
+  .option('--max <number>', 'Limit computation steps', raw => {
+    const n = Number.parseInt(raw);
+    if (Number.isNaN(n) || n <= 0)
+      throw new Error('--max requires a positive integer');
+    runOptions.max = n;
+  })
+  .option('--max-size <number>', 'Limit expression\'s total footprint during computations', raw => {
+    const n = Number.parseInt(raw);
+    if (Number.isNaN(n) || n <= 0)
+      throw new Error('--max-size requires a positive integer');
+    runOptions.maxSize = n;
+  })
+  .option('--max-args <number>', 'Limit probed arguments when inferring terms', raw => {
+    const n = Number.parseInt(raw);
+    if (Number.isNaN(n) || n <= 0)
+      throw new Error('--max-args requires a positive integer');
+    runOptions.maxArgs = n;
+  });
 
 // REPL subcommand
 program
   .command('repl')
   .description('Start interactive REPL')
-  .option('--verbose', 'Show all evaluation steps')
   .action((options) => {
-    startRepl(options.verbose);
+    startRepl(options);
   });
 
 // Eval subcommand
 program
   .command('eval <expression>')
   .description('Evaluate a single expression')
-  .option('--verbose', 'Show all evaluation steps')
   .action((expression, options) => {
-    evaluateExpression(expression, options.verbose);
+    evaluateExpression(expression, options);
   });
 
 // File subcommand
 program
   .command('file <filepath>')
   .description('Evaluate expressions from a file')
-  .option('--verbose', 'Show all evaluation steps')
   .action((filepath, options) => {
-    evaluateFile(filepath, options.verbose);
+    evaluateFile(filepath);
   });
 
-// Search subcommand
+// Infer subcommand
 program
-  .command('search <target> <terms...>')
-  .description('Search for an expression equivalent to target using known terms')
-  .action((target, terms) => {
-    searchExpression(target, terms);
+  .command('infer <expression>')
+  .description('Find a canonical form of the expression and its properties')
+  .action((expression) => {
+    inferExpression(expression);
   });
 
 // Extract subcommand
@@ -57,6 +78,14 @@ program
     extractExpression(target, terms);
   });
 
+// Search subcommand
+program
+  .command('search <target> <terms...>')
+  .description('Search for an expression equivalent to target using known terms')
+  .option('--max-depth <number>', 'Limit search depth', toInt('--max-depth'))
+  .option('--max-tries <number>', 'Limit total terms probed', toInt('--max-tries'))
+  .action(searchExpression);
+
 // Quest-check subcommand
 program
   .command('quest-lint <files...>')
@@ -72,9 +101,9 @@ program
   .parse(process.argv);
 
 if (!process.argv.slice(2).length)
-  startRepl(false);
+  startRepl();
 
-function startRepl (verbose) {
+function startRepl () {
   const readline = require('readline');
   const ski = new SKI();
 
@@ -92,7 +121,7 @@ function startRepl (verbose) {
       if (str.startsWith('!'))
         handleCommand(str, ski);
       else {
-        processLine(str, ski, verbose, err => {
+        processLine(str, ski, err => {
           console.log('' + err);
         });
       }
@@ -108,19 +137,19 @@ function startRepl (verbose) {
   rl.prompt();
 }
 
-function evaluateExpression (expression, verbose) {
+function evaluateExpression (expression) {
   const ski = new SKI();
-  processLine(expression, ski, verbose, err => {
+  processLine(expression, ski, err => {
     console.error('' + err);
     process.exit(3);
   });
 }
 
-function evaluateFile (filepath, verbose) {
+function evaluateFile (filepath) {
   const ski = new SKI();
   fs.readFile(filepath, 'utf8')
     .then(source => {
-      processLine(source, ski, verbose, err => {
+      processLine(source, ski, err => {
         console.error('' + err);
         process.exit(3);
       });
@@ -131,7 +160,7 @@ function evaluateFile (filepath, verbose) {
     });
 }
 
-function processLine (source, ski, verbose, onErr) {
+function processLine (source, ski, onErr) {
   if (!source.match(/\S/))
     return; // nothing to see here
 
@@ -141,12 +170,12 @@ function processLine (source, ski, verbose, onErr) {
     const isAlias = expr instanceof SKI.classes.Alias;
     const aliasName = isAlias ? expr.name : null;
 
-    for (const state of expr.walk()) {
+    for (const state of expr.walk(runOptions)) {
       if (state.final)
         console.log(`// ${state.steps} step(s) in ${new Date() - t0}ms`);
 
       if (verbose || state.final)
-        console.log('' + state.expr.format());
+        console.log(state.expr.format(format));
 
       if (state.final && isAlias && aliasName)
         ski.add(aliasName, state.expr);
@@ -156,6 +185,43 @@ function processLine (source, ski, verbose, onErr) {
   }
 }
 
+function inferExpression (expression) {
+  const ski = new SKI();
+
+  const expr = ski.parse(expression);
+  const guess = expr.infer(runOptions);
+
+  if (guess.normal) {
+    displayInfer(guess);
+    return;
+  }
+  // hard case...
+  let steps = guess.steps;
+  const canon = expr.traverse(e => {
+    if (e === expr)
+      return; // already tried
+    const g = e.infer(runOptions);
+    steps += g.steps;
+    return g.expr;
+  });
+
+  displayInfer({ expr: canon, steps, normal: false, proper: false });
+}
+
+/**
+ *
+ * @param {TermInfo} guess
+ */
+function displayInfer (guess) {
+  if (guess.expr)
+    console.log(guess.expr.format(format));
+
+  for (const key of ['normal', 'proper', 'arity', 'discard', 'duplicate', 'steps']) {
+    if (guess[key] !== undefined)
+      console.log(`// ${key}: ${guess[key]}`);
+  }
+}
+
 async function questCheck (files, solutionFile) {
   try {
     // Load solutions if provided
@@ -220,11 +286,10 @@ async function questCheck (files, solutionFile) {
   }
 }
 
-function searchExpression (targetStr, termStrs) {
+function searchExpression (targetStr, termStrs, options) {
   const ski = new SKI();
-  const jar = {};
-  const target = ski.parse(targetStr, { vars: jar });
-  const seed = termStrs.map(s => ski.parse(s, { vars: jar }));
+  const target = ski.parse(targetStr);
+  const seed = termStrs.map(s => ski.parse(s));
 
   const { expr } = target.infer();
   if (!expr) {
@@ -232,7 +297,7 @@ function searchExpression (targetStr, termStrs) {
     process.exit(1);
   }
 
-  const res = SKI.extras.search(seed, { tries: 10_000_000, depth: 100 }, (e, p) => {
+  const res = SKI.extras.search(seed, { tries: options.maxTries, depth: options.maxDepth }, (e, p) => {
     if (!p.expr)
       return -1;
     if (p.expr.equals(expr))
@@ -241,7 +306,7 @@ function searchExpression (targetStr, termStrs) {
   });
 
   if (res.expr) {
-    console.log(`Found ${res.expr} after ${res.total} tries.`);
+    console.log(`Found ${res.expr.format(format)} after ${res.total} tries.`);
     process.exit(0);
   } else {
     console.error(`No equivalent expression found for ${target} after ${res.total} tries.`);
@@ -254,7 +319,7 @@ function extractExpression (targetStr, termStrs) {
   const expr = ski.parse(targetStr);
   const pairs = termStrs
     .map(s => ski.parse(s))
-    .map(e => [e.infer().expr, e]);
+    .map(e => [e.infer(runOptions).expr, e]);
 
   const uncanonical = pairs.filter(pair => !pair[0]);
   if (uncanonical.length) {
@@ -264,25 +329,22 @@ function extractExpression (targetStr, termStrs) {
   }
 
   const replaced = expr.traverse(e => {
-    const canon = e.infer().expr;
+    const canon = e.infer(runOptions).expr;
     if (canon) {
       for (const [lambda, term] of pairs) {
         if (canon.equals(lambda))
           return term;
       }
     }
-    return null;
   });
 
-  if (replaced)
-    console.log(replaced.toString());
-  else
+  console.log((replaced ?? expr).format(format));
+  if (!replaced)
     console.log('// unchanged');
 }
 
 function handleCommand (input, ski) {
-  const parts = input.trim().split(/\s+/);
-  const cmd = parts[0];
+  const [_, cmd, arg] = input.match(/^\s*(\S+)(?:\s+(.*\S))?\s*$/);
 
   const dispatch = {
     '!ls': () => {
@@ -296,9 +358,21 @@ function handleCommand (input, ski) {
           console.log(`  ${name} ${term.props?.expr ?? '(native)'}`);
       }
     },
+    '!verbose': flag => {
+      verbose = !(['off', 'false', '0', '-'].includes(flag));
+      console.log('// verbose is ' + (verbose ? 'on' : 'off'));
+    },
+    '!format': options => {
+      if (options)
+        setFormat(options);
+      else
+        console.log('Format: ' + JSON.stringify(format, null, 2));
+    },
     '!help': () => {
       console.log('Available commands:');
       console.log('  !ls    - List term inventory');
+      console.log('  !verbose [on|off] - Toggle verbose mode (show all evaluation steps)');
+      console.log('  !format [json] - Set or show output format options');
       console.log('  !help  - Show this help message');
     },
     '': () => {
@@ -307,5 +381,22 @@ function handleCommand (input, ski) {
     }
   };
 
-  (dispatch[cmd] || dispatch[''])(...parts.slice(1));
+  try {
+    (dispatch[cmd] || dispatch[''])(arg)
+  } catch (err) {
+    console.error(`Error executing command ${cmd}:`, err.message);
+  }
+}
+
+function setFormat (options) {
+  format = SKI.schemas.FormatOptions.parse(JSON.parse(options));
+}
+
+function toInt (comment) {
+  return function (str) {
+    const n = Number.parseInt(str);
+    if (Number.isNaN(n) || n <= 0)
+      throw new Error(comment + ' requires positive integer');
+    return n;
+  }
 }