TxHashMap.ts

TxHashMap.ts overview

Transactional hash maps for storing and updating key-value pairs inside Effect transactions.

A TxHashMap stores an immutable HashMap in a TxRef, so map reads and writes can commit atomically with other transactional operations. Use it for shared registries, counters, indexes, and other maps that need safe read-modify-write sequences alongside related transactional state.

Since v2.0.0

---

Exports Grouped by Category

• combinators
  • clear
  • compact
  • entries
  • every
  • filter
  • filterMap
  • findFirst
  • flatMap
  • forEach
  • get
  • getHash
  • has
  • hasBy
  • hasHash
  • isEmpty
  • isNonEmpty
  • keys
  • map
  • modify
  • modifyAt
  • reduce
  • remove
  • removeMany
  • set
  • setMany
  • size
  • snapshot
  • some
  • toEntries
  • toValues
  • union
  • values
• constructors
  • empty
  • fromIterable
  • make
• guards
  • isTxHashMap
• models
  • TxHashMap (interface)
• utils
  • TxHashMap (namespace)
    • Key (type alias)
    • Value (type alias)
    • Entry (type alias)

---

combinators

clear

Removes all entries from the TxHashMap.

Details

This function mutates the original TxHashMap by clearing all key-value pairs. It does not return a new TxHashMap reference.

Example (Clearing all entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const sessionMap = yield* TxHashMap.make(
    ["session1", { userId: "alice", expires: "2024-01-01T12:00:00Z" }],
    ["session2", { userId: "bob", expires: "2024-01-01T13:00:00Z" }],
    ["session3", { userId: "charlie", expires: "2024-01-01T14:00:00Z" }]
  )

  // Check initial state
  const initialSize = yield* TxHashMap.size(sessionMap)
  console.log(initialSize) // 3

  // Clear all sessions (e.g., during maintenance)
  yield* TxHashMap.clear(sessionMap)

  // Verify cleared
  const finalSize = yield* TxHashMap.size(sessionMap)
  console.log(finalSize) // 0

  const isEmpty = yield* TxHashMap.isEmpty(sessionMap)
  console.log(isEmpty) // true
})

Signature

declare const clear: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<void>

Source

Since v4.0.0

compact

Removes all None values from a TxHashMap containing Option values.

Details

This function returns a new TxHashMap reference with only the Some values unwrapped. The original TxHashMap is not modified.

Example (Compacting optional values)

import { Effect, Option, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a map with optional user data
  const userData = yield* TxHashMap.make<string, Option.Option<{ age: number; email?: string }>>(
    ["alice", Option.some({ age: 30, email: "alice@example.com" })],
    ["bob", Option.none()], // incomplete data
    ["charlie", Option.some({ age: 25 })],
    ["diana", Option.none()], // missing data
    ["eve", Option.some({ age: 28, email: "eve@example.com" })]
  )

  // Remove all None values and unwrap Some values
  const validUsers = yield* TxHashMap.compact(userData)

  const size = yield* TxHashMap.size(validUsers)
  console.log(size) // 3 (alice, charlie, eve)

  const alice = yield* TxHashMap.get(validUsers, "alice")
  console.log(alice) // Option.some({ age: 30, email: "alice@example.com" })

  const bob = yield* TxHashMap.get(validUsers, "bob")
  console.log(bob) // Option.none() (removed from map)

  // Useful for cleaning up optional data processing results
  const userAges = yield* TxHashMap.map(validUsers, (user) => user.age)
  const ageEntries = yield* TxHashMap.entries(userAges)
  const sortedAgeEntries = ageEntries.toSorted(([left], [right]) => left.localeCompare(right))
  console.log(sortedAgeEntries) // [["alice", 30], ["charlie", 25], ["eve", 28]]
})

Signature

declare const compact: <K, A>(self: TxHashMap<K, Option.Option<A>>) => Effect.Effect<TxHashMap<K, A>>

Source

Since v4.0.0

entries

Returns an array of all key-value pairs in the TxHashMap.

Example (Reading entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const config = yield* TxHashMap.make(["host", "localhost"], ["port", "3000"], ["ssl", "false"])

  const allEntries = yield* TxHashMap.entries(config)
  const sortedEntries = allEntries.toSorted(([left], [right]) => left.localeCompare(right))
  console.log(sortedEntries)
  // [["host", "localhost"], ["port", "3000"], ["ssl", "false"]]

  // Process configuration entries
  for (const [key, value] of sortedEntries) {
    console.log(`${key}=${value}`)
  }
  // host=localhost
  // port=3000
  // ssl=false
})

Signature

declare const entries: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<Array<readonly [K, V]>>

Source

Since v4.0.0

every

Checks whether all entries in the TxHashMap satisfy the given predicate.

Example (Checking whether every entry matches)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a user permissions map
  const permissions = yield* TxHashMap.make(
    ["alice", { canRead: true, canWrite: true, canDelete: false }],
    ["bob", { canRead: true, canWrite: false, canDelete: false }],
    ["charlie", { canRead: true, canWrite: true, canDelete: true }]
  )

  // Check if all users can read
  const allCanRead = yield* TxHashMap.every(permissions, (perms) => perms.canRead)
  console.log(allCanRead) // true

  // Check if all users can write
  const allCanWrite = yield* TxHashMap.every(permissions, (perms) => perms.canWrite)
  console.log(allCanWrite) // false

  // Data-last usage with pipe
  const allHaveBasicAccess = yield* permissions.pipe(
    TxHashMap.every((perms, username) => perms.canRead && username.length > 2)
  )
  console.log(allHaveBasicAccess) // true
})

Signature

declare const every: {
  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
}

Source

Since v4.0.0

filter

Filters the TxHashMap to keep only entries that satisfy the provided predicate.

