effect 3.16.11 → 3.16.13

package/src/Data.ts

@@ -361,15 +361,20 @@ export declare namespace TaggedEnum {
       readonly $is: <Tag extends A["_tag"]>(tag: Tag) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
       readonly $match: {
         <
-          Cases extends {
+          const Cases extends {
             readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
           }
-        >(cases: Cases): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>
+        >(
+          cases: Cases & { [K in Exclude<keyof Cases, A["_tag"]>]: never }
+        ): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>
         <
-          Cases extends {
+          const Cases extends {
             readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
           }
-        >(value: A, cases: Cases): Unify<ReturnType<Cases[A["_tag"]]>>
+        >(
+          value: A,
+          cases: Cases & { [K in Exclude<keyof Cases, A["_tag"]>]: never }
+        ): Unify<ReturnType<Cases[A["_tag"]]>>
       }
     }
   >
@@ -398,7 +403,7 @@ export declare namespace TaggedEnum {
           ) => any
         }
       >(
-        cases: Cases
+        cases: Cases & { [K in Exclude<keyof Cases, Z["taggedEnum"]["_tag"]>]: never }
       ): (self: TaggedEnum.Kind<Z, A, B, C, D>) => Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
       <
         A,
@@ -412,7 +417,7 @@ export declare namespace TaggedEnum {
         }
       >(
         self: TaggedEnum.Kind<Z, A, B, C, D>,
-        cases: Cases
+        cases: Cases & { [K in Exclude<keyof Cases, Z["taggedEnum"]["_tag"]>]: never }
       ): Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
     }
   }

package/src/Effect.ts

@@ -7265,64 +7265,6 @@ 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.
@@ -7440,65 +7382,7 @@ export const catchTag: {
    * @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.
-   *
-   * **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>, R1, E1, A1>(
+  <A, E, R, const K extends RA.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, A1, E1, R1>(
     self: Effect<A, E, R>,
     ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect<A1, E1, R1>]
   ): Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>

package/src/internal/core-effect.ts

@@ -237,19 +237,32 @@ export const catchSomeDefect = dual<
 
 /* @internal */
 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<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  <
+    E,
+    const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>,
+    A1,
+    E1,
+    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>(
+  <
+    A,
+    E,
+    R,
+    const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>,
+    A1,
+    E1,
+    R1
+  >(
     self: Effect.Effect<A, E, R>,
-    ...args: [...tags: K, f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, 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]),

package/src/internal/version.ts

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