eyeprolog 1.1.23 → 1.1.25

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.23",
+  "version": "1.1.25",
   "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) {
@@ -1784,7 +1784,8 @@ function* phraseBuiltin({ solver, goal, env }) {
   }
 }
 function formalErrorTerm(error) {
-  if (error.formalTerm != null) return compound('error', [error.formalTerm, atom('eyeprolog')]);
+  const context = error.contextTerm ?? atom('eyeprolog');
+  if (error.formalTerm != null) return compound('error', [error.formalTerm, context]);
   const parse = (text) => {
     const open = text.indexOf('(');
     if (open === -1) return atom(text);
@@ -1811,7 +1812,7 @@ function formalErrorTerm(error) {
       formal = compound(formal.name, [error.culprit]);
     }
   }
-  return compound('error', [formal, atom('eyeprolog')]);
+  return compound('error', [formal, context]);
 }
 function* catchBuiltin({ solver, goal, env }) {
   const child = solver.cloneForInnerGoal();

package/src/repl.js

@@ -415,21 +415,43 @@ function formatError(engine, state, error) {
     let generated = 0;
     if (error.formalTerm != null) {
       collectUnboundVariables(engine, error.formalTerm, env, variableNames, () => `_${letterName(generated++)}`);
+      if (error.contextTerm != null) {
+        collectUnboundVariables(engine, error.contextTerm, env, variableNames, () => `_${letterName(generated++)}`);
+      }
       const formal = engine.formatTermForWrite(error.formalTerm, env, {
         quoted: true,
         operators: [...state.program.operators.values()],
         variableNames,
       });
+      if (error.contextTerm != null) {
+        const context = engine.formatTermForWrite(error.contextTerm, env, {
+          quoted: true,
+          operators: [...state.program.operators.values()],
+          variableNames,
+        });
+        return `error(${formal}, ${context}).`;
+      }
       return `error(${formal}).`;
     }
     if (error.culprit != null) {
       collectUnboundVariables(engine, error.culprit, env, variableNames, () => `_${letterName(generated++)}`);
     }
+    if (error.contextTerm != null) {
+      collectUnboundVariables(engine, error.contextTerm, env, variableNames, () => `_${letterName(generated++)}`);
+    }
     const culprit = error.culprit == null ? '' : `, ${engine.formatTermForWrite(error.culprit, env, {
       quoted: true,
       operators: [...state.program.operators.values()],
       variableNames,
     })}`;
+    if (error.contextTerm != null) {
+      const context = engine.formatTermForWrite(error.contextTerm, env, {
+        quoted: true,
+        operators: [...state.program.operators.values()],
+        variableNames,
+      });
+      return `error(${error.formal}${culprit}, ${context}).`;
+    }
     return `error(${error.formal}${culprit}).`;
   }
   const message = error?.message ?? String(error);

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  COMPOUND, Env, compound, copyResolved, deref, flattenConjunction, freshTerm,
+  COMPOUND, Env, compound, copyResolved, deref, emptyList, flattenConjunction, freshTerm,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variantTerms,
 } from './term.js';
 import { PrologError } from './iso.js';
@@ -24,8 +24,11 @@ export function nextFreshId() {
 }
 
 function raiseOccursCheckError(left, right, env) {
-  const error = new PrologError('occurs_check');
-  error.formalTerm = copyResolved(compound('occurs_check', [left, right]), env);
+  // occurs_check=error is an implementation-specific STO diagnostic.  Report
+  // the unrepresentable cyclic result through the standard error envelope.
+  // Keep the implementation-defined context empty for stable, portable output.
+  const error = new PrologError('representation_error(term)');
+  error.contextTerm = emptyList();
   throw error;
 }
 

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

@@ -523,7 +523,7 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'occurs_check error mode detects STO while ISO occurs-check unification still fails',
+      name: 'occurs_check error mode reports representation_error(term) while ISO occurs-check unification still fails',
       run: () => {
         const filename = path.join(tmp, `occurs-check-${++tmpCounter}.pl`);
         fs.writeFileSync(filename, ':- set_prolog_flag(occurs_check, error).\nsame(X, X).\n');
@@ -544,11 +544,11 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout,
           '?-    Mode = true.\n' +
           '?-    true.\n' +
-          '?-    error(occurs_check(_A, f(_A))).\n' +
-          '?-    E = error(occurs_check(_A, g(_A)), eyeprolog).\n' +
+          '?-    error(representation_error(term), []).\n' +
+          '?-    E = error(representation_error(term), []).\n' +
           '?-    false.\n' +
           '?-    true.\n' +
-          '?-    error(occurs_check(_A, k(_A))).\n' +
+          '?-    error(representation_error(term), []).\n' +
           '?-    true.\n' +
           '?-    false.\n' +
           '?- ',
@@ -950,6 +950,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 +1037,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

@@ -785,15 +785,22 @@ subject-to-occurs-check (STO). EyeProlog's default remains the sound finite-tree
 behavior above. For diagnosis, EyeProlog additionally provides the
 implementation-specific flag `occurs_check`; setting it to `error` turns a
 normal unification that would otherwise fail because of the occurs check into
-an exception:
+a representation error:
 
 ```eyeprolog
 :- set_prolog_flag(occurs_check, error).
 
 sto_example :- X = wrapper(X).
-% error(occurs_check(_A, wrapper(_A)))
+% error(representation_error(term), [])
 ```
 
+The ISO error mechanism wraps an error term together with an
+implementation-defined context term. For this implementation-specific STO
+diagnostic EyeProlog uses `representation_error(term)` and currently uses the
+empty list `[]` as that context. This reports that the cyclic result of a
+succeeding STO unification cannot be represented by EyeProlog's finite-tree
+term model, without exposing a non-standard `occurs_check/2` error term.
+
 The supported values are `true` (the default finite-tree behavior) and `error`
 (STO detection). EyeProlog deliberately does not provide `occurs_check=false`,
 because its term model does not construct cyclic terms. The ISO predicate
@@ -5124,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
@@ -5164,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`.