eyeprolog 1.3.71 → 1.3.72

package/README.md

@@ -151,7 +151,9 @@ top level includes pending `dif/2` goals in residual answers. See
 
 `library(atts)` exposes Scryer-style attributed-variable operations on the same
 persistent `Env` machinery used by `dif/2`: `put_atts/2`, `get_atts/2`,
-`put_attr/3`, `get_attr/3`, `del_attr/2`, and `term_attributed_variables/2`.
+`put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2`, and
+`call_residue_vars/2`. The latter reports variables whose residual attributes or
+constraints were created or modified by a goal, including native `dif/2` residues.
 `:- attribute ...` declarations are accepted, `verify_attributes/3` runs before
 an attributed binding is committed, and the hook's returned goals run after
 that binding. Attribute state follows variable representatives and ordinary
@@ -359,7 +361,8 @@ lambda syntax also changes the active operator table.
 Outside `--iso-strict`, an otherwise undefined unqualified call may autoload a
 predicate only when the interop profile has one canonical EyeProlog provider.
 For example, `member/2` autoloads from `library(lists)`, `call_nth/2` from
-`library(iso_ext)`, and `between/3` from EyeProlog's internal
+`library(iso_ext)`, `call_residue_vars/2` from `library(atts)`, and `between/3`
+from EyeProlog's internal
 `library(prologue)` implementation. Use `--no-autoload` to disable this
 convenience. Strict ISO mode never autoloads library predicates.
 

package/examples/dif-constraints.pl

@@ -11,8 +11,8 @@ allowed_pair(X, Y) :-
     X = left,
     Y = right.
 
-% The structural constraint remains pending after X=Y. Binding both to 1
-% then proves X-Y and 1-2 different, so the constraint is discharged.
+% X=Y already proves X-Y and 1-2 different: X-X cannot unify with 1-2,
+% so the dif/2 constraint is discharged before the final specialization Y=1.
 specialization(X, Y) :-
     dif(X-Y, 1-2),
     X = Y,

package/package.json

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

package/src/iso.js

@@ -165,6 +165,7 @@ export const isoBuiltins = {
 export const eyePrologLibraryBuiltins = {
   register(registry) {
     registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__call_residue_vars', 2, callResidueVarsBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__countall', 2, countAllBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__freeze', 2, freezeBuiltin, { eyePrologLibrary: true });
     registry.add('dif', 2, difBuiltin, { deterministic: true, eyePrologLibrary: true });
@@ -2497,6 +2498,79 @@ function* callNthBuiltin({ solver, goal, env }) {
   }
 }
 
+function residueSnapshot(env) {
+  const attributes = new Map();
+  for (const name of env.attributedVariableNames?.() ?? []) {
+    attributes.set(name, env.prologAttributes(name));
+  }
+  const delays = new Map();
+  for (const name of env.delayedVariableNames?.() ?? []) {
+    delays.set(name, env.delayedGoals(name));
+  }
+  const constraints = new Map();
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    constraints.set(constraint, [...constraint.variables(env)]);
+  }
+  return { attributes, delays, constraints };
+}
+
+function sameAttributeEntries(before, after) {
+  if (before == null || before.length !== after.length) return false;
+  for (let i = 0; i < after.length; i++) {
+    if (before[i].module !== after[i].module || before[i].attribute !== after[i].attribute) return false;
+  }
+  return true;
+}
+
+function sameDelayEntries(before, after) {
+  if (before == null || before.length !== after.length) return false;
+  for (let i = 0; i < after.length; i++) if (before[i] !== after[i]) return false;
+  return true;
+}
+
+function residueVariablesSince(snapshot, env) {
+  const names = [];
+  const seen = new Set();
+  const add = (name) => {
+    const root = deref(variable(name), env);
+    if (root.type !== VAR || seen.has(root.name)) return;
+    seen.add(root.name);
+    names.push(root);
+  };
+
+  for (const name of env.attributedVariableNames?.() ?? []) {
+    const after = env.prologAttributes(name);
+    if (!sameAttributeEntries(snapshot.attributes.get(name), after)) add(name);
+  }
+  for (const name of env.delayedVariableNames?.() ?? []) {
+    const after = env.delayedGoals(name);
+    if (!sameDelayEntries(snapshot.delays.get(name), after)) add(name);
+  }
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    const after = [...constraint.variables(env)];
+    const before = snapshot.constraints.get(constraint);
+    const unchanged = before != null && before.length === after.length && before.every((name, index) => name === after[index]);
+    if (unchanged) continue;
+    for (const name of after) add(name);
+  }
+  return names;
+}
+
+function* callResidueVarsBuiltin({ solver, goal, env }) {
+  const invoked = callable(goal.args[0], env);
+  if (invoked.module == null) invoked.module = goal.module ?? 'user';
+  const snapshot = residueSnapshot(env);
+  const child = solver.cloneForInnerGoal();
+  try {
+    for (const answerEnv of child.solve([invoked], env, 0)) {
+      const next = answerEnv.clone();
+      if (unify(goal.args[1], listFromItems(residueVariablesSince(snapshot, answerEnv)), next)) yield next;
+    }
+  } finally {
+    solver.absorbStatsFrom(child);
+  }
+}
+
 function* freezeBuiltin({ solver, goal, env }) {
   const watched = deref(goal.args[0], env);
   if (watched.type !== VAR) {

package/src/lib/atts.pl

@@ -12,9 +12,14 @@
     put_attr/3,
     get_attr/3,
     del_attr/2,
-    term_attributed_variables/2
+    term_attributed_variables/2,
+    call_residue_vars/2
 ]).
 :- op(1199, fx, attribute).