Details

This function returns a new TxHashMap reference containing only the entries that match the condition. The original TxHashMap is not modified.

Example (Filtering entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a product inventory
  const inventory = yield* TxHashMap.make(
    ["laptop", { price: 999, stock: 5, category: "electronics" }],
    ["mouse", { price: 29, stock: 50, category: "electronics" }],
    ["book", { price: 15, stock: 100, category: "books" }],
    ["phone", { price: 699, stock: 0, category: "electronics" }]
  )

  // Filter to get only electronics in stock
  const electronicsInStock = yield* TxHashMap.filter(
    inventory,
    (product) => product.category === "electronics" && product.stock > 0
  )

  const size = yield* TxHashMap.size(electronicsInStock)
  console.log(size) // 2 (laptop and mouse)

  // Data-last usage with pipe
  const expensiveItems = yield* inventory.pipe(TxHashMap.filter((product) => product.price > 500))

  const expensiveSize = yield* TxHashMap.size(expensiveItems)
  console.log(expensiveSize) // 2 (laptop and phone)

  // Type guard usage
  const highValueItems = yield* TxHashMap.filter(
    inventory,
    (product): product is typeof product & { price: number } => product.price > 50
  )
})

Signature

declare const filter: {
  <K, V, B extends V>(
    predicate: (value: V, key: K) => value is B
  ): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, B>>
  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, V>>
  <K, V, B extends V>(
    self: TxHashMap<K, V>,
    predicate: (value: V, key: K) => value is B
  ): Effect.Effect<TxHashMap<K, B>>
  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>>
}

Source

Since v4.0.0

filterMap

Combines filtering and mapping in a single operation. Applies a filter to each entry, keeping only successful results and transforming them.

Details

This function returns a new TxHashMap reference containing only the transformed entries that succeeded. The original TxHashMap is not modified.

Example (Filtering and mapping entries)

import { Effect, Option, Result, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a mixed data map
  const userData = yield* TxHashMap.make(
    ["alice", { age: "30", role: "admin", active: true }],
    ["bob", { age: "invalid", role: "user", active: true }],
    ["charlie", { age: "25", role: "admin", active: false }],
    ["diana", { age: "28", role: "user", active: true }]
  )

  // Extract valid ages for active admin users only
  const activeAdminAges = yield* TxHashMap.filterMap(userData, (user, username) => {
    if (!user.active || user.role !== "admin") return Result.failVoid
    const age = parseInt(user.age)
    if (isNaN(age)) return Result.failVoid
    return Result.succeed({
      username,
      age,
      seniority: age > 27 ? "senior" : "junior"
    })
  })

  const aliceData = yield* TxHashMap.get(activeAdminAges, "alice")
  console.log(aliceData) // Option.some({ username: "alice", age: 30, seniority: "senior" })

  const charlieData = yield* TxHashMap.get(activeAdminAges, "charlie")
  console.log(charlieData) // Option.none() (not active)

  // Data-last usage with pipe
  const validAges = yield* userData.pipe(
    TxHashMap.filterMap((user) => {
      const age = parseInt(user.age)
      return isNaN(age) ? Result.failVoid : Result.succeed(age)
    })
  )

  const size = yield* TxHashMap.size(validAges)
  console.log(size) // 3 (alice, charlie, diana have valid ages)
})

Signature

declare const filterMap: {
  <V, K, A, X>(f: (input: V, key: K) => Result<A, X>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
  <K, V, A, X>(self: TxHashMap<K, V>, f: (input: V, key: K) => Result<A, X>): Effect.Effect<TxHashMap<K, A>>
}

Source

Since v4.0.0

findFirst

Finds the first entry in the TxHashMap that matches the given predicate. Returns the key-value pair as a tuple wrapped in an Option.

Example (Finding the first matching entry)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a task priority map
  const tasks = yield* TxHashMap.make(
    ["task1", { priority: 1, assignee: "alice", completed: false }],
    ["task2", { priority: 3, assignee: "bob", completed: true }],
    ["task3", { priority: 2, assignee: "alice", completed: false }]
  )

  // Find first high-priority incomplete task
  const highPriorityTask = yield* TxHashMap.findFirst(tasks, (task) => task.priority >= 2 && !task.completed)

  if (highPriorityTask._tag === "Some") {
    const [taskId, task] = highPriorityTask.value
    console.log(`Found task: ${taskId}, priority: ${task.priority}`)
    // "Found task: task3, priority: 2"
  }

  // Find first task assigned to specific user
  const aliceTask = yield* tasks.pipe(TxHashMap.findFirst((task) => task.assignee === "alice"))

  if (aliceTask._tag === "Some") {
    console.log(`Alice's task: ${aliceTask.value[0]}`)
  }
})

Signature

declare const findFirst: {
  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<[K, V]>>
  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<Option.Option<[K, V]>>
}

Source

Since v4.0.0

flatMap

Maps each entry effectfully to a TxHashMap and flattens the produced maps.

Details

This function returns a new TxHashMap reference with the flattened results. The original TxHashMap is not modified.

Example (Flat mapping entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a department-employee map
  const departments = yield* TxHashMap.make(["engineering", ["alice", "bob"]], ["marketing", ["charlie", "diana"]])

  // Expand each department into individual employee entries with metadata
  const employeeDetails = yield* TxHashMap.flatMap(departments, (employees, department) =>
    Effect.gen(function* () {
      const employeeMap = yield* TxHashMap.empty<string, { department: string; role: string }>()
      for (let i = 0; i < employees.length; i++) {
        const employee = employees[i]
        const role = i === 0 ? "lead" : "member"
        yield* TxHashMap.set(employeeMap, employee, { department, role })
      }
      return employeeMap
    })
  )

  // Check the flattened result
  const alice = yield* TxHashMap.get(employeeDetails, "alice")
  console.log(alice) // Option.some({ department: "engineering", role: "lead" })

  const charlie = yield* TxHashMap.get(employeeDetails, "charlie")
  console.log(charlie) // Option.some({ department: "marketing", role: "lead" })

  const size = yield* TxHashMap.size(employeeDetails)
  console.log(size) // 4 (all employees)
})

