effect 3.12.12 → 3.13.0

package/src/Effect.ts

@@ -34,12 +34,13 @@ import * as defaultServices from "./internal/defaultServices.js"
 import * as circular from "./internal/effect/circular.js"
 import * as fiberRuntime from "./internal/fiberRuntime.js"
 import * as layer from "./internal/layer.js"
+import * as option_ from "./internal/option.js"
 import * as query from "./internal/query.js"
 import * as runtime_ from "./internal/runtime.js"
 import * as schedule_ from "./internal/schedule.js"
 import * as internalTracer from "./internal/tracer.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"
@@ -16778,6 +16779,263 @@ export const filterOrFail: {
   <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>): Effect<A, E | Cause.NoSuchElementException, R>
 } = effect.filterOrFail
 
+/**
+ * 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 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>
+} = core.filterEffectOrElse
+
+/**
+ * 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 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>
+} = core.filterEffectOrFail
+
 /**
  * Executes an effect only if the condition is `false`.
  *
@@ -22755,7 +23013,7 @@ export const log: (...message: ReadonlyArray<any>) => Effect<void, never, never>
  * @category Logging
  */
 export const logWithLevel = (
-  level: LogLevel,
+  level: LogLevel.LogLevel,
   ...message: ReadonlyArray<any>
 ): Effect<void> => effect.logWithLevel(level)(...message)
 
@@ -23371,7 +23629,7 @@ export 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.
@@ -23406,9 +23664,107 @@ export 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>
 } = core.withUnhandledErrorLogLevel
 
+/**
+ * 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 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>
+} = fiberRuntime.whenLogLevel
+
 /**
  * Converts an effect's failure into a fiber termination, removing the error
  * from the effect's type.
@@ -26651,7 +27007,7 @@ export const withParentSpan: {
  * ```
  *
  * @since 2.0.0
- * @category Optional Wrapping
+ * @category Optional Wrapping & Unwrapping
  */
 export const fromNullable: <A>(value: A) => Effect<NonNullable<A>, Cause.NoSuchElementException> = effect.fromNullable
 
@@ -26706,12 +27062,47 @@ export const fromNullable: <A>(value: A) => Effect<NonNullable<A>, Cause.NoSuchE
  * ```
  *
  * @since 2.0.0
- * @category Optional Wrapping
+ * @category Optional Wrapping & Unwrapping
  */
 export const optionFromOptional: <A, E, R>(
   self: Effect<A, E, R>
 ) => Effect<Option.Option<A>, Exclude<E, Cause.NoSuchElementException>, R> = effect.optionFromOptional
 
+/**
+ * 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 const transposeOption = <A = never, E = never, R = never>(
+  self: Option.Option<Effect<A, E, R>>
+): Effect<Option.Option<A>, E, R> => {
+  return option_.isNone(self) ? succeedNone : map(self.value, option_.some)
+}
+
 /**
  * @since 2.0.0
  * @category Models
@@ -27222,7 +27613,8 @@ export namespace fn {
           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
-        >
+        >,
+        ...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>>(
@@ -27232,9 +27624,10 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B
+      b: (_: A, ...args: Args) => B
     ): (...args: Args) => B
     <
       Eff extends YieldWrap<Effect<any, any, any>>,
@@ -27250,10 +27643,11 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B,
-      c: (_: B) => C
+      b: (_: A, ...args: Args) => B,
+      c: (_: B, ...args: Args) => C
     ): (...args: Args) => C
     <
       Eff extends YieldWrap<Effect<any, any, any>>,
@@ -27270,11 +27664,12 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B,
-      c: (_: B) => C,
-      d: (_: C) => D
+      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>>,
@@ -27292,12 +27687,13 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B,
-      c: (_: B) => C,
-      d: (_: C) => D,
-      e: (_: D) => E
+      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>>,
@@ -27316,13 +27712,14 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B,
-      c: (_: B) => C,
-      d: (_: C) => D,
-      e: (_: D) => E,
-      f: (_: E) => F
+      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>>,
@@ -27342,14 +27739,15 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B,
-      c: (_: B) => C,
-      d: (_: C) => D,
-      e: (_: D) => E,
-      f: (_: E) => F,
-      g: (_: F) => G
+      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>>,
@@ -27370,15 +27768,16 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => A,
-      b: (_: A) => B,
-      c: (_: B) => C,
-      d: (_: C) => D,
-      e: (_: D) => E,
-      f: (_: E) => F,
-      g: (_: F) => G,
-      h: (_: G) => H
+      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>>,
@@ -27400,16 +27799,17 @@ export namespace fn {
           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
-        >
+        >,
+        ...args: Args
       ) => 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
+      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
   }
 
@@ -27423,75 +27823,75 @@ export namespace fn {
     ): (...args: Args) => Eff
     <Eff extends Effect<any, any, any>, A, Args extends Array<any>>(
       body: (...args: Args) => A,
-      a: (_: A) => Eff
+      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) => B,
-      b: (_: B) => Eff
+      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) => B,
-      b: (_: B) => C,
-      c: (_: C) => Eff
+      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) => B,
-      b: (_: B) => C,
-      c: (_: C) => D,
-      d: (_: D) => Eff
+      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) => B,
-      b: (_: B) => C,
-      c: (_: C) => D,
-      d: (_: D) => E,
-      e: (_: E) => Eff
+      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) => B,
-      b: (_: B) => C,
-      c: (_: C) => D,
-      d: (_: D) => E,
-      e: (_: E) => F,
-      f: (_: E) => Eff
+      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) => B,
-      b: (_: B) => C,
-      c: (_: C) => D,
-      d: (_: D) => E,
-      e: (_: E) => F,
-      f: (_: E) => G,
-      g: (_: G) => Eff
+      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) => B,
-      b: (_: B) => C,
-      c: (_: C) => D,
-      d: (_: D) => E,
-      e: (_: E) => F,
-      f: (_: E) => G,
-      g: (_: G) => H,
-      h: (_: H) => Eff
+      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) => 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
+      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
   }
 }
@@ -27655,7 +28055,7 @@ function fnApply(options: {
   if (options.pipeables.length > 0) {
     try {
       for (const x of options.pipeables) {
-        effect = x(effect)
+        effect = x(effect, ...options.args)
       }
     } catch (error) {
       effect = fnError
@@ -27693,18 +28093,4 @@ function fnApply(options: {
  * @since 3.12.0
  * @category Tracing
  */
-export const fnUntraced: fn.Gen = (body: Function, ...pipeables: Array<any>) =>
-  defineLength(
-    body.length,
-    pipeables.length === 0
-      ? function(this: any, ...args: Array<any>) {
-        return core.fromIterator(() => body.apply(this, args))
-      }
-      : function(this: any, ...args: Array<any>) {
-        let effect = core.fromIterator(() => body.apply(this, args))
-        for (const x of pipeables) {
-          effect = x(effect)
-        }
-        return effect
-      }
-  )
+export const fnUntraced: fn.Gen = core.fnUntraced