+:- meta_predicate(call_residue_vars(0, '?')).
 
 term_attributed_variables(Term, Variables) :-
     '$term_attributed_variables'(Term, Variables).
+
+call_residue_vars(Goal, Variables) :-
+    eyeprolog__call_residue_vars(Goal, Variables).

package/src/repl.js

@@ -672,18 +672,18 @@ async function solveQuery(engine, state, goal, reader, output) {
 }
 
 function pullSolution(solver, solutions, reader) {
-  const stream = solver.io.resolve('user_output');
-  const originalWrite = stream?.write;
-  let captured = '';
-  if (stream) stream.write = (text) => { captured += String(text); };
+  // Prolog output is an observable side effect of execution, so never hold it
+  // until the search reaches its next leaf. In particular an infinite search
+  // that periodically writes progress must remain observable at the terminal.
+  // Completed queries keep the same byte order because user_output writes are
+  // synchronous and occur before solutions.next() returns its answer.
   const suspended = reader.suspendForComputation();
   try {
-    return { result: solutions.next(), output: captured };
+    return { result: solutions.next(), output: '' };
   } catch (error) {
-    return { error, output: captured };
+    return { error, output: '' };
   } finally {
     reader.resumeAfterComputation(suspended);
-    if (stream) stream.write = originalWrite;
   }
 }
 

package/src/standard-library.js

