effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/TxHashMap.ts

@@ -11,6 +11,8 @@ import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
+import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxHashMap"
@@ -41,7 +43,7 @@ const TxHashMapProto = {
  *
  * @example
  * ```ts
- * import { Effect, Option, TxHashMap } from "effect"
+ * import { Effect, TxHashMap } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a transactional hash map
@@ -53,10 +55,10 @@ const TxHashMapProto = {
  *   console.log(user) // Option.some("Alice")
  *
  *   // Multi-step atomic operations
- *   yield* Effect.atomic(
+ *   yield* Effect.tx(
  *     Effect.gen(function*() {
  *       const currentUser = yield* TxHashMap.get(txMap, "user1")
- *       if (Option.isSome(currentUser)) {
+ *       if (currentUser._tag === "Some") {
  *         yield* TxHashMap.set(txMap, "user1", currentUser.value + "_updated")
  *         yield* TxHashMap.remove(txMap, "user2")
  *       }
@@ -273,7 +275,9 @@ export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>> =>
  * @since 2.0.0
  * @category constructors
  */
-export const make = <K, V>(...entries: Array<readonly [K, V]>): Effect.Effect<TxHashMap<K, V>> =>
+export const make = <K, V>(
+  ...entries: Array<readonly [K, V]>
+): Effect.Effect<TxHashMap<K, V>> =>
   Effect.gen(function*() {
     const hashMap = HashMap.make(...entries)
     const ref = yield* TxRef.make(hashMap)
@@ -314,7 +318,9 @@ export const make = <K, V>(...entries: Array<readonly [K, V]>): Effect.Effect<Tx
  * @since 2.0.0
  * @category constructors
  */
-export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): Effect.Effect<TxHashMap<K, V>> =>
+export const fromIterable = <K, V>(
+  entries: Iterable<readonly [K, V]>
+): Effect.Effect<TxHashMap<K, V>> =>
   Effect.gen(function*() {
     const hashMap = HashMap.fromIterable(entries)
     const ref = yield* TxRef.make(hashMap)
@@ -343,7 +349,7 @@ export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): Effect.E
  *
  *   // Use with pipe syntax for type-safe access
  *   const bobRole = yield* TxHashMap.get(userMap, "bob")
- *   if (Option.isSome(bobRole)) {
+ *   if (bobRole._tag === "Some") {
  *     console.log(bobRole.value.role) // "user"
  *   }
  * })
@@ -375,7 +381,7 @@ export const get: {
    *
    *   // Use with pipe syntax for type-safe access
    *   const bobRole = yield* TxHashMap.get(userMap, "bob")
-   *   if (Option.isSome(bobRole)) {
+   *   if (bobRole._tag === "Some") {
    *     console.log(bobRole.value.role) // "user"
    *   }
    * })
@@ -407,7 +413,7 @@ export const get: {
    *
    *   // Use with pipe syntax for type-safe access
    *   const bobRole = yield* TxHashMap.get(userMap, "bob")
-   *   if (Option.isSome(bobRole)) {
+   *   if (bobRole._tag === "Some") {
    *     console.log(bobRole.value.role) // "user"
    *   }
    * })
@@ -756,16 +762,14 @@ export const remove: {
 } = dual(
   2,
   <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const existed = HashMap.has(currentMap, key)
-        if (existed) {
-          yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
-        }
-        return existed
-      })
-    )
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const existed = HashMap.has(currentMap, key)
+      if (existed) {
+        yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
+      }
+      return existed
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1038,19 +1042,21 @@ export const modify: {
   <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>>
 } = dual(
   3,
-  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const currentValue = HashMap.get(currentMap, key)
-        if (Option.isSome(currentValue)) {
-          const newValue = f(currentValue.value)
-          yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue))
-          return currentValue
-        }
-        return Option.none()
-      })
-    )
+  <K, V>(
+    self: TxHashMap<K, V>,
+    key: K,
+    f: (value: V) => V
+  ): Effect.Effect<Option.Option<V>> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const currentValue = HashMap.get(currentMap, key)
+      if (Option.isSome(currentValue)) {
+        const newValue = f(currentValue.value)
+        yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue))
+        return currentValue
+      }
+      return Option.none()
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1062,7 +1068,7 @@ export const modify: {
  *
  * @example
  * ```ts
- * import { Effect, Option, TxHashMap } from "effect"
+ * import { Effect, TxHashMap } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const storage = yield* TxHashMap.make<string, string | number>([
@@ -1070,26 +1076,32 @@ export const modify: {
  *     "content1"
  *   ], ["access_count", 0])
  *
- *   // Increment counter or initialize to 1
- *   const updateFn = (opt: Option.Option<string | number>) =>
- *     Option.isSome(opt) && typeof opt.value === "number"
- *       ? Option.some(opt.value + 1)
- *       : Option.some(1)
- *
  *   // Increment existing counter
- *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+ *   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", updateFn)
+ *   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)
  *
- *   // Remove by returning None
- *   yield* TxHashMap.modifyAt(storage, "file1.txt", () => Option.none())
- *   const hasFile = yield* TxHashMap.has(storage, "file1.txt")
- *   console.log(hasFile) // false
+ *   // 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")
  * })
  * ```
  *
@@ -1106,7 +1118,7 @@ export const modifyAt: {
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   const storage = yield* TxHashMap.make<string, string | number>([
@@ -1114,26 +1126,32 @@ export const modifyAt: {
    *     "content1"
    *   ], ["access_count", 0])
    *
-   *   // Increment counter or initialize to 1
-   *   const updateFn = (opt: Option.Option<string | number>) =>
-   *     Option.isSome(opt) && typeof opt.value === "number"
-   *       ? Option.some(opt.value + 1)
-   *       : Option.some(1)
-   *
    *   // Increment existing counter
-   *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+   *   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", updateFn)
+   *   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)
    *
-   *   // Remove by returning None
-   *   yield* TxHashMap.modifyAt(storage, "file1.txt", () => Option.none())
-   *   const hasFile = yield* TxHashMap.has(storage, "file1.txt")
-   *   console.log(hasFile) // false
+   *   // 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")
    * })
    * ```
    *
