@suss/datalog 0.37.0 → 0.38.0

package/dist/index.cjs

@@ -50,45 +50,93 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/factIndex.ts
-var emptyNode = () => ({
-  present: false,
-  tag: void 0,
-  next: void 0
-});
+var FactKey = class {
+  constructor(tuple) {
+    this.tuple = tuple;
+  }
+  tuple;
+  present = false;
+  tag = void 0;
+};
+var Branch = class {
+  /** The key of a tuple that ends at this column, as a shorter one in a relation of mixed arity does. */
+  here = void 0;
+  next = /* @__PURE__ */ new Map();
+};
+function sameFrom(a, b, from) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let at = from; at < a.length; at++) {
+    if (a[at] !== b[at]) {
+      return false;
+    }
+  }
+  return true;
+}
+function place(branch, key, depth) {
+  if (depth === key.tuple.length) {
+    branch.here = key;
+  } else {
+    branch.next.set(key.tuple[depth], key);
+  }
+}
+function soleKey(branch) {
+  if (branch.here !== void 0) {
+    return branch.next.size === 0 ? branch.here : void 0;
+  }
+  if (branch.next.size !== 1) {
+    return void 0;
+  }
+  const only = branch.next.values().next().value;
+  return only instanceof FactKey ? only : void 0;
+}
 var FactIndex = class {
   /** How many facts are present. */
   size = 0;
-  root = emptyNode();
+  root = new Branch();
   /** This tuple's key here, whether or not the fact is present. */
   key(tuple) {
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      let next = node.next;
-      if (next === void 0) {
-        next = /* @__PURE__ */ new Map();
-        node.next = next;
+    let branch = this.root;
+    for (let depth = 0; ; depth++) {
+      if (depth === tuple.length) {
+        branch.here ??= new FactKey(tuple);
+        return branch.here;
       }
-      const atom = tuple[i];
-      let child = next.get(atom);
+      const atom = tuple[depth];
+      const child = branch.next.get(atom);
       if (child === void 0) {
-        child = emptyNode();
-        next.set(atom, child);
+        const key = new FactKey(tuple);
+        branch.next.set(atom, key);
+        return key;
+      }
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      if (sameFrom(child.tuple, tuple, depth + 1)) {
+        return child;
       }
-      node = child;
+      const split = new Branch();
+      place(split, child, depth + 1);
+      branch.next.set(atom, split);
+      branch = split;
     }
-    return node;
   }
   /** The key of a fact this relation has, or undefined when it has none. */
   find(tuple) {
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      const child = node.next?.get(tuple[i]);
+    let branch = this.root;
+    for (let depth = 0; ; depth++) {
+      const child = depth === tuple.length ? branch.here : branch.next.get(tuple[depth]);
       if (child === void 0) {
         return void 0;
       }
-      node = child;
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      return child.present && sameFrom(child.tuple, tuple, depth + 1) ? child : void 0;
     }
-    return node.present ? node : void 0;
   }
   has(key) {
     return key.present;
@@ -112,32 +160,45 @@ var FactIndex = class {
     this.size -= 1;
   }
   /**
-   * Drop what is left of a removed tuple's path, up to the first node
-   * another fact still needs. Without this a relation that is retracted
-   * from over and over keeps a node per tuple it ever had.
+   * Drop a removed tuple's key, and any branch left with one key to
+   * tell apart. Without this a relation that is retracted from over and
+   * over keeps a key per tuple it ever had.
    */
   prune(tuple) {
-    const path = [this.root];
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      const child = node.next?.get(tuple[i]);
+    const path = [];
+    let branch = this.root;
+    let depth = 0;
+    for (; ; depth++) {
+      path.push(branch);
+      const child = depth === tuple.length ? branch.here : branch.next.get(tuple[depth]);
       if (child === void 0) {
         return;
       }
-      node = child;
-      path.push(child);
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      if (child.present || !sameFrom(child.tuple, tuple, depth + 1)) {
+        return;
+      }
+      break;
+    }
+    if (depth === tuple.length) {
+      branch.here = void 0;
+    } else {
+      branch.next.delete(tuple[depth]);
     }
-    for (let i = path.length - 1; i > 0; i--) {
-      const child = path[i];
-      if (child.present || (child.next?.size ?? 0) > 0) {
+    for (let at = path.length - 1; at > 0; at--) {
+      const sole = soleKey(path[at]);
+      if (sole === void 0) {
         return;
       }
-      path[i - 1].next?.delete(tuple[i - 1]);
+      path[at - 1].next.set(tuple[at - 1], sole);
     }
   }
   /** Drop every fact, and whatever was kept in order to find them. */
   clear() {
-    this.root = emptyNode();
+    this.root = new Branch();
     this.size = 0;
   }
 };
@@ -574,6 +635,24 @@ function formatProfile(profile) {
 }
 
 // src/relation.ts
+var isLone = (bucket) => typeof bucket[0] !== "object";
+var NO_TUPLES = [];
+function tuplesIn(bucket) {
+  if (bucket === void 0) {
+    return NO_TUPLES;
+  }
+  return isLone(bucket) ? [bucket] : bucket;
+}
+function fileUnder(buckets, key, tuple) {
+  const bucket = buckets.get(key);
+  if (bucket === void 0) {
+    buckets.set(key, tuple);
+  } else if (isLone(bucket)) {
+    buckets.set(key, [bucket, tuple]);
+  } else {
+    bucket.push(tuple);
+  }
+}
 var sameTuple = (a, b) => a.length === b.length && a.every((atom, at) => atom === b[at]);
 function storedTuplesOf(relation, facts) {
   const column = relation.columns.findIndex((buckets2) => buckets2 !== void 0);
@@ -582,19 +661,24 @@ function storedTuplesOf(relation, facts) {
     return null;
   }
   const stored = facts.map(
-    (fact) => buckets.get(fact[column])?.find((tuple) => sameTuple(tuple, fact))
+    (fact) => tuplesIn(buckets.get(fact[column])).find(
+      (tuple) => sameTuple(tuple, fact)
+    )
   );
   return stored.every((tuple) => tuple !== void 0) ? stored : null;
 }
 function removeFrom(buckets, key, tuple) {
   const bucket = buckets.get(key);
-  const at = bucket?.indexOf(tuple) ?? -1;
-  if (bucket === void 0 || at === -1) {
+  if (bucket === void 0) {
     return;
   }
-  bucket.splice(at, 1);
-  if (bucket.length === 0) {
+  if (isLone(bucket)) {
     buckets.delete(key);
+    return;
+  }
+  bucket.splice(bucket.indexOf(tuple), 1);
+  if (bucket.length === 1) {
+    buckets.set(key, bucket[0]);
   }
 }
 function removeTuples(relation, stored) {
@@ -646,7 +730,7 @@ function addToCombined(index, tuple) {
     }
     level = next;
   }
-  addToBucket(
+  fileUnder(
     level,
     tuple[index.columns[last]],
     tuple
@@ -665,10 +749,10 @@ function combinedBucketIn(relation, mask, values) {
   for (const value of values) {
     level = level.get(value);
     if (level === void 0) {
-      return [];
+      return NO_TUPLES;
     }
   }
-  return level;
+  return tuplesIn(level);
 }
 function addToBucket(buckets, key, tuple) {
   const bucket = buckets.get(key);
@@ -685,12 +769,12 @@ function bucketIn(relation, column, value) {
     for (const tuple of relation.tuples) {
       const at = tuple[column];
       if (at !== void 0) {
-        addToBucket(buckets, at, tuple);
+        fileUnder(buckets, at, tuple);
       }
     }
     relation.columns[column] = buckets;
   }
-  return buckets.get(value) ?? [];
+  return tuplesIn(buckets.get(value));
 }
 
 // src/stratum.ts
@@ -956,7 +1040,7 @@ var Database = class {
       const buckets = relation.columns[column];
       const value = tuple[column];
       if (buckets !== void 0 && value !== void 0) {
-        addToBucket(buckets, value, tuple);
+        fileUnder(buckets, value, tuple);
       }
     }
     for (const combined of relation.combined.values()) {

package/dist/index.d.cts

@@ -7,10 +7,10 @@
  * The join asks for that key again on every candidate the rules
  * consider, so what the key costs to work out sets the cost of
  * evaluation. A relation finds a fact by walking a trie of its tuple's
- * atoms, one map hop per column, and the node the walk lands on is the
- * fact itself. Nothing is built to identify a tuple, and a membership
- * test that fails stops at the first column that misses. DESIGN.md says
- * why the walk is over the atoms rather than over interned integers.
+ * atoms, one map hop per column, to the first column where no other
+ * tuple shares the atoms so far. The key is stored there, and the walk
+ * compares the rest of the tuple instead of taking a map per column.
+ * DESIGN.md says why the walk is over the atoms, not interned integers.
  */
 
 /**
@@ -18,10 +18,11 @@
  * nothing to the relation that did not hand it out, and nothing outside
  * this module reads its fields.
  */
-interface FactKey {
+declare class FactKey {
+    readonly tuple: Tuple;
     present: boolean;
     tag: unknown;
-    next: Map<Atom, FactKey> | undefined;
+    constructor(tuple: Tuple);
 }
 /** The facts one relation has, and the tag stored against each. */
 declare class FactIndex {
@@ -40,9 +41,9 @@ declare class FactIndex {
     /** Take the fact away, and the tag with it. */
     remove(key: FactKey): void;
     /**
-     * Drop what is left of a removed tuple's path, up to the first node
-     * another fact still needs. Without this a relation that is retracted
-     * from over and over keeps a node per tuple it ever had.
+     * Drop a removed tuple's key, and any branch left with one key to
+     * tell apart. Without this a relation that is retracted from over and
+     * over keeps a key per tuple it ever had.
      */
     prune(tuple: Tuple): void;
     /** Drop every fact, and whatever was kept in order to find them. */
@@ -70,7 +71,7 @@ interface Relation {
      * encoding it first would build a string out of every node id on every
      * lookup and buy nothing.
      */
-    columns: (Map<Atom, Tuple[]> | undefined)[];
+    columns: (Map<Atom, Bucket> | undefined)[];
     /**
      * Per set of columns, the tuples under each combination of values at
      * those columns, keyed by a bitmask of the column positions. Built and
@@ -86,6 +87,13 @@ interface CombinedIndex {
     columns: readonly number[];
     root: Map<Atom, unknown>;
 }
+/**
+ * The tuples an index has under one value, in the order they arrived.
+ * Most values in a column of node ids belong to a single tuple, and an
+ * array for each of those cost more than the tuple itself, so a lone
+ * tuple is kept on its own.
+ */
+type Bucket = Tuple | Tuple[];
 
 /**
  * Confidence levels as a tag algebra: how sure the run is of each

package/dist/index.d.ts

@@ -7,10 +7,10 @@
  * The join asks for that key again on every candidate the rules
  * consider, so what the key costs to work out sets the cost of
  * evaluation. A relation finds a fact by walking a trie of its tuple's
- * atoms, one map hop per column, and the node the walk lands on is the
- * fact itself. Nothing is built to identify a tuple, and a membership
- * test that fails stops at the first column that misses. DESIGN.md says
- * why the walk is over the atoms rather than over interned integers.
+ * atoms, one map hop per column, to the first column where no other
+ * tuple shares the atoms so far. The key is stored there, and the walk
+ * compares the rest of the tuple instead of taking a map per column.
+ * DESIGN.md says why the walk is over the atoms, not interned integers.
  */
 
 /**
@@ -18,10 +18,11 @@
  * nothing to the relation that did not hand it out, and nothing outside
  * this module reads its fields.
  */
-interface FactKey {
+declare class FactKey {
+    readonly tuple: Tuple;
     present: boolean;
     tag: unknown;
-    next: Map<Atom, FactKey> | undefined;
+    constructor(tuple: Tuple);
 }
 /** The facts one relation has, and the tag stored against each. */
 declare class FactIndex {
@@ -40,9 +41,9 @@ declare class FactIndex {
     /** Take the fact away, and the tag with it. */
     remove(key: FactKey): void;
     /**
-     * Drop what is left of a removed tuple's path, up to the first node
-     * another fact still needs. Without this a relation that is retracted
-     * from over and over keeps a node per tuple it ever had.
+     * Drop a removed tuple's key, and any branch left with one key to
+     * tell apart. Without this a relation that is retracted from over and
+     * over keeps a key per tuple it ever had.
      */
     prune(tuple: Tuple): void;
     /** Drop every fact, and whatever was kept in order to find them. */
@@ -70,7 +71,7 @@ interface Relation {
      * encoding it first would build a string out of every node id on every
      * lookup and buy nothing.
      */
-    columns: (Map<Atom, Tuple[]> | undefined)[];
+    columns: (Map<Atom, Bucket> | undefined)[];
     /**
      * Per set of columns, the tuples under each combination of values at
      * those columns, keyed by a bitmask of the column positions. Built and
@@ -86,6 +87,13 @@ interface CombinedIndex {
     columns: readonly number[];
     root: Map<Atom, unknown>;
 }
+/**
+ * The tuples an index has under one value, in the order they arrived.
+ * Most values in a column of node ids belong to a single tuple, and an
+ * array for each of those cost more than the tuple itself, so a lone
+ * tuple is kept on its own.
+ */
+type Bucket = Tuple | Tuple[];
 
 /**
  * Confidence levels as a tag algebra: how sure the run is of each

package/dist/index.js

@@ -1,43 +1,91 @@
 // src/factIndex.ts
-var emptyNode = () => ({
-  present: false,
-  tag: void 0,
-  next: void 0
-});
+var FactKey = class {
+  constructor(tuple) {
+    this.tuple = tuple;
+  }
+  tuple;
+  present = false;
+  tag = void 0;
+};
+var Branch = class {
+  /** The key of a tuple that ends at this column, as a shorter one in a relation of mixed arity does. */
+  here = void 0;
+  next = /* @__PURE__ */ new Map();
+};
+function sameFrom(a, b, from) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let at = from; at < a.length; at++) {
+    if (a[at] !== b[at]) {
+      return false;
+    }
+  }
+  return true;
+}
+function place(branch, key, depth) {
+  if (depth === key.tuple.length) {
+    branch.here = key;
+  } else {
+    branch.next.set(key.tuple[depth], key);
+  }
+}
+function soleKey(branch) {
+  if (branch.here !== void 0) {
+    return branch.next.size === 0 ? branch.here : void 0;
+  }
+  if (branch.next.size !== 1) {
+    return void 0;
+  }
+  const only = branch.next.values().next().value;
+  return only instanceof FactKey ? only : void 0;
+}
 var FactIndex = class {
   /** How many facts are present. */
   size = 0;
-  root = emptyNode();
+  root = new Branch();
   /** This tuple's key here, whether or not the fact is present. */
   key(tuple) {
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      let next = node.next;
-      if (next === void 0) {
-        next = /* @__PURE__ */ new Map();
-        node.next = next;
+    let branch = this.root;
+    for (let depth = 0; ; depth++) {
+      if (depth === tuple.length) {
+        branch.here ??= new FactKey(tuple);
+        return branch.here;
       }
-      const atom = tuple[i];
-      let child = next.get(atom);
+      const atom = tuple[depth];
+      const child = branch.next.get(atom);
       if (child === void 0) {
-        child = emptyNode();
-        next.set(atom, child);
+        const key = new FactKey(tuple);
+        branch.next.set(atom, key);
+        return key;
+      }
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      if (sameFrom(child.tuple, tuple, depth + 1)) {
+        return child;
       }
-      node = child;
+      const split = new Branch();
+      place(split, child, depth + 1);
+      branch.next.set(atom, split);
+      branch = split;
     }
-    return node;
   }
   /** The key of a fact this relation has, or undefined when it has none. */
   find(tuple) {
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      const child = node.next?.get(tuple[i]);
+    let branch = this.root;
+    for (let depth = 0; ; depth++) {
+      const child = depth === tuple.length ? branch.here : branch.next.get(tuple[depth]);
       if (child === void 0) {
         return void 0;
       }
-      node = child;
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      return child.present && sameFrom(child.tuple, tuple, depth + 1) ? child : void 0;
     }
-    return node.present ? node : void 0;
   }
   has(key) {
     return key.present;
@@ -61,32 +109,45 @@ var FactIndex = class {
     this.size -= 1;
   }
   /**
-   * Drop what is left of a removed tuple's path, up to the first node
-   * another fact still needs. Without this a relation that is retracted
-   * from over and over keeps a node per tuple it ever had.
+   * Drop a removed tuple's key, and any branch left with one key to
+   * tell apart. Without this a relation that is retracted from over and
+   * over keeps a key per tuple it ever had.
    */
   prune(tuple) {
-    const path = [this.root];
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      const child = node.next?.get(tuple[i]);
+    const path = [];
+    let branch = this.root;
+    let depth = 0;
+    for (; ; depth++) {
+      path.push(branch);
+      const child = depth === tuple.length ? branch.here : branch.next.get(tuple[depth]);
       if (child === void 0) {
         return;
       }
-      node = child;
-      path.push(child);
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      if (child.present || !sameFrom(child.tuple, tuple, depth + 1)) {
+        return;
+      }
+      break;
+    }
+    if (depth === tuple.length) {
+      branch.here = void 0;
+    } else {
+      branch.next.delete(tuple[depth]);
     }
-    for (let i = path.length - 1; i > 0; i--) {
-      const child = path[i];
-      if (child.present || (child.next?.size ?? 0) > 0) {
+    for (let at = path.length - 1; at > 0; at--) {
+      const sole = soleKey(path[at]);
+      if (sole === void 0) {
         return;
       }
-      path[i - 1].next?.delete(tuple[i - 1]);
+      path[at - 1].next.set(tuple[at - 1], sole);
     }
   }
   /** Drop every fact, and whatever was kept in order to find them. */
   clear() {
-    this.root = emptyNode();
+    this.root = new Branch();
     this.size = 0;
   }
 };
@@ -523,6 +584,24 @@ function formatProfile(profile) {
 }
 
 // src/relation.ts
+var isLone = (bucket) => typeof bucket[0] !== "object";
+var NO_TUPLES = [];
+function tuplesIn(bucket) {
+  if (bucket === void 0) {
+    return NO_TUPLES;
+  }
+  return isLone(bucket) ? [bucket] : bucket;
+}
+function fileUnder(buckets, key, tuple) {
+  const bucket = buckets.get(key);
+  if (bucket === void 0) {
+    buckets.set(key, tuple);
+  } else if (isLone(bucket)) {
+    buckets.set(key, [bucket, tuple]);
+  } else {
+    bucket.push(tuple);
+  }
+}
 var sameTuple = (a, b) => a.length === b.length && a.every((atom, at) => atom === b[at]);
 function storedTuplesOf(relation, facts) {
   const column = relation.columns.findIndex((buckets2) => buckets2 !== void 0);
@@ -531,19 +610,24 @@ function storedTuplesOf(relation, facts) {
     return null;
   }
   const stored = facts.map(
-    (fact) => buckets.get(fact[column])?.find((tuple) => sameTuple(tuple, fact))
+    (fact) => tuplesIn(buckets.get(fact[column])).find(
+      (tuple) => sameTuple(tuple, fact)
+    )
   );
   return stored.every((tuple) => tuple !== void 0) ? stored : null;
 }
 function removeFrom(buckets, key, tuple) {
   const bucket = buckets.get(key);
-  const at = bucket?.indexOf(tuple) ?? -1;
-  if (bucket === void 0 || at === -1) {
+  if (bucket === void 0) {
     return;
   }
-  bucket.splice(at, 1);
-  if (bucket.length === 0) {
+  if (isLone(bucket)) {
     buckets.delete(key);
+    return;
+  }
+  bucket.splice(bucket.indexOf(tuple), 1);
+  if (bucket.length === 1) {
+    buckets.set(key, bucket[0]);
   }
 }
 function removeTuples(relation, stored) {
@@ -595,7 +679,7 @@ function addToCombined(index, tuple) {
     }
     level = next;
   }
-  addToBucket(
+  fileUnder(
     level,
     tuple[index.columns[last]],
     tuple
@@ -614,10 +698,10 @@ function combinedBucketIn(relation, mask, values) {
   for (const value of values) {
     level = level.get(value);
     if (level === void 0) {
-      return [];
+      return NO_TUPLES;
     }
   }
-  return level;
+  return tuplesIn(level);
 }
 function addToBucket(buckets, key, tuple) {
   const bucket = buckets.get(key);
@@ -634,12 +718,12 @@ function bucketIn(relation, column, value) {
     for (const tuple of relation.tuples) {
       const at = tuple[column];
       if (at !== void 0) {
-        addToBucket(buckets, at, tuple);
+        fileUnder(buckets, at, tuple);
       }
     }
     relation.columns[column] = buckets;
   }
-  return buckets.get(value) ?? [];
+  return tuplesIn(buckets.get(value));
 }
 
 // src/stratum.ts
@@ -905,7 +989,7 @@ var Database = class {
       const buckets = relation.columns[column];
       const value = tuple[column];
       if (buckets !== void 0 && value !== void 0) {
-        addToBucket(buckets, value, tuple);
+        fileUnder(buckets, value, tuple);
       }
     }
     for (const combined of relation.combined.values()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/datalog",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "type": "module",
   "description": "A small semi-naive Datalog evaluator with stratified negation, the rules engine suss runs its whole-program analyses on.",
   "keywords": [