eyeprolog 1.2.37 → 1.2.38

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.37",
+  "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/write.js

@@ -227,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) {

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';
@@ -782,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