Lorem Ipsum MCP Server

/** * # 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 type { Equal } from "./Equal.js"; import type { Inspectable } from "./Inspectable.js"; import type { Pipeable } from "./Pipeable.js"; import type { Predicate, Refinement } from "./Predicate.js"; import type { NoInfer } from "./Types.js"; declare const TypeId: unique symbol; /** * @since 2.0.0 * @category symbol */ export type TypeId = typeof TypeId; /** * @memberof HashSet * @since 2.0.0 * @category models * @example * * ```ts * // Syntax * import { HashSet } from "effect" * * let numberSet: HashSet.HashSet<number> * ``` * * @interface */ export interface HashSet<out A> extends Iterable<A>, Equal, Pipeable, Inspectable { readonly [TypeId]: TypeId; } /** * @memberof HashSet * @since 2.0.0 * @category refinements */ export declare const isHashSet: { /** * Type guard function to determine if a given iterable is a `HashSet`. * * This overload preserves the type of the iterable's elements. * * @example * * ```ts * import { HashSet } from "effect" * * const numberIterable: Iterable<1 | 2 | 3> = [1, 2, 3] * * if ( * // if passed an Iterable<A> the type guard that preserves the type parameter <A> * HashSet.isHashSet(numberIterable) * ) { * const HashSet: HashSet.HashSet<1 | 2 | 3> = numberIterable * } * ``` * * @param u - The iterable input to be checked. * @returns A boolean indicating whether the provided iterable is a `HashSet`. */ <A>(u: Iterable<A>): u is HashSet<A>; /** * Type guard function that checks if the provided value is a `HashSet` of * unknown type. * * @example * * ```ts * import { HashSet } from "effect" * import assert from "node:assert/strict" * * // Check if a value is a HashSet * const set = HashSet.make(1, 2, 3) * * assert.equal(HashSet.isHashSet(set), true) // true * assert.equal(HashSet.isHashSet(HashSet.empty()), true) * * // Works with any type * assert.equal(HashSet.isHashSet(null), false) // false * assert.equal(HashSet.isHashSet({}), false) // false * assert.equal(HashSet.isHashSet([1, 2, 3]), false) // false * ``` * * @param u - The value to check. * @returns A boolean indicating whether the value is a `HashSet<unknown>`. */ (u: unknown): u is HashSet<unknown>; }; /** * 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 declare const empty: <A = never>() => HashSet<A>; /** * 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 declare const fromIterable: <A>(elements: Iterable<A>) => HashSet<A>; /** * 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 declare const make: <As extends ReadonlyArray<any>>(...elements: As) => HashSet<As[number]>; /** * 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 declare const has: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import * as assert from "node:assert/strict" * import { HashSet, pipe } from "effect" * * const set = HashSet.make(0, 1, 2) * * assert.equal(pipe(set, HashSet.has(0)), true) * assert.equal(pipe(set, HashSet.has(1)), true) * assert.equal(pipe(set, HashSet.has(2)), true) * assert.equal(pipe(set, HashSet.has(3)), false) * ``` */ <A>(value: A): (self: HashSet<A>) => boolean; /** * @example * * ```ts * // `data-first` API * import * as assert from "node:assert/strict" * import { HashSet, pipe } from "effect" * * const set = HashSet.make(0, 1, 2) * * assert.equal(HashSet.has(set, 0), true) * assert.equal(HashSet.has(set, 1), true) * assert.equal(HashSet.has(set, 2), true) * assert.equal(HashSet.has(set, 3), false) * ``` */ <A>(self: HashSet<A>, value: A): boolean; }; /** * 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 declare const some: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import * as assert from "node:assert/strict" * import { HashSet, pipe } from "effect" * * const set = HashSet.make(0, 1, 2) * * assert.equal( * pipe( * set, * HashSet.some((n) => n > 0) * ), * true * ) * * assert.equal( * pipe( * set, * HashSet.some((n) => n > 2) * ), * false * ) * ``` */ <A>(f: Predicate<A>): (self: HashSet<A>) => boolean; /** * @example * * ```ts * // `data-first` API * import * as assert from "node:assert/strict" * import { HashSet } from "effect" * * const set = HashSet.make(0, 1, 2) * * assert.equal( * HashSet.some(set, (n) => n > 0), * true * ) * * assert.equal( * HashSet.some(set, (n) => n > 2), * false * ) * ``` */ <A>(self: HashSet<A>, f: Predicate<A>): boolean; }; /** * 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 declare const every: { /** * @example * * ```ts * import * as assert from "node:assert/strict" * import { Effect, HashSet, pipe, Predicate } from "effect" * * const numberOrString: HashSet.HashSet<number | string> = HashSet.make( * 1, * "1", * "one", * "uno" * ) * * assert.equal( * pipe( * numberOrString, // HashSet.HashSet<number | string> * HashSet.every(Predicate.isString) * ), // HashSet.HashSet<string> * false * ) * ``` */ <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => self is HashSet<B>; /** * @example * * ```ts * import * as assert from "node:assert/strict" * import { HashSet, pipe } from "effect" * * const set = HashSet.make(0, 1, 2) * * assert.equal( * pipe( * set, * HashSet.every((n) => n >= 0) * ), * true * ) * ``` */ <A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean; /** * @example * * ```ts * import * as assert from "node:assert/strict" * import { Effect, HashSet, pipe, Predicate } from "effect" * * const numberOrString: HashSet.HashSet<number | string> = HashSet.make( * 1, * "1", * "one", * "uno" * ) * * assert.equal( * HashSet.every( * numberOrString, // HashSet.HashSet<number | string> * Predicate.isString * ), // HashSet.HashSet<string> * false * ) * ``` */ <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): self is HashSet<B>; /** * @example * * ```ts * import * as assert from "node:assert/strict" * import { HashSet } from "effect" * * const set = HashSet.make(0, 1, 2) * * assert.equal( * HashSet.every(set, (n) => n >= 0), * true * ) * ``` */ <A>(self: HashSet<A>, predicate: Predicate<A>): boolean; }; /** * 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 declare const isSubset: { /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * assert.equal( * pipe( * HashSet.make(0, 1), // * HashSet.isSubset(HashSet.make(1, 2)) * ), * false * ) * * assert.equal( * pipe( * HashSet.make(0, 1), // * HashSet.isSubset(HashSet.make(0, 1, 2)) * ), * true * ) * ``` */ <A>(that: HashSet<A>): (self: HashSet<A>) => boolean; /** * @example * * ```ts * import { HashSet } from "effect" * import * as assert from "node:assert/strict" * * assert.equal(HashSet.isSubset(set1, set2), false) * * assert.equal(HashSet.isSubset(set1, set3), true) * ``` */ <A>(self: HashSet<A>, that: HashSet<A>): boolean; }; /** * 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 declare const values: <A>(self: HashSet<A>) => IterableIterator<A>; /** * 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 declare const toValues: <A>(self: HashSet<A>) => Array<A>; /** * 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 declare const size: <A>(self: HashSet<A>) => number; /** * 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 declare const beginMutation: <A>(self: HashSet<A>) => HashSet<A>; /** * 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 declare const endMutation: <A>(self: HashSet<A>) => HashSet<A>; /** * 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 declare const mutate: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import assert from "node:assert/strict" * * // Create a set with initial values * const immutableSet = HashSet.make(1, 2, 3) * * // Use mutate to perform multiple operations efficiently * const result = pipe( * immutableSet, * HashSet.mutate((set) => { * assert.equal(Object.is(immutableSet, set), false) * * // The set is temporarily mutable inside this function * const mod1 = HashSet.add(set, 4) * const mod2 = HashSet.remove(set, 1) * assert.equal(Object.is(mod1, mod2), true) // they are the same object by reference * }) * ) * * // The original set is unchanged * assert.equal(Object.is(immutableSet, result), false) * assert.deepStrictEqual( * HashSet.toValues(immutableSet).sort(), * [1, 2, 3] * ) * * // The result contains the mutations * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3, 4]) * ``` */ <A>(f: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet } from "effect" * import assert from "node:assert/strict" * * // Create a set with initial values * const immutableSet = HashSet.make(1, 2, 3) * * // Use mutate with data-first API * const result = HashSet.mutate(immutableSet, (set) => { * // The set is temporarily mutable inside this function * HashSet.add(set, 4) * HashSet.remove(set, 1) * }) * * // The original set is unchanged * assert.equal(Object.is(immutableSet, result), false) * assert.deepStrictEqual( * HashSet.toValues(immutableSet).sort(), * [1, 2, 3] * ) * * // The result contains the mutations * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3, 4]) * ``` */ <A>(self: HashSet<A>, f: (set: HashSet<A>) => void): HashSet<A>; }; /** * 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 declare const add: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import assert from "node:assert/strict" * * assert.deepStrictEqual( * pipe( * HashSet.empty<number>(), // HashSet.HashSet<number> * HashSet.add(0), * HashSet.add(1), * HashSet.add(1), * HashSet.add(2), * HashSet.toValues * ), * Array.of(0, 1, 2) * ) * ``` */ <A>(value: A): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet, pipe } from "effect" * import assert from "node:assert/strict" * * const empty = HashSet.empty<number>() * const withZero = HashSet.add(empty, 0) * const withOne = HashSet.add(withZero, 1) * const withTwo = HashSet.add(withOne, 2) * const withTwoTwo = HashSet.add(withTwo, 2) * * assert.deepStrictEqual(HashSet.toValues(withTwoTwo), Array.of(0, 1, 2)) * ``` */ <A>(self: HashSet<A>, value: A): HashSet<A>; }; /** * 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 declare const remove: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * const set = HashSet.make(0, 1, 2) * const result = pipe(set, HashSet.remove(0)) * * assert.equal(pipe(result, HashSet.has(0)), false) // it has correctly removed 0 * assert.equal(pipe(set, HashSet.has(0)), true) // it does not mutate the original set * assert.equal(pipe(result, HashSet.has(1)), true) * assert.equal(pipe(result, HashSet.has(2)), true) * ``` */ <A>(value: A): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * const set = HashSet.make(0, 1, 2) * const result = HashSet.remove(set, 0) * * assert.equal(HashSet.has(result, 0), false) // it has correctly removed 0 * assert.equal(HashSet.has(set, 0), true) // it does not mutate the original set * assert.equal(HashSet.has(result, 1), true) * assert.equal(HashSet.has(result, 2), true) * ``` */ <A>(self: HashSet<A>, value: A): HashSet<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; 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 declare const difference: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * // Create two sets with some overlapping elements * const thisSet = HashSet.make(1, 2, 3) * const thatIterable = HashSet.make(3, 4, 5) * * // Compute the difference (elements in thisSet that are not in thatIterable) * const result = pipe(thisSet, HashSet.difference(thatIterable)) * * // The result contains only elements from thisSet that are not in thatIterable * assert.deepStrictEqual(HashSet.toValues(result).sort(), [1, 2]) * * // The original sets are unchanged * assert.deepStrictEqual(HashSet.toValues(thisSet).sort(), [1, 2, 3]) * assert.deepStrictEqual( * HashSet.toValues(thatIterable).sort(), * [3, 4, 5] * ) * * // You can also use arrays or other iterables * const diffWithArray = pipe(thisSet, HashSet.difference([3, 4])) * assert.deepStrictEqual(HashSet.toValues(diffWithArray).sort(), [1, 2]) * ``` */ <A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet } from "effect" * import * as assert from "node:assert/strict" * * // Create two sets with some overlapping elements * const thisSet = HashSet.make(1, 2, 3) * const thatIterable = HashSet.make(3, 4, 5) * * // Compute the difference using data-first API * const result = HashSet.difference(thisSet, thatIterable) * * // The result contains only elements from thisSet that are not in thatIterable * assert.deepStrictEqual(HashSet.toValues(result).sort(), [1, 2]) * * // The original sets are unchanged * assert.deepStrictEqual(HashSet.toValues(thisSet).sort(), [1, 2, 3]) * assert.deepStrictEqual( * HashSet.toValues(thatIterable).sort(), * [3, 4, 5] * ) * * // You can also compute the difference in the other direction * const reverseResult = HashSet.difference(thatIterable, thisSet) * assert.deepStrictEqual(HashSet.toValues(reverseResult).sort(), [4, 5]) * ``` */ <A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>; }; /** * 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 declare const intersection: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * // Create two sets with some overlapping elements * const set1 = HashSet.make(1, 2, 3) * const set2 = HashSet.make(2, 3, 4) * * // Compute the intersection (elements that are in both sets) * const result = pipe(set1, HashSet.intersection(set2)) * * // The result contains only elements that are in both sets * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3]) * * // The original sets are unchanged * assert.deepStrictEqual(HashSet.toValues(set1).sort(), [1, 2, 3]) * assert.deepStrictEqual(HashSet.toValues(set2).sort(), [2, 3, 4]) * * // You can also use arrays or other iterables * const intersectWithArray = pipe(set1, HashSet.intersection([2, 3, 5])) * assert.deepStrictEqual( * HashSet.toValues(intersectWithArray).sort(), * [2, 3] * ) * ``` */ <A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet } from "effect" * import * as assert from "node:assert/strict" * * // Create two sets with some overlapping elements * const set1 = HashSet.make(1, 2, 3) * const set2 = HashSet.make(2, 3, 4) * * // Compute the intersection using data-first API * const result = HashSet.intersection(set1, set2) * * // The result contains only elements that are in both sets * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3]) * * // The original sets are unchanged * assert.deepStrictEqual(HashSet.toValues(set1).sort(), [1, 2, 3]) * assert.deepStrictEqual(HashSet.toValues(set2).sort(), [2, 3, 4]) * * // You can also use arrays or other iterables * const intersectWithArray = HashSet.intersection(set1, [2, 3, 5]) * assert.deepStrictEqual( * HashSet.toValues(intersectWithArray).sort(), * [2, 3] * ) * ``` */ <A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>; }; /** * 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 declare const union: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * // Create two sets with some overlapping elements * const selfSet = HashSet.make(1, 2, 3) * const thatIterable = HashSet.make(3, 4, 5) * * // Compute the union (all elements from both sets) * const result = pipe(selfSet, HashSet.union(thatIterable)) * * // The result contains all elements from both sets (without duplicates) * assert.deepStrictEqual( * HashSet.toValues(result).sort(), * [1, 2, 3, 4, 5] * ) * * // The original sets are unchanged * assert.deepStrictEqual(HashSet.toValues(selfSet).sort(), [1, 2, 3]) * assert.deepStrictEqual( * HashSet.toValues(thatIterable).sort(), * [3, 4, 5] * ) * * // You can also use arrays or other iterables * const unionWithArray = pipe(selfSet, HashSet.union([4, 5, 6])) * assert.deepStrictEqual( * HashSet.toValues(unionWithArray).sort(), * [1, 2, 3, 4, 5, 6] * ) * ``` */ <A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet } from "effect" * import * as assert from "node:assert/strict" * * // Create two sets with some overlapping elements * const selfSet = HashSet.make(1, 2, 3) * const thatIterable = HashSet.make(3, 4, 5) * * // Compute the union using data-first API * const result = HashSet.union(selfSet, thatIterable) * * // The result contains all elements from both sets (without duplicates) * assert.deepStrictEqual( * HashSet.toValues(result).sort(), * [1, 2, 3, 4, 5] * ) * * // The original sets are unchanged * assert.deepStrictEqual(HashSet.toValues(selfSet).sort(), [1, 2, 3]) * assert.deepStrictEqual( * HashSet.toValues(thatIterable).sort(), * [3, 4, 5] * ) * * // You can also use arrays or other iterables * const unionWithArray = HashSet.union(selfSet, [4, 5, 6]) * assert.deepStrictEqual( * HashSet.toValues(unionWithArray).sort(), * [1, 2, 3, 4, 5, 6] * ) * ``` */ <A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>; }; /** * 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 declare const toggle: { /** * @example * * ```ts * // `data-last` a.k.a. `pipeable` API * import { HashSet, pipe } from "effect" * import assert from "node:assert/strict" * * // arrange * let set = HashSet.make(0, 1, 2) * * // assert 1: 0 is in the set * assert.equal(pipe(set, HashSet.has(0)), true) * * // act 2: toggle 0 once on the set * set = pipe(set, HashSet.toggle(0)) * * // assert 2: 0 is not in the set any longer * assert.equal(pipe(set, HashSet.has(0)), false) * * // act 3: toggle 0 once again on the set * set = pipe(set, HashSet.toggle(0)) * * // assert 3: 0 in now back in the set * assert.equal(pipe(set, HashSet.has(0)), true) * ``` */ <A>(value: A): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * // `data-first` API * import { HashSet, pipe } from "effect" * import assert from "node:assert/strict" * * // arrange * let set = HashSet.make(0, 1, 2) * * // assert 1: 0 is in the set * assert.equal(HashSet.has(set, 0), true) * * // act 2: toggle 0 once on the set * set = HashSet.toggle(set, 0) * * // assert 2: 0 is not in the set any longer * assert.equal(HashSet.has(set, 0), false) * * // act 3: toggle 0 once again on the set * set = HashSet.toggle(set, 0) * * // assert 3: 0 in now back in the set * assert.equal(HashSet.has(set, 0), true) * ``` */ <A>(self: HashSet<A>, value: A): HashSet<A>; }; /** * 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 declare const map: { /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * assert.deepStrictEqual( * pipe( * HashSet.make(0, 1, 2), // HashSet.HashSet<number> * HashSet.map((n) => String(n + 1)) // HashSet.HashSet<String> * ), * HashSet.make("1", "2", "3") * ) * ``` */ <A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>; /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * assert.deepStrictEqual( * HashSet.map( * HashSet.make(0, 1, 2), // HashSet.HashSet<number> * (n) => String(n + 1) * ), // HashSet.HashSet<String> * HashSet.make("1", "2", "3") * ) * ``` */ <A, B>(self: HashSet<A>, f: (a: A) => B): HashSet<B>; }; /** * 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 declare const flatMap: { /** * @example * * ```ts * import { HashSet, pipe, List } from "effect" * import * as assert from "node:assert/strict" * * assert.deepStrictEqual( * pipe( * HashSet.make(0, 1, 2), * HashSet.flatMap((n) => List.of(String(n * n))) // needs to return an Iterable * ), * HashSet.make("0", "1", "4") * ) * ``` */ <A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>; /** * @example * * ```ts * import { HashSet, pipe, List } from "effect" * import * as assert from "node:assert/strict" * * assert.deepStrictEqual( * HashSet.flatMap(HashSet.make(0, 1, 2), (n) => * List.of(String(n * n * n)) * ), // needs to return an Iterable * HashSet.make("0", "1", "8") * ) * ``` */ <A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>): HashSet<B>; }; /** * 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 declare const forEach: { /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * const result: Array<number> = [] * * pipe( * HashSet.make(0, 1, 2), * HashSet.forEach((n): void => { * result.push(n) * }) * ) * * assert.deepStrictEqual(result, [0, 1, 2]) * ``` */ <A>(f: (value: A) => void): (self: HashSet<A>) => void; /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * const result: Array<number> = [] * * HashSet.forEach(HashSet.make(0, 1, 2), (n): void => { * result.push(n) * }) * * assert.deepStrictEqual(result, [0, 1, 2]) * ``` */ <A>(self: HashSet<A>, f: (value: A) => void): void; }; /** * 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 declare const reduce: { /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * assert.equal( * pipe( * HashSet.make(0, 1, 2), * HashSet.reduce(10, (accumulator, value) => accumulator + value) * ), * 13 * ) * ``` */ <A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet<A>) => Z; /** * @example * * ```ts * import { HashSet } from "effect" * import * as assert from "node:assert/strict" * * assert.equal( * HashSet.reduce( * HashSet.make(0, 1, 2), * -3, * (accumulator, value) => accumulator + value * ), * 0 * ) * ``` */ <A, Z>(self: HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): Z; }; /** * 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 declare const filter: { /** * @example * * ```ts * import { HashSet, pipe, Predicate } from "effect" * import * as assert from "node:assert/strict" * * const numbersAndStringsHashSet: HashSet.HashSet<number | string> = * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") * * const stringRefinement: Predicate.Refinement< * string | number, * string * > = (value) => typeof value === "string" * * const stringHashSet: HashSet.HashSet<string> = pipe( * numbersAndStringsHashSet, * HashSet.filter(stringRefinement) * ) * * assert.equal( * pipe(stringHashSet, HashSet.every(Predicate.isString)), * true * ) * ``` */ <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => HashSet<B>; /** * @example * * ```ts * import { HashSet, pipe, type Predicate } from "effect" * import * as assert from "node:assert/strict" * * const filterPositiveNumbers: Predicate.Predicate<number> = (n) => n > 0 * * assert.deepStrictEqual( * pipe( * HashSet.make(-2, -1, 0, 1, 2), * HashSet.filter(filterPositiveNumbers) * ), * HashSet.make(1, 2) * ) * ``` */ <A>(predicate: Predicate<NoInfer<A>>): (self: HashSet<A>) => HashSet<A>; /** * @example * * ```ts * import { HashSet, Predicate } from "effect" * import * as assert from "node:assert/strict" * * const numbersAndStringsHashSet: HashSet.HashSet<number | string> = * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") * * const stringRefinement: Predicate.Refinement< * string | number, * string * > = (value) => typeof value === "string" * * const stringHashSet: HashSet.HashSet<string> = HashSet.filter( * numbersAndStringsHashSet, * stringRefinement * ) * * assert.equal(HashSet.every(stringHashSet, Predicate.isString), true) * ``` */ <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>; /** * @example * * ```ts * import { HashSet, pipe, type Predicate } from "effect" * import * as assert from "node:assert/strict" * * const filterPositiveNumbers: Predicate.Predicate<number> = (n) => n > 0 * * assert.deepStrictEqual( * HashSet.filter(HashSet.make(-2, -1, 0, 1, 2), filterPositiveNumbers), * HashSet.make(1, 2) * ) * ``` */ <A>(self: HashSet<A>, predicate: Predicate<A>): HashSet<A>; }; /** * 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 declare const partition: { /** * @example * * ```ts * import { HashSet, pipe, Predicate } from "effect" * import * as assert from "node:assert/strict" * * const numbersAndStringsHashSet: HashSet.HashSet<number | string> = * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") * * const stringRefinement: Predicate.Refinement< * string | number, * string * > = (value) => typeof value === "string" * * const [ * excluded, // HashSet.HashSet<number> * satisfying // HashSet.HashSet<string> * ] = pipe(numbersAndStringsHashSet, HashSet.partition(stringRefinement)) * * assert.equal(pipe(satisfying, HashSet.every(Predicate.isString)), true) * assert.equal(pipe(excluded, HashSet.every(Predicate.isNumber)), true) * * assert.deepStrictEqual(excluded, HashSet.make(1, 2, 3, 4)) * assert.deepStrictEqual( * satisfying, * HashSet.make("unos", "two", "trois", "vier") * ) * ``` */ <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]; /** * @example * * ```ts * import { HashSet, pipe } from "effect" * import * as assert from "node:assert/strict" * * const [excluded, satisfying] = pipe( * HashSet.make(0, 1, 2, 3, 4, 5), * HashSet.partition((n) => n % 2 === 0) * ) * * assert.deepStrictEqual(excluded, HashSet.make(1, 3, 5)) * assert.deepStrictEqual(satisfying, HashSet.make(0, 2, 4)) * ``` */ <A>(predicate: Predicate<NoInfer<A>>): (self: HashSet<A>) => [excluded: HashSet<A>, satisfying: HashSet<A>]; /** * @example * * ```ts * import { HashSet, pipe, Predicate } from "effect" * import * as assert from "node:assert/strict" * * const numbersAndStringsHashSet: HashSet.HashSet<number | string> = * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") * * const stringRefinement: Predicate.Refinement< * string | number, * string * > = (value) => typeof value === "string" * * const [ * excluded, // HashSet.HashSet<number> * satisfying // HashSet.HashSet<string> * ] = HashSet.partition(numbersAndStringsHashSet, stringRefinement) * * assert.equal(HashSet.every(satisfying, Predicate.isString), true) * assert.equal(HashSet.every(excluded, Predicate.isNumber), true) * * assert.deepStrictEqual(excluded, HashSet.make(1, 2, 3, 4)) * assert.deepStrictEqual( * satisfying, * HashSet.make("unos", "two", "trois", "vier") * ) * ``` */ <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]; /** * @example * * ```ts * import { HashSet } from "effect" * import * as assert from "node:assert/strict" * * const [excluded, satisfying] = HashSet.partition( * HashSet.make(0, 1, 2, 3, 4, 5), * (n) => n % 2 === 0 * ) * * assert.deepStrictEqual(excluded, HashSet.make(1, 3, 5)) * assert.deepStrictEqual(satisfying, HashSet.make(0, 2, 4)) * ``` */ <A>(self: HashSet<A>, predicate: Predicate<A>): [excluded: HashSet<A>, satisfying: HashSet<A>]; }; export {}; //# sourceMappingURL=HashSet.d.ts.map