@calcit/ternary-tree 0.0.24 → 0.0.26

package/lib/list.mjs

@@ -1,5 +1,11 @@
 import { TernaryTreeKind } from "./types.mjs";
-import { dataEqual, divideTernarySizes, roughIntPow } from "./utils.mjs";
+import { dataEqual, roughIntPow } from "./utils.mjs";
+// When false (default), internal structure checks are skipped for performance.
+// Set to true in development/testing to catch structural bugs early.
+let _devMode = false;
+export function enableStructureCheck(enabled = true) {
+    _devMode = enabled;
+}
 // just get, will not compute recursively
 export function getDepth(tree) {
     if (tree == null)
@@ -18,16 +24,18 @@ let isEmptyBranch = (x) => {
     }
     return x.size == 0;
 };
-function decideParentDepth(...xs) {
-    let depth = 0;
-    for (let i = 0; i < xs.length; i++) {
-        let x = xs[i];
-        let y = getDepth(x);
-        if (y > depth) {
-            depth = y;
-        }
-    }
-    return depth + 1;
+// Explicit 2/3-arg versions avoid rest-parameter array allocation on every call.
+// Inlining getDepth avoids indirect function calls in V8's lower JIT tiers.
+function decideParentDepth(a, b, c) {
+    let da = a == null ? 0 : a.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : a.depth;
+    let db = b == null ? 0 : b.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : b.depth;
+    let d = da > db ? da : db;
+    if (c != null) {
+        let dc = c.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : c.depth;
+        if (dc > d)
+            d = dc;
+    }
+    return d + 1;
 }
 export function makeTernaryTreeList(size, offset, xs) {
     switch (size) {
@@ -41,13 +49,14 @@ 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,
                 depth: decideParentDepth(left, middle),
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         case 3: {
@@ -56,50 +65,57 @@ 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,
                 depth: decideParentDepth(left, middle, right),
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         default: {
-            let divided = divideTernarySizes(size);
-            let left = makeTernaryTreeList(divided.left, offset, xs);
-            let middle = makeTernaryTreeList(divided.middle, offset + divided.left, xs);
-            let right = makeTernaryTreeList(divided.right, offset + divided.left + divided.middle, xs);
+            // Inline divideTernarySizes to avoid heap object allocation per recursive call
+            let extra = size % 3;
+            let groupSize = (size / 3) | 0;
+            let leftSize = groupSize + (extra === 2 ? 1 : 0);
+            let middleSize = groupSize + (extra === 1 ? 1 : 0);
+            let rightSize = groupSize + (extra === 2 ? 1 : 0);
+            let left = makeTernaryTreeList(leftSize, offset, xs);
+            let middle = makeTernaryTreeList(middleSize, offset + leftSize, xs);
+            let right = makeTernaryTreeList(rightSize, offset + leftSize + middleSize, 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,
                 right: right,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
 }
 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 };
@@ -134,30 +150,26 @@ export function formatListInline(tree) {
     }
 }
 export function* listToItems(tree) {
-    if (tree != null) {
-        switch (tree.kind) {
-            case TernaryTreeKind.ternaryTreeLeaf: {
-                yield tree.value;
-                break;
-            }
-            case TernaryTreeKind.ternaryTreeBranch: {
-                if (tree.left != null) {
-                    for (let x of listToItems(tree.left)) {
-                        yield x;
-                    }
-                }
-                if (tree.middle != null) {
-                    for (let x of listToItems(tree.middle)) {
-                        yield x;
-                    }
-                }
-                if (tree.right != null) {
-                    for (let x of listToItems(tree.right)) {
-                        yield x;
-                    }
-                }
-                break;
-            }
+    if (tree == null)
+        return;
+    // Iterative pre-order traversal using an explicit stack — avoids
+    // O(n) nested generator delegation overhead of the recursive version.
+    let stack = [tree];
+    while (stack.length > 0) {
+        let node = stack.pop();
+        if (node == null || node.size === 0)
+            continue;
+        if (node.kind === TernaryTreeKind.ternaryTreeLeaf) {
+            yield node.value;
+        }
+        else {
+            // Push right first so left is popped (processed) first (LIFO order).
+            if (node.right != null && node.right.size > 0)
+                stack.push(node.right);
+            if (node.middle != null && node.middle.size > 0)
+                stack.push(node.middle);
+            if (node.left != null && node.left.size > 0)
+                stack.push(node.left);
         }
     }
 }
@@ -176,17 +188,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 +221,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 +247,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 +308,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;
-        if (leftSize + middleSize + rightSize !== tree.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 (_devMode && 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,48 +363,55 @@ 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);
-    if (leftSize + middleSize + rightSize !== tree.size)
+    // 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 (_devMode && 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);
+        if (_devMode)
+            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);
+        if (_devMode)
+            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);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
 }
@@ -400,22 +434,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);
-    if (leftSize + middleSize + rightSize !== tree.size) {
+    // 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 (_devMode && 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 +461,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, right, emptyBranch),
+                left: left,
+                middle: right,
                 right: emptyBranch,
             };
         }
@@ -446,31 +484,32 @@ 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,
         };
     }
     if (result.middle == null) {
         return result.left;
     }
