eyeprolog 1.2.13 → 1.2.14

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.13",
+  "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/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';
@@ -2443,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