eyeprolog 1.1.22 → 1.1.24

package/package.json

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

package/src/iso.js

@@ -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/parser.js

@@ -39,6 +39,7 @@ const graphicAtomChars = '#$&*+-./<=>@^~\\:';
 // canonical notation. Commas remain separators except inside parentheses.
 const INFIX_OPERATORS = new Map([
   [':-', { precedence: 1, associativity: 'none' }],
+  ['?-', { precedence: 1, associativity: 'none' }], // quad label extension
   ['-->', { precedence: 1, associativity: 'none' }],
   ['|', { precedence: 96, associativity: 'right' }],
   [';', { precedence: 101, associativity: 'right' }],
@@ -77,14 +78,15 @@ const INFIX_OPERATORS = new Map([
   ['^', { precedence: 1001, associativity: 'right' }],
 ]);
 const PREFIX_OPERATORS = new Map([
-  ['\\+', 301],
-  ['+', 1001],
-  ['-', 1001],
-  ['\\', 1001],
+  ['?-', { precedence: 1, strict: true }],
+  ['\\+', { precedence: 301, strict: false }],
+  ['+', { precedence: 1001, strict: false }],
+  ['-', { precedence: 1001, strict: false }],
+  ['\\', { precedence: 1001, strict: false }],
 ]);
 
 export const ISO_OPERATOR_DEFINITIONS = [
-  [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'xfx', '-->'],
+  [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'fx', '?-'], [1200, 'xfx', '-->'],
   [1105, 'xfy', '|'],
   [1100, 'xfy', ';'], [1050, 'xfy', '->'], [1000, 'xfy', ','],
   [900, 'fy', '\\+'],
@@ -97,6 +99,13 @@ export const ISO_OPERATOR_DEFINITIONS = [
   [200, 'fy', '+'], [200, 'fy', '-'], [200, 'fy', '\\'],
 ];
 
+// EyeProlog's embedded quad syntax permits an optional label before `?-`.
+// That makes `?-` an implementation-specific xfx operator in addition to its
+// ISO 1200 fx definition.
+export const QUAD_OPERATOR_DEFINITIONS = [
+  [1200, 'xfx', '?-'],
+];
+
 const CLPZ_OPERATOR_DEFINITIONS = [
   [760, 'yfx', '#<==>'], [750, 'xfy', '#==>'], [750, 'yfx', '#<=='],
   [740, 'yfx', '#\\/'], [730, 'yfx', '#\\'], [720, 'yfx', '#/\\'],
@@ -133,9 +142,7 @@ function defineParserOperator(state, priority, specifier, name) {
 export function createParserOperatorState(definitions = [], includeDefaults = true) {
   const state = {
     infixOperators: includeDefaults ? new Map(INFIX_OPERATORS) : new Map(),
-    prefixOperators: includeDefaults
-      ? new Map([...PREFIX_OPERATORS].map(([name, precedence]) => [name, { precedence, strict: false }]))
-      : new Map(),
+    prefixOperators: includeDefaults ? new Map(PREFIX_OPERATORS) : new Map(),
     postfixOperators: new Map(),
   };
   for (const definition of definitions) {

package/src/program.js

@@ -4,6 +4,7 @@ import { ATOM, COMPOUND, VAR, Env, atom, compound, deref, flattenConjunction, is
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
+  QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
   parseClauses,
   parseClausesInto,
@@ -101,8 +102,10 @@ export class Program {
     this.moduleMetaPredicates = new Map();
     this.dynamicPredicates = new Set();
     this.operators = new Map();
-    for (const [priority, specifier, name] of ISO_OPERATOR_DEFINITIONS) {
-      this.defineOperator(priority, specifier, name);
+    for (const definitions of [ISO_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS]) {
+      for (const [priority, specifier, name] of definitions) {
+        this.defineOperator(priority, specifier, name);
+      }
     }
     this.initializations = [];
     this.quads = [];

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/test/conformance/cases/iso/operator_atoms_as_arguments.pl

@@ -5,3 +5,10 @@
 operator_atoms(Priority, Specifier, List) :-
     current_op(Priority, Specifier, :-),
     List = [:-,-].
+
+% ISO 6.3.4.4, Table 7: ?- is a predefined 1200 fx operator.
+
+%% goal: query_prefix_operator(ok)
+
+query_prefix_operator(ok) :-
+    current_op(1200, fx, ?-).

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

@@ -1,2 +1,3 @@
 operator_atoms(1200, xfx, [':-', '-']).
 operator_atoms(1200, fx, [':-', '-']).
+query_prefix_operator(ok).

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,32 @@ c4 ?- call((!;1)).
         assertEqual(run(source, { goal: 'operator_argument(ok)' }).stdout, 'operator_argument(ok).\n', 'operator argument syntax');
       },
     },
+    {
+      name: 'ISO query operator and quad infix extension are visible through current_op/3',
+      run: () => {
+        assertEqual(
+          run('', { goal: 'current_op(Priority, Specifier, ?-)' }).stdout,
+          "current_op(1200, fx, '?-').\ncurrent_op(1200, xfx, '?-').\n",
+          'query operator definitions',
+        );
+        assertEqual(
+          run('', { goal: 'current_op(1200, fx, ?-)' }).stdout,
+          "current_op(1200, fx, '?-').\n",
+          'ISO query prefix operator',
+        );
+        assertEqual(
+          run('', { goal: 'current_op(1200, xfx, ?-)' }).stdout,
+          "current_op(1200, xfx, '?-').\n",
+          'quad query infix operator',
+        );
+        const prefix = parseGoalText('(?- true)');
+        assertEqual(prefix.name, '?-', 'prefix query functor');
+        assertEqual(prefix.arity, 1, 'prefix query arity');
+        const infix = parseGoalText('(label ?- true)');
+        assertEqual(infix.name, '?-', 'quad query functor');
+        assertEqual(infix.arity, 2, 'quad query arity');
+      },
+    },
     {
       name: 'term input keeps dotted operators intact and uses program operators',
       run: () => {

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,13 @@ 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.
+or parenthesizing those operator atoms. 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
+syntax is supported it additionally exposes `?-` at priority 1200 with
+specifier `xfx` as an implementation-specific operator. Consequently
+`current_op(Priority, Specifier, ?-)` enumerates both definitions.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -5290,8 +5303,10 @@ clause ends in a period. The grammar above gives the canonical term shapes.
 The initial operator table contains the following ISO-style operators, all
 lowered to ordinary compound terms:
 
-- prefix: `\+`, unary `+`, unary `-`, and `\`;
+- prefix: ISO `?-`, `\+`, unary `+`, unary `-`, and `\`;
 - control: `,`, `;`, and `->`;
+- quad syntax extension: `?-` is also a priority-1200 `xfx` operator so a
+  label may precede a quad query;
 - grammar rules: `-->` and the Part 3 alternative `|`;
 - unification and comparison: `=`, `\=`, `==`, `\==`, `@<`, `@=<`, `@>`,
   `@>=`, `is`, `=:=`, `=\=`, `<`, `=<`, `>`, and `>=`;