effect 3.13.0 → 3.13.2

package/src/Either.ts

@@ -828,10 +828,7 @@ export const filterOrLeft: {
    * @since 2.0.0
    * @category filtering & conditionals
    */
-  <R, L2>(
-    predicate: Predicate<NoInfer<R>>,
-    orLeftWith: (right: NoInfer<R>) => L2
-  ): <L>(self: Either<R, L>) => Either<R, L2 | L>
+  <R, L2>(predicate: Predicate<NoInfer<R>>, orLeftWith: (right: NoInfer<R>) => L2): <L>(self: Either<R, L>) => Either<R, L2 | L>
   /**
    * Filter the right value with the provided function.
    * If the predicate fails, set the left value with the result of the provided function.
@@ -1445,10 +1442,7 @@ export const bind: {
    * @category do notation
    * @since 2.0.0
    */
-  <N extends string, A extends object, B, L2>(
-    name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Either<B, L2>
-  ): <L1>(self: Either<A, L1>) => Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
+  <N extends string, A extends object, B, L2>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Either<B, L2>): <L1>(self: Either<A, L1>) => Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
   /**
    * 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/ExecutionStrategy.ts

@@ -114,11 +114,11 @@ export const match: {
    * @category folding
    */
   <A>(
-    options: {
-      readonly onSequential: LazyArg<A>
-      readonly onParallel: LazyArg<A>
-      readonly onParallelN: (n: number) => A
-    }
+   options: {
+     readonly onSequential: LazyArg<A>
+     readonly onParallel: LazyArg<A>
+     readonly onParallelN: (n: number) => A
+   }
   ): (self: ExecutionStrategy) => A
   /**
    * Folds over the specified `ExecutionStrategy` using the provided case
@@ -128,11 +128,11 @@ export const match: {
    * @category folding
    */
   <A>(
-    self: ExecutionStrategy,
-    options: {
-      readonly onSequential: LazyArg<A>
-      readonly onParallel: LazyArg<A>
-      readonly onParallelN: (n: number) => A
-    }
+   self: ExecutionStrategy,
+   options: {
+     readonly onSequential: LazyArg<A>
+     readonly onParallel: LazyArg<A>
+     readonly onParallelN: (n: number) => A
+   }
   ): A
 } = internal.match

package/src/Exit.ts

@@ -258,9 +258,7 @@ export const flatMapEffect: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, E, A2, E2, R>(
-    f: (a: A) => Effect.Effect<Exit<A2, E>, E2, R>
-  ): (self: Exit<A, E>) => Effect.Effect<Exit<A2, E>, E2, R>
+  <A, E, A2, E2, R>(f: (a: A) => Effect.Effect<Exit<A2, E>, E2, R>): (self: Exit<A, E>) => Effect.Effect<Exit<A2, E>, E2, R>
   /**
    * @since 2.0.0
    * @category sequencing
@@ -387,7 +385,7 @@ export const mapBoth: {
    * @category mapping
    */
   <E, A, E2, A2>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+   options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
   ): (self: Exit<A, E>) => Exit<A2, E2>
   /**
    * Maps over the `Success` and `Failure` cases of the specified exit using the
@@ -397,8 +395,8 @@ export const mapBoth: {
    * @category mapping
    */
   <A, E, E2, A2>(
-    self: Exit<A, E>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+   self: Exit<A, E>,
+   options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
   ): Exit<A2, E2>
 } = core.exitMapBoth
 
@@ -464,15 +462,15 @@ export const match: {
    * @category folding
    */
   <E, A, Z1, Z2>(
-    options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
+   options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
   ): (self: Exit<A, E>) => Z1 | Z2
   /**
    * @since 2.0.0
    * @category folding
    */
   <A, E, Z1, Z2>(
-    self: Exit<A, E>,
-    options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
+   self: Exit<A, E>,
+   options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
   ): Z1 | Z2
 } = core.exitMatch
 
@@ -486,21 +484,21 @@ export const matchEffect: {
    * @category folding
    */
   <E, A2, E2, R, A, A3, E3, R2>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
-      readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
-    }
+   options: {
+     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
+     readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
+   }
   ): (self: Exit<A, E>) => Effect.Effect<A2 | A3, E2 | E3, R | R2>
   /**
    * @since 2.0.0
    * @category folding
    */
   <A, E, A2, E2, R, A3, E3, R2>(
-    self: Exit<A, E>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
-      readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
-    }
+   self: Exit<A, E>,
+   options: {
+     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
+     readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
+   }
   ): Effect.Effect<A2 | A3, E2 | E3, R | R2>
 } = core.exitMatchEffect
 
