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

package/src/TxReentrantLock.ts

@@ -98,14 +98,14 @@ const TxReentrantLockProto: Omit<TxReentrantLock, typeof TypeId | "stateRef"> =
  * @since 4.0.0
  * @category constructors
  */
-export const make = (): Effect.Effect<TxReentrantLock, never, Effect.Transaction> =>
+export const make = (): Effect.Effect<TxReentrantLock> =>
   Effect.gen(function*() {
     const stateRef = yield* TxRef.make<LockState>(emptyState)
     const self = Object.create(TxReentrantLockProto)
     self[TypeId] = TypeId
     self.stateRef = stateRef
     return self
-  })
+  }).pipe(Effect.tx)
 
 // =============================================================================
 // Mutations
@@ -131,7 +131,7 @@ export const make = (): Effect.Effect<TxReentrantLock, never, Effect.Transaction
  * @since 4.0.0
  * @category mutations
  */
-export const acquireRead = (self: TxReentrantLock): Effect.Effect<number, never, Effect.Transaction> =>
+export const acquireRead = (self: TxReentrantLock): Effect.Effect<number> =>
   Effect.withFiber((fiber) =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
@@ -139,7 +139,7 @@ export const acquireRead = (self: TxReentrantLock): Effect.Effect<number, never,
 
       // If another fiber holds the write lock, retry
       if (Option.isSome(state.writer) && state.writer.value[0] !== fiberId) {
-        return yield* Effect.retryTransaction
+        return yield* Effect.txRetry
       }
 
       // Grant read lock
@@ -150,7 +150,7 @@ export const acquireRead = (self: TxReentrantLock): Effect.Effect<number, never,
         readers: HashMap.set(state.readers, fiberId, newCount)
       })
       return newCount
-    })
+    }).pipe(Effect.tx)
   )
 
 /**
@@ -174,7 +174,7 @@ export const acquireRead = (self: TxReentrantLock): Effect.Effect<number, never,
  * @since 4.0.0
  * @category mutations
  */
-export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number, never, Effect.Transaction> =>
+export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number> =>
   Effect.withFiber((fiber) =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
@@ -182,13 +182,13 @@ export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number, never
 
       // If another fiber holds the write lock, retry
       if (Option.isSome(state.writer) && state.writer.value[0] !== fiberId) {
-        return yield* Effect.retryTransaction
+        return yield* Effect.txRetry
       }
 
       // If other fibers hold read locks, retry
       for (const [readerId] of state.readers) {
         if (readerId !== fiberId && Option.getOrElse(HashMap.get(state.readers, readerId), () => 0) > 0) {
-          return yield* Effect.retryTransaction
+          return yield* Effect.txRetry
         }
       }
 
@@ -209,7 +209,7 @@ export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number, never
         writer: Option.some([fiberId, 1] as const)
       })
       return 1
-    })
+    }).pipe(Effect.tx)
   )
 
 /**
@@ -231,7 +231,7 @@ export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number, never
  * @since 4.0.0
  * @category mutations
  */
-export const releaseRead = (self: TxReentrantLock): Effect.Effect<number, never, Effect.Transaction> =>
+export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
   Effect.withFiber((fiber) =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
@@ -247,7 +247,7 @@ export const releaseRead = (self: TxReentrantLock): Effect.Effect<number, never,
 
       yield* TxRef.set(self.stateRef, { ...state, readers: newReaders })
       return newCount
-    })
+    }).pipe(Effect.tx)
   )
 
 /**
@@ -269,7 +269,7 @@ export const releaseRead = (self: TxReentrantLock): Effect.Effect<number, never,
  * @since 4.0.0
  * @category mutations
  */
