eyeprolog 1.2.12 → 1.2.14

package/package.json

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

package/src/iso.js

@@ -284,8 +284,8 @@ function termIsAcyclic(term, env) {
   return true;
 }
 
-function resolvedOrder(left, right, env) {
-  return compareTerms(copyResolved(left, env), copyResolved(right, env));
+function resolvedOrder(left, right, env, variableRanks = null) {
+  return compareTerms(copyResolved(left, env), copyResolved(right, env), variableRanks);
 }
 function* compareBuiltin({ goal, env }) {
   const order = deref(goal.args[0], env);
@@ -331,10 +331,11 @@ function validateListOutput(term, env) {
 function* sortBuiltin({ goal, env }) {
   const items = requireProperList(goal.args[0], env);
   validateListOutput(goal.args[1], env);
-  const sorted = [...items].sort((a, b) => resolvedOrder(a, b, env));
+  const variableRanks = new Map();
+  const sorted = [...items].sort((a, b) => resolvedOrder(a, b, env, variableRanks));
   const unique = [];
   for (const item of sorted) {
-    if (unique.length === 0 || resolvedOrder(unique[unique.length - 1], item, env) !== 0) unique.push(item);
+    if (unique.length === 0 || resolvedOrder(unique[unique.length - 1], item, env, variableRanks) !== 0) unique.push(item);
   }
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(unique), next)) yield next;
@@ -350,7 +351,11 @@ function* keysortBuiltin({ goal, env }) {
     }
   }
   // Modern ECMAScript specifies a stable Array#sort, as required by keysort/2.
-  const sorted = [...items].sort((a, b) => resolvedOrder(deref(a, env).args[0], deref(b, env).args[0], env));
+  // Keep one implementation-dependent variable order for this whole sorting
+  // operation, as required by ISO 7.2.1.
+  const variableRanks = new Map();
+  const sorted = [...items].sort((a, b) =>
+    resolvedOrder(deref(a, env).args[0], deref(b, env).args[0], env, variableRanks));
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(sorted), next)) yield next;
 }