Signature

declare const flatMap: {
  <A, V, K>(
    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
  ): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
  <K, V, A>(
    self: TxHashMap<K, V>,
    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
  ): Effect.Effect<TxHashMap<K, A>>
}

Source

Since v4.0.0

forEach

Executes a side-effect function for each entry in the TxHashMap. The function receives the value and key as parameters and can perform effects.

Example (Running effects for each entry)

import { Console, Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a log processing map
  const logs = yield* TxHashMap.make(
    ["error.log", { size: 1024, level: "error" }],
    ["access.log", { size: 2048, level: "info" }],
    ["debug.log", { size: 512, level: "debug" }]
  )

  // Process each log file with side effects
  yield* TxHashMap.forEach(logs, (logInfo, filename) =>
    Effect.gen(function* () {
      yield* Console.log(`Processing ${filename}: ${logInfo.size} bytes, level: ${logInfo.level}`)
      if (logInfo.level === "error") {
        yield* Console.log(`⚠️  Error log detected: ${filename}`)
      }
    })
  )

  // Data-last usage with pipe
  yield* logs.pipe(
    TxHashMap.forEach((logInfo) =>
      logInfo.size > 1000 ? Console.log(`Large log file: ${logInfo.size} bytes`) : Effect.void
    )
  )
})

Signature

declare const forEach: {
  <V, K, R, E>(f: (value: V, key: K) => Effect.Effect<void, E, R>): (self: TxHashMap<K, V>) => Effect.Effect<void, E, R>
  <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): Effect.Effect<void, E, R>
}

Source

Since v2.0.0

get

Looks up the value for the specified key in the TxHashMap.

Example (Looking up values safely)

import { Effect, Option, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const userMap = yield* TxHashMap.make(
    ["alice", { name: "Alice", role: "admin" }],
    ["bob", { name: "Bob", role: "user" }]
  )

  // Safe lookup - returns Option
  const alice = yield* TxHashMap.get(userMap, "alice")
  console.log(alice) // Option.some({ name: "Alice", role: "admin" })

  const nonExistent = yield* TxHashMap.get(userMap, "charlie")
  console.log(nonExistent) // Option.none()

  // Use with pipe syntax for type-safe access
  const bobRole = yield* TxHashMap.get(userMap, "bob")
  if (bobRole._tag === "Some") {
    console.log(bobRole.value.role) // "user"
  }
})

Signature

declare const get: {
  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>>
}

Source

Since v2.0.0

getHash

Looks up the value for the specified key using a caller-supplied hash.

Gotchas

The supplied hash must be the hash for the same key, such as a precomputed Hash.hash(key) value. If the hash does not match the key, an existing entry may not be found.

Example (Looking up values with precomputed hashes)

import { Effect, Hash, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a cache with user sessions
  const cache = yield* TxHashMap.make(
    ["session_abc123", { userId: "user1", lastActive: 1_700_000_000_000 }],
    ["session_def456", { userId: "user2", lastActive: 1_700_000_060_000 }]
  )

  // When you have precomputed hash (e.g., from another lookup)
  const sessionId = "session_abc123"
  const precomputedHash = Hash.string(sessionId)

  // Use hash-optimized lookup for performance in hot paths
  const session = yield* TxHashMap.getHash(cache, sessionId, precomputedHash)
  console.log(session) // Option.some({ userId: "user1", lastActive: ... })

  // This avoids recomputing the hash when you already have it
  const invalidSession = yield* TxHashMap.getHash(cache, "invalid", Hash.string("invalid"))
  console.log(invalidSession) // Option.none()
})

Signature

declare const getHash: {
  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>>
}

Source

Since v4.0.0

has

Checks whether the specified key exists in the TxHashMap.

Example (Checking for keys)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const permissions = yield* TxHashMap.make(["alice", ["read", "write"]], ["bob", ["read"]], ["charlie", ["admin"]])

  // Check if users exist
  const hasAlice = yield* TxHashMap.has(permissions, "alice")
  console.log(hasAlice) // true

  const hasDavid = yield* TxHashMap.has(permissions, "david")
  console.log(hasDavid) // false

  // Use direct method call for type-safe access
  const hasBob = yield* TxHashMap.has(permissions, "bob")
  console.log(hasBob) // true
})

Signature

declare const has: {
  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean>
}

Source

Since v2.0.0

hasBy

Checks whether any entry in the TxHashMap matches the given predicate.

Example (Checking entries with a predicate)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a user status map
  const currentTime = 1_700_000_000_000
  const userStatuses = yield* TxHashMap.make(
    ["alice", { status: "online", lastSeen: currentTime }],
    ["bob", { status: "offline", lastSeen: currentTime - 3_600_000 }],
    ["charlie", { status: "online", lastSeen: currentTime }]
  )

  // Check if any users are online
  const hasOnlineUsers = yield* TxHashMap.hasBy(userStatuses, (user) => user.status === "online")
  console.log(hasOnlineUsers) // true

  // Check if any users have specific username pattern
  const hasAdminUser = yield* TxHashMap.hasBy(userStatuses, (user, username) => username.startsWith("admin"))
  console.log(hasAdminUser) // false

  // Data-last usage with pipe
  const hasRecentActivity = yield* userStatuses.pipe(
    TxHashMap.hasBy((user) => currentTime - user.lastSeen < 1_800_000) // 30 minutes
  )
  console.log(hasRecentActivity) // true
})

