eyeprolog 1.5.47 → 1.5.49

package/conformance-report.md

@@ -53,6 +53,11 @@ EyeProlog checks the input and remainder of `phrase/2-3` and reports
 `type_error(list, S)` when an argument is neither a list nor a partial list.
 These implementation-defined checks follow ISO/IEC TS 13211-3:2025,
 8.18.1.3 g and h; this behavior is not a known deviation.
+The checks are optional. EyeProlog elects to perform both consistently.
+Dedicated regressions require the exact error for atomic non-lists and
+improper lists across both arities and both sequence positions, while
+accepting variables, proper lists, and partial lists. The upstream quads
+allow checking and non-checking outcomes and do not prove this policy.
 
 The Part 3 implementation target is
 [ISO/IEC TS 13211-3:2025](https://www.iso.org/standard/83635.html).

package/package.json

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

package/src/iso.js

@@ -3024,7 +3024,9 @@ function* phraseSolutions({ solver, goal, env }, state) {
   validateDcgEmbeddedGoals(grammarBody, input, requestedOutput);
   // ISO/IEC TS 13211-3:2025, 8.18.1.3 g and h permit these checks
   // and specify type_error(list, S) for invalid terminal-sequence arguments.
-  // Keep both diagnostics and the unmodified upstream phrase quad gate.
+  // EyeProlog elects to perform both optional checks consistently, including
+  // improper lists. The upstream quads allow non-checking outcomes too; the
+  // dedicated regression matrix requires our exact diagnostics.
   // See conformance-report.md and issue #94.
   if (!isListOrPartialList(input, env)) {
     throw new PrologError('type_error(list)', deref(input, env));

package/src/quads.js

@@ -68,7 +68,18 @@ function checkQuadDescription(program, quad, description, options, context) {
 }
 
 function checkDescription(program, quad, description, options, context) {
-  const alternatives = splitOperator(description, '|');
+  const parts = splitOperator(description, '|');
+  const alternatives = [];
+  const unordered = new Set();
+  for (const part of parts) {
+    if (part.type === ATOM && part.name === 'other_answer_sequence') {
+      const previous = alternatives.at(-1);
+      if (previous == null || unordered.has(previous)) {
+        return { ok: false, kind: 'malformed', expected: part };
+      }
+      unordered.add(previous);
+    } else alternatives.push(part);
+  }
   // Probe an explicitly accepted nontermination outcome before alternatives
   // that would run the same query without a bound.
   const ordered = [...alternatives].sort((left, right) =>
@@ -80,7 +91,7 @@ function checkDescription(program, quad, description, options, context) {
   let unsupported = null;
   let undecided = null;
   for (const alternative of ordered) {
-    const checked = checkAlternative(program, quad, alternative, options, context);
+    const checked = checkAlternative(program, quad, alternative, options, context, unordered.has(alternative));
     if (checked.ok) return checked;
     if (checked.kind === 'unsupported') unsupported ??= checked;
     if (checked.kind === 'undecided') undecided ??= checked;
@@ -88,7 +99,7 @@ function checkDescription(program, quad, description, options, context) {
   return unsupported ?? undecided ?? { ok: false, kind: 'failed', expected: description };
 }
 
-function checkAlternative(program, quad, alternative, options, context) {
+function checkAlternative(program, quad, alternative, options, context, unordered = false) {
   const leaves = splitOperator(alternative, ';').map(describeLeaf);
   const requiresSto = leaves.some((leaf) => leaf.sto);
   const unsupported = leaves.find((leaf) => leaf.unsupported != null)?.unsupported;
@@ -96,6 +107,13 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: false, kind: 'unsupported', expected: unsupported };
   }
 
+  // A permutation describes a complete sequence, not an arbitrary prefix or
+  // a negative assertion. Do not silently weaken those annotations.
+  if (unordered && leaves.some((leaf) => leaf.more || leaf.unexpected || leaf.sto ||
+      leaf.waits || leaf.input != null || leaf.peek != null)) {
+    return { ok: false, kind: 'unsupported', expected: alternative };
+  }
+
   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 };
@@ -143,6 +161,8 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: leaf.unexpected ? !matches : matches };
   }
 
+  if (unordered) return checkAnswerPermutation(program, quad.query, leaves, actual, alternative);
+
   let position = 0;
   for (const leaf of leaves) {
     if (leaf.more && !leaf.hasExpectation) return { ok: true };
@@ -186,6 +206,37 @@ function checkAlternative(program, quad, alternative, options, context) {
   return { ok: ended };
 }
 
+// Match a multiset, preserving duplicate counts. A greedy match is insufficient:
+// wildcard and approximate descriptions may overlap more specific descriptions.
+// Augmenting paths find a one-to-one assignment without enumerating permutations.
+function checkAnswerPermutation(program, query, leaves, actual, alternative) {
+  const terminalAt = leaves.findIndex((leaf) => leaf.false || leaf.loops || leaf.error != null);
+  if (terminalAt >= 0 && terminalAt !== leaves.length - 1) return { ok: false };
+  const answers = terminalAt < 0 ? leaves : leaves.slice(0, -1);
+  if (actual.solutions.length > answers.length) return { ok: false };
+  if (actual.undecided) return undecidedResult(actual, alternative);
+  if (actual.solutions.length !== answers.length) return { ok: false };
+  if (terminalAt >= 0) {
+    if (!matchLeaf(program, query, leaves[terminalAt], actual, answers.length)) return { ok: false };
+  } else if (!actual.complete || actual.error != null || actual.loopObserved) return { ok: false };
+
+  const edges = answers.map((leaf) => actual.solutions.flatMap((_, position) =>
+    matchLeaf(program, query, leaf, actual, position) ? [position] : []));
+  const owners = Array(answers.length).fill(-1);
+  const assign = (index, seen) => {
+    for (const position of edges[index]) {
+      if (seen.has(position)) continue;
+      seen.add(position);
+      if (owners[position] < 0 || assign(owners[position], seen)) {
+        owners[position] = index;
+        return true;
+      }
+    }
+    return false;
+  };
+  return { ok: answers.every((_, index) => assign(index, new Set())) };
+}
+
 function malformedAlternative(query, alternative) {
   const queryNames = new Set(namedVariables(query).map((variable) => variable.name));
   for (const leaf of splitOperator(alternative, ';').map(describeLeaf)) {

package/test/conformance/ISO-PART2-PART3-SCOPE.md

@@ -37,12 +37,23 @@ implementation-dependent negation/if-then choices documented in the reference.
 `--iso-strict` leaves `-->/2` as ordinary Part 1 operator syntax and excludes
 Part 3 grammar expansion and `phrase/2-3` from the strict registry.
 
-One compatibility difference is explicit: EyeProlog currently reports
-`type_error(list)` when its `phrase/2-3` terminal-sequence validation rejects a
-non-list. The Part 3 terminal-sequence specification uses its own terminal
-sequence error category. EyeProlog retains the list-shaped error for its normal
-interoperability profile, so this behavior must not be presented as evidence of
-complete Part 3 conformance.
+EyeProlog elects to perform both implementation-defined terminal-sequence
+checks in ISO/IEC TS 13211-3:2025, 8.18.1.3 g and h. The checks are optional;
+when performed, their specified error type is `list`. EyeProlog consistently
+raises `type_error(list, Culprit)` for a non-list input to `phrase/2` or
+`phrase/3`, and for a non-list remainder to `phrase/3`. The culprit is the
+whole invalid argument, including an improper list, not just its tail.
+Variables, proper lists, and partial lists are accepted by these checks.
+For otherwise valid grammar bodies, validation precedes execution, even when
+the grammar would fail or produce a side effect.
+
+The upstream phrase quads permit both checking and non-checking outcomes and
+therefore do not establish this consistency. A dedicated regression matrix in
+`test/run-regression.mjs` requires the exact diagnostic across both arities,
+both sequence positions, atomic and compound non-lists, improper lists at
+several depths, and several grammar bodies. Positive cases protect variables,
+proper lists, and partial lists. These are policy checks, not a relaxation of
+the unmodified upstream corpus.
 
 The Part 3 implementation otherwise keeps sequence validation, grammar-body
 callability, variable-body instantiation errors, `phrase/3` steadfastness, and

package/test/run-conformance-report.mjs

@@ -143,6 +143,11 @@ function dcgConformanceSection() {
     '`type_error(list, S)` when an argument is neither a list nor a partial list.',
     'These implementation-defined checks follow ISO/IEC TS 13211-3:2025,',
     '8.18.1.3 g and h; this behavior is not a known deviation.',
+    'The checks are optional. EyeProlog elects to perform both consistently.',
+    'Dedicated regressions require the exact error for atomic non-lists and',
+    'improper lists across both arities and both sequence positions, while',
+    'accepting variables, proper lists, and partial lists. The upstream quads',
+    'allow checking and non-checking outcomes and do not prove this policy.',
     '',
     'The Part 3 implementation target is',
     '[ISO/IEC TS 13211-3:2025](https://www.iso.org/standard/83635.html).',

package/test/run-regression.mjs

@@ -995,6 +995,45 @@ why(
         assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads matches other_answer_sequence permutations exactly (issue #95)',
+      run: () => {
+        const cases = [
+          ['setof groups', 'setof(1, (Y=2 ; Y=1), L)', 'Y=2,L=[1];Y=1,L=[1]', true],
+          ['reverse', '(X=1;X=2;X=3)', 'X=3;X=2;X=1', true],
+          ['duplicates', '(X=1;X=1;X=2)', 'X=2;X=1;X=1', true],
+          ['wrong multiplicity', '(X=1;X=1;X=2)', 'X=2;X=2;X=1', false],
+          ['missing', '(X=1;X=2)', 'X=3;X=2;X=1', false],
+          ['extra', '(X=1;X=2;X=3)', 'X=2;X=1', false],
+          ['wrong value', '(X=1;X=2)', 'X=3;X=1', false],
+          ['overlapping patterns', '(X=f(a);X=f(b))', "X=f('...');X=f(a)", true],
+          ['variable sharing', '(X=Y;true)', 'true;X=Y', true],
+          ['wrong sharing', '(X=Y;true)', 'X=Y;X=Y', false],
+          ['per-answer output', '(X=1,write(a);X=2,write(b))', 'X=2,outputs("b");X=1,outputs("a")', true],
+          ['wrong output', '(X=1,write(a);X=2,write(b))', 'X=2,outputs("a");X=1,outputs("b")', false],
+          ['unlisted exception', '(X=1;throw(ball))', 'X=1', false],
+          ['terminal exception', '(X=1;X=2;throw(ball))', 'X=2;X=1;throw(ball)', true],
+          ['terminal failure', '(X=1;X=2)', 'X=2;X=1;false', true],
+          ['empty sequence', 'fail', 'false', true],
+          ['ordinary order retained', '(X=1;X=2)', 'X=2;X=1', false, false],
+        ];
+        for (const [name, query, answers, passes, unordered = true] of cases) {
+          const result = publicApi.runQuads(`?- ${query}.\n   ${answers}${unordered ? ' | other_answer_sequence' : ''}.\n`);
+          assertEqual(result.passed, passes ? 1 : 0, name);
+          assertEqual(result.undecided, 0, `${name} decided`);
+        }
+        for (const answers of ['other_answer_sequence', 'other_answer_sequence | X=1',
+          'X=1 | other_answer_sequence | other_answer_sequence']) {
+          const result = publicApi.runQuads(`?- X=1.\n   ${answers}.\n`);
+          assertEqual(result.results[0].kind, 'malformed', 'orphan or repeated marker');
+        }
+        const bounded = publicApi.runQuads(
+          'p(0). p(X) :- p(Y), X is Y+1.\n?- p(X).\n   X=1;X=0 | other_answer_sequence.\n',
+          { quadMaxInferences: 1 },
+        );
+        assertEqual(bounded.undecided, 1, 'bounded execution is not proof of a permutation');
+      },
+    },
     {
       name: 'runQuads supports realistic decimal-precision float descriptions with ~~ (issue #90)',
       run: () => {
@@ -1191,6 +1230,44 @@ why(
         assertEqual(forbiddenFresh.failed, 1, 'fresh thrown variable is detected');
       },
     },
+    {
+      name: 'phrase terminal-sequence checks are consistent across arities and list shapes (issue #94)',
+      run: () => {
+        // The upstream quads allow both checking and non-checking processors.
+        // Require EyeProlog's chosen diagnostic, not either portable outcome.
+        const bodies = ['[]', '[a]', '{true}', '{fail}', '{write(reached)}', '!', 'p'];
+        const invalid = ['non_list', '0', 'f(a)', '[a|non_list]', '[a,b|0]', '[a,b,c|f(t)]'];
+        for (const body of bodies) {
+          for (const bad of invalid) {
+            for (const call of [`phrase(${body}, Bad)`, `phrase(${body}, Bad, [])`,
+              `phrase(${body}, [], Bad)`]) {
+              let output = '';
+              runEyeProlog('p --> [a].', {
+                ioOptions: { write: (text) => { output += text; } },
+                goal: `Bad=${bad}, catch((${call}, write(missed)), error(type_error(list, Bad), _), write(ok))`,
+              });
+              assertEqual(output, 'ok', `${call} with ${bad}`);
+            }
+          }
+        }
+        for (const goal of [
+          'phrase([], [])',
+          'phrase([a], [a])',
+          'phrase([a], L), L == [a]',
+          'phrase([a], [a|T]), T == []',
+          'phrase([], S, S), var(S)',
+          'phrase([], [a|T], [a|T]), var(T)',
+          'phrase([], L, [a|T]), L == [a|T], var(T)',
+          'phrase([a], [a|T], T), var(T)',
+          'phrase([f(a),1], [f(a),1])',
+        ]) {
+          let output = '';
+          runEyeProlog('', { goal: `(${goal}), write(ok)`,
+            ioOptions: { write: (text) => { output += text; } } });
+          assertEqual(output, 'ok', goal);
+        }
+      },
+    },
     {
       name: 'runQuads matches the corrected ISO phrase quad boundaries',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5870,10 +5870,14 @@ look_ahead(X), [X] --> [X].
 `phrase(+Body,?Sequence)` accepts or generates a complete sequence.
 `phrase(+Body,?Sequence,?Rest)` leaves `Rest` unconsumed and is steadfast in
 that argument. A variable body raises `instantiation_error`; a non-callable
-body raises `type_error(callable)`. EyeProlog performs terminal-sequence checks and currently reports
-`type_error(list)` for a rejected non-list. This is a normal-profile
-interoperability choice, not a Part 3 conformance claim; Part 3 defines a
-dedicated terminal-sequence error category. See
+body raises `type_error(callable)`. EyeProlog elects to perform the optional
+terminal-sequence checks of ISO/IEC TS 13211-3:2025, 8.18.1.3 g and h.
+It consistently reports `type_error(list, Culprit)` for invalid input in both
+arities and invalid remainder in `phrase/3`, including improper lists.
+Variables, proper lists, and partial lists pass these checks. Validation
+precedes grammar execution; an otherwise valid failing grammar does not
+suppress the diagnostic. Dedicated regressions enforce this policy separately
+from the portable quads, which accept both checking and non-checking outcomes. See
 [`ISO-PART2-PART3-SCOPE.md`](test/conformance/ISO-PART2-PART3-SCOPE.md).
 
 #### A bidirectional expression grammar
@@ -9663,8 +9667,16 @@ 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.
+Appending `| other_answer_sequence` accepts any permutation of the preceding
+complete answer sequence. Substitutions, residual constraints, per-answer output,
+and duplicate counts must still match; missing or extra answers are failures.
+A final failure or exception stays at the end. Overlapping wildcard or approximate
+answer descriptions are matched one-to-one rather than greedily. Search-budget
+exhaustion remains undecided. Prefix (`...`), negative (`unexpected`), STO, and
+input/wait annotations are not supported in a permuted sequence.
+
+For `setof(1, (Y=2 ; Y=1), L)`, the description
+`Y=2, L=[1] ; Y=1, L=[1] | other_answer_sequence` accepts either group order.
 
 #### STO, loops, and undecided quad results