eyelang 1.3.7 → 1.3.9

package/README.md

@@ -1,6 +1,6 @@
 # eyelang
 
-[![npm version](https://img.shields.io/npm/v/eyelangreasoner.svg)](https://www.npmjs.com/package/eyelangreasoner)
+[![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.1242549108-blue.svg)](https://doi.org/10.5281/zenodo.20342331)
 
 eyelang is a small rule engine for Prolog-style Horn clauses over ordinary terms, lists, arithmetic, strings, and finite search. The command-line executable is `eyelang`.
@@ -458,6 +458,8 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`service-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/service-impact.pl) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/service-impact.pl) |
 | [`sieve.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/sieve.pl) | Enumerates primes with a sieve-style program. | [`output/sieve.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/sieve.pl) |
 | [`skolem-functions.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/skolem-functions.pl) | Generates deterministic functional terms. | [`output/skolem-functions.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/skolem-functions.pl) |
+| [`socket-age.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/socket-age.pl) | Shows socket-declared age reasoning inputs and plugs. | [`output/socket-age.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/socket-age.pl) |
+| [`socket-family.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/socket-family.pl) | Shows socket-declared family-source inputs and ancestry rules. | [`output/socket-family.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/socket-family.pl) |
 | [`socrates.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/socrates.pl) | Derives that Socrates is mortal. | [`output/socrates.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/socrates.pl) |
 | [`statistics-summary.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/statistics-summary.pl) | Computes population statistics for a sample. | [`output/statistics-summary.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/statistics-summary.pl) |
 | [`sudoku.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/sudoku.pl) | Solves generic 9x9 Sudoku strings through the sudoku/2 builtin. | [`output/sudoku.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/sudoku.pl) |

package/examples/socket-age.pl

@@ -1,8 +1,8 @@
-% eyelog-socket-age.pl
+% socket-age.pl
 %
-% A small runnable eyelog Socket example for age reasoning.
+% A small runnable eyelang Socket example for age reasoning.
 %
-% The socket facts are ordinary eyelog data. They document the semantic
+% The socket facts are ordinary eyelang data. They document the semantic
 % openings that this rule module expects:
 %
 %   - a patient registry that provides birthDay/2
@@ -12,7 +12,7 @@
 % The plug facts say which concrete providers are connected.
 %
 % Run:
-%   eyelog eyelog-socket-age.pl
+%   eyelang socket-age.pl
 
 materialize(ageAbove, 2).
 

package/examples/socket-family.pl

@@ -1,13 +1,13 @@
-% eyelog-socket-family.pl
+% socket-family.pl
 %
-% A small runnable eyelog Socket example.
+% A small runnable eyelang Socket example.
 %
-% The socket facts below are ordinary eyelog data. They document the
+% The socket facts below are ordinary eyelang data. They document the
 % semantic opening: this reasoning module expects a provider for parent/2.
 % The plug fact says which provider is connected.
 %
 % Run:
-%   eyelog eyelog-socket-family.pl
+%   eyelang socket-family.pl
 
 materialize(ancestor, 2).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "type": "module",
   "description": "A small rule engine for Prolog-style Horn clauses",
   "keywords": [

package/playground.html

@@ -438,10 +438,12 @@
   "ackermann",
   "age",
   "aliases-and-namespaces",
+  "alignment-demo",
   "allen-interval-calculus",
   "ancestor",
   "animal",
   "annotation",
+  "backward",
   "basic-monadic",
   "bayes-diagnosis",
   "bayes-therapy",
@@ -452,12 +454,14 @@
   "buck-converter-design",
   "cache-performance",
   "canary-release",
+  "cat-koko",
   "clinical-trial-screening",
   "collatz-1000",
   "combinatorics-findall-sort",
   "competitive-enzyme-kinetics",
   "complex",
   "complex-matrix-stability",
+  "composition-of-injective-functions-is-injective",
   "context-association",
   "control-system",
   "cryptarithmetic-send-more-money",
@@ -479,13 +483,16 @@
   "dijkstra-findall-sort",
   "dijkstra-risk-path",
   "dining-philosophers",
+  "dog",
   "drone-corridor-planner",
   "easter-computus",
   "electrical-rc-filter",
   "epidemic-policy",
+  "equivalence-classes-overlap-implies-same-class",
   "eulerian-path",
   "ev-range-worlds",
   "exact-cover-sudoku",
+  "existential-rule",
   "exoplanet-validation-worlds",
   "expression-eval",
   "family-cousins",
@@ -500,9 +507,12 @@
   "gd-step-certified",
   "gdpr-compliance",
   "goldbach-1000",
+  "good-cobbler",
   "gps",
   "graph-reachability",
   "gray-code-counter",
+  "greatest-lower-bound-uniqueness",
+  "group-inverse-uniqueness",
   "hamiltonian-cycle",
   "hamiltonian-path",
   "hamming-code",
@@ -542,6 +552,8 @@
   "service-impact",
   "sieve",
   "skolem-functions",
+  "socket-age",
+  "socket-family",
   "socrates",
   "statistics-summary",
   "sudoku",

package/src/cli.js

@@ -39,7 +39,7 @@ export async function main(argv) {
       return;
     } else if (!endOptions && arg === '--stats') {
       options.stats = true;
-    } else if (!endOptions && arg === '--no-why') {
+    } else if (!endOptions && (arg === '--no-why' || arg === '-n')) {
       options.why = false;
     } else if (!endOptions && arg === '--query') {
       if (i + 1 >= argv.length) throw new Error('--query requires an argument');
@@ -77,7 +77,7 @@ export async function main(argv) {
     }
   }
 
-  const program = Program.parseSources(sourceParts);
+  const program = Program.parseSources(sourceParts, { sourceMetadata: options.why, markRecursive: options.why });
 
   if (options.query != null) runQuery(program, options.query, options);
   else runDefault(program, options);
@@ -142,10 +142,10 @@ Input:
 
 Options:
   -h, --help            Show this help text and exit.
-  -v, --version         Show the package version and exit.
+  -n, --no-why          Suppress why/2 explanation facts; print answers only.
       --query GOAL      Run GOAL as a query instead of materializing output predicates.
       --stats           Print solver statistics to stderr after execution.
-      --no-why          Suppress why/2 explanation facts; print answers only.
+  -v, --version         Show the package version and exit.
   --                    Stop option parsing; following arguments are treated as files.
 `);
 }

package/src/parser.js

@@ -36,6 +36,7 @@ class Parser {
     this.pos = 0;
     this.line = 1;
     this.anonymous = 0;
+    this.sourceMetadata = options.sourceMetadata !== false;
     this.token = this.nextToken();
   }
   peek(offset = 0) {
@@ -256,16 +257,144 @@ class Parser {
       }
       this.expect(TOK.DOT, '.');
       this.advance();
-      clauses.push({ head, body, source: { filename: this.filename, line, clause: clauses.length + 1 } });
+      const clause = { head, body };
+      if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauses.length + 1 };
+      clauses.push(clause);
     }
     return clauses;
   }
 }
 