Signature

declare const hasBy: {
  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
}

Source

Since v4.0.0

hasHash

Checks whether the specified key has an entry using a caller-supplied hash.

Gotchas

The supplied hash must be the hash for the same key, such as a precomputed Hash.hash(key) value. If the hash does not match the key, an existing entry may not be found.

Example (Checking keys with precomputed hashes)

import { Effect, Hash, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create an access control map
  const permissions = yield* TxHashMap.make(
    ["admin", { read: true, write: true, delete: true }],
    ["user", { read: true, write: false, delete: false }]
  )

  // When checking permissions frequently with same roles
  const role = "admin"
  const roleHash = Hash.string(role)

  // Use hash-optimized existence check
  const hasAdminRole = yield* TxHashMap.hasHash(permissions, role, roleHash)
  console.log(hasAdminRole) // true

  // Check non-existent role
  const hasGuestRole = yield* TxHashMap.hasHash(permissions, "guest", Hash.string("guest"))
  console.log(hasGuestRole) // false

  // Useful in hot paths where hash is computed once and reused
  const roles = ["admin", "user", "moderator"]
  const roleHashes = roles.map((role) => [role, Hash.string(role)] as const)

  for (const [role, hash] of roleHashes) {
    const exists = yield* TxHashMap.hasHash(permissions, role, hash)
    console.log(`Role ${role}: ${exists}`)
  }
})

Signature

declare const hasHash: {
  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean>
}

Source

Since v4.0.0

isEmpty

Checks whether the TxHashMap is empty.

Example (Checking for an empty map)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Start with empty map
  const cache = yield* TxHashMap.empty<string, any>()
  const empty = yield* TxHashMap.isEmpty(cache)
  console.log(empty) // true

  // Add an item
  yield* TxHashMap.set(cache, "key1", "value1")
  const stillEmpty = yield* TxHashMap.isEmpty(cache)
  console.log(stillEmpty) // false

  // Clear and check again
  yield* TxHashMap.clear(cache)
  const emptyAgain = yield* TxHashMap.isEmpty(cache)
  console.log(emptyAgain) // true
})

Signature

declare const isEmpty: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>

Source

Since v2.0.0

isNonEmpty

Checks whether the TxHashMap is non-empty.

Example (Checking for a non-empty map)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const inventory = yield* TxHashMap.make(["laptop", 5])

  const hasItems = yield* TxHashMap.isNonEmpty(inventory)
  console.log(hasItems) // true

  // Clear inventory
  yield* TxHashMap.clear(inventory)
  const stillHasItems = yield* TxHashMap.isNonEmpty(inventory)
  console.log(stillHasItems) // false
})

Signature

declare const isNonEmpty: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>

Source

Since v4.0.0

keys

Returns an array of all keys in the TxHashMap.

Example (Reading keys)

import { Effect, Option, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const userRoles = yield* TxHashMap.make(["alice", "admin"], ["bob", "user"], ["charlie", "moderator"])

  const usernames = yield* TxHashMap.keys(userRoles)
  console.log(usernames.sort()) // ["alice", "bob", "charlie"]

  // Useful for iteration
  for (const username of usernames) {
    const role = yield* TxHashMap.get(userRoles, username)
    if (role._tag === "Some") {
      console.log(`${username}: ${role.value}`)
    }
  }
})

Signature

declare const keys: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<Array<K>>

Source

Since v2.0.0

map

Transforms all values in the TxHashMap using the provided function, preserving keys.

Details

This function returns a new TxHashMap reference with the transformed values. The original TxHashMap is not modified.

Example (Mapping values)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a user profile map
  const profiles = yield* TxHashMap.make(
    ["alice", { name: "Alice", age: 30, active: true }],
    ["bob", { name: "Bob", age: 25, active: false }],
    ["charlie", { name: "Charlie", age: 35, active: true }]
  )

  // Transform to extract just names with greeting
  const greetings = yield* TxHashMap.map(profiles, (profile, userId) => `Hello, ${profile.name}! (User: ${userId})`)

  // Check the transformed values
  const aliceGreeting = yield* TxHashMap.get(greetings, "alice")
  console.log(aliceGreeting) // Option.some("Hello, Alice! (User: alice)")

  // Data-last usage with pipe
  const ages = yield* profiles.pipe(TxHashMap.map((profile) => profile.age))

  const aliceAge = yield* TxHashMap.get(ages, "alice")
  console.log(aliceAge) // Option.some(30)

  // Original map is unchanged
  const originalAlice = yield* TxHashMap.get(profiles, "alice")
  console.log(originalAlice) // Option.some({ name: "Alice", age: 30, active: true })
})

Signature

declare const map: {
  <A, V, K>(f: (value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>>
}

Source

Since v4.0.0

modify

Updates the value for the specified key if it exists, returning the previous value in Some; returns None and leaves the map unchanged when the key is absent.

Details

This function mutates the original TxHashMap by updating the value at the specified key. It does not return a new TxHashMap reference.

Example (Updating existing values)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const counters = yield* TxHashMap.make(["downloads", 100], ["views", 250])

  // Increment existing counter
  const oldDownloads = yield* TxHashMap.modify(counters, "downloads", (count) => count + 1)
  console.log(oldDownloads) // Option.some(100)

  const newDownloads = yield* TxHashMap.get(counters, "downloads")
  console.log(newDownloads) // Option.some(101)

  // Try to modify non-existent key
  const nonExistent = yield* TxHashMap.modify(counters, "clicks", (count) => count + 1)
  console.log(nonExistent) // Option.none()

  // Update views counter with direct method call
  yield* TxHashMap.modify(counters, "views", (views) => views * 2)
})

Signature

