effect 2.0.0-next.57 → 2.0.0-next.59

package/src/Metric.ts

@@ -1,11 +1,9 @@
 /**
  * @since 2.0.0
  */
-import type * as Chunk from "./Chunk.js"
 import type * as Duration from "./Duration.js"
 import type * as Effect from "./Effect.js"
 import type { LazyArg } from "./Function.js"
-import type * as HashSet from "./HashSet.js"
 import * as fiberRuntime from "./internal/fiberRuntime.js"
 import * as internal from "./internal/metric.js"
 import type * as MetricBoundaries from "./MetricBoundaries.js"
@@ -56,8 +54,8 @@ export interface Metric<in out Type, in In, out Out> extends Metric.Variance<Typ
    * `MetricKeyType.Counter` or `MetricKeyType.Gauge`.
    */
   readonly keyType: Type
-  unsafeUpdate(input: In, extraTags: HashSet.HashSet<MetricLabel.MetricLabel>): void
-  unsafeValue(extraTags: HashSet.HashSet<MetricLabel.MetricLabel>): Out
+  unsafeUpdate(input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>): void
+  unsafeValue(extraTags: ReadonlyArray<MetricLabel.MetricLabel>): Out
   register(): this
   <R, E, A extends In>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
 }
@@ -69,8 +67,8 @@ export interface Metric<in out Type, in In, out Out> extends Metric.Variance<Typ
 export interface MetricApply {
   <Type, In, Out>(
     keyType: Type,
-    unsafeUpdate: (input: In, extraTags: HashSet.HashSet<MetricLabel.MetricLabel>) => void,
-    unsafeValue: (extraTags: HashSet.HashSet<MetricLabel.MetricLabel>) => Out
+    unsafeUpdate: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void,
+    unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out
   ): Metric<Type, In, Out>
 }
 