@@ -695,11 +693,11 @@ export const zipWith: {
    * @category zipping
    */
   <B, E2, A, C, E>(
-    that: Exit<B, E2>,
-    options: {
-      readonly onSuccess: (a: A, b: B) => C
-      readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<any>
-    }
+   that: Exit<B, E2>,
+   options: {
+     readonly onSuccess: (a: A, b: B) => C
+     readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<any>
+   }
   ): (self: Exit<A, E>) => Exit<C, any>
   /**
    * Zips this exit together with that exit using the specified combination
@@ -709,11 +707,11 @@ export const zipWith: {
    * @category zipping
    */
   <A, E, B, E2, C>(
-    self: Exit<A, E>,
-    that: Exit<B, E2>,
-    options: {
-      readonly onSuccess: (a: A, b: B) => C
-      readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<E | E2>
-    }
+   self: Exit<A, E>,
+   that: Exit<B, E2>,
+   options: {
+     readonly onSuccess: (a: A, b: B) => C
+     readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<E | E2>
+   }
   ): Exit<C, E | E2>
 } = core.exitZipWith

package/src/Fiber.ts

@@ -668,10 +668,10 @@ export const match: {
    * @category folding
    */
   <A, E, Z>(
-    options: {
-      readonly onFiber: (fiber: Fiber<A, E>) => Z
-      readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
-    }
+   options: {
+     readonly onFiber: (fiber: Fiber<A, E>) => Z
+     readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
+   }
   ): (self: Fiber<A, E>) => Z
   /**
    * Folds over the `Fiber` or `RuntimeFiber`.
@@ -680,11 +680,11 @@ export const match: {
    * @category folding
    */
   <A, E, Z>(
-    self: Fiber<A, E>,
-    options: {
-      readonly onFiber: (fiber: Fiber<A, E>) => Z
-      readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
-    }
+   self: Fiber<A, E>,
+   options: {
+     readonly onFiber: (fiber: Fiber<A, E>) => Z
+     readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
+   }
   ): Z
 } = internal.match
 

package/src/FiberRefsPatch.ts

@@ -132,8 +132,8 @@ export const patch: {
    * @category destructors
    */
   (
-    self: FiberRefsPatch,
-    fiberId: FiberId.Runtime,
-    oldValue: FiberRefs.FiberRefs
+   self: FiberRefsPatch,
+   fiberId: FiberId.Runtime,
+   oldValue: FiberRefs.FiberRefs
   ): FiberRefs.FiberRefs
 } = internal.patch

package/src/Function.ts

@@ -116,10 +116,7 @@ export const dual: {
    *
    * @since 2.0.0
    */
-  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(
-    arity: Parameters<DataFirst>["length"],
-    body: DataFirst
-  ): DataLast & DataFirst
+  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(arity: Parameters<DataFirst>["length"], body: DataFirst): DataLast & DataFirst
   /**
    * Creates a function that can be used in a data-last (aka `pipe`able) or
    * data-first style.
@@ -163,10 +160,7 @@ export const dual: {
    *
    * @since 2.0.0
    */
-  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(
-    isDataFirst: (args: IArguments) => boolean,
-    body: DataFirst
-  ): DataLast & DataFirst
+  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(isDataFirst: (args: IArguments) => boolean, body: DataFirst): DataLast & DataFirst
 } = function(arity, body) {
   if (typeof arity === "function") {
     return function() {

package/src/GroupBy.ts

@@ -67,8 +67,8 @@ export const evaluate: {
    * @category destructors
    */
   <K, V, E, A, E2, R2>(
-    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
-    options?: { readonly bufferSize?: number | undefined } | undefined
+   f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
+   options?: { readonly bufferSize?: number | undefined } | undefined
   ): <R>(self: GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>
   /**
    * Run the function across all groups, collecting the results in an
@@ -78,9 +78,9 @@ export const evaluate: {
    * @category destructors
    */
   <K, V, E, R, A, E2, R2>(
-    self: GroupBy<K, V, E, R>,
-    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
-    options?: { readonly bufferSize?: number | undefined } | undefined
+   self: GroupBy<K, V, E, R>,
+   f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
+   options?: { readonly bufferSize?: number | undefined } | undefined
   ): Stream.Stream<A, E | E2, R | R2>
 } = internal.evaluate
 

package/src/HashSet.ts

@@ -551,9 +551,7 @@ export const partition: {
    * @since 2.0.0
    * @category partitioning
    */
-  <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>
-  ): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
   /**
    * Partition the values of a `HashSet` using the specified predicate.
    *
@@ -575,10 +573,7 @@ export const partition: {
    * @since 2.0.0
    * @category partitioning
    */
-  <A, B extends A>(
-    self: HashSet<A>,
-    refinement: Refinement<A, B>
-  ): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
   /**
    * Partition the values of a `HashSet` using the specified predicate.
    *

package/src/Iterable.ts

@@ -977,9 +977,7 @@ export const groupBy: {
    * @category grouping
    * @since 2.0.0
    */
-  <A, K extends string | symbol>(
-    f: (a: A) => K
-  ): (self: Iterable<A>) => Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  <A, K extends string | symbol>(f: (a: A) => K): (self: Iterable<A>) => Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
   /**
    * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
    * function on each element, and grouping the results according to values returned
@@ -987,10 +985,7 @@ export const groupBy: {
    * @category grouping
    * @since 2.0.0
    */
-  <A, K extends string | symbol>(
-    self: Iterable<A>,
-    f: (a: A) => K
-  ): Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  <A, K extends string | symbol>(self: Iterable<A>, f: (a: A) => K): Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
 } = dual(2, <A, K extends string | symbol>(
   self: Iterable<A>,
   f: (a: A) => K

package/src/Layer.ts

@@ -262,19 +262,14 @@ export const catchAll: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, RIn2, E2, ROut2>(
-    onError: (error: E) => Layer<ROut2, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
+  <E, RIn2, E2, ROut2>(onError: (error: E) => Layer<ROut2, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
   /**
    * Recovers from all errors.
    *
    * @since 2.0.0
    * @category error handling
    */
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<ROut, E, RIn>,
-    onError: (error: E) => Layer<ROut2, E2, RIn2>
-  ): Layer<ROut & ROut2, E2, RIn | RIn2>
+  <RIn, E, ROut, RIn2, E2, ROut2>(self: Layer<ROut, E, RIn>, onError: (error: E) => Layer<ROut2, E2, RIn2>): Layer<ROut & ROut2, E2, RIn | RIn2>
 } = internal.catchAll
 
 /**
@@ -290,9 +285,7 @@ export const catchAllCause: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, RIn2, E2, ROut2>(
-    onError: (cause: Cause.Cause<E>) => Layer<ROut2, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
+  <E, RIn2, E2, ROut2>(onError: (cause: Cause.Cause<E>) => Layer<ROut2, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
   /**
    * Recovers from all errors.
    *
@@ -445,9 +438,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, A2, E2, R2>(
-    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
-  ): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (context: Context.Context<A>) => Layer<A2, E2, R2>): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
   /**
    * Constructs a layer dynamically based on the output of this layer.
    *
@@ -669,19 +660,14 @@ export const merge: {
    * @since 2.0.0
    * @category zipping
    */
-  <RIn2, E2, ROut2>(
-    that: Layer<ROut2, E2, RIn2>
-  ): <RIn, E1, ROut>(self: Layer<ROut, E1, RIn>) => Layer<ROut2 | ROut, E2 | E1, RIn2 | RIn>
+  <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>): <RIn, E1, ROut>(self: Layer<ROut, E1, RIn>) => Layer<ROut2 | ROut, E2 | E1, RIn2 | RIn>
   /**
    * Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
    *
    * @since 2.0.0
    * @category zipping
    */
-  <RIn, E1, ROut, RIn2, E2, ROut2>(
-    self: Layer<ROut, E1, RIn>,
-    that: Layer<ROut2, E2, RIn2>
-  ): Layer<ROut | ROut2, E1 | E2, RIn | RIn2>
+  <RIn, E1, ROut, RIn2, E2, ROut2>(self: Layer<ROut, E1, RIn>, that: Layer<ROut2, E2, RIn2>): Layer<ROut | ROut2, E1 | E2, RIn | RIn2>
 } = internal.merge
 
 /**
@@ -859,19 +845,14 @@ export const retry: {
    * @since 2.0.0
    * @category retrying
    */
-  <X, E, RIn2>(
-    schedule: Schedule.Schedule<X, NoInfer<E>, RIn2>
-  ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
+  <X, E, RIn2>(schedule: Schedule.Schedule<X, NoInfer<E>, RIn2>): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
   /**
    * Retries constructing this layer according to the specified schedule.
    *
    * @since 2.0.0
    * @category retrying
    */
-  <ROut, E, RIn, X, RIn2>(
-    self: Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<X, E, RIn2>
-  ): Layer<ROut, E, RIn | RIn2>
+  <ROut, E, RIn, X, RIn2>(self: Layer<ROut, E, RIn>, schedule: Schedule.Schedule<X, E, RIn2>): Layer<ROut, E, RIn | RIn2>
 } = internal.retry
 
 /**
@@ -898,19 +879,14 @@ export const scoped: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(
-    tag: Context.Tag<I, S>
-  ): <E, R>(effect: Effect.Effect<Types.NoInfer<S>, E, R>) => Layer<I, E, Exclude<R, Scope.Scope>>
+  <I, S>(tag: Context.Tag<I, S>): <E, R>(effect: Effect.Effect<Types.NoInfer<S>, E, R>) => Layer<I, E, Exclude<R, Scope.Scope>>
   /**
    * Constructs a layer from the specified scoped effect.
    *
    * @since 2.0.0
    * @category constructors
    */
-  <I, S, E, R>(
-    tag: Context.Tag<I, S>,
-    effect: Effect.Effect<Types.NoInfer<S>, E, R>
-  ): Layer<I, E, Exclude<R, Scope.Scope>>
+  <I, S, E, R>(tag: Context.Tag<I, S>, effect: Effect.Effect<Types.NoInfer<S>, E, R>): Layer<I, E, Exclude<R, Scope.Scope>>
 } = internal.scoped
 
 /**
@@ -1028,9 +1004,7 @@ export const tap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <ROut, XR extends ROut, RIn2, E2, X>(
-    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
-  ): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E2 | E, RIn2 | RIn>
+  <ROut, XR extends ROut, RIn2, E2, X>(f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E2 | E, RIn2 | RIn>
   /**
    * Performs the specified effect if this layer succeeds.
    *
@@ -1056,19 +1030,14 @@ export const tapError: {
    * @since 2.0.0
    * @category sequencing
    */
-  <E, XE extends E, RIn2, E2, X>(
-    f: (e: XE) => Effect.Effect<X, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
+  <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect.Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
   /**
    * Performs the specified effect if this layer fails.
    *
    * @since 2.0.0
    * @category sequencing
    */
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
-    self: Layer<ROut, E, RIn>,
-    f: (e: XE) => Effect.Effect<X, E2, RIn2>
-  ): Layer<ROut, E | E2, RIn | RIn2>
+  <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: XE) => Effect.Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | RIn2>
 } = internal.tapError
 
 /**
@@ -1084,9 +1053,7 @@ export const tapErrorCause: {
    * @since 2.0.0
    * @category sequencing
    */
