eyeprolog 1.3.92 → 1.3.94

package/examples/book/README.md

@@ -250,3 +250,4 @@ npm run generate
 - [01-color.pl](chapter-40/01-color.pl) — Embedded quad tests
 - [02-program.pl](chapter-40/02-program.pl)
 - [03-program-2.pl](chapter-40/03-program-2.pl)
+- [04-program-3.pl](chapter-40/04-program-3.pl)

package/examples/book/chapter-40/02-program.pl

@@ -1,5 +1,6 @@
 % From The Art of EyeProlog, Chapter 40.
-?- read(X).
-   inputs("1."), X = 1, unexpected.
-   inputs("1."), peeks(" "), X = 1.
-   inputs("1. "), peeks(" "), X = 1, unexpected.
+?- dif(X,Y), X = a.
+   true, unexpected.
+   X = a, unexpected.
+   X = a, maybe.
+   maybe, unexpected.

package/examples/book/chapter-40/03-program-2.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 40.
-inf :- inf, inf.
-
-?- inf.
-   loops.
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.

package/examples/book/chapter-40/04-program-3.pl

@@ -0,0 +1,5 @@
+% From The Art of EyeProlog, Chapter 40.
+inf :- inf, inf.
+
+?- inf.
+   loops.

package/package.json

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

package/src/quads.js

@@ -1,6 +1,8 @@
 // Embedded quad tests: a query followed by one or more answer descriptions.
 // The syntax follows the portable "queries using answer descriptions" format
 // used by Trealla and the ISO Prolog working examples linked from issue #1.
+// A `maybe` annotation denotes a successful answer with residual constraints;
+// it does not relax the ordinary answer-substitution comparison.
 import {
   ATOM, COMPOUND, VAR, Env, atom, compound, copyResolved, deref,
   flattenConjunction, listFromItems, properListItems, termIsGround,
@@ -203,6 +205,7 @@ function describeLeaf(term) {
     sto: false,
     false: false,
     truth: false,
+    maybe: false,
     loops: false,
     waits: false,
     error: null,
@@ -218,6 +221,7 @@ function describeLeaf(term) {
       if (item.name === 'unexpected' || item.name === 'inattendue') leaf.unexpected = true;
       else if (item.name === '...' || item.name === 'ad_infinitum') leaf.more = true;
       else if (item.name === 'sto') leaf.sto = true;
+      else if (item.name === 'maybe') leaf.maybe = true;
       else if (item.name === 'loops') leaf.loops = true;
       else if (item.name === 'waits') leaf.waits = true;
       else if (item.name === 'other_answer_sequence') {
@@ -253,10 +257,11 @@ function describeLeaf(term) {
     if (isErrorDescription(item)) leaf.error = item;
     else leaf.malformed ??= item;
   }
-  leaf.hasExpectation = leaf.bindings.length > 0 || leaf.truth || leaf.false || leaf.loops || leaf.waits ||
+  leaf.hasExpectation = leaf.bindings.length > 0 || leaf.truth || leaf.false || leaf.maybe || leaf.loops || leaf.waits ||
     leaf.error != null || leaf.output != null;
   if (!leaf.hasExpectation && !leaf.more && !leaf.sto && leaf.unsupported == null) leaf.malformed ??= term;
   if ([leaf.false, leaf.truth, leaf.error != null].filter(Boolean).length > 1) leaf.malformed ??= term;
+  if (leaf.maybe && (leaf.false || leaf.loops || leaf.waits || leaf.error != null)) leaf.malformed ??= term;
   return leaf;
 }
 
@@ -386,9 +391,26 @@ function matchLeaf(program, query, leaf, actual, position) {
   }
   const solution = actual.solutions[position];
   if (!solution || !outputMatches(program, leaf.output, solution.output)) return false;
+  // Portable answer descriptions distinguish plain success from success with
+  // residual constraints. `maybe` requires at least one pending residue, while
+  // its absence requires an unconstrained answer. In either case the stated
+  // substitutions remain exact and are checked below.
+  if (leaf.maybe !== hasPendingConstraints(solution.env)) return false;
   return substitutionMatches(query, leaf.bindings, solution.env);
 }
 
+function hasPendingConstraints(env) {
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    if (constraint.status?.(env) === 'pending') return true;
+  }
+  // Prolog attributed variables and delayed goals are the other residual-state
+  // mechanisms exposed by call_residue_vars/2. Treat either as pending residue
+  // even when a library does not provide a printable projection goal.
+  if ((env.attributedVariableNames?.() ?? []).length > 0) return true;
+  if ((env.delayedVariableNames?.() ?? []).length > 0) return true;
+  return false;
+}
+
 function descriptionDeclaresSto(description) {
   return splitOperator(description, '|').some((alternative) =>
     splitOperator(alternative, ';').some((term) => describeLeaf(term).sto));

package/src/solver.js

@@ -524,14 +524,21 @@ export class Solver {
         if (this.solutionsSeen >= this.solutionLimit) break;
 
         const pendingAttributeGoals = env.takePendingAttributeGoals?.() ?? [];
-        if (pendingAttributeGoals.length > 0) goals = [...pendingAttributeGoals, ...goals];
+        if (pendingAttributeGoals.length > 0) {
+          // Goals produced by verify_attributes/3 are invoked by the attribute
+          // mechanism, not textually spliced into the caller.  Give every
+          // awakened goal the same opaque cut boundary as call/1 so a delayed
+          // cut cannot prune choices that were made before the suspension.
+          const awakened = pendingAttributeGoals.map((pending) => compound('call', [pending]));
+          goals = [...awakened, ...goals];
+        }
 
         const readyDelays = env.takeReadyDelays();
         if (readyDelays.length > 0) {
           const awakened = readyDelays.map(({ goal, module }) => {
             const delayed = copyResolved(goal, env);
             qualifyTerm(delayed, module);
-            return delayed;
+            return compound('call', [delayed]);
           });
           goals = [...awakened, ...goals];
         }

package/test/run-regression.mjs

@@ -1990,6 +1990,22 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'wake(ready, awake).\n', 'freeze answer');
       },
     },
