eyeprolog 1.2.12 → 1.2.13

package/package.json

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

package/src/parser.js

@@ -746,11 +746,11 @@ class Parser {
     const accept = emit ?? ((clause) => clauses.push(clause));
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
-      // In the normal EyeProlog profile, canonical functional ?-/1 and
-      // ?-/2 notation denotes the same quad marker as the corresponding
-      // operator notation.  Keep the existing operator-form query parsing so
-      // a query containing comma remains wholly to the right of `?-`, while
-      // functional notation is parsed as a term and then decomposed by arity.
+      // Prefix operator notation needs one program-level distinction so
+      // a comma in `?- A, B.` remains inside the query rather than outside the
+      // prefix term. Ordinary functional notation is parsed as a term and then
+      // recognized structurally by parseQuadTerm; further equivalent spellings
+      // are recognized after the general head parser below.
       if (this.operatorTokenName() === '?-' && !this.strictIso) {
         if (this.peek() === '(') {
           const quadTerm = this.parseTerm(0, true);
@@ -818,6 +818,14 @@ class Parser {
         head = items.pop();
         while (items.length > 0) head = compound(',', [items.pop(), head]);
       }
+      // Parentheses and other ordinary term syntax may hide the surface ?-
+      // token from the program-level dispatch above.  Once the complete head
+      // term has been parsed, recognize the same ?-/1 or ?-/2 structure here.
+      // Requiring the following dot prevents an ordinary rule whose head just
+      // happens to be ?-/1 or ?-/2 from being consumed as a quad mid-clause.
+      if (!this.strictIso && this.token.type === TOK.DOT && this.parseQuadTerm(head, line, accept)) {
+        continue;
+      }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {
           // There is no predefined infix ?-/2 in strict core mode.  If a

package/test/run-regression.mjs

@@ -222,7 +222,7 @@ why(
       },
     },
     {
-      name: 'quad parser treats operator and functional ?- notation equivalently',
+      name: 'quad parser treats regular term spellings of ?- equivalently',
       run: () => {
         const labelled = Program.parse(
           `0,passes
@@ -253,9 +253,28 @@ why(
         const functionalReport = publicApi.runQuads(functional);
         assertEqual(functionalReport.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'functional quad report');
 
-        const strict = Program.parse(`?-(','(0,passes),=(X,1)).\n`, { isoStrict: true });
+        // Issue #11 is about ordinary term syntax, not one privileged
+        // canonical spelling. Parentheses, quoted functor syntax, and mixed
+        // operator/functional notation must all denote the same ?-/2 term and
+        // therefore the same quad in the normal EyeProlog profile.
+        for (const [name, source] of [
+          ['mixed', `?-((0,passes), X = 1).\n   X = 1.\n`],
+          ['parenthesized', `(?-(','(0,passes),=(X,1))).\n   X = 1.\n`],
+          ['parenthesized mixed', `(?-((0,passes), X = 1)).\n   X = 1.\n`],
+          ['quoted functor', `'?-'(','(0,passes),=(X,1)).\n   X = 1.\n`],
+          ['quoted parenthesized', `('?-'(','(0,passes),=(X,1))).\n   X = 1.\n`],
+        ]) {
+          const regular = Program.parse(source);
+          assertEqual(regular.quads.length, 1, `${name} quad count`);
+          assertEqual(regular.clauses.length, 0, `${name} quad clause count`);
+          assertEqual(termToString(regular.quads[0].id), termToString(labelled.quads[0].id), `${name} label`);
+          assertEqual(termToString(regular.quads[0].query), termToString(labelled.quads[0].query), `${name} query`);
+          assertEqual(publicApi.runQuads(regular).stdout, 'quads: 1 run, 1 passed, 0 failed.\n', `${name} report`);
+        }
+
+        const strict = Program.parse(`(?-(','(0,passes),=(X,1))).\n`, { isoStrict: true });
         assertEqual(strict.quads.length, 0, 'strict mode has no quads');
-        assertEqual(strict.clauses.length, 1, 'strict functional ?-/2 remains an ordinary term');
+        assertEqual(strict.clauses.length, 1, 'strict ?-/2 remains an ordinary term');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -5156,10 +5156,12 @@ 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. At top level in the normal EyeProlog profile, the quad marker is recognized
-after term parsing, so equivalent syntax stays equivalent: `Label ?- Query.`
-and canonical `?-(Label, Query).` denote the same labelled quad when followed
-by its indented answer descriptions. In `--iso-strict` mode this quad
-interpretation is disabled, and `?-/2` remains ordinary Prolog term syntax.
+from the parsed `?-/1` or `?-/2` term rather than from one privileged surface
+spelling. Thus `Label ?- Query.`, `?-(Label, Query).`, mixed forms such as
+`?-((Label), Query).`, quoted-functor notation, and a parenthesized whole
+`(?-(Label, Query)).` denote the same quad when followed by indented answer
+descriptions. In `--iso-strict` mode this quad interpretation is disabled, and
+`?-/2` remains ordinary Prolog term syntax.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -6432,9 +6434,11 @@ Trealla and the ISO Prolog working examples. Because answer descriptions are
 layout-sensitive, indent every description while keeping ordinary clause heads
 and the next quad query at the left margin. A quad label may contain any number
 of comma-separated metadata fields, including across layout before `?-`; for
-example `9, "case", passes ?- Goal.` is one labelled query. Canonical
-functional notation is semantically equivalent: `?-(Label, Query).` followed by
-the same indented answer descriptions creates the same labelled quad as
+example `9, "case", passes ?- Goal.` is one labelled query. Quad recognition
+is structural after ordinary term parsing: functional, mixed, quoted-functor,
+and parenthesized spellings of the same `?-/1` or `?-/2` term are semantically
+equivalent. For example `?-(Label, Query).` and `(?-(Label, Query)).`, followed
+by the same indented answer descriptions, create the same labelled quad as
 `Label ?- Query.`.
 
 Statistics are comparative evidence, not a score in isolation. Preserve the