eyeprolog 1.3.39 → 1.3.41

package/README.md

@@ -91,6 +91,11 @@ execution as positive STO evidence, and rejects `sto` when a finite execution
 completes without such an event (for example `?- true. sto.`). If execution is
 cut short by a search/resource boundary, the STO claim remains conservatively
 unverified rather than being guessed.
+For nontermination expectations, `loops` is kept distinct from resource
+exhaustion: structural loop evidence may satisfy `loops`, while a bounded
+search that cannot establish the requested answer sequence is reported as
+`UNDECIDED`. In CLI quad mode, failures use exit status `1`; if there are no
+failures but at least one undecided quad, the exit status is `2`.
 
 ## Tabling and well-founded negation
 

package/examples/book/README.md

@@ -248,3 +248,5 @@ npm run generate
 ## Chapter 40: Running EyeProlog: command line and corpus
 
 - [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)

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

@@ -0,0 +1,5 @@
+% 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.

package/examples/book/chapter-40/03-program-2.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.39",
+  "version": "1.3.41",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/io.js

@@ -1,7 +1,7 @@
 // Synchronous ISO stream state shared by a solver and all of its inner solvers.
 import { BufferCtor, fs } from './platform.js';
 
-const INVALID_UTF8_SENTINEL = '\udc00';
+export const INVALID_UTF8_SENTINEL = '\udc00';
 
 export class InvalidCharacterEncodingError extends Error {
   constructor() {

package/src/iso.js

@@ -12,6 +12,7 @@ import {
 } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
+import { INVALID_UTF8_SENTINEL } from './io.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -1089,6 +1090,13 @@ function* termTextCandidates(stream, solver) {
   let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
+    // Text streams preserve invalid UTF-8 bytes as an impossible Unicode
+    // sentinel.  read/1-2 and read_term/2-3 must surface the same character
+    // representation error as get_char/1-2 instead of misclassifying the
+    // undecodable byte as malformed Prolog syntax (issue #64).
+    if (stream.strictUtf8 && ch === INVALID_UTF8_SENTINEL) {
+      throw new PrologError('representation_error(character)');
+    }
     if (lineComment) { if (ch === '\n') lineComment = false; continue; }
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
@@ -1305,10 +1313,10 @@ function* readTermBuiltin({ solver, goal, env }) {
   yield next;
 }
 function defaultTermWriteOptions(mode) {
-  if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
-  if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
-  if (mode === 'write_term') return { quoted: false, ignoreOps: false, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
-  return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'write_term') return { quoted: false, ignoreOps: false, numbervars: false, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
 }
 
 function writeOptionBoolean(value, env, option) {

package/src/quads.js

@@ -11,6 +11,7 @@ import { Program } from './program.js';
 import { Solver } from './solver.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { formatTermForWrite } from './write.js';
+import { INVALID_UTF8_SENTINEL } from './io.js';
 
 const DEFAULT_QUAD_MAX_INFERENCES = 100000;
 const DEFAULT_LOOP_MAX_INFERENCES = 10000;
@@ -93,18 +94,24 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: false, kind: 'unsupported', expected: unsupported };
   }
 
-  const inputSpecs = [...new Set(leaves.filter((leaf) => leaf.input != null).map((leaf) => leaf.input))];
-  if (inputSpecs.length > 1) return { ok: false, kind: 'malformed', expected: alternative };
-  const input = inputSpecs[0] ?? '';
-  if (inputSpecs.length > 0 && leaves.length !== 1) return { ok: false };
+  const ioLeaves = leaves.filter((leaf) => leaf.input != null || leaf.peek != null);
+  if (ioLeaves.length > 1 || (ioLeaves.length > 0 && leaves.length !== 1)) {
+    return { ok: false, kind: 'malformed', expected: alternative };
+  }
+  const hasInputSpec = ioLeaves.length === 1;
+  const inputLeaf = ioLeaves[0] ?? null;
+  const input = inputLeaf?.input ?? '';
+  const peek = inputLeaf?.peek ?? null;
   const moreAt = leaves.findIndex((leaf) => leaf.more);
   const describedCount = moreAt < 0 ? leaves.length : moreAt + (leaves[moreAt].hasExpectation ? 1 : 0);
-  const maxSolutions = inputSpecs.length > 0
+  const maxSolutions = hasInputSpec
     ? 1
     : moreAt < 0 ? describedCount + 1 : Math.max(describedCount, 1);
   const actual = executeQuery(program, quad.query, input, maxSolutions, {
     ...options,
     detectLoops: leaves.some((leaf) => leaf.loops),
+    inputBoundary: hasInputSpec,
+    inputPeek: peek,
   });
 
   if (requiresSto) {
@@ -119,9 +126,12 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: true };
   }
 
-  if (inputSpecs.length > 0) {
+  if (hasInputSpec) {
     const leaf = leaves[0];
-    const matches = actual.inputPosition === input.length && matchLeaf(program, quad.query, leaf, actual, 0);
+    const exactConsumption = actual.inputPosition === input.length;
+    const expectedRemainder = `${peek ?? ''}${INVALID_UTF8_SENTINEL}`;
+    const boundaryPreserved = actual.inputRemainder === expectedRemainder;
+    const matches = exactConsumption && boundaryPreserved && matchLeaf(program, quad.query, leaf, actual, 0);
     if (actual.undecided && !matches) return undecidedResult(actual, alternative);
     return { ok: leaf.unexpected ? !matches : matches };
   }
@@ -147,14 +157,14 @@ function checkAlternative(program, quad, alternative, options, context) {
     // turn a successful negative match back into a failure.
     if (leaf.unexpected && leaf.error != null) return { ok: true };
     if (leaf.more) return { ok: true };
-    if (!leaf.unexpected && (leaf.false || leaf.error != null)) {
+    if (!leaf.unexpected && (leaf.false || leaf.loops || leaf.error != null)) {
       if (actual.undecided) return undecidedResult(actual, alternative);
       return { ok: position === leaves.length - 1 };
     }
     position++;
   }
 
-  const ended = position >= actual.solutions.length && actual.error == null && !actual.undecided;
+  const ended = position >= actual.solutions.length && actual.error == null && !actual.undecided && !actual.loopObserved;
   if (!ended && actual.undecided && position >= actual.solutions.length && actual.error == null) {
     return undecidedResult(actual, alternative);
   }
@@ -191,6 +201,7 @@ function describeLeaf(term) {
     loops: false,
     error: null,
     input: null,
+    peek: null,
     output: null,
     unsupported: null,
     malformed: null,
@@ -227,7 +238,9 @@ function describeLeaf(term) {
       continue;
     }
     if (item.type === COMPOUND && item.name === 'peeks' && item.arity === 1) {
-      leaf.unsupported ??= item;
+      const text = characterText(item.args[0]);
+      if (text == null || Array.from(text).length !== 1 || leaf.peek != null) leaf.malformed ??= item;
+      else leaf.peek = text;
       continue;
     }
     if (isErrorDescription(item)) leaf.error = item;
@@ -241,6 +254,9 @@ function describeLeaf(term) {
 
 function executeQuery(program, query, input, maxSolutions, options) {
   let pendingOutput = '';
+  const boundedInput = options.inputBoundary
+    ? `${input}${options.inputPeek ?? ''}${INVALID_UTF8_SENTINEL}`
+    : input;
   const solver = new Solver(program, {
     ...options,
     registry: options.registry ?? getEyePrologRegistry(),
@@ -254,10 +270,18 @@ function executeQuery(program, query, input, maxSolutions, options) {
     // allowance.
     solutionLimit: Math.max(maxSolutions, options.solutionLimit ?? 10000000),
     ioOptions: {
-      input,
+      input: boundedInput,
       write: (text) => { pendingOutput += String(text); },
     },
   });
+  if (options.inputBoundary) {
+    // Quads need a boundary that is neither EOF nor a valid character.  This
+    // mirrors Trealla's sentinel technique: inputs/1 says exactly what was
+    // consumed, while peeks/1 supplies one additional character that must
+    // remain unread.  If the query asks for anything beyond that boundary it
+    // sees representation_error(character), not an artificial EOF.
+    solver.io.resolve('user_input').strictUtf8 = true;
+  }
   // Undefined predicates are test failures rather than silent negative
   // answers unless the source explicitly selected another unknown policy.
   if (!(program.prologFlagDirectives ?? []).some(([flag]) => flag.type === ATOM && flag.name === 'unknown')) {
@@ -273,7 +297,15 @@ function executeQuery(program, query, input, maxSolutions, options) {
     iterator = solver.solve([query], new Env(), 0);
     while (solutions.length < maxSolutions) {
       pendingOutput = '';
+      const cycleBefore = solver.recursionCycleDetected;
       const result = iterator.next();
+      if (!cycleBefore && solver.recursionCycleDetected) {
+        // The recursion guard found an operational loop wall while advancing
+        // to this result.  Any answer produced only after that guard pruned the
+        // looping branch is not reachable by ordinary Prolog search, so do not
+        // count it as a leaf answer (issue #58 comment 5381101420).
+        break;
+      }
       if (result.done) {
         tailOutput += pendingOutput;
         complete = true;
@@ -289,22 +321,30 @@ function executeQuery(program, query, input, maxSolutions, options) {
   } finally {
     if (!complete) iterator?.return?.();
   }
-  const inputPosition = solver.io.resolve('user_input')?.position ?? 0;
+  const inputStream = solver.io.resolve('user_input');
+  const inputPosition = inputStream?.position ?? 0;
+  const inputRemainder = String(inputStream?.content ?? '').slice(inputPosition);
   const bounded = solver.depthLimitExceeded || solver.inferenceLimitExceeded;
-  const undecided = !options.detectLoops && (solver.recursionCycleDetected || bounded);
+  const loopObserved = solver.recursionCycleDetected;
+  // A structural recursion-cycle witness is stronger than a resource limit:
+  // it establishes an operational loop wall and can therefore refute a finite
+  // answer description.  Pure depth/inference exhaustion remains undecided.
+  const undecided = !options.detectLoops && !loopObserved && bounded;
   return {
     solutions,
     error,
     tailOutput,
     inputPosition,
+    inputRemainder,
     complete,
+    loopObserved,
     stoObserved: solver.occursCheckObserved,
-    nstoObserved: complete && !solver.occursCheckObserved && !solver.recursionCycleDetected &&
+    nstoObserved: complete && !solver.occursCheckObserved && !loopObserved &&
       !bounded && !resourceInterrupted,
     // A loops expectation explicitly asks for bounded nontermination evidence.
     // Other descriptions treat the same exhausted search budget as undecided:
     // a timeout cannot establish finite failure or an exact answer sequence.
-    loops: options.detectLoops && (solver.recursionCycleDetected || bounded),
+    loops: options.detectLoops && (loopObserved || bounded),
     undecided,
     undecidedReason: solver.inferenceLimitExceeded ? 'inference limit reached'
       : solver.depthLimitExceeded ? 'depth limit reached'
@@ -316,7 +356,7 @@ function executeQuery(program, query, input, maxSolutions, options) {
 function matchLeaf(program, query, leaf, actual, position) {
   if (leaf.loops) return actual.loops;
   if (leaf.false) {
-    return position >= actual.solutions.length && actual.error == null && !actual.undecided &&
+    return position >= actual.solutions.length && actual.error == null && !actual.undecided && !actual.loopObserved &&
       outputMatches(program, leaf.output, actual.tailOutput);
   }
   if (leaf.error != null) {

package/src/write.js

@@ -58,6 +58,51 @@ function isDottedGraphicAtom(name) {
     [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
 }
 
+function compactBoundaryNeedsSpace(left, right) {
+  const leftChars = Array.from(left);
+  const rightChars = Array.from(right);
+  const a = leftChars[leftChars.length - 1] ?? '';
+  const b = rightChars[0] ?? '';
+  if (!a || !b) return false;
+  // Adjacent quoted atoms need layout: `''` is part of quoted-atom syntax,
+  // so concatenating two quoted operator/argument tokens would change the
+  // tokenization (WG17 #169).
+  if (a === "'" && b === "'") return true;
+  // Adjacent graphic characters form one maximal graphic token. Keep them
+  // apart when an operator boundary would otherwise disappear (`a+ -b`,
+  // `a/ *b`, etc.).
+  if (graphicAtomCharacters.has(a) && graphicAtomCharacters.has(b)) return true;
+  // Alphanumeric operator names similarly need a lexical boundary from a
+  // neighbouring identifier/number token.  Most predefined word operators
+  // are handled explicitly below; this also protects quoted/custom cases that
+  // render without punctuation.
+  if (/^[A-Za-z0-9_]$/.test(a) && /^[A-Za-z0-9_]$/.test(b)) return true;
+  return false;
+}
+
+function isWordOperatorToken(token) {
+  return /^[a-z][A-Za-z0-9_]*$/.test(token);
+}
+
+function compactPrefixOperator(token, argument) {
+  if (isWordOperatorToken(token)) return `${token} ${argument}`;
+  return `${token}${compactBoundaryNeedsSpace(token, argument) ? ' ' : ''}${argument}`;
+}
+
+function compactPostfixOperator(argument, token) {
+  if (isWordOperatorToken(token)) return `${argument} ${token}`;
+  return `${argument}${compactBoundaryNeedsSpace(argument, token) ? ' ' : ''}${token}`;
+}
+
+function compactInfixOperator(left, token, right) {
+  // Solo punctuation operators already delimit themselves.
+  if (token === ',' || token === ';') return `${left}${token}${right}`;
+  if (isWordOperatorToken(token)) return `${left} ${token} ${right}`;
+  const before = compactBoundaryNeedsSpace(left, token) ? ' ' : '';
+  const after = compactBoundaryNeedsSpace(token, right) ? ' ' : '';
+  return `${left}${before}${token}${after}${right}`;
+}
+
 function legacyVariableToIso(name) {
   if (name === '?') return '_';
   const tail = name.slice(1);
@@ -313,9 +358,11 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         // numeric-leading argument so writeq/write_term remain read-back safe
         // (WG17 #135, #183, #215, #216, and #248).
         if (resolved.name === '-' && startsWithUnsignedNumber(resolved.args[0], env, table, options)) {
-          text = `${token} (${format(resolved.args[0], env, options, table, 1200)})`;
+          const argument = format(resolved.args[0], env, options, table, 1200);
+          text = options.minimalOperatorSpacing ? `${token}(${argument})` : `${token} (${argument})`;
         } else {
-          text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
+          const argument = format(resolved.args[0], env, options, table, argumentPriority);
+          text = options.minimalOperatorSpacing ? compactPrefixOperator(token, argument) : `${token} ${argument}`;
         }
       } else if (specifier === 'xf' || specifier === 'yf') {
         let argumentPriority = specifier === 'xf' ? priority - 1 : priority;
@@ -324,7 +371,8 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
             ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(childDefinition.specifier)) {
           argumentPriority = priority - 1;
         }
-        text = `${format(resolved.args[0], env, options, table, argumentPriority)} ${token}`;
+        const argument = format(resolved.args[0], env, options, table, argumentPriority);
+        text = options.minimalOperatorSpacing ? compactPostfixOperator(argument, token) : `${argument} ${token}`;
       } else {
         let leftPriority = specifier === 'yfx' ? priority : priority - 1;
         const rightPriority = specifier === 'xfy' ? priority : priority - 1;
@@ -334,9 +382,13 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         }
         const left = format(resolved.args[0], env, options, table, leftPriority);
         const right = format(resolved.args[1], env, options, table, rightPriority);
-        text = resolved.name === ',' ? `${left}, ${right}`
-          : compactInfixOperators.has(resolved.name) ? `${left}${token}${right}`
-            : `${left} ${token} ${right}`;
+        if (options.minimalOperatorSpacing) {
+          text = resolved.name === ',' ? `${left},${right}` : compactInfixOperator(left, token, right);
+        } else if (resolved.name === ',') {
+          text = `${left}, ${right}`;
+        } else {
+          text = compactInfixOperators.has(resolved.name) ? `${left}${token}${right}` : `${left} ${token} ${right}`;
+        }
       }
       return priority > maxPriority ? `(${text})` : text;
     }
@@ -358,6 +410,7 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
       ? printableGeneratedVariableNames(term, env, explicitVariableNames, options.variableNameState)
       : printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
+    minimalOperatorSpacing: options.minimalOperatorSpacing === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
     dottedGraphicAtoms: options.dottedGraphicAtoms === true,
   };

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -21,8 +21,8 @@ upstream assertion.
 The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
 3 upstream `waits` cases are checked through EyeProlog's interactive input
 hook. All 366 executable cases are independently checked against the
-upstream Codex expectation. 365 cases additionally retain exact reviewed
-outcomes for stronger regression checking; 1 case currently relies on the upstream assertion alone.
+upstream Codex expectation. 366 cases additionally retain exact reviewed
+outcomes for stronger regression checking; 0 cases currently rely on the upstream assertion alone.
 
 ## Traceable evidence
 

package/test/conformance/expected/iso/wg17_syntax_high_risk.pl

@@ -6,8 +6,8 @@ wg17_hex_escape.
 f(*)
 f(;,'|',';;')
 wg17_operator_arguments.
-a * (b + c)
-a :- b, c
+a*(b+c)
+a:-b,c
 wg17_operator_precedence.
 wg17_spaced_prefix_operator((a, b)).
 '.'(a,[])