-export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number, never, Effect.Transaction> =>
+export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
   Effect.withFiber((fiber) =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
@@ -284,7 +284,7 @@ export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number, never
 
       yield* TxRef.set(self.stateRef, { ...state, writer: newWriter })
       return newCount
-    })
+    }).pipe(Effect.tx)
   )
 
 /**
@@ -313,8 +313,8 @@ export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number, never
  */
 export const readLock = (self: TxReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.transaction(acquireRead(self)),
-    () => Effect.transaction(releaseRead(self))
+    acquireRead(self),
+    () => releaseRead(self)
   )
 
 /**
@@ -343,34 +343,10 @@ export const readLock = (self: TxReentrantLock): Effect.Effect<number, never, Sc
  */
 export const writeLock = (self: TxReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.transaction(acquireWrite(self)),
-    () => Effect.transaction(releaseWrite(self))
+    acquireWrite(self),
+    () => releaseWrite(self)
   )
 
-/**
- * Alias for `writeLock`. Acquires a write lock for the duration of the scope.
- *
- * @example
- * ```ts
- * import { Effect, TxReentrantLock } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const lock = yield* TxReentrantLock.make()
- *
- *   yield* Effect.scoped(
- *     Effect.gen(function*() {
- *       yield* TxReentrantLock.lock(lock)
- *       // exclusive lock is held
- *     })
- *   )
- * })
- * ```
- *
- * @since 4.0.0
- * @category mutations
- */
-export const lock = writeLock
-
 /**
  * Runs the provided effect while holding a read lock. The lock is automatically
  * released after the effect completes, fails, or is interrupted.
@@ -442,16 +418,16 @@ export const withReadLock: {
     const [effect] = args
     return (self: TxReentrantLock) =>
       Effect.acquireUseRelease(
-        Effect.transaction(acquireRead(self)),
+        acquireRead(self),
         () => effect,
-        () => Effect.transaction(releaseRead(self))
+        () => releaseRead(self)
       )
   }
   const [self, effect] = args
   return Effect.acquireUseRelease(
-    Effect.transaction(acquireRead(self)),
+    acquireRead(self),
     () => effect,
-    () => Effect.transaction(releaseRead(self))
+    () => releaseRead(self)
   )
 }) as any
 
@@ -526,16 +502,16 @@ export const withWriteLock: {
     const [effect] = args
     return (self: TxReentrantLock) =>
       Effect.acquireUseRelease(
-        Effect.transaction(acquireWrite(self)),
+        acquireWrite(self),
         () => effect,
-        () => Effect.transaction(releaseWrite(self))
+        () => releaseWrite(self)
       )
   }
   const [self, effect] = args
   return Effect.acquireUseRelease(
-    Effect.transaction(acquireWrite(self)),
+    acquireWrite(self),
     () => effect,
-    () => Effect.transaction(releaseWrite(self))
+    () => releaseWrite(self)
   )
 }) as any
 
@@ -627,7 +603,7 @@ export const withLock: {
  * @since 4.0.0
  * @category getters
  */
-export const readLocks = (self: TxReentrantLock): Effect.Effect<number, never, Effect.Transaction> =>
+export const readLocks = (self: TxReentrantLock): Effect.Effect<number> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     let total = 0
@@ -654,7 +630,7 @@ export const readLocks = (self: TxReentrantLock): Effect.Effect<number, never, E
  * @since 4.0.0
  * @category getters
  */
-export const writeLocks = (self: TxReentrantLock): Effect.Effect<number, never, Effect.Transaction> =>
+export const writeLocks = (self: TxReentrantLock): Effect.Effect<number> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return Option.isSome(state.writer) ? state.writer.value[1] : 0
@@ -677,7 +653,7 @@ export const writeLocks = (self: TxReentrantLock): Effect.Effect<number, never,
  * @since 4.0.0
  * @category getters
  */
-export const locked = (self: TxReentrantLock): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const locked = (self: TxReentrantLock): Effect.Effect<boolean> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return HashMap.size(state.readers) > 0 || Option.isSome(state.writer)
@@ -700,7 +676,7 @@ export const locked = (self: TxReentrantLock): Effect.Effect<boolean, never, Eff
  * @since 4.0.0
  * @category getters
  */
-export const readLocked = (self: TxReentrantLock): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const readLocked = (self: TxReentrantLock): Effect.Effect<boolean> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return HashMap.size(state.readers) > 0
@@ -723,7 +699,7 @@ export const readLocked = (self: TxReentrantLock): Effect.Effect<boolean, never,
  * @since 4.0.0
  * @category getters
  */
