effect 4.0.0-beta.40 → 4.0.0-beta.42

package/src/TxChunk.ts

@@ -5,7 +5,7 @@
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @since 4.0.0
  */
@@ -28,7 +28,7 @@ const TypeId = "~effect/transactions/TxChunk"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @example
  * ```ts
@@ -48,7 +48,7 @@ const TypeId = "~effect/transactions/TxChunk"
  *   console.log(Chunk.toReadonlyArray(result)) // [1, 2, 3, 4]
  *
  *   // Multi-step atomic operation - use explicit transaction
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     Effect.gen(function*() {
  *       yield* TxChunk.prepend(txChunk, 0)
  *       yield* TxChunk.append(txChunk, 5)
@@ -109,7 +109,7 @@ const TxChunkProto = {
  * })
  * ```
  */
-export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
+export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>> =>
   Effect.map(TxRef.make(initial), (ref) => makeUnsafe(ref))
 
 /**
@@ -140,7 +140,7 @@ export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>, neve
  * })
  * ```
  */
-export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
+export const empty = <A = never>(): Effect.Effect<TxChunk<A>> =>
   Effect.map(TxRef.make(Chunk.empty<A>()), (ref) => makeUnsafe(ref))
 
 /**
@@ -164,7 +164,7 @@ export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Tran
  *   console.log(Chunk.toReadonlyArray(chunk)) // [1, 2, 3, 4, 5]
  *
  *   // Multi-step atomic modification - use explicit transaction
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     Effect.gen(function*() {
  *       yield* TxChunk.append(txChunk, 6)
  *       yield* TxChunk.prepend(txChunk, 0)
@@ -176,7 +176,7 @@ export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Tran
  * })
  * ```
  */
-export const fromIterable = <A>(iterable: Iterable<A>): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
+export const fromIterable = <A>(iterable: Iterable<A>): Effect.Effect<TxChunk<A>> =>
   Effect.map(TxRef.make(Chunk.fromIterable(iterable)), (ref) => makeUnsafe(ref))
 
 /**
@@ -263,9 +263,7 @@ export const modify: {
    */
   <A, R>(
     f: (current: Chunk.Chunk<NoInfer<A>>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): (
-    self: TxChunk<A>
-  ) => Effect.Effect<R, never, Effect.Transaction>
+  ): (self: TxChunk<A>) => Effect.Effect<R>
   /**
    * Modifies the value of the `TxChunk` using the provided function.
    *
@@ -297,13 +295,13 @@ export const modify: {
   <A, R>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): Effect.Effect<R, never, Effect.Transaction>
+  ): Effect.Effect<R>
 } = dual(
   2,
   <A, R>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): Effect.Effect<R, never, Effect.Transaction> => TxRef.modify(self.ref, f)
+  ): Effect.Effect<R> => TxRef.modify(self.ref, f)
 )
 
 /**
@@ -357,7 +355,7 @@ export const update: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(f: (current: Chunk.Chunk<NoInfer<A>>) => Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(f: (current: Chunk.Chunk<NoInfer<A>>) => Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Updates the value of the `TxChunk` using the provided function.
    *
@@ -383,13 +381,13 @@ export const update: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
   <A>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>
-  ): Effect.Effect<void, never, Effect.Transaction> => TxRef.update(self.ref, f)
+  ): Effect.Effect<void> => TxRef.update(self.ref, f)
 )
 
 /**
@@ -415,8 +413,7 @@ export const update: {
  * @since 4.0.0
  * @category combinators
  */
-export const get = <A>(self: TxChunk<A>): Effect.Effect<Chunk.Chunk<A>, never, Effect.Transaction> =>
-  TxRef.get(self.ref)
+export const get = <A>(self: TxChunk<A>): Effect.Effect<Chunk.Chunk<A>> => TxRef.get(self.ref)
 
 /**
  * Sets the value of the `TxChunk`.
@@ -469,7 +466,7 @@ export const set: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(chunk: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(chunk: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Sets the value of the `TxChunk`.
    *
@@ -495,11 +492,10 @@ export const set: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
-    TxRef.set(self.ref, chunk)
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void> => TxRef.set(self.ref, chunk)
 )
 
 /**
@@ -551,7 +547,7 @@ export const append: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Appends an element to the end of the `TxChunk`.
    *
@@ -576,11 +572,10 @@ export const append: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.append(current, element))
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void> => update(self, (current) => Chunk.append(current, element))
 )
 
 /**
@@ -632,7 +627,7 @@ export const prepend: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Prepends an element to the beginning of the `TxChunk`.
    *
@@ -657,11 +652,10 @@ export const prepend: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.prepend(current, element))
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void> => update(self, (current) => Chunk.prepend(current, element))
 )
 
 /**
@@ -688,7 +682,7 @@ export const prepend: {
  * @since 4.0.0
  * @category combinators
  */
