HashMap

Stores key/value entries in an immutable hash map.

A HashMap<Key, Value> hashes keys and resolves matches with Effect's structural equality rules. Lookup, insertion, removal, and transformation operations return new maps, while temporary mutation helpers support efficient batch updates. This module also includes constructors, iteration, conversion, mapping, filtering, and reducing helpers.

40 exports Added in v2.0.0 Source

Combining

union

Added in v2.0.0 Source

Combines two HashMaps into one.

Details

Entries from that are inserted into self; when both maps contain an equal key, the value from that replaces the value from self.

Signature

declare const union: {
  <K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>;
  <K0, V0, K1, V1>(self: HashMap<K0, V0>, that: HashMap<K1, V1>): HashMap<K0 | K1, V0 | V1>;
}

Example

(Combining HashMaps)

import { HashMap, Option } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2])
const map2 = HashMap.make(["b", 20], ["c", 3])
const union = HashMap.union(map1, map2)

union // => HashMap.make(["a", 1], ["b", 20], ["c", 3])
HashMap.get(union, "b") // => Option.some(20)

Constructors

empty

Added in v2.0.0 Source

Creates a new empty HashMap.

Signature

declare const empty: <K = never, V = never>() => HashMap<K, V>

Example

(Creating an empty HashMap)

import { HashMap } from "effect"

HashMap.empty<string, number>() // => HashMap.empty()

fromIterable

Added in v2.0.0 Source

Creates a new HashMap from an iterable collection of key/value pairs.

Signature

declare const fromIterable: <K, V>(entries: Iterable<readonly [K, V]>) => HashMap<K, V>

Example

(Creating a HashMap from an iterable)

import { HashMap } from "effect"

const entries = [["a", 1], ["b", 2], ["c", 3]] as const
HashMap.fromIterable(entries) // => HashMap.make(["a", 1], ["b", 2], ["c", 3])

make

Added in v2.0.0 Source

Constructs a new HashMap from an array of key/value pairs.

Signature

declare const make: <Entries extends ReadonlyArray<readonly [any, any]>>(...entries: Entries) => HashMap<Entries[number] extends readonly [infer K, any] ? K : never, Entries[number] extends readonly [any, infer V] ? V : never>

Example

(Creating a HashMap from entries)

import { HashMap } from "effect"

HashMap.make(["a", 1], ["b", 2], ["c", 3]) // => HashMap.make(["a", 1], ["b", 2], ["c", 3])

Filtering

compact

Added in v2.0.0 Source

Filters out None values from a HashMap of Optionss.

Signature

declare const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A>

Example

(Compacting Option values)

import { HashMap, Option } from "effect"

const map1 = HashMap.make(
  ["a", Option.some(1)],
  ["b", Option.none()],
  ["c", Option.some(3)]
)
const map2 = HashMap.compact(map1)

map2 // => HashMap.make(["a", 1], ["c", 3])
HashMap.get(map2, "a") // => Option.some(1)

filter

Added in v2.0.0 Source

Filters entries out of a HashMap using the specified predicate.

Signature

declare const filter: {
  <K, A>(f: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>;
  <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>;
}

Example

(Filtering entries)

import { HashMap } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
const map2 = HashMap.filter(map1, (value) => value % 2 === 0)

map2 // => HashMap.make(["b", 2], ["d", 4])

filterMap

Added in v2.0.0 Source

Maps over the entries of the HashMap using the specified filter and keeps only successful results.

Signature

declare const filterMap: {
  <A, K, B, X>(f: (input: A, key: K) => Result<B, X>): (self: HashMap<K, A>) => HashMap<K, B>;
  <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result<B, X>): HashMap<K, B>;
}

Example

(Filtering and mapping Results)