@@ -1150,7 +1168,7 @@ export const modifyAt: {
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   const storage = yield* TxHashMap.make<string, string | number>([
@@ -1158,26 +1176,32 @@ export const modifyAt: {
    *     "content1"
    *   ], ["access_count", 0])
    *
-   *   // Increment counter or initialize to 1
-   *   const updateFn = (opt: Option.Option<string | number>) =>
-   *     Option.isSome(opt) && typeof opt.value === "number"
-   *       ? Option.some(opt.value + 1)
-   *       : Option.some(1)
-   *
    *   // Increment existing counter
-   *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+   *   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", updateFn)
+   *   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)
    *
-   *   // Remove by returning None
-   *   yield* TxHashMap.modifyAt(storage, "file1.txt", () => Option.none())
-   *   const hasFile = yield* TxHashMap.has(storage, "file1.txt")
-   *   console.log(hasFile) // false
+   *   // 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")
    * })
    * ```
    *
@@ -1191,20 +1215,22 @@ export const modifyAt: {
   ): Effect.Effect<void>
 } = dual(
   3,
-  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): Effect.Effect<void> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const currentValue = HashMap.get(currentMap, key)
-        const newValue = f(currentValue)
+  <K, V>(
+    self: TxHashMap<K, V>,
+    key: K,
+    f: (value: Option.Option<V>) => Option.Option<V>
+  ): Effect.Effect<void> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const currentValue = HashMap.get(currentMap, key)
+      const newValue = f(currentValue)
 
-        if (Option.isSome(newValue)) {
-          yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue.value))
-        } else if (Option.isSome(currentValue)) {
-          yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
-        }
-      })
-    )
+      if (Option.isSome(newValue)) {
+        yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue.value))
+      } else if (Option.isSome(currentValue)) {
+        yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
+      }
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1227,7 +1253,7 @@ export const modifyAt: {
  *   // Useful for iteration
  *   for (const username of usernames) {
  *     const role = yield* TxHashMap.get(userRoles, username)
- *     if (Option.isSome(role)) {
+ *     if (role._tag === "Some") {
  *       console.log(`${username}: ${role.value}`)
  *     }
  *   }
@@ -1311,7 +1337,9 @@ export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>> =>
  * @since 2.0.0
  * @category combinators
  */
-export const entries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<readonly [K, V]>> =>
+export const entries = <K, V>(
+  self: TxHashMap<K, V>
+): Effect.Effect<Array<readonly [K, V]>> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.toEntries(map)
@@ -1351,7 +1379,9 @@ export const entries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<readon
  * @since 2.0.0
  * @category combinators
  */
-export const snapshot = <K, V>(self: TxHashMap<K, V>): Effect.Effect<HashMap.HashMap<K, V>> => TxRef.get(self.ref)
+export const snapshot = <K, V>(
+  self: TxHashMap<K, V>
+): Effect.Effect<HashMap.HashMap<K, V>> => TxRef.get(self.ref)
 
 /**
  * Merges another HashMap into this TxHashMap. If both maps contain the same key,
@@ -1499,8 +1529,10 @@ export const union: {
   <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void>
 } = dual(
   2,
-  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void> =>
-    TxRef.update(self.ref, (map) => HashMap.union(map, other))
+  <K1 extends K, K, V1 extends V, V>(
+    self: TxHashMap<K, V>,
+    other: HashMap.HashMap<K1, V1>
+  ): Effect.Effect<void> => TxRef.update(self.ref, (map) => HashMap.union(map, other))
 )
 
 /**
@@ -1850,7 +1882,7 @@ export const setMany: {
  * @category guards
  */
 export const isTxHashMap = <K, V>(value: unknown): value is TxHashMap<K, V> => {
-  return typeof value === "object" && value !== null && TypeId in value
+  return hasProperty(value, TypeId)
 }
 
 /**
@@ -1966,8 +1998,11 @@ export const getHash: {
   <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>>
 } = dual(
   3,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.getHash(map, key, hash)))
+  <K1 extends K, K, V>(
+    self: TxHashMap<K, V>,
+    key: K1,
+    hash: number
+  ): Effect.Effect<Option.Option<V>> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.getHash(map, key, hash)))
 )
 
 /**
@@ -2110,8 +2145,11 @@ export const hasHash: {
   <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean>
 } = dual(
   3,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasHash(map, key, hash)))
+  <K1 extends K, K, V>(
+    self: TxHashMap<K, V>,
+    key: K1,
+    hash: number
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasHash(map, key, hash)))
 )
 
 /**
@@ -2254,14 +2292,15 @@ export const map: {
   <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>>
 } = dual(
   2,
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const mappedMap = HashMap.map(currentMap, f)
-        return yield* fromHashMap(mappedMap)
-      })
-    )
+  <K, V, A>(
+    self: TxHashMap<K, V>,
+    f: (value: V, key: K) => A
+  ): Effect.Effect<TxHashMap<K, A>> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const mappedMap = HashMap.map(currentMap, f)
+      return yield* fromHashMap(mappedMap)
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -2511,14 +2550,15 @@ export const filter: {
   <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const filteredMap = HashMap.filter(currentMap, predicate)
-        return yield* fromHashMap(filteredMap)
-      })
-    )
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<TxHashMap<K, V>> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const filteredMap = HashMap.filter(currentMap, predicate)
+      return yield* fromHashMap(filteredMap)
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -2688,20 +2728,23 @@ export const reduce: {
   <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A>
 } = dual(
   3,
-  <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.reduce(map, zero, f)))
+  <K, V, A>(
+    self: TxHashMap<K, V>,
+    zero: A,
+    f: (accumulator: A, value: V, key: K) => A
+  ): Effect.Effect<A> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.reduce(map, zero, f)))
 )
 
 /**
- * Combines filtering and mapping in a single operation. Applies a function that returns
- * an Option to each entry, keeping only the Some values and transforming them.
+ * Combines filtering and mapping in a single operation. Applies a filter to each
+ * entry, keeping only successful results and transforming them.
  *
  * **Return behavior**: This function returns a new TxHashMap reference containing
- * only the transformed entries that returned Some values. The original TxHashMap is not modified.
+ * only the transformed entries that succeeded. The original TxHashMap is not modified.
  *
  * @example
  * ```ts
