effect 4.0.0-beta.27 → 4.0.0-beta.29

package/dist/Effect.d.ts

@@ -40,12 +40,14 @@
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Effect that may fail
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Division by zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(a / b)
  *
  * // Error handling
@@ -111,13 +113,15 @@ declare const TypeId: "~effect/Effect";
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * // A simple effect that succeeds with a value
  * const success = Effect.succeed(42)
  *
- * // An effect that may fail
- * const risky = Effect.fail(new Error("Something went wrong"))
+ * // An effect that will always fail
+ * const risky = Effect.fail(new TaskError({ message: "Something went wrong" }))
  *
  * // Effects can be composed using generator functions
  * const program = Effect.gen(function*() {
@@ -367,13 +371,15 @@ export declare namespace All {
      * @category Models
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class OopsError extends Data.TaggedError("OopsError")<{}> {}
      *
      * // EffectAny represents an Effect with any type parameters
      * const effects: Array<Effect.All.EffectAny> = [
      *   Effect.succeed(42),
      *   Effect.succeed("hello"),
-     *   Effect.fail(new Error("oops"))
+     *   Effect.fail(new OopsError())
      * ]
      * ```
      */
@@ -1352,16 +1358,18 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  *
  * @example Custom Error Handling
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TodoFetchError extends Data.TaggedError("TodoFetchError")<{ readonly cause: unknown }> {}
  *
  * const getTodo = (id: number) =>
  *   Effect.tryPromise({
  *     try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`),
  *     // remap the error
- *     catch: (unknown) => new Error(`something went wrong ${unknown}`)
+ *     catch: (cause) => new TodoFetchError({ cause })
  *   })
  *
- * //      ┌─── Effect<Response, Error, never>
+ * //      ┌─── Effect<Response, TodoFetchError, never>
  * //      ▼
  * const program = getTodo(1)
  * ```
@@ -1737,16 +1745,18 @@ export declare const bind: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * const addServiceCharge = (amount: number) => amount + 1
  *
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -1786,16 +1796,18 @@ export declare const gen: {
      *
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * const addServiceCharge = (amount: number) => amount + 1
      *
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -1839,16 +1851,18 @@ export declare const gen: {
      *
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * const addServiceCharge = (amount: number) => amount + 1
      *
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -1903,12 +1917,14 @@ export declare namespace gen {
  * @example
  * ```ts
  * // Title: Creating a Failed Effect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
  *
