effect 3.13.1 → 3.13.3

package/src/STM.ts

@@ -363,19 +363,14 @@ export const catchSome: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, A2, E2, R2>(
-    pf: (error: E) => Option.Option<STM<A2, E2, R2>>
-  ): <A, R>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>
+  <E, A2, E2, R2>(pf: (error: E) => Option.Option<STM<A2, E2, R2>>): <A, R>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>
   /**
    * Recovers from some or all of the error cases.
    *
    * @since 2.0.0
    * @category error handling
    */
-  <A, E, R, A2, E2, R2>(
-    self: STM<A, E, R>,
-    pf: (error: E) => Option.Option<STM<A2, E2, R2>>
-  ): STM<A | A2, E | E2, R | R2>
+  <A, E, R, A2, E2, R2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<STM<A2, E2, R2>>): STM<A | A2, E | E2, R | R2>
 } = stm.catchSome
 
 /**
@@ -391,10 +386,7 @@ export const catchTag: {
    * @since 2.0.0
    * @category error handling
    */
-  <K extends E["_tag"] & string, E extends { _tag: string }, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => STM<A1, E1, R1>
-  ): <A, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+  <K extends E["_tag"] & string, E extends { _tag: string }, A1, E1, R1>(k: K, f: (e: Extract<E, { _tag: K }>) => STM<A1, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   /**
    * Recovers from the specified tagged error.
    *
@@ -799,10 +791,7 @@ export const filterOrDie: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>,
-    defect: LazyArg<unknown>
-  ): <E, R>(self: STM<A, E, R>) => STM<B, E, R>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<B, E, R>
   /**
    * Dies with specified defect if the predicate fails.
    *
@@ -932,31 +921,21 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B extends A, E2>(
-    refinement: Refinement<NoInfer<A>, B>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: STM<A, E, R>) => STM<B, E2 | E, R>
+  <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: STM<A, E, R>) => STM<B, E2 | E, R>
   /**
    * Fails with the specified error if the predicate fails.
    *
    * @since 2.0.0
    * @category filtering
    */
-  <A, E2>(
-    predicate: Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R>
+  <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R>
   /**
    * Fails with the specified error if the predicate fails.
    *
    * @since 2.0.0
    * @category filtering
    */
-  <A, E, R, B extends A, E2>(
-    self: STM<A, E, R>,
-    refinement: Refinement<A, B>,
-    orFailWith: (a: A) => E2
-  ): STM<B, E | E2, R>
+  <A, E, R, B extends A, E2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): STM<B, E | E2, R>
   /**
    * Fails with the specified error if the predicate fails.
    *
@@ -1121,10 +1100,7 @@ export const forEach: {
    * @since 2.0.0
    * @category traversing
    */
-  <A, A2, E, R>(
-    f: (a: A) => STM<A2, E, R>,
-    options: { readonly discard: true }
-  ): (elements: Iterable<A>) => STM<void, E, R>
+  <A, A2, E, R>(f: (a: A) => STM<A2, E, R>, options: { readonly discard: true }): (elements: Iterable<A>) => STM<void, E, R>
   /**
    * Applies the function `f` to each element of the `Iterable<A>` and returns
    * a transactional effect that produces a new `Chunk<A2>`.
@@ -1927,9 +1903,7 @@ export const orElseOptional: {
    * @since 2.0.0
    * @category error handling
    */
-  <A2, E2, R2>(
-    that: LazyArg<STM<A2, Option.Option<E2>, R2>>
-  ): <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<A2 | A, Option.Option<E2 | E>, R2 | R>
+  <A2, E2, R2>(that: LazyArg<STM<A2, Option.Option<E2>, R2>>): <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<A2 | A, Option.Option<E2 | E>, R2 | R>
   /**
    * Returns an effect that will produce the value of this effect, unless it
    * fails with the `None` value, in which case it will produce the value of the
@@ -2011,9 +1985,7 @@ export const partition: {
    * @since 2.0.0
    * @category traversing
    */
-  <A, A2, E, R>(
-    f: (a: A) => STM<A2, E, R>
-  ): (elements: Iterable<A>) => STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>
+  <A, A2, E, R>(f: (a: A) => STM<A2, E, R>): (elements: Iterable<A>) => STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>
   /**
    * Feeds elements of type `A` to a function `f` that returns an effect.
    * Collects all successes and failures in a tupled fashion.
@@ -2021,10 +1993,7 @@ export const partition: {
    * @since 2.0.0
    * @category traversing
    */
-  <A, A2, E, R>(
-    elements: Iterable<A>,
-    f: (a: A) => STM<A2, E, R>
-  ): STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>
+  <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>): STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>
 } = stm.partition
 
 /**
@@ -2120,10 +2089,7 @@ export const provideServiceSTM: {
    * @since 2.0.0
    * @category context
    */