+
 export function parseClauses(source, options = {}) {
+  if (options.sourceMetadata === false) {
+    const clauses = parseClausesFastNoSource(source);
+    if (clauses) return clauses;
+  }
   return new Parser(source, options).parseProgram();
 }
 
+function isSimpleName(text) {
+  if (!text) return false;
+  const first = text.charCodeAt(0);
+  if (!(first >= 97 && first <= 122)) return false;
+  for (let i = 1; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (!(code === 95 || (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122))) return false;
+  }
+  return true;
+}
+
+const SIMPLE_NUMBER = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+const SIMPLE_ARG_FORBIDDEN = /[\s()[\]|"']/;
+
+function parseClausesFastNoSource(source) {
+  source = String(source ?? '');
+  const atomCache = new Map();
+  const numberCache = new Map();
+  const stringCache = new Map();
+  const clauses = [];
+  let anonymous = 0;
+  let chunk = '';
+
+  const cached = (cache, key, create) => {
+    const existing = cache.get(key);
+    if (existing) return existing;
+    const value = create(key);
+    cache.set(key, value);
+    return value;
+  };
+  const scalarOrVariable = (text, variables) => {
+    text = text.trim();
+    if (!text) throw new Error('empty simple term');
+    if (text === '_') return variable(`__anon${anonymous++}`);
+    if (isVariableStart(text)) {
+      const existing = variables.get(text);
+      if (existing) return existing;
+      const value = variable(text);
+      variables.set(text, value);
+      return value;
+    }
+    if (SIMPLE_NUMBER.test(text)) return cached(numberCache, text, numberTerm);
+    if (text[0] === '"' && text.endsWith('"')) return cached(stringCache, text.slice(1, -1), stringTerm);
+    return cached(atomCache, text, atom);
+  };
+  const parseBinaryCompound = (text, variables) => {
+    text = text.trim();
+    const open = text.indexOf('(');
+    if (open <= 0 || text[text.length - 1] !== ')') return null;
+    const name = text.slice(0, open).trim();
+    if (!isSimpleName(name)) return null;
+    const inner = text.slice(open + 1, -1);
+    if (inner.includes('(') || inner.includes(')') || inner.includes('[') || inner.includes(']') || inner.includes('|') || inner.includes('"') || inner.includes("'")) return null;
+    const comma = inner.indexOf(',');
+    if (comma < 0 || inner.indexOf(',', comma + 1) >= 0) return null;
+    const left = inner.slice(0, comma).trim();
+    const right = inner.slice(comma + 1).trim();
+    if (!left || !right || SIMPLE_ARG_FORBIDDEN.test(left) || SIMPLE_ARG_FORBIDDEN.test(right)) return null;
+    return compound(name, [scalarOrVariable(left, variables), scalarOrVariable(right, variables)]);
+  };
+  const parseSimple = (text) => {
+    if (!text.endsWith('.') || text.includes('\n')) return null;
+    text = text.slice(0, -1);
+    const variables = new Map();
+    const rule = text.indexOf(':-');
+    if (rule < 0) {
+      const head = parseBinaryCompound(text, variables);
+      return head ? { head, body: [] } : null;
+    }
+    const head = parseBinaryCompound(text.slice(0, rule), variables);
+    const bodyGoal = parseBinaryCompound(text.slice(rule + 2), variables);
+    return head && bodyGoal ? { head, body: [bodyGoal] } : null;
+  };
+
+  const flush = () => {
+    const text = chunk.trim();
+    chunk = '';
+    if (!text) return true;
+    const simple = parseSimple(text);
+    if (simple) {
+      clauses.push(simple);
+      return true;
+    }
+    try {
+      const parsed = new Parser(text, { sourceMetadata: false }).parseProgram();
+      clauses.push(...parsed);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  };
+
+  let lineStart = 0;
+  while (lineStart <= source.length) {
+    let lineEnd = source.indexOf('\n', lineStart);
+    if (lineEnd < 0) lineEnd = source.length;
+    let line = source.slice(lineStart, lineEnd);
+    if (line.endsWith('\r')) line = line.slice(0, -1);
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('%')) {
+      if (!chunk && trimmed.endsWith('.')) {
+        const simple = parseSimple(trimmed);
+        if (simple) clauses.push(simple);
+        else {
+          chunk = line + '\n';
+          if (!flush()) return null;
+        }
+      } else {
+        chunk += line + '\n';
+        if (trimmed.endsWith('.')) {
+          if (!flush()) return null;
+        }
+      }
+    }
+    if (lineEnd === source.length) break;
+    lineStart = lineEnd + 1;
+  }
+  if (chunk.trim() && !flush()) return null;
+  return clauses;
+}
+
 export function parseProgramText(source) {
   return parseClauses(source);
 }

package/src/program.js

@@ -1,27 +1,33 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
-import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termIsGround, termToString } from './term.js';
+import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termToString } from './term.js';
 import { parseClauses } from './parser.js';
 
 export class Program {
-  constructor(clauses = []) {
-    this.clauses = clauses.map((clause, index) => ({ ...clause, index, headGround: termIsGround(clause.head) }));
+  constructor(clauses = [], options = {}) {
+    this.clauses = clauses;
     this.groups = new Map();
-    for (const clause of this.clauses) this.indexClause(clause);
-    this.applyDeclarations();
+    this.materializedGroups = new Set();
+    this.hasMaterialize = false;
+    for (let index = 0; index < this.clauses.length; index++) {
+      const clause = this.clauses[index];
+      clause.index = index;
+      this.indexClause(clause);
+    }
+    this.applyDeclarations(options);
   }
   static parse(source, options = {}) {
-    return new Program(parseClauses(source, options));
+    return new Program(parseClauses(source, options), options);
   }
-  static parseSources(sources = []) {
+  static parseSources(sources = [], options = {}) {
     const clauses = [];
     for (const source of sources) {
       const parsed = typeof source === 'string'
-        ? parseClauses(source)
-        : parseClauses(source?.text ?? source?.source ?? '', { filename: source?.filename ?? '<input>' });
+        ? parseClauses(source, options)
+        : parseClauses(source?.text ?? source?.source ?? '', { ...options, filename: source?.filename ?? '<input>' });
       for (const clause of parsed) clauses.push(clause);
     }
-    return new Program(clauses);
+    return new Program(clauses, options);
   }
   makeGroup(name, arity) {
     // A group corresponds to one predicate indicator, for example edge/3.
@@ -61,22 +67,27 @@ export class Program {
   findGroup(name, arity) {
     return this.groups.get(`${name}/${arity}`) ?? null;
   }
-  applyDeclarations() {
+  applyDeclarations(options = {}) {
     for (const clause of this.clauses) {
       const h = clause.head;
-      if (clause.body.length === 0 && h.type === COMPOUND && h.name === 'memoize' && h.arity === 2) {
-        const [name, arity] = h.args;
-        if (name.type === ATOM && arity.type === 'number') {
-          const group = this.findGroup(name.name, Number(arity.name));
-          if (group) group.memoized = true;
-        }
+      if (clause.body.length !== 0 || h.type !== COMPOUND || h.arity !== 2) continue;
+      const [name, arity] = h.args;
+      if (name.type !== ATOM || arity.type !== 'number') continue;
+      const key = `${name.name}/${Number(arity.name)}`;
+      if (h.name === 'memoize') {
+        const group = this.groups.get(key);
+        if (group) group.memoized = true;
+      } else if (h.name === 'materialize') {
+        this.hasMaterialize = true;
+        this.materializedGroups.add(key);
       }
     }
-    this.markRecursivePredicates();
+    if (options.markRecursive !== false) this.markRecursivePredicates();
   }
   markRecursivePredicates() {
-    // Recursion is a group-level hint used by the solver and diagnostics. It is
-    // computed from predicate dependencies rather than from individual clauses.
+    // Recursion is a group-level diagnostic hint. It is computed from predicate
+    // dependencies rather than from individual clauses when callers explicitly ask
+    // for it.
     const groups = [...this.groups.values()];
     const indexByGroup = new Map(groups.map((group, i) => [group, i]));
     const deps = groups.map(() => new Set());
@@ -109,15 +120,10 @@ export class Program {
     }
   }
   hasMaterializeDeclarations() {
-    return this.clauses.some((clause) => clause.body.length === 0 && clause.head.type === COMPOUND && clause.head.name === 'materialize' && clause.head.arity === 2);
+    return this.hasMaterialize;
   }
   groupIsMaterialized(group) {
-    return this.clauses.some((clause) => {
-      const h = clause.head;
-      if (clause.body.length !== 0 || h.type !== COMPOUND || h.name !== 'materialize' || h.arity !== 2) return false;
-      const [name, arity] = h.args;
-      return name.type === ATOM && arity.type === 'number' && name.name === group.name && String(group.arity) === arity.name;
-    });
+    return this.materializedGroups.has(`${group.name}/${group.arity}`);
   }
   groupHasRule(group) {
     return group.clauses.some((clause) => clause.body.length > 0);

package/test/run-regression.js

@@ -185,6 +185,16 @@ why(
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'README and playground cover every bundled example',
+      run: () => {
+        const examples = listExampleNames();
+        const readmeExamples = readmeCatalogExampleNames();
+        const playgroundExamples = playgroundExampleNames();
+        assertEqual(readmeExamples.join('\n'), examples.join('\n'), 'README example catalog');
+        assertEqual(playgroundExamples.join('\n'), examples.join('\n'), 'playground examples');
+      },
+    },
     {
       name: 'stdin input is accepted',
       run: () => {
@@ -206,6 +216,15 @@ why(
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: '-n suppresses query explanations',
+      run: () => {
+        const result = runCli(['-n', '--query', 'p(X)', '-'], { input: 'p(a).\np(b).\n' });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'p(a).\np(b).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: '--no-why suppresses materialization explanations',
       run: () => {
@@ -460,6 +479,40 @@ function runWhyLoose({ program, query }) {
   return result;
 }
 
+function listExampleNames() {
+  return fs.readdirSync(path.join(root, 'examples'))
+    .filter((name) => name.endsWith('.pl'))
+    .map((name) => name.slice(0, -3))
+    .sort();
+}
+
+function readmeCatalogExampleNames() {
+  const readme = fs.readFileSync(path.join(root, 'README.md'), 'utf8');
+  const section = between(readme, '## Example catalog', '## Golden outputs, tests, and conformance');
+  return [...section.matchAll(/examples\/([A-Za-z0-9_-]+)\.pl/g)]
+    .map((match) => match[1])
+    .filter((name, index, names) => names.indexOf(name) === index)
+    .sort();
+}
+
+function playgroundExampleNames() {
+  const html = fs.readFileSync(path.join(root, 'playground.html'), 'utf8');
+  const match = html.match(/const EXAMPLES = \[(.*?)\];/s);
+  if (match == null) throw new Error('playground EXAMPLES array not found');
+  return [...match[1].matchAll(/"([^"]+)"/g)]
+    .map((match) => match[1])
+    .sort();
+}
+
+function between(text, startMarker, endMarker) {
+  const start = text.indexOf(startMarker);
+  if (start === -1) throw new Error(`${startMarker} not found`);
+  const contentStart = start + startMarker.length;
+  const end = text.indexOf(endMarker, contentStart);
+  if (end === -1) throw new Error(`${endMarker} not found`);
+  return text.slice(contentStart, end);
+}
+
 function runCli(args, options = {}) {
   return spawnSync(process.execPath, [bin, ...args], {
     cwd: root,