@bablr/btree 0.4.0 → 0.4.2

package/README.md

@@ -1,18 +1,19 @@
 # @bablr/btree
 
-Functional utilities for working with btrees such as those used in agAST.
+This library offers a set of functional utilities for working with immutable btrees such as those used in agAST.
 
 ```js
-expect(push(['a', 'b'], 'c')).toEqual([
-  3,
-  [['a'], ['b', 'c']],
-]);
+import * as btree from '@bablr/btree';
 
-expect(addAt(0, [3, [['x'], ['y', 'z']]], 'w')).toEqual([
-  4,
-  [
-    ['w', 'x'],
-    ['y', 'z'],
-  ],
-]);
+let tree = btree.fromValues([]);
+tree = btree.push('a');
+tree = btree.push('b');
+tree = btree.push('c');
+let tree3 = tree;
+tree = btree.concat(tree, tree);
+tree = btree.concat(tree3, tree);
+
+btree.getSize(tree); // 9
+btree.getAt(-2, tree); // 'b'
+[...btree.traverse(tree)]; // ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
 ```

package/lib/enhanceable.js

@@ -1,23 +1,50 @@
-import emptyStack from '@iter-tools/imm-stack';
-
 const { isArray } = Array;
 const { freeze } = Object;
 const { isFinite } = Number;
 
 export const defaultNodeSize = 8;
 
