effect 3.16.12 → 3.16.13

package/dist/dts/Array.d.ts

@@ -2926,8 +2926,8 @@ export declare const setNonEmptyLast: {
  * ```ts
  * import { Array } from "effect"
  *
- * const result = Array.rotate(['a', 'b', 'c', 'd'], 2)
- * console.log(result) // ['c', 'd', 'a', 'b']
+ * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2)
+ * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ]
  * ```
  *
  * @since 2.0.0
@@ -2942,8 +2942,8 @@ export declare const rotate: {
      * ```ts
      * import { Array } from "effect"
      *
-     * const result = Array.rotate(['a', 'b', 'c', 'd'], 2)
-     * console.log(result) // ['c', 'd', 'a', 'b']
+     * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2)
+     * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ]
      * ```
      *
      * @since 2.0.0
@@ -2958,8 +2958,8 @@ export declare const rotate: {
      * ```ts
      * import { Array } from "effect"
      *
-     * const result = Array.rotate(['a', 'b', 'c', 'd'], 2)
-     * console.log(result) // ['c', 'd', 'a', 'b']
+     * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2)
+     * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ]
      * ```
      *
      * @since 2.0.0
@@ -2974,8 +2974,8 @@ export declare const rotate: {
      * ```ts
      * import { Array } from "effect"
      *
-     * const result = Array.rotate(['a', 'b', 'c', 'd'], 2)
-     * console.log(result) // ['c', 'd', 'a', 'b']
+     * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2)
+     * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ]
      * ```
      *
      * @since 2.0.0

package/dist/dts/Effect.d.ts

@@ -6712,66 +6712,6 @@ export declare const catchSomeDefect: {
  * @category Error handling
  */
 export declare 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.
@@ -6895,67 +6835,7 @@ export declare const catchTag: {
      */
     <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>(self: Effect<A, E, R>, ...args: [...tags: K, f: (e: Extract<NoInfer<E>, {
+    } ? 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];