eyeprolog 1.5.4 → 1.5.5

package/package.json

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

package/src/datalog-common.js

@@ -0,0 +1,56 @@
+// Shared plumbing for the finite positive-Datalog and WFS evaluators.
+//
+// Keep evaluator-specific relation storage and fixpoint algorithms in their
+// own modules; this file only contains representation/traversal helpers whose
+// semantics are common to both execution paths.
+
+import { ATOM, COMPOUND, VAR } from './term.js';
+
+export const EMPTY_ARRAY = Object.freeze([]);
+
+export function predicateKey(module, name, arity) {
+  return `${module ?? 'user'}:${name}/${arity}`;
+}
+
+export function directLiteral(goal, module) {
+  if (goal?.type !== COMPOUND && goal?.type !== ATOM) return null;
+  return {
+    key: predicateKey(goal.module ?? module, goal.name, goal.arity),
+    name: goal.name,
+    arity: goal.arity,
+    module: goal.module ?? module,
+    args: goal.args ?? EMPTY_ARRAY,
+  };
+}
+
+export function dependencyCone(program, rootGroup, literalForGoal = directLiteral) {
+  const groups = [];
+  const seen = new Set();
+  const stack = [rootGroup];
+  while (stack.length > 0) {
+    const group = stack.pop();
+    const key = predicateKey(group.module, group.name, group.arity);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    groups.push(group);
+    for (const clause of group.clauses) {
+      for (const goal of clause.body) {
+        const literal = literalForGoal(goal, group.module);
+        if (!literal) continue;
+        const target = program.findGroup(literal.name, literal.arity, literal.module);
+        if (target) stack.push(target);
+      }
+    }
+  }
+  return groups;
+}
+
+export function resolvePatternTerm(term, bindings) {
+  if (term.type === VAR) return bindings.get(term.name) ?? null;
+  return term;
+}
+
+export function estimateLiteral(literal, relation, bindings) {
+  const candidates = relation.candidateIndexes(literal.args, bindings);
+  return candidates == null ? relation.rows.length : candidates.length;
+}

package/src/datalog.js

@@ -5,14 +5,16 @@
 // newly-added row fires only the rule occurrences that mention its predicate.
 // This avoids replaying the whole recursive program on every table round.
 
-import { ATOM, COMPOUND, VAR } from './term.js';
+import { VAR } from './term.js';
 import { numberValueKey } from './number-value.js';
-
-const EMPTY_ARRAY = Object.freeze([]);
-
-function predicateKey(module, name, arity) {
-  return `${module ?? 'user'}:${name}/${arity}`;
-}
+import {
+  EMPTY_ARRAY,
+  dependencyCone,
+  directLiteral,
+  estimateLiteral,
+  predicateKey,
+  resolvePatternTerm,
+} from './datalog-common.js';
 
 const scalarKeyCache = new WeakMap();
 
@@ -30,11 +32,6 @@ function sameScalar(left, right) {
   return scalarKey(left) === scalarKey(right);
 }
 
