eyeprolog 1.1.24 → 1.1.26

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.24",
+  "version": "1.1.26",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/iso.js

@@ -1164,9 +1164,9 @@ function* readTermBuiltin({ solver, goal, env }) {
   yield next;
 }
 function defaultTermWriteOptions(mode) {
-  if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map() };
-  if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map() };
-  return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map() };
+  if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true };
+  if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true };
+  return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true };
 }
 
 function writeOptionBoolean(value, env, option) {

package/src/quads.js

@@ -106,6 +106,11 @@ function checkAlternative(program, quad, alternative, options) {
     if (leaf.more && !leaf.hasExpectation) return { ok: true };
     const matches = matchLeaf(quad.query, leaf, actual, position);
     if (leaf.unexpected ? matches : !matches) return { ok: false };
+    // An unexpected error description is a negative assertion about that
+    // particular error pattern.  A different exception may be present and is
+    // checked by other descriptions; do not make the final 'no error' test
+    // turn a successful negative match back into a failure.
+    if (leaf.unexpected && leaf.error != null) return { ok: true };
     if (leaf.more) return { ok: true };
     if (!leaf.unexpected && (leaf.false || leaf.error != null)) {
       return { ok: position === leaves.length - 1 };
@@ -252,7 +257,7 @@ function matchLeaf(query, leaf, actual, position) {
   }
   if (leaf.error != null) {
     return position === actual.solutions.length && actual.error != null &&
-      errorMatches(leaf.error, actual.error.term) && outputMatches(leaf.output, actual.error.output);
+      errorMatches(query, leaf.error, actual.error.term) && outputMatches(leaf.output, actual.error.output);
   }
   const solution = actual.solutions[position];
   if (!solution || !outputMatches(leaf.output, solution.output)) return false;
@@ -297,12 +302,15 @@ function namedVariables(term) {
   return found;
 }
 
-function patternVariant(pattern, patternEnv, actual, actualEnv, pairs = new Map(), reverse = new Map()) {
+function patternVariant(
+  pattern, patternEnv, actual, actualEnv, pairs = new Map(), reverse = new Map(), fixedPatternNames = null,
+) {
   pattern = deref(pattern, patternEnv);
   actual = deref(actual, actualEnv);
   if (pattern.type === ATOM && pattern.name === '...') return true;
   if (pattern.type === VAR || actual.type === VAR) {
     if (pattern.type !== VAR || actual.type !== VAR) return false;
+    if (fixedPatternNames?.has(pattern.name)) return pattern.name === actual.name;
     const paired = pairs.get(pattern.name);
     const reversed = reverse.get(actual.name);
     if (paired != null || reversed != null) return paired === actual.name && reversed === pattern.name;
@@ -312,7 +320,9 @@ function patternVariant(pattern, patternEnv, actual, actualEnv, pairs = new Map(
   }
   if (pattern.type !== actual.type || pattern.name !== actual.name || pattern.arity !== actual.arity) return false;
   for (let index = 0; index < pattern.arity; index++) {
-    if (!patternVariant(pattern.args[index], patternEnv, actual.args[index], actualEnv, pairs, reverse)) return false;
+    if (!patternVariant(
+      pattern.args[index], patternEnv, actual.args[index], actualEnv, pairs, reverse, fixedPatternNames,
+    )) return false;
   }
   return true;
 }
@@ -334,16 +344,26 @@ function errorTerm(error) {
   return compound('error', [atom('system_error'), variable('$quad_context')]);
 }
 
-function errorMatches(expected, actual) {
+function errorMatches(query, expected, actual) {
+  // Variables named in the query keep their identity in answer descriptions.
+  // Seed both directions so a query variable can match only that same query
+  // variable, while variables introduced by the description (for example _X)
+  // remain fresh pattern variables.  This is especially important for throw/1:
+  // ISO requires the thrown ball to be a renamed copy, so throw(g(_X)) may
+  // describe throw(g(X)), but throw(g(X)) must not.
+  const queryNames = new Set(namedVariables(query).map((item) => item.name));
+  const matches = (pattern, term) => patternVariant(
+    pattern, new Env(), term, new Env(), new Map(), new Map(), queryNames);
+
   if (expected.type === COMPOUND && expected.name === 'throw' && expected.arity === 1 &&
       actual.type === COMPOUND && actual.name === '$quad_thrown' && actual.arity === 1) {
-    return patternVariant(expected.args[0], new Env(), actual.args[0], new Env());
+    return matches(expected.args[0], actual.args[0]);
   }
   if (actual.type !== COMPOUND || actual.name !== 'error' || actual.arity !== 2) return false;
   if (expected.type === COMPOUND && expected.name === 'error' && expected.arity === 2) {
-    return patternVariant(expected, new Env(), actual, new Env());
+    return matches(expected, actual);
   }
-  return patternVariant(expected, new Env(), actual.args[0], new Env());
+  return matches(expected, actual.args[0]);
 }
 
 function isErrorDescription(term) {

package/src/write.js

@@ -124,11 +124,18 @@ function chooseOperator(term, table) {
   return null;
 }
 
-function format(term, env, options, table, maxPriority = 1200) {
+function format(term, env, options, table, maxPriority = 1200, context = 'term') {
   const resolved = deref(term, env);
   if (resolved.type === VAR) return options.variableNames.get(resolved.name) ?? writeVariable(resolved.name);
   if (resolved.type === STRING) return writeString(resolved.name);
-  if (resolved.type === ATOM) return options.quoted ? writeAtom(resolved.name) : resolved.name;
+  if (resolved.type === ATOM) {
+    if (!options.quoted) return resolved.name;
+    // ISO 6.3.3.1 gives functional arguments and list elements a special
+    // `arg` production: an atom that is a current operator is valid there
+    // without quoting. Keep lexical exceptions such as `|` quoted.
+    if (options.operatorAtomsAsArgs && context === 'argument' && table.has(resolved.name)) return operatorName(resolved.name);
+    return writeAtom(resolved.name);
+  }
   if (resolved.type === NUMBER) return resolved.name;
 
   if (options.numbervars && resolved.type === COMPOUND && resolved.name === '$VAR' && resolved.arity === 1) {
@@ -146,9 +153,13 @@ function format(term, env, options, table, maxPriority = 1200) {
     let cursor = resolved;
     while (true) {
       cursor = deref(cursor, env);
-      if (isEmptyList(cursor)) return `[${parts.join(', ')}]`;
-      if (!isCons(cursor)) return `[${parts.join(', ')} | ${format(cursor, env, options, table, 999)}]`;
-      parts.push(format(cursor.args[0], env, options, table, 999));
+      const separator = options.compact ? ',' : ', ';
+      if (isEmptyList(cursor)) return `[${parts.join(separator)}]`;
+      if (!isCons(cursor)) {
+        const tailSeparator = options.compact ? '|' : ' | ';
+        return `[${parts.join(separator)}${tailSeparator}${format(cursor, env, options, table, 999, 'argument')}]`;
+      }
+      parts.push(format(cursor.args[0], env, options, table, 999, 'argument'));
       cursor = cursor.args[1];
     }
   }
@@ -183,8 +194,8 @@ function format(term, env, options, table, maxPriority = 1200) {
   }
 
   const name = options.quoted ? writeAtom(resolved.name) : resolved.name;
-  const args = resolved.args.map((arg) => format(arg, env, options, table, 999));
-  return `${name}(${args.join(', ')})`;
+  const args = resolved.args.map((arg) => format(arg, env, options, table, 999, 'argument'));
+  return `${name}(${args.join(options.compact ? ',' : ', ')})`;
 }
 
 export function formatTermForWrite(term, env = new Env(), options = {}) {
@@ -194,6 +205,8 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
     variableNames: options.variableNames instanceof Map ? options.variableNames : new Map(),
+    compact: options.compact === true,
+    operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
   };
   return format(term, env, normalized, operatorTable(options.operators), 1200);
 }

package/test/conformance/expected/iso/corrigendum3_write_variable_names.pl

@@ -1,2 +1,2 @@
-pair(First, Second)
+pair(First,Second)
 corrigendum3_write_variable_names.

package/test/run-regression.mjs

@@ -243,6 +243,24 @@ why(
         assertEqual(result.stdout, 'quads: 12 run, 12 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads distinguishes query variables from renamed throw variables',
+      run: () => {
+        const source = `?- throw(g(X)).\n` +
+          `   throw(g(_X)).\n` +
+          `   throw(g(X)), unexpected.\n`;
+        const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'throw-copy-quad.pl' }]));
+        assertEqual(result.total, 1, 'quad total');
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+
+        const forbiddenFresh = publicApi.runQuads(
+          `?- throw(g(X)).\n   throw(g(_X)), unexpected.\n`,
+        );
+        assertEqual(forbiddenFresh.failed, 1, 'fresh thrown variable is detected');
+      },
+    },
     {
       name: 'runQuads matches the corrected ISO phrase quad boundaries',
       run: () => {
@@ -950,6 +968,23 @@ c4 ?- call((!;1)).
         assertEqual(run(source, { goal: 'operator_argument(ok)' }).stdout, 'operator_argument(ok).\n', 'operator argument syntax');
       },
     },
+    {
+      name: 'ISO writeq preserves operator atoms in argument syntax',
+      run: () => {
+        const source = [
+          'emit_operator_arguments :-',
+          "  writeq([:-,-]), put_char('|'),",
+          "  writeq(f(*)), put_char('|'),",
+          "  writeq(f(;,'|',';;')).",
+          '',
+        ].join('\n');
+        assertEqual(
+          run(source, { goal: 'emit_operator_arguments' }).stdout,
+          "[:-,-]|f(*)|f(;,'|',';;')emit_operator_arguments.\n",
+          'operator argument output',
+        );
+      },
+    },
     {
       name: 'ISO query operator and quad infix extension are visible through current_op/3',
       run: () => {
@@ -1020,7 +1055,7 @@ c4 ?- call((!;1)).
         ].join('\n');
         assertEqual(
           run(source, { goal: 'emit' }).stdout,
-          "hello world|'hello world'|a + b * c|'+'(a, *(b, c))|hello world|'hello world'|+(a, b)|a + b|A|$VAR(0)|pair(Left, Right)emit.\n",
+          "hello world|'hello world'|a + b * c|'+'(a,*(b,c))|hello world|'hello world'|+(a,b)|a + b|A|$VAR(0)|pair(Left,Right)emit.\n",
           'stdout',
         );
       },

package/the-art-of-eyeprolog.md

@@ -5131,7 +5131,12 @@ parsing of subsequent text, place them before their first use. ISO argument
 syntax also permits an atom that is currently an operator to appear directly
 as a functional argument or list element, so forms such as
 `current_op(Priority, Specifier, :-)` and `[:-,-]` are valid without quoting
-or parenthesizing those operator atoms. The ISO initial operator table also
+or parenthesizing those operator atoms. Term output observes the same `arg`
+rule: with `quoted(true)`, an operator atom is not quoted merely because it is
+an operator when it occurs as a functional argument or list element. Thus
+`writeq([:-,-])` emits `[:-,-]`, and `writeq(f(;,'|',';;'))` emits
+`f(;,'|',';;')`; the bar stays quoted because ISO treats the unquoted `|`
+token as a list separator rather than an atom. The ISO initial operator table also
 contains `?-` at priority 1200 with specifier `fx`, so
 `current_op(1200, fx, ?-)` succeeds. EyeProlog's embedded quad syntax permits
 an optional label before the query marker (`Label ?- Query.`), so while quad
@@ -5171,7 +5176,10 @@ write_event(Path, Event) :-
 
 The period is essential when another Prolog processor will read the result as
 a term. `write/1-2` uses readable conventional syntax, `writeq/1-2` quotes
-where needed, and `write_canonical/1-2` exposes canonical structure.
+where needed, and `write_canonical/1-2` exposes canonical structure. ISO term
+output uses only the separator characters needed by the syntax, so functional
+arguments and list elements are emitted compactly; for example `writeq([a,b])`
+outputs `[a,b]`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`.
 
@@ -6292,7 +6300,11 @@ accepted as a negative answer.
 Answer descriptions support ordered answers separated by `;`, acceptable
 alternatives separated by `|`, `true`, `false`, standard error descriptions,
 and the `unexpected` annotation for an answer that must not occur (`inattendue`
-is its synonym). `...` and `ad_infinitum` accept further answers. Multiple
+is its synonym). Variables named in the query keep their identity inside answer
+descriptions; variables introduced only by a description are fresh. For example,
+a query `throw(g(X))` is described by `throw(g(_X))`, while
+`throw(g(X)), unexpected` verifies that ISO `throw/1` did not retain the query
+variable in the renamed exception term. `...` and `ad_infinitum` accept further answers. Multiple
 indented descriptions after one query must all hold. `inputs/1` supplies and
 checks consumed characters; `outputs/1` checks emitted characters. `sto` marks
 an answer description that this finite-tree implementation skips. `loops` is