import { HashMap, Option, Result } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
const map2 = HashMap.filterMap(
  map1,
  (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
)

map2 // => HashMap.make(["b", 4], ["d", 8])
HashMap.get(map2, "b") // => Option.some(4)

Folding

reduce

Added in v2.0.0 Source

Reduces the specified state over the entries of the HashMap.

Signature

declare const reduce: {
  <Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z;
  <K, V, Z>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z;
}

Example

(Reducing values)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
HashMap.reduce(map, 0, (acc, value) => acc + value) // => 6

Getters

entries

Added in v2.0.0 Source

Returns an IterableIterator of the entries within the HashMap.

Signature

declare const entries: <K, V>(self: HashMap<K, V>) => IterableIterator<[K, V]>

Example

(Iterating entries)

import { HashMap } from "effect"

// Create a configuration map
const config = HashMap.make(
  ["database.host", "localhost"],
  ["database.port", "5432"],
  ["cache.enabled", "true"]
)

// Sort the derived array for deterministic output
const settings = Array.from(HashMap.entries(config))
  .sort(([left], [right]) => left.localeCompare(right))
  .map(([key, value]) => `Setting ${key} = ${value}`)

settings // => ["Setting cache.enabled = true", "Setting database.host = localhost", "Setting database.port = 5432"]

// Convert to array when you need all entries at once
Array.from(HashMap.entries(config)).length // => 3

get

Added in v2.0.0 Source

Looks up the value for the specified key in the HashMap safely using the internal hashing function.

Signature

declare const get: {
  <K1, K>(key: K1): <V>(self: HashMap<K, V>) => Option<V>;
  <K1, K, V>(self: HashMap<K, V>, key: K1): Option<V>;
}

Example

(Looking up values)

import { HashMap, Option } from "effect"

const map = HashMap.make(["a", 1], ["b", 2])

HashMap.get(map, "a") // => Option.some(1)
HashMap.get(map, "c") // => Option.none()

// Using pipe syntax
HashMap.get("b")(map) // => Option.some(2)

getHash

Added in v2.0.0 Source

Looks up the value for the specified key in the HashMap safely using a custom hash.

Signature

declare const getHash: {
  <K1, K>(key: K1, hash: number): <V>(self: HashMap<K, V>) => Option<V>;
  <K1, K, V>(self: HashMap<K, V>, key: K1, hash: number): Option<V>;
}

Example

(Looking up values with a hash)

import { Hash, HashMap, Option } from "effect"

// Useful when implementing custom equality for complex keys
const userMap = HashMap.make(
  ["user123", { name: "Alice", role: "admin" }],
  ["user456", { name: "Bob", role: "user" }]
)

// Use precomputed hash for performance in hot paths
const userId = "user123"
const precomputedHash = Hash.string(userId)

// Lookup with custom hash (e.g., cached hash value)
HashMap.getHash(userMap, userId, precomputedHash) // => Option.some({ name: "Alice", role: "admin" })

// This avoids recomputing the hash when you already have it
HashMap.getHash(userMap, "user999", Hash.string("user999")) // => Option.none()

keys

Added in v2.0.0 Source

Returns an IterableIterator of the keys within the HashMap.

Signature

declare const keys: <K, V>(self: HashMap<K, V>) => IterableIterator<K>

Example

(Iterating keys)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
Array.from(HashMap.keys(map)).sort() // => ["a", "b", "c"]

size

Added in v2.0.0 Source

Returns the number of entries within the HashMap.

Signature

declare const size: <K, V>(self: HashMap<K, V>) => number

Example

(Getting the size)

import { HashMap } from "effect"

const emptyMap = HashMap.empty<string, number>()
const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])

HashMap.size(emptyMap) // => 0
HashMap.size(map) // => 3

toEntries

Added in v2.0.0 Source

Returns an Array<[K, V]> of the entries within the HashMap.

Signature

declare function toEntries<K, V>(self: HashMap<K, V>): Array<[K, V]>

Example

(Converting entries to an array)

import { HashMap } from "effect"

const gameScores = HashMap.make(
  ["alice", 1250],
  ["bob", 980],
  ["charlie", 1100]
)

// Convert to entries for processing
const scoreEntries = HashMap.toEntries(gameScores)

// Sort by score (descending)
const leaderboard = scoreEntries
  .sort(([, a], [, b]) => b - a)
  .map(([player, score], rank) => `${rank + 1}. ${player}: ${score}`)

leaderboard // => ["1. alice: 1250", "2. charlie: 1100", "3. bob: 980"]