-function tupleKey(tuple) {
-  if (tuple.length === 1) return scalarKey(tuple[0]);
-  return tuple.map(scalarKey).join('\u0001');
-}
-
 export class DatalogRelation {
   constructor(arity) {
     this.arity = arity;
@@ -117,50 +114,16 @@ export class DatalogRelation {
   }
 }
 
-function directLiteral(goal, module) {
-  if (goal?.type !== COMPOUND && goal?.type !== ATOM) return null;
-  return {
-    key: predicateKey(goal.module ?? module, goal.name, goal.arity),
-    name: goal.name,
-    arity: goal.arity,
-    module: goal.module ?? module,
-    args: goal.args ?? EMPTY_ARRAY,
-  };
-}
-
-function dependencyCone(program, rootGroup) {
-  const groups = [];
-  const seen = new Set();
-  const stack = [rootGroup];
-  while (stack.length > 0) {
-    const group = stack.pop();
-    const key = predicateKey(group.module, group.name, group.arity);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    groups.push(group);
-    for (const clause of group.clauses) {
-      for (const goal of clause.body) {
-        const literal = directLiteral(goal, group.module);
-        if (!literal) continue;
-        const target = program.findGroup(literal.name, literal.arity, literal.module);
-        if (target) stack.push(target);
-      }
-    }
-  }
-  return groups;
-}
 
 function compileProgram(program, rootGroup) {
   const groups = dependencyCone(program, rootGroup);
   const relations = new Map();
-  const groupByKey = new Map();
   const rules = [];
   const triggers = new Map();
 
   for (const group of groups) {
     const key = predicateKey(group.module, group.name, group.arity);
     relations.set(key, new DatalogRelation(group.arity));
-    groupByKey.set(key, group);
   }
 
   for (const group of groups) {
@@ -181,13 +144,9 @@ function compileProgram(program, rootGroup) {
     }
   }
 
-  return { groups, groupByKey, relations, rules, triggers };
+  return { groups, relations, rules, triggers };
 }
 
-function resolvePatternTerm(term, bindings) {
-  if (term.type === VAR) return bindings.get(term.name) ?? null;
-  return term;
-}
 
 function matchTupleMutable(args, tuple, bindings) {
   const added = [];
@@ -218,10 +177,6 @@ function undoBindings(bindings, added) {
   for (let i = added.length - 1; i >= 0; i--) bindings.delete(added[i]);
 }
 
-function estimateLiteral(literal, relation, bindings) {
-  const candidates = relation.candidateIndexes(literal.args, bindings);
-  return candidates == null ? relation.rows.length : candidates.length;
-}
 
 function forEachBinding(body, relations, callback, bindings, remaining) {
   if (remaining.length === 0) {
@@ -271,16 +226,6 @@ function forEachBinding(body, relations, callback, bindings, remaining) {
   }
 }
 
-function instantiateTuple(args, bindings) {
-  const tuple = new Array(args.length);
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const value = arg.type === VAR ? bindings.get(arg.name) : arg;
-    if (value == null || value.type === VAR) return null;
-    tuple[i] = value;
-  }
-  return tuple;
-}
 
 export function evaluatePositiveDatalog(program, rootGroup) {
   const compiled = compileProgram(program, rootGroup);

package/src/wfs.js

@@ -12,10 +12,14 @@
 
 import { ATOM, COMPOUND, VAR } from './term.js';
 import { numberValueKey } from './number-value.js';
-
-function predicateKey(module, name, arity) {
-  return `${module ?? 'user'}:${name}/${arity}`;
-}
+import {
+  EMPTY_ARRAY,
+  dependencyCone,
+  directLiteral,
+  estimateLiteral,
+  predicateKey,
+  resolvePatternTerm,
+} from './datalog-common.js';
 
 function scalarKey(term) {
   if (term.type === 'number') return `number\u0000${numberValueKey(term.name)}`;
@@ -73,8 +77,6 @@ class Relation {
   }
 }
 
-const EMPTY_ARRAY = Object.freeze([]);
-
 function emptyRelations(groups) {
   const relations = new Map();
   for (const group of groups) {
@@ -93,48 +95,18 @@ function copyBaseRelations(base, groups) {
   return relations;
 }
 
-function directLiteral(goal, module) {
-  if (goal?.type !== COMPOUND && goal?.type !== ATOM) return null;
-  return {
-    key: predicateKey(goal.module ?? module, goal.name, goal.arity),
-    name: goal.name,
-    arity: goal.arity,
-    module: goal.module ?? module,
-    args: goal.args ?? EMPTY_ARRAY,
-  };
-}
 
 function negativeLiteral(goal, module) {
   if (goal?.type !== COMPOUND || goal.name !== 'tnot' || goal.arity !== 1) return null;
   return directLiteral(goal.args[0], module);
 }
 
-function dependencyCone(program, rootGroup) {
-  const groups = [];
-  const seen = new Set();
-  const stack = [rootGroup];
-  while (stack.length > 0) {
-    const group = stack.pop();
-    const key = predicateKey(group.module, group.name, group.arity);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    groups.push(group);
-
-    for (const clause of group.clauses) {
-      for (const goal of clause.body) {
-        const neg = negativeLiteral(goal, group.module);
-        const literal = neg ?? directLiteral(goal, group.module);
-        if (!literal) continue;
-        const target = program.findGroup(literal.name, literal.arity, literal.module);
-        if (target) stack.push(target);
-      }
-    }
-  }
-  return groups;
+function dependencyLiteral(goal, module) {
+  return negativeLiteral(goal, module) ?? directLiteral(goal, module);
 }
 
 function compileProgram(program, rootGroup) {
-  const groups = dependencyCone(program, rootGroup);
+  const groups = dependencyCone(program, rootGroup, dependencyLiteral);
   const base = emptyRelations(groups);
   const rules = [];
 
@@ -175,10 +147,6 @@ function compileProgram(program, rootGroup) {
   return { groups, base, rules };
 }
 
-function resolvePatternTerm(term, bindings) {
-  if (term.type === VAR) return bindings.get(term.name) ?? null;
-  return term;
-}
 
 function matchTuple(args, tuple, bindings) {
   let next = null;
@@ -199,10 +167,6 @@ function matchTuple(args, tuple, bindings) {
   return next ?? bindings;
 }
 
-function estimateLiteral(literal, relation, bindings) {
-  const candidates = relation.candidateIndexes(literal.args, bindings);
-  return candidates == null ? relation.rows.length : candidates.length;
-}
 
 function forEachPositiveBinding(positives, relations, callback, bindings = new Map(), remaining = null) {
   if (remaining == null) remaining = positives.map((_, index) => index);