declare const modify: {
  <K, V>(key: K, f: (value: V) => V): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>>
}

Source

Since v4.0.0

modifyAt

Updates the value for the specified key using an Option-based update function.

Details

This function mutates the original TxHashMap by updating, adding, or removing the key-value pair based on the function result. It does not return a new TxHashMap reference.

Example (Updating values with Option)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const storage = yield* TxHashMap.make<string, string | number>(["file1.txt", "content1"], ["access_count", 0])

  // Increment existing counter
  yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
    current._tag === "Some" && typeof current.value === "number" ? { ...current, value: current.value + 1 } : current
  )
  const count1 = yield* TxHashMap.get(storage, "access_count")
  console.log(count1) // Option.some(1)

  // Increment existing counter again
  yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
    current._tag === "Some" && typeof current.value === "number" ? { ...current, value: current.value + 1 } : current
  )
  const count2 = yield* TxHashMap.get(storage, "access_count")
  console.log(count2) // Option.some(2)

  // Update an existing string entry
  yield* TxHashMap.modifyAt(storage, "file1.txt", (current) =>
    current._tag === "Some" && typeof current.value === "string"
      ? { ...current, value: `${current.value}.bak` }
      : current
  )
  const backup = yield* TxHashMap.get(storage, "file1.txt")
  console.log(backup) // Option.some("content1.bak")
})

Signature

declare const modifyAt: {
  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: TxHashMap<K, V>) => Effect.Effect<void>
  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): Effect.Effect<void>
}

Source

Since v4.0.0

reduce

Reduces the TxHashMap entries to a single value by applying a reducer function. Iterates over all key-value pairs and accumulates them into a final result.

Example (Reducing entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a sales data map
  const sales = yield* TxHashMap.make(["Q1", 15000], ["Q2", 18000], ["Q3", 22000], ["Q4", 25000])

  // Calculate total sales
  const totalSales = yield* TxHashMap.reduce(sales, 0, (total, amount, quarter) => {
    console.log(`Adding ${quarter}: ${amount}`)
    return total + amount
  })
  console.log(`Total sales: ${totalSales}`) // 80000

  // Data-last usage with pipe
  const quarterlyReport = yield* sales.pipe(
    TxHashMap.reduce({ quarters: 0, total: 0, max: 0 }, (report, amount, quarter) => ({
      quarters: report.quarters + 1,
      total: report.total + amount,
      max: Math.max(report.max, amount)
    }))
  )
  console.log(quarterlyReport) // { quarters: 4, total: 80000, max: 25000 }

  // Build a summary string
  const summary = yield* TxHashMap.reduce(
    sales,
    "",
    (acc, amount, quarter) => acc + `${quarter}: $${amount.toLocaleString()}\n`
  )
  console.log(summary)
})

Signature

declare const reduce: {
  <A, V, K>(zero: A, f: (accumulator: A, value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<A>
  <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A>
}

Source

Since v2.0.0

remove

Removes the specified key from the TxHashMap.

Details

This function mutates the original TxHashMap by removing the specified key-value pair. It does not return a new TxHashMap reference.

Example (Removing keys)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const cache = yield* TxHashMap.make(
    ["user:1", { name: "Alice", lastSeen: "2024-01-01" }],
    ["user:2", { name: "Bob", lastSeen: "2024-01-02" }],
    ["user:3", { name: "Charlie", lastSeen: "2023-12-30" }]
  )

  // Remove expired user
  const removed = yield* TxHashMap.remove(cache, "user:3")
  console.log(removed) // true (key existed and was removed)

  // Try to remove non-existent key
  const notRemoved = yield* TxHashMap.remove(cache, "user:999")
  console.log(notRemoved) // false (key didn't exist)

  // Verify removal
  const hasUser3 = yield* TxHashMap.has(cache, "user:3")
  console.log(hasUser3) // false

  const size = yield* TxHashMap.size(cache)
  console.log(size) // 2
})

Signature

declare const remove: {
  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean>
}

Source

Since v2.0.0

removeMany

Removes multiple keys from the TxHashMap.

Details

This function mutates the original TxHashMap by removing all specified keys. It does not return a new TxHashMap reference.

Example (Removing multiple keys)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a cache with temporary data
  const cache = yield* TxHashMap.make(
    ["session_1", { user: "alice", expires: "2024-01-01" }],
    ["session_2", { user: "bob", expires: "2024-01-01" }],
    ["session_3", { user: "charlie", expires: "2024-12-31" }],
    ["temp_data_1", { value: "temporary" }],
    ["temp_data_2", { value: "also_temporary" }]
  )

  console.log(yield* TxHashMap.size(cache)) // 5

  // Remove expired sessions and temporary data
  const keysToRemove = ["session_1", "session_2", "temp_data_1", "temp_data_2"]
  yield* TxHashMap.removeMany(cache, keysToRemove)

  console.log(yield* TxHashMap.size(cache)) // 1

  // Verify only the valid session remains
  const remainingSession = yield* TxHashMap.get(cache, "session_3")
  console.log(remainingSession) // Option.some({ user: "charlie", expires: "2024-12-31" })

  // Can also remove from Set, Array, or any iterable
  const moreKeysToRemove = new Set(["session_3"])
  yield* TxHashMap.removeMany(cache, moreKeysToRemove)
  console.log(yield* TxHashMap.isEmpty(cache)) // true
})

Signature

declare const removeMany: {
  <K1 extends K, K>(keys: Iterable<K1>): <V>(self: TxHashMap<K, V>) => Effect.Effect<void>
  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void>
}

Source

Since v4.0.0

set

Sets the value for the specified key in the TxHashMap.

Details

This function mutates the original TxHashMap by updating its internal state. It does not return a new TxHashMap reference.

