eyeprolog 1.2.13 → 1.2.15

package/README.md

@@ -79,10 +79,12 @@ member_test ?- member(X, [prolog, logic]).
 ;  X = logic.
 ```
 
-A label may contain several comma-separated metadata fields. When a query has
-multiple indented answer descriptions, each description is checked and counted
-independently, so one failed expectation does not prevent the later ones from
-running.
+A label is simply the first argument of the ordinary `(?-)/2` term, so it may
+use any normal Prolog term syntax; EyeProlog only requires it to be ground when
+the quad is checked. A non-ground label is a quad failure, not a source syntax
+error, and later quads still run. When a query has multiple indented answer
+descriptions, each description is checked and counted independently, so one
+failed expectation does not prevent the later ones from running.
 
 ## Strict ISO/IEC 13211-1 core
 

package/package.json

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

@@ -794,13 +794,47 @@ class Parser {
         accept(clause);
         continue;
       }
+      // Program clauses historically parse comma separately from the head, so
+      // keep that grammar unchanged.  A quad id, however, is simply the first
+      // argument of the ordinary ?-/2 term.  If the initial head parse stops at
+      // a comma, tentatively reparse that left operand with the normal term
+      // grammar (where comma is the predefined priority-1000 xfy operator).
+      // Only when the resulting term is actually followed by ?- do we keep the
+      // tentative parse; otherwise restore the parser and retain the existing
+      // clause/DCG handling below.
+      const headState = {
+        pos: this.pos,
+        line: this.line,
+        anonymous: this.anonymous,
+        variables: new Map(this.variables),
+        previousToken: this.previousToken,
+        token: this.token,
+      };
+      const restoreHeadState = () => {
+        this.pos = headState.pos;
+        this.line = headState.line;
+        this.anonymous = headState.anonymous;
+        this.variables = new Map(headState.variables);
+        this.previousToken = headState.previousToken;
+        this.token = headState.token;
+      };
+
       let head = this.parseTerm(3);
-      // Both a quad label and a TS 13211-3 semicontext may contain one or more
-      // unparenthesized commas before their priority-1200 operator.  Parse the
-      // complete comma sequence here instead of stopping after one separator;
-      // portable quad labels commonly carry several metadata fields, e.g.
-      // `9, "case", passes ?- Goal.`.  Build the standard right-associative
-      // comma term so this is the same label as `(9, "case", passes)`.
+      if (this.token.type === TOK.COMMA && !this.strictIso) {
+        restoreHeadState();
+        const quadId = this.parseTerm(3, true);
+        if (this.operatorTokenName() === '?-') {
+          this.advance();
+          this.parseQuad(quadId, line, accept);
+          continue;
+        }
+        restoreHeadState();
+        head = this.parseTerm(3);
+      }
+
+      // Outside quad syntax, preserve the existing program-level comma rule,
+      // including the TS 13211-3 semicontext boundary.  This is deliberately
+      // not a grammar for quad ids.
       if (this.token.type === TOK.COMMA) {
         const items = [head];
         let extraCommaLine = null;
@@ -809,9 +843,6 @@ class Parser {
           this.advance();
           items.push(this.parseTerm(3));
         }
-        // Historically the program grammar admitted exactly one comma in a
-        // DCG semicontext.  Keep that boundary: the broader comma sequence is
-        // specifically the quad-label extension, not a new DCG syntax.
         if (extraCommaLine != null && this.operatorTokenName() !== '?-') {
           throw new Error(`parse line ${extraCommaLine}: expected ., got ,`);
         }

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';
@@ -278,8 +279,11 @@ why(
       },
     },
     {
-      name: 'quad labels accept multiple metadata fields and each answer description is independent',
+      name: 'quad ids use ordinary term syntax and each answer description is independent',
       run: () => {
+        // Issue #21: the first argument of ?-/2 is an ordinary Prolog term.
+        // The commas here are the normal priority-1000 comma operator, not a
+        // special metadata grammar owned by the quad parser.
         const source = `9, "✳54·43", passes
 ` +
           `?- X is 1+1.