- * import { Effect, Option, TxHashMap } from "effect"
+ * import { Effect, Option, Result, TxHashMap } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a mixed data map
@@ -2716,10 +2759,10 @@ export const reduce: {
  *   const activeAdminAges = yield* TxHashMap.filterMap(
  *     userData,
  *     (user, username) => {
- *       if (!user.active || user.role !== "admin") return Option.none()
+ *       if (!user.active || user.role !== "admin") return Result.failVoid
  *       const age = parseInt(user.age)
- *       if (isNaN(age)) return Option.none()
- *       return Option.some({
+ *       if (isNaN(age)) return Result.failVoid
+ *       return Result.succeed({
  *         username,
  *         age,
  *         seniority: age > 27 ? "senior" : "junior"
@@ -2737,7 +2780,7 @@ export const reduce: {
  *   const validAges = yield* userData.pipe(
  *     TxHashMap.filterMap((user) => {
  *       const age = parseInt(user.age)
- *       return isNaN(age) ? Option.none() : Option.some(age)
+ *       return isNaN(age) ? Result.failVoid : Result.succeed(age)
  *     })
  *   )
  *
@@ -2751,15 +2794,15 @@ export const reduce: {
  */
 export const filterMap: {
   /**
-   * Combines filtering and mapping in a single operation. Applies a function that returns
-   * an Option to each entry, keeping only the Some values and transforming them.
+   * Combines filtering and mapping in a single operation. Applies a filter to each
+   * entry, keeping only successful results and transforming them.
    *
    * **Return behavior**: This function returns a new TxHashMap reference containing
-   * only the transformed entries that returned Some values. The original TxHashMap is not modified.
+   * only the transformed entries that succeeded. The original TxHashMap is not modified.
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, Option, Result, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   // Create a mixed data map
@@ -2774,10 +2817,10 @@ export const filterMap: {
    *   const activeAdminAges = yield* TxHashMap.filterMap(
    *     userData,
    *     (user, username) => {
-   *       if (!user.active || user.role !== "admin") return Option.none()
+   *       if (!user.active || user.role !== "admin") return Result.failVoid
    *       const age = parseInt(user.age)
-   *       if (isNaN(age)) return Option.none()
-   *       return Option.some({
+   *       if (isNaN(age)) return Result.failVoid
+   *       return Result.succeed({
    *         username,
    *         age,
    *         seniority: age > 27 ? "senior" : "junior"
@@ -2795,7 +2838,7 @@ export const filterMap: {
    *   const validAges = yield* userData.pipe(
    *     TxHashMap.filterMap((user) => {
    *       const age = parseInt(user.age)
-   *       return isNaN(age) ? Option.none() : Option.some(age)
+   *       return isNaN(age) ? Result.failVoid : Result.succeed(age)
    *     })
    *   )
    *
@@ -2807,17 +2850,17 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(f: (value: V, key: K) => Option.Option<A>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
+  <V, K, A, X>(f: (input: V, key: K) => Result<A, X>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
   /**
-   * Combines filtering and mapping in a single operation. Applies a function that returns
-   * an Option to each entry, keeping only the Some values and transforming them.
+   * Combines filtering and mapping in a single operation. Applies a filter to each
+   * entry, keeping only successful results and transforming them.
    *
    * **Return behavior**: This function returns a new TxHashMap reference containing
-   * only the transformed entries that returned Some values. The original TxHashMap is not modified.
+   * only the transformed entries that succeeded. The original TxHashMap is not modified.
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, Option, Result, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   // Create a mixed data map
@@ -2832,10 +2875,10 @@ export const filterMap: {
    *   const activeAdminAges = yield* TxHashMap.filterMap(
    *     userData,
    *     (user, username) => {
-   *       if (!user.active || user.role !== "admin") return Option.none()
+   *       if (!user.active || user.role !== "admin") return Result.failVoid
    *       const age = parseInt(user.age)
-   *       if (isNaN(age)) return Option.none()
-   *       return Option.some({
+   *       if (isNaN(age)) return Result.failVoid
+   *       return Result.succeed({
    *         username,
    *         age,
    *         seniority: age > 27 ? "senior" : "junior"
@@ -2853,7 +2896,7 @@ export const filterMap: {
    *   const validAges = yield* userData.pipe(
    *     TxHashMap.filterMap((user) => {
    *       const age = parseInt(user.age)
-   *       return isNaN(age) ? Option.none() : Option.some(age)
+   *       return isNaN(age) ? Result.failVoid : Result.succeed(age)
    *     })
    *   )
    *
@@ -2865,17 +2908,18 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => Option.Option<A>): 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>>
 } = dual(
   2,
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => Option.Option<A>): Effect.Effect<TxHashMap<K, A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const filteredMap = HashMap.filterMap(currentMap, f)
-        return yield* fromHashMap(filteredMap)
-      })
-    )
+  <K, V, A, X>(
+    self: TxHashMap<K, V>,
+    f: (input: V, key: K) => Result<A, X>
+  ): Effect.Effect<TxHashMap<K, A>> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const filteredMap = HashMap.filterMap(currentMap, f)
+      return yield* fromHashMap(filteredMap)
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -3003,8 +3047,10 @@ export const hasBy: {
   <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasBy(map, predicate)))
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasBy(map, predicate)))
 )
 
 /**
@@ -3029,8 +3075,8 @@ export const hasBy: {
  *     (task) => task.priority >= 2 && !task.completed
  *   )
  *
- *   if (highPriorityTask) {
- *     const [taskId, task] = highPriorityTask
+ *   if (highPriorityTask._tag === "Some") {
+ *     const [taskId, task] = highPriorityTask.value
  *     console.log(`Found task: ${taskId}, priority: ${task.priority}`)
  *     // "Found task: task3, priority: 2"
  *   }
@@ -3040,8 +3086,8 @@ export const hasBy: {
  *     TxHashMap.findFirst((task) => task.assignee === "alice")
  *   )
  *
- *   if (aliceTask) {
- *     console.log(`Alice's task: ${aliceTask[0]}`)
+ *   if (aliceTask._tag === "Some") {
+ *     console.log(`Alice's task: ${aliceTask.value[0]}`)
  *   }
  * })
  * ```
@@ -3072,8 +3118,8 @@ export const findFirst: {
    *     (task) => task.priority >= 2 && !task.completed
    *   )
    *
-   *   if (highPriorityTask) {
-   *     const [taskId, task] = highPriorityTask
+   *   if (highPriorityTask._tag === "Some") {
+   *     const [taskId, task] = highPriorityTask.value
    *     console.log(`Found task: ${taskId}, priority: ${task.priority}`)
    *     // "Found task: task3, priority: 2"
    *   }
@@ -3083,8 +3129,8 @@ export const findFirst: {
    *     TxHashMap.findFirst((task) => task.assignee === "alice")
    *   )
    *
-   *   if (aliceTask) {
-   *     console.log(`Alice's task: ${aliceTask[0]}`)
+   *   if (aliceTask._tag === "Some") {
+   *     console.log(`Alice's task: ${aliceTask.value[0]}`)
    *   }
    * })
    * ```
@@ -3092,7 +3138,7 @@ export const findFirst: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<[K, V] | undefined>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<[K, V]>>
   /**
    * Finds the first entry in the TxHashMap that matches the given predicate.
    * Returns the key-value pair as a tuple wrapped in an Option.
@@ -3115,8 +3161,8 @@ export const findFirst: {
    *     (task) => task.priority >= 2 && !task.completed
    *   )
    *
-   *   if (highPriorityTask) {
-   *     const [taskId, task] = highPriorityTask
+   *   if (highPriorityTask._tag === "Some") {
+   *     const [taskId, task] = highPriorityTask.value
    *     console.log(`Found task: ${taskId}, priority: ${task.priority}`)
    *     // "Found task: task3, priority: 2"
    *   }
@@ -3126,8 +3172,8 @@ export const findFirst: {
    *     TxHashMap.findFirst((task) => task.assignee === "alice")
    *   )
    *
-   *   if (aliceTask) {
-   *     console.log(`Alice's task: ${aliceTask[0]}`)
+   *   if (aliceTask._tag === "Some") {
+   *     console.log(`Alice's task: ${aliceTask.value[0]}`)
    *   }
    * })
    * ```
@@ -3135,10 +3181,13 @@ export const findFirst: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<[K, V] | undefined>
+  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<Option.Option<[K, V]>>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<[K, V] | undefined> =>
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<Option.Option<[K, V]>> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.findFirst(map, predicate)))
 )
 
@@ -3267,8 +3316,10 @@ export const some: {
   <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.some(map, predicate)))
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.some(map, predicate)))
 )
 
 /**
@@ -3396,8 +3447,10 @@ export const every: {
   <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.every(map, predicate)))
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.every(map, predicate)))
 )
 
 /**
@@ -3528,7 +3581,10 @@ export const forEach: {
   <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): Effect.Effect<void, E, R>
 } = dual(
   2,
-  <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): 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> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const entries = HashMap.toEntries(currentMap)
@@ -3701,123 +3757,121 @@ export const flatMap: {
     self: TxHashMap<K, V>,
     f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
   ): Effect.Effect<TxHashMap<K, A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const result = yield* empty</**
-         * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
-         * then flattening the results. Useful for complex transformations that require creating new maps.
-         *
-         * **Return behavior**: This function returns a new TxHashMap reference with the
-         * flattened results. The original TxHashMap is not modified.
-         *
-         * @example
-         * ```ts
-         * 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)
-         * })
-         * ```
-         *
-         * @since 2.0.0
-         * @category combinators
-         */
-        K, /**
-         * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
-         * then flattening the results. Useful for complex transformations that require creating new maps.
-         *
-         * **Return behavior**: This function returns a new TxHashMap reference with the
-         * flattened results. The original TxHashMap is not modified.
-         *
-         * @example
-         * ```ts
-         * 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)
-         * })
-         * ```
-         *
-         * @since 2.0.0
-         * @category combinators
-         */
-        A>()
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const result = yield* empty</**
+       * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
+       * then flattening the results. Useful for complex transformations that require creating new maps.
+       *
+       * **Return behavior**: This function returns a new TxHashMap reference with the
+       * flattened results. The original TxHashMap is not modified.
+       *
+       * @example
+       * ```ts
+       * 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)
+       * })
+       * ```
+       *
+       * @since 2.0.0
+       * @category combinators
+       */
+      K, /**
+       * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
+       * then flattening the results. Useful for complex transformations that require creating new maps.
+       *
+       * **Return behavior**: This function returns a new TxHashMap reference with the
+       * flattened results. The original TxHashMap is not modified.
+       *
+       * @example
+       * ```ts
+       * 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)
+       * })
+       * ```
+       *
+       * @since 2.0.0
+       * @category combinators
+       */
+      A>()
 
-        const mapEntries = HashMap.toEntries(currentMap)
-        for (const [key, value] of mapEntries) {
-          const newMap = yield* f(value, key)
-          const newEntries = yield* entries(newMap)
-          yield* setMany(result, newEntries)
-        }
+      const mapEntries = HashMap.toEntries(currentMap)
+      for (const [key, value] of mapEntries) {
+        const newMap = yield* f(value, key)
+        const newEntries = yield* entries(newMap)
+        yield* setMany(result, newEntries)
+      }
 
-        return result
-      })
-    )
+      return result
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -3865,14 +3919,14 @@ export const flatMap: {
  * @since 2.0.0
  * @category combinators
  */
-export const compact = <K, A>(self: TxHashMap<K, Option.Option<A>>): Effect.Effect<TxHashMap<K, A>> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const currentMap = yield* TxRef.get(self.ref)
-      const compactedMap = HashMap.compact(currentMap)
-      return yield* fromHashMap(compactedMap)
-    })
-  )
+export const compact = <K, A>(
+  self: TxHashMap<K, Option.Option<A>>
+): Effect.Effect<TxHashMap<K, A>> =>
+  Effect.gen(function*() {
+    const currentMap = yield* TxRef.get(self.ref)
+    const compactedMap = HashMap.compact(currentMap)
+    return yield* fromHashMap(compactedMap)
+  }).pipe(Effect.tx)
 
 /**
  * Returns an array of all key-value pairs in the TxHashMap.
@@ -3908,7 +3962,9 @@ export const compact = <K, A>(self: TxHashMap<K, Option.Option<A>>): Effect.Effe
  * @since 2.0.0
  * @category combinators
  */
-export const toEntries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<readonly [K, V]>> => entries(self)
+export const toEntries = <K, V>(
+  self: TxHashMap<K, V>
+): Effect.Effect<Array<readonly [K, V]>> => entries(self)
 
 /**
  * Returns an array of all values in the TxHashMap.