Example (Setting values)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const inventory = yield* TxHashMap.make(["laptop", 5], ["mouse", 20])

  // Update existing item
  yield* TxHashMap.set(inventory, "laptop", 3)
  const laptopStock = yield* TxHashMap.get(inventory, "laptop")
  console.log(laptopStock) // Option.some(3)

  // Add new item
  yield* TxHashMap.set(inventory, "keyboard", 15)
  const keyboardStock = yield* TxHashMap.get(inventory, "keyboard")
  console.log(keyboardStock) // Option.some(15)

  // Use with pipe syntax
  yield* TxHashMap.set("tablet", 8)(inventory)
})

Signature

declare const set: {
  <K, V>(key: K, value: V): (self: TxHashMap<K, V>) => Effect.Effect<void>
  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void>
}

Source

Since v2.0.0

setMany

Sets multiple key-value pairs in the TxHashMap.

Details

This function mutates the original TxHashMap by setting all provided key-value pairs. It does not return a new TxHashMap reference.

Example (Setting multiple entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create an empty product catalog
  const catalog = yield* TxHashMap.empty<string, { price: number; stock: number }>()

  // Bulk load initial products
  const initialProducts: Array<readonly [string, { price: number; stock: number }]> = [
    ["laptop", { price: 999, stock: 5 }],
    ["mouse", { price: 29, stock: 50 }],
    ["keyboard", { price: 79, stock: 20 }],
    ["monitor", { price: 299, stock: 8 }]
  ]

  yield* TxHashMap.setMany(catalog, initialProducts)

  console.log(yield* TxHashMap.size(catalog)) // 4

  // Update prices with a new batch
  const priceUpdates: Array<readonly [string, { price: number; stock: number }]> = [
    ["laptop", { price: 899, stock: 5 }], // sale price
    ["mouse", { price: 25, stock: 50 }], // sale price
    ["webcam", { price: 89, stock: 12 }] // new product
  ]

  yield* TxHashMap.setMany(catalog, priceUpdates)

  console.log(yield* TxHashMap.size(catalog)) // 5 (4 original + 1 new)

  // Verify the updates
  const laptop = yield* TxHashMap.get(catalog, "laptop")
  console.log(laptop) // Option.some({ price: 899, stock: 5 })

  // Can also use Map, Set of tuples, or any iterable of entries
  const jsMap = new Map([["tablet", { price: 399, stock: 3 }]])
  yield* TxHashMap.setMany(catalog, jsMap)
})

Signature

declare const setMany: {
  <K1 extends K, K, V1 extends V, V>(
    entries: Iterable<readonly [K1, V1]>
  ): (self: TxHashMap<K, V>) => Effect.Effect<void>
  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, entries: Iterable<readonly [K1, V1]>): Effect.Effect<void>
}

Source

Since v4.0.0

size

Returns the number of entries in the TxHashMap.

Example (Counting entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const metrics = yield* TxHashMap.make(["requests", 1000], ["errors", 5], ["users", 50])

  const count = yield* TxHashMap.size(metrics)
  console.log(count) // 3

  // Add more metrics
  yield* TxHashMap.set(metrics, "response_time", 250)
  const newCount = yield* TxHashMap.size(metrics)
  console.log(newCount) // 4

  // Remove a metric
  yield* TxHashMap.remove(metrics, "errors")
  const finalCount = yield* TxHashMap.size(metrics)
  console.log(finalCount) // 3
})

Signature

declare const size: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<number>

Source

Since v2.0.0

snapshot

Returns an immutable snapshot of the current TxHashMap state.

Example (Taking immutable snapshots)

import { Effect, HashMap, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const liveData = yield* TxHashMap.make(["temperature", 22.5], ["humidity", 45.2], ["pressure", 1013.25])

  // Take snapshot for reporting
  const snapshot = yield* TxHashMap.snapshot(liveData)

  // Continue modifying live data
  yield* TxHashMap.set(liveData, "temperature", 23.1)
  yield* TxHashMap.set(liveData, "wind_speed", 5.3)

  // Snapshot remains unchanged
  console.log(HashMap.size(snapshot)) // 3
  console.log(HashMap.get(snapshot, "temperature")) // Option.some(22.5)

  // Can use regular HashMap operations on snapshot
  const tempReading = HashMap.get(snapshot, "temperature")
  const humidityReading = HashMap.get(snapshot, "humidity")
})

Signature

declare const snapshot: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<HashMap.HashMap<K, V>>

Source

Since v4.0.0

some

Checks whether at least one entry in the TxHashMap satisfies the given predicate.

Example (Checking whether some entries match)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a product inventory
  const inventory = yield* TxHashMap.make(
    ["laptop", { price: 999, stock: 5 }],
    ["mouse", { price: 29, stock: 50 }],
    ["keyboard", { price: 79, stock: 0 }]
  )

  // Check if any products are expensive
  const hasExpensiveProducts = yield* TxHashMap.some(inventory, (product) => product.price > 500)
  console.log(hasExpensiveProducts) // true

  // Check if any products are out of stock
  const hasOutOfStock = yield* TxHashMap.some(inventory, (product) => product.stock === 0)
  console.log(hasOutOfStock) // true

  // Data-last usage with pipe
  const hasAffordableItems = yield* inventory.pipe(TxHashMap.some((product) => product.price < 50))
  console.log(hasAffordableItems) // true (mouse is $29)
})

Signature

declare const some: {
  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
}

Source

Since v4.0.0

toEntries

Returns an array of all key-value pairs in the TxHashMap. This is an alias for the entries function, providing API consistency with HashMap.

