effect 3.13.1 → 3.13.3

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

package/src/Logger.ts

@@ -140,17 +140,12 @@ export const mapInput: {
    * @since 2.0.0
    * @category mapping
    */
-  <Message, Message2>(
-    f: (message: Message2) => Message
-  ): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
+  <Message, Message2>(f: (message: Message2) => Message): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
   /**
    * @since 2.0.0
    * @category mapping
    */
-  <Output, Message, Message2>(
-    self: Logger<Message, Output>,
-    f: (message: Message2) => Message
-  ): Logger<Message2, Output>
+  <Output, Message, Message2>(self: Logger<Message, Output>, f: (message: Message2) => Message): Logger<Message2, Output>
 } = internal.mapInput
 
 /**
@@ -162,16 +157,14 @@ export const mapInputOptions: {
    * @since 2.0.0
    * @category mapping
    */
-  <Message, Message2>(
-    f: (options: Logger.Options<Message2>) => Logger.Options<Message>
-  ): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
+  <Message, Message2>(f: (options: Logger.Options<Message2>) => Logger.Options<Message>): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
   /**
    * @since 2.0.0
    * @category mapping
    */
   <Output, Message, Message2>(
-    self: Logger<Message, Output>,
-    f: (options: Logger.Options<Message2>) => Logger.Options<Message>
+   self: Logger<Message, Output>,
+   f: (options: Logger.Options<Message2>) => Logger.Options<Message>
   ): Logger<Message2, Output>
 } = internal.mapInputOptions
 
@@ -190,9 +183,7 @@ export const filterLogLevel: {
    * @since 2.0.0
    * @category filtering
    */
-  (
-    f: (logLevel: LogLevel.LogLevel) => boolean
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Option.Option<Output>>
+  (f: (logLevel: LogLevel.LogLevel) => boolean): <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Option.Option<Output>>
   /**
    * Returns a version of this logger that only logs messages when the log level
    * satisfies the specified predicate.
@@ -200,10 +191,7 @@ export const filterLogLevel: {
    * @since 2.0.0
    * @category filtering
    */
-  <Message, Output>(
-    self: Logger<Message, Output>,
-    f: (logLevel: LogLevel.LogLevel) => boolean
-  ): Logger<Message, Option.Option<Output>>
+  <Message, Output>(self: Logger<Message, Output>, f: (logLevel: LogLevel.LogLevel) => boolean): Logger<Message, Option.Option<Output>>
 } = internal.filterLogLevel
 
 /**
@@ -215,9 +203,7 @@ export const map: {
    * @since 2.0.0
    * @category mapping
    */
-  <Output, Output2>(
-    f: (output: Output) => Output2
-  ): <Message>(self: Logger<Message, Output>) => Logger<Message, Output2>
+  <Output, Output2>(f: (output: Output) => Output2): <Message>(self: Logger<Message, Output>) => Logger<Message, Output2>
   /**
    * @since 2.0.0
    * @category mapping
@@ -295,8 +281,8 @@ export const batched: {
    * @category mapping
    */
   <Output, R>(
-    window: DurationInput,
-    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+   window: DurationInput,
+   f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
   ): <Message>(self: Logger<Message, Output>) => Effect<Logger<Message, void>, never, R | Scope>
   /**
    * Creates a batched logger that groups log messages together and processes them
@@ -333,9 +319,9 @@ export const batched: {
    * @category mapping
    */
   <Message, Output, R>(
-    self: Logger<Message, Output>,
-    window: DurationInput,
-    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+   self: Logger<Message, Output>,
+   window: DurationInput,
+   f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
   ): Effect<Logger<Message, void>, never, Scope | R>
 } = fiberRuntime.batchedLogger
 
