effect 3.13.0 → 3.13.2

package/src/Schema.ts

@@ -2549,17 +2549,12 @@ export const optionalWith: {
    * @category PropertySignature
    * @since 3.10.0
    */
-  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(
-    options: Options
-  ): (self: S) => optionalWith<S, Options>
+  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(options: Options): (self: S) => optionalWith<S, Options>
   /**
    * @category PropertySignature
    * @since 3.10.0
    */
-  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(
-    self: S,
-    options: Options
-  ): optionalWith<S, Options>
+  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(self: S, options: Options): optionalWith<S, Options>
 } = dual((args) => isSchema(args[0]), (self, options) => {
   return new PropertySignatureWithFromImpl(optionalPropertySignatureAST(self, options), self)
 })
@@ -3133,99 +3128,97 @@ export const pluck: {
     key: K
   ): Schema<A[K], Pick<I, K>, R> => {
     const ps = AST.getPropertyKeyIndexedAccess(AST.typeAST(schema.ast), key)
-    const value = make<
-      /**
-       * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
-       * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
-       *
-       * @example
-       * ```ts
-       * import * as Schema from "effect/Schema"
-       *
-       * // ---------------------------------------------
-       * // use case: pull out a single field from a
-       * // struct through a transformation
-       * // ---------------------------------------------
-       *
-       * const mytable = Schema.Struct({
-       *   column1: Schema.NumberFromString,
-       *   column2: Schema.Number
-       * })
-       *
-       * // const pullOutColumn: S.Schema<number, {
-       * //     readonly column1: string;
-       * // }, never>
-       * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
-       *
-       * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
-       * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
-       * ```
-       *
-       * @category struct transformations
-       * @since 3.10.0
-       */
-      A[K], /**
-       * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
-       * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
-       *
-       * @example
-       * ```ts
-       * import * as Schema from "effect/Schema"
-       *
-       * // ---------------------------------------------
-       * // use case: pull out a single field from a
-       * // struct through a transformation
-       * // ---------------------------------------------
-       *
-       * const mytable = Schema.Struct({
-       *   column1: Schema.NumberFromString,
-       *   column2: Schema.Number
-       * })
-       *
-       * // const pullOutColumn: S.Schema<number, {
-       * //     readonly column1: string;
-       * // }, never>
-       * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
-       *
-       * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
-       * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
-       * ```
-       *
-       * @category struct transformations
-       * @since 3.10.0
-       */
-      A[K], /**
-       * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
-       * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
-       *
-       * @example
-       * ```ts
-       * import * as Schema from "effect/Schema"
-       *
-       * // ---------------------------------------------
-       * // use case: pull out a single field from a
-       * // struct through a transformation
-       * // ---------------------------------------------
-       *
-       * const mytable = Schema.Struct({
-       *   column1: Schema.NumberFromString,
-       *   column2: Schema.Number
-       * })
-       *
-       * // const pullOutColumn: S.Schema<number, {
-       * //     readonly column1: string;
-       * // }, never>
-       * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
-       *
-       * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
-       * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
-       * ```
-       *
-       * @category struct transformations
-       * @since 3.10.0
-       */
-      R
-    >(ps.isOptional ? AST.orUndefined(ps.type) : ps.type)
+    const value = make</**
+     * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
+     * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
+     *
+     * @example
+     * ```ts
+     * import * as Schema from "effect/Schema"
+     *
+     * // ---------------------------------------------
+     * // use case: pull out a single field from a
+     * // struct through a transformation
+     * // ---------------------------------------------
+     *
+     * const mytable = Schema.Struct({
+     *   column1: Schema.NumberFromString,
+     *   column2: Schema.Number
+     * })
+     *
+     * // const pullOutColumn: S.Schema<number, {
+     * //     readonly column1: string;
+     * // }, never>
+     * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
+     *
+     * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
+     * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
+     * ```
+     *
+     * @category struct transformations
+     * @since 3.10.0
+     */
+    A[K], /**
+     * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
+     * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
+     *
+     * @example
+     * ```ts
+     * import * as Schema from "effect/Schema"
+     *
+     * // ---------------------------------------------
+     * // use case: pull out a single field from a
+     * // struct through a transformation
+     * // ---------------------------------------------
+     *
+     * const mytable = Schema.Struct({
+     *   column1: Schema.NumberFromString,
+     *   column2: Schema.Number
+     * })
+     *
+     * // const pullOutColumn: S.Schema<number, {
+     * //     readonly column1: string;
+     * // }, never>
+     * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
+     *
+     * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
+     * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
+     * ```
+     *
+     * @category struct transformations
+     * @since 3.10.0
+     */
+    A[K], /**
+     * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
+     * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
+     *
+     * @example
+     * ```ts
+     * import * as Schema from "effect/Schema"
+     *
+     * // ---------------------------------------------
+     * // use case: pull out a single field from a
+     * // struct through a transformation
+     * // ---------------------------------------------
+     *
+     * const mytable = Schema.Struct({
+     *   column1: Schema.NumberFromString,
+     *   column2: Schema.Number
+     * })
+     *
+     * // const pullOutColumn: S.Schema<number, {
+     * //     readonly column1: string;
+     * // }, never>
+     * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
+     *
+     * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
+     * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
+     * ```
+     *
+     * @category struct transformations
+     * @since 3.10.0
+     */
+    R>(ps.isOptional ? AST.orUndefined(ps.type) : ps.type)
     return transform(
       schema.pipe(pick(key)),
       value,
@@ -3335,10 +3328,7 @@ export const partialWith: {
    * @category combinators
    * @since 3.10.0
    */
-  <A, I, R, const Options extends { readonly exact: true } | undefined>(
-    self: Schema<A, I, R>,
-    options: Options
-  ): SchemaClass<{ [K in keyof A]?: A[K] }, { [K in keyof I]?: I[K] }, R>
+  <A, I, R, const Options extends { readonly exact: true } | undefined>(self: Schema<A, I, R>, options: Options): SchemaClass<{ [K in keyof A]?: A[K] }, { [K in keyof I]?: I[K] }, R>
 } = dual((args) => isSchema(args[0]), <A, I, R>(
   self: Schema<A, I, R>,
   options: { readonly exact: true }
@@ -3720,18 +3710,12 @@ export const compose: {
    * @category combinators
    * @since 3.10.0
    */
-  <C, B, R2>(
-    to: Schema<C, B, R2>,
-    options?: { readonly strict: true }
-  ): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<C, A, R1 | R2>
+  <C, B, R2>(to: Schema<C, B, R2>, options?: { readonly strict: true }): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<C, A, R1 | R2>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <D, C, R2>(
-    to: Schema<D, C, R2>,
-    options: { readonly strict: false }
-  ): <B, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
+  <D, C, R2>(to: Schema<D, C, R2>, options: { readonly strict: false }): <B, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
 
   /**
    * @category combinators
@@ -10617,9 +10601,7 @@ export const deserializeFailure: {
    * @since 3.10.0
    * @category decoding
    */
-  (
-    value: unknown
-  ): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FA, ParseResult.ParseError, R>
+  (value: unknown): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FA, ParseResult.ParseError, R>
   /**
    * @since 3.10.0
    * @category decoding
@@ -10697,10 +10679,7 @@ export const serializeExit: {
    * @since 3.10.0
    * @category encoding
    */
-  <SA, SI, FA, FI, R>(
-    self: WithResult<SA, SI, FA, FI, R>,
-    value: exit_.Exit<SA, FA>
-  ): Effect.Effect<ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
+  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: exit_.Exit<SA, FA>): Effect.Effect<ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
 } = dual(2, <SA, SI, FA, FI, R>(
   self: WithResult<SA, SI, FA, FI, R>,
   value: exit_.Exit<SA, FA>
@@ -10722,10 +10701,7 @@ export const deserializeExit: {
    * @since 3.10.0
    * @category decoding
    */
-  <SA, SI, FA, FI, R>(
-    self: WithResult<SA, SI, FA, FI, R>,
-    value: unknown
-  ): Effect.Effect<exit_.Exit<SA, FA>, ParseResult.ParseError, R>
+  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: unknown): Effect.Effect<exit_.Exit<SA, FA>, ParseResult.ParseError, R>
 } = dual(2, <SA, SI, FA, FI, R>(
   self: WithResult<SA, SI, FA, FI, R>,
   value: unknown

package/src/SchemaAST.ts

@@ -1075,7 +1075,7 @@ export class Enums implements Annotated {
   toString() {
     return Option.getOrElse(
       getExpected(this),
-      () => `<enum ${this.enums.length} value(s): ${this.enums.map((_, value) => JSON.stringify(value)).join(" | ")}>`
+      () => `<enum ${this.enums.length} value(s): ${this.enums.map(([_, value]) => JSON.stringify(value)).join(" | ")}>`
     )
   }
   /**

package/src/Sink.ts

@@ -336,19 +336,14 @@ export const mapInputEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <In0, In, E2, R2>(
-    f: (input: In0) => Effect.Effect<In, E2, R2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
+  <In0, In, E2, R2>(f: (input: In0) => Effect.Effect<In, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
   /**
    * Effectfully transforms this sink's input elements.
    *
    * @since 2.0.0
    * @category mapping
    */
-  <A, In, L, E, R, In0, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    f: (input: In0) => Effect.Effect<In, E2, R2>
-  ): Sink<A, In0, L, E | E2, R | R2>
+  <A, In, L, E, R, In0, E2, R2>(self: Sink<A, In, L, E, R>, f: (input: In0) => Effect.Effect<In, E2, R2>): Sink<A, In0, L, E | E2, R | R2>
 } = internal.mapInputEffect
 
 /**
@@ -364,9 +359,7 @@ export const mapInputChunks: {
    * @since 2.0.0
    * @category mapping
    */
-  <In0, In>(
-    f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>
+  <In0, In>(f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>
   /**
    * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
    *
@@ -394,9 +387,7 @@ export const mapInputChunksEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <In0, In, E2, R2>(
-    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
+  <In0, In, E2, R2>(f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
   /**
    * Effectfully transforms this sink's input chunks. `f` must preserve
    * chunking-invariance.
@@ -648,9 +639,7 @@ export const ensuring: {
    * @since 2.0.0
    * @category finalization
    */
-  <X, R2>(
-    finalizer: Effect.Effect<X, never, R2>
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
+  <X, R2>(finalizer: Effect.Effect<X, never, R2>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
   /**
    * Returns a new sink with an attached finalizer. The finalizer is guaranteed
    * to be executed so long as the sink begins execution (and regardless of
@@ -679,9 +668,7 @@ export const ensuringWith: {
    * @since 2.0.0
    * @category finalization
    */
-  <A, E, X, R2>(
-    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>
-  ): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
+  <A, E, X, R2>(finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
   /**
    * Returns a new sink with an attached finalizer. The finalizer is guaranteed
    * to be executed so long as the sink begins execution (and regardless of
@@ -787,9 +774,7 @@ export const filterInput: {
    * @since 2.0.0
    * @category filtering
    */
-  <In, In1 extends In, In2 extends In1>(
-    f: Refinement<In1, In2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>
+  <In, In1 extends In, In2 extends In1>(f: Refinement<In1, In2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>
   /**
    * Filters the sink's input with the given predicate.
    *
@@ -812,9 +797,7 @@ export const filterInputEffect: {
    * @since 2.0.0
    * @category filtering
    */
-  <In, In1 extends In, E2, R2>(
-    f: (input: In1) => Effect.Effect<boolean, E2, R2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>
+  <In, In1 extends In, E2, R2>(f: (input: In1) => Effect.Effect<boolean, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>
   /**
    * Effectfully filter the input of this sink using the specified predicate.
    *
@@ -840,19 +823,14 @@ export const findEffect: {
    * @since 2.0.0
    * @category elements
    */
-  <A, E2, R2>(
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option.Option<A>, In, L, E2 | E, R2 | R>
+  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option.Option<A>, In, L, E2 | E, R2 | R>
   /**
    * Creates a sink that produces values until one verifies the predicate `f`.
    *
    * @since 2.0.0
    * @category elements
    */
-  <A, In, L extends In, E, R, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): Sink<Option.Option<A>, In, L, E | E2, R | R2>
+  <A, In, L extends In, E, R, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Sink<Option.Option<A>, In, L, E | E2, R | R2>
 } = internal.findEffect as any
 
 /**
@@ -1190,9 +1168,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, A1, In, In1 extends In, L1, E1, R1>(
-    f: (a: A) => Sink<A1, In1, L1, E1, R1>
-  ): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1, In & In1, L1 | L, E1 | E, R1 | R>
+  <A, A1, In, In1 extends In, L1, E1, R1>(f: (a: A) => Sink<A1, In1, L1, E1, R1>): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1, In & In1, L1 | L, E1 | E, R1 | R>
   /**
    * Runs this sink until it yields a result, then uses that result to create
    * another sink from the provided function which will continue to run until it
@@ -1203,10 +1179,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1>(
-    self: Sink<A, In, L, E, R>,
-    f: (a: A) => Sink<A1, In1, L1, E1, R1>
-  ): Sink<A1, In & In1, L | L1, E | E1, R | R1>
+  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1>(self: Sink<A, In, L, E, R>, f: (a: A) => Sink<A1, In1, L1, E1, R1>): Sink<A1, In & In1, L | L1, E | E1, R | R1>
 } = internal.flatMap
 
 /**
@@ -1350,19 +1323,14 @@ export const mapEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, A2, E2, R2>(
-    f: (a: A) => Effect.Effect<A2, E2, R2>
-  ): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (a: A) => Effect.Effect<A2, E2, R2>): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>
   /**
    * Effectfully transforms this sink's result.
    *
    * @since 2.0.0
    * @category mapping
    */
-  <A, In, L, E, R, A2, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    f: (a: A) => Effect.Effect<A2, E2, R2>
-  ): Sink<A2, In, L, E | E2, R | R2>
+  <A, In, L, E, R, A2, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>): Sink<A2, In, L, E | E2, R | R2>
 } = internal.mapEffect
 
 /**
@@ -1440,19 +1408,14 @@ export const orElse: {
    * @since 2.0.0
    * @category error handling
    */
-  <A2, In2, L2, E2, R2>(
-    that: LazyArg<Sink<A2, In2, L2, E2, R2>>
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>
+  <A2, In2, L2, E2, R2>(that: LazyArg<Sink<A2, In2, L2, E2, R2>>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>
   /**
    * Switch to another sink in case of failure
    *
    * @since 2.0.0
    * @category error handling
    */
-  <A, In, L, E, R, A2, In2, L2, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    that: LazyArg<Sink<A2, In2, L2, E2, R2>>
-  ): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>
+  <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: LazyArg<Sink<A2, In2, L2, E2, R2>>): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>
 } = internal.orElse
 
 /**
@@ -1496,9 +1459,7 @@ export const race: {
    * @since 2.0.0
    * @category utils
    */
-  <R1, E1, In1, L1, A1>(
-    that: Sink<A1, In1, L1, E1, R1>
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
+  <R1, E1, In1, L1, A1>(that: Sink<A1, In1, L1, E1, R1>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
   /**
    * Runs both sinks in parallel on the input, , returning the result or the
    * error from the one that finishes first.
@@ -1506,10 +1467,7 @@ export const race: {
    * @since 2.0.0
    * @category utils
    */
-  <A, In, L, E, R, A1, In1, L1, E1, R1>(
-    self: Sink<A, In, L, E, R>,
-    that: Sink<A1, In1, L1, E1, R1>
-  ): Sink<A | A1, In & In1, L | L1, E | E1, R | R1>
+  <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, that: Sink<A1, In1, L1, E1, R1>): Sink<A | A1, In & In1, L | L1, E | E1, R | R1>
 } = internal.race
 
 /**
@@ -1612,10 +1570,7 @@ export const refineOrDieWith: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, E2>(
-    pf: (error: E) => Option.Option<E2>,
-    f: (error: E) => unknown
-  ): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>
+  <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>
   /**
    * @since 2.0.0
    * @category error handling
@@ -1695,10 +1650,7 @@ export const summarized: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, E2, R2, A3>(
-    summary: Effect.Effect<A2, E2, R2>,
-    f: (start: A2, end: A2) => A3
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A3], In, L, E2 | E, R2 | R>
+  <A2, E2, R2, A3>(summary: Effect.Effect<A2, E2, R2>, f: (start: A2, end: A2) => A3): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A3], In, L, E2 | E, R2 | R>
   /**
    * Summarize a sink by running an effect when the sink starts and again when
    * it completes.

package/src/SortedMap.ts

@@ -334,9 +334,7 @@ export const partition: {
    * @since 3.1.0
    * @category filtering
    */
-  <K, V>(
-    predicate: (a: Types.NoInfer<K>) => boolean
-  ): (self: SortedMap<K, V>) => [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>]
+  <K, V>(predicate: (a: Types.NoInfer<K>) => boolean): (self: SortedMap<K, V>) => [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>]
   /**
    * @since 3.1.0
    * @category filtering