+    {
+      name: 'Prologue freeze keeps awakened cuts inside the delayed call (issue #81)',
+      run: () => {
+        const result = publicApi.runQuads(`:- use_module(library(prologue)).
+38
+?- call( ( (Y=1;Y=2), freeze(X,!), X = c ) ); Y = 3.
+   Y = 1, X = c
+;  Y = 2, X = c
+;  Y = 3.
+`);
+        assertEqual(result.total, 1, 'quad total');
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'runQuads covers the remaining finite Prologue examples and arities',
       run: () => {
@@ -2005,6 +2021,25 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 37 run, 37 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads maybe requires pending constraints without weakening substitutions (issue #80)',
+      run: () => {
+        const result = publicApi.runQuads(`37
+?- dif(X,Y), X = a.
+   true, unexpected.
+   X = a, unexpected.
+   X = a, maybe.
+   maybe, unexpected.
+
+?- X = a.
+   X = a, maybe, unexpected.
+`);
+        assertEqual(result.total, 5, 'quad total');
+        assertEqual(result.passed, 5, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 5 run, 5 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'runQuads rejects malformed answer substitutions',
       run: () => {
@@ -3234,22 +3269,18 @@ c4 ?- call((!;1)).
     {
       name: 'REPL releases terminal signals while a query computes',
       run: () => {
-        if (process.platform === 'win32') return;
-        const available = spawnSync('sh', ['-c',
-          'command -v script >/dev/null 2>&1 && script --version 2>/dev/null | grep -qi util-linux']);
-        if (available.status !== 0) return;
-        const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
-        const scriptCommand =
-          `{ printf 'repeat, fail.\n'; sleep 0.2; printf '\\003'; } | ` +
-          `script -qefc ${shellQuote(command)} /dev/null`;
-        const result = spawnSync('sh', ['-c', scriptCommand], {
-          cwd: packageRoot,
-          encoding: 'utf8',
-          timeout: 3000,
-        });
+        if (!hasUtilLinuxScript()) return;
+        // Synchronize on output produced from inside the solver instead of a
+        // fixed sleep: on a loaded host Ctrl-C could otherwise arrive before
+        // the query starts, leaving repeat/fail to run until the test timeout.
+        const result = runScriptedRepl([
+          { waitFor: '?- ', send: 'put_code(82), put_code(69), put_code(65), put_code(68), put_code(89), repeat, fail.\n' },
+          { waitFor: 'READY', send: '\u0003' },
+        ]);
         assertEqual(result.error?.code, undefined, 'terminal interrupt timeout');
         assertEqual(result.status, 130, 'SIGINT exit status');
-        assertIncludes(result.stdout, '?- repeat, fail.', 'terminal query echo');
+        assertIncludes(result.stdout, '?- put_code(82), put_code(69), put_code(65), put_code(68), put_code(89), repeat, fail.', 'terminal query echo');
+        assertIncludes(result.stdout, 'READY', 'query entered computation');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -6283,7 +6283,11 @@ private helpers and same-named predicates in different modules separate.
 `freeze(?Term,:Goal)` runs `Goal` immediately when `Term` is already nonvariable;
 otherwise it delays the goal until `Term` becomes nonvariable. Suspensions are
 kept in the logical environment, so bindings and backtracking remain isolated
-between solution branches.
+between solution branches. When a suspension wakes, its goal is meta-invoked
+with its own cut scope: a `!` inside the delayed goal may commit choices made by
+that invocation, but it cannot prune alternatives that were created before the
+`freeze/2` call. Thus `call(((Y=1;Y=2),freeze(X,!),X=c));Y=3` retains the three
+answers `Y=1`, `Y=2`, and `Y=3`.
 
 `dif(?Left,?Right)` posts a delayed finite-tree disequality when its arguments
 can still unify. Its residual store is normalized by logical implication:
@@ -7045,7 +7049,23 @@ is its synonym). Variables named in the query keep their identity inside answer
 descriptions; variables introduced only by a description are fresh. For example,
 a query `throw(g(X))` is described by `throw(g(_X))`, while
 `throw(g(X)), unexpected` verifies that ISO `throw/1` did not retain the query
-variable in the renamed exception term. `...` and `ad_infinitum` accept further answers. Multiple
+variable in the renamed exception term. `...` and `ad_infinitum` accept further answers. The `maybe` annotation describes
+a successful answer that still has at least one pending residual constraint. It
+does not stand for an arbitrary answer and it does not weaken substitution
+matching: `X = a, maybe` still requires the `X = a` substitution. Conversely, a
+successful answer description without `maybe` requires that no residual
+constraint remain. For example, a pending `dif/2` constraint can be checked as:
+
+```eyeprolog
+?- dif(X,Y), X = a.
+   true, unexpected.
+   X = a, unexpected.
+   X = a, maybe.
+   maybe, unexpected.
+```
+
+EyeProlog treats native variable constraints, attributed-variable residue, and
+delayed goals as pending residue for this purpose. Multiple
 indented descriptions after one query are independent checks: each re-runs the
 query, each is counted in the `quads:` summary, and a failing description does
 not suppress later descriptions for that query. `inputs/1` supplies and checks