Lorem Ipsum MCP Server

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]))