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

package/src/internal/stm/tMap.ts

@@ -1,824 +0,0 @@
-import * as RA from "../../Array.js"
-import * as Chunk from "../../Chunk.js"
-import * as Equal from "../../Equal.js"
-import type { LazyArg } from "../../Function.js"
-import { dual, pipe } from "../../Function.js"
-import * as Hash from "../../Hash.js"
-import * as HashMap from "../../HashMap.js"
-import * as Option from "../../Option.js"
-import { hasProperty } from "../../Predicate.js"
-import * as STM from "../../STM.js"
-import type * as TArray from "../../TArray.js"
-import type * as TMap from "../../TMap.js"
-import type * as TRef from "../../TRef.js"
-import * as core from "./core.js"
-import type * as Journal from "./journal.js"
-import * as stm from "./stm.js"
-import * as tArray from "./tArray.js"
-import * as tRef from "./tRef.js"
-
-/** @internal */
-const TMapSymbolKey = "effect/TMap"
-
-/** @internal */
-export const TMapTypeId: TMap.TMapTypeId = Symbol.for(
-  TMapSymbolKey
-) as TMap.TMapTypeId
-
-const tMapVariance = {
-  /* c8 ignore next */
-  _K: (_: any) => _,
-  /* c8 ignore next */
-  _V: (_: any) => _
-}
-
-/** @internal */
-class TMapImpl<in out K, in out V> implements TMap.TMap<K, V> {
-  readonly [TMapTypeId] = tMapVariance
-  constructor(
-    readonly tBuckets: TRef.TRef<TArray.TArray<Chunk.Chunk<readonly [K, V]>>>,
-    readonly tSize: TRef.TRef<number>
-  ) {}
-}
-
-const isTMap = (u: unknown) => hasProperty(u, TMapTypeId)
-
-/** @internal */
-const InitialCapacity = 16
-const LoadFactor = 0.75
-
-/** @internal */
-const nextPowerOfTwo = (size: number): number => {
-  const n = -1 >>> Math.clz32(size - 1)
-  return n < 0 ? 1 : n + 1
-}
-
-/** @internal */
-const hash = <K>(key: K): number => {
-  const h = Hash.hash(key)
-  return h ^ (h >>> 16)
-}
-
-/** @internal */
-const indexOf = <K>(k: K, capacity: number): number => hash(k) & (capacity - 1)
-
-/** @internal */
-const allocate = <K, V>(
-  capacity: number,
-  data: Chunk.Chunk<readonly [K, V]>
-): STM.STM<TMap.TMap<K, V>> => {
-  const buckets = Array.from({ length: capacity }, () => Chunk.empty<readonly [K, V]>())
-  const distinct = new Map<K, V>(data)
-  let size = 0
-  for (const entry of distinct) {
-    const index = indexOf(entry[0], capacity)
-    buckets[index] = pipe(buckets[index], Chunk.prepend(entry))
-    size = size + 1
-  }
-  return pipe(
-    tArray.fromIterable(buckets),
-    core.flatMap((buckets) =>
-      pipe(
-        tRef.make(buckets),
-        core.flatMap((tBuckets) =>
-          pipe(
-            tRef.make(size),
-            core.map((tSize) => new TMapImpl(tBuckets, tSize))
-          )
-        )
-      )
-    )
-  )
-}
-
-/** @internal */
-export const empty = <K, V>(): STM.STM<TMap.TMap<K, V>> => fromIterable<K, V>([])
-
-/** @internal */
-export const find = dual<
-  <K, V, A>(
-    pf: (key: K, value: V) => Option.Option<A>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<Option.Option<A>>,
-  <K, V, A>(
-    self: TMap.TMap<K, V>,
-    pf: (key: K, value: V) => Option.Option<A>
-  ) => STM.STM<Option.Option<A>>
->(2, (self, pf) =>
-  findSTM(self, (key, value) => {
-    const option = pf(key, value)
-    if (Option.isSome(option)) {
-      return core.succeed(option.value)
-    }
-    return core.fail(Option.none())
-  }))
-
-/** @internal */
-export const findSTM = dual<
-  <K, V, A, E, R>(
-    f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<Option.Option<A>, E, R>,
-  <K, V, A, E, R>(
-    self: TMap.TMap<K, V>,
-    f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => STM.STM<Option.Option<A>, E, R>
->(2, <K, V, A, E, R>(
-  self: TMap.TMap<K, V>,
-  f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-) =>
-  reduceSTM(self, Option.none<A>(), (acc, value, key) =>
-    Option.isNone(acc) ?
-      core.matchSTM(f(key, value), {
-        onFailure: Option.match({
-          onNone: () => stm.succeedNone,
-          onSome: core.fail
-        }),
-        onSuccess: stm.succeedSome
-      }) :
-      STM.succeed(acc)))
-
-/** @internal */
-export const findAll = dual<
-  <K, V, A>(
-    pf: (key: K, value: V) => Option.Option<A>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<Array<A>>,
-  <K, V, A>(
-    self: TMap.TMap<K, V>,
-    pf: (key: K, value: V) => Option.Option<A>
-  ) => STM.STM<Array<A>>
->(2, (self, pf) =>
-  findAllSTM(self, (key, value) => {
-    const option = pf(key, value)
-    if (Option.isSome(option)) {
-      return core.succeed(option.value)
-    }
-    return core.fail(Option.none())
-  }))
-
-/** @internal */
-export const findAllSTM = dual<
-  <K, V, A, E, R>(
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<Array<A>, E, R>,
-  <K, V, A, E, R>(
-    self: TMap.TMap<K, V>,
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => STM.STM<Array<A>, E, R>
->(2, <K, V, A, E, R>(
-  self: TMap.TMap<K, V>,
-  pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-) =>
-  core.map(
-    reduceSTM(self, Chunk.empty<A>(), (acc, value, key) =>
-      core.matchSTM(pf(key, value), {
-        onFailure: Option.match({
-          onNone: () => core.succeed(acc),
-          onSome: core.fail
-        }),
-        onSuccess: (a) => core.succeed(Chunk.append(acc, a))
-      })),
-    (a) => Array.from(a)
-  ))
-
-/** @internal */
-export const forEach = dual<
-  <K, V, X, E, R>(f: (key: K, value: V) => STM.STM<X, E, R>) => (self: TMap.TMap<K, V>) => STM.STM<void, E, R>,
-  <K, V, X, E, R>(self: TMap.TMap<K, V>, f: (key: K, value: V) => STM.STM<X, E, R>) => STM.STM<void, E, R>
->(2, (self, f) =>
-  reduceSTM(
-    self,
-    void 0 as void,
-    (_, value, key) => stm.asVoid(f(key, value))
-  ))
-
-/** @internal */
-export const fromIterable = <K, V>(iterable: Iterable<readonly [K, V]>): STM.STM<TMap.TMap<K, V>> =>
-  stm.suspend(() => {
-    const data = Chunk.fromIterable(iterable)
-    const capacity = data.length < InitialCapacity
-      ? InitialCapacity
-      : nextPowerOfTwo(data.length)
-    return allocate(capacity, data)
-  })
-
-/** @internal */
-export const get = dual<
-  <K>(key: K) => <V>(self: TMap.TMap<K, V>) => STM.STM<Option.Option<V>>,
-  <K, V>(self: TMap.TMap<K, V>, key: K) => STM.STM<Option.Option<V>>
->(2, <K, V>(self: TMap.TMap<K, V>, key: K) =>
-  core.effect<never, Option.Option<V>>((journal) => {
-    const buckets = tRef.unsafeGet(self.tBuckets, journal)
-    const index = indexOf(key, buckets.chunk.length)
-    const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-    return pipe(
-      Chunk.findFirst(bucket, (entry) => Equal.equals(entry[0])(key)),
-      Option.map((entry) => entry[1])
-    )
-  }))
-
-/** @internal */
-export const getOrElse = dual<
-  <K, V>(key: K, fallback: LazyArg<V>) => (self: TMap.TMap<K, V>) => STM.STM<V>,
-  <K, V>(self: TMap.TMap<K, V>, key: K, fallback: LazyArg<V>) => STM.STM<V>
->(3, (self, key, fallback) =>
-  core.map(
-    get(self, key),
-    Option.getOrElse(fallback)
-  ))
-
-/** @internal */
-export const has = dual<
-  <K>(key: K) => <V>(self: TMap.TMap<K, V>) => STM.STM<boolean>,
-  <K, V>(self: TMap.TMap<K, V>, key: K) => STM.STM<boolean>
->(2, (self, key) => core.map(get(self, key), Option.isSome))
-
-/** @internal */
-export const isEmpty = <K, V>(self: TMap.TMap<K, V>): STM.STM<boolean> =>
-  core.map(tRef.get(self.tSize), (size) => size === 0)
-
-/** @internal */
-export const keys = <K, V>(self: TMap.TMap<K, V>): STM.STM<Array<K>> =>
-  core.map(toReadonlyArray(self), RA.map((entry) => entry[0]))
-
-/** @internal */
-export const make = <K, V>(...entries: Array<readonly [K, V]>): STM.STM<TMap.TMap<K, V>> => fromIterable(entries)
-
-/** @internal */
-export const merge = dual<
-  <K, V>(key: K, value: V, f: (x: V, y: V) => V) => (self: TMap.TMap<K, V>) => STM.STM<V>,
-  <K, V>(self: TMap.TMap<K, V>, key: K, value: V, f: (x: V, y: V) => V) => STM.STM<V>
->(4, (self, key, value, f) =>
-  core.flatMap(
-    get(self, key),
-    Option.match({
-      onNone: () => stm.as(set(self, key, value), value),
-      onSome: (v0) => {
-        const v1 = f(v0, value)
-        return stm.as(set(self, key, v1), v1)
-      }
-    })
-  ))
-
-/** @internal */
-export const reduce = dual<
-  <Z, K, V>(zero: Z, f: (acc: Z, value: V, key: K) => Z) => (self: TMap.TMap<K, V>) => STM.STM<Z>,
-  <K, V, Z>(self: TMap.TMap<K, V>, zero: Z, f: (acc: Z, value: V, key: K) => Z) => STM.STM<Z>
->(
-  3,
-  <K, V, Z>(self: TMap.TMap<K, V>, zero: Z, f: (acc: Z, value: V, key: K) => Z) =>
-    core.effect<never, Z>((journal) => {
-      const buckets = tRef.unsafeGet(self.tBuckets, journal)
-      let result = zero
-      let index = 0
-      while (index < buckets.chunk.length) {
-        const bucket = buckets.chunk[index]
-        const items = tRef.unsafeGet(bucket, journal)
-        result = Chunk.reduce(items, result, (acc, entry) => f(acc, entry[1], entry[0]))
-        index = index + 1
-      }
-      return result
-    })
-)
-
-/** @internal */
-export const reduceSTM = dual<
-  <Z, V, K, R, E>(
-    zero: Z,
-    f: (acc: Z, value: V, key: K) => STM.STM<Z, E, R>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<Z, E, R>,
-  <Z, V, K, R, E>(
-    self: TMap.TMap<K, V>,
-    zero: Z,
-    f: (acc: Z, value: V, key: K) => STM.STM<Z, E, R>
-  ) => STM.STM<Z, E, R>
->(3, (self, zero, f) =>
-  core.flatMap(
-    toReadonlyArray(self),
-    stm.reduce(zero, (acc, entry) => f(acc, entry[1], entry[0]))
-  ))
-
-/** @internal */
-export const remove = dual<
-  <K>(key: K) => <V>(self: TMap.TMap<K, V>) => STM.STM<void>,
-  <K, V>(self: TMap.TMap<K, V>, key: K) => STM.STM<void>
->(2, (self, key) =>
-  core.effect<never, void>((journal) => {
-    const buckets = tRef.unsafeGet(self.tBuckets, journal)
-    const index = indexOf(key, buckets.chunk.length)
-    const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-    const [toRemove, toRetain] = Chunk.partition(bucket, (entry) => Equal.equals(entry[1], key))
-    if (Chunk.isNonEmpty(toRemove)) {
-      const currentSize = tRef.unsafeGet(self.tSize, journal)
-      tRef.unsafeSet(buckets.chunk[index], toRetain, journal)
-      tRef.unsafeSet(self.tSize, currentSize - 1, journal)
-    }
-  }))
-
-/** @internal */
-export const removeAll = dual<
-  <K>(keys: Iterable<K>) => <V>(self: TMap.TMap<K, V>) => STM.STM<void>,
-  <K, V>(self: TMap.TMap<K, V>, keys: Iterable<K>) => STM.STM<void>
->(2, <K, V>(self: TMap.TMap<K, V>, keys: Iterable<K>) =>
-  core.effect<never, void>((journal) => {
-    const iterator = keys[Symbol.iterator]()
-    let next: IteratorResult<K, any>
-    while ((next = iterator.next()) && !next.done) {
-      const buckets = tRef.unsafeGet(self.tBuckets, journal)
-      const index = indexOf(next.value, buckets.chunk.length)
-      const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-      const [toRemove, toRetain] = Chunk.partition(bucket, (entry) => Equal.equals(next.value)(entry[0]))
-      if (Chunk.isNonEmpty(toRemove)) {
-        const currentSize = tRef.unsafeGet(self.tSize, journal)
-        tRef.unsafeSet(buckets.chunk[index], toRetain, journal)
-        tRef.unsafeSet(self.tSize, currentSize - 1, journal)
-      }
-    }
-  }))
-
-/** @internal */
-export const removeIf: {
-  <K, V>(
-    predicate: (key: K, value: V) => boolean,
-    options: {
-      readonly discard: true
-    }
-  ): (self: TMap.TMap<K, V>) => STM.STM<void>
-  <K, V>(
-    predicate: (key: K, value: V) => boolean,
-    options?: {
-      readonly discard: false
-    }
-  ): (self: TMap.TMap<K, V>) => STM.STM<Array<[K, V]>>
-  <K, V>(
-    self: TMap.TMap<K, V>,
-    predicate: (key: K, value: V) => boolean,
-    options: {
-      readonly discard: true
-    }
-  ): STM.STM<void>
-  <K, V>(
-    self: TMap.TMap<K, V>,
-    predicate: (key: K, value: V) => boolean,
-    options?: {
-      readonly discard: false
-    }
-  ): STM.STM<Array<[K, V]>>
-} = dual((args) => isTMap(args[0]), <K, V>(
-  self: TMap.TMap<K, V>,
-  predicate: (key: K, value: V) => boolean,
-  options?: {
-    readonly discard: boolean
-  }
-) =>
-  core.effect((journal) => {
-    const discard = options?.discard === true
-    const buckets = tRef.unsafeGet(self.tBuckets, journal)
-    const capacity = buckets.chunk.length
-    const removed: Array<[K, V]> = []
-    let index = 0
-    let newSize = 0
-    while (index < capacity) {
-      const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-      const iterator = bucket[Symbol.iterator]()
-      let next: IteratorResult<readonly [K, V], any>
-      let newBucket = Chunk.empty<readonly [K, V]>()
-      while ((next = iterator.next()) && !next.done) {
-        const [k, v] = next.value
-        if (!predicate(k, v)) {
-          newBucket = Chunk.prepend(newBucket, next.value)
-          newSize = newSize + 1
-        } else {
-          if (!discard) {
-            removed.push([k, v])
-          }
-        }
-      }
-      tRef.unsafeSet(buckets.chunk[index], newBucket, journal)
-      index = index + 1
-    }
-    tRef.unsafeSet(self.tSize, newSize, journal)
-    if (!discard) {
-      return removed
-    }
-  }))
-
-/** @internal */
-export const retainIf: {
-  <K, V>(
-    predicate: (key: K, value: V) => boolean,
-    options: {
-      readonly discard: true
-    }
-  ): (self: TMap.TMap<K, V>) => STM.STM<void>
-  <K, V>(
-    predicate: (key: K, value: V) => boolean,
-    options?: {
-      readonly discard: false
-    }
-  ): (self: TMap.TMap<K, V>) => STM.STM<Array<[K, V]>>
-  <K, V>(
-    self: TMap.TMap<K, V>,
-    predicate: (key: K, value: V) => boolean,
-    options: {
-      readonly discard: true
-    }
-  ): STM.STM<void>
-  <K, V>(
-    self: TMap.TMap<K, V>,
-    predicate: (key: K, value: V) => boolean,
-    options?: {
-      readonly discard: false
-    }
-  ): STM.STM<Array<[K, V]>>
-} = dual(
-  (args) => isTMap(args[0]),
-  (self, predicate, options) => removeIf(self, (key, value) => !predicate(key, value), options)
-)
-
-/** @internal */
-export const set = dual<
-  <K, V>(key: K, value: V) => (self: TMap.TMap<K, V>) => STM.STM<void>,
-  <K, V>(self: TMap.TMap<K, V>, key: K, value: V) => STM.STM<void>
->(3, <K, V>(self: TMap.TMap<K, V>, key: K, value: V) => {
-  const resize = (journal: Journal.Journal, buckets: TArray.TArray<Chunk.Chunk<readonly [K, V]>>): void => {
-    const capacity = buckets.chunk.length
-    const newCapacity = capacity << 1
-    const newBuckets = Array.from({ length: newCapacity }, () => Chunk.empty<readonly [K, V]>())
-    let index = 0
-    while (index < capacity) {
-      const pairs = tRef.unsafeGet(buckets.chunk[index], journal)
-      const iterator = pairs[Symbol.iterator]()
-      let next: IteratorResult<readonly [K, V], any>
-      while ((next = iterator.next()) && !next.done) {
-        const newIndex = indexOf(next.value[0], newCapacity)
-        newBuckets[newIndex] = Chunk.prepend(newBuckets[newIndex], next.value)
-      }
-      index = index + 1
-    }
-    // insert new pair
-    const newIndex = indexOf(key, newCapacity)
-    newBuckets[newIndex] = Chunk.prepend(newBuckets[newIndex], [key, value] as const)
-
-    const newArray: Array<TRef.TRef<Chunk.Chunk<readonly [K, V]>>> = []
-    index = 0
-    while (index < newCapacity) {
-      newArray[index] = new tRef.TRefImpl(newBuckets[index])
-      index = index + 1
-    }
-    const newTArray: TArray.TArray<Chunk.Chunk<readonly [K, V]>> = new tArray.TArrayImpl(newArray)
-    tRef.unsafeSet(self.tBuckets, newTArray, journal)
-  }
-  return core.effect<never, void>((journal) => {
-    const buckets = tRef.unsafeGet(self.tBuckets, journal)
-    const capacity = buckets.chunk.length
-    const index = indexOf(key, capacity)
-    const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-    const shouldUpdate = Chunk.some(bucket, (entry) => Equal.equals(key)(entry[0]))
-    if (shouldUpdate) {
-      const newBucket = Chunk.map(bucket, (entry) =>
-        Equal.equals(key)(entry[0]) ?
-          [key, value] as const :
-          entry)
-      tRef.unsafeSet(buckets.chunk[index], newBucket, journal)
-    } else {
-      const newSize = tRef.unsafeGet(self.tSize, journal) + 1
-      tRef.unsafeSet(self.tSize, newSize, journal)
-      if (capacity * LoadFactor < newSize) {
-        resize(journal, buckets)
-      } else {
-        const newBucket = Chunk.prepend(bucket, [key, value] as const)
-        tRef.unsafeSet(buckets.chunk[index], newBucket, journal)
-      }
-    }
-  })
-})
-
-/** @internal */
-export const setIfAbsent = dual<
-  <K, V>(key: K, value: V) => (self: TMap.TMap<K, V>) => STM.STM<void>,
-  <K, V>(self: TMap.TMap<K, V>, key: K, value: V) => STM.STM<void>
->(3, (self, key, value) =>
-  core.flatMap(
-    get(self, key),
-    Option.match({
-      onNone: () => set(self, key, value),
-      onSome: () => stm.void
-    })
-  ))
-
-/** @internal */
-export const size = <K, V>(self: TMap.TMap<K, V>): STM.STM<number> => tRef.get(self.tSize)
-
-/** @internal */
-export const takeFirst = dual<
-  <K, V, A>(pf: (key: K, value: V) => Option.Option<A>) => (self: TMap.TMap<K, V>) => STM.STM<A>,
-  <K, V, A>(self: TMap.TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>) => STM.STM<A>
->(2, <K, V, A>(self: TMap.TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>) =>
-  pipe(
-    core.effect<never, Option.Option<A>>((journal) => {
-      const buckets = tRef.unsafeGet(self.tBuckets, journal)
-      const capacity = buckets.chunk.length
-      const size = tRef.unsafeGet(self.tSize, journal)
-      let result: Option.Option<A> = Option.none()
-      let index = 0
-      while (index < capacity && Option.isNone(result)) {
-        const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-        const recreate = Chunk.some(bucket, (entry) => Option.isSome(pf(entry[0], entry[1])))
-        if (recreate) {
-          const iterator = bucket[Symbol.iterator]()
-          let newBucket = Chunk.empty<readonly [K, V]>()
-          let next: IteratorResult<readonly [K, V], any>
-          while ((next = iterator.next()) && !next.done && Option.isNone(result)) {
-            const option = pf(next.value[0], next.value[1])
-            if (Option.isSome(option) && Option.isNone(result)) {
-              result = option
-            } else {
-              newBucket = Chunk.prepend(newBucket, next.value)
-            }
-          }
-          tRef.unsafeSet(buckets.chunk[index], newBucket, journal)
-        }
-        index = index + 1
-      }
-      if (Option.isSome(result)) {
-        tRef.unsafeSet(self.tSize, size - 1, journal)
-      }
-      return result
-    }),
-    stm.collect((option) =>
-      Option.isSome(option) ?
-        Option.some(option.value) :
-        Option.none<A>()
-    )
-  ))
-
-/** @internal */
-export const takeFirstSTM = dual<
-  <K, V, A, E, R>(
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<A, E, R>,
-  <K, V, A, E, R>(self: TMap.TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>) => STM.STM<A, E, R>
->(2, (self, pf) =>
-  pipe(
-    findSTM(self, (key, value) => core.map(pf(key, value), (a) => [key, a] as const)),
-    stm.collect((option) => Option.isSome(option) ? Option.some(option.value) : Option.none()),
-    core.flatMap((entry) => stm.as(remove(self, entry[0]), entry[1]))
-  ))
-
-/** @internal */
-export const takeSome = dual<
-  <K, V, A>(
-    pf: (key: K, value: V) => Option.Option<A>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<RA.NonEmptyArray<A>>,
-  <K, V, A>(
-    self: TMap.TMap<K, V>,
-    pf: (key: K, value: V) => Option.Option<A>
-  ) => STM.STM<RA.NonEmptyArray<A>>
->(2, <K, V, A>(self: TMap.TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>) =>
-  pipe(
-    core.effect<never, Option.Option<RA.NonEmptyArray<A>>>((journal) => {
-      const buckets = tRef.unsafeGet(self.tBuckets, journal)
-      const capacity = buckets.chunk.length
-      const builder: Array<A> = []
-      let newSize = 0
-      let index = 0
-      while (index < capacity) {
-        const bucket = tRef.unsafeGet(buckets.chunk[index], journal)
-        const recreate = Chunk.some(bucket, (entry) => Option.isSome(pf(entry[0], entry[1])))
-        if (recreate) {
-          const iterator = bucket[Symbol.iterator]()
-          let newBucket = Chunk.empty<readonly [K, V]>()
-          let next: IteratorResult<readonly [K, V], any>
-          while ((next = iterator.next()) && !next.done) {
-            const option = pf(next.value[0], next.value[1])
-            if (Option.isSome(option)) {
-              builder.push(option.value)
-            } else {
-              newBucket = Chunk.prepend(newBucket, next.value)
-              newSize = newSize + 1
-            }
-          }
-          tRef.unsafeSet(buckets.chunk[index], newBucket, journal)
-        } else {
-          newSize = newSize + bucket.length
-        }
-        index = index + 1
-      }
-      tRef.unsafeSet(self.tSize, newSize, journal)
-      if (builder.length > 0) {
-        return Option.some(builder as RA.NonEmptyArray<A>)
-      }
-      return Option.none()
-    }),
-    stm.collect((option) =>
-      Option.isSome(option) ?
-        Option.some(option.value) :
-        Option.none<RA.NonEmptyArray<A>>()
-    )
-  ))
-
-/** @internal */
-export const takeSomeSTM = dual<
-  <K, V, A, E, R>(
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<RA.NonEmptyArray<A>, E, R>,
-  <K, V, A, E, R>(
-    self: TMap.TMap<K, V>,
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ) => STM.STM<RA.NonEmptyArray<A>, E, R>
->(2, <K, V, A, E, R>(
-  self: TMap.TMap<K, V>,
-  pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-) =>
-  pipe(
-    findAllSTM(
-      self,
-      (key, value) => core.map(pf(key, value), (a) => [key, a] as const)
-    ),
-    core.map((chunk) =>
-      RA.isNonEmptyArray(chunk) ?
-        Option.some(chunk) :
-        Option.none()
-    ),
-    stm.collect((option) =>
-      Option.isSome(option) ?
-        Option.some(option.value) :
-        Option.none()
-    ),
-    core.flatMap((entries) =>
-      stm.as(
-        removeAll(self, entries.map((entry) => entry[0])),
-        RA.map(entries, (entry) => entry[1]) as RA.NonEmptyArray<A>
-      )
-    )
-  ))
-
-const toReadonlyArray = <K, V>(self: TMap.TMap<K, V>): STM.STM<ReadonlyArray<readonly [K, V]>> =>
-  core.effect<never, Array<readonly [K, V]>>((journal) => {
-    const buckets = tRef.unsafeGet(self.tBuckets, journal)
-    const capacity = buckets.chunk.length
-    const builder: Array<readonly [K, V]> = []
-    let index = 0
-    while (index < capacity) {
-      const bucket = buckets.chunk[index]
-      for (const entry of tRef.unsafeGet(bucket, journal)) {
-        builder.push(entry)
-      }
-      index = index + 1
-    }
-    return builder
-  })
-
-/** @internal */
-export const toChunk = <K, V>(self: TMap.TMap<K, V>): STM.STM<Chunk.Chunk<[K, V]>> =>
-  reduce(
-    self,
-    Chunk.empty<[K, V]>(),
-    (acc, value, key) => Chunk.append(acc, [key, value])
-  )
-
-/** @internal */
-export const toHashMap = <K, V>(self: TMap.TMap<K, V>): STM.STM<HashMap.HashMap<K, V>> =>
-  reduce(
-    self,
-    HashMap.empty<K, V>(),
-    (acc, value, key) => pipe(acc, HashMap.set(key, value))
-  )
-
-/** @internal */
-export const toArray = <K, V>(self: TMap.TMap<K, V>): STM.STM<Array<[K, V]>> =>
-  reduce(
-    self,
-    [] as Array<[K, V]>,
-    (acc, value, key) => {
-      acc.unshift([key, value])
-      return acc
-    }
-  )
-
-/** @internal */
-export const toMap = <K, V>(self: TMap.TMap<K, V>): STM.STM<Map<K, V>> =>
-  reduce(
-    self,
-    new Map<K, V>(),
-    (acc, value, key) => acc.set(key, value)
-  )
-
-/** @internal */
-export const transform = dual<
-  <K, V>(f: (key: K, value: V) => readonly [K, V]) => (self: TMap.TMap<K, V>) => STM.STM<void>,
-  <K, V>(self: TMap.TMap<K, V>, f: (key: K, value: V) => readonly [K, V]) => STM.STM<void>
->(
-  2,
-  <K, V>(self: TMap.TMap<K, V>, f: (key: K, value: V) => readonly [K, V]) =>
-    core.effect<never, void>((journal) => {
-      const buckets = pipe(self.tBuckets, tRef.unsafeGet(journal))
-      const capacity = buckets.chunk.length
-      const newBuckets = Array.from({ length: capacity }, () => Chunk.empty<readonly [K, V]>())
-      let newSize = 0
-      let index = 0
-      while (index < capacity) {
-        const bucket = buckets.chunk[index]
-        const pairs = tRef.unsafeGet(bucket, journal)
-        const iterator = pairs[Symbol.iterator]()
-        let next: IteratorResult<readonly [K, V], any>
-        while ((next = iterator.next()) && !next.done) {
-          const newPair = f(next.value[0], next.value[1])
-          const index = indexOf(newPair[0], capacity)
-          const newBucket = newBuckets[index]
-          if (!Chunk.some(newBucket, (entry) => Equal.equals(entry[0], newPair[0]))) {
-            newBuckets[index] = Chunk.prepend(newBucket, newPair)
-            newSize = newSize + 1
-          }
-        }
-        index = index + 1
-      }
-      index = 0
-      while (index < capacity) {
-        tRef.unsafeSet(buckets.chunk[index], newBuckets[index], journal)
-        index = index + 1
-      }
-      tRef.unsafeSet(self.tSize, newSize, journal)
-    })
-)
-
-/** @internal */
-export const transformSTM = dual<
-  <K, V, R, E>(
-    f: (key: K, value: V) => STM.STM<readonly [K, V], E, R>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<void, E, R>,
-  <K, V, R, E>(self: TMap.TMap<K, V>, f: (key: K, value: V) => STM.STM<readonly [K, V], E, R>) => STM.STM<void, E, R>
->(
-  2,
-  <K, V, R, E>(self: TMap.TMap<K, V>, f: (key: K, value: V) => STM.STM<readonly [K, V], E, R>) =>
-    pipe(
-      core.flatMap(
-        toReadonlyArray(self),
-        stm.forEach((entry) => f(entry[0], entry[1]))
-      ),
-      core.flatMap((newData) =>
-        core.effect<never, void>((journal) => {
-          const buckets = tRef.unsafeGet(self.tBuckets, journal)
-          const capacity = buckets.chunk.length
-          const newBuckets = Array.from({ length: capacity }, () => Chunk.empty<readonly [K, V]>())
-          const iterator = newData[Symbol.iterator]()
-          let newSize = 0
-          let next: IteratorResult<readonly [K, V], any>
-          while ((next = iterator.next()) && !next.done) {
-            const index = indexOf(next.value[0], capacity)
-            const newBucket = newBuckets[index]
-            if (!Chunk.some(newBucket, (entry) => Equal.equals(entry[0])(next.value[0]))) {
-              newBuckets[index] = Chunk.prepend(newBucket, next.value)
-              newSize = newSize + 1
-            }
-          }
-          let index = 0
-          while (index < capacity) {
-            tRef.unsafeSet(buckets.chunk[index], newBuckets[index], journal)
-            index = index + 1
-          }
-          tRef.unsafeSet(self.tSize, newSize, journal)
-        })
-      )
-    )
-)
-
-/** @internal */
-export const transformValues = dual<
-  <V>(f: (value: V) => V) => <K>(self: TMap.TMap<K, V>) => STM.STM<void>,
-  <K, V>(self: TMap.TMap<K, V>, f: (value: V) => V) => STM.STM<void>
->(2, (self, f) => transform(self, (key, value) => [key, f(value)]))
-
-/** @internal */
-export const transformValuesSTM = dual<
-  <V, R, E>(f: (value: V) => STM.STM<V, E, R>) => <K>(self: TMap.TMap<K, V>) => STM.STM<void, E, R>,
-  <K, V, R, E>(self: TMap.TMap<K, V>, f: (value: V) => STM.STM<V, E, R>) => STM.STM<void, E, R>
->(2, (self, f) =>
-  transformSTM(
-    self,
-    (key, value) => core.map(f(value), (value) => [key, value])
-  ))
-
-/** @internal */
-export const updateWith = dual<
-  <K, V>(
-    key: K,
-    f: (value: Option.Option<V>) => Option.Option<V>
-  ) => (self: TMap.TMap<K, V>) => STM.STM<Option.Option<V>>,
-  <K, V>(
-    self: TMap.TMap<K, V>,
-    key: K,
-    f: (value: Option.Option<V>) => Option.Option<V>
-  ) => STM.STM<Option.Option<V>>
->(3, (self, key, f) =>
-  core.flatMap(get(self, key), (option) =>
-    Option.match(
-      f(option),
-      {
-        onNone: () => stm.as(remove(self, key), Option.none()),
-        onSome: (value) => stm.as(set(self, key, value), Option.some(value))
-      }
-    )))
-
-/** @internal */
-export const values = <K, V>(self: TMap.TMap<K, V>): STM.STM<Array<V>> =>
-  core.map(toReadonlyArray(self), RA.map((entry) => entry[1]))