@@ -357,7 +355,7 @@ export const set: {
  * @since 2.0.0
  * @category getters
  */
-export const snapshot: Effect.Effect<never, never, HashSet.HashSet<MetricPair.MetricPair.Untyped>> = internal.snapshot
+export const snapshot: Effect.Effect<never, never, ReadonlyArray<MetricPair.MetricPair.Untyped>> = internal.snapshot
 
 /**
  * Creates a metric that ignores input and produces constant output.
@@ -396,7 +394,7 @@ export const sync: <Out>(evaluate: LazyArg<Out>) => Metric<void, unknown, Out> =
  *   maxAge: "60 seconds", // Retain observations for 60 seconds.
  *   maxSize: 1000, // Keep a maximum of 1000 observations.
  *   error: 0.01, // Allow a 1% error when calculating quantiles.
- *   quantiles: Chunk.make(0.5, 0.9, 0.99), // Calculate 50th, 90th, and 99th percentiles.
+ *   quantiles: [0.5, 0.9, 0.99], // Calculate 50th, 90th, and 99th percentiles.
  *   description: "Measures the distribution of response times."
  * });
  *
@@ -409,7 +407,7 @@ export const summary: (
     readonly maxAge: Duration.DurationInput
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
     readonly description?: string | undefined
   }
 ) => Metric.Summary<number> = internal.summary
@@ -424,7 +422,7 @@ export const summaryTimestamp: (
     readonly maxAge: Duration.DurationInput
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
     readonly description?: string | undefined
   }
 ) => Metric.Summary<readonly [value: number, timestamp: number]> // readonly because contravariant
@@ -498,7 +496,7 @@ export const timer: (
  */
 export const timerWithBoundaries: (
   name: string,
-  boundaries: Chunk.Chunk<number>,
+  boundaries: ReadonlyArray<number>,
   description?: string
 ) => Metric<MetricKeyType.MetricKeyType.Histogram, Duration.Duration, MetricState.MetricState.Histogram> =
   internal.timerWithBoundaries
@@ -723,7 +721,7 @@ export const zip: {
  * @since 2.0.0
  * @category unsafe
  */
-export const unsafeSnapshot: (_: void) => HashSet.HashSet<MetricPair.MetricPair.Untyped> = internal.unsafeSnapshot
+export const unsafeSnapshot: (_: void) => ReadonlyArray<MetricPair.MetricPair.Untyped> = internal.unsafeSnapshot
 
 /**
  * @since 2.0.0

package/src/MetricBoundaries.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-import type * as Chunk from "./Chunk.js"
 import type * as Equal from "./Equal.js"
 import * as internal from "./internal/metric/boundaries.js"
 import type { Pipeable } from "./Pipeable.js"
@@ -24,7 +23,7 @@ export type MetricBoundariesTypeId = typeof MetricBoundariesTypeId
  */
 export interface MetricBoundaries extends Equal.Equal, Pipeable {
   readonly [MetricBoundariesTypeId]: MetricBoundariesTypeId
-  readonly values: Chunk.Chunk<number>
+  readonly values: ReadonlyArray<number>
 }
 
 /**
@@ -37,7 +36,7 @@ export const isMetricBoundaries: (u: unknown) => u is MetricBoundaries = interna
  * @since 2.0.0
  * @category constructors
  */
-export const fromChunk: (chunk: Chunk.Chunk<number>) => MetricBoundaries = internal.fromChunk
+export const fromIterable: (iterable: Iterable<number>) => MetricBoundaries = internal.fromIterable
 
 /**
  * A helper method to create histogram bucket boundaries for a histogram

package/src/MetricKey.ts

@@ -1,10 +1,8 @@
 /**
  * @since 2.0.0
  */
-import type * as Chunk from "./Chunk.js"
 import type * as Duration from "./Duration.js"
 import type * as Equal from "./Equal.js"
-import type * as HashSet from "./HashSet.js"
 import * as internal from "./internal/metric/key.js"
 import type * as MetricBoundaries from "./MetricBoundaries.js"
 import type * as MetricKeyType from "./MetricKeyType.js"
@@ -41,7 +39,7 @@ export interface MetricKey<out Type extends MetricKeyType.MetricKeyType<any, any
   readonly name: string
   readonly keyType: Type
   readonly description: Option.Option<string>
-  readonly tags: HashSet.HashSet<MetricLabel.MetricLabel>
+  readonly tags: ReadonlyArray<MetricLabel.MetricLabel>
 }
 
 /**
@@ -178,7 +176,7 @@ export const summary: (
     readonly maxAge: Duration.DurationInput
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
     readonly description?: string | undefined
   }
 ) => MetricKey.Summary = internal.summary
@@ -209,26 +207,10 @@ export const tagged: {
  */
 export const taggedWithLabels: {
   (
-    extraTags: Iterable<MetricLabel.MetricLabel>
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
   ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
   <Type extends MetricKeyType.MetricKeyType<any, any>>(
     self: MetricKey<Type>,
-    extraTags: Iterable<MetricLabel.MetricLabel>
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
   ): MetricKey<Type>
 } = internal.taggedWithLabels
-
-/**
- * Returns a new `MetricKey` with the specified tags appended.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const taggedWithLabelSet: {
-  (
-    extraTags: HashSet.HashSet<MetricLabel.MetricLabel>
-  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey<Type>,
-    extraTags: HashSet.HashSet<MetricLabel.MetricLabel>
-  ): MetricKey<Type>
-} = internal.taggedWithLabelSet

package/src/MetricKeyType.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-import type * as Chunk from "./Chunk.js"
 import type * as Duration from "./Duration.js"
 import type * as Equal from "./Equal.js"
 import * as internal from "./internal/metric/keyType.js"
@@ -143,7 +142,7 @@ export declare namespace MetricKeyType {
     readonly maxAge: Duration.Duration
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
   }
 
   /**
@@ -217,7 +216,7 @@ export const summary: (
     readonly maxAge: Duration.DurationInput
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
   }
 ) => MetricKeyType.Summary = internal.summary
 

package/src/MetricRegistry.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-import type * as HashSet from "./HashSet.js"
 import * as internal from "./internal/metric/registry.js"
 import type * as MetricHook from "./MetricHook.js"
 import type * as MetricKey from "./MetricKey.js"
@@ -26,7 +25,7 @@ export type MetricRegistryTypeId = typeof MetricRegistryTypeId
  */
 export interface MetricRegistry {
   readonly [MetricRegistryTypeId]: MetricRegistryTypeId
-  snapshot(): HashSet.HashSet<MetricPair.MetricPair.Untyped>
+  snapshot(): ReadonlyArray<MetricPair.MetricPair.Untyped>
   get<Type extends MetricKeyType.MetricKeyType<any, any>>(
     key: MetricKey.MetricKey<Type>
   ): MetricHook.MetricHook<

package/src/MetricState.ts

@@ -1,9 +1,7 @@
 /**
  * @since 2.0.0
  */
-import type * as Chunk from "./Chunk.js"
 import type * as Equal from "./Equal.js"
-import type * as HashMap from "./HashMap.js"
 import * as internal from "./internal/metric/state.js"
 import type * as MetricKeyType from "./MetricKeyType.js"
 import type * as Option from "./Option.js"
@@ -119,7 +117,7 @@ export declare namespace MetricState {
    */
   export interface Frequency extends MetricState<MetricKeyType.MetricKeyType.Frequency> {
     readonly [FrequencyStateTypeId]: FrequencyStateTypeId
-    readonly occurrences: HashMap.HashMap<string, number>
+    readonly occurrences: ReadonlyMap<string, number>
   }
 
   /**
@@ -137,7 +135,7 @@ export declare namespace MetricState {
    */
   export interface Histogram extends MetricState<MetricKeyType.MetricKeyType.Histogram> {
     readonly [HistogramStateTypeId]: HistogramStateTypeId
-    readonly buckets: Chunk.Chunk<readonly [number, number]>
+    readonly buckets: ReadonlyArray<readonly [number, number]>
     readonly count: number
     readonly min: number
     readonly max: number
@@ -151,7 +149,7 @@ export declare namespace MetricState {
   export interface Summary extends MetricState<MetricKeyType.MetricKeyType.Summary> {
     readonly [SummaryStateTypeId]: SummaryStateTypeId
     readonly error: number
-    readonly quantiles: Chunk.Chunk<readonly [number, Option.Option<number>]>
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
     readonly count: number
     readonly min: number
     readonly max: number
@@ -182,7 +180,7 @@ export const counter: {
  * @since 2.0.0
  * @category constructors
  */
-export const frequency: (occurrences: HashMap.HashMap<string, number>) => MetricState.Frequency = internal.frequency
+export const frequency: (occurrences: ReadonlyMap<string, number>) => MetricState.Frequency = internal.frequency
 
 /**
  * @since 2.0.0
@@ -199,7 +197,7 @@ export const gauge: {
  */
 export const histogram: (
   options: {
-    readonly buckets: Chunk.Chunk<readonly [number, number]>
+    readonly buckets: ReadonlyArray<readonly [number, number]>
     readonly count: number
     readonly min: number
     readonly max: number
@@ -214,7 +212,7 @@ export const histogram: (
 export const summary: (
   options: {
     readonly error: number
-    readonly quantiles: Chunk.Chunk<readonly [number, Option.Option<number>]>
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
     readonly count: number
     readonly min: number
     readonly max: number

package/src/MutableHashMap.ts

@@ -1,13 +1,14 @@
 /**
  * @since 2.0.0
  */
-import * as Dual from "./Function.js"
-import * as HashMap from "./HashMap.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 MutableRef from "./MutableRef.js"
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
+import type { NonEmptyArray } from "./ReadonlyArray.js"
 
 const TypeId: unique symbol = Symbol.for("effect/MutableHashMap") as TypeId
 
@@ -23,15 +24,18 @@ export type TypeId = typeof TypeId
  */
 export interface MutableHashMap<out K, out V> extends Iterable<[K, V]>, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
-
   /** @internal */
-  readonly backingMap: MutableRef.MutableRef<HashMap.HashMap<K, V>>
+  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>, "backingMap"> = {
+const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "referential" | "buckets" | "bucketsSize"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashMap<unknown, unknown>): Iterator<[unknown, unknown]> {
-    return this.backingMap.current[Symbol.iterator]()
+    return new MutableHashMapIterator(this)
   },
   toString() {
     return format(this.toJSON())
@@ -50,17 +54,61 @@ const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "backingMap">
   }
 }
 
-const fromHashMap = <K, V>(backingMap: HashMap.HashMap<K, V>): MutableHashMap<K, V> => {
-  const map = Object.create(MutableHashMapProto)
-  map.backingMap = MutableRef.make(backingMap)
-  return map
+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> => fromHashMap<K, V>(HashMap.empty())
+export const empty = <K, V>(): 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
@@ -74,11 +122,18 @@ export const make: <Entries extends Array<readonly [any, any]>>(
 > = (...entries) => fromIterable(entries)
 
 /**
+ * Creates a new `MutableHashMap` from an iterable collection of key/value pairs.
+ *
  * @since 2.0.0
- * @category conversions
+ * @category constructors
  */
-export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): MutableHashMap<K, V> =>
-  fromHashMap(HashMap.fromIterable(entries))
+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
@@ -87,10 +142,42 @@ export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): MutableH
 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.dual<
+} = 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) => HashMap.get(self.backingMap.current, key))
+>(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)
+})
+
+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
@@ -99,11 +186,54 @@ export const get: {
 export const has: {
   <K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean
   <K, V>(self: MutableHashMap<K, V>, key: K): boolean
-} = Dual.dual<
+} = 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.
  *
@@ -112,16 +242,31 @@ export const has: {
 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.dual<
+} = 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) => {
-    MutableRef.update(self.backingMap, HashMap.modify(key, f))
+>(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
@@ -132,7 +277,7 @@ export const modify: {
 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.dual<
+} = dual<
   <K, V>(
     key: K,
     f: (value: Option.Option<V>) => Option.Option<V>
@@ -143,12 +288,32 @@ export const modifyAt: {
     f: (value: Option.Option<V>) => Option.Option<V>
   ) => MutableHashMap<K, V>
 >(3, (self, key, f) => {
-  const result = f(get(self, key))
-  if (Option.isSome(result)) {
-    set(self, key, result.value)
-  } else {
-    remove(self, key)
+  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
 })
 
@@ -158,25 +323,24 @@ export const modifyAt: {
 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.dual<
+} = 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) => {
-  MutableRef.update(self.backingMap, HashMap.remove(key))
-  return self
-})
+  if (Equal.isEqual(key) === false) {
+    self.referential.delete(key)
+    return self
+  }
 
-/**
- * @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.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) => {
-  MutableRef.update(self.backingMap, HashMap.set(key, value))
+  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
 })
 
@@ -184,4 +348,6 @@ export const set: {
  * @since 2.0.0
  * @category elements
  */
-export const size = <K, V>(self: MutableHashMap<K, V>): number => HashMap.size(MutableRef.get(self.backingMap))
+export const size = <K, V>(self: MutableHashMap<K, V>): number => {
+  return self.referential.size + self.bucketsSize
+}

package/src/MutableHashSet.ts

@@ -61,6 +61,8 @@ const fromHashMap = <V>(keyMap: MutableHashMap.MutableHashMap<V, boolean>): Muta
 export const empty = <K = never>(): MutableHashSet<K> => fromHashMap(MutableHashMap.empty())
 
 /**
+ * Creates a new `MutableHashSet` from an iterable collection of values.
+ *
  * @since 2.0.0
  * @category constructors
  */

package/src/MutableList.ts

@@ -98,7 +98,7 @@ export const empty = <A>(): MutableList<A> => {
 }
 
 /**
- * Creates a new `MutableList` from an `Iterable`.
+ * Creates a new `MutableList` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors

package/src/Option.ts

@@ -231,7 +231,7 @@ export const toRefinement = <A, B extends A>(f: (a: A) => Option<B>): (a: A) =>
  * assert.deepStrictEqual(fromIterable([1, 2, 3]), some(1))
  * assert.deepStrictEqual(fromIterable([]), none())
  *
- * @category conversions
+ * @category constructors
  * @since 2.0.0
  */
 export const fromIterable = <A>(collection: Iterable<A>): Option<A> => {