-export const buildModule = (
-  NODE_SIZE = defaultNodeSize,
-  statsReducer,
-  getSumsInitial,
-  finalizeSums,
-) => {
+export const deepFreeze = (object) => {
+  let stack = [object];
+  while (stack.length) {
+    let item = stack[stack.length - 1];
+    stack.pop();
+
+    for (const value of Object.values(item)) {
+      if (value && typeof value === 'object') {
+        if (
+          !(Array.isArray(value) || [Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        )
+          throw new Error();
+        stack.push(value);
+      }
+    }
+
+    Object.freeze(item);
+  }
+  return object;
+};
+
+export const buildModule = (NODE_SIZE = defaultNodeSize, buildStats) => {
   const sumNodes = (nodes) => {
     return nodes.map(getSize).reduce((a, b) => a + b, 0);
   };
 
+  const getHeight = (tree) => {
+    let height = 0;
+    let node = tree;
+
+    while (Array.isArray(node)) {
+      height++;
+      node = getValues(node)[0];
+    }
+
+    return height;
+  };
+
   const treeFrom = (...values) => {
-    if (!statsReducer && values.length <= NODE_SIZE) {
+    validateValues(values);
+    if (!buildStats && values.length <= NODE_SIZE) {
       return freeze(values);
     } else {
       let tree = [];
@@ -28,18 +55,14 @@ export const buildModule = (
     }
   };
 
-  const buildStats = (values) => {
-    let sums = values.reduce(statsReducer, getSumsInitial());
-    finalizeSums(sums);
-    return sums;
-  };
-
   const treeFromValues = (values) => {
-    if (!statsReducer && values.length <= NODE_SIZE) {
+    validateValues(values);
+
+    if (!buildStats && values.length <= NODE_SIZE) {
       return isArray(values[0]) ? freeze([sumNodes(values), freeze(values)]) : freeze(values);
     } else {
       if (values.length <= NODE_SIZE) {
-        if (statsReducer) {
+        if (buildStats) {
           return freeze([sumNodes(values), freeze(values), buildStats(values)]);
         } else {
           return freeze([sumNodes(values), freeze(values)]);
@@ -78,11 +101,11 @@ export const buildModule = (
 
     let midIndex;
 
-    if (isLeaf) {
-      midIndex = Math.floor(values.length / 2 + 0.01);
-    } else {
-      midIndex = findBalancePoint(values);
-    }
+    // if (isLeaf) {
+    midIndex = Math.floor(values.length / 2 + 0.01);
+    // } else {
+    //   midIndex = findBalancePoint(values);
+    // }
 
     let leftValues = values.slice(0, midIndex);
     let rightValues = values.slice(midIndex);
@@ -91,32 +114,81 @@ export const buildModule = (
   };
 
   const setValuesAt = (idx, node, value) => {
-    const isLeaf = isLeafNode(node);
     const values = getValues(node);
 
     if (!Number.isFinite(idx)) throw new Error();
 
-    if (!isLeaf && !isArray(value)) {
+    if (!value == null) {
       throw new Error();
     }
 
-    if (isLeaf && isArray(value) && node.length) throw new Error();
-
     const newValues = values.slice();
     newValues[idx] = value;
     return treeFromValues(newValues);
   };
 
+  const concat = (first, second) => {
+    if (!isArray(first) || !isArray(second)) throw new Error();
+
+    let firstHeight = getHeight(first);
+    let secondHeight = getHeight(second);
+    let firstValues = getValues(first);
+    let secondValues = getValues(second);
+
+    if (!secondValues.length) return first;
+    if (!firstValues.length) return second;
+
+    if (firstHeight === secondHeight) {
+      if (firstValues.length + secondValues.length <= NODE_SIZE) {
+        return treeFromValues([...firstValues, ...secondValues]);
+      } else {
+        let { leftValues, rightValues } = splitValues([...firstValues, ...secondValues]);
+        return treeFromValues([treeFromValues(leftValues), treeFromValues(rightValues)]);
+      }
+    } else {
+      let tree = firstHeight <= secondHeight ? second : first;
+      let pushout = firstHeight > secondHeight ? second : first;
+
+      if (!nodeCollapses(pushout)) {
+        let targetIndex = firstHeight > secondHeight ? getSize(tree) : 0;
+        return addAt(targetIndex, tree, pushout);
+      } else {
+        let depth = Math.abs(firstHeight - secondHeight) - 1;
+        let targetIndex = firstHeight > secondHeight ? getSize(tree) - 1 : 0;
+        let targetPath = findPath(targetIndex, tree, depth);
+        let lastIndex = targetPath.length - 1;
+        let targetNode = getValues(targetPath[lastIndex].node)[targetPath[lastIndex].index];
+        let combinedValues =
+          firstHeight > secondHeight
+            ? [...getValues(targetNode), ...getValues(pushout)]
+            : [...getValues(pushout), ...getValues(targetNode)];
+        if (getValues(pushout).length + getValues(targetNode).length <= NODE_SIZE) {
+          return replaceAt(targetIndex, tree, treeFromValues(combinedValues));
+        } else {
+          let { leftValues, rightValues } = splitValues(combinedValues);
+
+          if (firstHeight > secondHeight) {
+            return replaceAt(targetIndex, addAt(targetIndex + 1, tree, rightValues), leftValues);
+            // return addAt(targetIndex + 1, replaceAt(targetIndex, tree, leftValues), rightValues);
+          } else {
+            // TODO change order of operations like above?
+            return addAt(targetIndex, replaceAt(targetIndex, tree, rightValues), leftValues);
+          }
+        }
+      }
+    }
+  };
+
   const addAt = (idx, tree, value) => {
     if (idx < 0 || !Number.isFinite(idx)) throw new Error('invalid argument');
     if (!isArray(tree)) throw new Error();
-    if (isArray(value)) throw new Error('cannot add arrays to btrees');
+    if (!value) throw new Error();
 
-    let path = findPath(idx, tree);
+    let path = findPath(idx, tree, getHeight(tree) - getHeight(value) - 1);
 
-    let { node, index } = path.value;
+    let pathIdx = path.length - 1;
+    let { node, index } = path[pathIdx];
 
-    // left pushout vs right pushout?
     let pushout = value;
 
     let values = getValues(node);
@@ -128,7 +200,7 @@ export const buildModule = (
         let finiteIndex = index === Infinity ? values.length : index;
 
         if (!isFinite(finiteIndex)) throw new Error();
-        if (values.length + getValues(pushout).length > NODE_SIZE) {
+        if (values.length + (pushout ? 1 : 0) > NODE_SIZE) {
           values.splice(finiteIndex, 0, pushout);
           const { leftValues, rightValues } = splitValues(values);
 
@@ -141,7 +213,7 @@ export const buildModule = (
         }
       }
 
-      if (path.size === 1) {
+      if (pathIdx === 0) {
         if (pushout) {
           return treeFromValues([pushout, node]);
         } else {
@@ -150,21 +222,21 @@ export const buildModule = (
       }
 
       const poppedNode = node;
-      path = path.pop();
-      ({ node, index } = path.value);
+      pathIdx--;
+      ({ node, index } = path[pathIdx]);
 
       node = setValuesAt(index, node, poppedNode);
       values = getValues(node);
-      path = path.replace({ node, index });
     }
   };
 
   const push = (tree, value) => {
-    return addAt(getSize(tree), tree, value);
+    let size = getSize(tree);
+    return size ? addAt(size, tree, value) : treeFromValues([value]);
   };
 
   const collapses = (size) => {
-    return size > NODE_SIZE / 2 + 0.01;
+    return size < NODE_SIZE / 2 - 0.01;
   };
 
   const nodeCollapses = (node) => {
@@ -172,25 +244,29 @@ export const buildModule = (
   };
 
   const nodeCanDonate = (node) => {
-    return collapses(getValues(node).length - 1);
+    return !collapses(getValues(node).length - 1);
   };
 
-  const pop = (tree) => {
-    let path = findPath(-1, tree);
+  const removeAt = (idx, tree) => {
+    if (idx > getSize(tree)) throw new Error('Index exceeds tree bounds');
 
-    let { node, index } = path.value;
+    let path = findPath(idx, tree);
 
-    const initialValues = freeze(getValues(node).slice(0, -1));
-    let returnValue = isLeafNode(node)
-      ? initialValues
-      : freeze([sumNodes(initialValues), initialValues]);
+    let pathIdx = path.length - 1;
+    let { node, index } = path[pathIdx];
+
+    const initialValues = [...getValues(node)];
+
+    initialValues.splice(index, 1);
+
+    let returnValue = !isFinite(node[0]) ? initialValues : treeFromValues(initialValues);
 
     for (;;) {
       let values = getValues(returnValue);
       let adjustSibling = null;
 
-      if (path.size > 1 && nodeCollapses(returnValue)) {
-        let { node: parentNode, index: parentIndex } = path.prev.value;
+      if (pathIdx >= 1 && nodeCollapses(returnValue)) {
+        let { node: parentNode, index: parentIndex } = path[pathIdx - 1];
         const prevSibling = getValues(parentNode)[parentIndex - 1];
         const nextSibling = getValues(parentNode)[parentIndex + 1];
         let targetSibling = nodeCanDonate(prevSibling)
@@ -220,15 +296,12 @@ export const buildModule = (
         }
       }
 
-      if (path.size === 1) {
-        if (isFinite(returnValue[0]) && getSize(returnValue) <= NODE_SIZE) {
-          returnValue = returnValue[1].flat();
-        }
+      if (pathIdx === 0) {
         return returnValue;
       }
 
-      path = path.pop();
-      ({ node, index } = path.value);
+      pathIdx--;
+      ({ node, index } = path[pathIdx]);
 
       values = getValues(node).slice();
 
@@ -247,10 +320,30 @@ export const buildModule = (
     }
   };
 
+  const pop = (tree) => {
+    return removeAt(-1, tree);
+  };
+
+  const validateValues = (values) => {
+    if (values.length > NODE_SIZE) throw new Error();
+    if (!values.length) return;
+
+    let nodeIsLeaf = !isArray(values[0]);
+    for (let value of values) {
+      if (!nodeIsLeaf && nodeCollapses(value)) {
+        throw new Error('invalid btree: uncollapsed node');
+      } else if (!nodeIsLeaf && value == null) {
+        throw new Error('invalid btree: nil sibling');
+      }
+    }
+  };
+
   const isValidNode = (node) => {
     if (!isArray(node)) return false;
     const values = getValues(node);
-    return isArray(values); //  && values.length <= NODE_SIZE;
+    if (!isArray(values) || values.length > NODE_SIZE) return false; //  ;
+
+    return !node[0] || isFinite(node[0]) || ['object', 'string'].includes(typeof node[0]);
   };
 
   const assertValidNode = (node) => {
@@ -264,45 +357,46 @@ export const buildModule = (
 
   const getSums = (node) => {
     if (!isValidNode(node)) throw new Error();
-    return node[2];
+    let sums = Number.isFinite(node[0]) ? node[2] : null;
+    return sums || (buildStats ? buildStats(getValues(node)) : null);
   };
 
   const setValues = (node, values) => {
-    if (values.length > NODE_SIZE) throw new Error();
+    if (isFinite(node[0]) || buildStats) {
+      return treeFromValues(values);
+    }
 
-    return isFinite(node[0]) || statsReducer ? treeFromValues(values) : freeze(values);
-  };
+    validateValues(values);
 
-  const isLeafNode = (node) => {
-    return !isArray(getValues(node)[0]);
+    return freeze(values);
   };
 
   function* traverse(tree) {
-    let states = emptyStack.push({ node: tree, i: 0 });
+    let states = [{ node: tree, i: 0 }];
 
     assertValidNode(tree);
 
-    stack: while (states.size) {
-      const s = states.value;
+    stack: while (states.length) {
+      const s = states[states.length - 1];
       const { node } = s;
-      const isLeaf = isLeafNode(node);
 
       const values = getValues(node);
 
-      if (isLeaf) {
-        for (let i = 0; i < values.length; i++) {
-          yield values[i];
-        }
-      } else {
-        for (let { i } = s; s.i < values.length; ) {
-          const node = values[i];
+      for (let { i } = s; s.i < values.length; ) {
+        const value = values[i];
+        if (isArray(value)) {
+          let node = value;
           assertValidNode(node);
-          states = states.push({ node, i: 0 });
+          states.push({ node, i: 0 });
           i = ++s.i;
           continue stack;
+        } else {
+          yield value;
+          i = ++s.i;
         }
       }
-      states = states.pop();
+
+      states.pop();
     }
   }
 
@@ -318,65 +412,103 @@ export const buildModule = (
     }
   };
 
-  const findPath = (idx, tree) => {
+  const findPath = (idx, tree, depth = Infinity) => {
     if (idx == null) throw new Error();
+    if (tree && !isArray(tree)) throw new Error();
+
+    let path = [];
+    let node = tree;
+
+    if (isArray(idx)) {
+      for (let seg of idx) {
+        let index = typeof seg !== 'object' ? seg : seg.index;
+        if (typeof index === 'string') throw new Error();
+        if (!isArray(node)) return null;
+        let index_ = index < 0 ? getSize(node) + index : index;
+        path.push({ index: index_, node });
+        node = getValues(node)[index_];
+        if (node && !isArray(node)) {
+          return freeze(path);
+        }
+        if (!node) return null;
+      }
 
-    let path = emptyStack;
+      return freeze(path);
+    }
 
     let treeSum = getSize(tree);
-    let currentIdx = idx < 0 ? treeSum : 0;
+    let currentIdx = idx < 0 ? treeSum - 1 : 0;
     let direction = idx < 0 ? -1 : 1;
     let targetIdx = idx < 0 ? treeSum + idx : idx;
 
-    let node = tree;
     stack: while (node) {
       assertValidNode(node);
 
-      if (isLeafNode(node)) {
-        const startIdx = idx < 0 ? currentIdx - getSize(node) : currentIdx;
-        let index = isFinite(currentIdx) ? targetIdx - startIdx : currentIdx;
-        if (index < 0) {
-          index = -Infinity;
-        } else if (index >= getSize(node)) {
-          index = Infinity;
-        }
-        return path.push({ index, node });
-      } else {
-        const values = node[1];
-        let candidateNode;
-        let i;
-
-        let backwards = idx < 0;
-        const increment = backwards ? -1 : 1;
-        for (
-          let i = backwards ? values.length - 1 : 0;
-          backwards ? i >= 0 : i < values.length;
-          i += increment
-        ) {
-          candidateNode = values[i];
+      const values = getValues(node);
+      let candidateNode;
+
+      let backwards = idx < 0;
+      const increment = backwards ? -1 : 1;
+      for (
+        let i = backwards ? values.length - 1 : 0;
+        backwards ? i >= 0 : i < values.length;
+        i += increment
+      ) {
+        let value = values[i];
+        if (isArray(value) && path.length < depth) {
+          candidateNode = value;
+
           const sum = getSize(candidateNode);
-          const nextCount = currentIdx + sum * direction;
-          if (backwards ? nextCount <= targetIdx : nextCount > targetIdx || nextCount >= treeSum) {
-            path = path.push({ index: i, node });
+          const nextIndex = currentIdx + sum * direction;
+          if (
+            (backwards ? nextIndex < targetIdx : nextIndex > targetIdx) ||
+            (backwards ? nextIndex < 0 : nextIndex >= treeSum)
+          ) {
+            path.push({ index: i, node });
             node = candidateNode;
             continue stack;
           } else {
             currentIdx += sum * direction;
           }
+        } else {
+          const sum = getSize(value);
+          const nextIndex = currentIdx + sum * direction;
+          if (!isFinite(targetIdx)) {
+            path.push({ index: targetIdx, node });
+
+            return freeze(path);
+          } else if (backwards ? nextIndex < targetIdx : nextIndex > targetIdx) {
+            path.push({ index: i, node });
+
+            return freeze(path);
+          } else if (
+            backwards
+              ? nextIndex < targetIdx || nextIndex < 0
+              : nextIndex > targetIdx || nextIndex >= treeSum
+          ) {
+            break;
+          } else {
+            currentIdx += direction * sum;
+          }
         }
       }
+
+      path.push({ index: backwards ? -Infinity : Infinity, node });
+
+      return freeze(path);
     }
 
     return null;
   };
 
   const getAt = (idx, tree) => {
-    const v = findPath(idx, tree)?.value;
-    return v && getValues(v.node)[v.index];
+    const path = findPath(idx, tree);
+    let seg = path && path[path.length - 1];
+    return seg && getValues(seg.node)[seg.index];
   };
 
   const replaceAt = (idx, tree, value) => {
-    let path = findPath(idx, tree);
+    let path = findPath(idx, tree, getHeight(tree) - getHeight(value) - 1);
 
     if (getSize(tree) < idx) {
       throw new Error('Cannot add past the end of a list');
@@ -384,16 +516,17 @@ export const buildModule = (
       return addAt(idx, tree, value);
     }
 
-    let { node, index } = path.value;
+    let pathIndex = path.length - 1;
+    let { node, index } = path[pathIndex];
 
     let returnValue = setValuesAt(index, node, value);
 
     for (;;) {
-      ({ node, index } = path.value);
+      ({ node, index } = path[pathIndex]);
 
-      if (path.size > 1) {
-        path = path.pop();
-        ({ node, index } = path.value);
+      if (pathIndex > 0) {
+        pathIndex--;
+        ({ node, index } = path[pathIndex]);
 
         returnValue = setValuesAt(index, node, returnValue);
       } else {
@@ -414,14 +547,15 @@ export const buildModule = (
     nodeCollapses,
     nodeCanDonate,
     pop,
+    removeAt,
     push,
     addAt,
+    concat,
     isValidNode,
     assertValidNode,
     getValues,
     getSums,
     setValues,
-    isLeafNode,
     traverse,
     getSize,
     findPath,

package/lib/index.js

@@ -1,6 +1,6 @@
-import { defaultNodeSize, buildModule } from './enhanceable.js';
+import { defaultNodeSize, deepFreeze, buildModule } from './enhanceable.js';
 
-export { defaultNodeSize };
+export { defaultNodeSize, deepFreeze };
 
 export const {
   btreeFrom,
@@ -14,13 +14,13 @@ export const {
   nodeCanDonate,
   pop,
   push,
+  concat,
   addAt,
   isValidNode,
   assertValidNode,
   getValues,
   getSums,
   setValues,
-  isLeafNode,
   traverse,
   getSize,
   findPath,

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.4.0",
+  "version": "0.4.2",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -15,9 +15,7 @@
   "scripts": {
     "test": "mocha test/*.test.js"
   },
-  "dependencies": {
-    "@iter-tools/imm-stack": "1.1.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c97bfa4b3663f8378e9b3e42bb5a41e685406cf9",
     "enhanced-resolve": "^5.12.0",
@@ -29,7 +27,10 @@
     "mocha": "10.7.3",
     "prettier": "^2.6.2"
   },
-  "repository": "github:bablr-lang/btree",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bablr-lang/btree.git"
+  },
   "homepage": "https://github.com/bablr-lang/btree",
   "license": "MIT"
 }