-export const writeLocked = (self: TxReentrantLock): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const writeLocked = (self: TxReentrantLock): Effect.Effect<boolean> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return Option.isSome(state.writer)

package/src/TxRef.ts

@@ -3,7 +3,7 @@
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and in order to
  * track changes, a transaction will retry whenever a conflict is detected or whenever the
- * transaction explicitely calls to `Effect.retryTransaction` and any of the accessed TxRef values
+ * transaction explicitely calls to `Effect.txRetry` and any of the accessed TxRef values
  * change.
  *
  * @since 4.0.0
@@ -21,7 +21,7 @@ const TypeId = "~effect/transactions/TxRef"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and in order to
  * track changes, a transaction will retry whenever a conflict is detected or whenever the
- * transaction explicitely calls to `Effect.retryTransaction` and any of the accessed TxRef values
+ * transaction explicitely calls to `Effect.txRetry` and any of the accessed TxRef values
  * change.
  *
  * @since 4.0.0
@@ -35,12 +35,12 @@ const TypeId = "~effect/transactions/TxRef"
  *   const ref: TxRef.TxRef<number> = yield* TxRef.make(0)
  *
  *   // Use within a transaction
- *   yield* Effect.transaction(Effect.gen(function*() {
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     const current = yield* TxRef.get(ref)
  *     yield* TxRef.set(ref, current + 1)
  *   }))
  *
- *   const final = yield* Effect.transaction(TxRef.get(ref))
+ *   const final = yield* TxRef.get(ref)
  *   console.log(final) // 1
  * })
  * ```
@@ -64,28 +64,21 @@ export interface TxRef<in out A> extends Pipeable {
  *
  * const program = Effect.gen(function*() {
  *   // Create a transactional reference with initial value
- *   const counter = yield* Effect.transaction(TxRef.make(0))
- *   const name = yield* Effect.transaction(TxRef.make("Alice"))
+ *   const counter = yield* TxRef.make(0)
+ *   const name = yield* TxRef.make("Alice")
  *
  *   // Use in transactions
- *   yield* Effect.transaction(Effect.gen(function*() {
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     yield* TxRef.set(counter, 42)
  *     yield* TxRef.set(name, "Bob")
  *   }))
  *
- *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 42
- *   console.log(yield* Effect.transaction(TxRef.get(name))) // "Bob"
+ *   console.log(yield* TxRef.get(counter)) // 42
+ *   console.log(yield* TxRef.get(name)) // "Bob"
  * })
  * ```
  */
-export const make = <A>(initial: A) =>
-  Effect.withTxState((state) =>
-    Effect.sync(() => {
-      const ref = makeUnsafe(initial)
-      state.journal.set(ref, { version: ref.version, value: ref.value })
-      return ref
-    })
-  )
+export const make = <A>(initial: A) => Effect.sync(() => makeUnsafe(initial))
 
 /**
  * Creates a new `TxRef` with the specified initial value.
@@ -128,12 +121,10 @@ export const makeUnsafe = <A>(initial: A): TxRef<A> => ({
  *   const counter = yield* TxRef.make(0)
  *
  *   // Modify and return both old and new value
- *   const result = yield* Effect.transaction(
- *     TxRef.modify(counter, (current) => [current * 2, current + 1])
- *   )
+ *   const result = yield* TxRef.modify(counter, (current) => [current * 2, current + 1])
  *
  *   console.log(result) // 0 (the return value: current * 2)
- *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 1 (the new value: current + 1)
+ *   console.log(yield* TxRef.get(counter)) // 1 (the new value: current + 1)
  * })
  * ```
  */
@@ -151,16 +142,14 @@ export const modify: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Modify and return both old and new value
-   *   const result = yield* Effect.transaction(
-   *     TxRef.modify(counter, (current) => [current * 2, current + 1])
-   *   )
+   *   const result = yield* TxRef.modify(counter, (current) => [current * 2, current + 1])
    *
    *   console.log(result) // 0 (the return value: current * 2)