-  <E, XE extends E, RIn2, E2, X>(
-    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
+  <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
   /**
    * Performs the specified effect if this layer fails.
    *
@@ -1125,9 +1092,7 @@ export const toRuntimeWithMemoMap: {
    * @since 2.0.0
    * @category conversions
    */
-  (
-    memoMap: MemoMap
-  ): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
+  (memoMap: MemoMap): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
   /**
    * Converts a layer that requires no services into a scoped runtime, which can
    * be used to execute effects.
@@ -1135,10 +1100,7 @@ export const toRuntimeWithMemoMap: {
    * @since 2.0.0
    * @category conversions
    */
-  <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>,
-    memoMap: MemoMap
-  ): Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap): Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
 } = internal.toRuntimeWithMemoMap
 
 /**
@@ -1158,9 +1120,7 @@ export const provide: {
    * @since 2.0.0
    * @category utils
    */
-  <RIn, E, ROut>(
-    that: Layer<ROut, E, RIn>
-  ): <RIn2, E2, ROut2>(self: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+  <RIn, E, ROut>(that: Layer<ROut, E, RIn>): <RIn2, E2, ROut2>(self: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
   /**
    * Feeds the output services of this builder into the input of the specified
    * builder, resulting in a new builder with the inputs of this builder as
@@ -1185,10 +1145,7 @@ export const provide: {
    * @since 2.0.0
    * @category utils
    */
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    self: Layer<ROut2, E2, RIn2>,
-    that: Layer<ROut, E, RIn>
-  ): Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+  <RIn2, E2, ROut2, RIn, E, ROut>(self: Layer<ROut2, E2, RIn2>, that: Layer<ROut, E, RIn>): Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
   /**
    * Feeds the output services of this builder into the input of the specified
    * builder, resulting in a new builder with the inputs of this builder as
@@ -1222,9 +1179,7 @@ export const provideMerge: {
    * @since 2.0.0
    * @category utils
    */
-  <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>
-  ): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut | ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut | ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
   /**
    * Feeds the output services of this layer into the input of the specified
    * layer, resulting in a new layer with the inputs of this layer, and the
@@ -1233,10 +1188,7 @@ export const provideMerge: {
    * @since 2.0.0
    * @category utils
    */
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    that: Layer<ROut2, E2, RIn2>,
-    self: Layer<ROut, E, RIn>
-  ): Layer<ROut2 | ROut, E2 | E, RIn | Exclude<RIn2, ROut>>
+  <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer<ROut2, E2, RIn2>, self: Layer<ROut, E, RIn>): Layer<ROut2 | ROut, E2 | E, RIn | Exclude<RIn2, ROut>>
 } = internal.provideMerge
 
 /**
@@ -1499,10 +1451,7 @@ export const buildWithMemoMap: {
    * @since 2.0.0
    * @category memo map
    */
