@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/redBlackTree.ts

@@ -1,1245 +0,0 @@
-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
-      }
-    }
-  }
-}