-   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 1 (the new value: current + 1)
+   *   console.log(yield* TxRef.get(counter)) // 1 (the new value: current + 1)
    * })
    * ```
    */
-  <A, R>(f: (current: NoInfer<A>) => [returnValue: R, newValue: A]): (self: TxRef<A>) => Effect.Effect<R, never, Effect.Transaction>
+  <A, R>(f: (current: NoInfer<A>) => [returnValue: R, newValue: A]): (self: TxRef<A>) => Effect.Effect<R>
   /**
    * Modifies the value of the `TxRef` using the provided function.
    *
@@ -174,23 +163,20 @@ export const modify: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Modify and return both old and new value
-   *   const result = yield* Effect.transaction(
-   *     TxRef.modify(counter, (current) => [current * 2, current + 1])
-   *   )
+   *   const result = yield* TxRef.modify(counter, (current) => [current * 2, current + 1])
    *
    *   console.log(result) // 0 (the return value: current * 2)
-   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 1 (the new value: current + 1)
+   *   console.log(yield* TxRef.get(counter)) // 1 (the new value: current + 1)
    * })
    * ```
    */
-  <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R, never, Effect.Transaction>
-} = dual(
-  2,
-  <A, R>(
-    self: TxRef<A>,
-    f: (current: A) => [returnValue: R, newValue: A]
-  ): Effect.Effect<R, never, Effect.Transaction> =>
-    Effect.withTxState((state) =>
+  <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R>
+} = dual(2, <A, R>(
+  self: TxRef<A>,
+  f: (current: A) => [returnValue: R, newValue: A]
+): Effect.Effect<R> =>
+  Effect.Transaction.asEffect().pipe(
+    Effect.flatMap((state) =>
       Effect.sync(() => {
         if (!state.journal.has(self)) {
           state.journal.set(self, { version: self.version, value: self.value })
@@ -200,8 +186,9 @@ export const modify: {
         current.value = next
         return returnValue
       })
-    )
-)
+    ),
+    Effect.tx
+  ))
 
 /**
  * Updates the value of the `TxRef` using the provided function.
@@ -216,11 +203,11 @@ export const modify: {
  *   const counter = yield* TxRef.make(10)
  *
  *   // Update the value using a function
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     TxRef.update(counter, (current) => current * 2)
  *   )
  *
- *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 20
+ *   console.log(yield* TxRef.get(counter)) // 20
  * })
  * ```
  */
@@ -238,15 +225,15 @@ export const update: {
    *   const counter = yield* TxRef.make(10)
    *
    *   // Update the value using a function
-   *   yield* Effect.transaction(
+   *   yield* Effect.tx(
    *     TxRef.update(counter, (current) => current * 2)
    *   )
    *
-   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 20
+   *   console.log(yield* TxRef.get(counter)) // 20
    * })
    * ```
    */
-  <A>(f: (current: NoInfer<A>) => A): (self: TxRef<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(f: (current: NoInfer<A>) => A): (self: TxRef<A>) => Effect.Effect<void>
   /**
    * Updates the value of the `TxRef` using the provided function.
    *
@@ -260,20 +247,19 @@ export const update: {
    *   const counter = yield* TxRef.make(10)
    *
    *   // Update the value using a function
-   *   yield* Effect.transaction(
+   *   yield* Effect.tx(
    *     TxRef.update(counter, (current) => current * 2)
    *   )
    *
-   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 20
+   *   console.log(yield* TxRef.get(counter)) // 20
    * })
    * ```
    */
-  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void, never, Effect.Transaction>
-} = dual(
-  2,
-  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void, never, Effect.Transaction> =>
-    modify(self, (current) => [void 0, f(current)])
-)
+  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void>
+} = dual(2, <A>(
+  self: TxRef<A>,
+  f: (current: A) => A
+): Effect.Effect<void> => modify(self, (current) => [void 0, f(current)]))
 
 /**
  * Reads the current value of the `TxRef`.
@@ -288,7 +274,7 @@ export const update: {
  *   const counter = yield* TxRef.make(42)
  *
  *   // Read the value within a transaction
- *   const value = yield* Effect.transaction(
+ *   const value = yield* Effect.tx(
  *     TxRef.get(counter)
  *   )
  *
@@ -296,8 +282,7 @@ export const update: {
  * })
  * ```
  */