@@ -297,14 +301,50 @@ why(
         const program = Program.parseSources([{ text: source, filename: 'issue-21.pl' }]);
         assertEqual(program.quads.length, 1, 'query group count');
         assertEqual(program.quads[0].answers.length, 4, 'answer-description count');
-        assertEqual(program.quads[0].id.name, ',', 'outer label comma');
-        assertEqual(program.quads[0].id.args[1].name, ',', 'right-associated label comma');
+        assertEqual(program.quads[0].id.name, ',', 'ordinary outer comma operator');
+        assertEqual(program.quads[0].id.args[1].name, ',', 'ordinary right-associated comma operator');
         const result = publicApi.runQuads(program);
         assertEqual(result.total, 4, 'answer-description total');
         assertEqual(result.passed, 4, 'answer-description passed');
         assertEqual(result.failed, 0, 'answer-description failed');
         assertEqual(result.stdout, 'quads: 4 run, 4 passed, 0 failed.\n', 'issue #21 report');
 
+        // No convention is imposed on the id term. Functional/list/curly and
+        // non-comma operator forms all go through the same ordinary term parser.
+        const ordinaryIds = Program.parse(
+          `meta(9, passes) ?- true.
+   true.
+` +
+          `[9, passes] ?- true.
+   true.
+` +
+          `{passes} ?- true.
+   true.
+` +
+          `(alpha ; beta) ?- true.
+   true.
+`,
+        );
+        assertEqual(ordinaryIds.quads.length, 4, 'ordinary id term count');
+        assertEqual(publicApi.runQuads(ordinaryIds).stdout, 'quads: 4 run, 4 passed, 0 failed.\n',
+          'ordinary id term report');
+
+        // Groundness is a quad semantic check, not source syntax. A bad id is
+        // reported as a test failure and processing continues to the next quad.
+        const nonGround = publicApi.runQuads(
+          `Id ?- true.
+   true.
+` +
+          `ok ?- true.
+   true.
+`,
+        );
+        assertEqual(nonGround.total, 2, 'non-ground id does not abort parsing');
+        assertEqual(nonGround.passed, 1, 'following quad still passes');
+        assertEqual(nonGround.failed, 1, 'non-ground id is a quad failure');
+        assertIncludes(nonGround.stdout, 'quads: BAD_ID Id, <input>:1', 'non-ground id diagnostic');
+        assertIncludes(nonGround.stdout, 'quads: 2 run, 1 passed, 1 failed.', 'non-ground continuation summary');
+
         const continuing = publicApi.runQuads(
           `case ?- X is 1+1.
    X = 3.
@@ -2443,6 +2483,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
@@ -5160,8 +5170,11 @@ 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.
+descriptions. `Label` itself is parsed with the ordinary Prolog term grammar:
+there is no quad-specific comma or metadata syntax. The runner requires the
+resulting first argument to be ground; if it is not, that quad is reported as
+`BAD_ID` and later quads are still processed. 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
@@ -6391,7 +6404,11 @@ colors ?- color(X).
 ```
 
 Run all quads in a file with `eyeprolog --quads file.pl` or `eyeprolog -q
-file.pl`. A label such as `colors` is optional. Loading the file normally only
+file.pl`. A label such as `colors` is optional. A label is not a separate
+mini-language: it is the ordinary first argument of `(?-)/2`, and therefore may
+be any Prolog term admitted there by the normal term grammar. Quad execution
+requires that argument to be ground; a non-ground label is reported as a quad
+failure rather than aborting source parsing. Loading the file normally only
 records its quads; it does not execute them or add their queries and answers as
 program clauses. A quad run prints a summary and exits with status `1` when any
 description fails. Quad mode imports `library(prologue)` as a compatibility