eyeprolog 1.2.25 → 1.2.26

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.25",
+  "version": "1.2.26",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -50,9 +50,11 @@
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",
+    "test:wg17-syntax": "node test/run-wg17-syntax.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
     "test:playground": "node test/run-playground.mjs",
+    "report:wg17-syntax": "node tools/report-wg17-syntax-coverage.mjs",
     "preversion": "npm test && node test/run-conformance-report.mjs conformance-report.md",
     "postversion": "git push origin HEAD --follow-tags"
   }

package/src/iso.js

@@ -1072,6 +1072,11 @@ function isTerminatingFullStop(source, index) {
   return true;
 }
 
+const termGraphicCharacters = new Set('#$&*+-./<=>@^~\\:');
+function continuesGraphicToken(source, index) {
+  return index > 0 && termGraphicCharacters.has(source[index - 1]);
+}
+
 function* termTextCandidates(stream) {
   const source = String(stream.content);
   let quote = null, lineComment = false, blockComment = false;
@@ -1095,13 +1100,24 @@ function* termTextCandidates(stream) {
     const characterCodeEnd = characterCodeConstantEnd(source, i);
     if (characterCodeEnd != null) { i = characterCodeEnd; continue; }
     if (ch === '%') { lineComment = true; continue; }
-    if (ch === '/' && next === '*') { blockComment = true; i++; continue; }
+    // Comment openers are recognized between tokens. Within a maximal
+    // graphic token, as in `//*`, the slash and star remain atom characters.
+    if (ch === '/' && next === '*' && !continuesGraphicToken(source, i)) {
+      blockComment = true;
+      i++;
+      continue;
+    }
     if (ch === "'" || ch === '"') { quote = ch; continue; }
     if (ch === '.' && isTerminatingFullStop(source, i)) {
       yield { text: source.slice(stream.position, i + 1), end: i + 1 };
     }
   }
 }
+function hasNonLayoutRemainder(source, start) {
+  return source.slice(start)
+    .replace(/[\u0009-\u000d\u0020]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g, '')
+    .length > 0;
+}
 function convertedTermText(text, solver) {
   if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) return text;
   let result = '', quote = null;
@@ -1143,6 +1159,7 @@ function readTermFromStream(stream, solver) {
         const clauses = parseClauses(convertedTermText(candidate.text, solver), {
           sourceMetadata: false,
           operatorState,
+          isoStrict: solver.isoStrict,
           doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
         });
         if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
@@ -1170,8 +1187,13 @@ function readTermFromStream(stream, solver) {
       }
     }
 
-    stream.position = String(stream.content).length;
-    if (!sawCandidate) return atom('end_of_file');
+    const source = String(stream.content);
+    const remainderStart = stream.position;
+    stream.position = source.length;
+    if (!sawCandidate) {
+      if (hasNonLayoutRemainder(source, remainderStart)) throw new PrologError('syntax_error(read_term)');
+      return atom('end_of_file');
+    }
     throw new PrologError('syntax_error(read_term)');
   }
 }

package/src/parser.js

