effect 4.0.0-beta.41 → 4.0.0-beta.43

package/src/TxHashMap.ts

@@ -55,7 +55,7 @@ const TxHashMapProto = {
  *   console.log(user) // Option.some("Alice")
  *
  *   // Multi-step atomic operations
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     Effect.gen(function*() {
  *       const currentUser = yield* TxHashMap.get(txMap, "user1")
  *       if (currentUser._tag === "Some") {
@@ -238,7 +238,7 @@ export declare namespace TxHashMap {
  * @since 2.0.0
  * @category constructors
  */
-export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
+export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>> =>
   Effect.gen(function*() {
     const ref = yield* TxRef.make(HashMap.empty<K, V>())
     return Object.assign(Object.create(TxHashMapProto), { ref })
@@ -277,7 +277,7 @@ export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>, never, Effect.Tran
  */
 export const make = <K, V>(
   ...entries: Array<readonly [K, V]>
-): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
+): Effect.Effect<TxHashMap<K, V>> =>
   Effect.gen(function*() {
     const hashMap = HashMap.make(...entries)
     const ref = yield* TxRef.make(hashMap)
@@ -320,7 +320,7 @@ export const make = <K, V>(
  */
 export const fromIterable = <K, V>(
   entries: Iterable<readonly [K, V]>
-): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
+): Effect.Effect<TxHashMap<K, V>> =>
   Effect.gen(function*() {
     const hashMap = HashMap.fromIterable(entries)
     const ref = yield* TxRef.make(hashMap)
@@ -390,7 +390,7 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>, never, Effect.Transaction>
+  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
   /**
    * Safely lookup the value for the specified key in the TxHashMap.
    *
@@ -422,10 +422,10 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>, never, Effect.Transaction>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>, never, Effect.Transaction> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>> =>
     Effect.gen(function*() {
       const map = yield* TxRef.get(self.ref)
       return HashMap.get(map, key)
@@ -501,7 +501,7 @@ export const set: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(key: K, value: V): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
+  <K, V>(key: K, value: V): (self: TxHashMap<K, V>) => Effect.Effect<void>
   /**
    * Sets the value for the specified key in the TxHashMap.
    *
@@ -536,10 +536,10 @@ export const set: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void, never, Effect.Transaction>
+  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void>
 } = dual(
   3,
-  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void, never, Effect.Transaction> =>
+  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void> =>
     TxRef.update(self.ref, (map) => HashMap.set(map, key, value))
 )
 
@@ -604,7 +604,7 @@ export const has: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
   /**
    * Checks if the specified key exists in the TxHashMap.
    *
@@ -635,10 +635,10 @@ export const has: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       const map = yield* TxRef.get(self.ref)
       return HashMap.has(map, key)
@@ -720,7 +720,7 @@ export const remove: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
   /**
    * Removes the specified key from the TxHashMap.
    *
@@ -758,10 +758,10 @@ export const remove: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const existed = HashMap.has(currentMap, key)
@@ -769,7 +769,7 @@ export const remove: {
         yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
       }
       return existed
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -808,8 +808,7 @@ export const remove: {
  * @since 2.0.0
  * @category combinators
  */
-export const clear = <K, V>(self: TxHashMap<K, V>): Effect.Effect<void, never, Effect.Transaction> =>
-  TxRef.set(self.ref, HashMap.empty<K, V>())
+export const clear = <K, V>(self: TxHashMap<K, V>): Effect.Effect<void> => TxRef.set(self.ref, HashMap.empty<K, V>())
 
 /**
  * Returns the number of entries in the TxHashMap.
@@ -843,7 +842,7 @@ export const clear = <K, V>(self: TxHashMap<K, V>): Effect.Effect<void, never, E
  * @since 2.0.0
  * @category combinators
  */
-export const size = <K, V>(self: TxHashMap<K, V>): Effect.Effect<number, never, Effect.Transaction> =>
+export const size = <K, V>(self: TxHashMap<K, V>): Effect.Effect<number> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.size(map)
@@ -877,7 +876,7 @@ export const size = <K, V>(self: TxHashMap<K, V>): Effect.Effect<number, never,
  * @since 2.0.0
  * @category combinators
  */
-export const isEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.isEmpty(map)
@@ -906,7 +905,7 @@ export const isEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean, nev
  * @since 2.0.0
  * @category combinators
  */
-export const isNonEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isNonEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean> =>
   Effect.map(isEmpty(self), (empty) => !empty)
 
 /**
@@ -996,7 +995,7 @@ export const modify: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(key: K, f: (value: V) => V): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>, never, Effect.Transaction>
+  <K, V>(key: K, f: (value: V) => V): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
   /**
    * Updates the value for the specified key if it exists.
    *
@@ -1040,14 +1039,14 @@ export const modify: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>, never, Effect.Transaction>
+  <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>, never, Effect.Transaction> =>
+  ): Effect.Effect<Option.Option<V>> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const currentValue = HashMap.get(currentMap, key)
@@ -1057,7 +1056,7 @@ export const modify: {
         return currentValue
       }
       return Option.none()
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1159,7 +1158,7 @@ export const modifyAt: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
+  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: TxHashMap<K, V>) => Effect.Effect<void>
   /**
    * Updates the value for the specified key using an Option-based update function.
    *
@@ -1213,14 +1212,14 @@ export const modifyAt: {
     self: TxHashMap<K, V>,
     key: K,
     f: (value: Option.Option<V>) => Option.Option<V>
-  ): Effect.Effect<void, never, Effect.Transaction>
+  ): Effect.Effect<void>
 } = dual(
   3,
   <K, V>(
     self: TxHashMap<K, V>,
     key: K,
     f: (value: Option.Option<V>) => Option.Option<V>
-  ): Effect.Effect<void, never, Effect.Transaction> =>
+  ): Effect.Effect<void> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const currentValue = HashMap.get(currentMap, key)
@@ -1231,7 +1230,7 @@ export const modifyAt: {
       } else if (Option.isSome(currentValue)) {
         yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
       }
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1264,7 +1263,7 @@ export const modifyAt: {
  * @since 2.0.0
  * @category combinators
  */
-export const keys = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<K>, never, Effect.Transaction> =>
+export const keys = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<K>> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return Array.from(HashMap.keys(map))
@@ -1301,7 +1300,7 @@ export const keys = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<K>, never
  * @since 2.0.0
  * @category combinators
  */
-export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>, never, Effect.Transaction> =>
+export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.toValues(map)
@@ -1340,7 +1339,7 @@ export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>, nev
  */
 export const entries = <K, V>(
   self: TxHashMap<K, V>
-): Effect.Effect<Array<readonly [K, V]>, never, Effect.Transaction> =>
+): Effect.Effect<Array<readonly [K, V]>> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.toEntries(map)
@@ -1382,7 +1381,7 @@ export const entries = <K, V>(
  */
 export const snapshot = <K, V>(
   self: TxHashMap<K, V>
-): Effect.Effect<HashMap.HashMap<K, V>, never, Effect.Transaction> => TxRef.get(self.ref)
+): Effect.Effect<HashMap.HashMap<K, V>> => TxRef.get(self.ref)
 
 /**
  * Merges another HashMap into this TxHashMap. If both maps contain the same key,
@@ -1479,7 +1478,7 @@ export const union: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(other: HashMap.HashMap<K1, V1>): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
+  <K1 extends K, K, V1 extends V, V>(other: HashMap.HashMap<K1, V1>): (self: TxHashMap<K, V>) => Effect.Effect<void>
   /**
    * Merges another HashMap into this TxHashMap. If both maps contain the same key,
    * the value from the other map will be used.
@@ -1527,13 +1526,13 @@ export const union: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void, never, Effect.Transaction>
+  <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, never, Effect.Transaction> => TxRef.update(self.ref, (map) => HashMap.union(map, other))
+  ): Effect.Effect<void> => TxRef.update(self.ref, (map) => HashMap.union(map, other))
 )
 
 /**
@@ -1621,7 +1620,7 @@ export const removeMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(keys: Iterable<K1>): <V>(self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
+  <K1 extends K, K>(keys: Iterable<K1>): <V>(self: TxHashMap<K, V>) => Effect.Effect<void>
   /**
    * Removes multiple keys from the TxHashMap.
    *
@@ -1664,10 +1663,10 @@ export const removeMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void, never, Effect.Transaction>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void, never, Effect.Transaction> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void> =>
     TxRef.update(self.ref, (map) => HashMap.removeMany(map, keys))
 )
 
@@ -1786,7 +1785,7 @@ export const setMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(entries: Iterable<readonly [K1, V1]>): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
+  <K1 extends K, K, V1 extends V, V>(entries: Iterable<readonly [K1, V1]>): (self: TxHashMap<K, V>) => Effect.Effect<void>
   /**
    * Sets multiple key-value pairs in the TxHashMap.
    *
@@ -1844,13 +1843,13 @@ export const setMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, entries: Iterable<readonly [K1, V1]>): Effect.Effect<void, never, Effect.Transaction>
+  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, entries: Iterable<readonly [K1, V1]>): Effect.Effect<void>
 } = dual(
   2,
   <K1 extends K, K, V1 extends V, V>(
     self: TxHashMap<K, V>,
     entries: Iterable<readonly [K1, V1]>
-  ): Effect.Effect<void, never, Effect.Transaction> => TxRef.update(self.ref, (map) => HashMap.setMany(map, entries))
+  ): Effect.Effect<void> => TxRef.update(self.ref, (map) => HashMap.setMany(map, entries))
 )
 
 /**
@@ -1959,7 +1958,7 @@ export const getHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>, never, Effect.Transaction>
+  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
   /**
    * Lookup the value for the specified key in the TxHashMap using a custom hash.
    * This can provide performance benefits when the hash is precomputed.
@@ -1996,15 +1995,14 @@ export const getHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>, never, Effect.Transaction>
+  <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>, never, Effect.Transaction> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.getHash(map, key, hash)))
+  ): Effect.Effect<Option.Option<V>> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.getHash(map, key, hash)))
 )
 
 /**
@@ -2098,7 +2096,7 @@ export const hasHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
   /**
    * Checks if the specified key has an entry in the TxHashMap using a custom hash.
    * This can provide performance benefits when the hash is precomputed.
@@ -2144,15 +2142,14 @@ export const hasHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean, never, Effect.Transaction>
+  <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, never, Effect.Transaction> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasHash(map, key, hash)))
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasHash(map, key, hash)))
 )
 
 /**
@@ -2246,7 +2243,7 @@ export const map: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(f: (value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <A, V, K>(f: (value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
   /**
    * Transforms all values in the TxHashMap using the provided function, preserving keys.
    *
@@ -2292,18 +2289,18 @@ export const map: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <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>, never, Effect.Transaction> =>
+  ): 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)
 )
 
 /**
@@ -2403,7 +2400,7 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, B extends V>(predicate: (value: V, key: K) => value is B): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, B>, never, Effect.Transaction>
+  <K, V, B extends V>(predicate: (value: V, key: K) => value is B): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, B>>
   /**
    * Filters the TxHashMap to keep only entries that satisfy the provided predicate.
    *
@@ -2452,7 +2449,7 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, V>>
   /**
    * Filters the TxHashMap to keep only entries that satisfy the provided predicate.
    *
@@ -2501,7 +2498,7 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, B extends V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => value is B): Effect.Effect<TxHashMap<K, B>, never, Effect.Transaction>
+  <K, V, B extends V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => value is B): Effect.Effect<TxHashMap<K, B>>
   /**
    * Filters the TxHashMap to keep only entries that satisfy the provided predicate.
    *
@@ -2550,18 +2547,18 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction>
+  <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>, never, Effect.Transaction> =>
+  ): 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)
 )
 
 /**
@@ -2673,7 +2670,7 @@ export const reduce: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(zero: A, f: (accumulator: A, value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<A, never, Effect.Transaction>
+  <A, V, K>(zero: A, f: (accumulator: A, value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<A>
   /**
    * 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.
@@ -2728,15 +2725,14 @@ export const reduce: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A, never, Effect.Transaction>
+  <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, never, Effect.Transaction> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.reduce(map, zero, f)))
+  ): Effect.Effect<A> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.reduce(map, zero, f)))
 )
 
 /**
@@ -2854,7 +2850,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <V, K, A, X>(f: (input: V, key: K) => Result<A, X>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <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 filter to each
    * entry, keeping only successful results and transforming them.
@@ -2912,18 +2908,18 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A, X>(self: TxHashMap<K, V>, f: (input: V, key: K) => Result<A, X>): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <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, X>(
     self: TxHashMap<K, V>,
     f: (input: V, key: K) => Result<A, X>
-  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+  ): 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)
 )
 
 /**
@@ -3007,7 +3003,7 @@ export const hasBy: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
   /**
    * Checks if any entry in the TxHashMap matches the given predicate.
    *
@@ -3048,14 +3044,13 @@ export const hasBy: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean, never, Effect.Transaction>
+  <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, never, Effect.Transaction> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasBy(map, predicate)))
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasBy(map, predicate)))
 )
 
 /**
@@ -3143,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<Option.Option<[K, V]>, never, Effect.Transaction>
+  <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.
@@ -3186,13 +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<Option.Option<[K, V]>, never, Effect.Transaction>
+  <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<Option.Option<[K, V]>, never, Effect.Transaction> =>
+  ): Effect.Effect<Option.Option<[K, V]>> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.findFirst(map, predicate)))
 )
 
@@ -3277,7 +3272,7 @@ export const some: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
   /**
    * Checks if at least one entry in the TxHashMap satisfies the given predicate.
    *
@@ -3318,14 +3313,13 @@ export const some: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean, never, Effect.Transaction>
+  <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, never, Effect.Transaction> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.some(map, predicate)))
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.some(map, predicate)))
 )
 
 /**
@@ -3409,7 +3403,7 @@ export const every: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
   /**
    * Checks if all entries in the TxHashMap satisfy the given predicate.
    *
@@ -3450,14 +3444,13 @@ export const every: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean, never, Effect.Transaction>
+  <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, never, Effect.Transaction> =>
-    TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.every(map, predicate)))
+  ): Effect.Effect<boolean> => TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.every(map, predicate)))
 )
 
 /**
@@ -3543,7 +3536,7 @@ export const forEach: {
    * @since 2.0.0
    * @category combinators
    */
-  <V, K, R, E>(f: (value: V, key: K) => Effect.Effect<void, E, R>): (self: TxHashMap<K, V>) => Effect.Effect<void, E, R | Effect.Transaction>
+  <V, K, R, E>(f: (value: V, key: K) => Effect.Effect<void, E, R>): (self: TxHashMap<K, V>) => Effect.Effect<void, E, R>
   /**
    * Executes a side-effect function for each entry in the TxHashMap.
    * The function receives the value and key as parameters and can perform effects.
@@ -3585,13 +3578,13 @@ export const forEach: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): Effect.Effect<void, E, R | Effect.Transaction>
+  <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 | Effect.Transaction> =>
+  ): Effect.Effect<void, E, R> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const entries = HashMap.toEntries(currentMap)
@@ -3702,9 +3695,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(
-    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
-  ): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <A, V, K>(f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
   /**
    * 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.
@@ -3758,14 +3749,14 @@ export const flatMap: {
    */
   <K, V, A>(
     self: TxHashMap<K, V>,
-    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
-  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
+  ): Effect.Effect<TxHashMap<K, A>>
 } = dual(
   2,
   <K, V, A>(
     self: TxHashMap<K, V>,
-    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
-  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
+  ): Effect.Effect<TxHashMap<K, A>> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const result = yield* empty</**
@@ -3880,7 +3871,7 @@ export const flatMap: {
       }
 
       return result
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -3930,12 +3921,12 @@ export const flatMap: {
  */
 export const compact = <K, A>(
   self: TxHashMap<K, Option.Option<A>>
-): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+): 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.
@@ -3973,7 +3964,7 @@ export const compact = <K, A>(
  */
 export const toEntries = <K, V>(
   self: TxHashMap<K, V>
-): Effect.Effect<Array<readonly [K, V]>, never, Effect.Transaction> => entries(self)
+): Effect.Effect<Array<readonly [K, V]>> => entries(self)
 
 /**
  * Returns an array of all values in the TxHashMap.
@@ -4011,13 +4002,12 @@ export const toEntries = <K, V>(
  * @since 2.0.0
  * @category combinators
  */
-export const toValues = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>, never, Effect.Transaction> =>
-  values(self)
+export const toValues = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>> => values(self)
 
 /**
  * Helper function to create a TxHashMap from an existing HashMap
  */
-const fromHashMap = <K, V>(hashMap: HashMap.HashMap<K, V>): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
+const fromHashMap = <K, V>(hashMap: HashMap.HashMap<K, V>): Effect.Effect<TxHashMap<K, V>> =>
   Effect.gen(function*() {
     const ref = yield* TxRef.make(hashMap)
     return Object.assign(Object.create(TxHashMapProto), { ref })