-export const size = <A>(self: TxChunk<A>): Effect.Effect<number, never, Effect.Transaction> =>
+export const size = <A>(self: TxChunk<A>): Effect.Effect<number> =>
   modify(self, (current) => [Chunk.size(current), current])
 
 /**
@@ -714,7 +708,7 @@ export const size = <A>(self: TxChunk<A>): Effect.Effect<number, never, Effect.T
  * @since 4.0.0
  * @category combinators
  */
-export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
   modify(self, (current) => [Chunk.isEmpty(current), current])
 
 /**
@@ -740,7 +734,7 @@ export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effe
  * @since 4.0.0
  * @category combinators
  */
-export const isNonEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isNonEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
   modify(self, (current) => [Chunk.isNonEmpty(current), current])
 
 /**
@@ -792,7 +786,7 @@ export const take: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Takes the first `n` elements from the `TxChunk`.
    *
@@ -817,11 +811,10 @@ export const take: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.take(current, n))
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.take(current, n))
 )
 
 /**
@@ -873,7 +866,7 @@ export const drop: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Drops the first `n` elements from the `TxChunk`.
    *
@@ -898,11 +891,10 @@ export const drop: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.drop(current, n))
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.drop(current, n))
 )
 
 /**
@@ -954,7 +946,7 @@ export const slice: {
    * @since 4.0.0
    * @category combinators
    */
-  (start: number, end: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  (start: number, end: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Takes a slice of the `TxChunk` from `start` to `end` (exclusive).
    *
@@ -979,10 +971,10 @@ export const slice: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void>
 } = dual(
   3,
-  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void> =>
     update(self, (current) => Chunk.take(Chunk.drop(current, start), end - start))
 )
 
@@ -1039,7 +1031,7 @@ export const map: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(f: (a: NoInfer<A>) => A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(f: (a: NoInfer<A>) => A): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Maps each element of the `TxChunk` using the provided function.
    * Note: This only works when the mapped type B is assignable to A.
@@ -1066,11 +1058,10 @@ export const map: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.map(current, f))
+  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void> => update(self, (current) => Chunk.map(current, f))
 )
 
 /**
@@ -1124,7 +1115,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B extends A>(refinement: (a: A) => a is B): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A, B extends A>(refinement: (a: A) => a is B): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1150,7 +1141,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(predicate: (a: A) => boolean): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(predicate: (a: A) => boolean): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1176,7 +1167,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B extends A>(self: TxChunk<A>, refinement: (a: A) => a is B): Effect.Effect<void, never, Effect.Transaction>
+  <A, B extends A>(self: TxChunk<A>, refinement: (a: A) => a is B): Effect.Effect<void>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1202,10 +1193,10 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void> =>
     update(self, (current) => Chunk.filter(current, predicate))
 )
 
@@ -1262,7 +1253,7 @@ export const appendAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Concatenates another chunk to the end of the `TxChunk`.
    *
@@ -1289,10 +1280,10 @@ export const appendAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void> =>
     update(self, (current) => Chunk.appendAll(current, other))
 )
 
@@ -1349,7 +1340,7 @@ export const prependAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Concatenates another chunk to the beginning of the `TxChunk`.
    *
@@ -1376,10 +1367,10 @@ export const prependAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void> =>
     update(self, (current) => Chunk.prependAll(current, other))
 )
 
@@ -1440,7 +1431,7 @@ export const concat: {
    * })
    * ```
    */