@@ -87,7 +87,6 @@ const PREFIX_OPERATORS = new Map([
 
 export const ISO_OPERATOR_DEFINITIONS = [
   [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'fx', '?-'], [1200, 'xfx', '-->'],
-  [1105, 'xfy', '|'],
   [1100, 'xfy', ';'], [1050, 'xfy', '->'], [1000, 'xfy', ','],
   [900, 'fy', '\\+'],
   ...['=', '=..', '\\=', '==', '\\==', '@<', '@=<', '@>', '@>=', 'is',
@@ -99,6 +98,13 @@ export const ISO_OPERATOR_DEFINITIONS = [
   [200, 'fy', '+'], [200, 'fy', '-'], [200, 'fy', '\\'],
 ];
 
+// The alternative operator belongs to the Part 3 grammar-rule profile. Part 1
+// reserves `|` as list punctuation but permits a program to declare it as an
+// infix operator at priority 1001 or greater (Corrigendum 2).
+export const PART3_OPERATOR_DEFINITIONS = [
+  [1105, 'xfy', '|'],
+];
+
 // EyeProlog's embedded quad syntax permits an optional label before `?-`.
 // That makes `?-` an implementation-specific xfx operator in addition to its
 // ISO 1200 fx definition.
@@ -118,6 +124,10 @@ function operatorStrength(priority) {
   return 1201 - priority;
 }
 
+// ISO 6.3.3 arguments have maximum priority 999. Parenthesized terms and
+// curly-bracket contents may contain a full priority-1200 term instead.
+const ARG_MIN_PRECEDENCE = operatorStrength(999);
+
 function isGraphicAtomCode(code) {
   return graphicAtomChars.includes(String.fromCharCode(code));
 }
@@ -148,7 +158,10 @@ export function createParserOperatorState(definitions = [], includeDefaults = tr
   // The infix ?-/2 form is an EyeProlog quad extension.  ISO 13211-1
   // predefines only the 1200 fx ?- operator; strict core mode starts from that
   // table and still permits an explicit op/3 directive to add an infix form.
-  if (options.isoStrict === true) state.infixOperators.delete('?-');
+  if (options.isoStrict === true) {
+    state.infixOperators.delete('?-');
+    state.infixOperators.delete('|');
+  }
   for (const definition of definitions) {
     const [priority, specifier, name] = Array.isArray(definition)
       ? definition
@@ -422,16 +435,22 @@ class Parser {
     const previousEndsTerm = this.previousToken && (
       [TOK.VAR, TOK.NUMBER, TOK.STRING, TOK.RPAREN, TOK.RBRACKET, TOK.RBRACE].includes(this.previousToken.type) ||
       (this.previousToken.type === TOK.ATOM &&
-       !this.infixOperators.has(this.previousToken.text) &&
-       !this.prefixOperators.has(this.previousToken.text) &&
-       !this.postfixOperators.has(this.previousToken.text))
+       (this.postfixOperators.has(this.previousToken.text) ||
+        (!this.infixOperators.has(this.previousToken.text) &&
+         !this.prefixOperators.has(this.previousToken.text))))
     );
     if (isDigitCode(ch.charCodeAt(0)) ||
         (ch === '-' && isDigitCode(this.peek(1).charCodeAt(0)) && !previousEndsTerm)) {
       const start = this.pos;
       const negative = this.peek() === '-';
       if (negative) this.take();
-      if (this.peek() === '0' && this.peek(1) === "'") {
+      const startsQuotedCharacter = this.peek() === '0' && this.peek(1) === "'" &&
+        // `0''` is the integer 0 followed by the empty atom, whereas `0'''`
+        // is the character-code constant for an apostrophe. A continuation
+        // after the integer likewise belongs to the following quoted atom.
+        (this.peek(2) !== "'" || this.peek(3) === "'") &&
+        !(this.peek(2) === '\\' && this.peek(3) === '\n');
+      if (startsQuotedCharacter) {
         this.take();
         this.take();
         let value = this.take();
@@ -463,7 +482,12 @@ class Parser {
         const code = value.codePointAt(0);
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
       }
-      if (this.peek() === '0' && ['b', 'o', 'x'].includes(this.peek(1))) {
+      const radixKind = this.peek() === '0' ? this.peek(1) : '';
+      const radixHasDigit = radixKind === 'b' ? /^[01]$/.test(this.peek(2))
+        : radixKind === 'o' ? /^[0-7]$/.test(this.peek(2))
+        : radixKind === 'x' ? /^[0-9A-Fa-f]$/.test(this.peek(2))
+        : false;
+      if (radixHasDigit) {
         this.take();
         const kind = this.take();
         const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
@@ -477,11 +501,16 @@ class Parser {
         return { type: TOK.NUMBER, text: integer.toString(), line };
       }
       while (isDigitCode(this.peek().charCodeAt(0))) this.take();
+      let hasFraction = false;
       if (this.peek() === '.' && isDigitCode(this.peek(1).charCodeAt(0))) {
+        hasFraction = true;
         this.take();
         while (isDigitCode(this.peek().charCodeAt(0))) this.take();
       }
-      if ((this.peek() === 'e' || this.peek() === 'E')) {
+      // ISO floating-point syntax requires a fractional part before an
+      // exponent. Thus 1.0e9 is one number token, while 1E9 is the integer 1
+      // followed by the name E9 and is not a valid term without an operator.
+      if (hasFraction && (this.peek() === 'e' || this.peek() === 'E')) {
         let idx = this.pos + 1;
         if (this.source[idx] === '+' || this.source[idx] === '-') idx++;
         if (isDigitCode((this.source[idx] ?? '').charCodeAt(0))) {
@@ -490,7 +519,10 @@ class Parser {
           while (isDigitCode(this.peek().charCodeAt(0))) this.take();
         }
       }
-      return { type: TOK.NUMBER, text: this.source.slice(start, this.pos), line };
+      let text = this.source.slice(start, this.pos);
+      if (!hasFraction) text = BigInt(text).toString();
+      else if (Object.is(Number(text), -0)) text = '0.0';
+      return { type: TOK.NUMBER, text, line };
     }
 
     if (isVariableStartCode(ch.charCodeAt(0))) {
@@ -527,7 +559,9 @@ class Parser {
   parseParenthesizedTerm() {
     this.expect(TOK.LPAREN, '(');
     this.advance();
-    const term = this.parseTerm(0, true);
+    // A current operator atom may be the complete parenthesized term, e.g.
+    // (+), but it cannot silently become an operand in a larger expression.
+    const term = this.parseTerm(0, true, true, true);
     this.expect(TOK.RPAREN, ')');
     this.advance();
     return term;
@@ -544,14 +578,14 @@ class Parser {
     const items = [];
     let tail = null;
     while (true) {
-      items.push(this.parseTerm(0, false, false));
+      items.push(this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true));
       if (this.token.type === TOK.COMMA) {
         this.advance();
         continue;
       }
       if (this.token.type === TOK.BAR) {
         this.advance();
-        tail = this.parseTerm(0, false, false);
+        tail = this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true);
         this.expect(TOK.RBRACKET, ']');
         this.advance();
         break;
@@ -576,8 +610,33 @@ class Parser {
     this.advance();
     return compound('{}', [term]);
   }
-  parseTerm(minPrecedence = 0, allowComma = false, allowBar = true) {
-    let left = this.parsePrefixTerm(minPrecedence, allowBar);
+  parseFunctionalNotation(name) {
+    this.expect(TOK.LPAREN, '(');
+    this.advance();
+    const args = [];
+    if (this.token.type === TOK.RPAREN) {
+      throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(name)} for arity zero data`);
+    }
+    while (true) {
+      args.push(this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true));
+      if (this.token.type !== TOK.COMMA) break;
+      this.advance();
+    }
+    this.expect(TOK.RPAREN, ')');
+    this.advance();
+    return compound(name, args);
+  }
+  parseTerm(minPrecedence = 0, allowComma = false, allowBar = true, allowOperatorAtom = false) {
+    const initialOperatorName = this.operatorTokenName();
+    // An atom whose only operator declaration is postfix can still seed a
+    // postfix expression: after `op(100,xf,a), op(200,xf,b)`, `a b` denotes
+    // b(a).  Prefix and infix operator atoms cannot be bare operands.
+    const initialWasCurrentOperator = initialOperatorName != null &&
+      (this.infixOperators.has(initialOperatorName) ||
+       this.prefixOperators.has(initialOperatorName));
+    let left = this.parsePrefixTerm(minPrecedence, allowBar, allowOperatorAtom);
+    const leftIsBareOperatorAtom = initialWasCurrentOperator &&
+      left.type === ATOM && left.name === initialOperatorName;
     let strictPostfixPrecedence = null;
     while (true) {
       const op = this.token.type === TOK.COMMA && allowComma
@@ -591,15 +650,26 @@ class Parser {
         const postfix = postfixName == null ? null : this.postfixOperators.get(postfixName);
         if (!postfix || postfix.precedence < minPrecedence ||
             (strictPostfixPrecedence === postfix.precedence)) break;
+        if (this.strictIso && leftIsBareOperatorAtom) {
+          throw new Error(`parse line ${this.token.line}: operator atom ${left.name} requires parentheses as an operand`);
+        }
         const name = postfixName;
         this.advance();
         left = compound(name, [left]);
         strictPostfixPrecedence = postfix.strict ? postfix.precedence : null;
         continue;
       }
+      if (this.strictIso && leftIsBareOperatorAtom) {
+        throw new Error(`parse line ${this.token.line}: operator atom ${left.name} requires parentheses as an operand`);
+      }
       strictPostfixPrecedence = null;
       this.advance();
-      const right = this.parseTerm(info.associativity === 'right' ? info.precedence : info.precedence + 1, allowComma, allowBar);
+      const right = this.parseTerm(
+        info.associativity === 'right' ? info.precedence : info.precedence + 1,
+        allowComma,
+        allowBar,
+        false,
+      );
       left = compound(op, [left, right]);
       if (info.associativity === 'none') {
         const nextOp = this.token.type === TOK.COMMA && allowComma
@@ -612,18 +682,46 @@ class Parser {
         }
       }
     }
+    if (this.strictIso && leftIsBareOperatorAtom && left.type === ATOM && !allowOperatorAtom) {
+      throw new Error(`parse line ${this.token.line}: operator atom ${left.name} requires parentheses as an operand`);
+    }
     return left;
   }
-  parsePrefixTerm(minPrecedence = 0, allowBar = true) {
+  parsePrefixTerm(minPrecedence = 0, allowBar = true, allowOperatorAtom = false) {
     // `:-` is tokenized specially so the program grammar can recognize clause
     // and directive markers. In term argument position, however, ISO 6.3.3.1
     // permits an operator atom directly as an `arg`; a leading `:-` cannot be
     // prefix operator notation at argument priority, so it denotes the atom.
     if (this.token.type === TOK.IF) {
+      if (this.strictIso && !allowOperatorAtom) {
+        throw new Error(`parse line ${this.token.line}: operator atom :- requires argument context or parentheses`);
+      }
       this.advance();
       return atom(':-');
     }
     const operatorName = this.operatorTokenName();
+    // A negative number consists of a minus name token followed by a numeric
+    // token, with layout permitted between them. It is lexical number syntax,
+    // not an application of the current prefix `-` operator, and therefore
+    // remains valid even after op(0, fy, -).
+    if (operatorName === '-' && this.token.type === TOK.ATOM) {
+      const state = {
+        pos: this.pos,
+        line: this.line,
+        previousToken: this.previousToken,
+        token: this.token,
+      };
+      this.advance();
+      if (this.token.type === TOK.NUMBER && !this.token.text.startsWith('-')) {
+        const value = this.token.text;
+        this.advance();
+        return numberTerm(`-${value}`);
+      }
+      this.pos = state.pos;
+      this.line = state.line;
+      this.previousToken = state.previousToken;
+      this.token = state.token;
+    }
     if (operatorName != null && this.prefixOperators.get(operatorName)?.precedence >= minPrecedence) {
       const op = operatorName;
       const info = this.prefixOperators.get(op);
@@ -633,26 +731,30 @@ class Parser {
       // an argument delimiter there is no operand for prefix syntax, so keep
       // the operator as an atom instead of reporting a misleading bad-term
       // error.
-      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.BAR].includes(this.token.type)) {
+      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.BAR, TOK.DOT].includes(this.token.type)) {
+        if (this.strictIso && !allowOperatorAtom && this.token.type !== TOK.DOT) {
+          throw new Error(`parse line ${this.token.line}: operator atom ${op} requires argument context or parentheses`);
+        }
         return atom(op);
       }
       if (this.token.type === TOK.LPAREN && this.token.precededByLayout !== true) {
-        this.advance();
-        const args = [];
-        while (true) {
-          args.push(this.parseTerm(0, false, false));
-          if (this.token.type !== TOK.COMMA) break;
-          this.advance();
-        }
-        this.expect(TOK.RPAREN, ')');
-        this.advance();
-        return compound(op, args);
+        return this.parseFunctionalNotation(op);
       }
-      return compound(op, [this.parseTerm(info.precedence + (info.strict ? 1 : 0), false, allowBar)]);
+      return compound(op, [this.parseTerm(info.precedence + (info.strict ? 1 : 0), false, allowBar, false)]);
     }
     if (this.token.type === TOK.LPAREN) return this.parseParenthesizedTerm();
-    if (this.token.type === TOK.LBRACKET) return this.parseList();
-    if (this.token.type === TOK.LBRACE) return this.parseCurly();
+    if (this.token.type === TOK.LBRACKET) {
+      const list = this.parseList();
+      if (list.type === ATOM && list.name === '[]' && this.token.type === TOK.LPAREN &&
+          this.token.precededByLayout !== true) return this.parseFunctionalNotation('[]');
+      return list;
+    }
+    if (this.token.type === TOK.LBRACE) {
+      const curly = this.parseCurly();
+      if (curly.type === ATOM && curly.name === '{}' && this.token.type === TOK.LPAREN &&
+          this.token.precededByLayout !== true) return this.parseFunctionalNotation('{}');
+      return curly;
+    }
     if (this.token.type === TOK.VAR) {
       const name = this.token.text;
       this.advance();
@@ -668,21 +770,7 @@ class Parser {
       const value = this.token.text;
       this.advance();
       if (this.parserFlagState.doubleQuotes === 'atom') {
-        if (this.token.type === TOK.LPAREN) {
-          this.advance();
-          const args = [];
-          if (this.token.type === TOK.RPAREN) {
-            throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(value)} for arity zero data`);
-          }
-          while (true) {
-            args.push(this.parseTerm(0, false, false));
-            if (this.token.type !== TOK.COMMA) break;
-            this.advance();
-          }
-          this.expect(TOK.RPAREN, ')');
-          this.advance();
-          return compound(value, args);
-        }
+        if (this.token.type === TOK.LPAREN && this.token.precededByLayout !== true) return this.parseFunctionalNotation(value);
         return atom(value);
       }
       const items = Array.from(value, (character) =>
@@ -701,23 +789,12 @@ class Parser {
     if (this.token.type === TOK.ATOM) {
       const name = this.token.text;
       this.advance();
-      if (this.token.type === TOK.LPAREN) {
-        this.advance();
-        const args = [];
-        if (this.token.type === TOK.RPAREN) {
-          throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(name)} for arity zero data`);
-        }
-        while (true) {
-          args.push(this.parseTerm(0, false, false));
-          if (this.token.type === TOK.COMMA) {
-            this.advance();
-            continue;
-          }
-          break;
-        }
-        this.expect(TOK.RPAREN, ')');
-        this.advance();
-        return compound(name, args);
+      if (this.token.type === TOK.LPAREN && this.token.precededByLayout !== true) {
+        return this.parseFunctionalNotation(name);
+      }
+      if (this.strictIso && !allowOperatorAtom &&
+          (this.infixOperators.has(name) || this.prefixOperators.has(name) || this.postfixOperators.has(name))) {
+        throw new Error(`parse line ${this.token.line}: operator atom ${name} requires argument context or parentheses`);
       }
       return atom(name);
     }
@@ -842,7 +919,7 @@ class Parser {
         this.token = headState.token;
       };
 
-      let head = this.parseTerm(3);
+      let head = this.parseTerm(3, false, true, true);
       if (this.token.type === TOK.COMMA && !this.strictIso) {
         restoreHeadState();
         const quadId = this.parseTerm(3, true);
@@ -852,7 +929,7 @@ class Parser {
           continue;
         }
         restoreHeadState();
-        head = this.parseTerm(3);
+        head = this.parseTerm(3, false, true, true);
       }
 
       // Outside quad syntax, preserve the existing program-level comma rule,
@@ -1387,11 +1464,13 @@ export function parseNumberTokenText(text) {
   const digitsStart = position;
   while (isDigitCode(source.charCodeAt(position))) position++;
   if (position === digitsStart) throw new Error('not exactly one number token');
+  let hasFraction = false;
   if (source[position] === '.' && isDigitCode(source.charCodeAt(position + 1))) {
+    hasFraction = true;
     position++;
     while (isDigitCode(source.charCodeAt(position))) position++;
   }
-  if (source[position] === 'e' || source[position] === 'E') {
+  if (hasFraction && (source[position] === 'e' || source[position] === 'E')) {
     position++;
     if (source[position] === '+' || source[position] === '-') position++;
     const exponentStart = position;
@@ -1399,6 +1478,8 @@ export function parseNumberTokenText(text) {
     if (position === exponentStart) throw new Error('not exactly one number token');
   }
   if (position !== source.length) throw new Error('not exactly one number token');
+  if (/^-?\d+$/.test(source)) return numberTerm(BigInt(source).toString());
+  if (Object.is(Number(source), -0)) return numberTerm('0.0');
   return numberTerm(source);
 }
 

package/src/program.js

@@ -5,6 +5,7 @@ import { numberValueKey } from './number-value.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
+  PART3_OPERATOR_DEFINITIONS,
   QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
   parseClauses,
@@ -106,7 +107,7 @@ export class Program {
     this.operators = new Map();
     const predefinedOperatorSets = this.strictIso
       ? [ISO_OPERATOR_DEFINITIONS]
-      : [ISO_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS];
+      : [ISO_OPERATOR_DEFINITIONS, PART3_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS];
     for (const definitions of predefinedOperatorSets) {
       for (const [priority, specifier, name] of definitions) {
         this.defineOperator(priority, specifier, name);

package/src/syntax-scan.js

@@ -34,6 +34,11 @@ export function characterCodeConstantEnd(source, apostropheIndex) {
   const characterIndex = apostropheIndex + 1;
   const character = source[characterIndex] ?? '';
   if (!character) return apostropheIndex;
+  // `0''` is two tokens (0 and the empty atom), and `0'\\\n...'
+  // likewise starts a quoted atom containing a continuation. Only `0'''`
+  // denotes the character-code constant for an apostrophe.
+  if (character === "'" && source[characterIndex + 1] !== "'") return null;
+  if (character === '\\' && ['\n', '\r'].includes(source[characterIndex + 1])) return null;
   if (character === '\\') return quotedEscapeEnd(source, characterIndex);
 
   // An apostrophe character is doubled in 0''' exactly as it is in a quoted

package/src/write.js

@@ -28,6 +28,7 @@ function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
   if (name === '...') return false;
+  if (name.startsWith('/*')) return true;
   if (name === '\\+' || name === '+' || name === '-' || name === '\\') return true;
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
   for (const ch of name) if (!graphicAtomCharacters.has(ch)) return true;
@@ -104,6 +105,7 @@ function writeNumberedVariable(index) {
 }
 
 function operatorName(name) {
+  if (name === '.' || name.startsWith('/*')) return quoteAtom(name);
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return name;
   if (/^[!#$&*+\-./<=>@^~\\;:]+$/.test(name)) return name;
   return quoteAtom(name);
@@ -142,6 +144,12 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
     // `arg` production: an atom that is a current operator is valid there
     // without quoting. Keep lexical exceptions such as `|` quoted.
     if (options.operatorAtomsAsArgs && context === 'argument' && table.has(resolved.name)) return operatorName(resolved.name);
+    if (!options.ignoreOps && context !== 'argument' && table.has(resolved.name)) {
+      const definitions = table.get(resolved.name);
+      const requiresParentheses = definitions.some(({ specifier }) =>
+        ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(specifier));
+      if (requiresParentheses) return `(${operatorName(resolved.name)})`;
+    }
     return writeAtom(resolved.name);
   }
   if (resolved.type === NUMBER) return resolved.name;
@@ -186,11 +194,20 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         const argumentPriority = specifier === 'fx' ? priority - 1 : priority;
         text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
       } else if (specifier === 'xf' || specifier === 'yf') {
-        const argumentPriority = specifier === 'xf' ? priority - 1 : priority;
+        let argumentPriority = specifier === 'xf' ? priority - 1 : priority;
+        const childDefinition = chooseOperator(deref(resolved.args[0], env), table);
+        if (childDefinition?.priority === priority &&
+            ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(childDefinition.specifier)) {
+          argumentPriority = priority - 1;
+        }
         text = `${format(resolved.args[0], env, options, table, argumentPriority)} ${token}`;
       } else {
-        const leftPriority = specifier === 'yfx' ? priority : priority - 1;
+        let leftPriority = specifier === 'yfx' ? priority : priority - 1;
         const rightPriority = specifier === 'xfy' ? priority : priority - 1;
+        const leftDefinition = chooseOperator(deref(resolved.args[0], env), table);
+        if (leftDefinition?.priority === priority && ['fx', 'fy'].includes(leftDefinition.specifier)) {
+          leftPriority = priority - 1;
+        }
         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}`

package/test/conformance/ISO-COMPLIANCE.md

@@ -18,7 +18,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Requirement | Status | EyeProlog evidence / remaining work |
 | --- | --- | --- |
-| 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the selected WG17 high-risk syntax case. Complete character-by-character external syntax sweep remains open. |
+| 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the [complete 366-case WG17 syntax matrix](WG17-SYNTAX-STATUS.md). Wider shall-by-shall text-processing audit remains open. |
 | 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. A normative goal-semantics ledger is still being expanded. |
 | 5.1(c) reject nonconforming text/read-terms | audit | Dedicated syntax-error cases and strict-core extension rejection. Exhaustive lexical rejection coverage remains open. |
 | 5.1(d) document permitted variations | audit | Major implementation-defined choices are documented in *The Art of EyeProlog*. Every occurrence of “implementation defined/dependent/specific” in Part 1 still needs a final documentation cross-check. |
@@ -30,7 +30,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, `wg17_syntax_high_risk`, quoted-layout/escape error cases, writer/read-back regressions. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete 366-case WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, and writer/read-back regressions. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates. |
 | 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Cross-text `multifile/1` and ordering constraints require explicit shall-by-shall audit. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access. Public/private and multi-text requirements still need complete mapping. |
@@ -75,6 +75,7 @@ A release intended to advance ISO conformance must pass all of:
 npm test
 npm run test:iso-strict
 npm run test:conformance
+npm run test:wg17-syntax
 ```
 
 The unified `npm test` gate includes the strict-core suite. Expected conformance
@@ -88,9 +89,9 @@ ISO/IEC 13211-1 processor” until all of the following are true:
 1. every normative Part 1 processor requirement is represented in this ledger;
 2. every `audit` row above has been reduced to explicit pass/not-applicable or
    documented implementation-defined choices;
-3. the complete external WG17 syntax/conversion/variable-name conformity
-   corpus has been run against the strict core mode, with every difference
-   explained or fixed;
+3. the external WG17 conversion and variable-name conformity corpora have
+   joined the now-complete syntax corpus in strict core mode, with every
+   difference explained or fixed;
 4. prescribed modes, errors, side effects, and relevant error precedence for
    every Part 1 built-in have executable coverage;
 5. every implementation-defined/dependent/specific choice required to be

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

@@ -0,0 +1,42 @@
+# WG17 syntax traceability status
+
+Source: [Conformity Testing I: Syntax](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing)  
+Upstream inventory checked: 2026-08-15
+
+This ledger counts an upstream case only when its WG17 identifier, query,
+expected ISO disposition, and observed EyeProlog outcome are stored in the
+offline executable matrix. Semantically similar parser tests are not inferred
+as coverage.
+
+## Current standing
+
+| Measure | Count |
+| --- | ---: |
+| Active upstream cases | 366 |
+| Executable EyeProlog dispositions | 366 (100.0%) |
+| Not yet traced one-by-one | 0 |
+| Deleted upstream identifiers | #20, #273 |
+
+The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
+three upstream `waits` cases are checked through EyeProlog's interactive input
+hook; the other 363 cases are checked for their exact stored
+success output, bindings, failure, or ISO error category.
+
+## Traceable evidence
+
+| Executable evidence | Referenced IDs | WG17 cases |
+| --- | ---: | --- |
+| [complete offline executable matrix](../run-wg17-syntax.mjs) | 366 | #1–#19, #21–#272, #274–#368 |
+
+The evidence groups overlap. Their union is **366** active cases:
+#1–#19, #21–#272, #274–#368.
+
+## Untraced upstream identifiers
+
+None.
+
+## Maintenance
+
+1. Refresh the dated fixture when the upstream table changes.
+2. Review any changed ISO expectation before updating an observed snapshot.
+3. Keep this generated status page synchronized in the release gate.