eyelang 2.0.0 → 4.0.1

package/README.md

@@ -3,9 +3,9 @@
 [![npm version](https://img.shields.io/npm/v/eyelang.svg)](https://www.npmjs.com/package/eyelang)
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20761726-blue.svg)](https://doi.org/10.5281/zenodo.20761726)
 
-Eyelang is a small logic programming language for facts, rules, goals, answers, and proofs.
-Its source syntax is Prolog-like Horn-clause syntax with deliberate eyelang choices, including ISO Prolog-style `X` variables, explicit `table(path, 2).` declarations for tabled predicates, advisory `mode/3` declarations for host tooling, explicit Herbrand witness terms for executable existential-style consequences, and stratified-negation diagnostics for portable `not/1` usage.
-It grew out of logic-language experiments in the EYE/N3 reasoning tradition, but is packaged here as its own project.
+Eyelang is a small reasoning language for turning facts and rules into answers and proofs.
+
+Prolog-like syntax. Small core. Inspectable results.
 
 ## Install and run
 
@@ -14,15 +14,15 @@ Eyelang has no runtime npm dependencies and no build step. From a source checkou
 ```bash
 node bin/eyelang.js examples/ancestor.pl
 node bin/eyelang.js --proof examples/socrates.pl
-node bin/eyelang.js --warnings examples/policy.pl
+node bin/eyelang.js --warnings test/conformance/warnings/negation/unstratified_mutual.pl
 printf 'works(stdin, true) :- eq(ok, ok).\n' | node bin/eyelang.js -
 ```
 
 For one-off local CLI use from the checkout, npm can run the package bin without a manual symlink:
 
 ```bash
-npm exec -- eyelang --version
-npm exec -- eyelang examples/ancestor.pl
+npm exec --yes --package=. -- eyelang --version
+npm exec --yes --package=. -- eyelang examples/ancestor.pl
 ```
 
 To install the checkout's `eyelang` command on your `PATH`, use npm's package link:
@@ -68,4 +68,3 @@ npm run conformance:report
 npm run test:examples
 npm run test:regression
 ```
-

package/docs/guide.md

@@ -36,8 +36,8 @@ printf 'works(stdin, true) :- eq(ok, ok).\n' | node bin/eyelang.js -
 You can also use npm's local package-bin runner from the checkout:
 
 ```sh
-npm exec -- eyelang --version
-npm exec -- eyelang examples/ancestor.pl
+npm exec --yes --package=. -- eyelang --version
+npm exec --yes --package=. -- eyelang examples/ancestor.pl
 ```
 
 To make the `eyelang` command available on your `PATH` while developing this checkout, prefer npm's package link instead of a manual symlink:
@@ -51,7 +51,7 @@ eyelang --version
 
 ## Running eyelang
 
-The commands in this section use `eyelang` for readability. In a source checkout where you have not run `npm link` or `npm install -g .`, replace `eyelang` with `node bin/eyelang.js`, or run the command through `npm exec -- eyelang`.
+The commands in this section use `eyelang` for readability. In a source checkout where you have not run `npm link` or `npm install -g .`, replace `eyelang` with `node bin/eyelang.js`, or run the command through `npm exec --yes --package=. -- eyelang`.
 
 Show the package version:
 
@@ -246,7 +246,7 @@ eyelang -s examples/observability-log-correlation.pl
 Add `-w` or `--warnings` when you want non-fatal portability diagnostics, such as unstratified `not/1` dependencies, printed to stderr while normal answer output still goes to stdout:
 
 ```sh
-eyelang --warnings policy.pl
+eyelang --warnings test/conformance/warnings/negation/unstratified_mutual.pl
 ```
 
 The playground has matching `--stats` and `--proof` checkboxes, so browser runs can show the same counters or explanations like the CLI.
@@ -573,7 +573,7 @@ A useful rule of thumb:
 | Human-auditable derivations | Either | Both can emit proof explanations when requested. |
 | Large generated Horn-clause workloads | eyelang | The engine specializes in predicate/arity indexing, scalar argument indexes, fast fact paths, and materialized output goals. |
 
-On local smoke benchmarks, eyelang is substantially faster on large generated Horn-clause and recursion-heavy workloads. These numbers are 5-run medians with stdout redirected to `/dev/null`, using Node.js `v22.16.0`, eyelang from this checkout, and Eyeling package version `1.34.6` with its default output mode. The ratio is `Eyeling median / eyelang median`, so larger numbers mean eyelang was faster.
+On local smoke benchmarks, eyelang is substantially faster on large generated Horn-clause and recursion-heavy workloads. These numbers are 5-run medians with stdout redirected to `/dev/null`, using Node.js `v22.16.0`, eyelang from this checkout, and Eyeling package version `1.34.6` with its default output mode. The ratio is `Eyeling median / eyelang median`, so larger numbers mea eyelang was faster.
 
 | Example | eyelang median | Eyeling median | Ratio |
 | --- | ---: | ---: | ---: |
@@ -618,4 +618,4 @@ When using `not/1` over user-defined predicates, keep the dependency graph strat
 
 ## Implementation limits
 
-Eyelang is intentionally smaller than ISO Prolog. It has no operators, zero-arity compound syntax, cut, modules, dynamic database updates, DCGs, or complete ISO library. Arity-zero data is always written and read back as an atom, such as `nil`, never `nil()`. Negation is negation-as-failure through `not/1`. Search is goal-directed and expected to be finite for the selected output goals. Output explanations are non-normative proof printouts and do not change answer semantics. 
+Eyelang is intentionally smaller than ISO Prolog. It has no operators, zero-arity compound syntax, cut, modules, dynamic database updates, DCGs, or complete ISO library. Arity-zero data is always written and read back as an atom, such as `nil`, never `nil()`. Negation is negation-as-failure through `not/1`. Search is goal-directed and expected to be finite for the selected output goals. Output explanations are non-normative proof printouts and do not change answer semantics.

package/docs/language-reference.md

@@ -7,13 +7,16 @@
 - [2. Design goals](#2-design-goals)
 - [3. Lexical structure](#3-lexical-structure)
   - [3.1 Character stream](#31-character-stream)
-  - [3.2 Comments](#32-comments)
-  - [3.3 Punctuation tokens](#33-punctuation-tokens)
-  - [3.4 Variables](#34-variables)
-  - [3.5 Atom constants](#35-atom-constants)
-  - [3.6 Strings](#36-strings)
-  - [3.7 Numbers](#37-numbers)
+  - [3.2 Unicode and UTF-8](#32-unicode-and-utf-8)
+  - [3.3 Comments](#33-comments)
+  - [3.4 Punctuation tokens](#34-punctuation-tokens)
+  - [3.5 Variables](#35-variables)
+  - [3.6 Atom constants](#36-atom-constants)
+  - [3.7 Strings](#37-strings)
+  - [3.8 Numbers](#38-numbers)
 - [4. Surface grammar](#4-surface-grammar)
+  - [4.1 EBNF grammar](#41-ebnf-grammar)
+  - [4.2 Grammar notes](#42-grammar-notes)
 - [5. Terms](#5-terms)
   - [5.1 Variables](#51-variables)
   - [5.2 Atom constants, strings, and numbers](#52-atom-constants-strings-and-numbers)
@@ -100,19 +103,32 @@ Non-goals include complete ISO Prolog compatibility, operator declarations, modu
 ## 3. Lexical structure
 
 ### 3.1 Character stream
-
 Input is Unicode text. Whitespace separates tokens and is otherwise insignificant outside quoted strings and quoted atom constants.
 
-### 3.2 Comments
 
+### 3.2 Unicode and UTF-8
+Eyelang source files are UTF-8.
+
+Quoted atoms and strings may contain Unicode text:
+
+```eyelang
+name(alice, 'Élodie').
+city('München').
+message("café").
+```
+
+Unquoted atoms and variables intentionally use ASCII syntax. This keeps programs portable and makes the Prolog-style distinction between atoms and variables clear: lowercase names are atoms, while uppercase and underscore names are variables.
+
+Use quoted atoms for non-ASCII names.
+
+### 3.3 Comments
 A percent sign starts a line comment outside quoted strings and quoted atom constants. The comment extends to the end of the line.
 
 ```eyelang
 parent(pat, jan).  % this is a comment
 ```
 
-### 3.3 Punctuation tokens
-
+### 3.4 Punctuation tokens
 The punctuation tokens are:
 
 ```text
@@ -121,8 +137,7 @@ The punctuation tokens are:
 
 A colon outside `:-` is not part of the language. Namespace-like names SHOULD be written as explicit atom constants such as `person_type`, `odrl_permission`, or quoted atoms such as `'org.schema'`.
 
-### 3.4 Variables
-
+### 3.5 Variables
 A variable is either the bare anonymous variable `_`, or starts with an uppercase ASCII letter or underscore and then zero or more ASCII letters, digits, or underscores. This is the source-level variable spelling used by ISO Prolog.
 
 Examples:
@@ -136,8 +151,7 @@ _
 
 Each bare `_` anonymous variable occurrence is fresh. A name such as `_thing` is a named variable and is reused within its clause.
 
-### 3.5 Atom constants
-
+### 3.6 Atom constants
 A plain atom constant starts with a lowercase ASCII letter and is followed by zero or more ASCII letters, digits, or underscores. A dot is not part of a plain atom; dotted web spaces such as `'be.ugent'` or `'org.schema'` MUST be quoted if they are meant as one atom constant. Names such as `a-b` MUST also be quoted if they are meant as one atom constant:
 
 ```eyelang
@@ -176,12 +190,10 @@ A graphic atom constant is one or more graphic characters from this set:
 
 Graphic atoms such as `<=>`, `<`, and `>=` remain graphic atoms. Longer names containing letters or punctuation outside the graphic set should be quoted, for example `'<abc>'`.
 
-### 3.6 Strings
-
+### 3.7 Strings
 A string is enclosed in double quotes. The implementation supports common escapes such as `\n`, `\t`, `\"`, and `\\`.
 
-### 3.7 Numbers
-
+### 3.8 Numbers
 Numbers are scalar terms. Integers, decimal numbers, and scientific notation are accepted:
 
 ```eyelang
@@ -196,33 +208,103 @@ Integer arithmetic built-ins use arbitrary-precision decimal strings where possi
 
 ## 4. Surface grammar
 
-This grammar is descriptive. Implementations MAY reject programs that exceed implementation limits.
+This section gives the portable source grammar in EBNF. Lexical tokens are defined in section 3. Whitespace and comments may appear between tokens and are otherwise ignored.
+
+### 4.1 EBNF grammar
 
 ```text
-program      ::= clause*
-clause       ::= term "." | term ":-" goal_list "."
-goal_list    ::= term ("," term)*
-term         ::= variable
-              | atom_constant
-              | string
-              | number
-              | atom_constant "(" term ("," term)* ")"
-              | "[" [list_items] "]"
-              | "(" term ("," term)+ ")"
-list_items   ::= term ("," term)* ["|" term]
+program             ::= { clause } ;
+
+clause              ::= head, "."
+                      | head, ":-", goal-list, "." ;
+
+head                ::= term ;
+
+goal-list           ::= term, { ",", term } ;
+
+term                ::= variable
+                      | atom-constant
+                      | string
+                      | number
+                      | compound
+                      | list
+                      | parenthesized-term ;
+
+compound            ::= atom-constant, "(", term, { ",", term }, ")" ;
+
+list                ::= "[", "]"
+                      | "[", list-items, "]" ;
+
+list-items          ::= term, { ",", term }, [ "|", term ] ;
+
+parenthesized-term  ::= "(", term, [ ",", term, { ",", term } ], ")" ;
+
+variable            ::= "_"
+                      | variable-start, { name-continue } ;
+
+atom-constant       ::= plain-atom
+                      | quoted-atom
+                      | graphic-atom ;
+
+plain-atom          ::= lowercase-letter, { name-continue } ;
+
+quoted-atom         ::= "'", { quoted-atom-char }, "'" ;
+
+quoted-atom-char    ::= non-single-quote-char
+                      | "''"
+                      | escape-sequence ;
+
+string              ::= '"', { string-char }, '"' ;
+
+string-char         ::= non-double-quote-char
+                      | '""'
+                      | escape-sequence ;
+
+number              ::= [ "-" ], digits, [ ".", digits ], [ exponent ] ;
+
+exponent            ::= ( "e" | "E" ), [ "+" | "-" ], digits ;
+
+graphic-atom        ::= graphic-char, { graphic-char } ;
+
+variable-start      ::= uppercase-letter | "_" ;
+
+name-continue       ::= uppercase-letter | lowercase-letter | digit | "_" ;
+
+digits              ::= digit, { digit } ;
+
+escape-sequence     ::= "\\", any-char ;
+
+uppercase-letter    ::= "A" | ... | "Z" ;
+lowercase-letter    ::= "a" | ... | "z" ;
+digit               ::= "0" | ... | "9" ;
+
+non-single-quote-char ::= any source character except "'", "\\", or end of input ;
+non-double-quote-char ::= any source character except '"', "\\", or end of input ;
+any-char           ::= any source character except end of input ;
+
+graphic-char        ::= "#" | "$" | "&" | "*" | "+" | "-" | "/" | "<"
+                      | "=" | ">" | "@" | "^" | "~" | "\\" ;
 ```
 
-Here `atom_constant` is a lexical class for symbolic scalar terms, not an atomic formula. Atomic formulas are represented by the grammar alternative `atom_constant "(" ... ")"` when such a compound appears in a clause head, rule body, or selected goal. Compound syntax always has at least one argument.
+### 4.2 Grammar notes
 
-A clause head SHOULD be a compound term. Non-compound heads are parsed but are not useful in the current predicate index.
+The `atom-constant` nonterminal is a lexical class for symbolic scalar terms, not an atomic formula. Atomic formulas are represented by the `compound` alternative when such a term appears as a clause head, rule body, or selected goal. The functor or predicate name is always an atom constant; Eyelang does not support variables in functor or predicate position.
 
-Arity-zero data is written as an atom constant, not as a zero-arity compound:
+A portable clause head SHOULD be a compound term. Non-compound heads are parsed, but they are not useful in the current predicate index.
+
+Compound syntax always has at least one argument. Arity-zero data is written as an atom constant, not as a zero-arity compound:
 
 ```eyelang
 value(example, nil).
 ```
 
-The syntax `nil()` is intentionally rejected so eyelang source and read-back output use one representation for arity-zero data. Host APIs SHOULD follow the same rule: constructing a term with an atom name and an empty argument list is canonicalized to the atom constant itself.
+The syntax `nil()` is intentionally rejected so Eyelang source and read-back output use one representation for arity-zero data. Host APIs SHOULD follow the same rule: constructing a term with an atom name and an empty argument list is canonicalized to the atom constant itself.
+
+Parentheses around a single term are accepted and denote that same term. Parentheses around two or more comma-separated terms denote a right-associated comma term using the functor `','/2`. When such a comma term appears as a goal, it is evaluated as conjunction.
+
+A quoted atom represents an atom constant. A doubled single quote inside a quoted atom represents one literal single quote. A backslash may introduce an escaped character in quoted atoms and strings. Portable source SHOULD use the common escapes `\\`, `\n`, `\t`, `\'` in quoted atoms, and `\\`, `\n`, `\t`, `\"` in strings.
+
+A percent sign outside a quoted atom or string starts a line comment that extends to the end of the line.
 
 ## 5. Terms
 
@@ -770,4 +852,3 @@ status(a, open) :- open(a).
 URL input uses host networking support when available. Hosts SHOULD treat downloaded programs as untrusted code because they can trigger expensive search.
 
 Programs SHOULD be written with finite search in mind. Broad default materialization can be expensive for helper predicates; use `materialize/2` declarations and concise output predicates when needed.
-

package/examples/derived-rule.pl

@@ -6,7 +6,7 @@
 %   { X a cat. } => { { Y a dog. } => { test is true. }. }.
 %
 % The inner implication is represented directly as quoted formula data.
-% var(y) is not an eyelang variable; it is a ground term that names
+% var(y) is not a eyelang variable; it is a ground term that names
 % a variable placeholder inside the quoted formula.
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.

package/examples/good-cobbler.pl

@@ -1,7 +1,7 @@
 % Good cobbler, adapted from Eyeling's examples/good-cobbler.n3.
 %
 % The Eyeling result is a quoted assertion saying that joe is a good Cobbler.
-% Here the quoted assertion is represented as an eyelang term.
+% Here the quoted assertion is represented as a eyelang term.
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
 materialize(is, 2).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eyelang",
-  "version": "2.0.0",
-  "description": "A small Prolog-like logic programming language for facts, rules, goals, answers, and proofs.",
+  "version": "4.0.1",
+  "description": "A small reasoning language with ISO Prolog-compatible surface syntax.",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/src/cli.js

@@ -139,8 +139,8 @@ Usage:
   eyelang [options] [file-or-url.pl|- ...]
 
 Input:
-  file-or-url.pl       Read an Eyelang program from a local file or http(s) URL.
-  -                     Read an Eyelang program from standard input.
+  file-or-url.pl        Read a Eyelang program from a local file or http(s) URL.
+  -                     Read a Eyelang program from standard input.
 
 Options:
   -h, --help            Show this help text and exit.

package/src/parser.js

@@ -335,6 +335,7 @@ function parseClausesFastNoSource(source) {
     cache.set(key, value);
     return value;
   };
+
   const isFastScalarToken = (text) => SIMPLE_VARIABLE.test(text) || SIMPLE_ATOM.test(text) || GRAPHIC_ATOM.test(text) || SIMPLE_NUMBER.test(text);
   const scalarOrVariableFast = (text) => {
     if (!text || !isFastScalarToken(text)) throw new Error('bad simple term');
@@ -350,8 +351,117 @@ function parseClausesFastNoSource(source) {
     if ((first === 45 || isDigitCode(first)) && SIMPLE_NUMBER.test(text)) return cached(numberCache, text, numberTerm);
     return atom(text);
   };
+
+  const trimRange = (text, start, end) => {
+    while (start < end && isWhitespaceCode(text.charCodeAt(start))) start++;
+    while (end > start && isWhitespaceCode(text.charCodeAt(end - 1))) end--;
+    return [start, end];
+  };
+
+  const tokenKindInRange = (text, start, end) => {
+    if (start >= end) return null;
+    const first = text.charCodeAt(start);
+    if (first === 95 || (first >= 65 && first <= 90)) {
+      for (let i = start + 1; i < end; i++) if (!isNameContinueCode(text.charCodeAt(i))) return null;
+      return 'var';
+    }
+    if (first >= 97 && first <= 122) {
+      for (let i = start + 1; i < end; i++) if (!isNameContinueCode(text.charCodeAt(i))) return null;
+      return 'atom';
+    }
+    let allGraphic = true;
+    for (let i = start; i < end; i++) {
+      if (!isGraphicAtomCode(text.charCodeAt(i))) { allGraphic = false; break; }
+    }
+    if (allGraphic) return 'atom';
+    return null;
+  };
+
+  const simpleNumberInRange = (text, start, end) => {
+    let i = start;
+    if (text.charCodeAt(i) === 45) i++;
+    if (i >= end || !isDigitCode(text.charCodeAt(i))) return false;
+    while (i < end && isDigitCode(text.charCodeAt(i))) i++;
+    if (i < end && text.charCodeAt(i) === 46) {
+      i++;
+      if (i >= end || !isDigitCode(text.charCodeAt(i))) return false;
+      while (i < end && isDigitCode(text.charCodeAt(i))) i++;
+    }
+    if (i < end && (text.charCodeAt(i) === 101 || text.charCodeAt(i) === 69)) {
+      i++;
+      if (i < end && (text.charCodeAt(i) === 43 || text.charCodeAt(i) === 45)) i++;
+      if (i >= end || !isDigitCode(text.charCodeAt(i))) return false;
+      while (i < end && isDigitCode(text.charCodeAt(i))) i++;
+    }
+    return i === end;
+  };
+
+  const scalarOrVariableRange = (text, start, end) => {
+    [start, end] = trimRange(text, start, end);
+    const kind = tokenKindInRange(text, start, end);
+    const value = text.slice(start, end);
+    if (kind === 'var') {
+      if (value === '_') return variable(`__anon${anonymous++}`);
+      const existing = variableCache.get(value);
+      if (existing) return existing;
+      const term = variable(value);
+      variableCache.set(value, term);
+      return term;
+    }
+    if (kind === 'atom') return atom(value);
+    if (simpleNumberInRange(text, start, end)) return cached(numberCache, value, numberTerm);
+    return null;
+  };
+
+  const parseBinaryCompoundRange = (text, start = 0, end = text.length) => {
+    [start, end] = trimRange(text, start, end);
+    let i = start;
+    const first = text.charCodeAt(i);
+    if (!(first >= 97 && first <= 122)) return null;
+    i++;
+    while (i < end && isNameContinueCode(text.charCodeAt(i))) i++;
+    const nameEnd = i;
+    while (i < end && isWhitespaceCode(text.charCodeAt(i))) i++;
+    if (text.charCodeAt(i) !== 40) return null;
+    i++;
+    const arg1Start = i;
+    while (i < end && text.charCodeAt(i) !== 44 && text.charCodeAt(i) !== 40 && text.charCodeAt(i) !== 41 && text.charCodeAt(i) !== 91 && text.charCodeAt(i) !== 93 && text.charCodeAt(i) !== 124 && text.charCodeAt(i) !== 34 && text.charCodeAt(i) !== 39) i++;
+    if (i >= end || text.charCodeAt(i) !== 44) return null;
+    const arg1End = i;
+    i++;
+    const arg2Start = i;
+    while (i < end && text.charCodeAt(i) !== 41 && text.charCodeAt(i) !== 40 && text.charCodeAt(i) !== 44 && text.charCodeAt(i) !== 91 && text.charCodeAt(i) !== 93 && text.charCodeAt(i) !== 124 && text.charCodeAt(i) !== 34 && text.charCodeAt(i) !== 39) i++;
+    if (i >= end || text.charCodeAt(i) !== 41) return null;
+    const arg2End = i;
+    i++;
+    while (i < end && isWhitespaceCode(text.charCodeAt(i))) i++;
+    if (i !== end) return null;
+    const left = scalarOrVariableRange(text, arg1Start, arg1End);
+    if (!left) return null;
+    const right = scalarOrVariableRange(text, arg2Start, arg2End);
+    if (!right) return null;
+    return compound(text.slice(start, nameEnd), [left, right]);
+  };
+
+  const parseFastLine = (text) => {
+    if (!text.endsWith('.')) return null;
+    const end = text.length - 1;
+    const rule = text.indexOf(':-');
+    if (rule < 0) {
+      const head = parseBinaryCompoundRange(text, 0, end);
+      return head ? { head, body: [] } : null;
+    }
+    if (text.indexOf(':-', rule + 2) >= 0) return null;
+    const head = parseBinaryCompoundRange(text, 0, rule);
+    if (!head) return null;
+    const bodyGoal = parseBinaryCompoundRange(text, rule + 2, end);
+    return bodyGoal ? { head, body: [bodyGoal] } : null;
+  };
+
   const scalarOrVariable = (text) => scalarOrVariableFast(text.trim());
   const parseBinaryCompound = (text) => {
+    const parsed = parseBinaryCompoundRange(text, 0, text.length);
+    if (parsed) return parsed;
     text = text.trim();
     const open = text.indexOf('(');
     if (open <= 0 || text[text.length - 1] !== ')') return null;
@@ -366,35 +476,11 @@ function parseClausesFastNoSource(source) {
     if (!isFastScalarToken(left) || !isFastScalarToken(right)) return null;
     return compound(name, [scalarOrVariable(left), scalarOrVariable(right)]);
   };
-  const parseFastBinaryMatch = (match) => {
-    if (!isFastScalarToken(match[2]) || !isFastScalarToken(match[3])) return null;
-    return compound(match[1], [scalarOrVariableFast(match[2]), scalarOrVariableFast(match[3])]);
-  };
-  const parseFastBinaryRuleMatch = (match) => {
-    if (!isFastScalarToken(match[2]) || !isFastScalarToken(match[3]) || !isFastScalarToken(match[5]) || !isFastScalarToken(match[6])) return null;
-    return {
-      head: compound(match[1], [scalarOrVariableFast(match[2]), scalarOrVariableFast(match[3])]),
-      body: [compound(match[4], [scalarOrVariableFast(match[5]), scalarOrVariableFast(match[6])])],
-    };
-  };
-  const parseFastLine = (text) => {
-    if (!text.endsWith('.')) return null;
-    const ruleMatch = FAST_BINARY_RULE.exec(text);
-    if (ruleMatch) {
-      const parsed = parseFastBinaryRuleMatch(ruleMatch);
-      if (parsed) return parsed;
-    }
-    const factMatch = FAST_BINARY_FACT.exec(text);
-    if (factMatch) {
-      const head = parseFastBinaryMatch(factMatch);
-      if (head) return { head, body: [] };
-    }
-    return null;
-  };
+
   const parseSimple = (text) => {
-    if (!text.endsWith('.') || text.includes('\n')) return null;
     const fast = parseFastLine(text);
     if (fast) return fast;
+    if (!text.endsWith('.') || text.includes('\n')) return null;
     text = text.slice(0, -1);
     const rule = text.indexOf(':-');
     if (rule < 0) {

package/src/program.js

@@ -44,6 +44,7 @@ export class Program {
       mode: null,
       determinism: null,
       recursive: false,
+      scalarFactsOnly: true,
       negationStratum: null,
     };
     if (arity > 2) {
@@ -64,6 +65,9 @@ export class Program {
       group = this.makeGroup(head.name, head.arity);
       this.groups.set(key, group);
     }
+    clause.groundHead = termHasNoVariables(head);
+    clause.scalarHead = head.type === COMPOUND && head.args.every(isScalar);
+    if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
     group.clauses.push(clause);
     for (let i = 0; i < head.arity; i++) indexOne(group.argIndexes[i], head.args[i], clause);
     for (const pair of group.pairIndexes) indexPair(pair, head, clause);
@@ -265,6 +269,12 @@ export class Program {
 
 
 
+
+function termHasNoVariables(term) {
+  if (!term || term.type === 'var') return false;
+  return !term.args?.some((arg) => !termHasNoVariables(arg));
+}
+
 function collectGoalDependencies(goal, negated) {
   if (goal.type !== COMPOUND) return [];
   if (goal.name === ',' && goal.arity === 2) {

package/src/solver.js

@@ -1,6 +1,6 @@
 // Depth-first eyelang solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
-import { COMPOUND, Env, copyResolved, flattenConjunction, freshTerm, termIsGround, termToString, unify, variantTerms } from './term.js';
+import { COMPOUND, Env, compound, copyResolved, flattenConjunction, freshTerm, termIsGround, termToString, unify, variantTerms } from './term.js';
 import { createDefaultRegistry } from './builtins/registry.js';
 import { selectClauseCandidates } from './program.js';
 
@@ -156,6 +156,7 @@ export class Solver {
           }
         }
 
+        if (!group.tabled && tryPushScalarFactRunFrames(stack, this, [goal, ...rest], env, depth, active)) break;
         pushUserGoalUncachedFrames(stack, this, group, goal, rest, env, depth, active);
         break;
       }
@@ -230,6 +231,14 @@ export class Solver {
     const candidates = selectClauseCandidates(group, goal, env);
     for (const pass of [candidates.primary, candidates.fallback]) {
       for (const clause of pass) {
+        if (clause.body.length === 0 && clause.scalarHead) {
+          const next = matchScalarFact(goal, clause.head, env);
+          if (!next) continue;
+          this.stats.unify_calls++;
+          yield* this.solve(rest, next, depth + 1);
+          if (this.solutionsSeen >= this.solutionLimit) return;
+          continue;
+        }
         if (headCannotMatch(goal, clause.head, env)) continue;
         const id = nextFreshId();
         const freshHead = freshTerm(clause.head, id);
@@ -285,6 +294,14 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   const frames = [];
   for (const pass of [candidates.primary, candidates.fallback]) {
     for (const clause of pass) {
+      if (clause.body.length === 0 && clause.scalarHead) {
+        const next = matchScalarFact(goal, clause.head, env);
+        if (next) {
+          solver.stats.unify_calls++;
+          frames.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
+        }
+        continue;
+      }
       if (headCannotMatch(goal, clause.head, env)) continue;
       const id = nextFreshId();
       const freshHead = freshTerm(clause.head, id);
@@ -309,6 +326,184 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
 }
 
 
+
+const SCALAR_FACT_RUN_FRAME_LIMIT = 100000;
+
+function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
+  // Consecutive lookups into predicates that are entirely scalar ground facts
+  // are common in data-heavy joins. Execute such a prefix as one iterative join
+  // using local binding arrays, so intermediate fact candidates do not allocate
+  // cloned Env maps.
+  let runLength = 0;
+  const groups = [];
+  while (runLength < goals.length) {
+    const goal = goals[runLength];
+    if (!goal || goal.kind === 'releaseActive' || goal.kind === 'memoStore') break;
+    if (goal.type !== COMPOUND) break;
+    const def = solver.registry.get(goal.name, goal.arity);
+    if (def) break;
+    const group = solver.program.findGroup(goal.name, goal.arity);
+    if (!group || group.tabled || !group.scalarFactsOnly) break;
+    groups.push(group);
+    runLength++;
+  }
+  if (runLength < 2) return false;
+
+  const rest = goals.slice(runLength);
+  const localStack = [{ index: 0, names: [], values: [], depth }];
+  const frames = [];
+
+  while (localStack.length) {
+    const state = localStack.pop();
+    solver.stats.max_depth = Math.max(solver.stats.max_depth, state.depth);
+    if (state.index === runLength) {
+      const next = env.clone();
+      for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
+      frames.push({ kind: 'goals', goals: rest, env: next, depth: state.depth, active });
+      if (frames.length > SCALAR_FACT_RUN_FRAME_LIMIT) return false;
+      continue;
+    }
+
+    const goal = goals[state.index];
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    solver.stats.solve_one_goal_calls++;
+    const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
+    const nextStates = [];
+    for (const pass of [candidates.primary, candidates.fallback]) {
+      for (const clause of pass) {
+        const match = matchScalarFactLocal(goal, clause.head, env, state.names, state.values);
+        if (!match) continue;
+        solver.stats.unify_calls++;
+        nextStates.push({ index: state.index + 1, names: match.names, values: match.values, depth: state.depth + 1 });
+      }
+    }
+    for (let i = nextStates.length - 1; i >= 0; i--) localStack.push(nextStates[i]);
+    if (solver.solutionsSeen >= solver.solutionLimit) break;
+  }
+
+  for (let i = frames.length - 1; i >= 0; i--) stack.push(frames[i]);
+  return true;
+}
+
+
+function activeMightContain(goal, active) {
+  if (active.length === 0 || goal.type !== COMPOUND) return false;
+  for (const entry of active) {
+    const activeGoal = entry.goal;
+    if (activeGoal?.type === COMPOUND && activeGoal.name === goal.name && activeGoal.arity === goal.arity) return true;
+  }
+  return false;
+}
+
+function envWithLocal(env, names, values) {
+  if (names.length === 0) return env;
+  return {
+    has(name) { return names.includes(name) || env.has(name); },
+    get(name) {
+      const index = names.indexOf(name);
+      return index >= 0 ? values[index] : env.get(name);
+    },
+  };
+}
+
+function selectScalarFactCandidates(group, goal, env, names, values) {
+  let bestPrimary = group.clauses;
+  let bestFallback = [];
+  let bestLen = group.clauses.length;
+  let indexed = false;
+
+  for (let i = 0; i < goal.arity; i++) {
+    const arg = derefScalarMatch(goal.args[i], env, names, values);
+    if (!isScalarTerm(arg)) continue;
+    const index = group.argIndexes[i];
+    const bucket = index.buckets.get(arg.name) ?? [];
+    const candidateLen = bucket.length + index.fallback.length;
+    if (!indexed || candidateLen < bestLen) {
+      bestPrimary = bucket;
+      bestFallback = index.fallback;
+      bestLen = candidateLen;
+      indexed = true;
+      if (bestLen === 0) break;
+    }
+  }
+
+  for (const pair of group.pairIndexes) {
+    const left = derefScalarMatch(goal.args[pair.left], env, names, values);
+    const right = derefScalarMatch(goal.args[pair.right], env, names, values);
+    if (!isScalarTerm(left) || !isScalarTerm(right)) continue;
+    const bucket = pair.buckets.get(`${left.name}\x1f${right.name}`) ?? [];
+    const candidateLen = bucket.length + pair.fallback.length;
+    if (!indexed || candidateLen < bestLen) {
+      bestPrimary = bucket;
+      bestFallback = pair.fallback;
+      bestLen = candidateLen;
+      indexed = true;
+      if (bestLen === 0) break;
+    }
+  }
+
+  return { primary: bestPrimary, fallback: bestFallback };
+}
+
+function matchScalarFactLocal(goal, head, env, names, values) {
+  if (goal.type !== COMPOUND || head.type !== COMPOUND) return null;
+  if (goal.name !== head.name || goal.arity !== head.arity) return null;
+
+  let nextNames = names;
+  let nextValues = values;
+  for (let i = 0; i < goal.arity; i++) {
+    const factArg = head.args[i];
+    const arg = derefScalarMatch(goal.args[i], env, nextNames, nextValues);
+    if (arg.type === 'var') {
+      if (nextNames === names) {
+        nextNames = names.slice();
+        nextValues = values.slice();
+      }
+      nextNames.push(arg.name);
+      nextValues.push(factArg);
+      continue;
+    }
+    if (!isScalarTerm(arg) || arg.name !== factArg.name) return null;
+  }
+  return { names: nextNames, values: nextValues };
+}
+
+function matchScalarFact(goal, head, env) {
+  // A scalar ground fact has no variables to freshen and no compound structure
+  // to traverse. Match the goal arguments directly and clone only after the
+  // candidate has succeeded.
+  if (goal.type !== COMPOUND || head.type !== COMPOUND) return null;
+  if (goal.name !== head.name || goal.arity !== head.arity) return null;
+
+  const names = [];
+  const values = [];
+  for (let i = 0; i < goal.arity; i++) {
+    const factArg = head.args[i];
+    let arg = derefScalarMatch(goal.args[i], env, names, values);
+    if (arg.type === 'var') {
+      names.push(arg.name);
+      values.push(factArg);
+      continue;
+    }
+    if (!isScalarTerm(arg) || arg.name !== factArg.name) return null;
+  }
+
+  const next = env.clone();
+  for (let i = 0; i < names.length; i++) next.bind(names[i], values[i]);
+  return next;
+}
+
+function derefScalarMatch(term, env, names, values) {
+  let current = term;
+  for (let guard = 0; current?.type === 'var' && guard < 128; guard++) {
+    const localIndex = names.indexOf(current.name);
+    if (localIndex >= 0) current = values[localIndex];
+    else if (env.has(current.name)) current = env.get(current.name);
+    else break;
+  }
+  return current;
+}
+
 function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active) {
   // Compress deterministic ground single-goal chains such as deep taxonomy
   // proofs: a(ind, n100000) -> a(ind, n99999) -> ... -> a(ind, n0).
@@ -331,7 +526,7 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
     // finite taxonomy chains with the recursive maxDepth guard.
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
-    const key = `${currentGoal.name}/${currentGoal.arity}:${termToString(currentGoal, currentEnv, true)}`;
+    const key = groundChainKey(currentGoal);
     if (seen.has(key)) return true;
     if (activeVariantIn(currentGoal, currentEnv, active)) return true;
     if (solver.groundChainSuccess.has(key)) {
@@ -346,28 +541,22 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
     for (const pass of [candidates.primary, candidates.fallback]) {
       for (const clause of pass) {
         if (headCannotMatch(currentGoal, clause.head, currentEnv)) continue;
-        const id = nextFreshId();
-        const freshHead = freshTerm(clause.head, id);
-        const freshBody = clause.body.map((term) => freshTerm(term, id));
-        const next = new Env();
-        solver.stats.unify_calls++;
-        if (!unify(currentGoal, freshHead, next)) continue;
-        matches.push({ body: freshBody, env: next });
+        const match = matchGroundClause(currentGoal, clause);
+        if (match === undefined) return false;
+        if (match === null) continue;
+        matches.push(match);
         if (matches.length > 1) return false;
       }
     }
 
     if (matches.length !== 1) return false;
     const match = matches[0];
-    if (match.body.length === 0) {
+    if (match.done) {
       rememberGroundChainSuccess(solver, seen);
       stack.push({ kind: 'goals', goals: rest, env: baseEnv, depth: depth + 1, active });
       return true;
     }
-    if (match.body.length !== 1) return false;
-    const nextGoal = match.body[0];
-    if (nextGoal.type !== COMPOUND || !termIsGround(nextGoal, match.env)) return false;
-    const resolvedNextGoal = copyResolved(nextGoal, match.env);
+    const resolvedNextGoal = match.nextGoal;
     const nextGroup = solver.program.findGroup(resolvedNextGoal.name, resolvedNextGoal.arity);
     if (!nextGroup) return false;
 
@@ -378,6 +567,72 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
 }
 
 
+
+
+function matchGroundClause(goal, clause) {
+  if (clause.head.type !== COMPOUND || goal.type !== COMPOUND) return undefined;
+  if (clause.head.name !== goal.name || clause.head.arity !== goal.arity) return null;
+
+  const names = [];
+  const values = [];
+  for (let i = 0; i < goal.arity; i++) {
+    const headArg = clause.head.args[i];
+    const goalArg = goal.args[i];
+    if (headArg.type === 'var') {
+      let index = names.indexOf(headArg.name);
+      if (index < 0) {
+        names.push(headArg.name);
+        values.push(goalArg);
+      } else if (!sameGroundTerm(values[index], goalArg)) {
+        return null;
+      }
+    } else if (isScalarTerm(headArg)) {
+      if (!sameGroundTerm(headArg, goalArg)) return null;
+    } else {
+      return undefined;
+    }
+  }
+
+  if (clause.body.length === 0) return { done: true };
+  if (clause.body.length !== 1) return undefined;
+  const bodyGoal = clause.body[0];
+  if (bodyGoal.type !== COMPOUND) return undefined;
+  const args = [];
+  for (const arg of bodyGoal.args) {
+    if (arg.type === 'var') {
+      const index = names.indexOf(arg.name);
+      if (index < 0) return undefined;
+      args.push(values[index]);
+    } else if (isScalarTerm(arg)) {
+      args.push(arg);
+    } else {
+      return undefined;
+    }
+  }
+  return { nextGoal: compound(bodyGoal.name, args) };
+}
+
+function isScalarTerm(term) {
+  return term && (term.type === 'atom' || term.type === 'string' || term.type === 'number');
+}
+
+function sameGroundTerm(left, right) {
+  if (left?.type !== right?.type || left?.name !== right?.name) return false;
+  const arity = left.args?.length ?? 0;
+  if (arity !== (right.args?.length ?? 0)) return false;
+  for (let i = 0; i < arity; i++) if (!sameGroundTerm(left.args[i], right.args[i])) return false;
+  return true;
+}
+
+function groundChainKey(term) {
+  if (term?.type === COMPOUND) {
+    let out = `${term.name}/${term.arity}`;
+    for (let i = 0; i < term.arity; i++) out += `${groundChainKey(term.args[i])}`;
+    return out;
+  }
+  return `${term?.type ?? ''}:${term?.name ?? ''}`;
+}
+
 function rememberGroundChainSuccess(solver, seen) {
   for (const key of seen) solver.groundChainSuccess.add(key);
 }

package/test/conformance/cases/builtins/037_matching_and_comparison.pl

@@ -1,5 +1,5 @@
 % Reference 9.3, 9.6: lexical comparison and simple text matching.
-answer(matches, true) :- matches("eyelang", "yel").
+answer(matches, true) :- matches("eyelang", "eye").
 answer(not_matches, true) :- not_matches("eyelang", "cat").
 answer(lex_lt, true) :- lt(alpha, beta).
 answer(lex_gt, true) :- gt(beta, alpha).

package/test/conformance/cases/strings/030_strings_and_atoms.pl

@@ -1,4 +1,4 @@
 % Reference 9.6: atom and string built-ins.
 answer(str_concat, X) :- str_concat("eye", "lang", X).
-answer(contains, true) :- contains("eyelang", "yel").
+answer(contains, true) :- contains("eyelang", "eye").
 materialize(answer, 2).

package/test/conformance/cases/strings/090_string_substring_replace_edges.pl

@@ -1,9 +1,9 @@
 % Reference 9.6: substring and replace have finite boundary behavior.
 materialize(answer, 2).
-answer(prefix, X) :- substring("eyelang", 0, 3, X).
-answer(middle, X) :- substring("eyelang", 3, 2, X).
-answer(suffix, X) :- substring("eyelang", 2, 3, X).
-answer(empty_at_end, X) :- substring("eyelang", 7, 0, X).
-answer(out_of_range_rejected, ok) :- not(substring("eyelang", 7, 2, X)).
+answer(prefix, X) :- substring("eyelanglet", 0, 3, X).
+answer(middle, X) :- substring("eyelanglet", 3, 2, X).
+answer(suffix, X) :- substring("eyelanglet", 2, 3, X).
+answer(empty_at_end, X) :- substring("eyelanglet", 10, 0, X).
+answer(out_of_range_rejected, ok) :- not(substring("eyelanglet", 10, 2, X)).
 answer(replace_all, X) :- replace("banana", "na", "NA", X).
 answer(replace_missing, X) :- replace("banana", "x", "y", X).

package/test/run-conformance.mjs

@@ -10,7 +10,7 @@ import { TestReporter, isMainModule } from './test-style.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(root, '..');
-const cliBin = path.join(packageRoot, 'src', 'bin.js');
+const cliBin = path.join(packageRoot, 'bin', 'eyelang.js');
 const filterArg = process.argv[2] ?? null;
 
 export function runConformance(reporter = new TestReporter(), requestedFilter = null) {

package/test/run-regression.mjs

@@ -40,8 +40,7 @@ import { hashHex } from '../src/hash.js';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..');
-const runtimeRoot = path.join(packageRoot, 'src');
-const bin = path.join(runtimeRoot, 'bin.js');
+const bin = path.join(packageRoot, 'bin', 'eyelang.js');
 const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
 let tmp = null;
 let tmpCounter = 0;
@@ -182,7 +181,7 @@ why(
         assertIncludes(result.stdout, '-v, --version', 'stdout');
         assertIncludes(result.stdout, '-w, --warnings', 'stdout');
         assertIncludes(result.stdout, '-v, --version         Show the package version and exit.\n  -w, --warnings        Print non-fatal portability warnings to stderr.', 'stdout');
-        assertIncludes(result.stdout, 'Read an Eyelang program', 'stdout');
+        assertIncludes(result.stdout, 'Read a Eyelang program', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
@@ -207,7 +206,7 @@ why(
     {
       name: 'npm exec can run package CLI bin from checkout',
       run: () => {
-        const result = spawnSync('npm', ['exec', '--', 'eyelang', '--version'], {
+        const result = spawnSync('npm', ['exec', '--yes', '--package=.', '--', 'eyelang', '--version'], {
           cwd: packageRoot,
           encoding: 'utf8',
           env: { ...process.env, npm_config_update_notifier: 'false' },

package/src/bin.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-import('./cli.js').then(({ main }) => main(process.argv.slice(2))).catch((error) => {
-  console.error(`eyelang: ${error && error.message ? error.message : String(error)}`);
-  process.exit(1);
-});

package/test/conformance/cases/aggregation/044_findall_user_goal.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/aggregation/057_countall_empty_and_nonempty.query

@@ -1 +0,0 @@
-(countall(item(X), C), countall(missing(X), Z))

package/test/conformance/cases/aggregation/058_sumall_numeric_template.query

@@ -1 +0,0 @@
-sumall(S, score(_item, S), Sum)

package/test/conformance/cases/aggregation/059_aggregate_min_template.query

@@ -1 +0,0 @@
-aggregate_min(S, item(Name, S), score(Name, S), Bests, Best)

package/test/conformance/cases/aggregation/060_aggregate_max_compound_key.query

@@ -1 +0,0 @@
-aggregate_max([S, Name], Name, score(Name, S), Key, Bestname)

package/test/conformance/cases/arithmetic/029_arithmetic_and_comparison.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/arithmetic/039_numeric_functions.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/arithmetic/040_between_enumeration.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/arithmetic/041_smallest_divisor.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/arithmetic/054_numeric_and_lexical_comparison.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/atoms/008_graphic_atoms.query

@@ -1 +0,0 @@
-value(K, V)

package/test/conformance/cases/atoms/018_quoted_atom_readback.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/builtins/037_matching_and_comparison.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/control/014_failure_filters_answers.query

@@ -1 +0,0 @@
-answer(X, V)

package/test/conformance/cases/control/043_once_user_predicate.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/005_list_deconstruction.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/015_improper_list_unification.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/020_nested_list_terms.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/031_lists_aggregation_ordering.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/035_list_relations.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/036_append_splits.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/045_sort_deduplicates_atoms.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/046_append_bound_prefix_suffix.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/047_nth0_index_generation.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/048_set_nth0_edges.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/lists/049_select_duplicate_occurrences.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/negation/033_negation_once_generators.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/negation/042_negation_filter.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/negation/050_not_member_filter.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/rules/002_rule_recursion.query

@@ -1 +0,0 @@
-ancestor(pat, X)

package/test/conformance/cases/rules/011_predicate_arity.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/rules/013_multiple_clauses_order.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/rules/017_three_step_recursion.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/strings/030_strings_and_atoms.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/strings/055_string_matching_filters.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/strings/056_string_and_atom_concat.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/syntax/004_conjunction_and_parentheses.query

@@ -1 +0,0 @@
-ok(X, Y)

package/test/conformance/cases/syntax/006_comma_formula_data.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/syntax/009_comments_and_whitespace.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/syntax/019_parenthesized_three_conjuncts.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/table/038_table_declaration.query

@@ -1 +0,0 @@
-reach(a, X)

package/test/conformance/cases/terms/003_terms_and_readback.query

@@ -1 +0,0 @@
-value(K, V)

package/test/conformance/cases/unification/012_nested_compound_unification.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/unification/034_equality_and_inequality.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/variables/007_anonymous_variables.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/cases/variables/010_variable_scope_and_reuse.query

@@ -1 +0,0 @@
-answer(K, V)