Example (Converting to entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const settings = yield* TxHashMap.make(["theme", "dark"], ["language", "en-US"], ["timezone", "UTC"])

  // Get all entries as an array
  const allEntries = yield* TxHashMap.toEntries(settings)
  const sortedEntries = allEntries.toSorted(([left], [right]) => left.localeCompare(right))
  console.log(sortedEntries)
  // [["language", "en-US"], ["theme", "dark"], ["timezone", "UTC"]]

  // Process entries
  for (const [setting, value] of sortedEntries) {
    console.log(`${setting}: ${value}`)
  }

  // Convert to object for JSON serialization
  const settingsObj = Object.fromEntries(sortedEntries)
  console.log(JSON.stringify(settingsObj))
  // {"language":"en-US","theme":"dark","timezone":"UTC"}
})

Signature

declare const toEntries: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<Array<readonly [K, V]>>

Source

Since v4.0.0

toValues

Returns an array of all values in the TxHashMap. This is an alias for the values function, providing API consistency with HashMap.

Example (Converting to values)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const inventory = yield* TxHashMap.make(
    ["laptop", { price: 999, stock: 5 }],
    ["mouse", { price: 29, stock: 50 }],
    ["keyboard", { price: 79, stock: 20 }]
  )

  // Get all product information
  const products = yield* TxHashMap.toValues(inventory)
  console.log(products.length) // 3

  // Calculate total inventory value
  const totalValue = products.reduce((sum, product) => sum + product.price * product.stock, 0)
  console.log(`Total inventory value: $${totalValue}`) // Total inventory value: $8025

  // Find products with low stock
  const lowStockProducts = products.filter((product) => product.stock < 10)
  console.log(`${lowStockProducts.length} product with low stock`) // 1 product with low stock
})

Signature

declare const toValues: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<Array<V>>

Source

Since v4.0.0

union

Merges another HashMap into this TxHashMap. If both maps contain the same key, the value from the other map will be used.

Details

This function mutates the original TxHashMap by merging the provided HashMap into it. It does not return a new TxHashMap reference.

Example (Merging HashMaps)

import { Effect, HashMap, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create initial user preferences
  const userPrefs = yield* TxHashMap.make(["theme", "light"], ["language", "en"], ["notifications", "enabled"])

  // New preferences to merge in
  const newSettings = HashMap.make(
    ["theme", "dark"], // will override existing
    ["timezone", "UTC"], // new setting
    ["sound", "enabled"] // new setting
  )

  // Merge the new settings
  yield* TxHashMap.union(userPrefs, newSettings)

  // Check the merged result
  const theme = yield* TxHashMap.get(userPrefs, "theme")
  console.log(theme) // Option.some("dark") - overridden

  const language = yield* TxHashMap.get(userPrefs, "language")
  console.log(language) // Option.some("en") - preserved

  const timezone = yield* TxHashMap.get(userPrefs, "timezone")
  console.log(timezone) // Option.some("UTC") - newly added

  const size = yield* TxHashMap.size(userPrefs)
  console.log(size) // 5 total settings
})

Signature

declare const union: {
  <K1 extends K, K, V1 extends V, V>(other: HashMap.HashMap<K1, V1>): (self: TxHashMap<K, V>) => Effect.Effect<void>
  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void>
}

Source

Since v4.0.0

values

Returns an array of all values in the TxHashMap.

Example (Reading values)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const scores = yield* TxHashMap.make(["alice", 95], ["bob", 87], ["charlie", 92])

  const allScores = yield* TxHashMap.values(scores)
  console.log(allScores.sort((a, b) => a - b)) // [87, 92, 95]

  // Calculate average
  const average = allScores.reduce((sum, score) => sum + score, 0) / allScores.length
  console.log(average.toFixed(2)) // "91.33"

  // Find maximum
  const maxScore = Math.max(...allScores)
  console.log(maxScore) // 95
})

Signature

declare const values: <K, V>(self: TxHashMap<K, V>) => Effect.Effect<Array<V>>

Source

Since v2.0.0

constructors

empty

Creates an empty TxHashMap.

Example (Creating an empty map)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create an empty transactional hash map
  const emptyMap = yield* TxHashMap.empty<string, number>()

  // Verify it's empty
  const isEmpty = yield* TxHashMap.isEmpty(emptyMap)
  console.log(isEmpty) // true

  const size = yield* TxHashMap.size(emptyMap)
  console.log(size) // 0

  // Start adding elements
  yield* TxHashMap.set(emptyMap, "first", 1)
  const newSize = yield* TxHashMap.size(emptyMap)
  console.log(newSize) // 1
})

Signature

declare const empty: <K, V>() => Effect.Effect<TxHashMap<K, V>>

Source

Since v2.0.0

fromIterable

Creates a TxHashMap from an iterable of key-value pairs.

Example (Creating a map from an iterable)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create from various iterable sources
  const configEntries = [
    ["database.host", "localhost"],
    ["database.port", "5432"],
    ["cache.enabled", "true"],
    ["logging.level", "info"]
  ] as const

  const configMap = yield* TxHashMap.fromIterable(configEntries)

  // Verify the configuration was loaded
  const size = yield* TxHashMap.size(configMap)
  console.log(size) // 4

  const dbHost = yield* TxHashMap.get(configMap, "database.host")
  console.log(dbHost) // Option.some("localhost")

  // Can also create from Map, Set of tuples, etc.
  const jsMap = new Map([
    ["key1", "value1"],
    ["key2", "value2"]
  ])
  const txMapFromJs = yield* TxHashMap.fromIterable(jsMap)
})

Signature

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

Source

Since v2.0.0

make

Creates a TxHashMap from the provided key-value pairs.

