@depup/effect 3.20.0-depup.0

package/src/internal/redBlackTree.ts

@@ -0,0 +1,1245 @@
+import * as Chunk from "../Chunk.js"
+import * as Equal from "../Equal.js"
+import { dual, pipe } from "../Function.js"
+import * as Hash from "../Hash.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import * as Option from "../Option.js"
+import type * as Order from "../Order.js"
+import type * as Ordering from "../Ordering.js"
+import { pipeArguments } from "../Pipeable.js"
+import { hasProperty } from "../Predicate.js"
+import type * as RBT from "../RedBlackTree.js"
+import { Direction, RedBlackTreeIterator } from "./redBlackTree/iterator.js"
+import * as Node from "./redBlackTree/node.js"
+import * as Stack from "./stack.js"
+
+const RedBlackTreeSymbolKey = "effect/RedBlackTree"
+
+/** @internal */
+export const RedBlackTreeTypeId: RBT.TypeId = Symbol.for(RedBlackTreeSymbolKey) as RBT.TypeId
+
+/** @internal */
+export interface RedBlackTreeImpl<in out K, out V> extends RBT.RedBlackTree<K, V> {
+  readonly _ord: Order.Order<K>
+  readonly _root: Node.Node<K, V> | undefined
+}
+
+const redBlackTreeVariance = {
+  /* c8 ignore next */
+  _Key: (_: any) => _,
+  /* c8 ignore next */
+  _Value: (_: never) => _
+}
+
+const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
+  [RedBlackTreeTypeId]: redBlackTreeVariance,
+  [Hash.symbol](this: RBT.RedBlackTree<unknown, unknown>): number {
+    let hash = Hash.hash(RedBlackTreeSymbolKey)
+    for (const item of this) {
+      hash ^= pipe(Hash.hash(item[0]), Hash.combine(Hash.hash(item[1])))
+    }
+    return Hash.cached(this, hash)
+  },
+  [Equal.symbol]<K, V>(this: RedBlackTreeImpl<K, V>, that: unknown): boolean {
+    if (isRedBlackTree(that)) {
+      if ((this._root?.count ?? 0) !== ((that as RedBlackTreeImpl<K, V>)._root?.count ?? 0)) {
+        return false
+      }
+      const entries = Array.from(that)
+      return Array.from(this).every((itemSelf, i) => {
+        const itemThat = entries[i]
+        return Equal.equals(itemSelf[0], itemThat[0]) && Equal.equals(itemSelf[1], itemThat[1])
+      })
+    }
+    return false
+  },
+  [Symbol.iterator]<K, V>(this: RedBlackTreeImpl<K, V>): RedBlackTreeIterator<K, V> {
+    const stack: Array<Node.Node<K, V>> = []
+    let n = this._root
+    while (n != null) {
+      stack.push(n)
+      n = n.left
+    }
+    return new RedBlackTreeIterator(this, stack, Direction.Forward)
+  },
+  toString() {
+    return format(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "RedBlackTree",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const makeImpl = <K, V>(ord: Order.Order<K>, root: Node.Node<K, V> | undefined): RedBlackTreeImpl<K, V> => {
+  const tree = Object.create(RedBlackTreeProto)
+  tree._ord = ord
+  tree._root = root
+  return tree
+}
+
+/** @internal */
+export const isRedBlackTree: {
+  <K, V>(u: Iterable<readonly [K, V]>): u is RBT.RedBlackTree<K, V>
+  (u: unknown): u is RBT.RedBlackTree<unknown, unknown>
+} = (u: unknown): u is RBT.RedBlackTree<unknown, unknown> => hasProperty(u, RedBlackTreeTypeId)
+
+/** @internal */
+export const empty = <K, V = never>(ord: Order.Order<K>): RBT.RedBlackTree<K, V> => makeImpl<K, V>(ord, undefined)
+
+/** @internal */
+export const fromIterable = dual<
+  <B>(ord: Order.Order<B>) => <K extends B, V>(entries: Iterable<readonly [K, V]>) => RBT.RedBlackTree<K, V>,
+  <K extends B, V, B>(entries: Iterable<readonly [K, V]>, ord: Order.Order<B>) => RBT.RedBlackTree<K, V>
+>(2, <K extends B, V, B>(entries: Iterable<readonly [K, V]>, ord: Order.Order<B>) => {
+  let tree = empty<K, V>(ord)
+  for (const [key, value] of entries) {
+    tree = insert(tree, key, value)
+  }
+  return tree
+})
+
+/** @internal */
+export const make =
+  <K>(ord: Order.Order<K>) =>
+  <Entries extends Array<readonly [K, any]>>(...entries: Entries): RBT.RedBlackTree<
+    K,
+    Entries[number] extends readonly [any, infer V] ? V : never
+  > => {
+    return fromIterable(entries, ord)
+  }
+
+/** @internal */
+export const atBackwards = dual<
+  (index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Iterable<[K, V]>
+>(2, (self, index) => at(self, index, Direction.Backward))
+
+/** @internal */
+export const atForwards = dual<
+  (index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Iterable<[K, V]>
+>(2, (self, index) => at(self, index, Direction.Forward))
+
+const at = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  index: number,
+  direction: RBT.RedBlackTree.Direction
+): Iterable<[K, V]> => {
+  return {
+    [Symbol.iterator]: () => {
+      if (index < 0) {
+        return new RedBlackTreeIterator(self, [], direction)
+      }
+      let node = (self as RedBlackTreeImpl<K, V>)._root
+      const stack: Array<Node.Node<K, V>> = []
+      while (node !== undefined) {
+        stack.push(node)
+        if (node.left !== undefined) {
+          if (index < node.left.count) {
+            node = node.left
+            continue
+          }
+          index -= node.left.count
+        }
+        if (!index) {
+          return new RedBlackTreeIterator(self, stack, direction)
+        }
+        index -= 1
+        if (node.right !== undefined) {
+          if (index >= node.right.count) {
+            break
+          }
+          node = node.right
+        } else {
+          break
+        }
+      }
+      return new RedBlackTreeIterator(self, [], direction)
+    }
+  }
+}
+
+/** @internal */
+export const findAll = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Chunk.Chunk<V>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Chunk.Chunk<V>
+>(2, <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => {
+  const stack: Array<Node.Node<K, V>> = []
+  let node = (self as RedBlackTreeImpl<K, V>)._root
+  let result = Chunk.empty<V>()
+  while (node !== undefined || stack.length > 0) {
+    if (node) {
+      stack.push(node)
+      node = node.left
+    } else {
+      const current = stack.pop()!
+      if (Equal.equals(key, current.key)) {
+        result = Chunk.prepend(current.value)(result)
+      }
+      node = current.right
+    }
+  }
+  return result
+})
+
+/** @internal */
+export const findFirst = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Option.Option<V>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Option.Option<V>
+>(2, <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => {
+  const cmp = (self as RedBlackTreeImpl<K, V>)._ord
+  let node = (self as RedBlackTreeImpl<K, V>)._root
+  while (node !== undefined) {
+    const d = cmp(key, node.key)
+    if (Equal.equals(key, node.key)) {
+      return Option.some(node.value)
+    }
+    if (d <= 0) {
+      node = node.left
+    } else {
+      node = node.right
+    }
+  }
+  return Option.none()
+})
+
+/** @internal */
+export const first = <K, V>(self: RBT.RedBlackTree<K, V>): Option.Option<[K, V]> => {
+  let node: Node.Node<K, V> | undefined = (self as RedBlackTreeImpl<K, V>)._root
+  let current: Node.Node<K, V> | undefined = (self as RedBlackTreeImpl<K, V>)._root
+  while (node !== undefined) {
+    current = node
+    node = node.left
+  }
+  return current ? Option.some([current.key, current.value]) : Option.none()
+}
+
+/** @internal */
+export const getAt = dual<
+  (index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Option.Option<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Option.Option<[K, V]>
+>(2, <K, V>(self: RBT.RedBlackTree<K, V>, index: number) => {
+  if (index < 0) {
+    return Option.none()
+  }
+  let root = (self as RedBlackTreeImpl<K, V>)._root
+  let node: Node.Node<K, V> | undefined = undefined
+  while (root !== undefined) {
+    node = root
+    if (root.left) {
+      if (index < root.left.count) {
+        root = root.left
+        continue
+      }
+      index -= root.left.count
+    }
+    if (!index) {
+      return Option.some([node.key, node.value])
+    }
+    index -= 1
+    if (root.right) {
+      if (index >= root.right.count) {
+        break
+      }
+      root = root.right
+    } else {
+      break
+    }
+  }
+  return Option.none()
+})
+
+/** @internal */
+export const getOrder = <K, V>(tree: RBT.RedBlackTree<K, V>): Order.Order<K> => (tree as RedBlackTreeImpl<K, V>)._ord
+
+/** @internal */
+export const has = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => boolean,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => boolean
+>(2, (self, key) => Option.isSome(findFirst(self, key)))
+
+/** @internal */
+export const insert = dual<
+  <K, V>(key: K, value: V) => (self: RBT.RedBlackTree<K, V>) => RBT.RedBlackTree<K, V>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K, value: V) => RBT.RedBlackTree<K, V>
+>(3, <K, V>(self: RBT.RedBlackTree<K, V>, key: K, value: V) => {
+  const cmp = (self as RedBlackTreeImpl<K, V>)._ord
+  // Find point to insert new node at
+  let n: Node.Node<K, V> | undefined = (self as RedBlackTreeImpl<K, V>)._root
+  const n_stack: Array<Node.Node<K, V>> = []
+  const d_stack: Array<Ordering.Ordering> = []
+  while (n != null) {
+    const d = cmp(key, n.key)
+    n_stack.push(n)
+    d_stack.push(d)
+    if (d <= 0) {
+      n = n.left
+    } else {
+      n = n.right
+    }
+  }
+  // Rebuild path to leaf node
+  n_stack.push({
+    color: Node.Color.Red,
+    key,
+    value,
+    left: undefined,
+    right: undefined,
+    count: 1
+  })
+  for (let s = n_stack.length - 2; s >= 0; --s) {
+    const n2 = n_stack[s]!
+    if (d_stack[s]! <= 0) {
+      n_stack[s] = {
+        color: n2.color,
+        key: n2.key,
+        value: n2.value,
+        left: n_stack[s + 1],
+        right: n2.right,
+        count: n2.count + 1
+      }
+    } else {
+      n_stack[s] = {
+        color: n2.color,
+        key: n2.key,
+        value: n2.value,
+        left: n2.left,
+        right: n_stack[s + 1],
+        count: n2.count + 1
+      }
+    }
+  }
+  // Rebalance tree using rotations
+  for (let s = n_stack.length - 1; s > 1; --s) {
+    const p = n_stack[s - 1]!
+    const n3 = n_stack[s]!
+    if (p.color === Node.Color.Black || n3.color === Node.Color.Black) {
+      break
+    }
+    const pp = n_stack[s - 2]!
+    if (pp.left === p) {
+      if (p.left === n3) {
+        const y = pp.right
+        if (y && y.color === Node.Color.Red) {
+          p.color = Node.Color.Black
+          pp.right = Node.repaint(y, Node.Color.Black)
+          pp.color = Node.Color.Red
+          s -= 1
+        } else {
+          pp.color = Node.Color.Red
+          pp.left = p.right
+          p.color = Node.Color.Black
+          p.right = pp
+          n_stack[s - 2] = p
+          n_stack[s - 1] = n3
+          Node.recount(pp)
+          Node.recount(p)
+          if (s >= 3) {
+            const ppp = n_stack[s - 3]!
+            if (ppp.left === pp) {
+              ppp.left = p
+            } else {
+              ppp.right = p
+            }
+          }
+          break
+        }
+      } else {
+        const y = pp.right
+        if (y && y.color === Node.Color.Red) {
+          p.color = Node.Color.Black
+          pp.right = Node.repaint(y, Node.Color.Black)
+          pp.color = Node.Color.Red
+          s -= 1
+        } else {
+          p.right = n3.left
+          pp.color = Node.Color.Red
+          pp.left = n3.right
+          n3.color = Node.Color.Black
+          n3.left = p
+          n3.right = pp
+          n_stack[s - 2] = n3
+          n_stack[s - 1] = p
+          Node.recount(pp)
+          Node.recount(p)
+          Node.recount(n3)
+          if (s >= 3) {
+            const ppp = n_stack[s - 3]!
+            if (ppp.left === pp) {
+              ppp.left = n3
+            } else {
+              ppp.right = n3
+            }
+          }
+          break
+        }
+      }
+    } else {
+      if (p.right === n3) {
+        const y = pp.left
+        if (y && y.color === Node.Color.Red) {
+          p.color = Node.Color.Black
+          pp.left = Node.repaint(y, Node.Color.Black)
+          pp.color = Node.Color.Red
+          s -= 1
+        } else {
+          pp.color = Node.Color.Red
+          pp.right = p.left
+          p.color = Node.Color.Black
+          p.left = pp
+          n_stack[s - 2] = p
+          n_stack[s - 1] = n3
+          Node.recount(pp)
+          Node.recount(p)
+          if (s >= 3) {
+            const ppp = n_stack[s - 3]!
+            if (ppp.right === pp) {
+              ppp.right = p
+            } else {
+              ppp.left = p
+            }
+          }
+          break
+        }
+      } else {
+        const y = pp.left
+        if (y && y.color === Node.Color.Red) {
+          p.color = Node.Color.Black
+          pp.left = Node.repaint(y, Node.Color.Black)
+          pp.color = Node.Color.Red
+          s -= 1
+        } else {
+          p.left = n3.right
+          pp.color = Node.Color.Red
+          pp.right = n3.left
+          n3.color = Node.Color.Black
+          n3.right = p
+          n3.left = pp
+          n_stack[s - 2] = n3
+          n_stack[s - 1] = p
+          Node.recount(pp)
+          Node.recount(p)
+          Node.recount(n3)
+          if (s >= 3) {
+            const ppp = n_stack[s - 3]!
+            if (ppp.right === pp) {
+              ppp.right = n3
+            } else {
+              ppp.left = n3
+            }
+          }
+          break
+        }
+      }
+    }
+  }
+  // Return new tree
+  n_stack[0]!.color = Node.Color.Black
+  return makeImpl((self as RedBlackTreeImpl<K, V>)._ord, n_stack[0])
+})
+
+/** @internal */
+export const keysForward = <K, V>(self: RBT.RedBlackTree<K, V>): IterableIterator<K> => keys(self, Direction.Forward)
+
+/** @internal */
+export const keysBackward = <K, V>(self: RBT.RedBlackTree<K, V>): IterableIterator<K> => keys(self, Direction.Backward)
+
+const keys = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  direction: RBT.RedBlackTree.Direction
+): IterableIterator<K> => {
+  const begin: RedBlackTreeIterator<K, V> = self[Symbol.iterator]() as RedBlackTreeIterator<K, V>
+  let count = 0
+  return {
+    [Symbol.iterator]: () => keys(self, direction),
+    next: (): IteratorResult<K, number> => {
+      count++
+      const entry = begin.key
+      if (direction === Direction.Forward) {
+        begin.moveNext()
+      } else {
+        begin.movePrev()
+      }
+      switch (entry._tag) {
+        case "None": {
+          return { done: true, value: count }
+        }
+        case "Some": {
+          return { done: false, value: entry.value }
+        }
+      }
+    }
+  }
+}
+
+/** @internal */
+export const last = <K, V>(self: RBT.RedBlackTree<K, V>): Option.Option<[K, V]> => {
+  let node: Node.Node<K, V> | undefined = (self as RedBlackTreeImpl<K, V>)._root
+  let current: Node.Node<K, V> | undefined = (self as RedBlackTreeImpl<K, V>)._root
+  while (node !== undefined) {
+    current = node
+    node = node.right
+  }
+  return current ? Option.some([current.key, current.value]) : Option.none()
+}
+
+/** @internal */
+export const reversed = <K, V>(self: RBT.RedBlackTree<K, V>): Iterable<[K, V]> => {
+  return {
+    [Symbol.iterator]: () => {
+      const stack: Array<Node.Node<K, V>> = []
+      let node = (self as RedBlackTreeImpl<K, V>)._root
+      while (node !== undefined) {
+        stack.push(node)
+        node = node.right
+      }
+      return new RedBlackTreeIterator(self, stack, Direction.Backward)
+    }
+  }
+}
+
+/** @internal */
+export const greaterThanBackwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => greaterThan(self, key, Direction.Backward))
+
+/** @internal */
+export const greaterThanForwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => greaterThan(self, key, Direction.Forward))
+
+const greaterThan = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  key: K,
+  direction: RBT.RedBlackTree.Direction
+): Iterable<[K, V]> => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = (self as RedBlackTreeImpl<K, V>)._ord
+      let node = (self as RedBlackTreeImpl<K, V>)._root
+      const stack = []
+      let last_ptr = 0
+      while (node !== undefined) {
+        const d = cmp(key, node.key)
+        stack.push(node)
+        if (d < 0) {
+          last_ptr = stack.length
+        }
+        if (d < 0) {
+          node = node.left
+        } else {
+          node = node.right
+        }
+      }
+      stack.length = last_ptr
+      return new RedBlackTreeIterator(self, stack, direction)
+    }
+  }
+}
+
+/** @internal */
+export const greaterThanEqualBackwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => greaterThanEqual(self, key, Direction.Backward))
+
+/** @internal */
+export const greaterThanEqualForwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => greaterThanEqual(self, key, Direction.Forward))
+
+const greaterThanEqual = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  key: K,
+  direction: RBT.RedBlackTree.Direction = Direction.Forward
+): Iterable<[K, V]> => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = (self as RedBlackTreeImpl<K, V>)._ord
+      let node = (self as RedBlackTreeImpl<K, V>)._root
+      const stack = []
+      let last_ptr = 0
+      while (node !== undefined) {
+        const d = cmp(key, node.key)
+        stack.push(node)
+        if (d <= 0) {
+          last_ptr = stack.length
+        }
+        if (d <= 0) {
+          node = node.left
+        } else {
+          node = node.right
+        }
+      }
+      stack.length = last_ptr
+      return new RedBlackTreeIterator(self, stack, direction)
+    }
+  }
+}
+
+/** @internal */
+export const lessThanBackwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => lessThan(self, key, Direction.Backward))
+
+/** @internal */
+export const lessThanForwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => lessThan(self, key, Direction.Forward))
+
+const lessThan = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  key: K,
+  direction: RBT.RedBlackTree.Direction
+): Iterable<[K, V]> => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = (self as RedBlackTreeImpl<K, V>)._ord
+      let node = (self as RedBlackTreeImpl<K, V>)._root
+      const stack = []
+      let last_ptr = 0
+      while (node !== undefined) {
+        const d = cmp(key, node.key)
+        stack.push(node)
+        if (d > 0) {
+          last_ptr = stack.length
+        }
+        if (d <= 0) {
+          node = node.left
+        } else {
+          node = node.right
+        }
+      }
+      stack.length = last_ptr
+      return new RedBlackTreeIterator(self, stack, direction)
+    }
+  }
+}
+
+/** @internal */
+export const lessThanEqualBackwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => lessThanEqual(self, key, Direction.Backward))
+
+/** @internal */
+export const lessThanEqualForwards = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<[K, V]>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<[K, V]>
+>(2, (self, key) => lessThanEqual(self, key, Direction.Forward))
+
+const lessThanEqual = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  key: K,
+  direction: RBT.RedBlackTree.Direction
+): Iterable<[K, V]> => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = (self as RedBlackTreeImpl<K, V>)._ord
+      let node = (self as RedBlackTreeImpl<K, V>)._root
+      const stack = []
+      let last_ptr = 0
+      while (node !== undefined) {
+        const d = cmp(key, node.key)
+        stack.push(node)
+        if (d >= 0) {
+          last_ptr = stack.length
+        }
+        if (d < 0) {
+          node = node.left
+        } else {
+          node = node.right
+        }
+      }
+      stack.length = last_ptr
+      return new RedBlackTreeIterator(self, stack, direction)
+    }
+  }
+}
+
+/** @internal */
+export const forEach = dual<
+  <K, V>(f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
+  <K, V>(self: RBT.RedBlackTree<K, V>, f: (key: K, value: V) => void) => void
+>(2, <K, V>(self: RBT.RedBlackTree<K, V>, f: (key: K, value: V) => void) => {
+  const root = (self as RedBlackTreeImpl<K, V>)._root
+  if (root !== undefined) {
+    visitFull(root, (key, value) => {
+      f(key, value)
+      return Option.none()
+    })
+  }
+})
+
+/** @internal */
+export const forEachGreaterThanEqual = dual<
+  <K, V>(min: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
+  <K, V>(self: RBT.RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void) => void
+>(3, <K, V>(self: RBT.RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void) => {
+  const root = (self as RedBlackTreeImpl<K, V>)._root
+  const ord = (self as RedBlackTreeImpl<K, V>)._ord
+  if (root !== undefined) {
+    visitGreaterThanEqual(root, min, ord, (key, value) => {
+      f(key, value)
+      return Option.none()
+    })
+  }
+})
+
+/** @internal */
+export const forEachLessThan = dual<
+  <K, V>(max: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
+  <K, V>(self: RBT.RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void) => void
+>(3, <K, V>(self: RBT.RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void) => {
+  const root = (self as RedBlackTreeImpl<K, V>)._root
+  const ord = (self as RedBlackTreeImpl<K, V>)._ord
+  if (root !== undefined) {
+    visitLessThan(root, max, ord, (key, value) => {
+      f(key, value)
+      return Option.none()
+    })
+  }
+})
+
+/** @internal */
+export const forEachBetween = dual<
+  <K, V>(options: {
+    readonly min: K
+    readonly max: K
+    readonly body: (key: K, value: V) => void
+  }) => (self: RBT.RedBlackTree<K, V>) => void,
+  <K, V>(self: RBT.RedBlackTree<K, V>, options: {
+    readonly min: K
+    readonly max: K
+    readonly body: (key: K, value: V) => void
+  }) => void
+>(2, <K, V>(self: RBT.RedBlackTree<K, V>, { body, max, min }: {
+  readonly min: K
+  readonly max: K
+  readonly body: (key: K, value: V) => void
+}) => {
+  const root = (self as RedBlackTreeImpl<K, V>)._root
+  const ord = (self as RedBlackTreeImpl<K, V>)._ord
+  if (root) {
+    visitBetween(root, min, max, ord, (key, value) => {
+      body(key, value)
+      return Option.none()
+    })
+  }
+})
+
+/** @internal */
+export const reduce = dual<
+  <Z, V, K>(
+    zero: Z,
+    f: (accumulator: Z, value: V, key: K) => Z
+  ) => (self: RBT.RedBlackTree<K, V>) => Z,
+  <Z, V, K>(self: RBT.RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => Z
+>(3, (self, zero, f) => {
+  let accumulator = zero
+  for (const entry of self) {
+    accumulator = f(accumulator, entry[1], entry[0])
+  }
+  return accumulator
+})
+
+/** @internal */
+export const removeFirst = dual<
+  <K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => RBT.RedBlackTree<K, V>,
+  <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => RBT.RedBlackTree<K, V>
+>(2, <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => {
+  if (!has(self, key)) {
+    return self
+  }
+  const ord = (self as RedBlackTreeImpl<K, V>)._ord
+  const cmp = ord
+  let node: Node.Node<K, V> | undefined = (self as RedBlackTreeImpl<K, V>)._root
+  const stack = []
+  while (node !== undefined) {
+    const d = cmp(key, node.key)
+    stack.push(node)
+    if (Equal.equals(key, node.key)) {
+      node = undefined
+    } else if (d <= 0) {
+      node = node.left
+    } else {
+      node = node.right
+    }
+  }
+  if (stack.length === 0) {
+    return self
+  }
+  const cstack = new Array<Node.Node<K, V>>(stack.length)
+  let n = stack[stack.length - 1]!
+  cstack[cstack.length - 1] = {
+    color: n.color,
+    key: n.key,
+    value: n.value,
+    left: n.left,
+    right: n.right,
+    count: n.count
+  }
+  for (let i = stack.length - 2; i >= 0; --i) {
+    n = stack[i]!
+    if (n.left === stack[i + 1]) {
+      cstack[i] = {
+        color: n.color,
+        key: n.key,
+        value: n.value,
+        left: cstack[i + 1],
+        right: n.right,
+        count: n.count
+      }
+    } else {
+      cstack[i] = {
+        color: n.color,
+        key: n.key,
+        value: n.value,
+        left: n.left,
+        right: cstack[i + 1],
+        count: n.count
+      }
+    }
+  }
+  // Get node
+  n = cstack[cstack.length - 1]!
+  // If not leaf, then swap with previous node
+  if (n.left !== undefined && n.right !== undefined) {
+    // First walk to previous leaf
+    const split = cstack.length
+    n = n.left
+    while (n.right != null) {
+      cstack.push(n)
+      n = n.right
+    }
+    // Copy path to leaf
+    const v = cstack[split - 1]
+    cstack.push({
+      color: n.color,
+      key: v!.key,
+      value: v!.value,
+      left: n.left,
+      right: n.right,
+      count: n.count
+    })
+    cstack[split - 1]!.key = n.key
+    cstack[split - 1]!.value = n.value
+    // Fix up stack
+    for (let i = cstack.length - 2; i >= split; --i) {
+      n = cstack[i]!
+      cstack[i] = {
+        color: n.color,
+        key: n.key,
+        value: n.value,
+        left: n.left,
+        right: cstack[i + 1],
+        count: n.count
+      }
+    }
+    cstack[split - 1]!.left = cstack[split]
+  }
+
+  // Remove leaf node
+  n = cstack[cstack.length - 1]!
+  if (n.color === Node.Color.Red) {
+    // Easy case: removing red leaf
+    const p = cstack[cstack.length - 2]!
+    if (p.left === n) {
+      p.left = undefined
+    } else if (p.right === n) {
+      p.right = undefined
+    }
+    cstack.pop()
+    for (let i = 0; i < cstack.length; ++i) {
+      cstack[i]!.count--
+    }
+    return makeImpl(ord, cstack[0])
+  } else {
+    if (n.left !== undefined || n.right !== undefined) {
+      // Second easy case:  Single child black parent
+      if (n.left !== undefined) {
+        Node.swap(n, n.left)
+      } else if (n.right !== undefined) {
+        Node.swap(n, n.right)
+      }
+      // Child must be red, so repaint it black to balance color
+      n.color = Node.Color.Black
+      for (let i = 0; i < cstack.length - 1; ++i) {
+        cstack[i]!.count--
+      }
+      return makeImpl(ord, cstack[0])
+    } else if (cstack.length === 1) {
+      // Third easy case: root
+      return makeImpl(ord, undefined)
+    } else {
+      // Hard case: Repaint n, and then do some nasty stuff
+      for (let i = 0; i < cstack.length; ++i) {
+        cstack[i]!.count--
+      }
+      const parent = cstack[cstack.length - 2]
+      fixDoubleBlack(cstack)
+      // Fix up links
+      if (parent!.left === n) {
+        parent!.left = undefined
+      } else {
+        parent!.right = undefined
+      }
+    }
+  }
+  return makeImpl(ord, cstack[0])
+})
+
+/** @internal */
+export const size = <K, V>(self: RBT.RedBlackTree<K, V>): number => (self as RedBlackTreeImpl<K, V>)._root?.count ?? 0
+
+/** @internal */
+export const valuesForward = <K, V>(self: RBT.RedBlackTree<K, V>): IterableIterator<V> =>
+  values(self, Direction.Forward)
+
+/** @internal */
+export const valuesBackward = <K, V>(self: RBT.RedBlackTree<K, V>): IterableIterator<V> =>
+  values(self, Direction.Backward)
+
+/** @internal */
+const values = <K, V>(
+  self: RBT.RedBlackTree<K, V>,
+  direction: RBT.RedBlackTree.Direction
+): IterableIterator<V> => {
+  const begin: RedBlackTreeIterator<K, V> = self[Symbol.iterator]() as RedBlackTreeIterator<K, V>
+  let count = 0
+  return {
+    [Symbol.iterator]: () => values(self, direction),
+    next: (): IteratorResult<V, number> => {
+      count++
+      const entry = begin.value
+      if (direction === Direction.Forward) {
+        begin.moveNext()
+      } else {
+        begin.movePrev()
+      }
+      switch (entry._tag) {
+        case "None": {
+          return { done: true, value: count }
+        }
+        case "Some": {
+          return { done: false, value: entry.value }
+        }
+      }
+    }
+  }
+}
+
+const visitFull = <K, V, A>(
+  node: Node.Node<K, V>,
+  visit: (key: K, value: V) => Option.Option<A>
+): Option.Option<A> => {
+  let current: Node.Node<K, V> | undefined = node
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
+  let done = false
+  while (!done) {
+    if (current != null) {
+      stack = Stack.make(current, stack)
+      current = current.left
+    } else if (stack != null) {
+      const value = visit(stack.value.key, stack.value.value)
+      if (Option.isSome(value)) {
+        return value
+      }
+      current = stack.value.right
+      stack = stack.previous
+    } else {
+      done = true
+    }
+  }
+  return Option.none()
+}
+
+const visitGreaterThanEqual = <K, V, A>(
+  node: Node.Node<K, V>,
+  min: K,
+  ord: Order.Order<K>,
+  visit: (key: K, value: V) => Option.Option<A>
+): Option.Option<A> => {
+  let current: Node.Node<K, V> | undefined = node
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
+  let done = false
+  while (!done) {
+    if (current !== undefined) {
+      stack = Stack.make(current, stack)
+      if (ord(min, current.key) <= 0) {
+        current = current.left
+      } else {
+        current = undefined
+      }
+    } else if (stack !== undefined) {
+      if (ord(min, stack.value.key) <= 0) {
+        const value = visit(stack.value.key, stack.value.value)
+        if (Option.isSome(value)) {
+          return value
+        }
+      }
+      current = stack.value.right
+      stack = stack.previous
+    } else {
+      done = true
+    }
+  }
+  return Option.none()
+}
+
+const visitLessThan = <K, V, A>(
+  node: Node.Node<K, V>,
+  max: K,
+  ord: Order.Order<K>,
+  visit: (key: K, value: V) => Option.Option<A>
+): Option.Option<A> => {
+  let current: Node.Node<K, V> | undefined = node
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
+  let done = false
+  while (!done) {
+    if (current !== undefined) {
+      stack = Stack.make(current, stack)
+      current = current.left
+    } else if (stack !== undefined && ord(max, stack.value.key) > 0) {
+      const value = visit(stack.value.key, stack.value.value)
+      if (Option.isSome(value)) {
+        return value
+      }
+      current = stack.value.right
+      stack = stack.previous
+    } else {
+      done = true
+    }
+  }
+  return Option.none()
+}
+
+const visitBetween = <K, V, A>(
+  node: Node.Node<K, V>,
+  min: K,
+  max: K,
+  ord: Order.Order<K>,
+  visit: (key: K, value: V) => Option.Option<A>
+): Option.Option<A> => {
+  let current: Node.Node<K, V> | undefined = node
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
+  let done = false
+  while (!done) {
+    if (current !== undefined) {
+      stack = Stack.make(current, stack)
+      if (ord(min, current.key) <= 0) {
+        current = current.left
+      } else {
+        current = undefined
+      }
+    } else if (stack !== undefined && ord(max, stack.value.key) > 0) {
+      if (ord(min, stack.value.key) <= 0) {
+        const value = visit(stack.value.key, stack.value.value)
+        if (Option.isSome(value)) {
+          return value
+        }
+      }
+      current = stack.value.right
+      stack = stack.previous
+    } else {
+      done = true
+    }
+  }
+  return Option.none()
+}
+
+/**
+ * Fix up a double black node in a Red-Black Tree.
+ */
+const fixDoubleBlack = <K, V>(stack: Array<Node.Node<K, V>>) => {
+  let n, p, s, z
+  for (let i = stack.length - 1; i >= 0; --i) {
+    n = stack[i]!
+    if (i === 0) {
+      n.color = Node.Color.Black
+      return
+    }
+    p = stack[i - 1]!
+    if (p.left === n) {
+      s = p.right
+      if (s !== undefined && s.right !== undefined && s.right.color === Node.Color.Red) {
+        s = p.right = Node.clone(s)
+        z = s.right = Node.clone(s.right!)
+        p.right = s.left
+        s.left = p
+        s.right = z
+        s.color = p.color
+        n.color = Node.Color.Black
+        p.color = Node.Color.Black
+        z.color = Node.Color.Black
+        Node.recount(p)
+        Node.recount(s)
+        if (i > 1) {
+          const pp = stack[i - 2]!
+          if (pp.left === p) {
+            pp.left = s
+          } else {
+            pp.right = s
+          }
+        }
+        stack[i - 1] = s
+        return
+      } else if (s !== undefined && s.left !== undefined && s.left.color === Node.Color.Red) {
+        s = p.right = Node.clone(s)
+        z = s.left = Node.clone(s.left!)
+        p.right = z.left
+        s.left = z.right
+        z.left = p
+        z.right = s
+        z.color = p.color
+        p.color = Node.Color.Black
+        s.color = Node.Color.Black
+        n.color = Node.Color.Black
+        Node.recount(p)
+        Node.recount(s)
+        Node.recount(z)
+        if (i > 1) {
+          const pp = stack[i - 2]!
+          if (pp.left === p) {
+            pp.left = z
+          } else {
+            pp.right = z
+          }
+        }
+        stack[i - 1] = z
+        return
+      }
+      if (s !== undefined && s.color === Node.Color.Black) {
+        if (p.color === Node.Color.Red) {
+          p.color = Node.Color.Black
+          p.right = Node.repaint(s, Node.Color.Red)
+          return
+        } else {
+          p.right = Node.repaint(s, Node.Color.Red)
+          continue
+        }
+      } else if (s !== undefined) {
+        s = Node.clone(s)
+        p.right = s.left
+        s.left = p
+        s.color = p.color
+        p.color = Node.Color.Red
+        Node.recount(p)
+        Node.recount(s)
+        if (i > 1) {
+          const pp = stack[i - 2]!
+          if (pp.left === p) {
+            pp.left = s
+          } else {
+            pp.right = s
+          }
+        }
+        stack[i - 1] = s
+        stack[i] = p
+        if (i + 1 < stack.length) {
+          stack[i + 1] = n
+        } else {
+          stack.push(n)
+        }
+        i = i + 2
+      }
+    } else {
+      s = p.left
+      if (s !== undefined && s.left !== undefined && s.left.color === Node.Color.Red) {
+        s = p.left = Node.clone(s)
+        z = s.left = Node.clone(s.left!)
+        p.left = s.right
+        s.right = p
+        s.left = z
+        s.color = p.color
+        n.color = Node.Color.Black
+        p.color = Node.Color.Black
+        z.color = Node.Color.Black
+        Node.recount(p)
+        Node.recount(s)
+        if (i > 1) {
+          const pp = stack[i - 2]!
+          if (pp.right === p) {
+            pp.right = s
+          } else {
+            pp.left = s
+          }
+        }
+        stack[i - 1] = s
+        return
+      } else if (s !== undefined && s.right !== undefined && s.right.color === Node.Color.Red) {
+        s = p.left = Node.clone(s)
+        z = s.right = Node.clone(s.right!)
+        p.left = z.right
+        s.right = z.left
+        z.right = p
+        z.left = s
+        z.color = p.color
+        p.color = Node.Color.Black
+        s.color = Node.Color.Black
+        n.color = Node.Color.Black
+        Node.recount(p)
+        Node.recount(s)
+        Node.recount(z)
+        if (i > 1) {
+          const pp = stack[i - 2]!
+          if (pp.right === p) {
+            pp.right = z
+          } else {
+            pp.left = z
+          }
+        }
+        stack[i - 1] = z
+        return
+      }
+      if (s !== undefined && s.color === Node.Color.Black) {
+        if (p.color === Node.Color.Red) {
+          p.color = Node.Color.Black
+          p.left = Node.repaint(s, Node.Color.Red)
+          return
+        } else {
+          p.left = Node.repaint(s, Node.Color.Red)
+          continue
+        }
+      } else if (s !== undefined) {
+        s = Node.clone(s)
+        p.left = s.right
+        s.right = p
+        s.color = p.color
+        p.color = Node.Color.Red
+        Node.recount(p)
+        Node.recount(s)
+        if (i > 1) {
+          const pp = stack[i - 2]!
+          if (pp.right === p) {
+            pp.right = s
+          } else {
+            pp.left = s
+          }
+        }
+        stack[i - 1] = s
+        stack[i] = p
+        if (i + 1 < stack.length) {
+          stack[i + 1] = n
+        } else {
+          stack.push(n)
+        }
+        i = i + 2
+      }
+    }
+  }
+}