eyeprolog 1.5.48 → 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.48",
+  "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/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

@@ -1230,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