eyeprolog 1.3.17 → 1.3.19

package/package.json

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

package/src/iso.js

@@ -1370,6 +1370,7 @@ function writeBuiltin(mode) {
     const options = defaultTermWriteOptions(mode);
     solver.io.writeUnit(stream, formatTermForWrite(goal.args[goal.arity - 1], env, {
       ...options,
+      generateVariableNames: true,
       operators: solver.program.operators.values(),
     }));
     yield env;
@@ -1386,6 +1387,7 @@ function* writeTermBuiltin({ solver, goal, env }) {
   }
   solver.io.writeUnit(stream, formatTermForWrite(goal.args[goal.arity - 2], env, {
     ...options,
+    generateVariableNames: true,
     operators: solver.program.operators.values(),
   }));
   yield env;

package/src/write.js

@@ -174,6 +174,40 @@ function printableReadVariableNames(term, env, explicit) {
   return names;
 }
 
+function generatedVariableName(index) {
+  const letter = String.fromCharCode(65 + (index % 26));
+  const suffix = Math.floor(index / 26);
+  return suffix === 0 ? `_${letter}` : `_${letter}${suffix}`;
+}
+
+function printableGeneratedVariableNames(term, env, explicit) {
+  const names = new Map(explicit);
+  const used = new Set(names.values());
+  const seenVariables = new Set();
+  const seenTerms = new Set();
+  const stack = [term];
+  let generated = 0;
+
+  while (stack.length) {
+    const current = deref(stack.pop(), env);
+    if (current.type === VAR) {
+      if (seenVariables.has(current.name)) continue;
+      seenVariables.add(current.name);
+      if (names.has(current.name)) continue;
+      let candidate;
+      do candidate = generatedVariableName(generated++); while (used.has(candidate));
+      names.set(current.name, candidate);
+      used.add(candidate);
+      continue;
+    }
+    if (current.type !== COMPOUND || seenTerms.has(current)) continue;
+    seenTerms.add(current);
+    for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
+  }
+
+  return names;
+}
+
 function format(term, env, options, table, maxPriority = 1200, context = 'term') {
   const resolved = deref(term, env);
   if (resolved.type === VAR) {
@@ -282,7 +316,9 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     ignoreOps: options.ignoreOps === true,
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
-    variableNames: printableReadVariableNames(term, env, explicitVariableNames),
+    variableNames: options.generateVariableNames === true
+      ? printableGeneratedVariableNames(term, env, explicitVariableNames)
+      : printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
     dottedGraphicAtoms: options.dottedGraphicAtoms === true,

package/test/conformance/wg17-syntax-cases.json

@@ -4128,7 +4128,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "+(__anon0,__anon1)",
+            "output": "+(_A,_B)",
             "variables": "[]"
           }
         ]
@@ -4144,7 +4144,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "+(B,B)",
+            "output": "+(_A,_A)",
             "variables": "['B' = B]"
           }
         ]
@@ -5221,7 +5221,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "1 is __anon0",
+            "output": "1 is _A",
             "variables": "[]"
           }
         ]

package/test/run-regression.mjs

@@ -1860,7 +1860,7 @@ c4 ?- call((!;1)).
           'check :- read(A), read(B), A \\== B, write_canonical(pair(A, B)), nl.\n',
           { goal: 'check', ioOptions: { input: 'V.\nV.\n' } },
         );
