effect 3.14.21 → 3.15.0

package/dist/dts/Effect.d.ts

@@ -45,7 +45,7 @@ import * as Scheduler from "./Scheduler.js";
 import type * as Scope from "./Scope.js";
 import type * as Supervisor from "./Supervisor.js";
 import type * as Tracer from "./Tracer.js";
-import type { Concurrency, Contravariant, Covariant, NoExcessProperties, NoInfer, NotFunction } from "./Types.js";
+import type { Concurrency, Contravariant, Covariant, EqualsWith, NoExcessProperties, NoInfer, NotFunction } from "./Types.js";
 import type * as Unify from "./Unify.js";
 import { type YieldWrap } from "./Utils.js";
 /**
@@ -6763,13 +6763,13 @@ export declare const catchTag: {
      * @since 2.0.0
      * @category Error handling
      */
-    <K extends E extends {
+    <E, const K extends RA.NonEmptyReadonlyArray<E extends {
         _tag: string;
-    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: NoInfer<Extract<E, {
-        _tag: K;
-    }>>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, {
-        _tag: K;
-    }>, R1 | R>;
+    } ? 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.
@@ -6827,13 +6827,13 @@ export declare const catchTag: {
      * @since 2.0.0
      * @category Error handling
      */
-    <A, E, R, K extends E extends {
+    <A, E, R, const K extends RA.NonEmptyReadonlyArray<E extends {
         _tag: string;
-    } ? E["_tag"] : never, R1, E1, A1>(self: Effect<A, E, R>, k: K, f: (e: Extract<E, {
-        _tag: K;
-    }>) => Effect<A1, E1, R1>): Effect<A | A1, E1 | Exclude<E, {
-        _tag: K;
-    }>, R | R1>;
+    } ? E["_tag"] : never>, R1, E1, A1>(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>;
 };
 /**
  * Handles multiple errors in a single block of code using their `_tag` field.
@@ -8852,51 +8852,7 @@ export declare const liftPredicate: {
      * @category Condition Checking
      * @since 3.4.0
      */
-    <A, B extends A, E>(refinement: Refinement<A, B>, orFailWith: (a: A) => E): (a: A) => Effect<B, E>;
-    /**
-     * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
-     * or failing with specified error if the predicate fails
-     *
-     * **Example**
-     *
-     * ```ts
-     * import { Effect } from "effect"
-     *
-     * const isPositive = (n: number): boolean => n > 0
-     *
-     * // succeeds with `1`
-     * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`)
-     *
-     * // fails with `"0 is not positive"`
-     * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`)
-     * ```
-     *
-     * @category Condition Checking
-     * @since 3.4.0
-     */
-    <B extends A, E, A = B>(predicate: Predicate<A>, orFailWith: (a: A) => E): (a: B) => Effect<B, E>;
-    /**
-     * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
-     * or failing with specified error if the predicate fails
-     *
-     * **Example**
-     *
-     * ```ts
-     * import { Effect } from "effect"
-     *
-     * const isPositive = (n: number): boolean => n > 0
-     *
-     * // succeeds with `1`
-     * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`)
-     *
-     * // fails with `"0 is not positive"`
-     * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`)
-     * ```
-     *
-     * @category Condition Checking
-     * @since 3.4.0
-     */
-    <A, E, B extends A>(self: A, refinement: Refinement<A, B>, orFailWith: (a: A) => E): Effect<B, E>;
+    <T extends A, E, B extends T = T, A = T>(predicate: Refinement<T, B> | Predicate<T>, orFailWith: (a: EqualsWith<T, B, A, Exclude<A, B>>) => E): (a: A) => Effect<EqualsWith<T, B, A, B>, E>;
     /**
      * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
      * or failing with specified error if the predicate fails
@@ -8918,7 +8874,7 @@ export declare const liftPredicate: {
      * @category Condition Checking
      * @since 3.4.0
      */
-    <B extends A, E, A = B>(self: B, predicate: Predicate<A>, orFailWith: (a: A) => E): Effect<B, E>;
+    <A, E, B extends A = A>(self: A, predicate: Refinement<A, B> | Predicate<A>, orFailWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => E): Effect<B, E>;
 };
 /**
  * Replaces the value inside an effect with a constant value.
@@ -15570,43 +15526,7 @@ export declare const filterOrDie: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, orDieWith: (a: NoInfer<A>) => unknown): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
-    /**
-     * Filters an effect, dying with a custom defect if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect dies with a custom defect
-     * generated by the `orDieWith` function.
-     *
-     * **When to Use**
-     *
-     * This is useful for enforcing constraints on values and treating violations as
-     * fatal program errors.
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A>(predicate: Predicate<NoInfer<A>>, orDieWith: (a: NoInfer<A>) => unknown): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
-    /**
-     * Filters an effect, dying with a custom defect if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect dies with a custom defect
-     * generated by the `orDieWith` function.
-     *
-     * **When to Use**
-     *
-     * This is useful for enforcing constraints on values and treating violations as
-     * fatal program errors.
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>, orDieWith: (a: A) => unknown): Effect<B, E, R>;
+    <A, B extends A = A>(predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>, orDieWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => unknown): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
     /**
      * Filters an effect, dying with a custom defect if the predicate fails.
      *
@@ -15624,7 +15544,7 @@ export declare const filterOrDie: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>, orDieWith: (a: A) => unknown): Effect<A, E, R>;
+    <A, E, R, B extends A>(self: Effect<A, E, R>, predicate: Predicate<A> | Refinement<A, B>, orDieWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => unknown): Effect<B, E, R>;
 };
 /**
  * Filters an effect, dying with a custom message if the predicate fails.
@@ -15651,33 +15571,7 @@ export declare const filterOrDieMessage: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
-    /**
-     * Filters an effect, dying with a custom message if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function works like {@link filterOrDie} but allows you to specify a
-     * custom error message to describe the reason for the failure. The message is
-     * included in the defect when the predicate evaluates to `false`.
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
-    /**
-     * Filters an effect, dying with a custom message if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function works like {@link filterOrDie} but allows you to specify a
-     * custom error message to describe the reason for the failure. The message is
-     * included in the defect when the predicate evaluates to `false`.
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>, message: string): Effect<B, E, R>;
+    <A, B extends A = A>(predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
     /**
      * Filters an effect, dying with a custom message if the predicate fails.
      *
@@ -15690,7 +15584,7 @@ export declare const filterOrDieMessage: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>, message: string): Effect<A, E, R>;
+    <A, E, R, B extends A = A>(self: Effect<A, E, R>, predicate: Predicate<A> | Refinement<A, B>, message: string): Effect<B, E, R>;
 };
 /**
  * Filters an effect, providing an alternative effect if the predicate fails.
@@ -15719,35 +15613,7 @@ export declare const filterOrElse: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B extends A, C, E2, R2>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => Effect<C, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<B | C, E2 | E, R2 | R>;
-    /**
-     * Filters an effect, providing an alternative effect if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, it executes the `orElse` effect instead. The
-     * `orElse` effect can produce an alternative value or perform additional
-     * computations.
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, B, E2, R2>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => Effect<B, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<A | B, E2 | E, R2 | R>;
-    /**
-     * Filters an effect, providing an alternative effect if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, it executes the `orElse` effect instead. The
-     * `orElse` effect can produce an alternative value or perform additional
-     * computations.
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, E, R, B extends A, C, E2, R2>(self: Effect<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => Effect<C, E2, R2>): Effect<B | C, E | E2, R | R2>;
+    <A, C, E2, R2, B extends A = A>(predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>, orElse: (a: EqualsWith<A, B, NoInfer<A>, Exclude<NoInfer<A>, B>>) => Effect<C, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<B | C, E2 | E, R2 | R>;
     /**
      * Filters an effect, providing an alternative effect if the predicate fails.
      *
@@ -15761,7 +15627,7 @@ export declare const filterOrElse: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B, E2, R2>(self: Effect<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => Effect<B, E2, R2>): Effect<A | B, E | E2, R | R2>;
+    <A, E, R, C, E2, R2, B extends A = A>(self: Effect<A, E, R>, predicate: Predicate<A> | Refinement<A, B>, orElse: (a: EqualsWith<A, B, A, Exclude<A, B>>) => Effect<C, E2, R2>): Effect<B | C, E | E2, R | R2>;
 };
 /**
  * Filters an effect, failing with a custom error if the predicate fails.
@@ -15864,211 +15730,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R>;
-    /**
-     * Filters an effect, failing with a custom error if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect fails with a custom error
-     * generated by the `orFailWith` function.
-     *
-     * **When to Use**
-     *
-     * This is useful for enforcing constraints and treating violations as
-     * recoverable errors.
-     *
-     * **Providing a Guard**
-     *
-     * In addition to the filtering capabilities discussed earlier, you have the
-     * option to further refine and narrow down the type of the success channel by
-     * providing a [user-defined type
-     * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-     * Let's explore this concept through an example:
-     *
-     * **Example**
-     *
-     * ```ts
-     * import { Effect, pipe } from "effect"
-     *
-     * // Define a user interface
-     * interface User {
-     *   readonly name: string
-     * }
-     *
-     * // Simulate an asynchronous authentication function
-     * declare const auth: () => Promise<User | null>
-     *
-     * const program = pipe(
-     *   Effect.promise(() => auth()),
-     *   // Use filterOrFail with a custom type guard to ensure user is not null
-     *   Effect.filterOrFail(
-     *     (user): user is User => user !== null, // Type guard
-     *     () => new Error("Unauthorized")
-     *   ),
-     *   // 'user' now has the type `User` (not `User | null`)
-     *   Effect.andThen((user) => user.name)
-     * )
-     * ```
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R>;
-    /**
-     * Filters an effect, failing with a custom error if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect fails with a custom error
-     * generated by the `orFailWith` function.
-     *
-     * **When to Use**
-     *
-     * This is useful for enforcing constraints and treating violations as
-     * recoverable errors.
-     *
-     * **Providing a Guard**
-     *
-     * In addition to the filtering capabilities discussed earlier, you have the
-     * option to further refine and narrow down the type of the success channel by
-     * providing a [user-defined type
-     * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-     * Let's explore this concept through an example:
-     *
-     * **Example**
-     *
-     * ```ts
-     * import { Effect, pipe } from "effect"
-     *
-     * // Define a user interface
-     * interface User {
-     *   readonly name: string
-     * }
-     *
-     * // Simulate an asynchronous authentication function
-     * declare const auth: () => Promise<User | null>
-     *
-     * const program = pipe(
-     *   Effect.promise(() => auth()),
-     *   // Use filterOrFail with a custom type guard to ensure user is not null
-     *   Effect.filterOrFail(
-     *     (user): user is User => user !== null, // Type guard
-     *     () => new Error("Unauthorized")
-     *   ),
-     *   // 'user' now has the type `User` (not `User | null`)
-     *   Effect.andThen((user) => user.name)
-     * )
-     * ```
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementException | E, R>;
-    /**
-     * Filters an effect, failing with a custom error if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect fails with a custom error
-     * generated by the `orFailWith` function.
-     *
-     * **When to Use**
-     *
-     * This is useful for enforcing constraints and treating violations as
-     * recoverable errors.
-     *
-     * **Providing a Guard**
-     *
-     * In addition to the filtering capabilities discussed earlier, you have the
-     * option to further refine and narrow down the type of the success channel by
-     * providing a [user-defined type
-     * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-     * Let's explore this concept through an example:
-     *
-     * **Example**
-     *
-     * ```ts
-     * import { Effect, pipe } from "effect"
-     *
-     * // Define a user interface
-     * interface User {
-     *   readonly name: string
-     * }
-     *
-     * // Simulate an asynchronous authentication function
-     * declare const auth: () => Promise<User | null>
-     *
-     * const program = pipe(
-     *   Effect.promise(() => auth()),
-     *   // Use filterOrFail with a custom type guard to ensure user is not null
-     *   Effect.filterOrFail(
-     *     (user): user is User => user !== null, // Type guard
-     *     () => new Error("Unauthorized")
-     *   ),
-     *   // 'user' now has the type `User` (not `User | null`)
-     *   Effect.andThen((user) => user.name)
-     * )
-     * ```
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Effect<A, E, R>) => Effect<A, Cause.NoSuchElementException | E, R>;
-    /**
-     * Filters an effect, failing with a custom error if the predicate fails.
-     *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect fails with a custom error
-     * generated by the `orFailWith` function.
-     *
-     * **When to Use**
-     *
-     * This is useful for enforcing constraints and treating violations as
-     * recoverable errors.
-     *
-     * **Providing a Guard**
-     *
-     * In addition to the filtering capabilities discussed earlier, you have the
-     * option to further refine and narrow down the type of the success channel by
-     * providing a [user-defined type
-     * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-     * Let's explore this concept through an example:
-     *
-     * **Example**
-     *
-     * ```ts
-     * import { Effect, pipe } from "effect"
-     *
-     * // Define a user interface
-     * interface User {
-     *   readonly name: string
-     * }
-     *
-     * // Simulate an asynchronous authentication function
-     * declare const auth: () => Promise<User | null>
-     *
-     * const program = pipe(
-     *   Effect.promise(() => auth()),
-     *   // Use filterOrFail with a custom type guard to ensure user is not null
-     *   Effect.filterOrFail(
-     *     (user): user is User => user !== null, // Type guard
-     *     () => new Error("Unauthorized")
-     *   ),
-     *   // 'user' now has the type `User` (not `User | null`)
-     *   Effect.andThen((user) => user.name)
-     * )
-     * ```
-     *
-     * @since 2.0.0
-     * @category Filtering
-     */
-    <A, E, R, B extends A, E2>(self: Effect<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): Effect<B, E | E2, R>;
+    <A, E2, B extends A = A>(predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>, orFailWith: (a: EqualsWith<A, B, NoInfer<A>, Exclude<NoInfer<A>, B>>) => E2): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R>;
     /**
      * Filters an effect, failing with a custom error if the predicate fails.
      *
@@ -16119,7 +15781,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, E2>(self: Effect<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Effect<A, E | E2, R>;
+    <A, E, R, E2, B extends A = A>(self: Effect<A, E, R>, predicate: Predicate<A> | Refinement<A, B>, orFailWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => E2): Effect<B, E2 | E, R>;
     /**
      * Filters an effect, failing with a custom error if the predicate fails.
      *
@@ -16170,7 +15832,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>): Effect<B, E | Cause.NoSuchElementException, R>;
+    <A, B extends A = A>(predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementException | E, R>;
     /**
      * Filters an effect, failing with a custom error if the predicate fails.
      *
@@ -16221,7 +15883,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>): Effect<A, E | Cause.NoSuchElementException, R>;
+    <A, E, R, B extends A = A>(self: Effect<A, E, R>, predicate: Predicate<A> | Refinement<A, B>): Effect<B, E | Cause.NoSuchElementException, R>;
 };
 /**
  * Filters an effect with an effectful predicate, falling back to an alternative