@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/ModuleVersion.ts

@@ -0,0 +1,18 @@
+/**
+ * @since 2.0.0
+ *
+ * Enables low level framework authors to run on their own isolated effect version
+ */
+import * as internal from "./internal/version.js"
+
+/**
+ * @since 2.0.0
+ * @category version
+ */
+export const getCurrentVersion: () => string = internal.getCurrentVersion
+
+/**
+ * @since 2.0.0
+ * @category version
+ */
+export const setCurrentVersion: (version: string) => void = internal.setCurrentVersion

package/src/MutableHashMap.ts

@@ -0,0 +1,411 @@
+/**
+ * @since 2.0.0
+ */
+import type { NonEmptyArray } from "./Array.js"
+import * as Equal from "./Equal.js"
+import { dual } from "./Function.js"
+import * as Hash from "./Hash.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import * as Option from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
+import { pipeArguments } from "./Pipeable.js"
+
+const TypeId: unique symbol = Symbol.for("effect/MutableHashMap") as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MutableHashMap<out K, out V> extends Iterable<[K, V]>, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+  /** @internal */
+  readonly referential: Map<K, V>
+  /** @internal */
+  readonly buckets: Map<number, NonEmptyArray<readonly [K & Equal.Equal, V]>>
+  /** @internal */
+  bucketsSize: number
+}
+
+const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "referential" | "buckets" | "bucketsSize"> = {
+  [TypeId]: TypeId,
+  [Symbol.iterator](this: MutableHashMap<unknown, unknown>): Iterator<[unknown, unknown]> {
+    return new MutableHashMapIterator(this)
+  },
+  toString() {
+    return format(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "MutableHashMap",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+class MutableHashMapIterator<K, V> implements IterableIterator<[K, V]> {
+  readonly referentialIterator: Iterator<[K, V]>
+  bucketIterator: Iterator<[K, V]> | undefined
+
+  constructor(readonly self: MutableHashMap<K, V>) {
+    this.referentialIterator = self.referential[Symbol.iterator]()
+  }
+  next(): IteratorResult<[K, V]> {
+    if (this.bucketIterator !== undefined) {
+      return this.bucketIterator.next()
+    }
+    const result = this.referentialIterator.next()
+    if (result.done) {
+      this.bucketIterator = new BucketIterator(this.self.buckets.values())
+      return this.next()
+    }
+    return result
+  }
+
+  [Symbol.iterator](): IterableIterator<[K, V]> {
+    return new MutableHashMapIterator(this.self)
+  }
+}
+
+class BucketIterator<K, V> implements Iterator<[K, V]> {
+  constructor(readonly backing: Iterator<NonEmptyArray<readonly [K, V]>>) {}
+  currentBucket: Iterator<readonly [K, V]> | undefined
+  next(): IteratorResult<[K, V]> {
+    if (this.currentBucket === undefined) {
+      const result = this.backing.next()
+      if (result.done) {
+        return result
+      }
+      this.currentBucket = result.value[Symbol.iterator]()
+    }
+    const result = this.currentBucket.next()
+    if (result.done) {
+      this.currentBucket = undefined
+      return this.next()
+    }
+    return result as IteratorResult<[K, V]>
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <K = never, V = never>(): MutableHashMap<K, V> => {
+  const self = Object.create(MutableHashMapProto)
+  self.referential = new Map()
+  self.buckets = new Map()
+  self.bucketsSize = 0
+  return self
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Entries extends Array<readonly [any, any]>>(
+  ...entries: Entries
+) => MutableHashMap<
+  Entries[number] extends readonly [infer K, any] ? K : never,
+  Entries[number] extends readonly [any, infer V] ? V : never
+> = (...entries) => fromIterable(entries)
+
+/**
+ * Creates a new `MutableHashMap` from an iterable collection of key/value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): MutableHashMap<K, V> => {
+  const self = empty<K, V>()
+  for (const [key, value] of entries) {
+    set(self, key, value)
+  }
+  return self
+}
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const get: {
+  <K>(key: K): <V>(self: MutableHashMap<K, V>) => Option.Option<V>
+  <K, V>(self: MutableHashMap<K, V>, key: K): Option.Option<V>
+} = dual<
+  <K>(key: K) => <V>(self: MutableHashMap<K, V>) => Option.Option<V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K) => Option.Option<V>
+>(2, <K, V>(self: MutableHashMap<K, V>, key: K): Option.Option<V> => {
+  if (Equal.isEqual(key) === false) {
+    return self.referential.has(key) ? Option.some(self.referential.get(key)!) : Option.none()
+  }
+
+  const hash = key[Hash.symbol]()
+  const bucket = self.buckets.get(hash)
+  if (bucket === undefined) {
+    return Option.none()
+  }
+
+  return getFromBucket(self, bucket, key)
+})
+
+/**
+ * @since 3.8.0
+ * @category elements
+ */
+export const keys = <K, V>(self: MutableHashMap<K, V>): Array<K> => {
+  const keys = Array.from(self.referential.keys())
+  for (const bucket of self.buckets.values()) {
+    for (let i = 0, len = bucket.length; i < len; i++) {
+      keys.push(bucket[i][0])
+    }
+  }
+  return keys
+}
+
+/**
+ * @since 3.8.0
+ * @category elements
+ */
+export const values = <K, V>(self: MutableHashMap<K, V>): Array<V> => {
+  const values = Array.from(self.referential.values())
+  for (const bucket of self.buckets.values()) {
+    for (let i = 0, len = bucket.length; i < len; i++) {
+      values.push(bucket[i][1])
+    }
+  }
+  return values
+}
+
+const getFromBucket = <K, V>(
+  self: MutableHashMap<K, V>,
+  bucket: NonEmptyArray<readonly [K & Equal.Equal, V]>,
+  key: K & Equal.Equal,
+  remove = false
+): Option.Option<V> => {
+  for (let i = 0, len = bucket.length; i < len; i++) {
+    if (key[Equal.symbol](bucket[i][0])) {
+      const value = bucket[i][1]
+      if (remove) {
+        bucket.splice(i, 1)
+        self.bucketsSize--
+      }
+      return Option.some(value)
+    }
+  }
+
+  return Option.none()
+}
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean
+  <K, V>(self: MutableHashMap<K, V>, key: K): boolean
+} = dual<
+  <K>(key: K) => <V>(self: MutableHashMap<K, V>) => boolean,
+  <K, V>(self: MutableHashMap<K, V>, key: K) => boolean
+>(2, (self, key) => Option.isSome(get(self, key)))
+
+/**
+ * @since 2.0.0
+ */
+export const set: {
+  <K, V>(key: K, value: V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K, value: V): MutableHashMap<K, V>
+} = dual<
+  <K, V>(key: K, value: V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K, value: V) => MutableHashMap<K, V>
+>(3, <K, V>(self: MutableHashMap<K, V>, key: K, value: V) => {
+  if (Equal.isEqual(key) === false) {
+    self.referential.set(key, value)
+    return self
+  }
+
+  const hash = key[Hash.symbol]()
+  const bucket = self.buckets.get(hash)
+  if (bucket === undefined) {
+    self.buckets.set(hash, [[key, value]])
+    self.bucketsSize++
+    return self
+  }
+
+  removeFromBucket(self, bucket, key)
+  bucket.push([key, value])
+  self.bucketsSize++
+  return self
+})
+
+const removeFromBucket = <K, V>(
+  self: MutableHashMap<K, V>,
+  bucket: NonEmptyArray<readonly [K & Equal.Equal, V]>,
+  key: K & Equal.Equal
+) => {
+  for (let i = 0, len = bucket.length; i < len; i++) {
+    if (key[Equal.symbol](bucket[i][0])) {
+      bucket.splice(i, 1)
+      self.bucketsSize--
+      return
+    }
+  }
+}
+
+/**
+ * Updates the value of the specified key within the `MutableHashMap` if it exists.
+ *
+ * @since 2.0.0
+ */
+export const modify: {
+  <K, V>(key: K, f: (v: V) => V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V): MutableHashMap<K, V>
+} = dual<
+  <K, V>(key: K, f: (v: V) => V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => MutableHashMap<K, V>
+>(3, <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => {
+  if (Equal.isEqual(key) === false) {
+    if (self.referential.has(key)) {
+      self.referential.set(key, f(self.referential.get(key)!))
+    }
+    return self
+  }
+
+  const hash = key[Hash.symbol]()
+  const bucket = self.buckets.get(hash)
+  if (bucket === undefined) {
+    return self
+  }
+
+  const value = getFromBucket(self, bucket, key, true)
+  if (Option.isNone(value)) {
+    return self
+  }
+  bucket.push([key, f(value.value)])
+  self.bucketsSize++
+  return self
+})
+
+/**
+ * Set or remove the specified key in the `MutableHashMap` using the specified
+ * update function.
+ *
+ * @since 2.0.0
+ */
+export const modifyAt: {
+  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): MutableHashMap<K, V>
+} = dual<
+  <K, V>(
+    key: K,
+    f: (value: Option.Option<V>) => Option.Option<V>
+  ) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(
+    self: MutableHashMap<K, V>,
+    key: K,
+    f: (value: Option.Option<V>) => Option.Option<V>
+  ) => MutableHashMap<K, V>
+>(3, (self, key, f) => {
+  if (Equal.isEqual(key) === false) {
+    const result = f(get(self, key))
+    if (Option.isSome(result)) {
+      set(self, key, result.value)
+    } else {
+      remove(self, key)
+    }
+    return self
+  }
+
+  const hash = key[Hash.symbol]()
+  const bucket = self.buckets.get(hash)
+  if (bucket === undefined) {
+    const result = f(Option.none())
+    return Option.isSome(result) ? set(self, key, result.value) : self
+  }
+
+  const result = f(getFromBucket(self, bucket, key, true))
+  if (Option.isNone(result)) {
+    if (bucket.length === 0) {
+      self.buckets.delete(hash)
+    }
+    return self
+  }
+  bucket.push([key, result.value])
+  self.bucketsSize++
+  return self
+})
+
+/**
+ * @since 2.0.0
+ */
+export const remove: {
+  <K>(key: K): <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K): MutableHashMap<K, V>
+} = dual<
+  <K>(key: K) => <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K) => MutableHashMap<K, V>
+>(2, <K, V>(self: MutableHashMap<K, V>, key: K) => {
+  if (Equal.isEqual(key) === false) {
+    self.referential.delete(key)
+    return self
+  }
+
+  const hash = key[Hash.symbol]()
+  const bucket = self.buckets.get(hash)
+  if (bucket === undefined) {
+    return self
+  }
+  removeFromBucket(self, bucket, key)
+  if (bucket.length === 0) {
+    self.buckets.delete(hash)
+  }
+  return self
+})
+
+/**
+ * @since 2.0.0
+ */
+export const clear = <K, V>(self: MutableHashMap<K, V>) => {
+  self.referential.clear()
+  self.buckets.clear()
+  self.bucketsSize = 0
+  return self
+}
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const size = <K, V>(self: MutableHashMap<K, V>): number => {
+  return self.referential.size + self.bucketsSize
+}
+
+/**
+ * @since 2.0.0
+ */
+export const isEmpty = <K, V>(self: MutableHashMap<K, V>): boolean => size(self) === 0
+
+/**
+ * @since 2.0.0
+ */
+export const forEach: {
+  <K, V>(f: (value: V, key: K) => void): (self: MutableHashMap<K, V>) => void
+  <K, V>(self: MutableHashMap<K, V>, f: (value: V, key: K) => void): void
+} = dual(2, <K, V>(self: MutableHashMap<K, V>, f: (value: V, key: K) => void) => {
+  self.referential.forEach(f)
+  for (const bucket of self.buckets.values()) {
+    for (const [key, value] of bucket) {
+      f(value, key)
+    }
+  }
+})