effect 3.16.2 → 3.16.3

package/src/Effect.ts

@@ -7265,6 +7265,64 @@ export const catchSomeDefect: {
  * @category Error handling
  */
 export const catchTag: {
+  /**
+   * Catches and handles specific errors by their `_tag` field, which is used as a
+   * discriminator.
+   *
+   * **When to Use**
+   *
+   * `catchTag` is useful when your errors are tagged with a readonly `_tag` field
+   * that identifies the error type. You can use this function to handle specific
+   * error types by matching the `_tag` value. This allows for precise error
+   * handling, ensuring that only specific errors are caught and handled.
+   *
+   * The error type must have a readonly `_tag` field to use `catchTag`. This
+   * field is used to identify and match errors.
+   *
+   * **Example** (Handling Errors by Tag)
+   *
+   * ```ts
+   * import { Effect, Random } from "effect"
+   *
+   * class HttpError {
+   *   readonly _tag = "HttpError"
+   * }
+   *
+   * class ValidationError {
+   *   readonly _tag = "ValidationError"
+   * }
+   *
+   * //      ┌─── Effect<string, HttpError | ValidationError, never>
+   * //      ▼
+   * const program = Effect.gen(function* () {
+   *   const n1 = yield* Random.next
+   *   const n2 = yield* Random.next
+   *   if (n1 < 0.5) {
+   *     yield* Effect.fail(new HttpError())
+   *   }
+   *   if (n2 < 0.5) {
+   *     yield* Effect.fail(new ValidationError())
+   *   }
+   *   return "some result"
+   * })
+   *
+   * //      ┌─── Effect<string, ValidationError, never>
+   * //      ▼
+   * const recovered = program.pipe(
+   *   // Only handle HttpError errors
+   *   Effect.catchTag("HttpError", (_HttpError) =>
+   *     Effect.succeed("Recovering from HttpError")
+   *   )
+   * )
+   * ```
+   *
+   * @see {@link catchTags} for a version that allows you to handle multiple error
+   * types at once.
+   *
+   * @since 2.0.0
+   * @category Error handling
+   */
+  <E, const K extends RA.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>>(...tags: K): <A, R>(self: Effect<A, E, R> & "missing error handler") => never
   /**
    * Catches and handles specific errors by their `_tag` field, which is used as a
    * discriminator.
@@ -7325,6 +7383,64 @@ export const catchTag: {
   <E, const K extends RA.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, A1, E1, R1>(
     ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect<A1, E1, R1>]
   ): <A, R>(self: Effect<A, E, R>) => Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+  /**
+   * Catches and handles specific errors by their `_tag` field, which is used as a
+   * discriminator.
+   *
+   * **When to Use**
+   *
+   * `catchTag` is useful when your errors are tagged with a readonly `_tag` field
+   * that identifies the error type. You can use this function to handle specific
+   * error types by matching the `_tag` value. This allows for precise error
+   * handling, ensuring that only specific errors are caught and handled.
+   *
+   * The error type must have a readonly `_tag` field to use `catchTag`. This
+   * field is used to identify and match errors.
+   *
+   * **Example** (Handling Errors by Tag)
+   *
+   * ```ts
+   * import { Effect, Random } from "effect"
+   *
+   * class HttpError {
+   *   readonly _tag = "HttpError"
+   * }
+   *
+   * class ValidationError {
+   *   readonly _tag = "ValidationError"
+   * }
+   *
+   * //      ┌─── Effect<string, HttpError | ValidationError, never>
+   * //      ▼
+   * const program = Effect.gen(function* () {
+   *   const n1 = yield* Random.next
+   *   const n2 = yield* Random.next
+   *   if (n1 < 0.5) {
+   *     yield* Effect.fail(new HttpError())
+   *   }
+   *   if (n2 < 0.5) {
+   *     yield* Effect.fail(new ValidationError())
+   *   }
+   *   return "some result"
+   * })
+   *
+   * //      ┌─── Effect<string, ValidationError, never>
+   * //      ▼
+   * const recovered = program.pipe(
+   *   // Only handle HttpError errors
+   *   Effect.catchTag("HttpError", (_HttpError) =>
+   *     Effect.succeed("Recovering from HttpError")
+   *   )
+   * )
+   * ```
+   *
+   * @see {@link catchTags} for a version that allows you to handle multiple error
+   * types at once.
+   *
+   * @since 2.0.0
+   * @category Error handling
+   */
+  <A, E, R, const K extends RA.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>>(self: Effect<A, E, R> & "missing error handler", ...tags: K): never
   /**
    * Catches and handles specific errors by their `_tag` field, which is used as a
    * discriminator.
@@ -28166,21 +28282,20 @@ export namespace fn {
    * @category Models
    */
   export type Gen = {
-    <Self, Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>
-    ): (this: Self, ...args: Args) => Effect<
+    <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>>(
+      body: (...args: Args) => Generator<Eff, AEff, never>
+    ): (...args: Args) => Effect<
       AEff,
       [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer E, infer _R>>] ? E : never,
       [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never
     >
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
       A extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28189,16 +28304,15 @@ export namespace fn {
         >,
         ...args: NoInfer<Args>
       ) => A
-    ): (this: Self, ...args: Args) => Effect.AsEffect<A>
+    ): (...args: Args) => Effect.AsEffect<A>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
       A,
       B extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28208,9 +28322,8 @@ export namespace fn {
         ...args: NoInfer<Args>
       ) => A,
       b: (_: A, ...args: NoInfer<Args>) => B
-    ): (this: Self, ...args: Args) => Effect.AsEffect<B>
+    ): (...args: Args) => Effect.AsEffect<B>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28218,7 +28331,7 @@ export namespace fn {
       B,
       C extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28229,9 +28342,8 @@ export namespace fn {
       ) => A,
       b: (_: A, ...args: NoInfer<Args>) => B,
       c: (_: B, ...args: NoInfer<Args>) => C
-    ): (this: Self, ...args: Args) => Effect.AsEffect<C>
+    ): (...args: Args) => Effect.AsEffect<C>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28240,7 +28352,7 @@ export namespace fn {
       C,
       D extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28252,9 +28364,8 @@ export namespace fn {
       b: (_: A, ...args: NoInfer<Args>) => B,
       c: (_: B, ...args: NoInfer<Args>) => C,
       d: (_: C, ...args: NoInfer<Args>) => D
-    ): (this: Self, ...args: Args) => Effect.AsEffect<D>
+    ): (...args: Args) => Effect.AsEffect<D>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28264,7 +28375,7 @@ export namespace fn {
       D,
       E extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28277,9 +28388,8 @@ export namespace fn {
       c: (_: B, ...args: NoInfer<Args>) => C,
       d: (_: C, ...args: NoInfer<Args>) => D,
       e: (_: D, ...args: NoInfer<Args>) => E
-    ): (this: Self, ...args: Args) => Effect.AsEffect<E>
+    ): (...args: Args) => Effect.AsEffect<E>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28290,7 +28400,7 @@ export namespace fn {
       E,
       F extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28304,9 +28414,8 @@ export namespace fn {
       d: (_: C, ...args: NoInfer<Args>) => D,
       e: (_: D, ...args: NoInfer<Args>) => E,
       f: (_: E, ...args: NoInfer<Args>) => F
-    ): (this: Self, ...args: Args) => Effect.AsEffect<F>
+    ): (...args: Args) => Effect.AsEffect<F>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28318,7 +28427,7 @@ export namespace fn {
       F,
       G extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28333,9 +28442,8 @@ export namespace fn {
       e: (_: D, ...args: NoInfer<Args>) => E,
       f: (_: E, ...args: NoInfer<Args>) => F,
       g: (_: F, ...args: NoInfer<Args>) => G
-    ): (this: Self, ...args: Args) => Effect.AsEffect<G>
+    ): (...args: Args) => Effect.AsEffect<G>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28348,7 +28456,7 @@ export namespace fn {
       G,
       H extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28364,9 +28472,8 @@ export namespace fn {
       f: (_: E, ...args: NoInfer<Args>) => F,
       g: (_: F, ...args: NoInfer<Args>) => G,
       h: (_: G, ...args: NoInfer<Args>) => H
-    ): (this: Self, ...args: Args) => Effect.AsEffect<H>
+    ): (...args: Args) => Effect.AsEffect<H>
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28380,7 +28487,7 @@ export namespace fn {
       H,
       I extends Effect<any, any, any>
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28397,7 +28504,7 @@ export namespace fn {
       g: (_: F, ...args: NoInfer<Args>) => G,
       h: (_: G, ...args: NoInfer<Args>) => H,
       i: (_: H, ...args: NoInfer<Args>) => I
-    ): (this: Self, ...args: Args) => Effect.AsEffect<I>
+    ): (...args: Args) => Effect.AsEffect<I>
   }
 
   /**
@@ -28405,50 +28512,50 @@ export namespace fn {
    * @category Models
    */
   export type NonGen = {
-    <Self, Eff extends Effect<any, any, any>, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    <Eff extends Effect<any, any, any>, Args extends Array<any>>(
+      body: (...args: Args) => Eff
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, D, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, D, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
       d: (_: D, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, D, E, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, D, E, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
       d: (_: D, ...args: NoInfer<Args>) => E,
       e: (_: E, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, D, E, F, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, D, E, F, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
       d: (_: D, ...args: NoInfer<Args>) => E,
       e: (_: E, ...args: NoInfer<Args>) => F,
       f: (_: F, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
@@ -28456,9 +28563,9 @@ export namespace fn {
       e: (_: E, ...args: NoInfer<Args>) => F,
       f: (_: F, ...args: NoInfer<Args>) => G,
       g: (_: G, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, H, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, H, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
@@ -28467,9 +28574,9 @@ export namespace fn {
       f: (_: F, ...args: NoInfer<Args>) => G,
       g: (_: G, ...args: NoInfer<Args>) => H,
       h: (_: H, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
-    <Self, Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, H, I, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => A,
+    ): (...args: Args) => Effect.AsEffect<Eff>
+    <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, H, I, Args extends Array<any>>(
+      body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
@@ -28479,7 +28586,7 @@ export namespace fn {
       g: (_: G, ...args: NoInfer<Args>) => H,
       h: (_: H, ...args: NoInfer<Args>) => I,
       i: (_: H, ...args: NoInfer<Args>) => Eff
-    ): (this: Self, ...args: Args) => Effect.AsEffect<Eff>
+    ): (...args: Args) => Effect.AsEffect<Eff>
   }
 
   /**
@@ -28487,15 +28594,15 @@ export namespace fn {
    * @category Models
    */
   export type Untraced = {
-    <Self, Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>>(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>
-    ): (this: Self, ...args: Args) => Effect<
+    <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>>(
+      body: (...args: Args) => Generator<Eff, AEff, never>
+    ): (...args: Args) => Effect<
       AEff,
       [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer E, infer _R>>] ? E : never,
       [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never
     >
-    <Self, Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A>(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+    <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A>(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28504,9 +28611,9 @@ export namespace fn {
         >,
         ...args: NoInfer<Args>
       ) => A
-    ): (this: Self, ...args: Args) => A
-    <Self, Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B>(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+    ): (...args: Args) => A
+    <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B>(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28516,9 +28623,8 @@ export namespace fn {
         ...args: NoInfer<Args>
       ) => A,
       b: (_: A, ...args: NoInfer<Args>) => B
-    ): (this: Self, ...args: Args) => B
+    ): (...args: Args) => B
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28526,7 +28632,7 @@ export namespace fn {
       B,
       C
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28537,9 +28643,8 @@ export namespace fn {
       ) => A,
       b: (_: A, ...args: NoInfer<Args>) => B,
       c: (_: B, ...args: NoInfer<Args>) => C
-    ): (this: Self, ...args: Args) => C
+    ): (...args: Args) => C
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28548,7 +28653,7 @@ export namespace fn {
       C,
       D
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28560,9 +28665,8 @@ export namespace fn {
       b: (_: A, ...args: NoInfer<Args>) => B,
       c: (_: B, ...args: NoInfer<Args>) => C,
       d: (_: C, ...args: NoInfer<Args>) => D
-    ): (this: Self, ...args: Args) => D
+    ): (...args: Args) => D
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28572,7 +28676,7 @@ export namespace fn {
       D,
       E
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28585,9 +28689,8 @@ export namespace fn {
       c: (_: B, ...args: NoInfer<Args>) => C,
       d: (_: C, ...args: NoInfer<Args>) => D,
       e: (_: D, ...args: NoInfer<Args>) => E
-    ): (this: Self, ...args: Args) => E
+    ): (...args: Args) => E
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28598,7 +28701,7 @@ export namespace fn {
       E,
       F
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28612,9 +28715,8 @@ export namespace fn {
       d: (_: C, ...args: NoInfer<Args>) => D,
       e: (_: D, ...args: NoInfer<Args>) => E,
       f: (_: E, ...args: NoInfer<Args>) => F
-    ): (this: Self, ...args: Args) => F
+    ): (...args: Args) => F
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28626,7 +28728,7 @@ export namespace fn {
       F,
       G
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28641,9 +28743,8 @@ export namespace fn {
       e: (_: D, ...args: NoInfer<Args>) => E,
       f: (_: E, ...args: NoInfer<Args>) => F,
       g: (_: F, ...args: NoInfer<Args>) => G
-    ): (this: Self, ...args: Args) => G
+    ): (...args: Args) => G
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28656,7 +28757,7 @@ export namespace fn {
       G,
       H
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28672,9 +28773,8 @@ export namespace fn {
       f: (_: E, ...args: NoInfer<Args>) => F,
       g: (_: F, ...args: NoInfer<Args>) => G,
       h: (_: G, ...args: NoInfer<Args>) => H
-    ): (this: Self, ...args: Args) => H
+    ): (...args: Args) => H
     <
-      Self,
       Eff extends YieldWrap<Effect<any, any, any>>,
       AEff,
       Args extends Array<any>,
@@ -28688,7 +28788,7 @@ export namespace fn {
       H,
       I
     >(
-      body: (this: Self, ...args: Args) => Generator<Eff, AEff, never>,
+      body: (...args: Args) => Generator<Eff, AEff, never>,
       a: (
         _: Effect<
           AEff,
@@ -28705,7 +28805,7 @@ export namespace fn {
       g: (_: F, ...args: NoInfer<Args>) => G,
       h: (_: G, ...args: NoInfer<Args>) => H,
       i: (_: H, ...args: NoInfer<Args>) => I
-    ): (this: Self, ...args: Args) => I
+    ): (...args: Args) => I
   }
 }
 

package/src/internal/core-effect.ts

@@ -236,19 +236,29 @@ export const catchSomeDefect = dual<
 )
 
 /* @internal */
-export const catchTag = dual<
+export const catchTag: {
+  <E, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>>(
+    ...tags: K
+  ): <A, R>(self: Effect.Effect<A, E, R>) => never
   <E, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, A1, E1, R1>(
-    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
-  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>,
+    ...args: [...tags: K, f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+  <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>>(
+    self: Effect.Effect<A, E, R>,
+    ...tags: K
+  ): never
   <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
     self: Effect.Effect<A, E, R>,
-    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
-  ) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
->(
+    ...args: [...tags: K, f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ): Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+} = dual(
   (args: any) => core.isEffect(args[0]),
   <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
     self: Effect.Effect<A, E, R>,
-    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+    ...args: [
+      ...tags: K & { [I in keyof K]: E extends { _tag: string } ? E["_tag"] : never },
+      f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>
+    ]
   ): Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1> => {
     const f = args[args.length - 1] as any
     let predicate: Predicate.Predicate<E>
@@ -266,7 +276,7 @@ export const catchTag = dual<
     }
     return core.catchIf(self, predicate as Predicate.Refinement<E, Extract<E, { _tag: K[number] }>>, f) as any
   }
-)
+) as any
 
 /** @internal */
 export const catchTags: {

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.16.2"
+let moduleVersion = "3.16.3"
 
 export const getCurrentVersion = () => moduleVersion