eyeprolog 1.6.0 → 1.6.1

package/package.json

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

package/src/parser.js

@@ -1036,8 +1036,17 @@ class Parser {
       // mode, a double-quoted chars/codes prefix may be followed by `||Tail`.
       // It is equivalent to the corresponding list prefix with Tail as its
       // final list tail, e.g. "ab"||T is [a,b|T] with double_quotes(chars).
-      // The extension binds at priority 1 (tighter than ordinary operators)
-      // and is deliberately absent from the strict ISO profile.
+      // Per the WG17-accepted design (issue #116; see
+      // https://www.complang.tuwien.ac.at/ulrich/iso-prolog/double_bar),
+      // the whole `dql||term` production, and the tail `term` itself, both
+      // have priority 0: the tail is a *primary* term, not an
+      // operator-priority-1 term. An operator argument therefore requires
+      // explicit parentheses, e.g. "abc"||(1 op 2) with `op` any infix
+      // operator, however low its own declared priority. This also stops
+      // an infix operator immediately following the tail from being
+      // absorbed into it: with `op(1, xfy, op)` declared, "abc"||1 op 2
+      // must parse as ("abc"||1) op 2, not "abc"||(1 op 2). The extension
+      // is deliberately absent from the strict ISO profile.
       if (!this.strictIso && this.token.type === TOK.BAR) {
         const state = {
           pos: this.pos,
@@ -1048,7 +1057,7 @@ class Parser {
         this.advance();
         if (this.token.type === TOK.BAR) {
           this.advance();
-          tail = this.parseTerm(operatorStrength(1), false, allowBar, false);
+          tail = this.parseTerm(operatorStrength(0), false, allowBar, false);
         } else {
           // A single bar remains ordinary bar syntax. We had to advance once
           // to distinguish it from `||`, so restore the tokenizer state.

package/src/write.js

@@ -356,10 +356,14 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
     if (quotedSplice != null && (quotedSplice.tail == null || options.doubleBar)) {
       const prefix = writeString(quotedSplice.text);
       if (quotedSplice.tail == null) return prefix;
-      // `||` is a normal-profile syntax extension with priority 1, so a
-      // looser operator in the right operand must be parenthesized to keep the
-      // emitted text readable as the same term.
-      return `${prefix}||${format(quotedSplice.tail, env, options, table, 1, 'term')}`;
+      // `||` is a normal-profile syntax extension whose tail has priority 0
+      // (issue #116; see
+      // https://www.complang.tuwien.ac.at/ulrich/iso-prolog/double_bar), so
+      // any operator term in the right operand must be parenthesized to
+      // keep the emitted text readable back as the same term — including
+      // one whose own declared priority is as low as 1, since the parser
+      // accepts nothing but a bare primary term after `||` unparenthesized.
+      return `${prefix}||${format(quotedSplice.tail, env, options, table, 0, 'term')}`;
     }
 
     if (!options.ignoreOps) {

package/test/regression/cases-white-box.mjs

@@ -201,6 +201,60 @@ export function whiteBoxCases() {
         }
       },
     },
+    {
+      // https://www.complang.tuwien.ac.at/ulrich/iso-prolog/double_bar: the
+      // whole `dql||term` production, and the tail `term` itself, both have
+      // priority 0 (the tail is a primary term, not a priority-1 term as an
+      // earlier revision of this extension had it). With a custom operator
+      // declared as low as priority 1, an unparenthesized tail must stop
+      // before that operator rather than absorb it, and a parenthesized tail
+      // must print with parentheses to remain distinguishable on readback.
+      name: 'double-bar tail has priority 0, so it is not absorbed into a following low-priority operator (issue #116)',
+      run: () => {
+        const operatorDefinitions = [...ISO_OPERATOR_DEFINITIONS, [1, 'xfy', 'op']];
+
+        // "abc"||1 op 2 must parse as ("abc"||1) op 2, not "abc"||(1 op 2):
+        // op's priority (1) is not <= the tail's max priority (0), so an
+        // unparenthesized tail parse must stop at `1` and let `op 2` apply
+        // to the whole splice term instead.
+        const unparenthesized = parseGoalText('p("abc"||1 op 2)', { operatorDefinitions }).args[0];
+        assertEqual(unparenthesized.name, 'op', 'unabsorbed tail: outer functor');
+        assertEqual(unparenthesized.args[1].name, '2', 'unabsorbed tail: outer right operand');
+        const splice = unparenthesized.args[0];
+        assertEqual(splice.args[1].args[1].args[1].name, '1', 'unabsorbed tail: splice tail value');
+
+        // "abc"||(1 op 2) is a different term: op(1, 2) spliced in as the
+        // tail.
+        const parenthesizedTail = parseGoalText('p("abc"||(1 op 2))', { operatorDefinitions }).args[0];
+        assertEqual(parenthesizedTail.name, '.', 'parenthesized tail: still a cons cell');
+        assertEqual(parenthesizedTail.args[1].args[1].args[1].name, 'op', 'parenthesized tail: splice tail is op(1, 2)');
+
+        // Printing must disambiguate the two terms above, and must agree
+        // that ("abc"||1) op 2 (explicit outer parentheses) is the same
+        // term as the unparenthesized case, exercising the real top-level
+        // answer-printing path (not just the parser).
+        const source = ':- op(1, xfy, op).\n';
+        const stdout = run(source, {
+          goals: [
+            '("abc"||1 op 2) == (("abc"||1) op 2)',
+            '("abc"||1 op 2) \\== ("abc"||(1 op 2))',
+            'L1 = "abc"||1 op 2',
+            'L3 = "abc"||(1 op 2)',
+          ],
+        }).stdout;
+        assertEqual(
+          stdout,
+          [
+            '"abc"||1 op 2 == "abc"||1 op 2.',
+            '"abc"||1 op 2 \\== "abc"||(1 op 2).',
+            '"abc"||1 op 2 = "abc"||1 op 2.',
+            '"abc"||(1 op 2) = "abc"||(1 op 2).',
+            '',
+          ].join('\n'),
+          'unabsorbed and parenthesized-tail terms are distinct and print disambiguated from each other',
+        );
+      },
+    },
     {
       name: 'normal integer syntax accepts WG17 digit separators (issue #89)',
       run: () => {