// Convert back to HashMap if needed
HashMap.fromIterable(scoreEntries) // => HashMap.make(["alice", 1250], ["charlie", 1100], ["bob", 980])

toValues

Added in v3.13.0 Source

Returns an Array of the values within the HashMap.

Signature

declare function toValues<K, V>(self: HashMap<K, V>): Array<V>

Example

(Converting values to an array)

import { HashMap } from "effect"

const employees = HashMap.make(
  ["alice", { department: "engineering", salary: 90000 }],
  ["bob", { department: "marketing", salary: 75000 }],
  ["charlie", { department: "engineering", salary: 95000 }]
)

// Extract all employee records
const allEmployees = HashMap.toValues(employees)
allEmployees.length // => 3

// Calculate total salary
allEmployees.reduce((sum, emp) => sum + emp.salary, 0) // => 260000

// Filter by department
allEmployees.filter((emp) => emp.department === "engineering").length // => 2

values

Added in v2.0.0 Source

Returns an IterableIterator of the values within the HashMap.

Signature

declare const values: <K, V>(self: HashMap<K, V>) => IterableIterator<V>

Example

(Iterating values)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
Array.from(HashMap.values(map)).sort() // => [1, 2, 3]

Guards

isHashMap

Added in v2.0.0 Source

Checks whether a value is a HashMap.

Signature

declare const isHashMap: {
  <K, V>(u: Iterable<readonly [K, V]>): u is HashMap<K, V>;
  (u: unknown): u is HashMap<unknown, unknown>;
}

Example

(Checking HashMap values)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2])
const notMap = { a: 1 }

HashMap.isHashMap(map) // => true
HashMap.isHashMap(notMap) // => false
HashMap.isHashMap(null) // => false

Mapping

map

Added in v2.0.0 Source

Maps over the entries of the HashMap using the specified function.

Signature

declare const map: {
  <A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>;
  <K, V, A>(self: HashMap<K, V>, f: (value: V, key: K) => A): HashMap<K, A>;
}

Example

(Mapping values)

import { HashMap, Option } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3])
const map2 = HashMap.map(map1, (value, key) => `${key}:${value * 2}`)

HashMap.get(map2, "a") // => Option.some("a:2")
HashMap.get(map2, "b") // => Option.some("b:4")

Models

HashMap interface

Added in v2.0.0 Source

A HashMap is an immutable key-value data structure that provides efficient lookup, insertion, and deletion operations. It uses a Hash Array Mapped Trie (HAMT) internally for structural sharing and optimal performance.

Signature

interface HashMap<out Key, out Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
  readonly "~effect/collections/HashMap": "~effect/collections/HashMap";
}

Example

(Using basic HashMap operations)

import { HashMap, Option } from "effect"

// Create a HashMap
const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])

// Access values
HashMap.get(map, "a") // => Option.some(1)
HashMap.get(map, "d") // => Option.none()

// Check if key exists
HashMap.has(map, "b") // => true

// Add/update values (returns new HashMap)
HashMap.set(map, "d", 4) // => HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])

Mutations

beginMutation

Added in v2.0.0 Source

Creates a transient mutable HashMap for efficient batched updates.

Details

Apply updates to the returned map, then call endMutation to finish the mutation window and use the result as an immutable HashMap.

Signature

declare const beginMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V>

Example

(Beginning batch mutation)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1])

// Begin mutation for efficient batch operations
const mutable = HashMap.beginMutation(map)

// Multiple operations are now more efficient
HashMap.set(mutable, "b", 2)
HashMap.set(mutable, "c", 3)
HashMap.remove(mutable, "a")

// End mutation to get final immutable result
HashMap.endMutation(mutable) // => HashMap.make(["b", 2], ["c", 3])

endMutation

Added in v2.0.0 Source

Marks the HashMap as immutable, completing the mutation cycle.

Signature

declare const endMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V>

Example

(Ending batch mutation)

import { HashMap } from "effect"

// Start with an existing map
const original = HashMap.make(["x", 10], ["y", 20])

// Begin mutation for batch operations
const mutable = HashMap.beginMutation(original)

