@calcit/ternary-tree 0.0.24 → 0.0.25

package/lib/list.mjs

@@ -41,7 +41,7 @@ export function makeTernaryTreeList(size, offset, xs) {
             let middle = xs[offset + 1];
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
-                size: listLen(left) + listLen(middle),
+                size: left.size + middle.size,
                 left: left,
                 middle: middle,
                 right: emptyBranch,
@@ -56,7 +56,7 @@ export function makeTernaryTreeList(size, offset, xs) {
             let right = xs[offset + 2];
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
-                size: listLen(left) + listLen(middle) + listLen(right),
+                size: left.size + middle.size + right.size,
                 left: left,
                 middle: middle,
                 right: right,
@@ -72,7 +72,7 @@ export function makeTernaryTreeList(size, offset, xs) {
             let right = makeTernaryTreeList(divided.right, offset + divided.left + divided.middle, xs);
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
-                size: listLen(left) + listLen(middle) + listLen(right),
+                size: left.size + middle.size + right.size,
                 depth: decideParentDepth(left, middle, right),
                 left: left,
                 middle: middle,
@@ -84,22 +84,22 @@ export function makeTernaryTreeList(size, offset, xs) {
     }
 }
 export function initTernaryTreeList(xs) {
-    let ys = new Array(xs.length);
-    let size = xs.length;
+    const size = xs.length;
+    let ys = new Array(size);
+    // Use cached size instead of accessing xs.length repeatedly
     for (let idx = 0; idx < size; idx++) {
-        let x = xs[idx];
-        ys[idx] = { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: x };
+        ys[idx] = { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: xs[idx] };
     }
-    return makeTernaryTreeList(xs.length, 0, ys);
+    return makeTernaryTreeList(size, 0, ys);
 }
 // from a slice of an existed array
 export function initTernaryTreeListFromRange(xs, from, to) {
-    let ys = new Array(to - from);
-    for (let idx = from; idx < to; idx++) {
-        let x = xs[idx];
-        ys[idx - from] = { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: x };
+    const length = to - from;
+    let ys = new Array(length);
+    for (let idx = 0; idx < length; idx++) {
+        ys[idx] = { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: xs[idx + from] };
     }
-    return makeTernaryTreeList(ys.length, 0, ys);
+    return makeTernaryTreeList(length, 0, ys);
 }
 export function initEmptyTernaryTreeList() {
     return { kind: TernaryTreeKind.ternaryTreeBranch, size: 0, depth: 1, middle: emptyBranch, left: emptyBranch, right: emptyBranch };
@@ -141,18 +141,22 @@ export function* listToItems(tree) {
                 break;
             }
             case TernaryTreeKind.ternaryTreeBranch: {
-                if (tree.left != null) {
-                    for (let x of listToItems(tree.left)) {
+                // Cache children to avoid repeated property access
+                const left = tree.left;
+                const middle = tree.middle;
+                const right = tree.right;
+                if (left != null) {
+                    for (let x of listToItems(left)) {
                         yield x;
                     }
                 }
-                if (tree.middle != null) {
-                    for (let x of listToItems(tree.middle)) {
+                if (middle != null) {
+                    for (let x of listToItems(middle)) {
                         yield x;
                     }
                 }
-                if (tree.right != null) {
-                    for (let x of listToItems(tree.right)) {
+                if (right != null) {
+                    for (let x of listToItems(right)) {
                         yield x;
                     }
                 }
@@ -176,17 +180,21 @@ export function findIndex(tree, f) {
             }
         }
         case TernaryTreeKind.ternaryTreeBranch: {
-            let tryLeft = findIndex(tree.left, f);
+            // Cache children to avoid repeated property access
+            const left = tree.left;
+            const middle = tree.middle;
+            const right = tree.right;
+            let tryLeft = findIndex(left, f);
             if (tryLeft >= 0) {
                 return tryLeft;
             }
-            let tryMiddle = findIndex(tree.middle, f);
+            let tryMiddle = findIndex(middle, f);
             if (tryMiddle >= 0) {
-                return tryMiddle + listLen(tree.left);
+                return tryMiddle + (left == null ? 0 : left.size);
             }
-            let tryRight = findIndex(tree.right, f);
+            let tryRight = findIndex(right, f);
             if (tryRight >= 0) {
-                return tryRight + listLen(tree.left) + listLen(tree.middle);
+                return tryRight + (left == null ? 0 : left.size) + (middle == null ? 0 : middle.size);
             }
             return -1;
         }
@@ -205,17 +213,21 @@ export function indexOf(tree, item) {
         default:
             return -1;
         case TernaryTreeKind.ternaryTreeBranch:
-            let tryLeft = indexOf(tree.left, item);
+            // Cache children to avoid repeated property access
+            const left = tree.left;
+            const middle = tree.middle;
+            const right = tree.right;
+            let tryLeft = indexOf(left, item);
             if (tryLeft >= 0) {
                 return tryLeft;
             }
-            let tryMiddle = indexOf(tree.middle, item);
+            let tryMiddle = indexOf(middle, item);
             if (tryMiddle >= 0) {
-                return tryMiddle + listLen(tree.left);
+                return tryMiddle + (left == null ? 0 : left.size);
             }
-            let tryRight = indexOf(tree.right, item);
+            let tryRight = indexOf(right, item);
             if (tryRight >= 0) {
-                return tryRight + listLen(tree.left) + listLen(tree.middle);
+                return tryRight + (left == null ? 0 : left.size) + (middle == null ? 0 : middle.size);
             }
             return -1;
     }
@@ -227,25 +239,28 @@ function writeLeavesArray(tree, acc, idx) {
     else {
         switch (tree.kind) {
             case TernaryTreeKind.ternaryTreeLeaf: {
-                acc[idx.value] = tree;
-                idx.value = idx.value + 1;
+                // Cache current index to reduce property access
+                const currentIdx = idx.value;
+                acc[currentIdx] = tree;
+                idx.value = currentIdx + 1;
                 break;
             }
             case TernaryTreeKind.ternaryTreeBranch: {
-                if (tree.left != null) {
-                    writeLeavesArray(tree.left, acc, idx);
+                // Cache children to avoid repeated property access
+                const left = tree.left;
+                const middle = tree.middle;
+                const right = tree.right;
+                if (left != null) {
+                    writeLeavesArray(left, acc, idx);
                 }
-                if (tree.middle != null) {
-                    writeLeavesArray(tree.middle, acc, idx);
+                if (middle != null) {
+                    writeLeavesArray(middle, acc, idx);
                 }
-                if (tree.right != null) {
-                    writeLeavesArray(tree.right, acc, idx);
+                if (right != null) {
+                    writeLeavesArray(right, acc, idx);
                 }
                 break;
             }
-            default: {
-                throw new Error("Unknown");
-            }
         }
     }
 }
@@ -285,17 +300,21 @@ export function listGet(originalTree, originalIdx) {
         if (idx > tree.size - 1) {
             throw new Error("Index too large");
         }
-        let leftSize = tree.left == null ? 0 : tree.left.size;
-        let middleSize = tree.middle == null ? 0 : tree.middle.size;
-        let rightSize = tree.right == null ? 0 : tree.right.size;
+        // Cache child sizes to avoid repeated property access
+        const left = tree.left;
+        const middle = tree.middle;
+        const right = tree.right;
+        const leftSize = left == null ? 0 : left.size;
+        const middleSize = middle == null ? 0 : middle.size;
+        const rightSize = right == null ? 0 : right.size;
         if (leftSize + middleSize + rightSize !== tree.size) {
             throw new Error("tree.size does not match sum case branch sizes");
         }
         if (idx <= leftSize - 1) {
-            tree = tree.left;
+            tree = left;
         }
         else if (idx <= leftSize + middleSize - 1) {
-            tree = tree.middle;
+            tree = middle;
             idx = idx - leftSize;
         }
         else {
@@ -336,45 +355,49 @@ export function assocList(tree, idx, item) {
             throw new Error(`Cannot get from leaf with index ${idx}`);
         }
     }
-    let leftSize = listLen(tree.left);
-    let middleSize = listLen(tree.middle);
-    let rightSize = listLen(tree.right);
+    // Cache children and their sizes to avoid repeated property access
+    const left = tree.left;
+    const middle = tree.middle;
+    const right = tree.right;
+    const leftSize = left == null ? 0 : left.size;
+    const middleSize = middle == null ? 0 : middle.size;
+    const rightSize = right == null ? 0 : right.size;
     if (leftSize + middleSize + rightSize !== tree.size)
         throw new Error("tree.size does not match sum case branch sizes");
     if (idx <= leftSize - 1) {
-        let changedBranch = assocList(tree.left, idx, item);
+        let changedBranch = assocList(left, idx, item);
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size,
-            depth: decideParentDepth(changedBranch, tree.middle, tree.right),
+            depth: decideParentDepth(changedBranch, middle, right),
             left: changedBranch,
-            middle: tree.middle,
-            right: tree.right,
+            middle: middle,
+            right: right,
         };
         checkListStructure(result);
         return result;
     }
     else if (idx <= leftSize + middleSize - 1) {
-        let changedBranch = assocList(tree.middle, idx - leftSize, item);
+        let changedBranch = assocList(middle, idx - leftSize, item);
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size,
-            depth: decideParentDepth(tree.left, changedBranch, tree.right),
-            left: tree.left,
+            depth: decideParentDepth(left, changedBranch, right),
+            left: left,
             middle: changedBranch,
-            right: tree.right,
+            right: right,
         };
         checkListStructure(result);
         return result;
     }
     else {
-        let changedBranch = assocList(tree.right, idx - leftSize - middleSize, item);
+        let changedBranch = assocList(right, idx - leftSize - middleSize, item);
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size,
-            depth: decideParentDepth(tree.left, tree.middle, changedBranch),
-            left: tree.left,
-            middle: tree.middle,
+            depth: decideParentDepth(left, middle, changedBranch),
+            left: left,
+            middle: middle,
             right: changedBranch,
         };
         checkListStructure(result);
@@ -400,22 +423,26 @@ export function dissocList(tree, idx) {
     if (tree.kind === TernaryTreeKind.ternaryTreeLeaf) {
         throw new Error("dissoc should be handled at branches");
     }
-    let leftSize = listLen(tree.left);
-    let middleSize = listLen(tree.middle);
-    let rightSize = listLen(tree.right);
+    // Cache children and their sizes to avoid repeated property access
+    const left = tree.left;
+    const middle = tree.middle;
+    const right = tree.right;
+    const leftSize = left == null ? 0 : left.size;
+    const middleSize = middle == null ? 0 : middle.size;
+    const rightSize = right == null ? 0 : right.size;
     if (leftSize + middleSize + rightSize !== tree.size) {
         throw new Error("tree.size does not match sum from branch sizes");
     }
     let result = emptyBranch;
     if (idx <= leftSize - 1) {
-        let changedBranch = dissocList(tree.left, idx);
+        let changedBranch = dissocList(left, idx);
         if (changedBranch == null || changedBranch.size === 0) {
             result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size - 1,
-                depth: decideParentDepth(tree.middle, tree.right),
-                left: tree.middle,
-                middle: tree.right,
+                depth: decideParentDepth(middle, right),
+                left: middle,
+                middle: right,
                 right: emptyBranch,
             };
         }
@@ -423,22 +450,22 @@ export function dissocList(tree, idx) {
             result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size - 1,
-                depth: decideParentDepth(changedBranch, tree.middle, tree.right),
+                depth: decideParentDepth(changedBranch, middle, right),
                 left: changedBranch,
-                middle: tree.middle,
-                right: tree.right,
+                middle: middle,
+                right: right,
             };
         }
     }
     else if (idx <= leftSize + middleSize - 1) {
-        let changedBranch = dissocList(tree.middle, idx - leftSize);
+        let changedBranch = dissocList(middle, idx - leftSize);
         if (changedBranch == null || changedBranch.size === 0) {
             result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size - 1,
-                depth: decideParentDepth(tree.left, changedBranch, tree.right),
-                left: tree.left,
-                middle: tree.right,
+                depth: decideParentDepth(left, changedBranch, right),
+                left: left,
+                middle: right,
                 right: emptyBranch,
             };
         }
@@ -446,24 +473,24 @@ export function dissocList(tree, idx) {
             result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size - 1,
-                depth: decideParentDepth(tree.left, changedBranch, tree.right),
-                left: tree.left,
+                depth: decideParentDepth(left, changedBranch, right),
+                left: left,
                 middle: changedBranch,
-                right: tree.right,
+                right: right,
             };
         }
     }
     else {
-        let changedBranch = dissocList(tree.right, idx - leftSize - middleSize);
+        let changedBranch = dissocList(right, idx - leftSize - middleSize);
         if (changedBranch == null || changedBranch.size === 0) {
             changedBranch = emptyBranch;
         }
         result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size - 1,
-            depth: decideParentDepth(tree.left, tree.middle, changedBranch),
-            left: tree.left,
-            middle: tree.middle,
+            depth: decideParentDepth(left, middle, changedBranch),
+            left: left,
+            middle: middle,
             right: changedBranch,
         };
     }
@@ -612,15 +639,19 @@ export function insert(tree, idx, item, after = false) {
             }
         }
     }
-    let leftSize = listLen(tree.left);
-    let middleSize = listLen(tree.middle);
-    let rightSize = listLen(tree.right);
+    // Cache children and their sizes to avoid repeated property access
+    const left = tree.left;
+    const middle = tree.middle;
+    const right = tree.right;
+    const leftSize = left == null ? 0 : left.size;
+    const middleSize = middle == null ? 0 : middle.size;
+    const rightSize = right == null ? 0 : right.size;
     if (leftSize + middleSize + rightSize !== tree.size) {
         throw new Error("tree.size does not match sum case branch sizes");
     }
     // echo "picking: ", idx, " ", leftSize, " ", middleSize, " ", rightSize
     if (idx === 0 && !after) {
-        if (listLen(tree.left) >= listLen(tree.middle) && listLen(tree.left) >= listLen(tree.right)) {
+        if (leftSize >= middleSize && leftSize >= rightSize) {
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size + 1,
@@ -634,7 +665,7 @@ export function insert(tree, idx, item, after = false) {
         }
     }
     if (idx === listLen(tree) - 1 && after) {
-        if (listLen(tree.right) >= listLen(tree.middle) && listLen(tree.right) >= listLen(tree.left)) {
+        if (rightSize >= middleSize && rightSize >= leftSize) {
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size + 1,
@@ -665,46 +696,46 @@ export function insert(tree, idx, item, after = false) {
             size: tree.size + 1,
             depth: tree.depth,
             left: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
-            middle: tree.left,
-            right: tree.middle,
+            middle: left,
+            right: middle,
         };
         checkListStructure(result);
         return result;
     }
     if (idx <= leftSize - 1) {
-        let changedBranch = insert(tree.left, idx, item, after);
+        let changedBranch = insert(left, idx, item, after);
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size + 1,
-            depth: decideParentDepth(changedBranch, tree.middle, tree.right),
+            depth: decideParentDepth(changedBranch, middle, right),
             left: changedBranch,
-            middle: tree.middle,
-            right: tree.right,
+            middle: middle,
+            right: right,
         };
         checkListStructure(result);
         return result;
     }
     else if (idx <= leftSize + middleSize - 1) {
-        let changedBranch = insert(tree.middle, idx - leftSize, item, after);
+        let changedBranch = insert(middle, idx - leftSize, item, after);
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size + 1,
-            depth: decideParentDepth(tree.left, changedBranch, tree.right),
-            left: tree.left,
+            depth: decideParentDepth(left, changedBranch, right),
+            left: left,
             middle: changedBranch,
-            right: tree.right,
+            right: right,
         };
         checkListStructure(result);
         return result;
     }
     else {
-        let changedBranch = insert(tree.right, idx - leftSize - middleSize, item, after);
+        let changedBranch = insert(right, idx - leftSize - middleSize, item, after);
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size + 1,
-            depth: decideParentDepth(tree.left, tree.middle, changedBranch),
-            left: tree.left,
-            middle: tree.middle,
+            depth: decideParentDepth(left, middle, changedBranch),
+            left: left,
+            middle: middle,
             right: changedBranch,
         };
         checkListStructure(result);
@@ -902,22 +933,29 @@ export function checkListStructure(tree) {
                 if (tree.size >= 6 && tree.depth >= tree.size) {
                     throw new Error(`Bad depth at branch ${formatListInline(tree)}`);
                 }
-                if (tree.size !== listLen(tree.left) + listLen(tree.middle) + listLen(tree.right)) {
+                // Cache children and their sizes to avoid repeated property access
+                const left = tree.left;
+                const middle = tree.middle;
+                const right = tree.right;
+                const leftSize = left == null ? 0 : left.size;
+                const middleSize = middle == null ? 0 : middle.size;
+                const rightSize = right == null ? 0 : right.size;
+                if (tree.size !== leftSize + middleSize + rightSize) {
                     throw new Error(`Bad size at branch ${formatListInline(tree)}`);
                 }
-                if (tree.left == null && tree.middle != null) {
+                if (left == null && middle != null) {
                     throw new Error("morformed tree");
                 }
-                if (tree.middle == null && tree.right != null) {
+                if (middle == null && right != null) {
                     throw new Error("morformed tree");
                 }
-                if (tree.depth !== decideParentDepth(tree.left, tree.middle, tree.right)) {
-                    let x = decideParentDepth(tree.left, tree.middle, tree.right);
+                if (tree.depth !== decideParentDepth(left, middle, right)) {
+                    let x = decideParentDepth(left, middle, right);
                     throw new Error(`Bad depth at branch ${formatListInline(tree)}`);
                 }
-                checkListStructure(tree.left);
-                checkListStructure(tree.middle);
-                checkListStructure(tree.right);
+                checkListStructure(left);
+                checkListStructure(middle);
+                checkListStructure(right);
                 break;
             }
         }
@@ -949,34 +987,38 @@ export function slice(tree, startIdx, endIdx) {
     if (startIdx === 0 && endIdx === listLen(tree)) {
         return tree;
     }
-    let leftSize = listLen(tree.left);
-    let middleSize = listLen(tree.middle);
-    let rightSize = listLen(tree.right);
+    // Cache children and their sizes to avoid repeated property access
+    const left = tree.left;
+    const middle = tree.middle;
+    const right = tree.right;
+    const leftSize = left == null ? 0 : left.size;
+    const middleSize = middle == null ? 0 : middle.size;
+    const rightSize = right == null ? 0 : right.size;
     // echo "sizes: {leftSize} {middleSize} {rightSize}"
     if (startIdx >= leftSize + middleSize) {
-        return slice(tree.right, startIdx - leftSize - middleSize, endIdx - leftSize - middleSize);
+        return slice(right, startIdx - leftSize - middleSize, endIdx - leftSize - middleSize);
     }
     if (startIdx >= leftSize)
         if (endIdx <= leftSize + middleSize) {
-            return slice(tree.middle, startIdx - leftSize, endIdx - leftSize);
+            return slice(middle, startIdx - leftSize, endIdx - leftSize);
         }
         else {
-            let middleCut = slice(tree.middle, startIdx - leftSize, middleSize);
-            let rightCut = slice(tree.right, 0, endIdx - leftSize - middleSize);
+            let middleCut = slice(middle, startIdx - leftSize, middleSize);
+            let rightCut = slice(right, 0, endIdx - leftSize - middleSize);
             return concat(middleCut, rightCut);
         }
     if (endIdx <= leftSize) {
-        return slice(tree.left, startIdx, endIdx);
+        return slice(left, startIdx, endIdx);
     }
     if (endIdx <= leftSize + middleSize) {
-        let leftCut = slice(tree.left, startIdx, leftSize);
-        let middleCut = slice(tree.middle, 0, endIdx - leftSize);
+        let leftCut = slice(left, startIdx, leftSize);
+        let middleCut = slice(middle, 0, endIdx - leftSize);
         return concat(leftCut, middleCut);
     }
     if (endIdx <= leftSize + middleSize + rightSize) {
-        let leftCut = slice(tree.left, startIdx, leftSize);
-        let rightCut = slice(tree.right, 0, endIdx - leftSize - middleSize);
-        return concat(concat(leftCut, tree.middle), rightCut);
+        let leftCut = slice(left, startIdx, leftSize);
+        let rightCut = slice(right, 0, endIdx - leftSize - middleSize);
+        return concat(concat(leftCut, middle), rightCut);
     }
     throw new Error("Unknown");
 }
@@ -1019,13 +1061,17 @@ export function listMapValues(tree, f) {
             return result;
         }
         case TernaryTreeKind.ternaryTreeBranch: {
+            // Cache children to avoid repeated property access
+            const left = tree.left;
+            const middle = tree.middle;
+            const right = tree.right;
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size,
                 depth: tree.depth,
-                left: tree.left == null ? emptyBranch : listMapValues(tree.left, f),
-                middle: tree.middle == null ? emptyBranch : listMapValues(tree.middle, f),
-                right: tree.right == null ? emptyBranch : listMapValues(tree.right, f),
+                left: left == null ? emptyBranch : listMapValues(left, f),
+                middle: middle == null ? emptyBranch : listMapValues(middle, f),
+                right: right == null ? emptyBranch : listMapValues(right, f),
             };
             return result;
         }