Skip to content

MutableHashSet

# MutableHashSet

A mutable MutableHashSet provides a collection of unique values with efficient lookup, insertion and removal. Unlike its immutable sibling module:HashSet, a MutableHashSet can be modified in-place; operations like add, remove, and clear directly modify the original set rather than creating a new one. This mutability offers benefits like improved performance in scenarios where you need to build or modify a set incrementally.

## What Problem Does It Solve?

MutableHashSet solves the problem of maintaining an unsorted collection where each value appears exactly once, with fast operations for checking membership and adding/removing values, in contexts where mutability is preferred for performance or implementation simplicity.

## When to Use

Use MutableHashSet when you need:

- A collection with no duplicate values - Efficient membership testing (O(1) average complexity) - In-place modifications for better performance - A set that will be built or modified incrementally - Local mutability in otherwise immutable code

## Advanced Features

MutableHashSet provides operations for:

- Adding and removing elements with direct mutation - Checking for element existence - Clearing all elements at once - Converting to/from other collection types

## Performance Characteristics

- Lookup operations (module:MutableHashSet.has): O(1) average time complexity - Insertion operations (module:MutableHashSet.add): O(1) average time complexity - Removal operations (module:MutableHashSet.remove): O(1) average time complexity - Iteration: O(n) where n is the size of the set

The MutableHashSet data structure implements the following traits:

- Iterable: allows iterating over the values in the set - Pipeable: allows chaining operations with the pipe operator - Inspectable: allows inspecting the contents of the set

## Operations Reference

| Category | Operation | Description | Complexity | | ------------ | ------------------------------------------ | ----------------------------------- | ---------- | | constructors | module:MutableHashSet.empty | Creates an empty MutableHashSet | O(1) | | constructors | module:MutableHashSet.fromIterable | Creates a set from an iterable | O(n) | | constructors | module:MutableHashSet.make | Creates a set from multiple values | O(n) | | | | | | | elements | module:MutableHashSet.has | Checks if a value exists in the set | O(1) avg | | elements | module:MutableHashSet.add | Adds a value to the set | O(1) avg | | elements | module:MutableHashSet.remove | Removes a value from the set | O(1) avg | | elements | module:MutableHashSet.size | Gets the number of elements | O(1) | | elements | module:MutableHashSet.clear | Removes all values from the set | O(1) |

## Notes

### Mutability Considerations:

Unlike most data structures in the Effect ecosystem, MutableHashSet is mutable. This means that operations like add, remove, and clear modify the original set rather than creating a new one. This can lead to more efficient code in some scenarios, but requires careful handling to avoid unexpected side effects.

### When to Choose MutableHashSet vs module:HashSet:

- Use MutableHashSet when you need to build or modify a set incrementally and performance is a priority - Use HashSet when you want immutability guarantees and functional programming patterns - Consider using module:HashSet's bounded mutation context (via module:HashSet.beginMutation, module:HashSet.endMutation, and module:HashSet.mutate methods) when you need temporary mutability within an otherwise immutable context - this approach might be sufficient for many use cases without requiring a separate MutableHashSet - MutableHashSet is often useful for local operations where the mutability is contained and doesn't leak into the broader application

10 exports Added in v2.0.0 Source

Constructors

empty

Added in v2.0.0 Source

Creates an empty mutable hash set.

This function initializes and returns an empty MutableHashSet instance, which allows for efficient storage and manipulation of unique elements.

Time complexity: O(1)

See

  • Other MutableHashSet constructors are module:MutableHashSet.make module:MutableHashSet.fromIterable

Signature

declare function empty<K = never>(): MutableHashSet<K>;

fromIterable

Added in v2.0.0 Source

Creates a new MutableHashSet from an iterable collection of values. Duplicate values are omitted.

Time complexity: O(n) where n is the number of elements in the iterable

Creating a MutableHashSet from an Array

Creating a MutableHashSet from a Set

Creating a MutableHashSet from a Generator

Creating a MutableHashSet from another module:MutableHashSet

Creating a MutableHashSet from an module:HashSet

Creating a MutableHashSet from other Effect's data structures like Chunk

See

  • Other MutableHashSet constructors are module:MutableHashSet.empty module:MutableHashSet.make

Signature

declare function fromIterable<K = never>(keys: Iterable<K>): MutableHashSet<K>;

make

