eyeprolog 1.3.39 → 1.3.41

package/test/run-regression.mjs

@@ -1333,6 +1333,24 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'quad recursion-cycle evidence consistently refutes finite failure (issue #58 comment 5381101420)',
+      run: () => {
+        const result = publicApi.runQuads(`inf :- inf, inf.
+
+23
+?- inf.
+   loops.
+   false.
+`);
+        assertEqual(result.total, 2, 'quad total');
+        assertEqual(result.passed, 1, 'loops passed');
+        assertEqual(result.failed, 1, 'false failed');
+        assertEqual(result.undecided, 0, 'no undecided result');
+        assertIncludes(result.stdout, 'expected: false.', 'finite failure diagnostic');
+        assertNotIncludes(result.stdout, 'undecided: recursion cycle encountered.', 'cycle is decisive');
+      },
+    },
     {
       name: 'quad search-budget exhaustion is undecided rather than loops or failure (issue #58)',
       run: () => {
@@ -1383,6 +1401,21 @@ c4 ?- call((!;1)).
         assertIncludes(nsto.stdout, 'quads: FAILED 34, <input>:1', 'NSTO diagnostic');
       },
     },
+    {
+      name: 'quads peeks/1 supplies one unconsumed look-ahead character (issue #62)',
+      run: () => {
+        const result = publicApi.runQuads(`29
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.
+`);
+        assertEqual(result.total, 3, 'quad total');
+        assertEqual(result.passed, 3, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 3 run, 3 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'outputs/1 accepts DCG bodies over captured characters (issue #59)',
       run: () => {
@@ -3282,6 +3315,28 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         }
       },
     },
+    {
+      name: 'read and read_term report invalid UTF-8 as representation_error(character) (issue #64)',
+      run: () => {
+        const invalidPath = path.join(tmp, `read-invalid-utf8-${++tmpCounter}.bin`);
+        fs.writeFileSync(invalidPath, Buffer.from([0xff]));
+        const quotedPath = sourceAtom(invalidPath);
+        for (const goal of [
+          `open(${quotedPath}, read, S, []), read(S, C)`,
+          `open(${quotedPath}, read, S, []), read_term(S, C, [])`,
+          `open(${quotedPath}, read, S, []), set_input(S), read(C)`,
+          `open(${quotedPath}, read, S, []), set_input(S), read_term(C, [])`,
+        ]) {
+          let caught = null;
+          try {
+            run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          assertEqual(caught?.formal, 'representation_error(character)', `${goal} invalid UTF-8`);
+        }
+      },
+    },
     {
       name: 'writeq gives unnamed variables underscore-prefixed names (issue #53)',
       run: () => {
@@ -3310,6 +3365,13 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         );
       },
     },
+    {
+      name: 'writeq separates operators only where lexical ambiguity requires it (issue #63)',
+      run: () => {
+        const source = "emit :- writeq(1+2), put_char('|'), writeq(a+ -b), put_char('|'), writeq(a+b*c), nl.\n";
+        assertEqual(run(source, { goal: 'emit' }).stdout, '1+2|a+ -b|a+b*c\nemit.\n', 'minimal operator spacing');
+      },
+    },
     {
       name: 'write predicates and write_term options select distinct formats',
       run: () => {
@@ -3332,7 +3394,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         ].join('\n');
         assertEqual(
           run(source, { goal: 'emit' }).stdout,
-          "hello world|'hello world'|a + b * c|+(a,*(b,c))|hello world|'hello world'|+(a,b)|a + b|A|$VAR(0)|pair(Left,Right)|\"ab\"|[a,b]emit.\n",
+          "hello world|'hello world'|a+b*c|+(a,*(b,c))|hello world|'hello world'|+(a,b)|a+b|A|$VAR(0)|pair(Left,Right)|\"ab\"|[a,b]emit.\n",
           'stdout',
         );
       },

package/the-art-of-eyeprolog.md

@@ -5412,8 +5412,11 @@ where needed, and `write_canonical/1-2` exposes canonical structure. Dotted
 graphic atoms do not need quotes merely because they contain a period:
 `writeq(./*)`, `writeq(.*)`, and `writeq(...*)` output `./*`, `.*`, and `...*`
 respectively. ISO term output uses only the separator characters needed by the
-syntax, so functional arguments and list elements are emitted compactly; for
-example `writeq([a,b])` outputs `[a,b]`.
+syntax, so functional arguments, list elements, and operator applications are
+emitted compactly when no lexical ambiguity would arise. For example,
+`writeq([a,b])` outputs `[a,b]` and `writeq(1+2)` outputs `1+2`; a separator is
+still retained where adjacent graphic tokens would otherwise merge, as in
+`a+ -b`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`.
 
@@ -6891,31 +6894,88 @@ variable in the renamed exception term. `...` and `ad_infinitum` accept further
 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
-consumed characters. `outputs/1` checks characters emitted while reaching the
-described answer or error, including output produced before a later exception.
-Its argument may be an exact character list/string or a DCG body: terminal
-sequences, conjunction/disjunction, `...`/`ad_infinitum` sequence wildcards,
-and user-defined DCG nonterminals are matched against the captured characters.
-Following Trealla's quad convention, `sto` declares that the query is subject
-to occurs-check; the answer portion of an `sto`-annotated leaf remains
-implementation-dependent and is not compared. EyeProlog can nevertheless check
-some of the declaration without a second execution: the normal finite-tree
-unifier records a concrete occurs-check event as positive STO evidence. A
-naturally completed finite execution with no such event disproves `sto` (so
-`?- true. sto.` fails), while a search/resource boundary leaves the declaration
-conservatively unchecked. When the same quad declares STO and an occurs-check
-event is observed, an unannotated `unexpected` leaf does not reject an outcome
-that is implementation-dependent precisely because the query is STO. This is
-partial STO detection, not a decision procedure for the full STO/NSTO property.
-`loops` explicitly asks for bounded nontermination evidence and accepts direct
-active-variant cycle evidence from EyeProlog's normal recursion guard, with the
-loop depth/inference bounds as a fallback. Ordinary quad descriptions also have
-a finite inference budget (100000 by default); exhausting it does **not** mean
-`loops` or `false`, but produces an `UNDECIDED` result. The JavaScript API may
-override this with `quadMaxInferences`, while `loopMaxDepth` and
-`loopMaxInferences` control the explicit `loops` probe. The advanced stream
-annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
-annotation, are not executed by the current runner.
+exactly the characters consumed by the query. `peeks/1` may add one character
+that is available for look-ahead but must remain unconsumed. The runner puts an
+invalid-character sentinel immediately after the declared input boundary, so a
+reader cannot accidentally use an artificial end-of-file to decide that a full
+stop terminates the term. For example:
+
+```eyeprolog
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.
+```
+
+`outputs/1` checks characters emitted while reaching the described answer or
+error, including output produced before a later exception. Its argument may be
+an exact character list/string or a DCG body: terminal sequences,
+conjunction/disjunction, `...`/`ad_infinitum` sequence wildcards, and
+user-defined DCG nonterminals are matched against the captured characters.
+The `waits` and unordered `other_answer_sequence` annotations are not executed
+by the current runner.
+
+#### STO, loops, and undecided quad results
+
+Following Trealla's quad convention, `sto` declares that a query is subject to
+occurs-check. EyeProlog checks this conservatively rather than attempting a
+complete STO/NSTO decision procedure. During the query's ordinary execution,
+the finite-tree unifier records a concrete occurs-check event as positive STO
+evidence; the query is not run a second time merely to probe STO-ness. A finite
+execution that completes naturally without such an event disproves `sto`, while
+a search or resource boundary leaves the declaration conservatively unchecked.
+The answer portion of an `sto`-annotated leaf remains implementation-dependent
+and is therefore not compared.
+
+For example, the cyclic binding in the first query provides positive STO
+evidence, whereas the second query is finite and cannot be STO:
+
+```eyeprolog
+?- X = s(X).
+   X = ..., unexpected.
+   false, unexpected.
+   sto, false
+|  sto, true.
+
+?- true.
+   sto.                  % fails: no STO evidence
+```
+
+When a quad declares STO and the execution observes an occurs-check event, an
+unannotated `unexpected` leaf does not reject the implementation-dependent
+finite-tree outcome. This is partial STO detection only: EyeProlog makes a
+definite statement where execution provides definite evidence and otherwise
+does not guess.
+
+`loops` is kept distinct from merely exhausting the quad runner's resources.
+EyeProlog accepts structural nontermination evidence such as an active-variant
+recursion cycle, with the loop depth/inference bounds as a bounded fallback. A
+structural cycle is also strong enough to refute a finite `false` description;
+it is not reported as undecided merely because the same query was checked by a
+different answer description:
+
+```eyeprolog
+inf :- inf, inf.
+
+?- inf.
+   loops.
+```
+
+Ordinary answer descriptions also have a finite inference budget (100000 by
+default). Exhausting that budget does **not** establish `loops` and does not
+turn an unfinished search into `false`; instead the description is reported as
+`UNDECIDED`, for example:
+
+```text
+quads: UNDECIDED expensive_case, program.pl:12
+   undecided: inference limit reached.
+```
+
+Thus quad execution has three useful outcomes: passed, failed, and undecided.
+When there are no failures but at least one undecided description, the CLI exits
+with status `2`. The JavaScript API may override the ordinary search budget with
+`quadMaxInferences`; `loopMaxDepth` and `loopMaxInferences` control the explicit
+`loops` probe.
 
 The JavaScript API exposes the same operation without process I/O: