effect 3.12.11 → 3.13.0

package/dist/dts/Effect.d.ts

@@ -25,7 +25,7 @@ import type * as HashMap from "./HashMap.js";
 import type * as HashSet from "./HashSet.js";
 import type { TypeLambda } from "./HKT.js";
 import type * as Layer from "./Layer.js";
-import type { LogLevel } from "./LogLevel.js";
+import type * as LogLevel from "./LogLevel.js";
 import type * as ManagedRuntime from "./ManagedRuntime.js";
 import type * as Metric from "./Metric.js";
 import type * as MetricLabel from "./MetricLabel.js";
@@ -14196,7 +14196,7 @@ export declare const provideService: {
      * @since 2.0.0
      * @category Context
      */
-    <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    <I, S>(tag: Context.Tag<I, S>, service: NoInfer<S>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>;
     /**
      * Provides an implementation for a service in the context of an effect.
      *
@@ -14249,7 +14249,7 @@ export declare const provideService: {
      * @since 2.0.0
      * @category Context
      */
-    <A, E, R, T extends Context.Tag<any, any>>(self: Effect<A, E, R>, tag: T, service: Context.Tag.Service<T>): Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, I, S>(self: Effect<A, E, R>, tag: Context.Tag<I, S>, service: NoInfer<S>): Effect<A, E, Exclude<R, I>>;
 };
 /**
  * Dynamically provides an implementation for a service using an effect.
@@ -14288,7 +14288,7 @@ export declare const provideServiceEffect: {
      * @since 2.0.0
      * @category Context
      */
-    <T extends Context.Tag<any, any>, E1, R1>(tag: T, effect: Effect<Context.Tag.Service<T>, E1, R1>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <I, S, E1, R1>(tag: Context.Tag<I, S>, effect: Effect<NoInfer<S>, E1, R1>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E1, R1 | Exclude<R, I>>;
     /**
      * Dynamically provides an implementation for a service using an effect.
      *
@@ -14307,7 +14307,7 @@ export declare const provideServiceEffect: {
      * @since 2.0.0
      * @category Context
      */
-    <A, E, R, T extends Context.Tag<any, any>, E1, R1>(self: Effect<A, E, R>, tag: T, effect: Effect<Context.Tag.Service<T>, E1, R1>): Effect<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, I, S, E1, R1>(self: Effect<A, E, R>, tag: Context.Tag<I, S>, effect: Effect<NoInfer<S>, E1, R1>): Effect<A, E | E1, R1 | Exclude<R, I>>;
 };
 /**
  * Creates a function that uses a service from the context to produce a value.
@@ -14435,7 +14435,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Context
      */
-    <T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R | Context.Tag.Identifier<T>>;
+    <I, S>(tag: Context.Tag<I, S>, f: (service: NoInfer<S>) => NoInfer<S>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R | I>;
     /**
      * Updates a service in the context with a new implementation.
      *
@@ -14454,7 +14454,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Context
      */
-    <A, E, R, T extends Context.Tag<any, any>>(self: Effect<A, E, R>, tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): Effect<A, E, R | Context.Tag.Identifier<T>>;
+    <A, E, R, I, S>(self: Effect<A, E, R>, tag: Context.Tag<I, S>, f: (service: NoInfer<S>) => NoInfer<S>): Effect<A, E, R | I>;
 };
 /**
  * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
@@ -15841,6 +15841,251 @@ export declare const filterOrFail: {
      */
     <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>): Effect<A, E | Cause.NoSuchElementException, R>;
 };
+/**
+ * Filters an effect with an effectful predicate, falling back to 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`, the effect falls back to the `orElse`
+ * effect. The `orElse` effect can produce an alternative value or perform
+ * additional computations.
+ *
+ * @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 filterEffectOrElse with an effectful predicate
+ *   Effect.filterEffectOrElse({
+ *     predicate: (user) => Effect.succeed(user !== null),
+ *     orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`))
+ *   }),
+ * )
+ * ```
+ *
+ * @since 3.13.0
+ * @category Filtering
+ */
+export declare const filterEffectOrElse: {
+    /**
+     * Filters an effect with an effectful predicate, falling back to 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`, the effect falls back to the `orElse`
+     * effect. The `orElse` effect can produce an alternative value or perform
+     * additional computations.
+     *
+     * @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 filterEffectOrElse with an effectful predicate
+     *   Effect.filterEffectOrElse({
+     *     predicate: (user) => Effect.succeed(user !== null),
+     *     orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`))
+     *   }),
+     * )
+     * ```
+     *
+     * @since 3.13.0
+     * @category Filtering
+     */
+    <A, E2, R2, A2, E3, R3>(options: {
+        readonly predicate: (a: NoInfer<A>) => Effect<boolean, E2, R2>;
+        readonly orElse: (a: NoInfer<A>) => Effect<A2, E3, R3>;
+    }): <E, R>(self: Effect<A, E, R>) => Effect<A | A2, E | E2 | E3, R | R2 | R3>;
+    /**
+     * Filters an effect with an effectful predicate, falling back to 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`, the effect falls back to the `orElse`
+     * effect. The `orElse` effect can produce an alternative value or perform
+     * additional computations.
+     *
+     * @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 filterEffectOrElse with an effectful predicate
+     *   Effect.filterEffectOrElse({
+     *     predicate: (user) => Effect.succeed(user !== null),
+     *     orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`))
+     *   }),
+     * )
+     * ```
+     *
+     * @since 3.13.0
+     * @category Filtering
+     */
+    <A, E, R, E2, R2, A2, E3, R3>(self: Effect<A, E, R>, options: {
+        readonly predicate: (a: A) => Effect<boolean, E2, R2>;
+        readonly orElse: (a: A) => Effect<A2, E3, R3>;
+    }): Effect<A | A2, E | E2 | E3, R | R2 | R3>;
+};
+/**
+ * Filters an effect with an effectful predicate, 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.
+ *
+ * @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 filterEffectOrFail with an effectful predicate
+ *   Effect.filterEffectOrFail({
+ *     predicate: (user) => Effect.succeed(user !== null),
+ *     orFailWith: () => new Error("Unauthorized")
+ *   }),
+ * )
+ * ```
+ *
+ * @since 3.13.0
+ * @category Filtering
+ */
+export declare const filterEffectOrFail: {
+    /**
+     * Filters an effect with an effectful predicate, 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.
+     *
+     * @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 filterEffectOrFail with an effectful predicate
+     *   Effect.filterEffectOrFail({
+     *     predicate: (user) => Effect.succeed(user !== null),
+     *     orFailWith: () => new Error("Unauthorized")
+     *   }),
+     * )
+     * ```
+     *
+     * @since 3.13.0
+     * @category Filtering
+     */
+    <A, E2, R2, E3>(options: {
+        readonly predicate: (a: NoInfer<A>) => Effect<boolean, E2, R2>;
+        readonly orFailWith: (a: NoInfer<A>) => E3;
+    }): <E, R>(self: Effect<A, E, R>) => Effect<A, E | E2 | E3, R | R2>;
+    /**
+     * Filters an effect with an effectful predicate, 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.
+     *
+     * @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 filterEffectOrFail with an effectful predicate
+     *   Effect.filterEffectOrFail({
+     *     predicate: (user) => Effect.succeed(user !== null),
+     *     orFailWith: () => new Error("Unauthorized")
+     *   }),
+     * )
+     * ```
+     *
+     * @since 3.13.0
+     * @category Filtering
+     */
+    <A, E, R, E2, R2, E3>(self: Effect<A, E, R>, options: {
+        readonly predicate: (a: A) => Effect<boolean, E2, R2>;
+        readonly orFailWith: (a: A) => E3;
+    }): Effect<A, E | E2 | E3, R | R2>;
+};
 /**
  * Executes an effect only if the condition is `false`.
  *
@@ -21625,7 +21870,7 @@ export declare const log: (...message: ReadonlyArray<any>) => Effect<void, never
  * @since 2.0.0
  * @category Logging
  */
-export declare const logWithLevel: (level: LogLevel, ...message: ReadonlyArray<any>) => Effect<void>;
+export declare const logWithLevel: (level: LogLevel.LogLevel, ...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs messages at the TRACE log level.
  *
@@ -22228,7 +22473,7 @@ export declare const withUnhandledErrorLogLevel: {
      * @since 2.0.0
      * @category Logging
      */
-    (level: Option.Option<LogLevel>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    (level: Option.Option<LogLevel.LogLevel>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
     /**
      * Configures whether child fibers will log unhandled errors and at what log
      * level.
@@ -22263,7 +22508,104 @@ export declare const withUnhandledErrorLogLevel: {
      * @since 2.0.0
      * @category Logging
      */
-    <A, E, R>(self: Effect<A, E, R>, level: Option.Option<LogLevel>): Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, level: Option.Option<LogLevel.LogLevel>): Effect<A, E, R>;
+};
+/**
+ * Conditionally executes an effect based on the specified log level and currently enabled log level.
+ *
+ * **Details**
+ *
+ * This function runs the provided effect only if the specified log level is
+ * enabled. If the log level is enabled, the effect is executed and its result
+ * is wrapped in `Some`. If the log level is not enabled, the effect is not
+ * executed and `None` is returned.
+ *
+ * This function is useful for conditionally executing logging-related effects
+ * or other operations that depend on the current log level configuration.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.gen(function* () {
+ *   yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None`
+ *   yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some`
+ * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug));
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=DEBUG fiber=#0 message=message2
+ * ```
+ *
+ * @see {@link FiberRef.minimumLogLevel} to retrieve the current minimum log level.
+ *
+ * @since 3.13.0
+ * @category Logging
+ */
+export declare const whenLogLevel: {
+    /**
+     * Conditionally executes an effect based on the specified log level and currently enabled log level.
+     *
+     * **Details**
+     *
+     * This function runs the provided effect only if the specified log level is
+     * enabled. If the log level is enabled, the effect is executed and its result
+     * is wrapped in `Some`. If the log level is not enabled, the effect is not
+     * executed and `None` is returned.
+     *
+     * This function is useful for conditionally executing logging-related effects
+     * or other operations that depend on the current log level configuration.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Logger, LogLevel } from "effect"
+     *
+     * const program = Effect.gen(function* () {
+     *   yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None`
+     *   yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some`
+     * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug));
+     *
+     * // Effect.runFork(program)
+     * // timestamp=... level=DEBUG fiber=#0 message=message2
+     * ```
+     *
+     * @see {@link FiberRef.minimumLogLevel} to retrieve the current minimum log level.
+     *
+     * @since 3.13.0
+     * @category Logging
+     */
+    (level: LogLevel.LogLevel | LogLevel.Literal): <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, E, R>;
+    /**
+     * Conditionally executes an effect based on the specified log level and currently enabled log level.
+     *
+     * **Details**
+     *
+     * This function runs the provided effect only if the specified log level is
+     * enabled. If the log level is enabled, the effect is executed and its result
+     * is wrapped in `Some`. If the log level is not enabled, the effect is not
+     * executed and `None` is returned.
+     *
+     * This function is useful for conditionally executing logging-related effects
+     * or other operations that depend on the current log level configuration.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Logger, LogLevel } from "effect"
+     *
+     * const program = Effect.gen(function* () {
+     *   yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None`
+     *   yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some`
+     * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug));
+     *
+     * // Effect.runFork(program)
+     * // timestamp=... level=DEBUG fiber=#0 message=message2
+     * ```
+     *
+     * @see {@link FiberRef.minimumLogLevel} to retrieve the current minimum log level.
+     *
+     * @since 3.13.0
+     * @category Logging
+     */
+    <A, E, R>(self: Effect<A, E, R>, level: LogLevel.LogLevel | LogLevel.Literal): Effect<Option.Option<A>, E, R>;
 };
 /**
  * Converts an effect's failure into a fiber termination, removing the error
@@ -25300,7 +25642,7 @@ export declare const withParentSpan: {
  * ```
  *
  * @since 2.0.0
- * @category Optional Wrapping
+ * @category Optional Wrapping & Unwrapping
  */
 export declare const fromNullable: <A>(value: A) => Effect<NonNullable<A>, Cause.NoSuchElementException>;
 /**
@@ -25354,9 +25696,39 @@ export declare const fromNullable: <A>(value: A) => Effect<NonNullable<A>, Cause
  * ```
  *
  * @since 2.0.0
- * @category Optional Wrapping
+ * @category Optional Wrapping & Unwrapping
  */
 export declare const optionFromOptional: <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, Exclude<E, Cause.NoSuchElementException>, R>;
+/**
+ * Converts an `Option` of an `Effect` into an `Effect` of an `Option`.
+ *
+ * **Details**
+ *
+ * This function transforms an `Option<Effect<A, E, R>>` into an
+ * `Effect<Option<A>, E, R>`. If the `Option` is `None`, the resulting `Effect`
+ * will immediately succeed with a `None` value. If the `Option` is `Some`, the
+ * inner `Effect` will be executed, and its result wrapped in a `Some`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ *
+ * //      ┌─── Option<Effect<number, never, never>>
+ * //      ▼
+ * const maybe = Option.some(Effect.succeed(42))
+ *
+ * //      ┌─── Effect<Option<number>, never, never>
+ * //      ▼
+ * const result = Effect.transposeOption(maybe)
+ *
+ * console.log(Effect.runSync(result))
+ * // Output: { _id: 'Option', _tag: 'Some', value: 42 }
+ * ```
+ *
+ * @since 3.13.0
+ * @category Optional Wrapping & Unwrapping
+ */
+export declare const transposeOption: <A = never, E = never, R = never>(self: Option.Option<Effect<A, E, R>>) => Effect<Option.Option<A>, E, R>;
 /**
  * @since 2.0.0
  * @category Models
@@ -25640,47 +26012,47 @@ export declare namespace fn {
             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>) => A): (...args: Args) => A;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A): (...args: Args) => A;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B): (...args: Args) => B;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B): (...args: Args) => B;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C): (...args: Args) => C;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C): (...args: Args) => C;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D): (...args: Args) => D;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C, d: (_: C, ...args: Args) => D): (...args: Args) => D;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E): (...args: Args) => E;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C, d: (_: C, ...args: Args) => D, e: (_: D, ...args: Args) => E): (...args: Args) => E;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F): (...args: Args) => F;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C, d: (_: C, ...args: Args) => D, e: (_: D, ...args: Args) => E, f: (_: E, ...args: Args) => F): (...args: Args) => F;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F, G extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F, g: (_: F) => G): (...args: Args) => G;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C, d: (_: C, ...args: Args) => D, e: (_: D, ...args: Args) => E, f: (_: E, ...args: Args) => F, g: (_: F, ...args: Args) => G): (...args: Args) => G;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F, G, H extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F, g: (_: F) => G, h: (_: G) => H): (...args: Args) => H;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C, d: (_: C, ...args: Args) => D, e: (_: D, ...args: Args) => E, f: (_: E, ...args: Args) => F, g: (_: F, ...args: Args) => G, h: (_: G, ...args: Args) => H): (...args: Args) => H;
         <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F, G, H, I extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: 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>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F, g: (_: F) => G, h: (_: G) => H, i: (_: H) => I): (...args: Args) => I;
+        ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>, ...args: Args) => A, b: (_: A, ...args: Args) => B, c: (_: B, ...args: Args) => C, d: (_: C, ...args: Args) => D, e: (_: D, ...args: Args) => E, f: (_: E, ...args: Args) => F, g: (_: F, ...args: Args) => G, h: (_: G, ...args: Args) => H, i: (_: H, ...args: Args) => I): (...args: Args) => I;
     };
     /**
      * @since 3.11.0
@@ -25688,15 +26060,15 @@ export declare namespace fn {
      */
     type NonGen = {
         <Eff extends Effect<any, any, any>, Args extends Array<any>>(body: (...args: Args) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, B, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, B, C, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, B, C, D, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, B, C, D, E, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => Eff): (...args: Args) => Eff;
-        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => G, g: (_: G) => Eff): (...args: Args) => 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) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => G, g: (_: G) => H, h: (_: H) => Eff): (...args: Args) => 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) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => G, g: (_: G) => H, h: (_: H) => I, i: (_: H) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A, ...args: Args) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A, ...args: Args) => B, b: (_: B, ...args: Args) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A, ...args: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A, ...args: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => D, d: (_: D, ...args: Args) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A, ...args: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => D, d: (_: D, ...args: Args) => E, e: (_: E, ...args: Args) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A, ...args: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => D, d: (_: D, ...args: Args) => E, e: (_: E, ...args: Args) => F, f: (_: F, ...args: Args) => Eff): (...args: Args) => 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: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => D, d: (_: D, ...args: Args) => E, e: (_: E, ...args: Args) => F, f: (_: F, ...args: Args) => G, g: (_: G, ...args: Args) => Eff): (...args: Args) => 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: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => D, d: (_: D, ...args: Args) => E, e: (_: E, ...args: Args) => F, f: (_: F, ...args: Args) => G, g: (_: G, ...args: Args) => H, h: (_: H, ...args: Args) => Eff): (...args: Args) => 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: Args) => B, b: (_: B, ...args: Args) => C, c: (_: C, ...args: Args) => D, d: (_: D, ...args: Args) => E, e: (_: E, ...args: Args) => F, f: (_: F, ...args: Args) => G, g: (_: G, ...args: Args) => H, h: (_: H, ...args: Args) => I, i: (_: H, ...args: Args) => Eff): (...args: Args) => Eff;
     };
 }
 /**