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

package/src/internal/trie.ts

@@ -1,722 +0,0 @@
-import * as Equal from "../Equal.js"
-import { dual, identity, 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 Ordering from "../Ordering.js"
-import { pipeArguments } from "../Pipeable.js"
-import { hasProperty } from "../Predicate.js"
-import type * as TR from "../Trie.js"
-import type { NoInfer } from "../Types.js"
-
-const TrieSymbolKey = "effect/Trie"
-
-/** @internal */
-export const TrieTypeId: TR.TypeId = Symbol.for(TrieSymbolKey) as TR.TypeId
-
-type TraversalMap<K, V, A> = (k: K, v: V) => A
-
-type TraversalFilter<K, V> = (k: K, v: V) => boolean
-
-/** @internal */
-export interface TrieImpl<in out V> extends TR.Trie<V> {
-  readonly _root: Node<V> | undefined
-  readonly _count: number
-}
-
-const trieVariance = {
-  /* c8 ignore next */
-  _Value: (_: never) => _
-}
-
-const TrieProto: TR.Trie<unknown> = {
-  [TrieTypeId]: trieVariance,
-  [Symbol.iterator]<V>(this: TrieImpl<V>): Iterator<[string, V]> {
-    return new TrieIterator(this, (k, v) => [k, v], () => true)
-  },
-  [Hash.symbol](this: TR.Trie<unknown>): number {
-    let hash = Hash.hash(TrieSymbolKey)
-    for (const item of this) {
-      hash ^= pipe(Hash.hash(item[0]), Hash.combine(Hash.hash(item[1])))
-    }
-    return Hash.cached(this, hash)
-  },
-  [Equal.symbol]<V>(this: TrieImpl<V>, that: unknown): boolean {
-    if (isTrie(that)) {
-      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
-  },
-  toString() {
-    return format(this.toJSON())
-  },
-  toJSON() {
-    return {
-      _id: "Trie",
-      values: Array.from(this).map(toJSON)
-    }
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-const makeImpl = <V>(root: Node<V> | undefined): TrieImpl<V> => {
-  const trie = Object.create(TrieProto)
-  trie._root = root
-  trie._count = root?.count ?? 0
-  return trie
-}
-
-class TrieIterator<in out V, out T> implements IterableIterator<T> {
-  stack: Array<[Node<V>, string, boolean]> = []
-
-  constructor(
-    readonly trie: TrieImpl<V>,
-    readonly f: TraversalMap<string, V, T>,
-    readonly filter: TraversalFilter<string, V>
-  ) {
-    const root = trie._root !== undefined ? trie._root : undefined
-    if (root !== undefined) {
-      this.stack.push([root, "", false])
-    }
-  }
-
-  next(): IteratorResult<T> {
-    while (this.stack.length > 0) {
-      const [node, keyString, isAdded] = this.stack.pop()!
-
-      if (isAdded) {
-        const value = node.value
-        if (value !== undefined) {
-          const key = keyString + node.key
-          if (this.filter(key, value)) {
-            return { done: false, value: this.f(key, value) }
-          }
-        }
-      } else {
-        this.addToStack(node, keyString)
-      }
-    }
-
-    return { done: true, value: undefined }
-  }
-
-  addToStack(node: Node<V>, keyString: string) {
-    if (node.right !== undefined) {
-      this.stack.push([node.right, keyString, false])
-    }
-    if (node.mid !== undefined) {
-      this.stack.push([node.mid, keyString + node.key, false])
-    }
-    this.stack.push([node, keyString, true])
-    if (node.left !== undefined) {
-      this.stack.push([node.left, keyString, false])
-    }
-  }
-
-  [Symbol.iterator](): IterableIterator<T> {
-    return new TrieIterator(this.trie, this.f, this.filter)
-  }
-}
-
-/** @internal */
-export const isTrie: {
-  <V>(u: Iterable<readonly [string, V]>): u is TR.Trie<V>
-  (u: unknown): u is TR.Trie<unknown>
-} = (u: unknown): u is TR.Trie<unknown> => hasProperty(u, TrieTypeId)
-
-/** @internal */
-export const empty = <V = never>(): TR.Trie<V> => makeImpl<V>(undefined)
-
-/** @internal */
-export const fromIterable = <V>(entries: Iterable<readonly [string, V]>) => {
-  let trie = empty<V>()
-  for (const [key, value] of entries) {
-    trie = insert(trie, key, value)
-  }
-  return trie
-}
-
-/** @internal */
-export const make = <Entries extends Array<readonly [string, any]>>(...entries: Entries): TR.Trie<
-  Entries[number] extends readonly [any, infer V] ? V : never
-> => {
-  return fromIterable(entries)
-}
-
-/** @internal */
-export const insert = dual<
-  <V>(key: string, value: V) => (self: TR.Trie<V>) => TR.Trie<V>,
-  <V>(self: TR.Trie<V>, key: string, value: V) => TR.Trie<V>
->(3, <V>(self: TR.Trie<V>, key: string, value: V) => {
-  if (key.length === 0) return self
-
-  // -1:left | 0:mid | 1:right
-  const dStack: Array<Ordering.Ordering> = []
-  const nStack: Array<Node<V>> = []
-  let n: Node<V> = (self as TrieImpl<V>)._root ?? {
-    key: key[0],
-    count: 0
-  }
-  const count = n.count + 1
-  let cIndex = 0
-
-  while (cIndex < key.length) {
-    const c = key[cIndex]
-    nStack.push(n)
-    if (c > n.key) {
-      dStack.push(1)
-      if (n.right === undefined) {
-        n = { key: c, count }
-      } else {
-        n = n.right
-      }
-    } else if (c < n.key) {
-      dStack.push(-1)
-      if (n.left === undefined) {
-        n = { key: c, count }
-      } else {
-        n = n.left
-      }
-    } else {
-      if (cIndex === key.length - 1) {
-        n.value = value
-      } else if (n.mid === undefined) {
-        dStack.push(0)
-        n = { key: key[cIndex + 1], count }
-      } else {
-        dStack.push(0)
-        n = n.mid
-      }
-
-      cIndex += 1
-    }
-  }
-
-  // Rebuild path to leaf node (Path-copying immutability)
-  for (let s = nStack.length - 2; s >= 0; --s) {
-    const n2 = nStack[s]
-    const d = dStack[s]
-    if (d === -1) {
-      // left
-      nStack[s] = {
-        key: n2.key,
-        count,
-        value: n2.value,
-        left: nStack[s + 1],
-        mid: n2.mid,
-        right: n2.right
-      }
-    } else if (d === 1) {
-      // right
-      nStack[s] = {
-        key: n2.key,
-        count,
-        value: n2.value,
-        left: n2.left,
-        mid: n2.mid,
-        right: nStack[s + 1]
-      }
-    } else {
-      // mid
-      nStack[s] = {
-        key: n2.key,
-        count,
-        value: n2.value,
-        left: n2.left,
-        mid: nStack[s + 1],
-        right: n2.right
-      }
-    }
-  }
-
-  nStack[0].count = count
-  return makeImpl(nStack[0])
-})
-
-/** @internal */
-export const size = <V>(self: TR.Trie<V>): number => (self as TrieImpl<V>)._root?.count ?? 0
-
-/** @internal */
-export const isEmpty = <V>(self: TR.Trie<V>): boolean => size(self) === 0
-
-/** @internal */
-export const keys = <V>(self: TR.Trie<V>): IterableIterator<string> =>
-  new TrieIterator(self as TrieImpl<V>, (key) => key, () => true)
-
-/** @internal */
-export const values = <V>(self: TR.Trie<V>): IterableIterator<V> =>
-  new TrieIterator(self as TrieImpl<V>, (_, value) => value, () => true)
-
-/** @internal */
-export const entries = <V>(self: TR.Trie<V>): IterableIterator<[string, V]> =>
-  new TrieIterator(self as TrieImpl<V>, (key, value) => [key, value], () => true)
-
-/** @internal */
-export const reduce = dual<
-  <Z, V>(
-    zero: Z,
-    f: (accumulator: Z, value: V, key: string) => Z
-  ) => (self: TR.Trie<V>) => Z,
-  <Z, V>(self: TR.Trie<V>, zero: Z, f: (accumulator: Z, value: V, key: string) => 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 map = dual<
-  <A, V>(f: (value: V, key: string) => A) => (self: TR.Trie<V>) => TR.Trie<A>,
-  <V, A>(self: TR.Trie<V>, f: (value: V, key: string) => A) => TR.Trie<A>
->(2, (self, f) =>
-  reduce(
-    self,
-    empty(),
-    (trie, value, key) => insert(trie, key, f(value, key))
-  ))
-
-/** @internal */
-export const filter: {
-  <A, B extends A>(f: (a: NoInfer<A>, k: string) => a is B): (self: TR.Trie<A>) => TR.Trie<B>
-  <A>(f: (a: NoInfer<A>, k: string) => boolean): (self: TR.Trie<A>) => TR.Trie<A>
-  <A, B extends A>(self: TR.Trie<A>, f: (a: A, k: string) => a is B): TR.Trie<B>
-  <A>(self: TR.Trie<A>, f: (a: A, k: string) => boolean): TR.Trie<A>
-} = dual(
-  2,
-  <A>(self: TR.Trie<A>, f: (a: A, k: string) => boolean): TR.Trie<A> =>
-    reduce(
-      self,
-      empty(),
-      (trie, value, key) => f(value, key) ? insert(trie, key, value) : trie
-    )
-)
-
-/** @internal */
-export const filterMap = dual<
-  <A, B>(
-    f: (value: A, key: string) => Option.Option<B>
-  ) => (self: TR.Trie<A>) => TR.Trie<B>,
-  <A, B>(self: TR.Trie<A>, f: (value: A, key: string) => Option.Option<B>) => TR.Trie<B>
->(2, (self, f) =>
-  reduce(
-    self,
-    empty(),
-    (trie, value, key) => {
-      const option = f(value, key)
-      return Option.isSome(option) ? insert(trie, key, option.value) : trie
-    }
-  ))
-
-/** @internal */
-export const compact = <A>(self: TR.Trie<Option.Option<A>>) => filterMap(self, identity)
-
-/** @internal */
-export const forEach = dual<
-  <V>(f: (value: V, key: string) => void) => (self: TR.Trie<V>) => void,
-  <V>(self: TR.Trie<V>, f: (value: V, key: string) => void) => void
->(2, (self, f) => reduce(self, void 0 as void, (_, value, key) => f(value, key)))
-
-/** @internal */
-export const keysWithPrefix = dual<
-  (prefix: string) => <V>(self: TR.Trie<V>) => IterableIterator<string>,
-  <V>(self: TR.Trie<V>, prefix: string) => IterableIterator<string>
->(
-  2,
-  <V>(self: TR.Trie<V>, prefix: string): IterableIterator<string> =>
-    new TrieIterator(self as TrieImpl<V>, (key) => key, (key) => key.startsWith(prefix))
-)
-
-/** @internal */
-export const valuesWithPrefix = dual<
-  (prefix: string) => <V>(self: TR.Trie<V>) => IterableIterator<V>,
-  <V>(self: TR.Trie<V>, prefix: string) => IterableIterator<V>
->(
-  2,
-  <V>(self: TR.Trie<V>, prefix: string): IterableIterator<V> =>
-    new TrieIterator(self as TrieImpl<V>, (_, value) => value, (key) => key.startsWith(prefix))
-)
-
-/** @internal */
-export const entriesWithPrefix = dual<
-  (prefix: string) => <V>(self: TR.Trie<V>) => IterableIterator<[string, V]>,
-  <V>(self: TR.Trie<V>, prefix: string) => IterableIterator<[string, V]>
->(
-  2,
-  <V>(self: TR.Trie<V>, prefix: string): IterableIterator<[string, V]> =>
-    new TrieIterator(self as TrieImpl<V>, (key, value) => [key, value], (key) => key.startsWith(prefix))
-)
-
-/** @internal */
-export const toEntriesWithPrefix = dual<
-  (prefix: string) => <V>(self: TR.Trie<V>) => Array<[string, V]>,
-  <V>(self: TR.Trie<V>, prefix: string) => Array<[string, V]>
->(
-  2,
-  <V>(self: TR.Trie<V>, prefix: string): Array<[string, V]> => Array.from(entriesWithPrefix(self, prefix))
-)
-
-/** @internal */
-export const get = dual<
-  (key: string) => <V>(self: TR.Trie<V>) => Option.Option<V>,
-  <V>(self: TR.Trie<V>, key: string) => Option.Option<V>
->(
-  2,
-  <V>(self: TR.Trie<V>, key: string) => {
-    let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return Option.none()
-    let cIndex = 0
-    while (cIndex < key.length) {
-      const c = key[cIndex]
-      if (c > n.key) {
-        if (n.right === undefined) {
-          return Option.none()
-        } else {
-          n = n.right
-        }
-      } else if (c < n.key) {
-        if (n.left === undefined) {
-          return Option.none()
-        } else {
-          n = n.left
-        }
-      } else {
-        if (cIndex === key.length - 1) {
-          return Option.fromNullable(n.value)
-        } else {
-          if (n.mid === undefined) {
-            return Option.none()
-          } else {
-            n = n.mid
-            cIndex += 1
-          }
-        }
-      }
-    }
-    return Option.none()
-  }
-)
-
-/** @internal */
-export const has = dual<
-  (key: string) => <V>(self: TR.Trie<V>) => boolean,
-  <V>(self: TR.Trie<V>, key: string) => boolean
->(2, (self, key) => Option.isSome(get(self, key)))
-
-/** @internal */
-export const unsafeGet = dual<
-  (key: string) => <V>(self: TR.Trie<V>) => V,
-  <V>(self: TR.Trie<V>, key: string) => V
->(2, (self, key) => {
-  const element = get(self, key)
-  if (Option.isNone(element)) {
-    throw new Error("Expected trie to contain key")
-  }
-  return element.value
-})
-
-/** @internal */
-export const remove = dual<
-  (key: string) => <V>(self: TR.Trie<V>) => TR.Trie<V>,
-  <V>(self: TR.Trie<V>, key: string) => TR.Trie<V>
->(
-  2,
-  <V>(self: TR.Trie<V>, key: string) => {
-    let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return self
-
-    const count = n.count - 1
-    // -1:left | 0:mid | 1:right
-    const dStack: Array<Ordering.Ordering> = []
-    const nStack: Array<Node<V>> = []
-
-    let cIndex = 0
-    while (cIndex < key.length) {
-      const c = key[cIndex]
-      if (c > n.key) {
-        if (n.right === undefined) {
-          return self
-        } else {
-          nStack.push(n)
-          dStack.push(1)
-          n = n.right
-        }
-      } else if (c < n.key) {
-        if (n.left === undefined) {
-          return self
-        } else {
-          nStack.push(n)
-          dStack.push(-1)
-          n = n.left
-        }
-      } else {
-        if (cIndex === key.length - 1) {
-          if (n.value !== undefined) {
-            nStack.push(n)
-            dStack.push(0)
-            cIndex += 1
-          } else {
-            return self
-          }
-        } else {
-          if (n.mid === undefined) {
-            return self
-          } else {
-            nStack.push(n)
-            dStack.push(0)
-            n = n.mid
-            cIndex += 1
-          }
-        }
-      }
-    }
-
-    const removeNode = nStack[nStack.length - 1]
-    nStack[nStack.length - 1] = {
-      key: removeNode.key,
-      count,
-      left: removeNode.left,
-      mid: removeNode.mid,
-      right: removeNode.right
-    }
-
-    // Rebuild path to leaf node (Path-copying immutability)
-    for (let s = nStack.length - 2; s >= 0; --s) {
-      const n2 = nStack[s]
-      const d = dStack[s]
-      const child = nStack[s + 1]
-      const nc = child.left === undefined && child.mid === undefined && child.right === undefined ? undefined : child
-      if (d === -1) {
-        // left
-        nStack[s] = {
-          key: n2.key,
-          count,
-          value: n2.value,
-          left: nc,
-          mid: n2.mid,
-          right: n2.right
-        }
-      } else if (d === 1) {
-        // right
-        nStack[s] = {
-          key: n2.key,
-          count,
-          value: n2.value,
-          left: n2.left,
-          mid: n2.mid,
-          right: nc
-        }
-      } else {
-        // mid
-        nStack[s] = {
-          key: n2.key,
-          count,
-          value: n2.value,
-          left: n2.left,
-          mid: nc,
-          right: n2.right
-        }
-      }
-    }
-
-    nStack[0].count = count
-    return makeImpl(nStack[0])
-  }
-)
-
-/** @internal */
-export const removeMany = dual<
-  (keys: Iterable<string>) => <V>(self: TR.Trie<V>) => TR.Trie<V>,
-  <V>(self: TR.Trie<V>, keys: Iterable<string>) => TR.Trie<V>
->(2, (self, keys) => {
-  let trie = self
-  for (const key of keys) {
-    trie = remove(key)(trie)
-  }
-  return trie
-})
-
-/** @internal */
-export const insertMany = dual<
-  <V>(iter: Iterable<[string, V]>) => (self: TR.Trie<V>) => TR.Trie<V>,
-  <V>(self: TR.Trie<V>, iter: Iterable<[string, V]>) => TR.Trie<V>
->(2, (self, iter) => {
-  let trie = self
-  for (const [key, value] of iter) {
-    trie = insert(key, value)(trie)
-  }
-  return trie
-})
-
-/** @internal */
-export const modify = dual<
-  <V>(key: string, f: (v: V) => V) => (self: TR.Trie<V>) => TR.Trie<V>,
-  <V>(self: TR.Trie<V>, key: string, f: (v: V) => V) => TR.Trie<V>
->(
-  3,
-  <V>(self: TR.Trie<V>, key: string, f: (v: V) => V): TR.Trie<V> => {
-    let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return self
-
-    // -1:left | 0:mid | 1:right
-    const dStack: Array<Ordering.Ordering> = []
-    const nStack: Array<Node<V>> = []
-
-    let cIndex = 0
-    while (cIndex < key.length) {
-      const c = key[cIndex]
-      if (c > n.key) {
-        if (n.right === undefined) {
-          return self
-        } else {
-          nStack.push(n)
-          dStack.push(1)
-          n = n.right
-        }
-      } else if (c < n.key) {
-        if (n.left === undefined) {
-          return self
-        } else {
-          nStack.push(n)
-          dStack.push(-1)
-          n = n.left
-        }
-      } else {
-        if (cIndex === key.length - 1) {
-          if (n.value !== undefined) {
-            nStack.push(n)
-            dStack.push(0)
-            cIndex += 1
-          } else {
-            return self
-          }
-        } else {
-          if (n.mid === undefined) {
-            return self
-          } else {
-            nStack.push(n)
-            dStack.push(0)
-            n = n.mid
-            cIndex += 1
-          }
-        }
-      }
-    }
-
-    const updateNode = nStack[nStack.length - 1]
-    if (updateNode.value === undefined) {
-      return self
-    }
-
-    nStack[nStack.length - 1] = {
-      key: updateNode.key,
-      count: updateNode.count,
-      value: f(updateNode.value), // Update
-      left: updateNode.left,
-      mid: updateNode.mid,
-      right: updateNode.right
-    }
-
-    // Rebuild path to leaf node (Path-copying immutability)
-    for (let s = nStack.length - 2; s >= 0; --s) {
-      const n2 = nStack[s]
-      const d = dStack[s]
-      const child = nStack[s + 1]
-      if (d === -1) {
-        // left
-        nStack[s] = {
-          key: n2.key,
-          count: n2.count,
-          value: n2.value,
-          left: child,
-          mid: n2.mid,
-          right: n2.right
-        }
-      } else if (d === 1) {
-        // right
-        nStack[s] = {
-          key: n2.key,
-          count: n2.count,
-          value: n2.value,
-          left: n2.left,
-          mid: n2.mid,
-          right: child
-        }
-      } else {
-        // mid
-        nStack[s] = {
-          key: n2.key,
-          count: n2.count,
-          value: n2.value,
-          left: n2.left,
-          mid: child,
-          right: n2.right
-        }
-      }
-    }
-
-    return makeImpl(nStack[0])
-  }
-)
-
-/** @internal */
-export const longestPrefixOf = dual<
-  (key: string) => <V>(self: TR.Trie<V>) => Option.Option<[string, V]>,
-  <V>(self: TR.Trie<V>, key: string) => Option.Option<[string, V]>
->(
-  2,
-  <V>(self: TR.Trie<V>, key: string) => {
-    let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return Option.none()
-    let longestPrefixNode: [string, V] | undefined = undefined
-    let cIndex = 0
-    while (cIndex < key.length) {
-      const c = key[cIndex]
-      if (n.value !== undefined) {
-        longestPrefixNode = [key.slice(0, cIndex + 1), n.value]
-      }
-
-      if (c > n.key) {
-        if (n.right === undefined) {
-          break
-        } else {
-          n = n.right
-        }
-      } else if (c < n.key) {
-        if (n.left === undefined) {
-          break
-        } else {
-          n = n.left
-        }
-      } else {
-        if (n.mid === undefined) {
-          break
-        } else {
-          n = n.mid
-          cIndex += 1
-        }
-      }
-    }
-
-    return Option.fromNullable(longestPrefixNode)
-  }
-)
-
-interface Node<V> {
-  key: string
-  count: number
-  value?: V | undefined
-  left?: Node<V> | undefined
-  mid?: Node<V> | undefined
-  right?: Node<V> | undefined
-}