-    checkListStructure(result);
+    if (_devMode)
+        checkListStructure(result);
     return result;
 }
 export function rest(tree) {
@@ -508,7 +547,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         else {
@@ -520,11 +560,13 @@ export function insert(tree, idx, item, after = false) {
                 middle: tree,
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
-    checkListStructure(tree);
+    if (_devMode)
+        checkListStructure(tree);
     if (listLen(tree) === 1) {
         if (after) {
             // in compact mode, values placed at left
@@ -536,7 +578,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         else {
@@ -548,7 +591,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: tree.left,
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
@@ -563,7 +607,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                     right: tree.middle,
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             if (idx === 1) {
@@ -575,7 +620,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: tree.middle,
                     right: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             else {
@@ -592,7 +638,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: tree.left,
                     right: tree.middle,
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             else if (idx === 1) {
@@ -604,7 +651,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                     right: tree.middle,
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             else {
@@ -612,15 +660,19 @@ export function insert(tree, idx, item, after = false) {
             }
         }
     }
-    let leftSize = listLen(tree.left);
-    let middleSize = listLen(tree.middle);
-    let rightSize = listLen(tree.right);
-    if (leftSize + middleSize + rightSize !== tree.size) {
+    // 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 (_devMode && 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,
@@ -629,12 +681,13 @@ export function insert(tree, idx, item, after = false) {
                 middle: tree,
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
     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,
@@ -643,7 +696,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
@@ -656,58 +710,63 @@ export function insert(tree, idx, item, after = false) {
             middle: tree.middle,
             right: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
-    if (!after && idx === 0 && rightSize === 0 && middleSize >= rightSize) {
+    if (!after && idx === 0 && rightSize === 0 && middleSize >= leftSize) {
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             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);
+        if (_devMode)
+            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);
+        if (_devMode)
+            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);
+        if (_devMode)
+            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);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
 }
@@ -775,7 +834,8 @@ export function concat(...xsGroups) {
     }
     let result = makeTernaryTreeList(xsGroups.length, 0, xsGroups);
     maybeReblance(result);
-    checkListStructure(result);
+    if (_devMode)
+        checkListStructure(result);
     return result;
 }
 export function concat2(left, middle) {
@@ -813,7 +873,8 @@ export function concat2(left, middle) {
         middle: middle,
         right: emptyBranch,
     };
-    checkListStructure(ret);
+    if (_devMode)
+        checkListStructure(ret);
     return ret;
 }
 export function concat3(left, middle, right) {
@@ -825,7 +886,8 @@ export function concat3(left, middle, right) {
         middle,
         right,
     };
-    checkListStructure(ret);
+    if (_devMode)
+        checkListStructure(ret);
     return ret;
 }
 export function sameListShape(xs, ys) {
@@ -902,22 +964,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 +1018,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 +1092,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;
         }