eyeprolog 1.1.21 → 1.1.23

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 165 | 209 | 0 | 0 | 374 |
+| iso | 166 | 209 | 0 | 0 | 375 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **480** | **260** | **19** | **21** | **780** |
+| **Total** | **481** | **260** | **19** | **21** | **781** |

package/package.json

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

package/src/parser.js

@@ -39,6 +39,7 @@ const graphicAtomChars = '#$&*+-./<=>@^~\\:';
 // canonical notation. Commas remain separators except inside parentheses.
 const INFIX_OPERATORS = new Map([
   [':-', { precedence: 1, associativity: 'none' }],
+  ['?-', { precedence: 1, associativity: 'none' }], // quad label extension
   ['-->', { precedence: 1, associativity: 'none' }],
   ['|', { precedence: 96, associativity: 'right' }],
   [';', { precedence: 101, associativity: 'right' }],
@@ -77,14 +78,15 @@ const INFIX_OPERATORS = new Map([
   ['^', { precedence: 1001, associativity: 'right' }],
 ]);
 const PREFIX_OPERATORS = new Map([
-  ['\\+', 301],
-  ['+', 1001],
-  ['-', 1001],
-  ['\\', 1001],
+  ['?-', { precedence: 1, strict: true }],
+  ['\\+', { precedence: 301, strict: false }],
+  ['+', { precedence: 1001, strict: false }],
+  ['-', { precedence: 1001, strict: false }],
+  ['\\', { precedence: 1001, strict: false }],
 ]);
 
 export const ISO_OPERATOR_DEFINITIONS = [
-  [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'xfx', '-->'],
+  [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'fx', '?-'], [1200, 'xfx', '-->'],
   [1105, 'xfy', '|'],
   [1100, 'xfy', ';'], [1050, 'xfy', '->'], [1000, 'xfy', ','],
   [900, 'fy', '\\+'],
@@ -97,6 +99,13 @@ export const ISO_OPERATOR_DEFINITIONS = [
   [200, 'fy', '+'], [200, 'fy', '-'], [200, 'fy', '\\'],
 ];
 
+// 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.
+export const QUAD_OPERATOR_DEFINITIONS = [
+  [1200, 'xfx', '?-'],
+];
+
 const CLPZ_OPERATOR_DEFINITIONS = [
   [760, 'yfx', '#<==>'], [750, 'xfy', '#==>'], [750, 'yfx', '#<=='],
   [740, 'yfx', '#\\/'], [730, 'yfx', '#\\'], [720, 'yfx', '#/\\'],
@@ -133,9 +142,7 @@ function defineParserOperator(state, priority, specifier, name) {
 export function createParserOperatorState(definitions = [], includeDefaults = true) {
   const state = {
     infixOperators: includeDefaults ? new Map(INFIX_OPERATORS) : new Map(),
-    prefixOperators: includeDefaults
-      ? new Map([...PREFIX_OPERATORS].map(([name, precedence]) => [name, { precedence, strict: false }]))
-      : new Map(),
+    prefixOperators: includeDefaults ? new Map(PREFIX_OPERATORS) : new Map(),
     postfixOperators: new Map(),
   };
   for (const definition of definitions) {
@@ -225,6 +232,11 @@ class Parser {
   }
   operatorTokenName(token = this.token) {
     if (token.type === TOK.ATOM) return token.text;
+    // `:-` has its own token because it also introduces clauses/directives,
+    // but ISO 6.3.3.1 still permits an operator atom as an argument. Treat the
+    // token as the ordinary operator name while parsing terms; the surrounding
+    // grammar decides whether it is operator notation or atom data.
+    if (token.type === TOK.IF) return ':-';
     if (token.type === TOK.STRING && this.parserFlagState.doubleQuotes === 'atom') return token.text;
     return null;
   }
@@ -533,6 +545,14 @@ class Parser {
     return left;
   }
   parsePrefixTerm(minPrecedence = 0, allowBar = true) {
+    // `:-` 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) {
+      this.advance();
+      return atom(':-');
+    }
     const operatorName = this.operatorTokenName();
     if (operatorName != null && this.prefixOperators.get(operatorName)?.precedence >= minPrecedence) {
       const op = operatorName;

package/src/program.js

@@ -4,6 +4,7 @@ import { ATOM, COMPOUND, VAR, Env, atom, compound, deref, flattenConjunction, is
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
+  QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
   parseClauses,
   parseClausesInto,
@@ -101,8 +102,10 @@ export class Program {
     this.moduleMetaPredicates = new Map();
     this.dynamicPredicates = new Set();
     this.operators = new Map();
-    for (const [priority, specifier, name] of ISO_OPERATOR_DEFINITIONS) {
-      this.defineOperator(priority, specifier, name);
+    for (const definitions of [ISO_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS]) {
+      for (const [priority, specifier, name] of definitions) {
+        this.defineOperator(priority, specifier, name);
+      }
     }
     this.initializations = [];
     this.quads = [];

package/test/conformance/README.md

@@ -94,7 +94,7 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 374 cases in `iso/` and 780 file-based conformance cases in
+The corpus has 375 cases in `iso/` and 781 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.

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

@@ -0,0 +1,14 @@
+% ISO 6.3.3.1: an arg may be an atom which is an operator.
+
+%% goal: operator_atoms(Priority, Specifier, List)
+
+operator_atoms(Priority, Specifier, List) :-
+    current_op(Priority, Specifier, :-),
+    List = [:-,-].
+
+% ISO 6.3.4.4, Table 7: ?- is a predefined 1200 fx operator.
+
+%% goal: query_prefix_operator(ok)
+
+query_prefix_operator(ok) :-
+    current_op(1200, fx, ?-).

package/test/conformance/expected/iso/operator_atoms_as_arguments.pl

@@ -0,0 +1,3 @@
+operator_atoms(1200, xfx, [':-', '-']).
+operator_atoms(1200, fx, [':-', '-']).
+query_prefix_operator(ok).

package/test/run-regression.mjs

@@ -940,6 +940,42 @@ c4 ?- call((!;1)).
         assertEqual(program.findGroup('b', 0).clauses.length, 1, 'b/0 count');
       },
     },
+    {
+      name: 'ISO operator atoms are valid functional and list arguments',
+      run: () => {
+        const source = [
+          'operator_argument(ok) :- current_op(1200, xfx, :-), [:-,-] = [:-,-].',
+          '',
+        ].join('\n');
+        assertEqual(run(source, { goal: 'operator_argument(ok)' }).stdout, 'operator_argument(ok).\n', 'operator argument syntax');
+      },
+    },
+    {
+      name: 'ISO query operator and quad infix extension are visible through current_op/3',
+      run: () => {
+        assertEqual(
+          run('', { goal: 'current_op(Priority, Specifier, ?-)' }).stdout,
+          "current_op(1200, fx, '?-').\ncurrent_op(1200, xfx, '?-').\n",
+          'query operator definitions',
+        );
+        assertEqual(
+          run('', { goal: 'current_op(1200, fx, ?-)' }).stdout,
+          "current_op(1200, fx, '?-').\n",
+          'ISO query prefix operator',
+        );
+        assertEqual(
+          run('', { goal: 'current_op(1200, xfx, ?-)' }).stdout,
+          "current_op(1200, xfx, '?-').\n",
+          'quad query infix operator',
+        );
+        const prefix = parseGoalText('(?- true)');
+        assertEqual(prefix.name, '?-', 'prefix query functor');
+        assertEqual(prefix.arity, 1, 'prefix query arity');
+        const infix = parseGoalText('(label ?- true)');
+        assertEqual(infix.name, '?-', 'quad query functor');
+        assertEqual(infix.arity, 2, 'quad query arity');
+      },
+    },
     {
       name: 'term input keeps dotted operators intact and uses program operators',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5120,7 +5120,17 @@ The fact is exactly `reports(sensor_7, temperature)`. Priority determines
 binding strength, and `fx`, `fy`, `xf`, `yf`, `xfx`, `xfy`, and `yfx`
 determine position and associativity. `current_op/3` inspects the table;
 `op(0, Specifier, Name)` removes a definition. Because declarations affect
-parsing of subsequent text, place them before their first use.
+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. 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
+syntax is supported it additionally exposes `?-` at priority 1200 with
+specifier `xfx` as an implementation-specific operator. Consequently
+`current_op(Priority, Specifier, ?-)` enumerates both definitions.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -5286,8 +5296,10 @@ clause ends in a period. The grammar above gives the canonical term shapes.
 The initial operator table contains the following ISO-style operators, all
 lowered to ordinary compound terms:
 
-- prefix: `\+`, unary `+`, unary `-`, and `\`;
+- prefix: ISO `?-`, `\+`, unary `+`, unary `-`, and `\`;
 - control: `,`, `;`, and `->`;
+- quad syntax extension: `?-` is also a priority-1200 `xfx` operator so a
+  label may precede a quad query;
 - grammar rules: `-->` and the Part 3 alternative `|`;
 - unification and comparison: `=`, `\=`, `==`, `\==`, `@<`, `@=<`, `@>`,
   `@>=`, `is`, `=:=`, `=\=`, `<`, `=<`, `>`, and `>=`;
@@ -6845,7 +6857,7 @@ node test/run-conformance-report.mjs
 ```
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 780 cases, including 374 focused ISO
+contains 781 cases, including 375 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 189 normal