effect 3.14.2 → 3.14.3

package/dist/cjs/HashSet.js

@@ -8,11 +8,262 @@ var HS = _interopRequireWildcard(require("./internal/hashSet.js"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
+ * # HashSet
+ *
+ * An immutable `HashSet` provides a collection of unique values with efficient
+ * lookup, insertion and removal. Once created, a `HashSet` cannot be modified;
+ * any operation that would alter the set instead returns a new `HashSet` with
+ * the changes. This immutability offers benefits like predictable state
+ * management and easier reasoning about your code.
+ *
+ * ## What Problem Does It Solve?
+ *
+ * `HashSet` solves the problem of maintaining an unsorted collection where each
+ * value appears exactly once, with fast operations for checking membership and
+ * adding/removing values.
+ *
+ * ## When to Use
+ *
+ * Use `HashSet` when you need:
+ *
+ * - A collection with no duplicate values
+ * - Efficient membership testing (**`O(1)`** average complexity)
+ * - Set operations like union, intersection, and difference
+ * - An immutable data structure that preserves functional programming patterns
+ *
+ * ## Advanced Features
+ *
+ * HashSet provides operations for:
+ *
+ * - Transforming sets with map and flatMap
+ * - Filtering elements with filter
+ * - Combining sets with union, intersection and difference
+ * - Performance optimizations via mutable operations in controlled contexts
+ *
+ * ## Performance Characteristics
+ *
+ * - **Lookup** operations ({@linkcode HashSet.has}): **`O(1)`** average time
+ *   complexity
+ * - **Insertion** operations ({@linkcode HashSet.add}): **`O(1)`** average time
+ *   complexity
+ * - **Removal** operations ({@linkcode HashSet.remove}): **`O(1)`** average time
+ *   complexity
+ * - **Set** operations ({@linkcode HashSet.union},
+ *   {@linkcode HashSet.intersection}): **`O(n)`** where n is the size of the
+ *   smaller set
+ * - **Iteration**: **`O(n)`** where n is the size of the set
+ *
+ * The HashSet data structure implements the following traits:
+ *
+ * - {@link Iterable}: allows iterating over the values in the set
+ * - {@link Equal}: allows comparing two sets for value-based equality
+ * - {@link Pipeable}: allows chaining operations with the pipe operator
+ * - {@link Inspectable}: allows inspecting the contents of the set
+ *
+ * ## Operations Reference
+ *
+ * | Category     | Operation                        | Description                                 | Complexity |
+ * | ------------ | -------------------------------- | ------------------------------------------- | ---------- |
+ * | constructors | {@linkcode HashSet.empty}        | Creates an empty HashSet                    | O(1)       |
+ * | constructors | {@linkcode HashSet.fromIterable} | Creates a HashSet from an iterable          | O(n)       |
+ * | constructors | {@linkcode HashSet.make}         | Creates a HashSet from multiple values      | O(n)       |
+ * |              |                                  |                                             |            |
+ * | elements     | {@linkcode HashSet.has}          | Checks if a value exists in the set         | O(1) avg   |
+ * | elements     | {@linkcode HashSet.some}         | Checks if any element satisfies a predicate | O(n)       |
+ * | elements     | {@linkcode HashSet.every}        | Checks if all elements satisfy a predicate  | O(n)       |
+ * | elements     | {@linkcode HashSet.isSubset}     | Checks if a set is a subset of another      | O(n)       |
+ * |              |                                  |                                             |            |
+ * | getters      | {@linkcode HashSet.values}       | Gets an iterator of all values              | O(1)       |
+ * | getters      | {@linkcode HashSet.toValues}     | Gets an array of all values                 | O(n)       |
+ * | getters      | {@linkcode HashSet.size}         | Gets the number of elements                 | O(1)       |
+ * |              |                                  |                                             |            |
+ * | mutations    | {@linkcode HashSet.add}          | Adds a value to the set                     | O(1) avg   |
+ * | mutations    | {@linkcode HashSet.remove}       | Removes a value from the set                | O(1) avg   |
+ * | mutations    | {@linkcode HashSet.toggle}       | Toggles a value's presence                  | O(1) avg   |
+ * |              |                                  |                                             |            |
+ * | operations   | {@linkcode HashSet.difference}   | Computes set difference (A - B)             | O(n)       |
+ * | operations   | {@linkcode HashSet.intersection} | Computes set intersection (A ∩ B)           | O(n)       |
+ * | operations   | {@linkcode HashSet.union}        | Computes set union (A ∪ B)                  | O(n)       |
+ * |              |                                  |                                             |            |
+ * | mapping      | {@linkcode HashSet.map}          | Transforms each element                     | O(n)       |
+ * |              |                                  |                                             |            |
+ * | sequencing   | {@linkcode HashSet.flatMap}      | Transforms and flattens elements            | O(n)       |
+ * |              |                                  |                                             |            |
+ * | traversing   | {@linkcode HashSet.forEach}      | Applies a function to each element          | O(n)       |
+ * |              |                                  |                                             |            |
+ * | folding      | {@linkcode HashSet.reduce}       | Reduces the set to a single value           | O(n)       |
+ * |              |                                  |                                             |            |
+ * | filtering    | {@linkcode HashSet.filter}       | Keeps elements that satisfy a predicate     | O(n)       |
+ * |              |                                  |                                             |            |
+ * | partitioning | {@linkcode HashSet.partition}    | Splits into two sets by a predicate         | O(n)       |
+ *
+ * ## Notes
+ *
+ * ### Composability with the Effect Ecosystem:
+ *
+ * This `HashSet` is designed to work seamlessly within the Effect ecosystem. It
+ * implements the {@link Iterable}, {@link Equal}, {@link Pipeable}, and
+ * {@link Inspectable} traits from Effect. This ensures compatibility with other
+ * Effect data structures and functionalities. For example, you can easily use
+ * Effect's `pipe` method to chain operations on the `HashSet`.
+ *
+ * **Equality of Elements with Effect's {@link Equal `Equal`} Trait:**
+ *
+ * This `HashSet` relies on Effect's {@link Equal} trait to determine the
+ * uniqueness of elements within the set. The way equality is checked depends on
+ * the type of the elements:
+ *
+ * - **Primitive Values:** For primitive JavaScript values like strings, numbers,
+ *   booleans, `null`, and `undefined`, equality is determined by their value
+ *   (similar to the `===` operator).
+ * - **Objects and Custom Types:** For objects and other custom types, equality is
+ *   determined by whether those types implement the {@link Equal} interface
+ *   themselves. If an element type implements `Equal`, the `HashSet` will
+ *   delegate to that implementation to perform the equality check. This allows
+ *   you to define custom logic for determining when two instances of your
+ *   objects should be considered equal based on their properties, rather than
+ *   just their object identity.
+ *
+ * ```ts
+ * import { Equal, Hash, HashSet } from "effect"
+ *
+ * class Person implements Equal.Equal {
+ *   constructor(
+ *     readonly id: number, // Unique identifier
+ *     readonly name: string,
+ *     readonly age: number
+ *   ) {}
+ *
+ *   // Define equality based on id, name, and age
+ *   [Equal.symbol](that: Equal.Equal): boolean {
+ *     if (that instanceof Person) {
+ *       return (
+ *         Equal.equals(this.id, that.id) &&
+ *         Equal.equals(this.name, that.name) &&
+ *         Equal.equals(this.age, that.age)
+ *       )
+ *     }
+ *     return false
+ *   }
+ *
+ *   // Generate a hash code based on the unique id
+ *   [Hash.symbol](): number {
+ *     return Hash.hash(this.id)
+ *   }
+ * }
+ *
+ * // Creating a HashSet with objects that implement the Equal interface
+ * const set = HashSet.empty().pipe(
+ *   HashSet.add(new Person(1, "Alice", 30)),
+ *   HashSet.add(new Person(1, "Alice", 30))
+ * )
+ *
+ * // HashSet recognizes them as equal, so only one element is stored
+ * console.log(HashSet.size(set))
+ * // Output: 1
+ * ```
+ *
+ * **Simplifying Equality and Hashing with `Data` and `Schema`:**
+ *
+ * Effect's {@link Data} and {@link Schema `Schema.Data`} modules offer powerful
+ * ways to automatically handle the implementation of both the {@link Equal} and
+ * {@link Hash} traits for your custom data structures.
+ *
+ * - **`Data` Module:** By using constructors like `Data.struct`, `Data.tuple`,
+ *   `Data.array`, or `Data.case` to define your data types, Effect
+ *   automatically generates the necessary implementations for value-based
+ *   equality and consistent hashing. This significantly reduces boilerplate and
+ *   ensures correctness.
+ *
+ * ```ts
+ * import { HashSet, Data, Equal } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * // Data.* implements the `Equal` traits for us
+ * const person1 = Data.struct({ id: 1, name: "Alice", age: 30 })
+ * const person2 = Data.struct({ id: 1, name: "Alice", age: 30 })
+ *
+ * assert(Equal.equals(person1, person2))
+ *
+ * const set = HashSet.empty().pipe(
+ *   HashSet.add(person1),
+ *   HashSet.add(person2)
+ * )
+ *
+ * // HashSet recognizes them as equal, so only one element is stored
+ * console.log(HashSet.size(set)) // Output: 1
+ * ```
+ *
+ * - **`Schema` Module:** When defining data schemas using the {@link Schema}
+ *   module, you can use `Schema.Data` to automatically include the `Equal` and
+ *   `Hash` traits in the decoded objects. This is particularly important when
+ *   working with `HashSet`. **For decoded objects to be correctly recognized as
+ *   equal within a `HashSet`, ensure that the schema for those objects is
+ *   defined using `Schema.Data`.**
+ *
+ * ```ts
+ * import { Equal, HashSet, Schema } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * // Schema.Data implements the `Equal` traits for us
+ * const PersonSchema = Schema.Data(
+ *   Schema.Struct({
+ *     id: Schema.Number,
+ *     name: Schema.String,
+ *     age: Schema.Number
+ *   })
+ * )
+ *
+ * const Person = Schema.decode(PersonSchema)
+ *
+ * const person1 = Person({ id: 1, name: "Alice", age: 30 })
+ * const person2 = Person({ id: 1, name: "Alice", age: 30 })
+ *
+ * assert(Equal.equals(person1, person2)) // Output: true
+ *
+ * const set = HashSet.empty().pipe(
+ *   HashSet.add(person1),
+ *   HashSet.add(person2)
+ * )
+ *
+ * // HashSet thanks to Schema.Data implementation of the `Equal` trait, recognizes the two Person as equal, so only one element is stored
+ * console.log(HashSet.size(set)) // Output: 1
+ * ```
+ *
+ * ### Interoperability with the JavaScript Runtime:
+ *
+ * To interoperate with the regular JavaScript runtime, Effect's `HashSet`
+ * provides methods to access its elements in formats readily usable by
+ * JavaScript APIs: {@link values `HashSet.values`},
+ * {@link toValues `HashSet.toValues`}
+ *
+ * ```ts
+ * import { HashSet } from "effect"
+ *
+ * const hashSet: HashSet.HashSet<number> = HashSet.make(1, 2, 3)
+ *
+ * // Using HashSet.values to convert HashSet.HashSet<A> to IterableIterator<A>
+ * const iterable: IterableIterator<number> = HashSet.values(hashSet)
+ *
+ * console.log(...iterable) // Logs:  1 2 3
+ *
+ * // Using HashSet.toValues to convert HashSet.HashSet<A> to Array<A>
+ * const array: Array<number> = HashSet.toValues(hashSet)
+ *
+ * console.log(array) // Logs: [ 1, 2, 3 ]
+ * ```
+ *
+ * Be mindful of performance implications (both time and space complexity) when
+ * frequently converting between Effect's immutable HashSet and mutable
+ * JavaScript data structures, especially for large collections.
+ *
+ * @module HashSet
  * @since 2.0.0
  */
 
 const TypeId = HS.HashSetTypeId;
 /**
+ * @memberof HashSet
  * @since 2.0.0
  * @category refinements
  */
@@ -20,43 +271,323 @@ const isHashSet = exports.isHashSet = HS.isHashSet;
 /**
  * Creates an empty `HashSet`.
  *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category constructors
+ * @example
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     // Provide a type argument to create a HashSet of a specific type
+ *     HashSet.empty<number>(),
+ *     HashSet.add(1),
+ *     HashSet.add(1), // Notice the duplicate
+ *     HashSet.add(2),
+ *     HashSet.toValues
+ *   )
+ * ) // Output: [1, 2]
+ * ```
+ *
+ * @see Other `HashSet` constructors are {@link make} {@link fromIterable}
  */
 const empty = exports.empty = HS.empty;
 /**
  * Creates a new `HashSet` from an iterable collection of values.
  *
+ * Time complexity: **`O(n)`** where n is the number of elements in the iterable
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category constructors
+ * @example Creating a HashSet from an {@link Array}
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     [1, 2, 3, 4, 5, 1, 2, 3], // Array<number> is an Iterable<number>;  Note the duplicates.
+ *     HashSet.fromIterable,
+ *     HashSet.toValues
+ *   )
+ * ) // Output: [1, 2, 3, 4, 5]
+ * ```
+ *
+ * @example Creating a HashSet from a {@link Set}
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     new Set(["apple", "banana", "orange", "apple"]), // Set<string> is an Iterable<string>
+ *     HashSet.fromIterable,
+ *     HashSet.toValues
+ *   )
+ * ) // Output: ["apple", "banana", "orange"]
+ * ```
+ *
+ * @example Creating a HashSet from a {@link Generator}
+ *
+ * ```ts
+ * import { HashSet } from "effect"
+ *
+ * // Generator functions return iterables
+ * function* fibonacci(n: number): Generator<number, void, unknown> {
+ *   let [a, b] = [0, 1]
+ *   for (let i = 0; i < n; i++) {
+ *     yield a
+ *     ;[a, b] = [b, a + b]
+ *   }
+ * }
+ *
+ * // Create a HashSet from the first 10 Fibonacci numbers
+ * const fibonacciSet = HashSet.fromIterable(fibonacci(10))
+ *
+ * console.log(HashSet.toValues(fibonacciSet))
+ * // Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
+ * ```
+ *
+ * @example Creating a HashSet from another {@link HashSet}
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     // since HashSet implements the Iterable interface, we can use it to create a new HashSet
+ *     HashSet.make(1, 2, 3, 4),
+ *     HashSet.fromIterable,
+ *     HashSet.toValues // turns the HashSet back into an array
+ *   )
+ * ) // Output: [1, 2, 3, 4]
+ * ```
+ *
+ * @example Creating a HashSet from other Effect's data structures like
+ * {@link Chunk}
+ *
+ * ```ts
+ * import { Chunk, HashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     Chunk.make(1, 2, 3, 4), // Iterable<number>
+ *     HashSet.fromIterable,
+ *     HashSet.toValues // turns the HashSet back into an array
+ *   )
+ * ) // Outputs: [1, 2, 3, 4]
+ * ```
+ *
+ * @see Other `HashSet` constructors are {@link empty} {@link make}
  */
 const fromIterable = exports.fromIterable = HS.fromIterable;
 /**
  * Construct a new `HashSet` from a variable number of values.
  *
+ * Time complexity: **`O(n)`** where n is the number of elements
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category constructors
+ * @example
+ *
+ * ```ts
+ * import { Equal, Hash, HashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * class Character implements Equal.Equal {
+ *   readonly name: string
+ *   readonly trait: string
+ *
+ *   constructor(name: string, trait: string) {
+ *     this.name = name
+ *     this.trait = trait
+ *   }
+ *
+ *   // Define equality based on name, and trait
+ *   [Equal.symbol](that: Equal.Equal): boolean {
+ *     if (that instanceof Character) {
+ *       return (
+ *         Equal.equals(this.name, that.name) &&
+ *         Equal.equals(this.trait, that.trait)
+ *       )
+ *     }
+ *     return false
+ *   }
+ *
+ *   // Generate a hash code based on the sum of the character's name and trait
+ *   [Hash.symbol](): number {
+ *     return Hash.hash(this.name + this.trait)
+ *   }
+ *
+ *   static readonly of = (name: string, trait: string): Character => {
+ *     return new Character(name, trait)
+ *   }
+ * }
+ *
+ * assert.strictEqual(
+ *   Equal.equals(
+ *     HashSet.make(
+ *       Character.of("Alice", "Curious"),
+ *       Character.of("Alice", "Curious"),
+ *       Character.of("White Rabbit", "Always late"),
+ *       Character.of("Mad Hatter", "Tea enthusiast")
+ *     ),
+ *     // Is the same as adding each character to an empty set
+ *     pipe(
+ *       HashSet.empty(),
+ *       HashSet.add(Character.of("Alice", "Curious")),
+ *       HashSet.add(Character.of("Alice", "Curious")), // Alice tried to attend twice!
+ *       HashSet.add(Character.of("White Rabbit", "Always late")),
+ *       HashSet.add(Character.of("Mad Hatter", "Tea enthusiast"))
+ *     )
+ *   ),
+ *   true,
+ *   "`HashSet.make` and `HashSet.empty() + HashSet.add()` should be equal"
+ * )
+ *
+ * assert.strictEqual(
+ *   Equal.equals(
+ *     HashSet.make(
+ *       Character.of("Alice", "Curious"),
+ *       Character.of("Alice", "Curious"),
+ *       Character.of("White Rabbit", "Always late"),
+ *       Character.of("Mad Hatter", "Tea enthusiast")
+ *     ),
+ *     HashSet.fromIterable([
+ *       Character.of("Alice", "Curious"),
+ *       Character.of("Alice", "Curious"),
+ *       Character.of("White Rabbit", "Always late"),
+ *       Character.of("Mad Hatter", "Tea enthusiast")
+ *     ])
+ *   ),
+ *   true,
+ *   "`HashSet.make` and `HashSet.fromIterable` should be equal"
+ * )
+ * ```
+ *
+ * @see Other `HashSet` constructors are {@linkcode fromIterable} {@linkcode empty}
  */
 const make = exports.make = HS.make;
 /**
  * Checks if the specified value exists in the `HashSet`.
  *
+ * Time complexity: **`O(1)`** average
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category elements
+ * @example **syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(HashSet.make(0, 1, 2), HashSet.has(3)) // false
+ *
+ * // or piped with the pipe function
+ * HashSet.make(0, 1, 2).pipe(HashSet.has(3)) // false
+ *
+ * // or with `data-first` API
+ * HashSet.has(HashSet.make(0, 1, 2), 3) // false
+ * ```
+ *
+ * @returns A `boolean` signaling the presence of the value in the HashSet
+ * @see Other `HashSet` elements are {@link some} {@link every} {@link isSubset}
  */
 const has = exports.has = HS.has;
 /**
  * Check if a predicate holds true for some `HashSet` element.
  *
+ * Time complexity: **`O(n)`** where n is the number of elements in the set
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category elements
+ * @example **syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * const set: HashSet.HashSet<number> = HashSet.make(0, 1, 2)
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   set,
+ *   HashSet.some((n) => n > 0)
+ * ) // true
+ *
+ * // or piped with the pipe function
+ * set.pipe(HashSet.some((n) => n > 0)) // true
+ *
+ * // or with `data-first` API
+ * HashSet.some(set, (n) => n > 0) // true
+ * ```
+ *
+ * @see Other `HashSet` elements are {@link has} {@link every} {@link isSubset}
  */
 const some = exports.some = HS.some;
 /**
  * Check if a predicate holds true for every `HashSet` element.
  *
+ * Time complexity is **`O(n)`** as it needs to traverse the whole HashSet
+ * collection
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category elements
+ * @example **syntax** with {@link Refinement}
+ *
+ * ```ts
+ * import { HashSet, pipe, Predicate } from "effect"
+ *
+ * const numberOrString = HashSet.make(1, "1", "one", "uno")
+ *
+ * // with `data-last`, a.k.a. `pipeable` API and `Refinement`
+ * pipe(
+ *   numberOrString, // HashSet.HashSet<number | string>
+ *   HashSet.every(Predicate.isString)
+ * ) // HashSet.HashSet<string>
+ *
+ * // or piped with the pipe function and  `Refinement`
+ * numberOrString // HashSet.HashSet<number | string>
+ *   .pipe(HashSet.every(Predicate.isString)) // HashSet.HashSet<string>
+ *
+ * // or with `data-first` API and `Refinement`
+ * HashSet.every(
+ *   numberOrString, // HashSet.HashSet<number | string>
+ *   Predicate.isString
+ * ) // HashSet.HashSet<string>
+ * ```
+ *
+ * @example **syntax** with {@link Predicate}
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * const set = HashSet.make(1, 2, 3)
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   set,
+ *   HashSet.every((n) => n >= 0)
+ * ) // true
+ *
+ * // or piped with the pipe function
+ * set.pipe(HashSet.every((n) => n >= 0)) // true
+ *
+ * // or with `data-first` API
+ * HashSet.every(set, (n) => n >= 0) // true
+ * ```
+ *
+ * @returns A boolean once it has evaluated that whole collection fulfill the
+ *   Predicate function
+ * @see Other `HashSet` elements are {@link has} {@link some} {@link isSubset}
  */
 const every = exports.every = HS.every;
 /**
@@ -65,90 +596,394 @@ const every = exports.every = HS.every;
  *
  * **NOTE**: the hash and equal of both sets must be the same.
  *
+ * Time complexity analysis is of **`O(n)`**
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category elements
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * const set1 = HashSet.make(0, 1)
+ * const set2 = HashSet.make(1, 2)
+ * const set3 = HashSet.make(0, 1, 2)
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(set1, HashSet.isSubset(set2)) // false
+ * pipe(set1, HashSet.isSubset(set3)) // true
+ *
+ * // or piped with the pipe function
+ * set1.pipe(HashSet.isSubset(set2)) // false
+ * set1.pipe(HashSet.isSubset(set3)) // true
+ *
+ * // or with `data-first` API
+ * HashSet.isSubset(set1, set2) // false
+ * HashSet.isSubset(set1, set3) // true)
+ * ```
+ *
+ * @see Other `HashSet` elements are {@link has} {@link some} {@link every}
  */
 const isSubset = exports.isSubset = HS.isSubset;
 /**
  * Returns an `IterableIterator` of the values in the `HashSet`.
  *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category getters
+ * @example
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * const numberIterable = pipe(
+ *   HashSet.make(0, 1, 1, 2), // HashSet.HashSet<number>
+ *   HashSet.values // takes an HashSet<A> and returns an IterableIterator<A>
+ * )
+ *
+ * for (const number of numberIterable) {
+ *   console.log(number) // it will logs: 0, 1, 2
+ * }
+ * ```
+ *
+ * @see Other `HashSet` getters are {@link toValues} {@link size}
  */
 const values = exports.values = HS.values;
 /**
  * Returns an `Array` of the values within the `HashSet`.
  *
+ * Time complexity: **`O(n)`** where n is the number of elements in the set
+ *
+ * @memberof HashSet
  * @since 3.13.0
  * @category getters
+ * @example
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ * import { deepStrictEqual } from "node:assert/strict"
+ *
+ * deepStrictEqual(
+ *   pipe(
+ *     HashSet.make(0, 1, 1, 2), // HashSet<number>
+ *     HashSet.toValues // takes an HashSet<A> and returns an Array<A>
+ *   ),
+ *   Array.of(0, 1, 2)
+ * )
+ * ```
+ *
+ * @see Other `HashSet` getters are {@link values} {@link size}
  */
 const toValues = self => Array.from(values(self));
 /**
  * Calculates the number of values in the `HashSet`.
  *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category getters
+ * @example
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.deepStrictEqual(pipe(HashSet.empty(), HashSet.size), 0)
+ *
+ * assert.deepStrictEqual(
+ *   pipe(HashSet.make(1, 2, 2, 3, 4, 3), HashSet.size),
+ *   4
+ * )
+ * ```
+ *
+ * @see Other `HashSet` getters are {@link values} {@link toValues}
  */
 exports.toValues = toValues;
 const size = exports.size = HS.size;
 /**
- * Marks the `HashSet` as mutable.
+ * Creates a new mutable version of the `HashSet`
+ *
+ * When a `HashSet` is mutable, operations like {@link add} and {@link remove}
+ * modify the data structure in place instead of creating a new one, which is
+ * more efficient when performing multiple operations.
  *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example
+ *
+ * ```ts
+ * import { HashSet } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * const UPPER_BOUND = 10_000
+ *
+ * const immutableSet = HashSet.empty<number>().pipe(HashSet.add(0))
+ *
+ * // Create a mutable version of the immutableSet
+ * const mutableSet = HashSet.beginMutation(immutableSet)
+ *
+ * for (let i = 1; i < UPPER_BOUND; i++) {
+ *   // Operations now modify the set in place instead of creating new instances
+ *   // This is more efficient when making multiple changes
+ *   const pointerToMutableSet = HashSet.add(mutableSet, i)
+ *
+ *   // the two sets have the same identity, hence `add` is mutating mutableSet and not returning a new HashSet instance
+ *   assert(Object.is(mutableSet, pointerToMutableSet))
+ *   assert.equal(HashSet.has(mutableSet, i), true) // `i` is in the mutableSet
+ *   assert.equal(HashSet.has(immutableSet, i), false) // `i` is not in the immutableSet
+ * }
+ *
+ * const next = UPPER_BOUND + 1
+ * // When done, mark the set as immutable again
+ * HashSet.endMutation(mutableSet).pipe(
+ *   HashSet.add(next) // since this returns a new HashSet, it will not be logged as part of the mutableSet
+ * )
+ * assert.equal(HashSet.has(mutableSet, next), false)
+ *
+ * console.log(HashSet.toValues(immutableSet)) // [0]
+ * console.log(HashSet.toValues(mutableSet).sort((a, b) => a - b)) // [0, 1, 2, 3, ...rest]
+ * ```
+ *
+ * @see Other `HashSet` mutations are {@link add} {@link remove} {@link toggle} {@link endMutation} {@link mutate}
  */
 const beginMutation = exports.beginMutation = HS.beginMutation;
 /**
- * Marks the `HashSet` as immutable.
+ * Makes the `HashSet` immutable again.
+ *
+ * After calling `endMutation`, operations like {@link add} and {@link remove}
+ * will create new instances of the `HashSet` instead of modifying the existing
+ * one.
  *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example
+ *
+ * ```ts
+ * import { HashSet } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * // Create a mutable set
+ * const mutableSet = HashSet.beginMutation(HashSet.empty<number>())
+ *
+ * // Add some elements to the mutable set
+ * HashSet.add(mutableSet, 1)
+ * HashSet.add(mutableSet, 2)
+ *
+ * // Before endMutation, operations modify the set in place
+ * const sameSet = HashSet.add(mutableSet, 3)
+ * assert(Object.is(mutableSet, sameSet)) // true - same object reference
+ * assert.deepStrictEqual(HashSet.toValues(mutableSet).sort(), [1, 2, 3])
+ *
+ * // Make the set immutable again
+ * const immutableSet = HashSet.endMutation(mutableSet)
+ *
+ * // endMutation returns the same set instance, now made immutable
+ * assert(Object.is(mutableSet, immutableSet)) // true - same object reference
+ *
+ * // After endMutation, operations create new instances
+ * const newSet = HashSet.add(immutableSet, 4)
+ * assert(!Object.is(immutableSet, newSet)) // false - different object references
+ *
+ * // The original set remains unchanged
+ * assert.deepStrictEqual(HashSet.toValues(immutableSet).sort(), [1, 2, 3])
+ *
+ * // The new set contains the added element
+ * assert.deepStrictEqual(HashSet.toValues(newSet).sort(), [1, 2, 3, 4])
+ * ```
+ *
+ * @see Other `HashSet` mutations are {@linkcode HashSet.add} {@linkcode HashSet.remove} {@linkcode HashSet.toggle} {@linkcode HashSet.beginMutation} {@linkcode HashSet.mutate}
  */
 const endMutation = exports.endMutation = HS.endMutation;
 /**
  * Mutates the `HashSet` within the context of the provided function.
  *
+ * You can consider it a functional abstraction on top of the lower-level
+ * mutation primitives of {@linkcode HashSet.beginMutation} `->` `mutable
+ * context` `->` {@linkcode HashSet.endMutation}.
+ *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(
+ *   HashSet.make(1, 2, 3),
+ *   HashSet.mutate((set) => {
+ *     HashSet.add(set, 4)
+ *     HashSet.remove(set, 1)
+ *   })
+ * )
+ *
+ * // or piped with the pipe function
+ * HashSet.make(1, 2, 3).pipe(
+ *   HashSet.mutate((set) => {
+ *     HashSet.add(set, 4)
+ *     HashSet.remove(set, 1)
+ *   })
+ * )
+ *
+ * // or with data-first API
+ * HashSet.mutate(HashSet.make(1, 2, 3), (set) => {
+ *   HashSet.add(set, 4)
+ *   HashSet.remove(set, 1)
+ * })
+ * ```
+ *
+ * @see Other `HashSet` mutations are {@linkcode HashSet.add} {@linkcode HashSet.remove} {@linkcode HashSet.toggle} {@linkcode HashSet.beginMutation} {@linkcode HashSet.endMutation}
  */
 const mutate = exports.mutate = HS.mutate;
 /**
  * Adds a value to the `HashSet`.
  *
+ * Time complexity: **`O(1)`** average
+ *
+ * @remarks
+ * Remember that a `HashSet` is a collection of unique values, so adding a value
+ * that already exists in the `HashSet` will not add a duplicate.
+ *
+ * Remember that HashSet is an immutable data structure, so the `add` function,
+ * like all other functions that modify the HashSet, will return a new HashSet
+ * with the added value.
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(HashSet.empty(), HashSet.add(0), HashSet.add(0))
+ *
+ * // or piped with the pipe function
+ * HashSet.empty().pipe(HashSet.add(0))
+ *
+ * // or with data-first API
+ * HashSet.add(HashSet.empty(), 0)
+ * ```
+ *
+ * @see Other `HashSet` mutations are {@link remove} {@link toggle} {@link beginMutation} {@link endMutation} {@link mutate}
  */
 const add = exports.add = HS.add;
 /**
  * Removes a value from the `HashSet`.
  *
+ * Time complexity: **`O(1)`** average
+ *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(HashSet.make(0, 1, 2), HashSet.remove(0))
+ *
+ * // or piped with the pipe function
+ * HashSet.make(0, 1, 2).pipe(HashSet.remove(0))
+ *
+ * // or with `data-first` API
+ * HashSet.remove(HashSet.make(0, 1, 2), 0)
+ * ```
+ *
+ * @see Other `HashSet` mutations are {@link add} {@link toggle} {@link beginMutation} {@link endMutation} {@link mutate}
  */
 const remove = exports.remove = HS.remove;
 /**
- * Computes the set difference between this `HashSet` and the specified
- * `Iterable<A>`.
+ * Computes the set difference `(A - B)` between this `HashSet` and the
+ * specified `Iterable<A>`.
+ *
+ * Time complexity: **`O(n)`** where n is the number of elements in the set
  *
  * **NOTE**: the hash and equal of the values in both the set and the iterable
- * must be the same.
+ * must be the same; meaning we cannot compute a difference between a `HashSet
+ * of bananas` and a `HashSet of elephants` as they are not the same type and
+ * won't implement the Equal trait in the same way.
  *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(HashSet.make(1, 2, 3), HashSet.difference(HashSet.make(3, 4, 5)))
+ *
+ * // or piped with the pipe function
+ * HashSet.make(1, 2, 3).pipe(HashSet.difference(HashSet.make(3, 4, 5)))
+ *
+ * // or with data-first API
+ * HashSet.difference(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5))
+ * ```
+ *
+ * @see Other `HashSet` operations are {@link intersection} {@link union}
  */
 const difference = exports.difference = HS.difference;
 /**
  * Returns a `HashSet` of values which are present in both this set and that
- * `Iterable<A>`.
+ * `Iterable<A>`. Computes set intersection (A ∩ B)
+ *
+ * Time complexity: **`O(n)`** where n is the number of elements in the smaller
+ * set
  *
  * **NOTE**: the hash and equal of the values in both the set and the iterable
  * must be the same.
  *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(HashSet.make(1, 2, 3), HashSet.intersection(HashSet.make(2, 3, 4)))
+ *
+ * // or piped with the pipe function
+ * HashSet.make(1, 2, 3).pipe(HashSet.intersection(HashSet.make(2, 3, 4)))
+ *
+ * // or with data-first API
+ * HashSet.intersection(HashSet.make(1, 2, 3), HashSet.make(2, 3, 4))
+ * ```
+ *
+ * @see Other `HashSet` operations are {@link difference} {@link union}
  */
 const intersection = exports.intersection = HS.intersection;
 /**
- * Computes the set union `(`self` + `that`)` between this `HashSet` and the
+ * Computes the set union `( self ∪ that )` between this `HashSet` and the
  * specified `Iterable<A>`.
  *
+ * Time complexity: **`O(n)`** where n is the number of elements in the set
+ *
  * **NOTE**: the hash and equal of the values in both the set and the iterable
  * must be the same.
  *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(HashSet.make(1, 2, 3), HashSet.union(HashSet.make(3, 4, 5)))
+ *
+ * // or piped with the pipe function
+ * HashSet.make(1, 2, 3).pipe(HashSet.union(HashSet.make(3, 4, 5)))
+ *
+ * // or with data-first API
+ * HashSet.union(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5))
+ * ```
+ *
+ * @see Other `HashSet` operations are {@link difference} {@link intersection}
  */
 const union = exports.union = HS.union;
 /**
@@ -156,42 +991,189 @@ const union = exports.union = HS.union;
  * will be removed from the `HashSet`, otherwise the value will be added to the
  * `HashSet`.
  *
+ * Time complexity: **`O(1)`** average
+ *
+ * @memberof HashSet
  * @since 2.0.0
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(HashSet.make(0, 1, 2), HashSet.toggle(0))
+ *
+ * // or piped with the pipe function
+ * HashSet.make(0, 1, 2).pipe(HashSet.toggle(0))
+ *
+ * // or with `data-first` API
+ * HashSet.toggle(HashSet.make(0, 1, 2), 0)
+ * ```
+ *
+ * @returns A new `HashSet` where the toggled value is being either added or
+ *   removed based on the initial `HashSet` state.
+ * @see Other `HashSet` mutations are {@link add} {@link remove} {@link beginMutation} {@link endMutation} {@link mutate}
  */
 const toggle = exports.toggle = HS.toggle;
 /**
  * Maps over the values of the `HashSet` using the specified function.
  *
+ * The time complexity is of **`O(n)`**.
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category mapping
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   HashSet.make(0, 1, 2), // HashSet.HashSet<number>
+ *   HashSet.map(String) // HashSet.HashSet<string>
+ * )
+ *
+ * // or piped with the pipe method
+ * HashSet.make(0, 1, 2).pipe(HashSet.map(String))
+ *
+ * // or with `data-first` API
+ * HashSet.map(HashSet.make(0, 1, 2), String)
+ * ```
  */
 const map = exports.map = HS.map;
 /**
  * Chains over the values of the `HashSet` using the specified function.
  *
+ * The time complexity is of **`O(n)`**.
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category sequencing
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   HashSet.make(0, 1, 2), // HashSet.HashSet<number>
+ *   HashSet.flatMap((n) => Array.of(String(n))) // HashSet.HashSet<string>
+ * )
+ *
+ * // or piped with the pipe method
+ * HashSet.make(0, 1, 2) // HashSet.HashSet<number>
+ *   .pipe(
+ *     HashSet.flatMap((n) => Array.of(String(n))) // HashSet.HashSet<string>
+ *   )
+ *
+ * // or with `data-first` API
+ * HashSet.flatMap(HashSet.make(0, 1, 2), (n) => Array.of(String(n)))
+ * ```
  */
 const flatMap = exports.flatMap = HS.flatMap;
 /**
  * Applies the specified function to the values of the `HashSet`.
  *
+ * The time complexity is of **`O(n)`**.
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category traversing
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(HashSet.make(0, 1, 2), HashSet.forEach(console.log)) // logs: 0 1 2
+ *
+ * // or piped with the pipe method
+ * HashSet.make(0, 1, 2).pipe(HashSet.forEach(console.log)) // logs: 0 1 2
+ *
+ * // or with `data-first` API
+ * HashSet.forEach(HashSet.make(0, 1, 2), console.log) // logs: 0 1 2
+ * ```
  */
 const forEach = exports.forEach = HS.forEach;
 /**
  * Reduces the specified state over the values of the `HashSet`.
  *
+ * The time complexity is of **`O(n)`**.
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category folding
+ * @example **Syntax**
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * const sum = (a: number, b: number): number => a + b
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(HashSet.make(0, 1, 2), HashSet.reduce(0, sum))
+ *
+ * // or with the pipe method
+ * HashSet.make(0, 1, 2).pipe(HashSet.reduce(0, sum))
+ *
+ * // or with `data-first` API
+ * HashSet.reduce(HashSet.make(0, 1, 2), 0, sum)
+ * ```
  */
 const reduce = exports.reduce = HS.reduce;
 /**
  * Filters values out of a `HashSet` using the specified predicate.
  *
+ * The time complexity is of **`O(n)`**.
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category filtering
+ * @example **Syntax** with {@link Predicate}
+ *
+ * ```ts
+ * import { HashSet, type Predicate, pipe } from "effect"
+ *
+ * const filterPositiveNumbers: Predicate.Predicate<number> = (n) => n > 0
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   HashSet.make(-2, -1, 0, 1, 2),
+ *   HashSet.filter(filterPositiveNumbers)
+ * )
+ *
+ * // or with the pipe method
+ * HashSet.make(-2, -1, 0, 1, 2).pipe(HashSet.filter(filterPositiveNumbers))
+ *
+ * // or with `data-first` API
+ * HashSet.filter(HashSet.make(-2, -1, 0, 1, 2), filterPositiveNumbers)
+ * ```
+ *
+ * @example **Syntax** with {@link Refinement}
+ *
+ * ```ts
+ * import { HashSet, pipe } from "effect"
+ *
+ * const stringRefinement = (value: unknown): value is string =>
+ *   typeof value === "string"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"), // // HashSet.HashSet<number | string>
+ *   HashSet.filter(stringRefinement)
+ * ) // HashSet.HashSet<string>
+ *
+ * // or with the pipe method
+ * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") // HashSet.HashSet<number | string>
+ *   .pipe(HashSet.filter(stringRefinement)) // HashSet.HashSet<string>
+ *
+ * // or with `data-first` API
+ * HashSet.filter(
+ *   HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"), // HashSet.HashSet<number | string>
+ *   stringRefinement
+ * ) // HashSet.HashSet<string>
+ * ```
  */
 const filter = exports.filter = HS.filter;
 /**
@@ -201,8 +1183,57 @@ const filter = exports.filter = HS.filter;
  * right side of the resulting `Tuple`, otherwise the value will be placed into
  * the left side.
  *
+ * Time complexity is of **`O(n)`**.
+ *
+ * @memberof HashSet
  * @since 2.0.0
  * @category partitioning
+ * @example **Syntax** with {@link Predicate}
+ *
+ * ```ts
+ * import { HashSet, pipe, Predicate } from "effect"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   HashSet.make(0, 1, 2, 3, 4, 5),
+ *   HashSet.partition((n) => n % 2 === 0)
+ * )
+ *
+ * // or with the pipe method
+ * HashSet.make(0, 1, 2, 3, 4, 5).pipe(
+ *   HashSet.partition((n) => n % 2 === 0)
+ * )
+ *
+ * // or with `data-first` API
+ * HashSet.partition(HashSet.make(0, 1, 2, 3, 4, 5), (n) => n % 2 === 0)
+ * ```
+ *
+ * @example **Syntax** with {@link Refinement}
+ *
+ * ```ts
+ * import { HashSet, pipe, Predicate } from "effect"
+ *
+ * const stringRefinement: Predicate.Refinement<string | number, string> = (
+ *   value
+ * ) => typeof value === "string"
+ *
+ * // with `data-last`, a.k.a. `pipeable` API
+ * pipe(
+ *   HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"),
+ *   HashSet.partition(stringRefinement)
+ * )
+ *
+ * // or with the pipe method
+ * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier").pipe(
+ *   HashSet.partition(stringRefinement)
+ * )
+ *
+ * // or with `data-first` API
+ * HashSet.partition(
+ *   HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"),
+ *   stringRefinement
+ * )
+ * ```
  */
 const partition = exports.partition = HS.partition;
 //# sourceMappingURL=HashSet.js.map