@@ -432,17 +418,12 @@ export const replaceScoped: {
    * @since 2.0.0
    * @category context
    */
-  <B, E, R>(
-    that: Effect<Logger<unknown, B>, E, R>
-  ): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>
+  <B, E, R>(that: Effect<Logger<unknown, B>, E, R>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>
   /**
    * @since 2.0.0
    * @category context
    */
-  <A, B, E, R>(
-    self: Logger<unknown, A>,
-    that: Effect<Logger<unknown, B>, E, R>
-  ): Layer.Layer<never, E, Exclude<R, Scope>>
+  <A, B, E, R>(self: Logger<unknown, A>, that: Effect<Logger<unknown, B>, E, R>): Layer.Layer<never, E, Exclude<R, Scope>>
 } = circular.replaceLoggerScoped
 
 /**
@@ -558,9 +539,7 @@ export const zip: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message2, Output2>(
-    that: Logger<Message2, Output2>
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, [Output, Output2]>
+  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, [Output, Output2]>
   /**
    * Combines this logger with the specified logger to produce a new logger that
    * logs to both this logger and that logger.
@@ -568,10 +547,7 @@ export const zip: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message, Output, Message2, Output2>(
-    self: Logger<Message, Output>,
-    that: Logger<Message2, Output2>
-  ): Logger<Message & Message2, [Output, Output2]>
+  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, [Output, Output2]>
 } = internal.zip
 
 /**
@@ -583,17 +559,12 @@ export const zipLeft: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message2, Output2>(
-    that: Logger<Message2, Output2>
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output>
+  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output>
   /**
    * @since 2.0.0
    * @category zipping
    */
-  <Message, Output, Message2, Output2>(
-    self: Logger<Message, Output>,
-    that: Logger<Message2, Output2>
-  ): Logger<Message & Message2, Output>
+  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, Output>
 } = internal.zipLeft
 
 /**
@@ -605,17 +576,12 @@ export const zipRight: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message2, Output2>(
-    that: Logger<Message2, Output2>
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output2>
+  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output2>
   /**
    * @since 2.0.0
    * @category zipping
    */
-  <Message, Output, Message2, Output2>(
-    self: Logger<Message, Output>,
-    that: Logger<Message2, Output2>
-  ): Logger<Message & Message2, Output2>
+  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, Output2>
 } = internal.zipRight
 
 /**

package/src/Mailbox.ts

@@ -275,10 +275,10 @@ export const fromStream: {
    * @category conversions
    */
   (
-    options?: {
-      readonly capacity?: number | undefined
-      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-    }
+   options?: {
+     readonly capacity?: number | undefined
+     readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+   }
   ): <A, E, R>(self: Stream<A, E, R>) => Effect<ReadonlyMailbox<A, E>, never, R | Scope>
   /**
    * Create a `ReadonlyMailbox` from a `Stream`.
@@ -288,10 +288,10 @@ export const fromStream: {
    * @category conversions
    */
   <A, E, R>(
-    self: Stream<A, E, R>,
-    options?: {
-      readonly capacity?: number | undefined
-      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-    }
+   self: Stream<A, E, R>,
+   options?: {
+     readonly capacity?: number | undefined
+     readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+   }
   ): Effect<ReadonlyMailbox<A, E>, never, R | Scope>
 } = internal.fromStream

package/src/MergeDecision.ts

@@ -84,20 +84,20 @@ export const match: {
    * @category folding
    */
   <R, E0, Z0, E, Z, Z2>(
-    options: {
-      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
-    }
+   options: {
+     readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+     readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
+   }
   ): (self: MergeDecision<R, E0, Z0, E, Z>) => Z2
   /**
    * @since 2.0.0
    * @category folding
    */
   <R, E0, Z0, E, Z, Z2>(
-    self: MergeDecision<R, E0, Z0, E, Z>,
-    options: {
-      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
-    }
+   self: MergeDecision<R, E0, Z0, E, Z>,
+   options: {
+     readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+     readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
+   }
   ): Z2
 } = internal.match

package/src/MergeStrategy.ts

@@ -103,10 +103,10 @@ export const match: {
    * @category folding
    */
   <A>(
-    options: {
-      readonly onBackPressure: () => A
-      readonly onBufferSliding: () => A
-    }
+   options: {
+     readonly onBackPressure: () => A
+     readonly onBufferSliding: () => A
+   }
   ): (self: MergeStrategy) => A
   /**
    * Folds an `MergeStrategy` into a value of type `A`.
@@ -115,10 +115,10 @@ export const match: {
    * @category folding
    */
   <A>(
-    self: MergeStrategy,
-    options: {
-      readonly onBackPressure: () => A
-      readonly onBufferSliding: () => A
-    }
+   self: MergeStrategy,
+   options: {
+     readonly onBackPressure: () => A
+     readonly onBufferSliding: () => A
+   }
   ): A
 } = internal.match