-  <I, S, E1, R1>(
-    tag: Context.Tag<I, S>,
-    stm: STM<NoInfer<S>, E1, R1>
-  ): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, I>>
+  <I, S, E1, R1>(tag: Context.Tag<I, S>, stm: STM<NoInfer<S>, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, I>>
   /**
    * Provides the effect with the single service it requires. If the transactional
    * effect requires more than one service use `provideEnvironment` instead.
@@ -2131,11 +2097,7 @@ export const provideServiceSTM: {
    * @since 2.0.0
    * @category context
    */
-  <A, E, R, I, S, E1, R1>(
-    self: STM<A, E, R>,
-    tag: Context.Tag<I, S>,
-    stm: STM<NoInfer<S>, E1, R1>
-  ): STM<A, E1 | E, R1 | Exclude<R, I>>
+  <A, E, R, I, S, E1, R1>(self: STM<A, E, R>, tag: Context.Tag<I, S>, stm: STM<NoInfer<S>, E1, R1>): STM<A, E1 | E, R1 | Exclude<R, I>>
 } = stm.provideServiceSTM
 
 /**
@@ -2177,10 +2139,7 @@ export const reduceAll: {
    * @since 2.0.0
    * @category constructors
    */
-  <A, E2, R2>(
-    initial: STM<A, E2, R2>,
-    f: (x: A, y: A) => A
-  ): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>
+  <A, E2, R2>(initial: STM<A, E2, R2>, f: (x: A, y: A) => A): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>
   /**
    * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
    *
@@ -2635,10 +2594,7 @@ export const summarized: {
    * @since 2.0.0
    * @category mutations
    */
-  <A2, E2, R2, A3>(
-    summary: STM<A2, E2, R2>,
-    f: (before: A2, after: A2) => A3
-  ): <A, E, R>(self: STM<A, E, R>) => STM<[A3, A], E2 | E, R2 | R>
+  <A2, E2, R2, A3>(summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): <A, E, R>(self: STM<A, E, R>) => STM<[A3, A], E2 | E, R2 | R>
   /**
    * Summarizes a `STM` effect by computing a provided value before and after
    * execution, and then combining the values to produce a summary, together
@@ -3026,10 +2982,7 @@ export const zipWith: {
    * @since 2.0.0
    * @category zipping
    */
-  <A1, E1, R1, A, A2>(
-    that: STM<A1, E1, R1>,
-    f: (a: A, b: A1) => A2
-  ): <E, R>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>
+  <A1, E1, R1, A, A2>(that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): <E, R>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>
   /**
    * Sequentially zips this value with the specified one, combining the values
    * using the specified combiner function.
@@ -3087,10 +3040,7 @@ export const bind: {
    * @category do notation
    * @since 2.0.0
    */
-  <N extends string, K, A, E2, R2>(
-    tag: Exclude<N, keyof K>,
-    f: (_: NoInfer<K>) => STM<A, E2, R2>
-  ): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
+  <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: NoInfer<K>) => STM<A, E2, R2>): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
   /**
    * @category do notation
    * @since 2.0.0

package/src/Schedule.ts

@@ -258,9 +258,7 @@ export const addDelayEffect: {
    * @since 2.0.0
    * @category Timing & Delay
    */