@@ -1701,8 +1706,10 @@ function sameWitness(left, right) {
 }
 
 function sortedUnique(items) {
-  const sorted = [...items].sort(compareTerms);
-  return sorted.filter((item, index) => index === 0 || compareTerms(sorted[index - 1], item) !== 0);
+  const variableRanks = new Map();
+  const compare = (left, right) => compareTerms(left, right, variableRanks);
+  const sorted = [...items].sort(compare);
+  return sorted.filter((item, index) => index === 0 || compare(sorted[index - 1], item) !== 0);
 }
 
 function allSolutionsBuiltin(asSet) {

package/src/parser.js

@@ -746,11 +746,11 @@ class Parser {
     const accept = emit ?? ((clause) => clauses.push(clause));
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
-      // In the normal EyeProlog profile, canonical functional ?-/1 and
-      // ?-/2 notation denotes the same quad marker as the corresponding
-      // operator notation.  Keep the existing operator-form query parsing so
-      // a query containing comma remains wholly to the right of `?-`, while
-      // functional notation is parsed as a term and then decomposed by arity.
+      // Prefix operator notation needs one program-level distinction so
+      // a comma in `?- A, B.` remains inside the query rather than outside the
+      // prefix term. Ordinary functional notation is parsed as a term and then
+      // recognized structurally by parseQuadTerm; further equivalent spellings
+      // are recognized after the general head parser below.
       if (this.operatorTokenName() === '?-' && !this.strictIso) {
         if (this.peek() === '(') {
           const quadTerm = this.parseTerm(0, true);
@@ -818,6 +818,14 @@ class Parser {
         head = items.pop();
         while (items.length > 0) head = compound(',', [items.pop(), head]);
       }
+      // Parentheses and other ordinary term syntax may hide the surface ?-
+      // token from the program-level dispatch above.  Once the complete head
+      // term has been parsed, recognize the same ?-/1 or ?-/2 structure here.
+      // Requiring the following dot prevents an ordinary rule whose head just
+      // happens to be ?-/1 or ?-/2 from being consumed as a quad mid-clause.
+      if (!this.strictIso && this.token.type === TOK.DOT && this.parseQuadTerm(head, line, accept)) {
+        continue;
+      }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {
           // There is no predefined infix ?-/2 in strict core mode.  If a

package/src/solver.js

@@ -1250,7 +1250,7 @@ function copyResolvedWithKey(term, env, variables) {
       id = variables.size;
       variables.set(value.name, id);
     }
-    return { term: termModuleCache.variable(value.name, value.order), key: `var:${id}` };
+    return { term: termModuleCache.variable(value.name), key: `var:${id}` };
   }
   if (!value.args?.length) {
     return {

package/src/term.js

@@ -6,10 +6,6 @@ export const STRING = 'string';
 export const NUMBER = 'number';
 export const COMPOUND = 'compound';
 const EMPTY_ARGS = Object.freeze([]);
-// Variable term order is carried by the variable objects themselves.  Do not
-// retain a process-global name registry: runtime clause freshening can create
-// an unbounded sequence of names in an otherwise constant-space computation.
-let variableOrder = 0;
 
 export class Term {
   constructor(type, name, args = []) {
@@ -22,11 +18,7 @@ export class Term {
   }
 }
 
-export const variable = (name, order = null) => {
-  const term = new Term(VAR, name, EMPTY_ARGS);
-  term.order = order ?? ++variableOrder;
-  return term;
-};
+export const variable = (name) => new Term(VAR, name, EMPTY_ARGS);
 export const atom = (name) => new Term(ATOM, name, EMPTY_ARGS);
 export const stringTerm = (value) => new Term(STRING, value, EMPTY_ARGS);
 export const numberTerm = (value) => new Term(NUMBER, value, EMPTY_ARGS);
@@ -271,7 +263,7 @@ export function unify(left, right, env, options = {}) {
 }
 
 export function cloneTerm(term) {
-  if (term.type === VAR) return variable(term.name, term.order);
+  if (term.type === VAR) return variable(term.name);
   const cloned = term.type === COMPOUND && term.arity === 0
     ? atom(term.name)
     : new Term(term.type, term.name, term.args.map(cloneTerm));
@@ -297,7 +289,7 @@ export function freshTerm(term, suffix, variables = new Map()) {
 
 export function copyResolved(term, env) {
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return variable(resolved.name, resolved.order);
+  if (resolved.type === VAR) return variable(resolved.name);
   const copied = resolved.type === COMPOUND && resolved.arity === 0
     ? atom(resolved.name)
     : new Term(resolved.type, resolved.name, resolved.args.map((arg) => copyResolved(arg, env)));
@@ -512,7 +504,27 @@ export function variantTerms(left, leftEnv, right, rightEnv, pairs = new Map(),
   return true;
 }
 
-export function compareTerms(left, right) {
+export function compareTerms(left, right, variableRanks = null) {
+  // ISO 7.2.1 deliberately leaves the order of distinct variables
+  // implementation dependent.  Do not attach a permanent ordinal to a
+  // logical variable: besides retaining implementation history, that would
+  // make the chosen order observable outside the operation that needs it.
+  // A caller that is constructing one sorted list can pass a shared Map so
+  // every comparison in that operation uses one consistent variable order.
+  const ranks = variableRanks ?? new Map();
+  return compareTermsWithRanks(left, right, ranks);
+}
+
+function variableRank(name, ranks) {
+  let rank = ranks.get(name);
+  if (rank == null) {
+    rank = ranks.size;
+    ranks.set(name, rank);
+  }
+  return rank;
+}
+
+function compareTermsWithRanks(left, right, variableRanks) {
   const rank = (term) => ({ [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]: 4 })[term.type];
   left = deref(left, new Env());
   right = deref(right, new Env());
@@ -527,18 +539,15 @@ export function compareTerms(left, right) {
   }
   if (left.type === VAR) {
     if (left.name === right.name) return 0;
-    const leftOrder = left.order ?? 0;
-    const rightOrder = right.order ?? 0;
-    if (leftOrder !== rightOrder) return leftOrder < rightOrder ? -1 : 1;
-    // Explicitly copied order values are permitted internally; keep the
-    // implementation-defined variable order total even in that case.
-    return left.name < right.name ? -1 : 1;
+    const leftOrder = variableRank(left.name, variableRanks);
+    const rightOrder = variableRank(right.name, variableRanks);
+    return leftOrder < rightOrder ? -1 : 1;
   }
   if (left.type === ATOM || left.type === STRING) return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
   if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;
   if (left.name !== right.name) return left.name < right.name ? -1 : 1;
   for (let i = 0; i < left.arity; i++) {
-    const cmp = compareTerms(left.args[i], right.args[i]);
+    const cmp = compareTermsWithRanks(left.args[i], right.args[i], variableRanks);
     if (cmp) return cmp;
   }
   return 0;

package/test/conformance/cases/iso/grouped_solutions_and_clauses.pl

@@ -45,7 +45,11 @@ shared_clause(Body) :-
 
 %% goal: shared_set_variables(X0)
 
-shared_set_variables(Set) :-
+% ISO 7.2.1 leaves the order of distinct variables implementation dependent.
+% Check that setof/3 constructs one consistent sorted list without baking a
+% particular variable order into the conformance golden.
+shared_set_variables(ok) :-
     setof(Value, (=(Value, Left); =(Value, Right)), Set),
     =(Left, a),
-    =(Right, b).
+    =(Right, b),
+    (=(Set, [a,b]); =(Set, [b,a])).

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

@@ -7,4 +7,4 @@ no_solutions.
 retrieved(bob, true).
 retrieved(carol, true).
 shared_clause(pair(ok, ok)).
-shared_set_variables("ab").
+shared_set_variables(ok).

package/test/run-regression.mjs

@@ -39,6 +39,7 @@ import {
   parseProgramText,
 } from '../src/index.js';
 import { parseGoalText } from '../src/parser.js';
+import { compareTerms } from '../src/term.js';
 import { selectClauseCandidates } from '../src/program.js';
 import { TestReporter, isMainModule } from './test-style.mjs';
 import { buildConformanceReport, formatConformanceReport } from './run-conformance-report.mjs';
@@ -222,7 +223,7 @@ why(
       },
     },
     {
-      name: 'quad parser treats operator and functional ?- notation equivalently',
+      name: 'quad parser treats regular term spellings of ?- equivalently',
       run: () => {
         const labelled = Program.parse(
           `0,passes
@@ -253,9 +254,28 @@ why(
         const functionalReport = publicApi.runQuads(functional);
         assertEqual(functionalReport.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'functional quad report');
 
-        const strict = Program.parse(`?-(','(0,passes),=(X,1)).\n`, { isoStrict: true });
+        // Issue #11 is about ordinary term syntax, not one privileged
+        // canonical spelling. Parentheses, quoted functor syntax, and mixed
+        // operator/functional notation must all denote the same ?-/2 term and
+        // therefore the same quad in the normal EyeProlog profile.
+        for (const [name, source] of [
+          ['mixed', `?-((0,passes), X = 1).\n   X = 1.\n`],
+          ['parenthesized', `(?-(','(0,passes),=(X,1))).\n   X = 1.\n`],
+          ['parenthesized mixed', `(?-((0,passes), X = 1)).\n   X = 1.\n`],
+          ['quoted functor', `'?-'(','(0,passes),=(X,1)).\n   X = 1.\n`],
+          ['quoted parenthesized', `('?-'(','(0,passes),=(X,1))).\n   X = 1.\n`],
+        ]) {
+          const regular = Program.parse(source);
+          assertEqual(regular.quads.length, 1, `${name} quad count`);
+          assertEqual(regular.clauses.length, 0, `${name} quad clause count`);
+          assertEqual(termToString(regular.quads[0].id), termToString(labelled.quads[0].id), `${name} label`);
+          assertEqual(termToString(regular.quads[0].query), termToString(labelled.quads[0].query), `${name} query`);
+          assertEqual(publicApi.runQuads(regular).stdout, 'quads: 1 run, 1 passed, 0 failed.\n', `${name} report`);
+        }
+
+        const strict = Program.parse(`(?-(','(0,passes),=(X,1))).\n`, { isoStrict: true });
         assertEqual(strict.quads.length, 0, 'strict mode has no quads');
-        assertEqual(strict.clauses.length, 1, 'strict functional ?-/2 remains an ordinary term');
+        assertEqual(strict.clauses.length, 1, 'strict ?-/2 remains an ordinary term');
       },
     },
     {
@@ -2424,6 +2444,26 @@ function whiteBoxCases() {
         assertEqual(termToString(variable('X'), env, true), 'socrates', 'binding');
       },
     },
+    {
+      name: 'variable term order is scoped to one comparison or sorted-list operation',
+      run: () => {
+        const left = variable('Left');
+        const right = variable('Right');
+        assertEqual(String(left.order), 'undefined', 'variables carry no persistent order ordinal');
+        assertEqual(String(right.order), 'undefined', 'second variable carries no persistent order ordinal');
+
+        // Separate comparisons are permitted to choose their own
+        // implementation-dependent order under ISO 7.2.1.
+        assertEqual(String(compareTerms(left, right)), '-1', 'first local comparison');
+        assertEqual(String(compareTerms(right, left)), '-1', 'second local comparison is independent');
+
+        // A sorted-list operation instead supplies one shared ranking context,
+        // so all comparisons made while constructing that list are consistent.
+        const ranks = new Map();
+        assertEqual(String(compareTerms(left, right, ranks)), '-1', 'shared order first direction');
+        assertEqual(String(compareTerms(right, left, ranks)), '1', 'shared order reverse direction');
+      },
+    },
     {
       name: 'unification rejects direct and indirect cyclic bindings',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1811,9 +1811,19 @@ child searches that inherit the solver limit do not stop after a fixed number of
 solutions. This matters for re-executable goals such as `repeat/0` and for
 library relations such as `call_nth/2`; an implementation safety threshold must
 not turn a still re-executable search into logical failure. Embedders that need
-a finite answer budget should pass `solutionLimit` explicitly. Host capacity
-failures that V8 reports as `Map maximum size exceeded` or `Set maximum size
-exceeded` are normalized at the solver boundary to the ISO error
+a finite answer budget should pass `solutionLimit` explicitly.
+
+Variable term order is deliberately scoped rather than stored as a permanent
+property of a variable. ISO 13211-1 section 7.2.1 leaves the order of two
+distinct variables implementation dependent and requires constancy only while
+a sorted list is being created. EyeProlog therefore chooses a local variable
+ranking for an ordinary term comparison, while `sort/2`, `keysort/2`, and the
+sorting step of `setof/3` share one ranking for the duration of that single
+sorted-list operation. No process-global variable registry or creation ordinal
+is retained or exposed through later comparisons.
+
+Host capacity failures that V8 reports as `Map maximum size exceeded` or `Set`
+`maximum size exceeded` are normalized at the solver boundary to the ISO error
 `resource_error(finite_memory)` instead of leaking a JavaScript `RangeError`.
 
 ### Implementation boundary
@@ -5156,10 +5166,12 @@ 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. At top level in the normal EyeProlog profile, the quad marker is recognized
-after term parsing, so equivalent syntax stays equivalent: `Label ?- Query.`
-and canonical `?-(Label, Query).` denote the same labelled quad when followed
-by its indented answer descriptions. In `--iso-strict` mode this quad
-interpretation is disabled, and `?-/2` remains ordinary Prolog term syntax.
+from the parsed `?-/1` or `?-/2` term rather than from one privileged surface
+spelling. Thus `Label ?- Query.`, `?-(Label, Query).`, mixed forms such as
+`?-((Label), Query).`, quoted-functor notation, and a parenthesized whole
+`(?-(Label, Query)).` denote the same quad when followed by indented answer
+descriptions. In `--iso-strict` mode this quad interpretation is disabled, and
+`?-/2` remains ordinary Prolog term syntax.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -6432,9 +6444,11 @@ Trealla and the ISO Prolog working examples. Because answer descriptions are
 layout-sensitive, indent every description while keeping ordinary clause heads
 and the next quad query at the left margin. A quad label may contain any number
 of comma-separated metadata fields, including across layout before `?-`; for
-example `9, "case", passes ?- Goal.` is one labelled query. Canonical
-functional notation is semantically equivalent: `?-(Label, Query).` followed by
-the same indented answer descriptions creates the same labelled quad as
+example `9, "case", passes ?- Goal.` is one labelled query. Quad recognition
+is structural after ordinary term parsing: functional, mixed, quoted-functor,
+and parenthesized spellings of the same `?-/1` or `?-/2` term are semantically
+equivalent. For example `?-(Label, Query).` and `(?-(Label, Query)).`, followed
+by the same indented answer descriptions, create the same labelled quad as
 `Label ?- Query.`.
 
 Statistics are comparative evidence, not a score in isolation. Preserve the