// Perform multiple efficient operations
HashMap.set(mutable, "z", 30)
HashMap.remove(mutable, "x")
HashMap.set(mutable, "w", 40)

// End mutation to get final immutable result
HashMap.endMutation(mutable) // => HashMap.make(["y", 20], ["z", 30], ["w", 40])

mutate

Added in v2.0.0 Source

Runs a batch of updates against a transient mutable copy of the HashMap and returns the finalized immutable result.

Details

The callback may call mutation-oriented helpers such as set and remove on the transient map.

Signature

declare const mutate: {
  <K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, f: (self: HashMap<K, V>) => void): HashMap<K, V>;
}

Example

(Applying batched mutations)

import { HashMap } from "effect"

const map1 = HashMap.make(["a", 1])
const map2 = HashMap.mutate(map1, (mutable) => {
  HashMap.set(mutable, "b", 2)
  HashMap.set(mutable, "c", 3)
})
map2 // => HashMap.make(["a", 1], ["b", 2], ["c", 3])

Other

HashMap

Added in v2.0.0 Source

The HashMap namespace contains type-level utilities and helper types for working with HashMap instances.

Example

(Extracting HashMap types)

import { HashMap } from "effect"

// Create a concrete HashMap for type extraction
const inventory = HashMap.make(
  ["laptop", { quantity: 5, price: 999 }],
  ["mouse", { quantity: 20, price: 29 }]
)

// Extract types for reuse
type ProductId = HashMap.HashMap.Key<typeof inventory> // string
type Product = HashMap.HashMap.Value<typeof inventory> // { quantity: number, price: number }
type InventoryEntry = HashMap.HashMap.Entry<typeof inventory> // [string, Product]

// Use extracted types in functions
const updateInventory = (id: ProductId, product: Product) =>
  HashMap.set(inventory, id, product)

const processEntry = ([id, product]: InventoryEntry) =>
  `${id}: ${product.quantity} @ $${product.price}`

// Example of extracted types in action
const newProduct: Product = { quantity: 10, price: 199 }
const updatedInventory = updateInventory("tablet", newProduct)
processEntry(["tablet", newProduct]) // => "tablet: 10 @ $199"
updatedInventory // => HashMap.make(["laptop", { quantity: 5, price: 999 }], ["mouse", { quantity: 20, price: 29 }], ["tablet", newProduct])

Predicates

every

Added in v3.14.0 Source

Checks whether all entries in a hashmap meets a specific condition.

Signature

declare const every: {
  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => boolean;
  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): boolean;
}

Example

(Checking all entries)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])

HashMap.every(map, (value) => value > 0) // => true
HashMap.every(map, (value) => value > 1) // => false

has

Added in v2.0.0 Source

Checks whether the specified key has an entry in the HashMap.

Signature

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

Example

(Checking for keys)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2])

HashMap.has(map, "a") // => true
HashMap.has(map, "c") // => false

// Using pipe syntax
HashMap.has("b")(map) // => true

hasBy

Added in v3.16.0 Source

Checks whether an element matching the given predicate exists in the given HashMap.

Signature

declare const hasBy: {
  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: HashMap<K, V>) => boolean;
  <K, V>(self: HashMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): boolean;
}

Example

(Checking entries by predicate)

import { HashMap } from "effect"

const hm = HashMap.make([1, "a"])
HashMap.hasBy(hm, (value, key) => value === "a" && key === 1) // => true
HashMap.hasBy(hm, (value) => value === "b") // => false

hasHash

Added in v2.0.0 Source

Checks whether the specified key has an entry in the HashMap using a custom hash.

Signature

declare const hasHash: {
  <K1, K>(key: K1, hash: number): <V>(self: HashMap<K, V>) => boolean;
  <K1, K, V>(self: HashMap<K, V>, key: K1, hash: number): boolean;
}

Example

(Checking keys with a hash)

import { Hash, HashMap } from "effect"

// Create a map with case-sensitive keys
const userMap = HashMap.make(
  ["Admin", { role: "administrator" }],
  ["User", { role: "standard" }]
)

// Check with exact hash
const exactHash = Hash.string("Admin")
HashMap.hasHash(userMap, "Admin", exactHash) // => true

