@bablr/btree 0.1.0 → 0.2.0

package/lib/enhanceable.js

@@ -1,20 +1,58 @@
 import emptyStack from '@iter-tools/imm-stack';
 
 const { isArray } = Array;
-const { freeze: freezeObject, isFrozen } = Object;
+const { freeze } = Object;
 const { isFinite } = Number;
 
-export const buildModule = (NODE_SIZE = 8) => {
+export const defaultNodeSize = 8;
+
+export const buildModule = (
+  NODE_SIZE = defaultNodeSize,
+  statsReducer,
+  getSumsInitial,
+  finalizeSums,
+) => {
   const sumNodes = (nodes) => {
     return nodes.map(getSum).reduce((a, b) => a + b, 0);
   };
 
-  const treeFrom = (...trees) => [sumNodes(trees), trees];
+  const treeFrom = (...values) => {
+    if (!statsReducer && values.length <= NODE_SIZE) {
+      return freeze(values);
+    } else {
+      let tree = [];
+      for (const value of values) {
+        tree = push(tree, value);
+      }
+      return tree;
+    }
+  };
+
+  const buildStats = (values) => {
+    let sums = values.reduce(statsReducer, getSumsInitial());
+    finalizeSums(sums);
+    return sums;
+  };
+
+  const treeFromValues = (values) => {
+    if (!statsReducer && values.length <= NODE_SIZE) {
+      return isArray(values[0]) ? freeze([sumNodes(values), freeze(values)]) : freeze(values);
+    } else {
+      if (values.length <= NODE_SIZE) {
+        if (statsReducer) {
+          return freeze([sumNodes(values), freeze(values), buildStats(values)]);
+        } else {
+          return freeze([sumNodes(values), freeze(values)]);
+        }
+      } else {
+        throw new Error();
+      }
+    }
+  };
 
-  const findBalancePoint = (tree) => {
-    const values = isFinite(tree[0]) ? tree[1] : tree;
+  const findBalancePoint = (values) => {
     let leftSum = 0;
-    let rightSum = getSum(tree);
+    let rightSum = values.reduce((sum, v) => sum + getSum(v), 0);
     let balance = leftSum / rightSum;
 
     if (!values.length) return null;
@@ -35,48 +73,47 @@ export const buildModule = (NODE_SIZE = 8) => {
     return values.length - 1;
   };
 
-  const split = (tree) => {
-    const values = isFinite(tree[0]) ? tree[1] : tree;
-    const isLeaf = isLeafNode(tree);
+  const splitValues = (values) => {
+    const isLeaf = !isArray(values[0]);
 
     let midIndex;
 
     if (isLeaf) {
       midIndex = Math.floor(values.length / 2 + 0.01);
     } else {
-      midIndex = findBalancePoint(tree);
+      midIndex = findBalancePoint(values);
     }
 
     let leftValues = values.slice(0, midIndex);
     let rightValues = values.slice(midIndex);
 
-    let left = isLeaf ? leftValues : [sumNodes(leftValues), leftValues];
-    let right = isLeaf ? rightValues : [sumNodes(rightValues), rightValues];
-
-    return { left, right };
+    return { leftValues, rightValues };
   };
 
   const setValuesAt = (idx, node, value) => {
     const isLeaf = isLeafNode(node);
-    const values = isLeaf ? node : node[1];
+    const values = getValues(node);
+
+    if (isArray(value)) Error('cannot set arrays as btree values');
 
     if (!isLeaf && !isArray(value)) {
       throw new Error();
     }
 
-    const oldSize = isLeaf ? 1 : values[idx] ? getSum(values[idx]) : 0;
-    const newSize = isLeaf ? 1 : getSum(value);
-
-    // TODO mutable sets?
+    if (isLeaf && isArray(value) && node.length) throw new Error();
 
     const newValues = [...values];
     newValues[idx] = value;
-    freezeObject(newValues);
-    return isLeaf ? newValues : freezeObject([node[0] + newSize - oldSize, newValues]);
+    return treeFromValues(newValues);
   };
 
   const addAt = (idx, tree, value) => {
     if (idx < 0) throw new Error('invalid argument');
+    if (!isArray(tree)) throw new Error();
+
+    let isLeaf = isLeafNode(tree);
+
+    if (isArray(value)) throw new Error('cannot add arrays to btrees');
 
     let path = findPath(idx, tree);
 
@@ -85,20 +122,23 @@ export const buildModule = (NODE_SIZE = 8) => {
     // left pushout vs right pushout?
     let pushout = value;
 
-    let values = [...getValues(node)];
+    let values = getValues(node);
 
     for (;;) {
       if (pushout) {
         values = [...values];
+
+        let finiteIndex = index === Infinity ? values.length : index;
+
+        if (!isFinite(finiteIndex)) throw new Error();
         if (values.length + getValues(pushout).length > NODE_SIZE) {
-          values.splice(index, 0, pushout);
-          node = setValues(node, values);
-          const { left, right } = split(node);
+          values.splice(finiteIndex, 0, pushout);
+          const { leftValues, rightValues } = splitValues(values);
 
-          pushout = left;
-          node = right;
+          pushout = treeFromValues(leftValues);
+          node = treeFromValues(rightValues);
         } else {
-          values.splice(index, 0, pushout);
+          values.splice(finiteIndex, 0, pushout);
           node = setValues(node, values);
           pushout = null;
         }
@@ -106,7 +146,7 @@ export const buildModule = (NODE_SIZE = 8) => {
 
       if (path.size === 1) {
         if (pushout) {
-          return treeFrom(pushout, node);
+          return treeFromValues([pushout, node]);
         } else {
           return node;
         }
@@ -143,8 +183,10 @@ export const buildModule = (NODE_SIZE = 8) => {
 
     let { node, index } = path.value;
 
-    const initialValues = [...getValues(node)].slice(0, -1);
-    let returnValue = isLeafNode(node) ? initialValues : [sumNodes(initialValues), initialValues];
+    const initialValues = freeze(getValues(node).slice(0, -1));
+    let returnValue = isLeafNode(node)
+      ? initialValues
+      : freeze([sumNodes(initialValues), initialValues]);
 
     for (;;) {
       let values = getValues(returnValue);
@@ -206,7 +248,7 @@ export const buildModule = (NODE_SIZE = 8) => {
 
   const isValidNode = (node) => {
     if (!isArray(node)) return false;
-    const values = isFinite(node[0]) ? node[1] : node;
+    const values = getValues(node);
     return isArray(values); //  && values.length <= NODE_SIZE;
   };
 
@@ -220,11 +262,13 @@ export const buildModule = (NODE_SIZE = 8) => {
   };
 
   const setValues = (node, values) => {
-    return isFinite(node[0]) ? treeFrom(...values) : values;
+    if (values.length > NODE_SIZE) throw new Error();
+
+    return isFinite(node[0]) || statsReducer ? treeFromValues(values) : freeze(values);
   };
 
   const isLeafNode = (node) => {
-    return isArray(node) && !isFinite(node[0]);
+    return !isArray(getValues(node)[0]);
   };
 
   function* traverse(tree) {
@@ -237,7 +281,7 @@ export const buildModule = (NODE_SIZE = 8) => {
       const { node } = s;
       const isLeaf = isLeafNode(node);
 
-      const values = isLeaf ? node : node[1];
+      const values = getValues(node);
 
       if (isLeaf) {
         for (let i = 0; i < values.length; i++) {
@@ -257,7 +301,9 @@ export const buildModule = (NODE_SIZE = 8) => {
   }
 
   const getSum = (tree) => {
-    if (!isArray(tree)) {
+    if (tree == null) {
+      return 0;
+    } else if (!isArray(tree)) {
       return 1;
     } else if (isFinite(tree[0])) {
       return tree[0];
@@ -274,6 +320,8 @@ export const buildModule = (NODE_SIZE = 8) => {
   }
 
   const findPath = (idx, tree) => {
+    if (idx == null) throw new Error();
+
     let path = emptyStack;
 
     let treeSum = getSum(tree);
@@ -290,7 +338,7 @@ export const buildModule = (NODE_SIZE = 8) => {
         let index = isFinite(currentIdx) ? targetIdx - startIdx : currentIdx;
         if (index < 0) {
           index = -Infinity;
-        } else if (index >= node.length) {
+        } else if (index >= getSum(node)) {
           index = Infinity;
         }
         return path.push({ index, node });
@@ -319,12 +367,18 @@ export const buildModule = (NODE_SIZE = 8) => {
 
   const getAt = (idx, tree) => {
     const v = findPath(idx, tree)?.value;
-    return v && v.node[v.index];
+    return v && getValues(v.node)[v.index];
   };
 
   const replaceAt = (idx, tree, value) => {
     let path = findPath(idx, tree);
 
+    if (getSum(tree) < idx) {
+      throw new Error('Cannot add past the end of a list');
+    } else if (getSum(tree) === idx) {
+      return addAt(idx, tree, value);
+    }
+
     let { node, index } = path.value;
 
     let returnValue = setValuesAt(index, node, value);
@@ -343,41 +397,12 @@ export const buildModule = (NODE_SIZE = 8) => {
     }
   };
 
-  const freeze = (tree) => {
-    let states = emptyStack.push({ node: tree, i: 0 });
-
-    stack: while (states.size) {
-      const s = states.value;
-      const { node } = s;
-      const isLeaf = isLeafNode(node);
-
-      assertValidNode(node);
-
-      freezeObject(node);
-
-      const values = isLeaf ? node : node[1];
-
-      if (!isLeaf) {
-        freezeObject(values);
-
-        for (let { i } = s; s.i < values.length; ) {
-          const node = values[i];
-          assertValidNode(node);
-          states = states.push({ node, i: 0 });
-          i = ++s.i;
-          continue stack;
-        }
-      }
-      states = states.pop();
-    }
-    return tree;
-  };
-
   return {
     buildModule,
     treeFrom,
+    treeFromValues,
     findBalancePoint,
-    split,
+    splitValues,
     collapses,
     nodeCollapses,
     nodeCanDonate,
@@ -394,6 +419,5 @@ export const buildModule = (NODE_SIZE = 8) => {
     findPath,
     getAt,
     replaceAt,
-    freeze,
   };
 };

package/lib/index.js

@@ -1,9 +1,10 @@
 import { buildModule } from './enhanceable.js';
 
 export const {
-  treeFrom,
+  defaultNodeSize,
+  treeFromValues,
   findBalancePoint,
-  split,
+  splitValues,
   collapses,
   nodeCollapses,
   nodeCanDonate,
@@ -20,5 +21,4 @@ export const {
   findPath,
   getAt,
   replaceAt,
-  freeze,
 } = buildModule();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/btree",
   "description": "Functional utilities for working with btrees such as those used in agAST",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,6 +12,9 @@
     "./enhanceable": "./lib/enhanceable.js"
   },
   "sideEffects": false,
+  "scripts": {
+    "test": "mocha test/*.test.js"
+  },
   "dependencies": {
     "@iter-tools/imm-stack": "1.1.0"
   },