Added in v2.0.0 Source

Construct a new MutableHashSet from a variable number of values.

Time complexity: O(n) where n is the number of elements

See

  • Other MutableHashSet constructors are module:MutableHashSet.fromIterable module:MutableHashSet.empty

Signature

declare function make<Keys extends readonly Array<unknown>>(...keys: Keys): MutableHashSet<Keys[number]>

Elements

add

Added in v2.0.0 Source

Checks whether the MutableHashSet contains the given element, and adds it if not.

Time complexity: O(1) average

Syntax

See

  • Other MutableHashSet elements are module:MutableHashSet.remove module:MutableHashSet.size module:MutableHashSet.clear module:MutableHashSet.has

Signature

declare const add: {
  <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
  <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
};

Example

import { MutableHashSet, pipe } from "effect"

// with data-last, a.k.a. pipeable API
pipe(MutableHashSet.empty(), MutableHashSet.add(0), MutableHashSet.add(0))

// or piped with the pipe function
MutableHashSet.empty().pipe(MutableHashSet.add(0))

// or with data-first API
MutableHashSet.add(MutableHashSet.empty(), 0)

clear

Added in v2.0.0 Source

Removes all values from the MutableHashSet.

This function operates by delegating the clearing action to the underlying key map associated with the given MutableHashSet. It ensures that the hash set becomes empty while maintaining its existence and structure.

See

  • Other MutableHashSet elements are module:MutableHashSet.add module:MutableHashSet.has module:MutableHashSet.remove module:MutableHashSet.size

Signature

declare function clear<V>(self: MutableHashSet<V>): MutableHashSet<V>;

has

Added in v2.0.0 Source

Checks if the specified value exists in the MutableHashSet.

Time complexity: O(1) average

Syntax

See

  • Other MutableHashSet elements are module:MutableHashSet.add module:MutableHashSet.remove module:MutableHashSet.size module:MutableHashSet.clear

Signature

declare const has: {
  <V>(key: V): (self: MutableHashSet<V>) => boolean;
  <V>(self: MutableHashSet<V>, key: V): boolean;
};

Example

import { MutableHashSet, pipe } from "effect"
import assert from "node:assert/strict"

assert.equal(
  // with `data-last`, a.k.a. `pipeable` API
  pipe(MutableHashSet.make(0, 1, 2), MutableHashSet.has(3)),
  false,
)

assert.equal(
  // or piped with the pipe function
  MutableHashSet.make(0, 1, 2).pipe(MutableHashSet.has(3)),
  false,
)

assert.equal(
  // or with `data-first` API
  MutableHashSet.has(MutableHashSet.make(0, 1, 2), 3),
  false,
)

remove

Added in v2.0.0 Source

Removes a value from the MutableHashSet.

Time complexity: O(1) average

Syntax

See

  • Other MutableHashSet elements are module:MutableHashSet.add module:MutableHashSet.has module:MutableHashSet.size module:MutableHashSet.clear

Signature

declare const remove: {
  <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
  <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
};

Example

import { MutableHashSet, pipe } from "effect"
import assert from "node:assert/strict"

assert.equal(
  // with `data-last`, a.k.a. `pipeable` API
  pipe(MutableHashSet.make(0, 1, 2), MutableHashSet.remove(0), MutableHashSet.has(0)),
  false,
)

assert.equal(
  // or piped with the pipe function
  MutableHashSet.make(0, 1, 2).pipe(MutableHashSet.remove(0), MutableHashSet.has(0)),
  false,
)

assert.equal(
  // or with `data-first` API
  MutableHashSet.remove(MutableHashSet.make(0, 1, 2), 0).pipe(MutableHashSet.has(0)),
  false,
)

size

Added in v2.0.0 Source

Calculates the number of values in the HashSet.

Time complexity: O(1)

See

  • Other MutableHashSet elements are module:MutableHashSet.add module:MutableHashSet.has module:MutableHashSet.remove module:MutableHashSet.clear

Signature

declare function size<V>(self: MutableHashSet<V>): number;

Models

MutableHashSet interface

Added in v2.0.0 Source

Signature

interface MutableHashSet<out V> extends Iterable<V>, Pipeable, Inspectable {
  readonly [TypeId]: typeof TypeId;
}

Symbol

TypeId type

Added in v2.0.0 Source

Signature

type TypeId = typeof TypeId;