effect 3.13.1 → 3.13.3

package/src/Metric.ts

@@ -720,9 +720,7 @@ export const taggedWithLabelsInput: {
    * @since 2.0.0
    * @category utils
    */
-  <In>(
-    f: (input: In) => Iterable<MetricLabel.MetricLabel>
-  ): <Type, Out>(self: Metric<Type, In, Out>) => Metric<Type, In, void>
+  <In>(f: (input: In) => Iterable<MetricLabel.MetricLabel>): <Type, Out>(self: Metric<Type, In, Out>) => Metric<Type, In, void>
   /**
    * Returns a new metric, which is identical in every way to this one, except
    * dynamic tags are added based on the update values. Note that the metric
@@ -811,9 +809,7 @@ export const trackAll: {
    * @since 2.0.0
    * @category aspects
    */
-  <In>(
-    input: In
-  ): <Type, Out>(self: Metric<Type, In, Out>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <In>(input: In): <Type, Out>(self: Metric<Type, In, Out>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the specified constant
    * value every time the aspect is applied to an effect, regardless of whether
@@ -822,10 +818,7 @@ export const trackAll: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    self: Metric<Type, In, Out>,
-    input: In
-  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(self: Metric<Type, In, Out>, input: In): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 } = internal.trackAll
 
 /**
@@ -871,10 +864,7 @@ export const trackDefectWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>,
-    f: (defect: unknown) => In
-  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>, f: (defect: unknown) => In): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the result of applying
    * the specified function to the defect throwables of the effects that the
@@ -907,9 +897,7 @@ export const trackDuration: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, Out>(
-    metric: Metric<Type, Duration.Duration, Out>
-  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, Out>(metric: Metric<Type, Duration.Duration, Out>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the duration that the
    * effect takes to execute. To call this method, the input type of the metric
@@ -918,10 +906,7 @@ export const trackDuration: {
    * @since 2.0.0
    * @category aspects
    */
-  <A, E, R, Type, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric<Type, Duration.Duration, Out>
-  ): Effect.Effect<A, E, R>
+  <A, E, R, Type, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, Duration.Duration, Out>): Effect.Effect<A, E, R>
 } = internal.trackDuration
 
 /**
@@ -941,10 +926,7 @@ export const trackDurationWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>,
-    f: (duration: Duration.Duration) => In
-  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>, f: (duration: Duration.Duration) => In): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the duration that the
    * effect takes to execute. To call this method, you must supply a function
@@ -975,9 +957,7 @@ export const trackError: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>
-  ): <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>): <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the failure value of
    * the effects that it is applied to.
@@ -985,10 +965,7 @@ export const trackError: {
    * @since 2.0.0
    * @category aspects
    */
-  <A, E extends In, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric<Type, In, Out>
-  ): Effect.Effect<A, E, R>
+  <A, E extends In, R, Type, In, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, In, Out>): Effect.Effect<A, E, R>
 } = internal.trackError
 
 /**
@@ -1008,10 +985,7 @@ export const trackErrorWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out, In2>(
-    metric: Metric<Type, In, Out>,
-    f: (error: In2) => In
-  ): <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out, In2>(metric: Metric<Type, In, Out>, f: (error: In2) => In): <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the result of applying
    * the specified function to the error value of the effects that the aspect is
@@ -1042,9 +1016,7 @@ export const trackSuccess: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>
-  ): <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>): <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the success value of
    * the effects that it is applied to.
@@ -1052,10 +1024,7 @@ export const trackSuccess: {
    * @since 2.0.0
    * @category aspects
    */
-  <A extends In, E, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric<Type, In, Out>
-  ): Effect.Effect<A, E, R>
+  <A extends In, E, R, Type, In, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, In, Out>): Effect.Effect<A, E, R>
 } = internal.trackSuccess
 
 /**
@@ -1075,10 +1044,7 @@ export const trackSuccessWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out, In2>(
-    metric: Metric<Type, In, Out>,
-    f: (value: In2) => In
-  ): <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out, In2>(metric: Metric<Type, In, Out>, f: (value: In2) => In): <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the result of applying
    * the specified function to the success value of the effects that the aspect is

package/src/MetricKey.ts

@@ -232,21 +232,14 @@ export const tagged: {
    * @since 2.0.0
    * @category constructors
    */