-  <Out, R2>(
-    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, R2>(f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Adds an effectfully computed delay to every interval in a schedule.
    *
@@ -323,9 +321,7 @@ export const andThen: {
    * @since 2.0.0
    * @category Sequential Composition
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2 | Out, In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2 | Out, In & In2, R2 | R>
   /**
    * Runs two schedules sequentially, merging their outputs.
    *
@@ -346,10 +342,7 @@ export const andThen: {
    * @since 2.0.0
    * @category Sequential Composition
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<Out | Out2, In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Out | Out2, In & In2, R | R2>
 } = internal.andThen
 
 /**
@@ -393,9 +386,7 @@ export const andThenEither: {
    * @since 2.0.0
    * @category Sequential Composition
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Either.Either<Out2, Out>, In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Either.Either<Out2, Out>, In & In2, R2 | R>
   /**
    * Runs two schedules sequentially, collecting results in an `Either`.
    *
@@ -416,10 +407,7 @@ export const andThenEither: {
    * @since 2.0.0
    * @category Sequential Composition
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<Either.Either<Out2, Out>, In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Either.Either<Out2, Out>, In & In2, R | R2>
 } = internal.andThenEither
 
 /**
@@ -527,9 +515,7 @@ export const bothInOut: {
    * @since 2.0.0
    * @category Zipping
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>
   // TODO(4.0): rename to `zip`?
   /**
    * Combines two schedules, preserving both their inputs and outputs.
@@ -548,10 +534,7 @@ export const bothInOut: {
    * @since 2.0.0
    * @category Zipping
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<[Out, Out2], readonly [In, In2], R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], readonly [In, In2], R | R2>
 } = internal.bothInOut
 
 /**
@@ -648,9 +631,7 @@ export const checkEffect: {
    * @since 2.0.0
    * @category Recurrence Conditions
    */
-  <In, Out, R2>(
-    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
-  ): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <In, Out, R2>(test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Conditionally filters schedule executions using an effectful function.
    *
@@ -934,9 +915,7 @@ export const mapInputEffect: {
    * @since 2.0.0
    * @category Mapping
    */
-  <In2, In, R2>(
-    f: (in2: In2) => Effect.Effect<In, never, R2>
-  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R2 | R>
+  <In2, In, R2>(f: (in2: In2) => Effect.Effect<In, never, R2>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R2 | R>
   /**
    * Transforms the input type of a schedule using an effectful function.
    *
@@ -955,10 +934,7 @@ export const mapInputEffect: {
    * @since 2.0.0
    * @category Mapping
    */
-  <Out, In, R, In2, R2>(
-    self: Schedule<Out, In, R>,
-    f: (in2: In2) => Effect.Effect<In, never, R2>
-  ): Schedule<Out, In2, R | R2>
+  <Out, In, R, In2, R2>(self: Schedule<Out, In, R>, f: (in2: In2) => Effect.Effect<In, never, R2>): Schedule<Out, In2, R | R2>
 } = internal.mapInputEffect
 
 /**
@@ -990,9 +966,7 @@ export const mapInputContext: {
    * @since 2.0.0
    * @category Mapping
    */
-  <R0, R>(
-    f: (env0: Context.Context<R0>) => Context.Context<R>
-  ): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, R0>
+  <R0, R>(f: (env0: Context.Context<R0>) => Context.Context<R>): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, R0>
   /**
    * Transforms the required context of a schedule.
    *
@@ -1209,9 +1183,7 @@ export const delayed: {
    * @since 2.0.0
    * @category Timing & Delay
    */
-  (
-    f: (duration: Duration.Duration) => Duration.DurationInput
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  (f: (duration: Duration.Duration) => Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
   /**
    * Modifies a schedule by adding a computed delay before each execution.
    *
@@ -1498,9 +1470,7 @@ export const either: {
    * @since 2.0.0
    * @category Alternatives
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
   // TODO(4.0): remove?
   /**
    * Alias of {@link union}.
@@ -1508,10 +1478,7 @@ export const either: {
    * @since 2.0.0
    * @category Alternatives
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<[Out, Out2], In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.either
 
 // TODO(4.0): remove?
@@ -1829,9 +1796,7 @@ export const intersect: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
   /**
    * Combines two schedules, continuing only if both schedules want to continue,
    * using the longer delay.
@@ -1854,10 +1819,7 @@ export const intersect: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<[Out, Out2], In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.intersect
 
 /**
@@ -1994,9 +1956,7 @@ export const jitteredWith: {
    * @since 2.0.0
    * @category Timing & Delay
    */
-  (
-    options: { min?: number | undefined; max?: number | undefined }
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  (options: { min?: number | undefined; max?: number | undefined }): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
   /**
    * Returns a new schedule that randomly adjusts the interval size within a
    * user-defined range.
@@ -2149,9 +2109,7 @@ export const mapEffect: {
    * @since 2.0.0
    * @category Mapping
    */
-  <Out, Out2, R2>(
-    f: (out: Out) => Effect.Effect<Out2, never, R2>
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
+  <Out, Out2, R2>(f: (out: Out) => Effect.Effect<Out2, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
   /**
    * Returns a new schedule that applies an effectful transformation to its
    * output.
@@ -2210,9 +2168,7 @@ export const modifyDelay: {
    * @since 2.0.0
    * @category Timing & Delay
    */
-  <Out>(
-    f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out>(f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
   /**
    * Returns a new schedule that modifies the delay between executions using a
    * custom function.
@@ -2450,10 +2406,7 @@ export const provideService: {
    * @since 2.0.0
    * @category Context
    */
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    service: Types.NoInfer<S>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, Exclude<R, I>>
+  <I, S>(tag: Context.Tag<I, S>, service: Types.NoInfer<S>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, Exclude<R, I>>
   /**
    * Returns a new schedule with a single required service provided, eliminating
    * the need for external dependencies.
@@ -2696,10 +2649,7 @@ export const reduceEffect: {
    * @since 2.0.0
    * @category Reducing
    */
-  <Z, Out, R2>(
-    zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R2 | R>
+  <Z, Out, R2>(zero: Z, f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R2 | R>
   /**
    * Returns a new schedule that effectfully folds over the outputs of this one.
    *
@@ -2873,10 +2823,7 @@ export const run: {
    * @since 2.0.0
    * @category Execution
    */
-  <In>(
-    now: number,
-    input: Iterable<In>
-  ): <Out, R>(self: Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>
+  <In>(now: number, input: Iterable<In>): <Out, R>(self: Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>
   /**
    * Runs a schedule using the provided inputs and collects all outputs.
    *
@@ -2965,9 +2912,7 @@ export const tapInput: {
    * @since 2.0.0
    * @category Tapping
    */
-  <In2, X, R2>(
-    f: (input: In2) => Effect.Effect<X, never, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
+  <In2, X, R2>(f: (input: In2) => Effect.Effect<X, never, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
   /**
    * Returns a new schedule that runs the given effectful function for each input
    * before continuing execution.
@@ -2981,10 +2926,7 @@ export const tapInput: {
    * @since 2.0.0
    * @category Tapping
    */
-  <Out, In, R, In2, X, R2>(
-    self: Schedule<Out, In, R>,
-    f: (input: In2) => Effect.Effect<X, never, R2>
-  ): Schedule<Out, In & In2, R | R2>
+  <Out, In, R, In2, X, R2>(self: Schedule<Out, In, R>, f: (input: In2) => Effect.Effect<X, never, R2>): Schedule<Out, In & In2, R | R2>
 } = internal.tapInput
 
 /**
@@ -3014,9 +2956,7 @@ export const tapOutput: {
    * @since 2.0.0
    * @category Tapping
    */
-  <X, R2, Out>(
-    f: (out: Types.NoInfer<Out>) => Effect.Effect<X, never, R2>
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <X, R2, Out>(f: (out: Types.NoInfer<Out>) => Effect.Effect<X, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Returns a new schedule that runs the given effectful function for each output
    * before continuing execution.
@@ -3030,10 +2970,7 @@ export const tapOutput: {
    * @since 2.0.0
    * @category Tapping
    */
-  <Out, In, R, X, R2>(
-    self: Schedule<Out, In, R>,
-    f: (out: Out) => Effect.Effect<X, never, R2>
-  ): Schedule<Out, In, R | R2>
+  <Out, In, R, X, R2>(self: Schedule<Out, In, R>, f: (out: Out) => Effect.Effect<X, never, R2>): Schedule<Out, In, R | R2>
 } = internal.tapOutput
 
 /**
@@ -3096,9 +3033,7 @@ export const union: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
   /**
    * Combines two schedules, continuing execution as long as at least one of them
    * allows it, using the shorter delay.
@@ -3121,10 +3056,7 @@ export const union: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<[Out, Out2], In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.union
 
 /**
@@ -3294,9 +3226,7 @@ export const untilInputEffect: {
    * @since 2.0.0
    * @category Recurrence Conditions
    */
-  <In, R2>(
-    f: (input: In) => Effect.Effect<boolean, never, R2>
-  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <In, R2>(f: (input: In) => Effect.Effect<boolean, never, R2>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Returns a new schedule that stops execution when the given effectful
    * predicate on the input evaluates to `true`.
@@ -3409,9 +3339,7 @@ export const untilOutputEffect: {
    * @since 2.0.0
    * @category Recurrence Conditions
    */
-  <Out, R2>(
-    f: (out: Out) => Effect.Effect<boolean, never, R2>
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, R2>(f: (out: Out) => Effect.Effect<boolean, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Returns a new schedule that stops execution when the given effectful
    * predicate on the output evaluates to `true`.
@@ -3555,9 +3483,7 @@ export const whileInputEffect: {
    * @since 2.0.0
    * @category Recurrence Conditions
    */
-  <In, R2>(
-    f: (input: In) => Effect.Effect<boolean, never, R2>
-  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <In, R2>(f: (input: In) => Effect.Effect<boolean, never, R2>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Returns a new schedule that continues execution for as long as the given
    * effectful predicate on the input evaluates to `true`.
@@ -3660,9 +3586,7 @@ export const whileOutputEffect: {
    * @since 2.0.0
    * @category Recurrence Conditions
    */
-  <Out, R2>(
-    f: (out: Out) => Effect.Effect<boolean, never, R2>
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, R2>(f: (out: Out) => Effect.Effect<boolean, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
   /**
    * Returns a new schedule that continues execution for as long as the given
    * effectful predicate on the output evaluates to `true`.
@@ -3722,19 +3646,14 @@ export const zipLeft: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
   /**
    * The same as {@link intersect} but ignores the right output.
    *
    * @since 2.0.0
    * @category Composition
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<Out, In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Out, In & In2, R | R2>
 } = internal.zipLeft
 
 /**
@@ -3750,19 +3669,14 @@ export const zipRight: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out2, In2, R2>(
-    that: Schedule<Out2, In2, R2>
-  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In & In2, R2 | R>
+  <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In & In2, R2 | R>
   /**
    * The same as {@link intersect} but ignores the left output.
    *
    * @since 2.0.0
    * @category Composition
    */
-  <Out, In, R, Out2, In2, R2>(
-    self: Schedule<Out, In, R>,
-    that: Schedule<Out2, In2, R2>
-  ): Schedule<Out2, In & In2, R | R2>
+  <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Out2, In & In2, R | R2>
 } = internal.zipRight
 
 /**
@@ -3778,10 +3692,7 @@ export const zipWith: {
    * @since 2.0.0
    * @category Composition
    */
-  <Out2, In2, R2, Out, Out3>(
-    that: Schedule<Out2, In2, R2>,
-    f: (out: Out, out2: Out2) => Out3
-  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out3, In & In2, R2 | R>
+  <Out2, In2, R2, Out, Out3>(that: Schedule<Out2, In2, R2>, f: (out: Out, out2: Out2) => Out3): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out3, In & In2, R2 | R>
   /**
    * Equivalent to {@link intersect} followed by {@link map}.
    *