- * //      ┌─── Effect<never, Error, never>
+ * class OperationFailedError extends Data.TaggedError("OperationFailedError")<{}> {}
+ *
+ * //      ┌─── Effect<never, OperationFailedError, never>
  * //      ▼
  * const failure = Effect.fail(
- *   new Error("Operation failed due to network error")
+ *   new OperationFailedError()
  * )
  * ```
  *
@@ -1924,9 +1940,11 @@ export declare const fail: <E>(error: E) => Effect<never, E>;
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ProgramError extends Data.TaggedError("ProgramError")<{ readonly failedAt: Date }> {}
  *
- * const program = Effect.failSync(() => new Error("Something went wrong"))
+ * const program = Effect.failSync(() => new ProgramError({ failedAt: new Date() }))
  *
  * Effect.runPromiseExit(program).then(console.log)
  * // Output: { _id: 'Exit', _tag: 'Failure', cause: ... }
@@ -2073,12 +2091,14 @@ export {
  *
  * @example Custom Error Handling
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class JsonParsingError extends Data.TaggedError("JsonParsingError")<{ readonly cause: unknown }> {}
  *
  * const parseJSON = (input: string) =>
  *   Effect.try({
  *     try: () => JSON.parse(input),
- *     catch: (error) => new Error(`JSON parsing failed: ${error}`)
+ *     catch: (cause) => new JsonParsingError({ cause })
  *   })
  *
  * Effect.runPromiseExit(parseJSON("invalid json")).then(console.log)
@@ -2271,15 +2291,17 @@ export declare const fromYieldable: <Self extends Yieldable.Any, A, E, R>(yielda
  *
  * @example
  * ```ts
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2333,15 +2355,17 @@ export declare const flatMap: {
      *
      * @example
      * ```ts
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2395,15 +2419,17 @@ export declare const flatMap: {
      *
      * @example
      * ```ts
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2488,15 +2514,17 @@ export declare const flatten: <A, E, R, E2, R2>(self: Effect<Effect<A, E, R>, E2
  *
  * @example Applying a Discount Based on Fetched Amount
  * ```ts
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2569,15 +2597,17 @@ export declare const andThen: {
      *
      * @example Applying a Discount Based on Fetched Amount
      * ```ts
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2650,15 +2680,17 @@ export declare const andThen: {
      *
      * @example Applying a Discount Based on Fetched Amount
      * ```ts
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2731,15 +2763,17 @@ export declare const andThen: {
      *
      * @example Applying a Discount Based on Fetched Amount
      * ```ts
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2812,15 +2846,17 @@ export declare const andThen: {
      *
      * @example Applying a Discount Based on Fetched Amount
      * ```ts
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
+     *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
      *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2878,16 +2914,18 @@ export declare const andThen: {
  * @example
  * ```ts
  * // Title: Logging a step in a pipeline
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
  * import { Console } from "effect"
  *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+ *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2937,16 +2975,18 @@ export declare const tap: {
      * @example
      * ```ts
      * // Title: Logging a step in a pipeline
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
      * import { Console } from "effect"
      *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+     *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2996,16 +3036,18 @@ export declare const tap: {
      * @example
      * ```ts
      * // Title: Logging a step in a pipeline
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
      * import { Console } from "effect"
      *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+     *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3055,16 +3097,18 @@ export declare const tap: {
      * @example
      * ```ts
      * // Title: Logging a step in a pipeline
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
      * import { Console } from "effect"
      *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+     *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3114,16 +3158,18 @@ export declare const tap: {
      * @example
      * ```ts
      * // Title: Logging a step in a pipeline
-     * import { Effect, pipe } from "effect"
+     * import { Data, Effect, pipe } from "effect"
      * import { Console } from "effect"
      *
+     * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+     *
      * // Function to apply a discount safely to a transaction amount
      * const applyDiscount = (
      *   total: number,
      *   discountRate: number
-     * ): Effect.Effect<number, Error> =>
+     * ): Effect.Effect<number, DiscountRateError> =>
      *   discountRate === 0
-     *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+     *     ? Effect.fail(new DiscountRateError())
      *     : Effect.succeed(total - (total * discountRate) / 100)
      *
      * // Simulated asynchronous task to fetch a transaction amount from database
@@ -5278,17 +5324,19 @@ export declare const catchCauseFilter: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * //      ┌─── Effect<number, string, never>
  * //      ▼
  * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
  *
- * //      ┌─── Effect<number, Error, never>
+ * //      ┌─── Effect<number, TaskError, never>
  * //      ▼
  * const mapped = Effect.mapError(
  *   simulatedTask,
- *   (message) => new Error(message)
+ *   (message) => new TaskError({ message })
  * )
  * ```
  *
@@ -5311,17 +5359,19 @@ export declare const mapError: {
      *
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
      *
      * //      ┌─── Effect<number, string, never>
      * //      ▼
      * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
      *
-     * //      ┌─── Effect<number, Error, never>
+     * //      ┌─── Effect<number, TaskError, never>
      * //      ▼
      * const mapped = Effect.mapError(
      *   simulatedTask,
-     *   (message) => new Error(message)
+     *   (message) => new TaskError({ message })
      * )
      * ```
      *
@@ -5344,17 +5394,19 @@ export declare const mapError: {
      *
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
      *
      * //      ┌─── Effect<number, string, never>
      * //      ▼
      * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
      *
-     * //      ┌─── Effect<number, Error, never>
+     * //      ┌─── Effect<number, TaskError, never>
      * //      ▼
      * const mapped = Effect.mapError(
      *   simulatedTask,
-     *   (message) => new Error(message)
+     *   (message) => new TaskError({ message })
      * )
      * ```
      *
@@ -5375,16 +5427,18 @@ export declare const mapError: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * //      ┌─── Effect<number, string, never>
  * //      ▼
  * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
  *
- * //      ┌─── Effect<boolean, Error, never>
+ * //      ┌─── Effect<boolean, TaskError, never>
  * //      ▼
  * const modified = Effect.mapBoth(simulatedTask, {
- *   onFailure: (message) => new Error(message),
+ *   onFailure: (message) => new TaskError({ message }),
  *   onSuccess: (n) => n > 0
  * })
  * ```
@@ -5408,16 +5462,18 @@ export declare const mapBoth: {
      *
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
      *
      * //      ┌─── Effect<number, string, never>
      * //      ▼
      * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
      *
-     * //      ┌─── Effect<boolean, Error, never>
+     * //      ┌─── Effect<boolean, TaskError, never>
      * //      ▼
      * const modified = Effect.mapBoth(simulatedTask, {
-     *   onFailure: (message) => new Error(message),
+     *   onFailure: (message) => new TaskError({ message }),
      *   onSuccess: (n) => n > 0
      * })
      * ```
@@ -5444,16 +5500,18 @@ export declare const mapBoth: {
      *
      * @example
      * ```ts
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
      *
      * //      ┌─── Effect<number, string, never>
      * //      ▼
      * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
      *
-     * //      ┌─── Effect<boolean, Error, never>
+     * //      ┌─── Effect<boolean, TaskError, never>
      * //      ▼
      * const modified = Effect.mapBoth(simulatedTask, {
-     *   onFailure: (message) => new Error(message),
+     *   onFailure: (message) => new TaskError({ message }),
      *   onSuccess: (n) => n > 0
      * })
      * ```
@@ -5487,11 +5545,13 @@ export declare const mapBoth: {
  * @example
  * ```ts
  * // Title: Propagating an Error as a Defect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DivideByZeroError extends Data.TaggedError("DivideByZeroError")<{}> {}
  *
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Cannot divide by zero"))
+ *     ? Effect.fail(new DivideByZeroError())
  *     : Effect.succeed(a / b)
  *
  * //      ┌─── Effect<number, never, never>
@@ -5500,7 +5560,7 @@ export declare const mapBoth: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // (FiberFailure) Error: Cannot divide by zero
+ * // (FiberFailure) DivideByZeroError
  * //   ...stack trace...
  * ```
  *
@@ -6205,13 +6265,15 @@ export declare namespace Retry {
  *
  * @example
  * ```ts
- * import { Effect, Schedule } from "effect"
+ * import { Data, Effect, Schedule } from "effect"
+ *
+ * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
  *
  * let attempt = 0
- * const task = Effect.callback<string, Error>((resume) => {
+ * const task = Effect.callback<string, AttemptError>((resume) => {
  *   attempt++
  *   if (attempt <= 2) {
- *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+ *     resume(Effect.fail(new AttemptError({ attempt })))
  *   } else {
  *     resume(Effect.succeed("Success!"))
  *   }
@@ -6254,13 +6316,15 @@ export declare const retry: {
      *
      * @example
      * ```ts
-     * import { Effect, Schedule } from "effect"
+     * import { Data, Effect, Schedule } from "effect"
+     *
+     * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
      *
      * let attempt = 0
-     * const task = Effect.callback<string, Error>((resume) => {
+     * const task = Effect.callback<string, AttemptError>((resume) => {
      *   attempt++
      *   if (attempt <= 2) {
-     *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+     *     resume(Effect.fail(new AttemptError({ attempt })))
      *   } else {
      *     resume(Effect.succeed("Success!"))
      *   }
@@ -6303,13 +6367,15 @@ export declare const retry: {
      *
      * @example
      * ```ts
-     * import { Effect, Schedule } from "effect"
+     * import { Data, Effect, Schedule } from "effect"
+     *
+     * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
      *
      * let attempt = 0
-     * const task = Effect.callback<string, Error>((resume) => {
+     * const task = Effect.callback<string, AttemptError>((resume) => {
      *   attempt++
      *   if (attempt <= 2) {
-     *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+     *     resume(Effect.fail(new AttemptError({ attempt })))
      *   } else {
      *     resume(Effect.succeed("Success!"))
      *   }
@@ -6352,13 +6418,15 @@ export declare const retry: {
      *
      * @example
      * ```ts
-     * import { Effect, Schedule } from "effect"
+     * import { Data, Effect, Schedule } from "effect"
+     *
+     * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
      *
      * let attempt = 0
-     * const task = Effect.callback<string, Error>((resume) => {
+     * const task = Effect.callback<string, AttemptError>((resume) => {
      *   attempt++
      *   if (attempt <= 2) {
-     *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+     *     resume(Effect.fail(new AttemptError({ attempt })))
      *   } else {
      *     resume(Effect.succeed("Success!"))
      *   }
@@ -6401,13 +6469,15 @@ export declare const retry: {
      *
      * @example
      * ```ts
-     * import { Effect, Schedule } from "effect"
+     * import { Data, Effect, Schedule } from "effect"
+     *
+     * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
      *
      * let attempt = 0
-     * const task = Effect.callback<string, Error>((resume) => {
+     * const task = Effect.callback<string, AttemptError>((resume) => {
      *   attempt++
      *   if (attempt <= 2) {
-     *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+     *     resume(Effect.fail(new AttemptError({ attempt })))
      *   } else {
      *     resume(Effect.succeed("Success!"))
      *   }
@@ -6450,13 +6520,15 @@ export declare const retry: {
      *
      * @example
      * ```ts
-     * import { Effect, Schedule } from "effect"
+     * import { Data, Effect, Schedule } from "effect"
+     *
+     * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
      *
      * let attempt = 0
-     * const task = Effect.callback<string, Error>((resume) => {
+     * const task = Effect.callback<string, AttemptError>((resume) => {
      *   attempt++
      *   if (attempt <= 2) {
-     *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+     *     resume(Effect.fail(new AttemptError({ attempt })))
      *   } else {
      *     resume(Effect.succeed("Success!"))
      *   }
@@ -6499,13 +6571,15 @@ export declare const retry: {
      *
      * @example
      * ```ts
-     * import { Effect, Schedule } from "effect"
+     * import { Data, Effect, Schedule } from "effect"
+     *
+     * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
      *
      * let attempt = 0
-     * const task = Effect.callback<string, Error>((resume) => {
+     * const task = Effect.callback<string, AttemptError>((resume) => {
      *   attempt++
      *   if (attempt <= 2) {
-     *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+     *     resume(Effect.fail(new AttemptError({ attempt })))
      *   } else {
      *     resume(Effect.succeed("Success!"))
      *   }
@@ -6546,14 +6620,16 @@ export declare const retry: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
  *
  * let attempt = 0
  * const networkRequest = Effect.gen(function*() {
  *   attempt++
  *   yield* Console.log(`Network attempt ${attempt}`)
  *   if (attempt < 3) {
- *     return yield* Effect.fail(new Error("Network timeout"))
+ *     return yield* Effect.fail(new NetworkTimeoutError())
  *   }
  *   return "Network data"
  * })
@@ -6601,14 +6677,16 @@ export declare const retryOrElse: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
      *
      * let attempt = 0
      * const networkRequest = Effect.gen(function*() {
      *   attempt++
      *   yield* Console.log(`Network attempt ${attempt}`)
      *   if (attempt < 3) {
-     *     return yield* Effect.fail(new Error("Network timeout"))
+     *     return yield* Effect.fail(new NetworkTimeoutError())
      *   }
      *   return "Network data"
      * })
@@ -6656,14 +6734,16 @@ export declare const retryOrElse: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
      *
      * let attempt = 0
      * const networkRequest = Effect.gen(function*() {
      *   attempt++
      *   yield* Console.log(`Network attempt ${attempt}`)
      *   if (attempt < 3) {
-     *     return yield* Effect.fail(new Error("Network timeout"))
+     *     return yield* Effect.fail(new NetworkTimeoutError())
      *   }
      *   return "Network data"
      * })
@@ -8673,9 +8753,11 @@ export declare const when: {
  * @example
  * ```ts
  * // Title: Handling Both Success and Failure Cases
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
  *
- * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+ * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
  *
  * const program1 = Effect.match(success, {
  *   onFailure: (error) => `failure: ${error.message}`,
@@ -8686,8 +8768,8 @@ export declare const when: {
  * Effect.runPromise(program1).then(console.log)
  * // Output: "success: 42"
  *
- * const failure: Effect.Effect<number, Error> = Effect.fail(
- *   new Error("Uh oh!")
+ * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+ *   new ExampleError({ message: "Uh oh!" })
  * )
  *
  * const program2 = Effect.match(failure, {
@@ -8725,9 +8807,11 @@ export declare const match: {
      * @example
      * ```ts
      * // Title: Handling Both Success and Failure Cases
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
      *
-     * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+     * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+     *
+     * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
      *
      * const program1 = Effect.match(success, {
      *   onFailure: (error) => `failure: ${error.message}`,
@@ -8738,8 +8822,8 @@ export declare const match: {
      * Effect.runPromise(program1).then(console.log)
      * // Output: "success: 42"
      *
-     * const failure: Effect.Effect<number, Error> = Effect.fail(
-     *   new Error("Uh oh!")
+     * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+     *   new ExampleError({ message: "Uh oh!" })
      * )
      *
      * const program2 = Effect.match(failure, {
@@ -8780,9 +8864,11 @@ export declare const match: {
      * @example
      * ```ts
      * // Title: Handling Both Success and Failure Cases
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
      *
-     * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+     * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
      *
      * const program1 = Effect.match(success, {
      *   onFailure: (error) => `failure: ${error.message}`,
@@ -8793,8 +8879,8 @@ export declare const match: {
      * Effect.runPromise(program1).then(console.log)
      * // Output: "success: 42"
      *
-     * const failure: Effect.Effect<number, Error> = Effect.fail(
-     *   new Error("Uh oh!")
+     * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+     *   new ExampleError({ message: "Uh oh!" })
      * )
      *
      * const program2 = Effect.match(failure, {
@@ -9196,9 +9282,11 @@ export declare const matchCauseEffectEager: {
  *
  * @example
  * ```ts
- * import { Cause, Console, Effect, Result } from "effect"
+ * import { Cause, Console, Data, Effect, Result } from "effect"
  *
- * const task = Effect.fail(new Error("Task failed"))
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+ *
+ * const task = Effect.fail(new TaskError({ message: "Task failed" }))
  *
  * const program = Effect.matchCauseEffect(task, {
  *   onFailure: (cause) =>
@@ -9248,9 +9336,11 @@ export declare const matchCauseEffect: {
      *
      * @example
      * ```ts
-     * import { Cause, Console, Effect, Result } from "effect"
+     * import { Cause, Console, Data, Effect, Result } from "effect"
+     *
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
      *
-     * const task = Effect.fail(new Error("Task failed"))
+     * const task = Effect.fail(new TaskError({ message: "Task failed" }))
      *
      * const program = Effect.matchCauseEffect(task, {
      *   onFailure: (cause) =>
@@ -9303,9 +9393,11 @@ export declare const matchCauseEffect: {
      *
      * @example
      * ```ts
-     * import { Cause, Console, Effect, Result } from "effect"
+     * import { Cause, Console, Data, Effect, Result } from "effect"
      *
-     * const task = Effect.fail(new Error("Task failed"))
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+     *
+     * const task = Effect.fail(new TaskError({ message: "Task failed" }))
      *
      * const program = Effect.matchCauseEffect(task, {
      *   onFailure: (cause) =>
@@ -9365,11 +9457,13 @@ export declare const matchCauseEffect: {
  * @example
  * ```ts
  * // Title: Handling Both Success and Failure Cases with Side Effects
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
  *
- * const success: Effect.Effect<number, Error> = Effect.succeed(42)
- * const failure: Effect.Effect<number, Error> = Effect.fail(
- *   new Error("Uh oh!")
+ * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+ *
+ * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+ * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+ *   new ExampleError({ message: "Uh oh!" })
  * )
  *
  * const program1 = Effect.matchEffect(success, {
@@ -9425,11 +9519,13 @@ export declare const matchEffect: {
      * @example
      * ```ts
      * // Title: Handling Both Success and Failure Cases with Side Effects
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
+     *
+     * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
      *
-     * const success: Effect.Effect<number, Error> = Effect.succeed(42)
-     * const failure: Effect.Effect<number, Error> = Effect.fail(
-     *   new Error("Uh oh!")
+     * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+     * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+     *   new ExampleError({ message: "Uh oh!" })
      * )
      *
      * const program1 = Effect.matchEffect(success, {
@@ -9488,11 +9584,13 @@ export declare const matchEffect: {
      * @example
      * ```ts
      * // Title: Handling Both Success and Failure Cases with Side Effects
-     * import { Effect } from "effect"
+     * import { Data, Effect } from "effect"
      *
-     * const success: Effect.Effect<number, Error> = Effect.succeed(42)
-     * const failure: Effect.Effect<number, Error> = Effect.fail(
-     *   new Error("Uh oh!")
+     * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+     *
+     * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+     * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+     *   new ExampleError({ message: "Uh oh!" })
      * )
      *
      * const program1 = Effect.matchEffect(success, {
@@ -11238,9 +11336,11 @@ export declare const ensuring: {
  *
  * @example
  * ```ts
- * import { Cause, Console, Effect } from "effect"
+ * import { Cause, Data, Console, Effect } from "effect"
  *
- * const task = Effect.fail(new Error("Something went wrong"))
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+ *
+ * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
  *
  * const program = Effect.onError(
  *   task,
@@ -11249,8 +11349,8 @@ export declare const ensuring: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // Cleanup on error: Error: Something went wrong
- * // Error: Something went wrong
+ * // Cleanup on error: TaskError: Something went wrong
+ * // TaskError: Something went wrong
  * ```
  *
  * @since 2.0.0
@@ -11263,9 +11363,11 @@ export declare const onError: {
      *
      * @example
      * ```ts
-     * import { Cause, Console, Effect } from "effect"
+     * import { Cause, Data, Console, Effect } from "effect"
      *
-     * const task = Effect.fail(new Error("Something went wrong"))
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+     *
+     * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
      *
      * const program = Effect.onError(
      *   task,
@@ -11274,8 +11376,8 @@ export declare const onError: {
      *
      * Effect.runPromise(program).catch(console.error)
      * // Output:
-     * // Cleanup on error: Error: Something went wrong
-     * // Error: Something went wrong
+     * // Cleanup on error: TaskError: Something went wrong
+     * // TaskError: Something went wrong
      * ```
      *
      * @since 2.0.0
@@ -11288,9 +11390,11 @@ export declare const onError: {
      *
      * @example
      * ```ts
-     * import { Cause, Console, Effect } from "effect"
+     * import { Cause, Data, Console, Effect } from "effect"
      *
-     * const task = Effect.fail(new Error("Something went wrong"))
+     * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+     *
+     * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
      *
      * const program = Effect.onError(
      *   task,
@@ -11299,8 +11403,8 @@ export declare const onError: {
      *
      * Effect.runPromise(program).catch(console.error)
      * // Output:
-     * // Cleanup on error: Error: Something went wrong
-     * // Error: Something went wrong
+     * // Cleanup on error: TaskError: Something went wrong
+     * // TaskError: Something went wrong
      * ```
      *
      * @since 2.0.0
@@ -14337,7 +14441,7 @@ export declare const withParentSpan: {
  * )
  *
  * const program = Effect.gen(function*() {
- *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+ *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
  *   yield* Console.log(name)
  * })
  * ```
@@ -14368,7 +14472,7 @@ export declare const request: {
      * )
      *
      * const program = Effect.gen(function*() {
-     *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+     *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
      *   yield* Console.log(name)
      * })
      * ```
@@ -14399,7 +14503,7 @@ export declare const request: {
      * )
      *
      * const program = Effect.gen(function*() {
-     *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+     *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
      *   yield* Console.log(name)
      * })
      * ```
@@ -16795,18 +16899,20 @@ export declare const trackSuccesses: {
  *
  * @example
  * ```ts
- * import { Effect, Metric } from "effect"
+ * import { Data, Effect, Metric } from "effect"
+ *
+ * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
  *
  * // Track error types using frequency metric
  * const errorTypeFrequency = Metric.frequency("error_types")
  *
- * const program = Effect.fail(new Error("Connection failed")).pipe(
- *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+ * const program = Effect.fail(new ConnectionFailedError()).pipe(
+ *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
  * )
  *
  * Effect.runPromiseExit(program).then(() =>
  *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
- *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+ *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
  * )
  * ```
  *
@@ -16841,18 +16947,20 @@ export declare const trackErrors: {
      *
      * @example
      * ```ts
-     * import { Effect, Metric } from "effect"
+     * import { Data, Effect, Metric } from "effect"
+     *
+     * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
      *
      * // Track error types using frequency metric
      * const errorTypeFrequency = Metric.frequency("error_types")
      *
-     * const program = Effect.fail(new Error("Connection failed")).pipe(
-     *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+     * const program = Effect.fail(new ConnectionFailedError()).pipe(
+     *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
      * )
      *
      * Effect.runPromiseExit(program).then(() =>
      *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-     *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+     *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
      * )
      * ```
      *
@@ -16887,18 +16995,20 @@ export declare const trackErrors: {
      *
      * @example
      * ```ts
-     * import { Effect, Metric } from "effect"
+     * import { Data, Effect, Metric } from "effect"
+     *
+     * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
      *
      * // Track error types using frequency metric
      * const errorTypeFrequency = Metric.frequency("error_types")
      *
-     * const program = Effect.fail(new Error("Connection failed")).pipe(
-     *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+     * const program = Effect.fail(new ConnectionFailedError()).pipe(
+     *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
      * )
      *
      * Effect.runPromiseExit(program).then(() =>
      *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-     *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+     *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
      * )
      * ```
      *
@@ -16933,18 +17043,20 @@ export declare const trackErrors: {
      *
      * @example
      * ```ts
-     * import { Effect, Metric } from "effect"
+     * import { Data, Effect, Metric } from "effect"
+     *
+     * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
      *
      * // Track error types using frequency metric
      * const errorTypeFrequency = Metric.frequency("error_types")
      *
-     * const program = Effect.fail(new Error("Connection failed")).pipe(
-     *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+     * const program = Effect.fail(new ConnectionFailedError()).pipe(
+     *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
      * )
      *
      * Effect.runPromiseExit(program).then(() =>
      *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-     *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+     *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
      * )
      * ```
      *
@@ -16979,18 +17091,20 @@ export declare const trackErrors: {
      *
      * @example
      * ```ts
-     * import { Effect, Metric } from "effect"
+     * import { Data, Effect, Metric } from "effect"
+     *
+     * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
      *
      * // Track error types using frequency metric
      * const errorTypeFrequency = Metric.frequency("error_types")
      *
-     * const program = Effect.fail(new Error("Connection failed")).pipe(
-     *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+     * const program = Effect.fail(new ConnectionFailedError()).pipe(
+     *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
      * )
      *
      * Effect.runPromiseExit(program).then(() =>
      *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-     *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+     *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
      * )
      * ```
      *
@@ -18065,18 +18179,20 @@ export declare const satisfiesSuccessType: <A>() => <A2 extends A, E, R>(effect:
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ValidationError extends Data.TaggedError("ValidationError")<{}> {}
  *
- * // Define a constraint that the error type must be an Error
- * const satisfiesError = Effect.satisfiesErrorType<Error>()
+ * // Define a constraint that the error type must be a ValidationError
+ * const satisfiesError = Effect.satisfiesErrorType<ValidationError>()
  *
- * // This works - Effect<number, TypeError, never> extends Effect<number, Error, never>
- * const validEffect = satisfiesError(Effect.fail(new TypeError("Invalid type")))
+ * // This works - Effect<number, ValidationError, never> extends the constrained type
+ * const validEffect = satisfiesError(Effect.fail(new ValidationError()))
  *
  * // This would cause a TypeScript compilation error:
  * // const invalidEffect = satisfiesError(Effect.fail("string error"))
  * //                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
- * // Type 'string' is not assignable to type 'Error'
+ * // Type 'string' is not assignable to type 'ValidationError'
  * ```
  *
  * @since 4.0.0