// A matching hash does not override key equality
HashMap.hasHash(userMap, "admin", exactHash) // => false

// A different hash also cannot find the existing key
const lowercaseHash = Hash.string("admin")
HashMap.hasHash(userMap, "Admin", lowercaseHash) // => false

isEmpty

Added in v2.0.0 Source

Checks whether the HashMap contains no entries.

Signature

declare const isEmpty: <K, V>(self: HashMap<K, V>) => boolean

Example

(Checking for empty HashMaps)

import { HashMap } from "effect"

const emptyMap = HashMap.empty<string, number>()
const nonEmptyMap = HashMap.make(["a", 1])

HashMap.isEmpty(emptyMap) // => true
HashMap.isEmpty(nonEmptyMap) // => false

some

Added in v3.13.0 Source

Checks whether any entry in a hashmap meets a specific condition.

Signature

declare const some: {
  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => boolean;
  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): boolean;
}

Example

(Checking for any matching entry)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])

HashMap.some(map, (value) => value > 2) // => true
HashMap.some(map, (value) => value > 5) // => false

Searching

findFirst

Added in v2.0.0 Source

Returns the first element that satisfies the specified predicate, or None if no such element exists.

Signature

declare const findFirst: {
  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => Option<[K, A]>;
  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option<[K, A]>;
}

Example

(Finding the first matching entry)

import { HashMap, Option } from "effect"

const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
HashMap.findFirst(map, (value, key) => key === "b" && value > 1) // => Option.some(["b", 2])

Sequencing

flatMap

Added in v2.0.0 Source

Maps each entry to a HashMap and flattens the results.

Gotchas

The hash and equality behavior of both maps have to be the same.

Signature

declare const flatMap: {
  <A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => HashMap<K, B>): HashMap<K, B>;
}

Example

(Flat mapping values)

import { HashMap, Option } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2])
const map2 = HashMap.flatMap(
  map1,
  (value, key) => HashMap.make([key + "1", value], [key + "2", value * 2])
)

map2 // => HashMap.make(["a1", 1], ["a2", 2], ["b1", 2], ["b2", 4])
HashMap.get(map2, "b2") // => Option.some(4)

Transforming

modify

Added in v2.0.0 Source

Updates the value of the specified key within the HashMap if it exists.

Signature

declare const modify: {
  <K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V>;
}

Example

(Modifying existing values)

import { HashMap, Option } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2])
const map2 = HashMap.modify(map1, "a", (value) => value * 3)

HashMap.get(map2, "a") // => Option.some(3)
HashMap.get(map2, "b") // => Option.some(2)

modifyAt

Added in v2.0.0 Source

Sets or removes the specified key using an update function.

Details

The update function receives Some(value) when the key exists or None when it does not. Returning Some(newValue) stores the value, and returning None removes the key or leaves it absent.

Signature

declare const modifyAt: {
  <K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, key: K, f: UpdateFn<V>): HashMap<K, V>;
}

Example

(Updating values with Options)

import { HashMap, Option } from "effect"

const map = HashMap.make(["a", 1], ["b", 2])

// Increment existing value or set to 1 if not present
const updateFn = (option: Option.Option<number>) =>
  Option.isSome(option) ? Option.some(option.value + 1) : Option.some(1)

const updated = HashMap.modifyAt(map, "a", updateFn)
HashMap.get(updated, "a") // => Option.some(2)

modifyHash

Added in v2.0.0 Source

Sets or removes the specified key using a precomputed hash and an update function.

Details

The update function receives Some(value) when the key exists or None when it does not. Returning Some(newValue) stores the value, and returning None removes the key or leaves it absent.

Signature

declare const modifyHash: {
  <K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V>;
}

Example

(Updating values with a hash)

import { Hash, HashMap, Option } from "effect"

// Useful when working with precomputed hashes for performance
const counters = HashMap.make(["downloads", 100], ["views", 250])

// Cache hash computation for frequently accessed keys
const metricKey = "downloads"
const cachedHash = Hash.string(metricKey)

// Update function that increments counter or initializes to 1
const incrementCounter = (current: Option.Option<number>) =>
  Option.isSome(current) ? Option.some(current.value + 1) : Option.some(1)