Example (Creating a map from entries)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a user directory
  const userMap = yield* TxHashMap.make(
    ["alice", { name: "Alice Smith", role: "admin" }],
    ["bob", { name: "Bob Johnson", role: "user" }],
    ["charlie", { name: "Charlie Brown", role: "user" }]
  )

  // Check the initial size
  const size = yield* TxHashMap.size(userMap)
  console.log(size) // 3

  // Access users
  const alice = yield* TxHashMap.get(userMap, "alice")
  console.log(alice) // Option.some({ name: "Alice Smith", role: "admin" })

  const nonExistent = yield* TxHashMap.get(userMap, "david")
  console.log(nonExistent) // Option.none()
})

Signature

declare const make: <K, V>(...entries: Array<readonly [K, V]>) => Effect.Effect<TxHashMap<K, V>>

Source

Since v2.0.0

guards

isTxHashMap

Returns true if the specified value is a TxHashMap, false otherwise.

Example (Checking TxHashMap values)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  const txMap = yield* TxHashMap.make(["key", "value"])

  console.log(TxHashMap.isTxHashMap(txMap)) // true
  console.log(TxHashMap.isTxHashMap({})) // false
  console.log(TxHashMap.isTxHashMap(null)) // false
  console.log(TxHashMap.isTxHashMap("not a map")) // false

  // Useful for type guards in runtime checks
  const validateInput = (value: unknown) => {
    if (TxHashMap.isTxHashMap(value)) {
      // TypeScript now knows this is a TxHashMap
      return Effect.succeed("Valid TxHashMap")
    }
    return Effect.fail("Invalid input")
  }
})

Signature

declare const isTxHashMap: <K, V>(value: unknown) => value is TxHashMap<K, V>

Source

Since v4.0.0

models

TxHashMap (interface)

A TxHashMap is a transactional hash map data structure that provides atomic operations on key-value pairs within Effect transactions. It uses an immutable HashMap internally with TxRef for transactional semantics, ensuring all operations are performed atomically.

Example (Using transactional hash maps)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a transactional hash map
  const txMap = yield* TxHashMap.make(["user1", "Alice"], ["user2", "Bob"])

  // Single operations are automatically transactional
  yield* TxHashMap.set(txMap, "user3", "Charlie")
  const user = yield* TxHashMap.get(txMap, "user1")
  console.log(user) // Option.some("Alice")

  // Multi-step atomic operations
  yield* Effect.tx(
    Effect.gen(function* () {
      const currentUser = yield* TxHashMap.get(txMap, "user1")
      if (currentUser._tag === "Some") {
        yield* TxHashMap.set(txMap, "user1", currentUser.value + "_updated")
        yield* TxHashMap.remove(txMap, "user2")
      }
    })
  )

  const size = yield* TxHashMap.size(txMap)
  console.log(size) // 2
})

Signature

export interface TxHashMap<in out K, in out V> extends Inspectable, Pipeable {
  readonly [TypeId]: typeof TypeId
  readonly ref: TxRef.TxRef<HashMap.HashMap<K, V>>
}

Source

Since v4.0.0

utils

TxHashMap (namespace)

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

Example (Reusing extracted TxHashMap types)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a transactional inventory map
  const inventory = yield* TxHashMap.make(["laptop", { stock: 5, price: 999 }], ["mouse", { stock: 20, price: 29 }])

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

  // Use extracted types in functions
  const updateStock = (id: ProductId, newStock: number) =>
    TxHashMap.modify(inventory, id, (product) => ({ ...product, stock: newStock }))

  yield* updateStock("laptop", 3)
})

Source

Since v4.0.0

Key (type alias)

Extracts the key type from a TxHashMap type.

Example (Extracting key types)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a user map to extract key type from
  const userMap = yield* TxHashMap.make(["alice", { name: "Alice", age: 30 }], ["bob", { name: "Bob", age: 25 }])

  // Extract the key type (string)
  type UserKey = TxHashMap.TxHashMap.Key<typeof userMap>

  // Use the extracted type in functions
  const getUserById = (id: UserKey) => TxHashMap.get(userMap, id)
  const alice = yield* getUserById("alice") // Option<{ name: string, age: number }>
})

Signature

type Key<T> = T extends TxHashMap<infer K, any> ? K : never

Source

Since v4.0.0

Value (type alias)

Extracts the value type from a TxHashMap type.

Example (Extracting value types)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a product catalog TxHashMap
  const catalog = yield* TxHashMap.make(
    ["laptop", { price: 999, category: "electronics" }],
    ["book", { price: 29, category: "education" }]
  )

  // Extract the value type (Product)
  type Product = TxHashMap.TxHashMap.Value<typeof catalog>

  // Use the extracted type for type-safe operations
  const processProduct = (product: Product) => {
    return `${product.category}: $${product.price}`
  }

  const laptop = yield* TxHashMap.get(catalog, "laptop")
  // laptop has type Option<Product> thanks to type extraction
})

Signature

type Value<T> = T extends TxHashMap<any, infer V> ? V : never

Source

Since v4.0.0

Entry (type alias)

Extracts the entry type from a TxHashMap type.

Example (Extracting entry types)

import { Effect, TxHashMap } from "effect"

const program = Effect.gen(function* () {
  // Create a configuration TxHashMap
  const config = yield* TxHashMap.make(["api_url", "https://api.example.com"], ["timeout", "5000"], ["retries", "3"])

  // Extract the entry type [string, string]
  type ConfigEntry = TxHashMap.TxHashMap.Entry<typeof config>

  // Use the extracted type for processing entries
  const processEntry = ([key, value]: ConfigEntry) => {
    return `${key}=${value}`
  }

  // Get all entries and process them
  const entries = yield* TxHashMap.entries(config)
  const configLines = entries.map(processEntry)
  console.log(configLines) // ["api_url=https://api.example.com", ...]
})

Signature

type Entry<T> = T extends TxHashMap<infer K, infer V> ? readonly [K, V] : never

Source

Since v4.0.0