eyelang 1.3.8 → 1.3.9

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.8",
+  "version": "1.3.9",
   "type": "module",
   "description": "A small rule engine for Prolog-style Horn clauses",
   "keywords": [

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

@@ -216,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: () => {