@fncts/base 0.0.1

package/_src/collection/immutable/SortedMap/internal.ts

@@ -0,0 +1,358 @@
+import type { RBNode } from "@fncts/base/collection/immutable/SortedMap/node";
+import type { Ordering } from "@fncts/base/typeclass";
+
+import { Color, Leaf, Node } from "@fncts/base/collection/immutable/SortedMap/node";
+
+export function swapNode<K, V>(node: Node<K, V>, v: Node<K, V>): void {
+  node.key   = v.key;
+  node.value = v.value;
+  node.left  = v.left;
+  node.right = v.right;
+  node.color = v.color;
+  node.count = v.count;
+}
+
+export function isEmptyNode<K, V>(node: RBNode<K, V>): node is Leaf {
+  return node === null;
+}
+
+function repaintNode<K, V>(n: RBNode<K, V>, c: Color): RBNode<K, V> {
+  return n === Leaf ? Leaf : new Node(c, n.left, n.key, n.value, n.right, n.count);
+}
+
+function cloneNode<K, V>(n: RBNode<K, V>): RBNode<K, V> {
+  return n === Leaf ? Leaf : new Node(n.color, n.left, n.key, n.value, n.right, n.count);
+}
+
+function recountNode<K, V>(n: Node<K, V>): void {
+  n.count = 1 + (n.left ? n.left.count : 0) + (n.right ? n.right.count : 0);
+}
+
+export function rebuildModifiedPath<K, V>(nodeStack: Array<Node<K, V>>, orderStack: Array<Ordering>, inc = 1): void {
+  for (let s = nodeStack.length - 2; s >= 0; --s) {
+    const n = nodeStack[s]!;
+    if (orderStack[s]! <= 0) {
+      nodeStack[s] = new Node(n.color, nodeStack[s + 1]!, n.key, n.value, n.right, n.count + inc);
+    } else {
+      nodeStack[s] = new Node(n.color, n.left, n.key, n.value, nodeStack[s + 1]!, n.count + inc);
+    }
+  }
+}
+
+export function balanceModifiedPath<K, V>(nodeStack: Array<Node<K, V>>): void {
+  for (let s = nodeStack.length - 1; s > 1; --s) {
+    const parent = nodeStack[s - 1]!;
+    const node   = nodeStack[s]!;
+    if (parent.color === Color.B || node.color === Color.B) {
+      break;
+    }
+    const gparent = nodeStack[s - 2]!;
+    if (gparent.left === parent) {
+      if (parent.left === node) {
+        const parsib = gparent.right;
+        if (parsib && parsib.color === Color.R) {
+          parent.color  = Color.B;
+          gparent.right = repaintNode(parsib, Color.B);
+          gparent.color = Color.R;
+          s            -= 1;
+        } else {
+          gparent.color    = Color.R;
+          gparent.left     = parent.right;
+          parent.color     = Color.B;
+          parent.right     = gparent;
+          nodeStack[s - 2] = parent;
+          nodeStack[s - 1] = node;
+          recountNode(gparent);
+          recountNode(parent);
+          if (s >= 3) {
+            const ggparent = nodeStack[s - 3]!;
+            if (ggparent.left === gparent) {
+              ggparent.left = parent;
+            } else {
+              ggparent.right = parent;
+            }
+          }
+          break;
+        }
+      } else {
+        const uncle = gparent.right;
+        if (uncle && uncle.color === Color.R) {
+          parent.color  = Color.B;
+          gparent.right = repaintNode(uncle, Color.B);
+          gparent.color = Color.R;
+          s            -= 1;
+        } else {
+          parent.right     = node.left;
+          gparent.color    = Color.R;
+          gparent.left     = node.right;
+          node.color       = Color.B;
+          node.left        = parent;
+          node.right       = gparent;
+          nodeStack[s - 2] = node;
+          nodeStack[s - 1] = parent;
+          recountNode(gparent);
+          recountNode(parent);
+          recountNode(node);
+          if (s >= 3) {
+            const ggparent = nodeStack[s - 3]!;
+            if (ggparent.left === gparent) {
+              ggparent.left = node;
+            } else {
+              ggparent.right = node;
+            }
+          }
+          break;
+        }
+      }
+    } else {
+      if (parent.right === node) {
+        const parsib = gparent.left;
+        if (parsib && parsib.color === Color.R) {
+          parent.color  = Color.B;
+          gparent.left  = repaintNode(parsib, Color.B);
+          gparent.color = Color.R;
+          s            -= 1;
+        } else {
+          gparent.color    = Color.R;
+          gparent.right    = parent.left;
+          parent.color     = Color.B;
+          parent.left      = gparent;
+          nodeStack[s - 2] = parent;
+          nodeStack[s - 1] = node;
+          recountNode(gparent);
+          recountNode(parent);
+          if (s >= 3) {
+            const ggparent = nodeStack[s - 3]!;
+            if (ggparent.right === gparent) {
+              ggparent.right = parent;
+            } else {
+              ggparent.left = parent;
+            }
+          }
+          break;
+        }
+      } else {
+        const parsib = gparent.left;
+        if (parsib && parsib.color === Color.R) {
+          parent.color  = Color.B;
+          gparent.left  = repaintNode(parsib, Color.B);
+          gparent.color = Color.R;
+          s            -= 1;
+        } else {
+          parent.left      = node.right;
+          gparent.color    = Color.R;
+          gparent.right    = node.left;
+          node.color       = Color.B;
+          node.right       = parent;
+          node.left        = gparent;
+          nodeStack[s - 2] = node;
+          nodeStack[s - 1] = parent;
+          recountNode(gparent);
+          recountNode(parent);
+          recountNode(node);
+          if (s >= 3) {
+            const ggparent = nodeStack[s - 3]!;
+            if (ggparent.right === gparent) {
+              ggparent.right = node;
+            } else {
+              ggparent.left = node;
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  nodeStack[0]!.color = Color.B;
+}
+
+export function fixDoubleBlack<K, V>(stack: Array<Node<K, V>>): void {
+  let node: Node<K, V>, parent: Node<K, V>, sibling: RBNode<K, V>, nibling: RBNode<K, V>;
+  for (let i = stack.length - 1; i >= 0; --i) {
+    node = stack[i]!;
+    if (i === 0) {
+      node.color = Color.B;
+      return;
+    }
+    parent = stack[i - 1]!;
+    if (parent.left === node) {
+      // left child
+      sibling = parent.right;
+      if (sibling && sibling.right && sibling.right.color === Color.R) {
+        // right sibling child red
+        sibling        = parent.right = cloneNode(sibling);
+        nibling        = sibling!.right = cloneNode(sibling!.right);
+        parent.right   = sibling!.left;
+        sibling!.left  = parent;
+        sibling!.right = nibling;
+        sibling!.color = parent.color;
+        node.color     = Color.B;
+        parent.color   = Color.B;
+        nibling!.color = Color.B;
+        recountNode(parent);
+        recountNode(sibling!);
+        if (i > 1) {
+          const pp = stack[i - 2]!;
+          if (pp.left === parent) {
+            pp.left = sibling;
+          } else {
+            pp.right = sibling;
+          }
+        }
+        stack[i - 1] = sibling!;
+        return;
+      } else if (sibling && sibling.left && sibling.left.color === Color.R) {
+        // left sibling child red
+        sibling        = parent.right = cloneNode(sibling);
+        nibling        = sibling!.left = cloneNode(sibling!.left);
+        parent.right   = nibling!.left;
+        sibling!.left  = nibling!.right;
+        nibling!.left  = parent;
+        nibling!.right = sibling;
+        nibling!.color = parent.color;
+        parent.color   = Color.B;
+        sibling!.color = Color.B;
+        node.color     = Color.B;
+        recountNode(parent);
+        recountNode(sibling!);
+        recountNode(nibling!);
+        if (i > 1) {
+          const pp = stack[i - 2]!;
+          if (pp.left === parent) {
+            pp.left = nibling;
+          } else {
+            pp.right = nibling;
+          }
+        }
+        stack[i - 1] = nibling!;
+        return;
+      }
+      if (sibling!.color === Color.B) {
+        if (parent.color === Color.R) {
+          // black sibling, red parent
+          parent.color = Color.B;
+          parent.right = repaintNode(sibling!, Color.R);
+          return;
+        } else {
+          // black sibling, black parent
+          parent.right = repaintNode(sibling!, Color.R);
+          continue;
+        }
+      } else {
+        // red sibling
+        sibling        = cloneNode(sibling);
+        parent.right   = sibling!.left;
+        sibling!.left  = parent;
+        sibling!.color = parent.color;
+        parent!.color  = Color.R;
+        recountNode(parent);
+        recountNode(sibling!);
+        if (i > 1) {
+          const pp = stack[i - 2]!;
+          if (pp.left === parent) {
+            pp.left = sibling;
+          } else {
+            pp.right = sibling;
+          }
+        }
+        stack[i - 1] = sibling!;
+        stack[i]     = parent;
+        if (i + 1 < stack.length) {
+          stack[i + 1] = node;
+        } else {
+          stack.push(node);
+        }
+        i += 2;
+      }
+    } else {
+      // right child
+      sibling = parent.left;
+      if (sibling && sibling.left && sibling.left.color === Color.R) {
+        // left sibling child red
+        sibling        = parent.left = cloneNode(sibling);
+        nibling        = sibling!.left = cloneNode(sibling!.left);
+        parent.left    = sibling!.right;
+        sibling!.right = parent;
+        sibling!.left  = nibling;
+        sibling!.color = parent.color;
+        node.color     = Color.B;
+        parent.color   = Color.B;
+        nibling!.color = Color.B;
+        recountNode(parent);
+        recountNode(sibling!);
+        if (i > 1) {
+          const pp = stack[i - 2]!;
+          if (pp.right === parent) {
+            pp.right = sibling;
+          } else {
+            pp.left = sibling;
+          }
+        }
+        stack[i - 1] = sibling!;
+        return;
+      } else if (sibling && sibling.right && sibling.right.color === Color.R) {
+        // right sibling child red
+        sibling        = parent.left = cloneNode(sibling);
+        nibling        = sibling!.right = cloneNode(sibling!.right);
+        parent.left    = nibling!.right;
+        sibling!.right = nibling!.left;
+        nibling!.right = parent;
+        nibling!.left  = sibling;
+        nibling!.color = parent.color;
+        parent.color   = Color.B;
+        sibling!.color = Color.B;
+        node.color     = Color.B;
+        recountNode(parent);
+        recountNode(sibling!);
+        recountNode(nibling!);
+        if (i > 1) {
+          const pp = stack[i - 2]!;
+          if (pp.right === parent) {
+            pp.right = nibling;
+          } else {
+            pp.left = nibling;
+          }
+        }
+        stack[i - 1] = nibling!;
+        return;
+      }
+      if (sibling!.color === Color.B) {
+        if (parent.color === Color.R) {
+          // black sibling, red parent
+          parent.color = Color.B;
+          parent.left  = repaintNode(sibling!, Color.R);
+          return;
+        } else {
+          // black sibling, black, parent
+          parent.left = repaintNode(sibling!, Color.R);
+          continue;
+        }
+      } else {
+        // red sibling
+        sibling        = cloneNode(sibling);
+        parent.left    = sibling!.right;
+        sibling!.right = parent;
+        sibling!.color = parent.color;
+        parent.color   = Color.R;
+        recountNode(parent);
+        recountNode(sibling!);
+        if (i > 1) {
+          const pp = stack[i - 2]!;
+          if (pp.right === parent) {
+            pp.right = sibling;
+          } else {
+            pp.left = sibling;
+          }
+        }
+        stack[i - 1] = sibling!;
+        stack[i]     = parent;
+        if (i + 1 < stack.length) {
+          stack[i + 1] = node;
+        } else {
+          stack.push(node);
+        }
+        i += 2;
+      }
+    }
+  }
+}

package/_src/collection/immutable/SortedMap/iterator.ts

@@ -0,0 +1,304 @@
+import type { RBNode } from "@fncts/base/collection/immutable/SortedMap/node";
+import type { Ord } from "@fncts/base/typeclass";
+
+import { fixDoubleBlack, swapNode } from "@fncts/base/collection/immutable/SortedMap/internal";
+import { Color, Leaf, Node } from "@fncts/base/collection/immutable/SortedMap/node";
+
+export interface SortedMapIterable<K, V> extends Iterable<readonly [K, V]> {
+  readonly ord: Ord<K>;
+  [Symbol.iterator](): SortedMapIterator<K, V>;
+}
+
+export function forward<K, V>(self: SortedMap<K, V>): SortedMapIterable<K, V> {
+  return {
+    ord: self.ord,
+    [Symbol.iterator]() {
+      const stack: Array<Node<K, V>> = [];
+      let n = self.root;
+      while (n) {
+        stack.push(n);
+        n = n.left;
+      }
+      return new SortedMapIterator(self, stack, 0);
+    },
+  };
+}
+
+export function backward<K, V>(self: SortedMap<K, V>): SortedMapIterable<K, V> {
+  return {
+    ord: self.ord,
+    [Symbol.iterator]() {
+      const stack: Array<Node<K, V>> = [];
+      let n = self.root;
+      while (n) {
+        stack.push(n);
+        n = n.right;
+      }
+      return new SortedMapIterator(self, stack, 1);
+    },
+  };
+}
+
+export class SortedMapIterator<K, V> implements Iterator<readonly [K, V]> {
+  private count = 0;
+  constructor(readonly m: SortedMap<K, V>, readonly stack: Array<Node<K, V>>, readonly direction: 0 | 1) {}
+
+  next(): IteratorResult<readonly [K, V]> {
+    if (this.isEmpty) {
+      return { done: true, value: this.count };
+    }
+    this.count++;
+    const value: readonly [K, V] = [this.stack[this.stack.length - 1]!.key, this.stack[this.stack.length - 1]!.value];
+    switch (this.direction) {
+      case 0: {
+        this.moveNext();
+        break;
+      }
+      case 1: {
+        this.movePrev();
+        break;
+      }
+    }
+    return { done: false, value };
+  }
+
+  get isEmpty(): boolean {
+    return this.stack.length === 0;
+  }
+
+  /**
+   * Returns the current node
+   */
+  get node(): RBNode<K, V> {
+    if (this.isEmpty) {
+      return Leaf;
+    }
+    return this.stack[this.stack.length - 1]!;
+  }
+
+  /**
+   * Returns the current key
+   */
+  get key(): Maybe<K> {
+    if (this.isEmpty) {
+      return Nothing();
+    }
+    return Just(this.node!.key);
+  }
+
+  /**
+   * Returns the current value
+   */
+  get value(): Maybe<V> {
+    if (this.isEmpty) {
+      return Nothing();
+    }
+    return Just(this.node!.value);
+  }
+
+  /**
+   * Returns the current entry
+   */
+  get entry(): Maybe<readonly [K, V]> {
+    if (this.isEmpty) {
+      return Nothing();
+    }
+    return Just([this.stack[this.stack.length - 1]!.key, this.stack[this.stack.length - 1]!.value]);
+  }
+
+  /**
+   * Checks if the iterator has a next element
+   */
+  get hasNext(): boolean {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return false;
+    }
+    if (stack[stack.length - 1]!.right) {
+      return true;
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1]!.left === stack[s]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Advances the iterator
+   */
+  moveNext(): void {
+    if (this.isEmpty) {
+      return;
+    }
+    const stack         = this.stack;
+    let n: RBNode<K, V> = stack[stack.length - 1]!;
+    if (n.right) {
+      n = n.right;
+      while (n) {
+        stack.push(n);
+        n = n.left;
+      }
+    } else {
+      stack.pop();
+      while (stack.length > 0 && stack[stack.length - 1]!.right === n) {
+        n = stack[stack.length - 1]!;
+        stack.pop();
+      }
+    }
+  }
+
+  /**
+   * Checks if the iterator has a previous element
+   */
+  get hasPrev(): boolean {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return false;
+    }
+    if (stack[stack.length - 1]!.left) {
+      return true;
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1]!.right === stack[s]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Retreats the iterator to the previous element
+   */
+  movePrev(): void {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return;
+    }
+    let n: RBNode<K, V> = stack[stack.length - 1]!;
+    if (n.left) {
+      n = n.left;
+      while (n) {
+        stack.push(n);
+        n = n.right;
+      }
+    } else {
+      stack.pop();
+      while (stack.length > 0 && stack[stack.length - 1]!.left === n) {
+        n = stack[stack.length - 1]!;
+        stack.pop();
+      }
+    }
+  }
+
+  /**
+   * Returns a `OrderedMapIterator` of the same tree, with a cloned stack
+   */
+  clone(): SortedMapIterator<K, V> {
+    return new SortedMapIterator(this.m, this.stack.slice(), this.direction);
+  }
+
+  /**
+   * Reverses the direction of the iterator
+   */
+  reverse(): SortedMapIterator<K, V> {
+    return new SortedMapIterator(this.m, this.stack.slice(), this.direction ? 0 : 1);
+  }
+
+  /**
+   * Deletes the current element, returing a new `OrderedMap`
+   */
+  remove(): SortedMap<K, V> {
+    const pathStack = this.stack;
+    if (pathStack.length === 0) {
+      return this.m;
+    }
+    // clone path to node
+    const stack: Array<Node<K, V>> = new Array(pathStack.length);
+    let n: Node<K, V>              = pathStack[pathStack.length - 1]!;
+    stack[stack.length - 1]        = new Node(n.color, n.left, n.key, n.value, n.right, n.count);
+    for (let i = pathStack.length - 2; i >= 0; --i) {
+      const n = pathStack[i]!;
+      if (n.left === pathStack[i + 1]!) {
+        stack[i] = new Node(n.color, stack[i + 1]!, n.key, n.value, n.right, n.count);
+      } else {
+        stack[i] = new Node(n.color, n.left, n.key, n.value, stack[i + 1]!, n.count);
+      }
+    }
+
+    // get node
+    n = stack[stack.length - 1]!;
+
+    // if not leaf, then swap with previous node
+    if (n.left && n.right) {
+      // first walk to previous leaf
+      const split = stack.length;
+      n           = n.left;
+      while (n.right) {
+        stack.push(n);
+        n = n.right;
+      }
+      // clone path to leaf
+      const v = stack[split - 1]!;
+      stack.push(new Node(n.color, n.left, v.key, v.value, n.right, n.count));
+      stack[split - 1]!.key   = n.key;
+      stack[split - 1]!.value = n.value;
+
+      // fix stack
+      for (let i = stack.length - 2; i >= split; --i) {
+        n        = stack[i]!;
+        stack[i] = new Node(n.color, n.left, n.key, n.value, stack[i + 1]!, n.count);
+      }
+      stack[split - 1]!.left = stack[split]!;
+    }
+    n = stack[stack.length - 1]!;
+    if (n.color === Color.R) {
+      // removing red leaf
+      const p = stack[stack.length - 2]!;
+      if (p.left === n) {
+        p.left = null;
+      } else if (p.right === n) {
+        p.right = null;
+      }
+      stack.pop();
+      for (let i = 0; i < stack.length; ++i) {
+        stack[i]!.count--;
+      }
+      return new SortedMap(this.m.ord, stack[0]!);
+    } else {
+      if (n.left || n.right) {
+        // single child black parent
+        // black single child
+        if (n.left) {
+          swapNode(n, n.left);
+        } else if (n.right) {
+          swapNode(n, n.right);
+        }
+        //Child must be red, so repaint it black to balance color
+        n.color = Color.B;
+        for (let i = 0; i < stack.length - 1; ++i) {
+          stack[i]!.count--;
+        }
+        return new SortedMap(this.m.ord, stack[0]!);
+      } else if (stack.length === 1) {
+        // root
+        return new SortedMap(this.m.ord, null);
+      } else {
+        // black leaf no children
+        for (let i = 0; i < stack.length; ++i) {
+          stack[i]!.count--;
+        }
+        const parent = stack[stack.length - 2]!;
+        fixDoubleBlack(stack);
+        // fix links
+        if (parent.left === n) {
+          parent.left = null;
+        } else {
+          parent.right = null;
+        }
+      }
+    }
+    return new SortedMap(this.m.ord, stack[0]!);
+  }
+}

package/_src/collection/immutable/SortedMap/node.ts

@@ -0,0 +1,21 @@
+export const enum Color {
+  R,
+  B,
+}
+
+export type Leaf = null;
+
+export class Node<K, V> {
+  constructor(
+    public color: Color,
+    public left: RBNode<K, V>,
+    public key: K,
+    public value: V,
+    public right: RBNode<K, V>,
+    public count: number,
+  ) {}
+}
+
+export const Leaf = null;
+
+export type RBNode<K, V> = Node<K, V> | Leaf;

package/_src/collection/immutable/SortedMap.ts

@@ -0,0 +1,7 @@
+// codegen:start { preset: barrel, include: ./SortedMap/*.ts }
+export * from "./SortedMap/api.js";
+export * from "./SortedMap/definition.js";
+export * from "./SortedMap/internal.js";
+export * from "./SortedMap/iterator.js";
+export * from "./SortedMap/node.js";
+// codegen:end