// Use cached hash for efficient updates in loops
const updated = HashMap.modifyHash(
  counters,
  metricKey,
  cachedHash,
  incrementCounter
)
HashMap.get(updated, "downloads") // => Option.some(101)

// Add new metric with precomputed hash
const newMetric = "clicks"
const clicksHash = Hash.string(newMetric)
const withClicks = HashMap.modifyHash(
  updated,
  newMetric,
  clicksHash,
  incrementCounter
)
HashMap.get(withClicks, "clicks") // => Option.some(1)

remove

Added in v2.0.0 Source

Removes the entry for the specified key in the HashMap using the internal hashing function.

Signature

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

Example

(Removing a key)

import { HashMap } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3])
const map2 = HashMap.remove(map1, "b")

map2 // => HashMap.make(["a", 1], ["c", 3])

removeMany

Added in v2.0.0 Source

Removes all entries in the HashMap which have the specified keys.

Signature

declare const removeMany: {
  <K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V>;
}

Example

(Removing multiple keys)

import { HashMap } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
const map2 = HashMap.removeMany(map1, ["b", "d"])

map2 // => HashMap.make(["a", 1], ["c", 3])

set

Added in v2.0.0 Source

Sets the specified key to the specified value using the internal hashing function.

Signature

declare const set: {
  <K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V>;
}

Example

(Setting a value)

import { HashMap } from "effect"

const map1 = HashMap.make(["a", 1])
HashMap.set(map1, "b", 2) // => HashMap.make(["a", 1], ["b", 2])

// Original map is unchanged
map1 // => HashMap.make(["a", 1])

setMany

Added in v4.0.0 Source

Sets multiple key-value pairs in the HashMap.

Signature

declare const setMany: {
  <K, V>(entries: Iterable<readonly [K, V]>): (self: HashMap<K, V>) => HashMap<K, V>;
  <K, V>(self: HashMap<K, V>, entries: Iterable<readonly [K, V]>): HashMap<K, V>;
}

Example

(Setting multiple entries)

import { HashMap, Option } from "effect"

const map1 = HashMap.make(["a", 1], ["b", 2])
const newEntries = [["c", 3], ["d", 4], ["a", 10]] as const // "a" will be overwritten
const map2 = HashMap.setMany(map1, newEntries)

map2 // => HashMap.make(["a", 10], ["b", 2], ["c", 3], ["d", 4])
HashMap.get(map2, "a") // => Option.some(10)

Traversing

forEach

Added in v2.0.0 Source

Applies the specified function to the entries of the HashMap.

Signature

declare const forEach: {
  <V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void;
  <V, K>(self: HashMap<K, V>, f: (value: V, key: K) => void): void;
}

Example

(Iterating with side effects)

import { HashMap } from "effect"

const map = HashMap.make(["a", 1], ["b", 2])
const collected: Array<[string, number]> = []

HashMap.forEach(map, (value, key) => {
  collected.push([key, value])
})

collected.sort() // => [["a", 1], ["b", 2]]

Unsafe

getUnsafe

Added in v4.0.0 Source

Looks up the value for the specified key in the HashMap unsafely using the internal hashing function.

When to use

Use when reading from a HashMap by a key known to exist, and throwing is an acceptable programming error for a missing key.

Gotchas

This function throws an error if the key is not found. Use HashMap.get for safe access that returns Option.

Signature

declare const getUnsafe: {
  <K1, K>(key: K1): <V>(self: HashMap<K, V>) => V;
  <K1, K, V>(self: HashMap<K, V>, key: K1): V;
}

Example

(Unsafely looking up values)

import { HashMap, Option } from "effect"

const config = HashMap.make(
  ["api_url", "https://api.example.com"],
  ["timeout", "5000"],
  ["retries", "3"]
)

// Safe: use when you're certain the key exists
HashMap.getUnsafe(config, "api_url") // => "https://api.example.com"

// Preferred: use get() for uncertain keys
HashMap.get(config, "db_url") // => Option.none()

// This would throw: HashMap.getUnsafe(config, "db_url")
// Error: "HashMap.getUnsafe: key not found"