 Server : Apache/2 System : Linux server-15-235-50-60 5.15.0-164-generic #174-Ubuntu SMP Fri Nov 14 20:25:16 UTC 2025 x86_64 User : gositeme ( 1004) PHP Version : 8.2.29 Disable Function : exec,system,passthru,shell_exec,proc_close,proc_open,dl,popen,show_source,posix_kill,posix_mkfifo,posix_getpwuid,posix_setpgid,posix_setsid,posix_setuid,posix_setgid,posix_seteuid,posix_setegid,posix_uname Directory : /home/gositeme/domains/lavocat.quebec/private_html/node_modules/effect/dist/esm/ |
/**
* # 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 ({@link module:HashSet.has}): **`O(1)`** average time
* complexity
* - **Insertion** operations ({@link module:HashSet.add}): **`O(1)`** average time
* complexity
* - **Removal** operations ({@link module:HashSet.remove}): **`O(1)`** average
* time complexity
* - **Set** operations ({@link module:HashSet.union},
* {@link module: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 | {@link module:HashSet.empty} | Creates an empty HashSet | O(1) |
* | constructors | {@link module:HashSet.fromIterable} | Creates a HashSet from an iterable | O(n) |
* | constructors | {@link module:HashSet.make} | Creates a HashSet from multiple values | O(n) |
* | | | | |
* | elements | {@link module:HashSet.has} | Checks if a value exists in the set | O(1) avg |
* | elements | {@link module:HashSet.some} | Checks if any element satisfies a predicate | O(n) |
* | elements | {@link module:HashSet.every} | Checks if all elements satisfy a predicate | O(n) |
* | elements | {@link module:HashSet.isSubset} | Checks if a set is a subset of another | O(n) |
* | | | | |
* | getters | {@link module:HashSet.values} | Gets an iterator of all values | O(1) |
* | getters | {@link module:HashSet.toValues} | Gets an array of all values | O(n) |
* | getters | {@link module:HashSet.size} | Gets the number of elements | O(1) |
* | | | | |
* | mutations | {@link module:HashSet.add} | Adds a value to the set | O(1) avg |
* | mutations | {@link module:HashSet.remove} | Removes a value from the set | O(1) avg |
* | mutations | {@link module:HashSet.toggle} | Toggles a value's presence | O(1) avg |
* | | | | |
* | operations | {@link module:HashSet.difference} | Computes set difference (A - B) | O(n) |
* | operations | {@link module:HashSet.intersection} | Computes set intersection (A ∩ B) | O(n) |
* | operations | {@link module:HashSet.union} | Computes set union (A ∪ B) | O(n) |
* | | | | |
* | mapping | {@link module:HashSet.map} | Transforms each element | O(n) |
* | | | | |
* | sequencing | {@link module:HashSet.flatMap} | Transforms and flattens elements | O(n) |
* | | | | |
* | traversing | {@link module:HashSet.forEach} | Applies a function to each element | O(n) |
* | | | | |
* | folding | {@link module:HashSet.reduce} | Reduces the set to a single value | O(n) |
* | | | | |
* | filtering | {@link module:HashSet.filter} | Keeps elements that satisfy a predicate | O(n) |
* | | | | |
* | partitioning | {@link module: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
*/
import * as HS from "./internal/hashSet.js";
const TypeId = HS.HashSetTypeId;
/**
* @memberof HashSet
* @since 2.0.0
* @category refinements
*/
export const 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 module:HashSet.make} {@link module:HashSet.fromIterable}
*/
export const 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
*
* ```ts
* // Creating a HashSet from an Array
* 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
*
* ```ts
* // Creating a HashSet from a Set
* 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
*
* ```ts
* // Creating a HashSet from a Generator
* 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
*
* ```ts
* // Creating a HashSet from another HashSet
* 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
*
* ```ts
* // Creating a HashSet from other Effect's data structures like Chunk
* 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 module:HashSet.empty} {@link module:HashSet.make}
*/
export const 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 {@link module:HashSet.fromIterable} {@link module:HashSet.empty}
*/
export const 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
*
* ```ts
* // Syntax
* 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 module:HashSet.some} {@link module:HashSet.every} {@link module:HashSet.isSubset}
*/
export const 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
*
* ```ts
* // Syntax
* 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 module:HashSet.has} {@link module:HashSet.every} {@link module:HashSet.isSubset}
*/
export const 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
*
* ```ts
* // Syntax with Refinement
* 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
*
* ```ts
* // Syntax with Predicate
* 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 module:HashSet.has} {@link module:HashSet.some} {@link module:HashSet.isSubset}
*/
export const every = HS.every;
/**
* Returns `true` if and only if every element in the this `HashSet` is an
* element of the second set,
*
* **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
*
* ```ts
* // Syntax
* 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 module:HashSet.has} {@link module:HashSet.some} {@link module:HashSet.every}
*/
export const 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 module:HashSet.toValues} {@link module:HashSet.size}
*/
export const 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 module:HashSet.values} {@link module:HashSet.size}
*/
export 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 module:HashSet.values} {@link module:HashSet.toValues}
*/
export const size = HS.size;
/**
* 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 module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
*/
export const beginMutation = HS.beginMutation;
/**
* 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 {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.mutate}
*/
export const 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 {@link module:HashSet.beginMutation} `->` `mutable
* context` `->` {@link HashSet.endMutation}.
*
* @memberof HashSet
* @since 2.0.0
* @example
*
* ```ts
* // Syntax
* 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 {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation}
*/
export const 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
*
* ```ts
* // Syntax
* 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 module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
*/
export const add = HS.add;
/**
* Removes a value from the `HashSet`.
*
* Time complexity: **`O(1)`** average
*
* @memberof HashSet
* @since 2.0.0
* @example
*
* ```ts
* // Syntax
* 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 module:HashSet.add} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
*/
export const remove = HS.remove;
/**
* 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; 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
*
* ```ts
* // Syntax
* 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 module:HashSet.intersection} {@link module:HashSet.union}
*/
export const difference = HS.difference;
/**
* Returns a `HashSet` of values which are present in both this set and that
* `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
*
* ```ts
* // Syntax
* 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 module:HashSet.difference} {@link module:HashSet.union}
*/
export const intersection = HS.intersection;
/**
* 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
*
* ```ts
* // Syntax
* 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 module:HashSet.difference} {@link module:HashSet.intersection}
*/
export const union = HS.union;
/**
* Checks if a value is present in the `HashSet`. If it is present, the value
* 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
*
* ```ts
* // Syntax
* 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 module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
*/
export const 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
*
* ```ts
* // Syntax
* 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)
* ```
*/
export const 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
*
* ```ts
* // Syntax
* 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)))
* ```
*/
export const 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
*
* ```ts
* // Syntax
* 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
* ```
*/
export const 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
*
* ```ts
* // Syntax
* 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)
* ```
*/
export const 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
*
* ```ts
* // Syntax with Predicate
* 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
*
* ```ts
* /// Syntax with Refinement
* 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>
* ```
*/
export const filter = HS.filter;
/**
* Partition the values of a `HashSet` using the specified predicate.
*
* If a value matches the predicate, it will be placed into the `HashSet` on the
* 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
*
* ```ts
* // Syntax with Predicate
* 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
*
* ```ts
* // Syntax with Refinement
* 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
* )
* ```
*/
export const partition = HS.partition;
//# sourceMappingURL=HashSet.js.map