@@ -63,7 +63,7 @@ function libraryUrl(filename) {
 
 export const eyePrologNativeLibraryIndicators = Object.freeze([
   'call_nth/2', 'freeze/2', 'dif/2', 'countall/2', 'time/1',
-  'put_atts/2', 'get_atts/2', 'put_attr/3', 'get_attr/3', 'del_attr/2', 'term_attributed_variables/2',
+  'put_atts/2', 'get_atts/2', 'put_attr/3', 'get_attr/3', 'del_attr/2', 'term_attributed_variables/2', 'call_residue_vars/2',
   '#>/2', '#</2', '#>=/2', '#=</2', '#=/2', '#\\=/2', '#\\/1',
   '#<==>/2', '#==>/2', '#<==/2', '#\\//2', '#\\/2', '#/\\/2',
   'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',
@@ -133,6 +133,9 @@ export const eyePrologInteropAutoload = Object.freeze({
   // it from library(iso_ext), matching the explicit Scryer import while still
   // allowing Trealla-style unqualified source to use the same autoload entry.
   'call_nth/2': 'iso_ext',
+  // Scryer exposes call_residue_vars/2 from library(atts); autoload it for
+  // constraint-test source that uses the predicate without an explicit import.
+  'call_residue_vars/2': 'atts',
   // Trealla exposes time/1 as a meta timing predicate and library(iso_ext)
   // supplies ... //0. Autoload both so UWN's DCG hand-off benchmark runs
   // unchanged while their implementations remain outside the ISO core.

package/src/term.js

@@ -268,6 +268,28 @@ export class Env {
     delays.set(name, [...(delays.get(name) ?? []), { goal, module }]);
     this._delays = delays;
   }
+  delayedVariableNames() {
+    if (this._delays == null || this._delays.size === 0) return [];
+    const names = [];
+    const seen = new Set();
+    for (const name of this._delays.keys()) {
+      const root = deref(variable(name), this);
+      if (root.type !== VAR || seen.has(root.name)) continue;
+      seen.add(root.name);
+      names.push(root.name);
+    }
+    return names;
+  }
+  delayedGoals(name) {
+    const root = deref(variable(name), this);
+    if (root.type !== VAR || this._delays == null) return [];
+    const result = [];
+    for (const [source, goals] of this._delays) {
+      const current = deref(variable(source), this);
+      if (current.type === VAR && current.name === root.name) result.push(...goals);
+    }
+    return result;
+  }
   takeReadyDelays() {
     if (this._delays == null || this._delays.size === 0) return [];
     const ready = [];

package/test/run-regression.mjs

@@ -132,7 +132,7 @@ function regressionCases() {
     {
       name: 'library(atts) provides Scryer-style attributed-variable hooks',
       run: () => {
-        const source = `:- module(attr_probe, [check_get/0, check_alias/0, check_ok/0, check_bad/0, check_conflict/0, check_backtrack/0, check_term_vars/0]).
+        const source = `:- module(attr_probe, [check_get/0, check_alias/0, check_ok/0, check_bad/0, check_conflict/0, check_backtrack/0, check_term_vars/0, check_residue_new/0, check_residue_unchanged/0, check_residue_modified/0, check_residue_dif/0]).
 :- use_module(library(atts)).
 :- attribute mark/1.
 attach(X, V) :- put_atts(X, mark(V)).
@@ -151,6 +151,10 @@ check_bad :- attach(X, 3), X = 4.
 check_conflict :- attach(X, a), attach(Y, b), X = Y.
 check_backtrack :- (attach(X, a), fail ; true), \\+ get_atts(X, mark(_)).
 check_term_vars :- attach(X, a), term_attributed_variables(pair(X,Y), [X]), var(Y), X = a.
+check_residue_new :- call_residue_vars(attach(X, a), Vs), Vs = [X].
+check_residue_unchanged :- attach(X, a), call_residue_vars(true, Vs), Vs = [], X = a.
+check_residue_modified :- attach(X, a), call_residue_vars(put_atts(X, mark(b)), Vs), Vs = [X], X = b.
+check_residue_dif :- call_residue_vars(dif(X,Y), Vs), Vs = [X,Y].
 `;
         assertIncludes(run(source, { goal: 'attr_probe:check_get' }).stdout, 'attr_probe:check_get.', 'get_atts/2');
         assertIncludes(run(source, { goal: 'attr_probe:check_alias' }).stdout, 'attr_probe:check_alias.', 'attribute transfer on aliasing');
@@ -159,6 +163,20 @@ check_term_vars :- attach(X, a), term_attributed_variables(pair(X,Y), [X]), var(
         assertEqual(run(source, { goal: 'attr_probe:check_conflict' }).stdout, '', 'same-module attributes are verified before aliasing');
         assertIncludes(run(source, { goal: 'attr_probe:check_backtrack' }).stdout, 'attr_probe:check_backtrack.', 'attributes backtrack with Env branches');
         assertIncludes(run(source, { goal: 'attr_probe:check_term_vars' }).stdout, 'attr_probe:check_term_vars.', 'term_attributed_variables/2');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_new' }).stdout, 'attr_probe:check_residue_new.', 'call_residue_vars/2 reports newly attributed variables');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_unchanged' }).stdout, 'attr_probe:check_residue_unchanged.', 'call_residue_vars/2 ignores unchanged pre-existing attributes');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_modified' }).stdout, 'attr_probe:check_residue_modified.', 'call_residue_vars/2 reports modified attributes');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_dif' }).stdout, 'attr_probe:check_residue_dif.', 'call_residue_vars/2 includes native dif/2 residual variables');
+        const freezeResidue = `:- use_module(library(atts)).
+:- use_module(library(prologue), [freeze/2]).
+check :- call_residue_vars(freeze(X,true), Vs), Vs = [X].
+`;
+        assertIncludes(run(freezeResidue, { goal: 'check' }).stdout, 'check.', 'call_residue_vars/2 includes delayed freeze/2 variables');
+        const clpzResidue = `:- use_module(library(atts)).
+:- use_module(library(clpz)).
+check :- call_residue_vars(X in 1..3, Vs), Vs = [X].
+`;
+        assertIncludes(run(clpzResidue, { goal: 'check' }).stdout, 'check.', 'call_residue_vars/2 includes CLP(Z) attributed variables');
 
         const residualFile = path.join(tmp, `atts-residual-${++tmpCounter}.pl`);
         fs.writeFileSync(residualFile, `:- use_module(library(atts)).
@@ -2090,6 +2108,53 @@ c4 ?- call((!;1)).
         assertEqual(advanced.stderr, '', 'advanced stderr');
       },
     },
+    {
+      name: 'REPL exposes output side effects while search is still running (issue #72)',
+      run: () => {
+        const helper = `
+          import { spawn } from 'node:child_process';
+
+          const child = spawn(${JSON.stringify(process.execPath)}, [${JSON.stringify(bin)}], {
+            cwd: ${JSON.stringify(packageRoot)},
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          child.stdout.setEncoding('utf8');
+          child.stderr.setEncoding('utf8');
+          let stdout = '';
+          let stderr = '';
+          child.stdout.on('data', (text) => { stdout += text; });
+          child.stderr.on('data', (text) => { stderr += text; });
+
+          async function waitFor(predicate, label) {
+            const deadline = Date.now() + 5000;
+            while (!predicate()) {
+              if (Date.now() >= deadline) {
+                child.kill('SIGKILL');
+                throw new Error(label + ' timeout; stdout=' + JSON.stringify(stdout) + '; stderr=' + JSON.stringify(stderr));
+              }
+              await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+          }
+
+          child.stdin.write('use_module(library(iso_ext)).\\n');
+          await waitFor(() => stdout.includes('   true.\\n?- '), 'module import');
+          child.stdin.write('call_nth(repeat,Nth), (Nth mod 2=:=0->writeq(r(Nth)),nl;true),Nth<0.\\n');
+          await waitFor(() => stdout.includes('r(2)\\nr(4)\\n'), 'progress output');
+          if (stdout.includes('false.')) throw new Error('infinite search unexpectedly reached a leaf');
+          child.kill('SIGKILL');
+          await new Promise((resolve) => child.once('exit', resolve));
+          process.stdout.write('progress-visible');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--input-type=module',
+          '--eval',
+          helper,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `progress helper status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'progress-visible', 'newline-terminated progress is visible before a leaf answer');
+      },
+    },
     {
       name: 'REPL bindings use argument syntax for operator atoms',
       run: () => {
@@ -4939,7 +5004,7 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 154, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(library.defs.size, 155, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
@@ -4956,21 +5021,23 @@ answer(ok) :-
         assertEqual(Boolean(library.get('call_cleanup', 2)), true, 'call_cleanup/2 is an EyeProlog cleanup control');
         assertEqual(registry.get('setup_call_cleanup', 3), null, 'setup_call_cleanup/3 is absent from the ISO registry');
         assertEqual(Boolean(library.get('setup_call_cleanup', 3)), true, 'setup_call_cleanup/3 is an EyeProlog cleanup control');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 48, 'public native EyeProlog builtin count');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 49, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 87, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 29, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 30, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext,lambda,atts', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
         assertEqual(eyePrologInteropAutoload['call_nth/2'], 'iso_ext', 'call_nth/2 canonical interop autoload');
+        assertEqual(eyePrologInteropAutoload['call_residue_vars/2'], 'atts', 'call_residue_vars/2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['time/1'], 'iso_ext', 'time/1 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['.../2'], 'iso_ext', '.../2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 48, 'native host library count');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 49, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 3).join(','), 'call_nth/2,freeze/2,dif/2', 'control and constraint predicates requiring host support');
-        assertEqual(eyePrologLibraryIndicators.length, 135, 'complete EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 136, 'complete EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
+        assertEqual(Boolean(library.get('eyeprolog__call_residue_vars', 2)), true, 'private call_residue_vars adapter is registered for EyeProlog');
         assertEqual(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');
         assertEqual(registry.get('eyeprolog__freeze', 2), null, 'private freeze adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__freeze', 2)), true, 'private freeze adapter is registered for EyeProlog');

package/the-art-of-eyeprolog.md

@@ -6253,7 +6253,7 @@ between solution branches.
 | Module | Exported predicate indicators |
 | --- | --- |
 | `library(aggregate)` | `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
-| `library(atts)` | `put_atts/2`, `get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2` |
+| `library(atts)` | `put_atts/2`, `get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2`, `call_residue_vars/2` |
 | `library(clpz)` | `#>/2`, `#</2`, `#>=/2`, `#=</2`, `#=/2`, `#\=/2`, `#\/1`, `#<==>/2`, `#==>/2`, `#<==/2`, `#\//2`, `#\/2`, `#/\/2`, `in/2`, `ins/2`, `all_different/1`, `all_distinct/1`, `nvalue/2`, `sum/3`, `scalar_product/4`, `tuples_in/2`, `labeling/2`, `label/1`, `indomain/1`, `lex_chain/1`, `serialized/2`, `global_cardinality/2`, `global_cardinality/3`, `circuit/1`, `chain/2`, `element/3`, `zcompare/3`, `fd_var/1`, `fd_inf/2`, `fd_sup/2`, `fd_size/2`, `fd_dom/2` |
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |