eyeprolog 1.5.34 → 1.5.35

package/package.json

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

package/src/parser.js

@@ -811,11 +811,14 @@ class Parser {
     let left = this.parsePrefixTerm(minPrecedence, allowBar, allowOperatorAtom);
     const leftIsBareOperatorAtom = initialWasCurrentOperator &&
       left.type === ATOM && left.name === initialOperatorName;
-    // Neumerkel syntax #379 (2026-09-03) pins a strict-ISO distinction for
-    // the processor-defined grammar-rule operator: `(-->)/2` is not an ISO
-    // predicate-indicator spelling.  Keep the ordinary profile permissive for
-    // existing DCG/module code; the moving ISO conformity gate runs strict.
-    if (this.strictIso && left.type === ATOM && left.name === '-->' &&
+    // Neumerkel syntax #379: the DCG rule operator `-->` is processor-defined
+    // and not an ISO predicate-indicator name.  A bare `-->` (not parenthesized)
+    // followed by `/` would be an invalid strict-ISO predicate indicator.
+    // However, `(-->)/2` is valid: the parentheses make `-->` an ordinary atom
+    // argument, and ISO 7.10.3 does not restrict which atoms may appear as the
+    // name in a Name/Arity indicator — only the write-term rules govern spelling.
+    // Only reject the bare-operator form so (-->)/2 succeeds per #379.
+    if (this.strictIso && leftIsBareOperatorAtom && left.name === '-->' &&
         this.operatorTokenName() === '/') {
       throw new Error(`parse line ${this.token.line}: operator atom --> is not permitted in a strict ISO predicate indicator`);
     }

package/src/program-analysis.js

@@ -8,7 +8,11 @@ import {
 
 export function componentHasNegativeEdge(start, deps, negativeEdges) {
   const forward = reachableIndexes(start, deps);
-  const component = new Set([...forward].filter((index) => reachableIndexes(index, deps).has(start)));
+  // A node is in the same SCC as `start` iff it can also reach `start`.
+  // Rather than calling reachableIndexes() per-node (O(n^2)), compute the
+  // reverse-reachability set from `start` over the transposed graph once.
+  const backward = reachableIndexesTransposed(start, deps, forward);
+  const component = new Set([...forward].filter((index) => backward.has(index)));
   return negativeEdges.some(([from, to]) => component.has(from) && component.has(to));
 }
 
@@ -27,7 +31,8 @@ export function clauseIsDirectRecursive(clause, group) {
 
 export function componentHasCut(start, deps, groups) {
   const forward = reachableIndexes(start, deps);
-  const component = [...forward].filter((index) => reachableIndexes(index, deps).has(start));
+  const backward = reachableIndexesTransposed(start, deps, forward);
+  const component = [...forward].filter((index) => backward.has(index));
   return component.some((index) => {
     const group = groups[index];
     const directRecursive = group.clauses.some((clause) => clauseIsDirectRecursive(clause, group));
@@ -50,6 +55,34 @@ export function reachableIndexes(start, deps) {
   return seen;
 }
 
+// Returns the set of nodes in `candidates` that can reach `target` by
+// traversing `deps` in reverse.  This is equivalent to asking which nodes
+// in the forward-reachable set from `target` also have `target` in their
+// own forward-reachable set, but computed in a single BFS over the
+// transposed graph rather than one BFS per candidate node.
+function reachableIndexesTransposed(target, deps, candidates) {
+  // Build a transposed adjacency list restricted to the candidate set.
+  const reverse = new Map();
+  for (const from of candidates) {
+    if (!reverse.has(from)) reverse.set(from, []);
+    for (const to of deps[from]) {
+      if (!candidates.has(to)) continue;
+      let bucket = reverse.get(to);
+      if (bucket == null) { bucket = []; reverse.set(to, bucket); }
+      bucket.push(from);
+    }
+  }
+  const seen = new Set();
+  const stack = [target];
+  while (stack.length) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    for (const prev of reverse.get(current) ?? []) if (!seen.has(prev)) stack.push(prev);
+  }
+  return seen;
+}
+
 
 export function isFiniteDatalogArgument(term) {
   return term?.type === VAR || term?.type === ATOM || term?.type === 'string' || term?.type === 'number';

package/src/solver.js

@@ -2,7 +2,7 @@
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
   ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
-  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
+  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList, isScalar,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
@@ -2692,11 +2692,14 @@ function matchScalarFact(goal, head, env) {
 
 function derefScalarMatch(term, env, names, values) {
   let current = term;
-  for (let guard = 0; current?.type === 'var' && guard < 128; guard++) {
+  const seen = new Set();
+  while (current?.type === 'var') {
+    if (seen.has(current.name)) break;
+    seen.add(current.name);
     const localIndex = names.indexOf(current.name);
-    if (localIndex >= 0) current = values[localIndex];
-    else if (env.has(current.name)) current = env.get(current.name);
-    else break;
+    if (localIndex >= 0) { current = values[localIndex]; continue; }
+    if (env.has(current.name)) { current = env.get(current.name); continue; }
+    break;
   }
   return current;
 }
@@ -3092,12 +3095,11 @@ function matchGroundBinaryClause(goal, clause) {
   return { nextGoal: compound(bodyGoal.name, bodyArgs) };
 }
 
-function isScalarTerm(term) {
-  return term && (term.type === 'atom' || term.type === 'string' || term.type === 'number');
-}
+// isScalar is imported from term.js; use it as the canonical scalar test.
+const isScalarTerm = isScalar;
 
 function sameScalarTerm(left, right) {
-  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type &&
+  return isScalar(left) && isScalar(right) && left.type === right.type &&
     (left.type === 'number' ? sameNumberValue(left.name, right.name) : left.name === right.name);
 }
 
@@ -3131,9 +3133,9 @@ function sameResolvedGroundTerm(left, right, env) {
 
 function groundChainKey(term) {
   if (term?.type === COMPOUND) {
-    let out = `${term.name}/${term.arity}`;
-    for (let i = 0; i < term.arity; i++) out += `${groundChainKey(term.args[i])}`;
-    return out;
+    const parts = [`${term.name}/${term.arity}`];
+    for (let i = 0; i < term.arity; i++) parts.push(groundChainKey(term.args[i]));
+    return parts.join('');
   }
   return `${term?.type ?? ''}:${term?.name ?? ''}`;
 }

package/src/write.js

@@ -5,7 +5,6 @@ import {
 } from './term.js';
 
 const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
-const dottedGraphicAtomCharacters = graphicAtomCharacters;
 const compactInfixOperators = new Set([':', '..']);
 
 function quotedControlEscape(ch) {
@@ -60,7 +59,7 @@ function writeAtom(name) {
 
 function isDottedGraphicAtom(name) {
   return name.includes('.') && [...name].some((ch) => ch !== '.') && !name.startsWith('/*') &&
-    [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
+    [...name].every((ch) => graphicAtomCharacters.has(ch));
 }
 
 function compactBoundaryNeedsSpace(left, right) {

package/test/run-neumerkel-tests.mjs

@@ -59,13 +59,16 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
     }
   });
 
-  reporter.test('latest strict syntax rejects Neumerkel #379 operator indicator', () => {
+  reporter.test('latest strict syntax allows Neumerkel #379 parenthesized --> atom', () => {
+    // Upstream Codex expectation for #379: writeq((-->)/2). -> (-->)/2
+    // (-->)/2 is valid: parentheses make --> an ordinary atom; only bare
+    // --> followed by / in a predicate indicator is processor-defined syntax.
     const item = {
       id: 379,
       query: 'writeq((-->)/2).',
       input: 'writeq((-->)/2).',
       readCount: 1,
-      expected: 'syntax err.',
+      expected: '(-->)/2',
     };
     const actual = executeWg17Item(item);
     if (!matchesUpstreamExpectation(item.expected, actual, item)) {

package/test/run-regression.mjs

@@ -1956,8 +1956,10 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'ISO predicate indicators require parentheses around operator atoms',
+      name: 'ISO predicate indicators require parentheses around bare operator atoms',
       run: () => {
+        // Bare --> /2 (without parens) is still rejected in all modes because
+        // --> is an infix/prefix operator atom that cannot appear as a bare operand.
         let caught = null;
         try {
           parseGoalText('writeq(--> /2)');
@@ -1966,20 +1968,22 @@ c4 ?- call((!;1)).
         }
         if (!caught) throw new Error('bare operator predicate indicator unexpectedly parsed');
         assertIncludes(caught.message, 'operator atom', 'bare indicator syntax rejection');
+        // (-->)/2 with parentheses is legal in both normal and strict ISO modes.
+        // Neumerkel #379: upstream Codex expectation is (-->)/2 -> (-->)/2 (success).
+        // Parentheses make --> an ordinary atom argument; ISO 7.10.3 does not
+        // restrict which atoms may appear as the name in a Name/Arity indicator.
         parseGoalText('writeq((-->)/2)');
         assertEqual(
           run('', { goal: 'writeq((-->)/2)' }).stdout,
           '(-->)/2writeq((-->) / 2).\n',
           'parenthesized operator indicator stays legal outside strict ISO',
         );
-        caught = null;
-        try {
-          parseGoalText('writeq((-->)/2)', { isoStrict: true });
-        } catch (error) {
-          caught = error;
-        }
-        if (!caught) throw new Error('Neumerkel #379 strict indicator unexpectedly parsed');
-        assertIncludes(caught.message, 'strict ISO predicate indicator', 'Neumerkel #379 strict syntax rejection');
+        parseGoalText('writeq((-->)/2)', { isoStrict: true });
+        assertEqual(
+          run('', { isoStrict: true, goal: 'writeq((-->)/2)' }).stdout,
+          '(-->)/2writeq((-->) / 2).\n',
+          'Neumerkel #379: parenthesized --> is legal in strict ISO',
+        );
       },
     },
     {