-  (
-    memoMap: MemoMap,
-    scope: Scope.Scope
-  ): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>
+  (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>
   /**
    * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
    * the layer construction.
@@ -1510,11 +1459,7 @@ export const buildWithMemoMap: {
    * @since 2.0.0
    * @category memo map
    */
-  <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>,
-    memoMap: MemoMap,
-    scope: Scope.Scope
-  ): Effect.Effect<Context.Context<ROut>, E, RIn>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect.Effect<Context.Context<ROut>, E, RIn>
 } = internal.buildWithMemoMap
 
 /**

package/src/List.ts

@@ -457,16 +457,13 @@ export const prepend: {
    * @since 2.0.0
    */
   <A, B>(self: List<A>, element: B): Cons<A | B>
-} = dual(2, <A, B>(self: List<A>, element: B): Cons<A | B> =>
-  cons<
-    /**
-     * Prepends the specified element to the beginning of the list.
-     *
-     * @category concatenating
-     * @since 2.0.0
-     */
-    A | B
-  >(element, self))
+} = dual(2, <A, B>(self: List<A>, element: B): Cons<A | B> => cons</**
+ * Prepends the specified element to the beginning of the list.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+A | B>(element, self))
 
 /**
  * Prepends the specified prefix list to the beginning of the specified list.
@@ -564,8 +561,28 @@ export const prependAll: {
   } else if (isNil(prefix)) {
     return self
   } else {
-    const result = makeCons<
-      /**
+    const result = makeCons</**
+     * Prepends the specified prefix list to the beginning of the specified list.
+     * If either list is non-empty, the result is also a non-empty list.
+     *
+     * @example
+     * ```ts
+     * import { List } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray),
+     *   ["a", "b", 1, 2]
+     * )
+     * ```
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
+    A | B>(prefix.head, self)
+    let curr = result
+    let that = prefix.tail
+    while (!isNil(that)) {
+      const temp = makeCons</**
        * Prepends the specified prefix list to the beginning of the specified list.
        * If either list is non-empty, the result is also a non-empty list.
        *
@@ -582,31 +599,7 @@ export const prependAll: {
        * @category concatenating
        * @since 2.0.0
        */
-      A | B
-    >(prefix.head, self)
-    let curr = result
-    let that = prefix.tail
-    while (!isNil(that)) {
-      const temp = makeCons<
-        /**
-         * Prepends the specified prefix list to the beginning of the specified list.
-         * If either list is non-empty, the result is also a non-empty list.
-         *
-         * @example
-         * ```ts
-         * import { List } from "effect"
-         *
-         * assert.deepStrictEqual(
-         *   List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray),
-         *   ["a", "b", 1, 2]
-         * )
-         * ```
-         *
-         * @category concatenating
-         * @since 2.0.0
-         */
-        A | B
-      >(that.head, self)
+      A | B>(that.head, self)
       curr.tail = temp
       curr = temp
       that = that.tail
@@ -999,9 +992,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <S extends List<any>, T extends List<any>>(
-    f: (a: List.Infer<S>, i: number) => T
-  ): (self: S) => List.AndNonEmpty<S, T, List.Infer<T>>
+  <S extends List<any>, T extends List<any>>(f: (a: List.Infer<S>, i: number) => T): (self: S) => List.AndNonEmpty<S, T, List.Infer<T>>
   /**
    * Applies a function to each element in a list and returns a new list containing the concatenated mapped elements.
    *
@@ -1173,9 +1164,7 @@ export const partition: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>
-  ): (self: List<A>) => [excluded: List<Exclude<A, B>>, satisfying: List<B>]
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => [excluded: List<Exclude<A, B>>, satisfying: List<B>]
   /**
    * Partition a list into two lists, where the first list contains all elements
    * that did not satisfy the specified predicate, and the second list contains