-  (
-    key: string,
-    value: string
-  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
+  (key: string, value: string): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
   /**
    * Returns a new `MetricKey` with the specified tag appended.
    *
    * @since 2.0.0
    * @category constructors
    */
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey<Type>,
-    key: string,
-    value: string
-  ): MetricKey<Type>
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>, key: string, value: string): MetricKey<Type>
 } = internal.tagged
 
 /**
@@ -262,17 +255,12 @@ export const taggedWithLabels: {
    * @since 2.0.0
    * @category constructors
    */
-  (
-    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
-  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
+  (extraTags: ReadonlyArray<MetricLabel.MetricLabel>): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
   /**
    * Returns a new `MetricKey` with the specified tags appended.
    *
    * @since 2.0.0
    * @category constructors
    */
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey<Type>,
-    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
-  ): MetricKey<Type>
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>, extraTags: ReadonlyArray<MetricLabel.MetricLabel>): MetricKey<Type>
 } = internal.taggedWithLabels

package/src/MetricPolling.ts

@@ -127,9 +127,7 @@ export const retry: {
    * @since 2.0.0
    * @category constructors
    */
-  <X, E, R2>(
-    policy: Schedule.Schedule<X, NoInfer<E>, R2>
-  ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
+  <X, E, R2>(policy: Schedule.Schedule<X, NoInfer<E>, R2>): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
   /**
    * Returns a new polling metric whose poll function will be retried with the
    * specified retry policy.

package/src/Micro.ts

@@ -1370,10 +1370,7 @@ export const andThen: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: A) => X
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: (a: A) => X): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
     : Micro<X, E, R>
   /**
    * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
@@ -1386,10 +1383,7 @@ export const andThen: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
     : Micro<X, E, R>
 } = dual(
   2,
@@ -1445,10 +1439,7 @@ export const tap: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: NoInfer<A>) => X
-  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
     : Micro<A, E, R>
   /**
    * Execute a side effect from the success value of the `Micro` effect.
@@ -1459,10 +1450,7 @@ export const tap: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
     : Micro<A, E, R>
 } = dual(
   2,
@@ -2048,9 +2036,7 @@ export const updateContext: {
    * @experimental
    * @category environment
    */
-  <R2, R>(
-    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
-  ): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
+  <R2, R>(f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
   /**
    * Update the Context with the given mapping function.
    *
@@ -2068,30 +2054,28 @@ export const updateContext: {
     self: Micro<A, E, R>,
     f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): Micro<A, E, R2> =>
-    withMicroFiber<
-      /**
-       * Update the Context with the given mapping function.
-       *
-       * @since 3.11.0
-       * @experimental
-       * @category environment
-       */
-      A, /**
-       * Update the Context with the given mapping function.
-       *
-       * @since 3.11.0
-       * @experimental
-       * @category environment
-       */
-      E, /**
-       * Update the Context with the given mapping function.
-       *
-       * @since 3.11.0
-       * @experimental
-       * @category environment
-       */
-      R2
-    >((fiber) => {
+    withMicroFiber</**
+     * Update the Context with the given mapping function.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category environment
+     */
+    A, /**
+     * Update the Context with the given mapping function.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category environment
+     */
+    E, /**
+     * Update the Context with the given mapping function.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category environment
+     */
+    R2>((fiber) => {
       const prev = fiber.context as Context.Context<R2>
       fiber.context = f(prev)
       return onExit(
@@ -2256,10 +2240,7 @@ export const provideServiceEffect: {
    * @experimental
    * @category environment
    */
-  <I, S, E2, R2>(
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
+  <I, S, E2, R2>(tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
   /**
    * Create a service using the provided `Micro` effect, and add it to the
    * current context.
@@ -2268,11 +2249,7 @@ export const provideServiceEffect: {
    * @experimental
    * @category environment
    */
-  <A, E, R, I, S, E2, R2>(
-    self: Micro<A, E, R>,
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): Micro<A, E | E2, Exclude<R, I> | R2>
+  <A, E, R, I, S, E2, R2>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): Micro<A, E | E2, Exclude<R, I> | R2>
 } = dual(
   3,
   <A, E, R, I, S, E2, R2>(
@@ -2620,10 +2597,7 @@ export const filterOrFail: {
    * @experimental
    * @category filtering & conditionals
    */
-  <A, B extends A, E2>(
-    refinement: Refinement<A, B>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>
+  <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>
   /**
    * Filter the specified effect with the provided function, failing with specified
    * error if the predicate fails.
@@ -2635,10 +2609,7 @@ export const filterOrFail: {
    * @experimental
    * @category filtering & conditionals
    */
-  <A, E2>(
-    predicate: Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>
+  <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>
   /**
    * Filter the specified effect with the provided function, failing with specified
    * error if the predicate fails.
@@ -2688,9 +2659,7 @@ export const when: {
    * @experimental
    * @category filtering & conditionals
    */
-  <E2 = never, R2 = never>(
-    condition: LazyArg<boolean> | Micro<boolean, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E | E2, R | R2>
+  <E2 = never, R2 = never>(condition: LazyArg<boolean> | Micro<boolean, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E | E2, R | R2>
   /**
    * The moral equivalent of `if (p) exp`.
    *
@@ -2698,10 +2667,7 @@ export const when: {
    * @experimental
    * @category filtering & conditionals
    */
-  <A, E, R, E2 = never, R2 = never>(
-    self: Micro<A, E, R>,
-    condition: LazyArg<boolean> | Micro<boolean, E2, R2>
-  ): Micro<Option.Option<A>, E | E2, R | R2>
+  <A, E, R, E2 = never, R2 = never>(self: Micro<A, E, R>, condition: LazyArg<boolean> | Micro<boolean, E2, R2>): Micro<Option.Option<A>, E | E2, R | R2>
 } = dual(
   2,
   <A, E, R, E2 = never, R2 = never>(
@@ -3206,9 +3172,7 @@ export const catchAllCause: {
    * @experimental
    * @category error handling
    */
-  <E, B, E2, R2>(
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
+  <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
   // ----------------------------------------------------------------------------
   // error handling
   // ----------------------------------------------------------------------------
@@ -3399,9 +3363,7 @@ export const tapErrorCause: {
    * @experimental
    * @category error handling
    */
-  <E, B, E2, R2>(
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
+  <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
   /**
    * Perform a side effect using the full `MicroCause` object of the given `Micro`.
    *
@@ -3438,10 +3400,7 @@ export const tapErrorCauseIf: {
    * @experimental
    * @category error handling
    */
-  <E, B, E2, R2, EB extends MicroCause<E>>(
-    refinement: Refinement<MicroCause<E>, EB>,
-    f: (a: EB) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
+  <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
   /**
    * Perform a side effect using if a `MicroCause` object matches the specified
    * predicate.
@@ -3564,10 +3523,7 @@ export const catchIf: {
    * @experimental
    * @category error handling
    */
-  <E, EB extends E, A2, E2, R2>(
-    refinement: Refinement<NoInfer<E>, EB>,
-    f: (e: EB) => Micro<A2, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
+  <E, EB extends E, A2, E2, R2>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Micro<A2, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
   /**
    * Catch any expected errors that match the specified predicate.
    *
@@ -3575,10 +3531,7 @@ export const catchIf: {
    * @experimental
    * @category error handling
    */
-  <E, A2, E2, R2>(
-    predicate: Predicate<NoInfer<E>>,
-    f: (e: NoInfer<E>) => Micro<A2, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
+  <E, A2, E2, R2>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Micro<A2, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
   /**
    * Catch any expected errors that match the specified predicate.
    *
@@ -3632,10 +3585,7 @@ export const catchTag: {
    * @experimental
    * @category error handling
    */
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   /**
    * Recovers from the specified tagged error.
    *
@@ -4521,9 +4471,7 @@ export const onExit: {
    * @experimental
    * @category resources & finalization
    */
-  <A, E, XE, XR>(
-    f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
+  <A, E, XE, XR>(f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
   /**
    * When the `Micro` effect is completed, run the given finalizer effect with the
    * `MicroExit` of the executed effect.
@@ -4664,9 +4612,7 @@ export const onError: {
    * @experimental
    * @category resources & finalization
    */
-  <A, E, XE, XR>(
-    f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
+  <A, E, XE, XR>(f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
   /**
    * When the `Micro` effect fails, run the given finalizer effect with the
    * `MicroCause` of the executed effect.
@@ -5240,10 +5186,7 @@ export const bind: {
    * @experimental
    * @category do notation
    */
-  <N extends string, A extends Record<string, any>, B, E2, R2>(
-    name: N,
-    f: (a: NoInfer<A>) => Micro<B, E2, R2>
-  ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
+  <N extends string, A extends Record<string, any>, B, E2, R2>(name: N, f: (a: NoInfer<A>) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
   /**
    * Bind the success value of this `Micro` effect to the provided name.
    *
@@ -5251,11 +5194,7 @@ export const bind: {
    * @experimental
    * @category do notation
    */
-  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(
-    self: Micro<A, E, R>,
-    name: N,
-    f: (a: NoInfer<A>) => Micro<B, E2, R2>
-  ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
+  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(self: Micro<A, E, R>, name: N, f: (a: NoInfer<A>) => Micro<B, E2, R2>): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
 } = doNotation.bind<MicroTypeLambda>(map, flatMap)
 
 const let_: {

package/src/MutableHashMap.ts

@@ -376,10 +376,7 @@ export const modifyAt: {
    *
    * @since 2.0.0
    */
-  <K, V>(
-    key: K,
-    f: (value: Option.Option<V>) => Option.Option<V>
-  ) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
   /**
    * Set or remove the specified key in the `MutableHashMap` using the specified
    * update function.

package/src/Option.ts

@@ -2867,21 +2867,9 @@ export const partitionMap: {
   return either.isLeft(e) ? [some(e.left), none()] : [none(), some(e.right)]
 })
 
+// TODO(4.0): remove?
 /**
- * Maps over the value of an `Option` with a function that may return `None`,
- * effectively filtering and transforming the value.
- *
- * **Details**
- *
- * This function allows you to both transform the value of a `Some` and filter
- * it at the same time. The mapping function `f` can either return a new
- * `Option` (to transform the value) or return `None` to filter it out. If the
- * input `Option` is `None`, the function is not applied, and the result remains
- * `None`.
- *
- * This utility is particularly useful when you want to apply a transformation
- * to the value of an `Option` while conditionally removing invalid or unwanted
- * results.
+ * Alias of {@link flatMap}.
  *
  * @example
  * ```ts
@@ -2905,21 +2893,9 @@ export const partitionMap: {
  * @since 2.0.0
  */
 export const filterMap: {
+  // TODO(4.0): remove?
   /**
-   * Maps over the value of an `Option` with a function that may return `None`,
-   * effectively filtering and transforming the value.
-   *
-   * **Details**
-   *
-   * This function allows you to both transform the value of a `Some` and filter
-   * it at the same time. The mapping function `f` can either return a new
-   * `Option` (to transform the value) or return `None` to filter it out. If the
-   * input `Option` is `None`, the function is not applied, and the result remains
-   * `None`.
-   *
-   * This utility is particularly useful when you want to apply a transformation
-   * to the value of an `Option` while conditionally removing invalid or unwanted
-   * results.
+   * Alias of {@link flatMap}.
    *
    * @example
    * ```ts
@@ -2943,21 +2919,9 @@ export const filterMap: {
    * @since 2.0.0
    */
   <A, B>(f: (a: A) => Option<B>): (self: Option<A>) => Option<B>
+  // TODO(4.0): remove?
   /**
-   * Maps over the value of an `Option` with a function that may return `None`,
-   * effectively filtering and transforming the value.
-   *
-   * **Details**
-   *
-   * This function allows you to both transform the value of a `Some` and filter
-   * it at the same time. The mapping function `f` can either return a new
-   * `Option` (to transform the value) or return `None` to filter it out. If the
-   * input `Option` is `None`, the function is not applied, and the result remains
-   * `None`.
-   *
-   * This utility is particularly useful when you want to apply a transformation
-   * to the value of an `Option` while conditionally removing invalid or unwanted
-   * results.
+   * Alias of {@link flatMap}.
    *
    * @example
    * ```ts
@@ -2981,10 +2945,7 @@ export const filterMap: {
    * @since 2.0.0
    */
   <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
-} = dual(
-  2,
-  <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B> => isNone(self) ? none() : f(self.value)
-)
+} = flatMap
 
 /**
  * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`.
@@ -3919,10 +3880,7 @@ export const bind: {
    * @category Do notation
    * @since 2.0.0
    */
-  <N extends string, A extends object, B>(
-    name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Option<B>
-  ): (self: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+  <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Option<B>): (self: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
   /**
    * 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`.
    *

package/src/ParseResult.ts

@@ -318,17 +318,12 @@ export const flatMap: {
    * @category optimisation
    * @since 3.10.0
    */
-  <A, B, E1, R1>(
-    f: (a: A) => Effect.Effect<B, E1, R1>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E1 | E, R1 | R>
+  <A, B, E1, R1>(f: (a: A) => Effect.Effect<B, E1, R1>): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E1 | E, R1 | R>
   /**
    * @category optimisation
    * @since 3.10.0
    */
-  <A, E, R, B, E1, R1>(
-    self: Effect.Effect<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E1, R1>
-  ): Effect.Effect<B, E | E1, R | R1>
+  <A, E, R, B, E1, R1>(self: Effect.Effect<A, E, R>, f: (a: A) => Effect.Effect<B, E1, R1>): Effect.Effect<B, E | E1, R | R1>
 } = dual(2, <A, E, R, B, E1, R1>(
   self: Effect.Effect<A, E, R>,
   f: (a: A) => Effect.Effect<B, E1, R1>
@@ -431,17 +426,12 @@ export const orElse: {
    * @category optimisation
    * @since 3.10.0
    */
-  <E, A2, E2, R2>(
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E2, R2 | R>
+  <E, A2, E2, R2>(f: (e: E) => Effect.Effect<A2, E2, R2>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E2, R2 | R>
   /**
    * @category optimisation
    * @since 3.10.0
    */
-  <A, E, R, A2, E2, R2>(
-    self: Effect.Effect<A, E, R>,
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Effect.Effect<A2 | A, E2, R2 | R>
+  <A, E, R, A2, E2, R2>(self: Effect.Effect<A, E, R>, f: (e: E) => Effect.Effect<A2, E2, R2>): Effect.Effect<A2 | A, E2, R2 | R>
 } = dual(2, <A, E, R, A2, E2, R2>(
   self: Effect.Effect<A, E, R>,
   f: (e: E) => Effect.Effect<A2, E2, R2>
@@ -1901,9 +1891,7 @@ const getMessage = (issue: ParseIssue): Effect.Effect<string | undefined> =>
 const getParseIssueTitleAnnotation = (issue: ParseIssue): string | undefined =>
   getAnnotated(issue).pipe(
     Option.flatMap(AST.getParseIssueTitleAnnotation),
-    Option.filterMap(
-      (annotation) => Option.fromNullable(annotation(issue))
-    ),
+    Option.flatMapNullable((annotation) => annotation(issue)),
     Option.getOrUndefined
   )