eyeprolog 1.2.36 → 1.2.38

package/package.json

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

package/src/parser.js

@@ -606,7 +606,9 @@ class Parser {
       this.advance();
       return atom('{}');
     }
-    const term = this.parseTerm(0, true);
+    // As with a parenthesized term, a current operator atom may be the entire
+    // curly-bracket content: `{*}` denotes {}(*), not an incomplete infix use.
+    const term = this.parseTerm(0, true, true, true);
     this.expect(TOK.RBRACE, '}');
     this.advance();
     return compound('{}', [term]);
@@ -732,7 +734,7 @@ 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, TOK.DOT].includes(this.token.type)) {
+      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.RBRACE, TOK.BAR, TOK.DOT].includes(this.token.type)) {
         if (!allowOperatorAtom && this.token.type !== TOK.DOT) {
           throw new Error(`parse line ${this.token.line}: operator atom ${op} requires argument context or parentheses`);
         }

package/src/repl.js

@@ -617,6 +617,7 @@ function formatAnswer(engine, state, variables, env) {
       // current operator atoms in argument and list-element positions without
       // quotes, just as writeq/1 already prints them.
       operatorAtomsAsArgs: true,
+      dottedGraphicAtoms: true,
       doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
     })}`);
   }

package/src/write.js

@@ -5,6 +5,7 @@ import {
 } from './term.js';
 
 const graphicAtomCharacters = new Set('!#$&*+-/<=>?@^~\\'.split(''));
+const dottedGraphicAtomCharacters = new Set([...graphicAtomCharacters, '.']);
 const compactInfixOperators = new Set([':', '..']);
 
 function quotedControlEscape(ch) {
@@ -48,6 +49,11 @@ function writeAtom(name) {
   return atomNeedsQuotes(name) ? quoteAtom(name) : name;
 }
 
+function isDottedGraphicAtom(name) {
+  return name.includes('.') && [...name].some((ch) => ch !== '.') && !name.startsWith('/*') &&
+    [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
+}
+
 function legacyVariableToIso(name) {
   if (name === '?') return '_';
   const tail = name.slice(1);
@@ -172,6 +178,10 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   if (resolved.type === STRING) return writeString(resolved.name);
   if (resolved.type === ATOM) {
     if (!options.quoted) return resolved.name;
+    // Top-level bindings are already delimited by their answer punctuation.
+    // Keep valid dotted graphic tokens readable there without weakening the
+    // ISO writeq/1 policy tested by WG17 #308.
+    if (options.dottedGraphicAtoms && isDottedGraphicAtom(resolved.name)) return resolved.name;
     // ISO 6.3.3.1 gives functional arguments and list elements a special
     // `arg` production: an atom that is a current operator is valid there
     // without quoting. Keep lexical exceptions such as `|` quoted.
@@ -217,7 +227,9 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   }
 
   if (!options.ignoreOps && resolved.name === '{}' && resolved.arity === 1) {
-    return `{${format(resolved.args[0], env, options, table, 1200)}}`;
+    // A current operator atom is valid as the complete curly-bracket content,
+    // just as it is in a functional argument or list element.
+    return `{${format(resolved.args[0], env, options, table, 1200, 'argument')}}`;
   }
 
   if (!options.ignoreOps) {
@@ -269,6 +281,7 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     variableNames: printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
+    dottedGraphicAtoms: options.dottedGraphicAtoms === true,
   };
   const maxPriority = Number.isInteger(options.maxPriority)
     ? Math.max(0, Math.min(1200, options.maxPriority))

package/test/conformance/cases/iso/lexical_and_curly_terms.pl

@@ -9,6 +9,7 @@ answer(Binary, Octal, Hex, Character, Escaped, Curly, EmptyCurly, IntegerPart, F
     =(Character, 0'\n),
     =(Escaped, 'A\x42\\101\'),
     =(Curly, {pair(a, b)}),
+    {*} = {}(*),
     =(EmptyCurly, {}),
     IntegerPart is float_integer_part(-3.75),
     FractionalPart is float_fractional_part(-3.75).

package/test/run-regression.mjs

@@ -38,7 +38,7 @@ import {
   variantTerms,
   parseProgramText,
 } from '../src/index.js';
-import { parseGoalText, parseNumberTokenText } from '../src/parser.js';
+import { ISO_OPERATOR_DEFINITIONS, parseGoalText, parseNumberTokenText } from '../src/parser.js';
 import { compareTerms } from '../src/term.js';
 import { formatTermForWrite } from '../src/write.js';
 import { selectClauseCandidates } from '../src/program.js';
@@ -764,7 +764,8 @@ c4 ?- call((!;1)).
           input: 'read(T).\n./*. .\nread(T).\nok.\nread(T).\n!.!.\nhalt.\n',
         });
         assertEqual(repl.status, 0, 'REPL exit status');
-        assertIncludes(repl.stdout, "T = './*.'.", 'REPL dotted graphic atom answer');
+        assertIncludes(repl.stdout, 'T = ./*..', 'REPL dotted graphic atom answer');
+        assertNotIncludes(repl.stdout, "T = './*.'", 'REPL dotted graphic atom has no spurious quotes');
         assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
         assertIncludes(repl.stdout, 'error(syntax_error(read_term), eyeprolog)', 'REPL syntax error');
         assertEqual(repl.stderr, '', 'REPL stderr');
@@ -781,6 +782,38 @@ c4 ?- call((!;1)).
         assertNotIncludes(result.stdout, "'?-'", 'writeq(?-) has no quotes');
       },
     },
+    {
+      name: 'curly brackets accept ISO and custom operator atoms (issue #41)',
+      run: () => {
+        const operatorNames = [...new Set(ISO_OPERATOR_DEFINITIONS.map(([, , name]) => name))]
+          .filter((name) => name !== ',');
+        for (const name of operatorNames) {
+          const holder = parseGoalText(`holder({${name}})`);
+          const curly = holder.args[0];
+          assertEqual(curly.name, '{}', `curly functor for ${name}`);
+          assertEqual(curly.args[0].name, name, `curly operator atom ${name}`);
+        }
+
+        const customProgram = parseProgramText([
+          ':- op(100, fx, pre).',
+          ':- op(100, xf, post).',
+          ':- op(100, xfx, infix).',
+          'custom({pre}, {post}, {infix}).',
+          '',
+        ].join('\n'));
+        const custom = customProgram.find((clause) => clause.head.name === 'custom').head;
+        assertEqual(
+          custom.args.map((curly) => curly.args[0].name).join(','),
+          'pre,post,infix',
+          'custom prefix, postfix, and infix operator atoms',
+        );
+
+        const repl = runCli([], { input: 'read(T).\n{*}.\nhalt.\n' });
+        assertEqual(repl.status, 0, 'curly operator REPL status');
+        assertIncludes(repl.stdout, 'T = {*}.', 'curly operator REPL answer');
+        assertNotIncludes(repl.stdout, '{(*)}', 'curly operator has no unnecessary parentheses');
+      },
+    },
     {
       name: 'normal parser rejects non-conforming bare operator operands',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5197,12 +5197,14 @@ parsing of subsequent text, place them before their first use. ISO argument
 syntax also permits an atom that is currently an operator to appear directly
 as a functional argument or list element, so forms such as
 `current_op(Priority, Specifier, :-)` and `[:-,-]` are valid without quoting
-or parenthesizing those operator atoms. Term output observes the same `arg`
-rule: with `quoted(true)`, an operator atom is not quoted merely because it is
-an operator when it occurs as a functional argument or list element. Thus
-`writeq([:-,-])` emits `[:-,-]`, and `writeq(f(;,'|',';;'))` emits
-`f(;,'|',';;')`; the bar stays quoted because ISO treats the unquoted `|`
-token as a list separator rather than an atom. The ISO initial operator table also
+or parenthesizing those operator atoms. A current operator atom may likewise
+be the complete content of parentheses or curly brackets: `(+)` denotes the
+atom `+`, and `{*}` denotes the curly term `{}(*)`. Term output observes the
+same context rules: with `quoted(true)`, an operator atom is not quoted merely
+because it occurs as a functional argument, list element, or sole curly-bracket
+content. Thus `writeq({*})` emits `{*}`, `writeq([:-,-])` emits `[:-,-]`, and
+`writeq(f(;,'|',';;'))` emits `f(;,'|',';;')`; the bar stays quoted because
+ISO treats the unquoted `|` token as a list separator rather than an atom. The ISO initial operator table also
 contains `?-` at priority 1200 with specifier `fx`, so
 `current_op(1200, fx, ?-)` succeeds. EyeProlog's embedded quad syntax permits
 an optional label before the query marker (`Label ?- Query.`), so while quad