-        assertEqual(distinctReads.stdout, 'pair(V,V_1)\ncheck.\n', 'separate read variable sets');
+        assertEqual(distinctReads.stdout, 'pair(_A,_B)\ncheck.\n', 'separate read variable sets');
       },
     },
     {
@@ -2189,7 +2189,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
     {
       name: 'npm exec can run package CLI bin from checkout',
       run: () => {
-        const result = spawnSync('npm', ['exec', '--loglevel=silent', '--yes', '--package=.', '--', 'eyeprolog', '--version'], {
+        const result = spawnSync('npm', ['exec', '--offline', '--loglevel=silent', '--yes', '--package=.', '--', 'eyeprolog', '--version'], {
           cwd: packageRoot,
           encoding: 'utf8',
           env: { ...process.env, npm_config_update_notifier: 'false' },
@@ -2975,6 +2975,20 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         }
       },
     },
+    {
+      name: 'writeq gives unnamed variables underscore-prefixed names (issue #53)',
+      run: () => {
+        const result = runCli([], {
+          input: "writeq(E).\nwriteq(pair(X,X,Y)).\nwrite_term(pair(X,Y), [variable_names(['Left'=X])]).\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout, '  _A true.\n', 'single unnamed variable');
+        assertIncludes(result.stdout, '  pair(_A,_A,_B) true.\n', 'stable repeated variable names');
+        assertIncludes(result.stdout, '  pair(Left,_A) true.\n', 'explicit variable name plus generated fallback');
+        const fresh = run('emit :- writeq(E), nl.\n', { goal: 'emit' });
+        assertEqual(fresh.stdout, '_A\nemit.\n', 'fresh clause variable hides its internal suffix');
+      },
+    },
     {
       name: 'write predicates and write_term options select distinct formats',
       run: () => {
@@ -3783,30 +3797,30 @@ answer(ok) :-
         `;
         const script = `
           import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
-          const program = Program.parse(${JSON.stringify(programText)}, { autoloadGoals: ['ti(R,3,0)'] });
+          const program = Program.parse(${JSON.stringify(programText)}, { autoloadGoals: ['ti(R,1,0)'] });
           const listTailGroup = program.findGroup('...', 2, 'user');
           if (listTailGroup?.listTailRecursive !== true) {
             throw new Error('recursive DCG tail-consumption was not recognized');
           }
           const solver = new Solver(program, { registry: getEyePrologRegistry(), maxMemoryBytes: Infinity });
-          const goal = parseGoalText('ti(R,3,0)', {
+          const goal = parseGoalText('ti(R,1,0)', {
             doubleQuotes: 'chars',
             operatorDefinitions: [...program.operators.values()],
           });
           let count = 0;
           for (const _ of solver.solve([goal], new Env(), 0)) {
-            if (++count === 20) break;
+            if (++count === 10) break;
           }
-          if (count !== 20) throw new Error('unexpected checkpoint count: ' + count);
+          if (count !== 10) throw new Error('unexpected checkpoint count: ' + count);
           const scope = solver.innerTableScopes.get('phrase');
           if (scope == null) throw new Error('missing phrase table scope');
           if (scope.memo.size !== 0) throw new Error('distinct tail-DCG inputs should not retain phrase tables: ' + scope.memo.size);
           process.stdout.write(count + ':' + scope.memo.size);
         `;
         const result = spawnSync(process.execPath, [
-          // This corresponds to 20,000 accepted number candidates. Before the
-          // phrase-local cache, every distinct recursive DCG tail stayed rooted
-          // in the caller memo and this workload exhausted a 32 MiB old space.
+          // This covers 100 accepted number candidates, enough to exercise
+          // many distinct recursive DCG inputs while keeping this a focused
+          // bounded-cache regression rather than a memory stress benchmark.
           '--max-old-space-size=32',
           '--input-type=module',
           '--eval',
@@ -3815,7 +3829,7 @@ answer(ok) :-
         if (result.error) throw result.error;
         assertEqual(result.status, 0, `bounded phrase-table child status; stderr=${result.stderr}`);
         const [countText, cacheText] = result.stdout.trim().split(':');
-        assertEqual(countText, '20', 'recursive phrase checkpoints');
+        assertEqual(countText, '10', 'recursive phrase checkpoints');
         assertEqual(cacheText, '0', 'distinct tail-DCG phrase cache');
       },
     },

package/test/run-wg17.mjs

@@ -18,7 +18,7 @@ function runnerStage(index, maximum) {
   return `read_term(G${index}, [variable_names(V${index})]), ` +
     `(G${index} == end_of_file -> write('\\n<WG17-COMPLETE>') ; (` +
     `write('\\n<WG17-BEGIN-${index}>'), call(G${index}), ` +
-    `write('<WG17-VARS>'), writeq(V${index}), write('<WG17-END>'), ` +
+    `write('<WG17-VARS>'), write_term(V${index}, [quoted(true), variable_names(V${index})]), write('<WG17-END>'), ` +
     `${runnerStage(index + 1, maximum)}))`;
 }