-export const get = <A>(self: TxRef<A>): Effect.Effect<A, never, Effect.Transaction> =>
-  modify(self, (current) => [current, current])
+export const get = <A>(self: TxRef<A>): Effect.Effect<A> => modify(self, (current) => [current, current])
 
 /**
  * Sets the value of the `TxRef`.
@@ -312,11 +297,11 @@ export const get = <A>(self: TxRef<A>): Effect.Effect<A, never, Effect.Transacti
  *   const counter = yield* TxRef.make(0)
  *
  *   // Set a new value within a transaction
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     TxRef.set(counter, 100)
  *   )
  *
- *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 100
+ *   console.log(yield* TxRef.get(counter)) // 100
  * })
  * ```
  */
@@ -334,15 +319,15 @@ export const set: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Set a new value within a transaction
-   *   yield* Effect.transaction(
+   *   yield* Effect.tx(
    *     TxRef.set(counter, 100)
    *   )
    *
-   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 100
+   *   console.log(yield* TxRef.get(counter)) // 100
    * })
    * ```
    */
-  <A>(value: A): (self: TxRef<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(value: A): (self: TxRef<A>) => Effect.Effect<void>
   /**
    * Sets the value of the `TxRef`.
    *
@@ -356,13 +341,16 @@ export const set: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Set a new value within a transaction
-   *   yield* Effect.transaction(
+   *   yield* Effect.tx(
    *     TxRef.set(counter, 100)
    *   )
    *
-   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 100
+   *   console.log(yield* TxRef.get(counter)) // 100
    * })
    * ```
    */
-  <A>(self: TxRef<A>, value: A): Effect.Effect<void, never, Effect.Transaction>
-} = dual(2, <A>(self: TxRef<A>, value: A): Effect.Effect<void, never, Effect.Transaction> => update(self, () => value))
+  <A>(self: TxRef<A>, value: A): Effect.Effect<void>
+} = dual(2, <A>(
+  self: TxRef<A>,
+  value: A
+): Effect.Effect<void> => update(self, () => value))

package/src/TxSemaphore.ts

@@ -101,7 +101,7 @@ const makeTxSemaphore = (permitsRef: TxRef.TxRef<number>, capacity: number): TxS
  * @since 4.0.0
  * @category constructors
  */