-  <A>(other: TxChunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(other: TxChunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Concatenates another `TxChunk` to the end of this `TxChunk`.
    *
@@ -1469,12 +1460,12 @@ export const concat: {
    * })
    * ```
    */
-  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void> =>
     Effect.gen(function*() {
       const otherChunk = yield* get(other)
       yield* appendAll(self, otherChunk)
-    })
+    }).pipe(Effect.tx)
 )

package/src/TxDeferred.ts

@@ -93,7 +93,7 @@ const makeTxDeferred = <A, E>(ref: TxRef.TxRef<Option<Result<A, E>>>): TxDeferre
  * @since 4.0.0
  * @category constructors
  */
-export const make = <A, E = never>(): Effect.Effect<TxDeferred<A, E>, never, Effect.Transaction> =>
+export const make = <A, E = never>(): Effect.Effect<TxDeferred<A, E>> =>
   Effect.map(TxRef.make<Option<Result<A, E>>>(O.none()), makeTxDeferred)
 
 /**
@@ -115,16 +115,16 @@ export const make = <A, E = never>(): Effect.Effect<TxDeferred<A, E>, never, Eff
  * @since 4.0.0
  * @category getters
  */
-const await_ = <A, E>(self: TxDeferred<A, E>): Effect.Effect<A, E, Effect.Transaction> =>
+const await_ = <A, E>(self: TxDeferred<A, E>): Effect.Effect<A, E> =>
   Effect.gen(function*() {
     const option = yield* TxRef.get(self.ref)
     if (O.isNone(option)) {
-      return yield* Effect.retryTransaction
+      return yield* Effect.txRetry
     }
     return Res.isSuccess(option.value)
       ? option.value.success
       : yield* Effect.fail(option.value.failure)
-  })
+  }).pipe(Effect.tx)
 
 export {
   /**
@@ -159,8 +159,7 @@ export {
  * @since 4.0.0
  * @category getters
  */
-export const poll = <A, E>(self: TxDeferred<A, E>): Effect.Effect<Option<Result<A, E>>, never, Effect.Transaction> =>
-  TxRef.get(self.ref)
+export const poll = <A, E>(self: TxDeferred<A, E>): Effect.Effect<Option<Result<A, E>>> => TxRef.get(self.ref)
 
 /**
  * Completes the deferred with a `Result`. Returns `true` if this was the first
@@ -203,7 +202,7 @@ export const done: {
    * @since 4.0.0
    * @category mutations
    */
-  <A, E>(result: Result<A, E>): (self: TxDeferred<A, E>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <A, E>(result: Result<A, E>): (self: TxDeferred<A, E>) => Effect.Effect<boolean>
   /**
    * Completes the deferred with a `Result`. Returns `true` if this was the first
    * completion, `false` if already completed.
@@ -224,10 +223,10 @@ export const done: {
    * @since 4.0.0
    * @category mutations
    */
-  <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean, never, Effect.Transaction>
+  <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean>
 } = dual(
   2,
-  <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean, never, Effect.Transaction> =>
+  <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean> =>
     TxRef.modify(self.ref, (current) => {
       if (O.isSome(current)) {
         return [false, current]
@@ -277,7 +276,7 @@ export const succeed: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(value: A): <E>(self: TxDeferred<A, E>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <A>(value: A): <E>(self: TxDeferred<A, E>) => Effect.Effect<boolean>
   /**
    * Completes the deferred with a success value. Returns `true` if this was the
    * first completion, `false` if already completed.
@@ -298,11 +297,10 @@ export const succeed: {
    * @since 4.0.0
    * @category mutations
    */
-  <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean, never, Effect.Transaction>
+  <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean>
 } = dual(
   2,
-  <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean, never, Effect.Transaction> =>
-    done(self, Res.succeed(value))
+  <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean> => done(self, Res.succeed(value))
 )
 
 /**
@@ -346,7 +344,7 @@ export const fail: {
    * @since 4.0.0
    * @category mutations
    */
-  <E>(error: E): <A>(self: TxDeferred<A, E>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <E>(error: E): <A>(self: TxDeferred<A, E>) => Effect.Effect<boolean>
   /**
    * Completes the deferred with a failure. Returns `true` if this was the first
    * completion, `false` if already completed.
@@ -367,11 +365,10 @@ export const fail: {
    * @since 4.0.0
    * @category mutations
    */
-  <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean, never, Effect.Transaction>
+  <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean>
 } = dual(
   2,
-  <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean, never, Effect.Transaction> =>
-    done(self, Res.fail(error))
+  <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean> => done(self, Res.fail(error))
 )
 
 /**