-export const make = (permits: number): Effect.Effect<TxSemaphore, never, Effect.Transaction> =>
+export const make = (permits: number): Effect.Effect<TxSemaphore> =>
   Effect.gen(function*() {
     if (permits < 0) {
       return yield* Effect.die(new Error("Permits must be non-negative"))
@@ -109,7 +109,7 @@ export const make = (permits: number): Effect.Effect<TxSemaphore, never, Effect.
 
     const permitsRef = yield* TxRef.make(permits)
     return makeTxSemaphore(permitsRef, permits)
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Gets the current number of available permits in the semaphore.
@@ -141,8 +141,7 @@ export const make = (permits: number): Effect.Effect<TxSemaphore, never, Effect.
  * @since 4.0.0
  * @category combinators
  */
-export const available = (self: TxSemaphore): Effect.Effect<number, never, Effect.Transaction> =>
-  TxRef.get(self.permitsRef)
+export const available = (self: TxSemaphore): Effect.Effect<number> => TxRef.get(self.permitsRef)
 
 /**
  * Gets the maximum capacity (total permits) of the semaphore.
@@ -202,14 +201,14 @@ export const capacity = (self: TxSemaphore): Effect.Effect<number> => Effect.suc
  * @since 4.0.0
  * @category combinators
  */
-export const acquire = (self: TxSemaphore): Effect.Effect<void, never, Effect.Transaction> =>
+export const acquire = (self: TxSemaphore): Effect.Effect<void> =>
   Effect.gen(function*() {
     const permits = yield* TxRef.get(self.permitsRef)
     if (permits <= 0) {
-      return yield* Effect.retryTransaction
+      return yield* Effect.txRetry
     }
     yield* TxRef.set(self.permitsRef, permits - 1)
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Acquires the specified number of permits from the semaphore. If not enough
@@ -238,17 +237,17 @@ export const acquire = (self: TxSemaphore): Effect.Effect<void, never, Effect.Tr
  * @since 4.0.0
  * @category combinators
  */
-export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void, never, Effect.Transaction> => {
+export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
   if (n <= 0) {
     return Effect.die(new Error("Number of permits must be positive"))
   }
   return Effect.gen(function*() {
     const permits = yield* TxRef.get(self.permitsRef)
     if (permits < n) {
-      return yield* Effect.retryTransaction
+      return yield* Effect.txRetry
     }
     yield* TxRef.set(self.permitsRef, permits - n)
-  })
+  }).pipe(Effect.tx)
 }
 
 /**
@@ -278,7 +277,7 @@ export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void, neve
  * @since 4.0.0
  * @category combinators
  */
-export const tryAcquire = (self: TxSemaphore): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const tryAcquire = (self: TxSemaphore): Effect.Effect<boolean> =>
   TxRef.modify(self.permitsRef, (permits: number) => {
     if (permits > 0) {
       return [true, permits - 1]
@@ -314,7 +313,7 @@ export const tryAcquire = (self: TxSemaphore): Effect.Effect<boolean, never, Eff
  * @since 4.0.0
  * @category combinators
  */
-export const tryAcquireN = (self: TxSemaphore, n: number): Effect.Effect<boolean, never, Effect.Transaction> => {
+export const tryAcquireN = (self: TxSemaphore, n: number): Effect.Effect<boolean> => {
   if (n <= 0) {
     return Effect.die(new Error("Number of permits must be positive"))
   }
@@ -354,7 +353,7 @@ export const tryAcquireN = (self: TxSemaphore, n: number): Effect.Effect<boolean
  * @since 4.0.0
  * @category combinators
  */
-export const release = (self: TxSemaphore): Effect.Effect<void, never, Effect.Transaction> =>
+export const release = (self: TxSemaphore): Effect.Effect<void> =>
   TxRef.update(self.permitsRef, (permits: number) => permits >= self.capacity ? permits : permits + 1)
 
 /**
@@ -386,7 +385,7 @@ export const release = (self: TxSemaphore): Effect.Effect<void, never, Effect.Tr
  * @since 4.0.0
  * @category combinators
  */
-export const releaseN = (self: TxSemaphore, n: number): Effect.Effect<void, never, Effect.Transaction> => {
+export const releaseN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
   if (n <= 0) {
     return Effect.die(new Error("Number of permits must be positive"))
   }
@@ -518,16 +517,16 @@ export const withPermit: {
     const [self] = args
     return (effect: Effect.Effect<any, any, any>) =>
       Effect.acquireUseRelease(
-        Effect.transaction(acquire(self)),
+        acquire(self),
         () => effect,
-        () => Effect.transaction(release(self))
+        () => release(self)
       )
   }
   const [self, effect] = args
   return Effect.acquireUseRelease(
-    Effect.transaction(acquire(self)),
+    acquire(self),
     () => effect,
-    () => Effect.transaction(release(self))
+    () => release(self)
   )
 }) as any
 
@@ -656,16 +655,16 @@ export const withPermits: {
     const [self, n] = args
     return (effect: Effect.Effect<any, any, any>) =>
       Effect.acquireUseRelease(
-        Effect.transaction(acquireN(self, n)),
+        acquireN(self, n),
         () => effect,
-        () => Effect.transaction(releaseN(self, n))
+        () => releaseN(self, n)
       )
   }
   const [self, n, effect] = args
   return Effect.acquireUseRelease(
-    Effect.transaction(acquireN(self, n)),
+    acquireN(self, n),
     () => effect,
-    () => Effect.transaction(releaseN(self, n))
+    () => releaseN(self, n)
   )
 }) as any
 
@@ -710,8 +709,8 @@ export const withPermits: {
  */
 export const withPermitScoped = (self: TxSemaphore): Effect.Effect<void, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.transaction(acquire(self)),
-    () => Effect.transaction(release(self))
+    acquire(self),
+    () => release(self)
   )
 
 /**