effect 3.13.0 → 3.13.2

package/src/Record.ts

@@ -147,9 +147,7 @@ export const fromIterableWith: {
    * @category constructors
    * @since 2.0.0
    */
-  <A, K extends string | symbol, B>(
-    f: (a: A) => readonly [K, B]
-  ): (self: Iterable<A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <A, K extends string | symbol, B>(f: (a: A) => readonly [K, B]): (self: Iterable<A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
    * Takes an iterable and a projection function and returns a record.
    * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record.
@@ -172,10 +170,7 @@ export const fromIterableWith: {
    * @category constructors
    * @since 2.0.0
    */
-  <A, K extends string | symbol, B>(
-    self: Iterable<A>,
-    f: (a: A) => readonly [K, B]
-  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <A, K extends string | symbol, B>(self: Iterable<A>, f: (a: A) => readonly [K, B]): Record<ReadonlyRecord.NonLiteralKey<K>, B>
 } = dual(
   2,
   <A, K extends string, B>(
@@ -615,10 +610,7 @@ export const modifyOption: {
    *
    * @since 2.0.0
    */
-  <K extends string | symbol, A, B>(
-    key: NoInfer<K>,
-    f: (a: A) => B
-  ): (self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
+  <K extends string | symbol, A, B>(key: NoInfer<K>, f: (a: A) => B): (self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
   /**
    * Apply a function to the element at the specified key, creating a new record,
    * or return `None` if the key doesn't exist.
@@ -645,11 +637,7 @@ export const modifyOption: {
    *
    * @since 2.0.0
    */
-  <K extends string | symbol, A, B>(
-    self: ReadonlyRecord<K, A>,
-    key: NoInfer<K>,
-    f: (a: A) => B
-  ): Option.Option<Record<K, A | B>>
+  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, f: (a: A) => B): Option.Option<Record<K, A | B>>
 } = dual(
   3,
   <K extends string | symbol, A, B>(
@@ -705,10 +693,7 @@ export const replaceOption: {
    *
    * @since 2.0.0
    */
-  <K extends string | symbol, B>(
-    key: NoInfer<K>,
-    b: B
-  ): <A>(self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
+  <K extends string | symbol, B>(key: NoInfer<K>, b: B): <A>(self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
   /**
    * Replaces a value in the record with the new value passed as parameter.
    *
@@ -841,9 +826,7 @@ export const pop: {
    * @category record
    * @since 2.0.0
    */
-  <K extends string | symbol, X extends K>(
-    key: X
-  ): <A>(self: ReadonlyRecord<K, A>) => Option.Option<[A, Record<Exclude<K, X>, A>]>
+  <K extends string | symbol, X extends K>(key: X): <A>(self: ReadonlyRecord<K, A>) => Option.Option<[A, Record<Exclude<K, X>, A>]>
   /**
    * Retrieves the value of the property with the given `key` from a record and returns an `Option`
    * of a tuple with the value and the record with the removed property.
@@ -863,10 +846,7 @@ export const pop: {
    * @category record
    * @since 2.0.0
    */
-  <K extends string | symbol, A, X extends K>(
-    self: ReadonlyRecord<K, A>,
-    key: X
-  ): Option.Option<[A, Record<Exclude<K, X>, A>]>
+  <K extends string | symbol, A, X extends K>(self: ReadonlyRecord<K, A>, key: X): Option.Option<[A, Record<Exclude<K, X>, A>]>
 } = dual(2, <K extends string | symbol, A, X extends K>(
   self: ReadonlyRecord<K, A>,
   key: X
@@ -1037,9 +1017,7 @@ export const mapEntries: {
    * @category mapping
    * @since 2.0.0
    */
-  <K extends string, A, K2 extends string, B>(
-    f: (a: A, key: K) => readonly [K2, B]
-  ): (self: ReadonlyRecord<K, A>) => Record<K2, B>
+  <K extends string, A, K2 extends string, B>(f: (a: A, key: K) => readonly [K2, B]): (self: ReadonlyRecord<K, A>) => Record<K2, B>
   /**
    * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values.
    *
@@ -1106,9 +1084,7 @@ export const filterMap: {
    *
    * @since 2.0.0
    */
-  <K extends string, A, B>(
-    f: (a: A, key: K) => Option.Option<B>
-  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B>(f: (a: A, key: K) => Option.Option<B>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
    * Transforms a record into a record by applying the function `f` to each key and value in the original record.
    * If the function returns `Some`, the key-value pair is included in the output record.
@@ -1127,10 +1103,7 @@ export const filterMap: {
    *
    * @since 2.0.0
    */
-  <K extends string, A, B>(
-    self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Option.Option<B>
-  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Option.Option<B>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
 } = dual(
   2,
   <K extends string, A, B>(
@@ -1183,9 +1156,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B extends A>(
-    refinement: (a: NoInfer<A>, key: K) => a is B
-  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
    * Selects properties from a record whose values match the given predicate.
    *
@@ -1203,9 +1174,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A>(
-    predicate: (A: NoInfer<A>, key: K) => boolean
-  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, A>
+  <K extends string, A>(predicate: (A: NoInfer<A>, key: K) => boolean): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, A>
   /**
    * Selects properties from a record whose values match the given predicate.
    *
@@ -1223,10 +1192,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B extends A>(
-    self: ReadonlyRecord<K, A>,
-    refinement: (a: A, key: K) => a is B
-  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B extends A>(self: ReadonlyRecord<K, A>, refinement: (a: A, key: K) => a is B): Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
    * Selects properties from a record whose values match the given predicate.
    *
@@ -1244,10 +1210,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A>(
-    self: ReadonlyRecord<K, A>,
-    predicate: (a: A, key: K) => boolean
-  ): Record<ReadonlyRecord.NonLiteralKey<K>, A>
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (a: A, key: K) => boolean): Record<ReadonlyRecord.NonLiteralKey<K>, A>
 } = dual(
   2,
   <K extends string, A>(
@@ -1406,10 +1369,7 @@ export const partitionMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(
-    self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Either<C, B>
-  ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
+  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Either<C, B>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
   <K extends string, A, B, C>(
@@ -1562,10 +1522,7 @@ export const partition: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A>(
-    self: ReadonlyRecord<K, A>,
-    predicate: (a: A, key: K) => boolean
-  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (a: A, key: K) => boolean): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
 } = dual(
   2,
   <K extends string, A>(
@@ -1639,10 +1596,7 @@ export const set: {
    *
    * @since 2.0.0
    */
-  <K extends string | symbol, K1 extends K | ((string | symbol) & {}), B>(
-    key: K1,
-    value: B
-  ): <A>(self: ReadonlyRecord<K, A>) => Record<K | K1, A | B>
+  <K extends string | symbol, K1 extends K | ((string | symbol) & {}), B>(key: K1, value: B): <A>(self: ReadonlyRecord<K, A>) => Record<K | K1, A | B>
   /**
    * Add a new key-value pair or update an existing key's value in a record.
    *
@@ -1660,11 +1614,7 @@ export const set: {
    *
    * @since 2.0.0
    */
-  <K extends string | symbol, A, K1 extends K | ((string | symbol) & {}), B>(
-    self: ReadonlyRecord<K, A>,
-    key: K1,
-    value: B
-  ): Record<K | K1, A | B>
+  <K extends string | symbol, A, K1 extends K | ((string | symbol) & {}), B>(self: ReadonlyRecord<K, A>, key: K1, value: B): Record<K | K1, A | B>
 } = dual(
   3,
   <K extends string | symbol, A, K1 extends K | ((string | symbol) & {}), B>(
@@ -1866,9 +1816,7 @@ export const every: {
    *
    * @since 2.0.0
    */
-  <A, K extends string, B extends A>(
-    refinement: (value: A, key: K) => value is B
-  ): (self: ReadonlyRecord<K, A>) => self is ReadonlyRecord<K, B>
+  <A, K extends string, B extends A>(refinement: (value: A, key: K) => value is B): (self: ReadonlyRecord<K, A>) => self is ReadonlyRecord<K, B>
   /**
    * Check if all entries in a record meet a specific condition.
    *
@@ -1886,10 +1834,7 @@ export const every: {
    *
    * @since 2.0.0
    */
-  <A, K extends string, B extends A>(
-    self: ReadonlyRecord<K, A>,
-    refinement: (value: A, key: K) => value is B
-  ): self is ReadonlyRecord<K, B>
+  <A, K extends string, B extends A>(self: ReadonlyRecord<K, A>, refinement: (value: A, key: K) => value is B): self is ReadonlyRecord<K, B>
   /**
    * Check if all entries in a record meet a specific condition.
    *
@@ -1972,10 +1917,7 @@ export const union: {
    *
    * @since 2.0.0
    */
-  <K1 extends string, A, B, C>(
-    that: ReadonlyRecord<K1, B>,
-    combine: (selfValue: A, thatValue: B) => C
-  ): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B | C>
+  <K1 extends string, A, B, C>(that: ReadonlyRecord<K1, B>, combine: (selfValue: A, thatValue: B) => C): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B | C>
   /**
    * Merge two records, preserving entries that exist in either of the records.
    *
@@ -2039,10 +1981,7 @@ export const intersection: {
    *
    * @since 2.0.0
    */
-  <K1 extends string, A, B, C>(
-    that: ReadonlyRecord<K1, B>,
-    combine: (selfValue: A, thatValue: B) => C
-  ): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<ReadonlyRecord.IntersectKeys<K0, K1>, C>
+  <K1 extends string, A, B, C>(that: ReadonlyRecord<K1, B>, combine: (selfValue: A, thatValue: B) => C): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<ReadonlyRecord.IntersectKeys<K0, K1>, C>
   /**
    * Merge two records, retaining only the entries that exist in both records.
    *
@@ -2094,9 +2033,7 @@ export const difference: {
    *
    * @since 2.0.0
    */
-  <K1 extends string, B>(
-    that: ReadonlyRecord<K1, B>
-  ): <K0 extends string, A>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B>
+  <K1 extends string, B>(that: ReadonlyRecord<K1, B>): <K0 extends string, A>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B>
   /**
    * Merge two records, preserving only the entries that are unique to each record.
    *
@@ -2105,10 +2042,7 @@ export const difference: {
    *
    * @since 2.0.0
    */
-  <K0 extends string, A, K1 extends string, B>(
-    self: ReadonlyRecord<K0, A>,
-    that: ReadonlyRecord<K1, B>
-  ): Record<K0 | K1, A | B>
+  <K0 extends string, A, K1 extends string, B>(self: ReadonlyRecord<K0, A>, that: ReadonlyRecord<K1, B>): Record<K0 | K1, A | B>
 } = dual(2, <K0 extends string, A, K1 extends string, B>(
   self: ReadonlyRecord<K0, A>,
   that: ReadonlyRecord<K1, B>

package/src/RedBlackTree.ts

@@ -622,11 +622,11 @@ export const forEachBetween: {
    * @category traversing
    */
   <K, V>(
-    options: {
-      readonly min: K
-      readonly max: K
-      readonly body: (key: K, value: V) => void
-    }
+   options: {
+     readonly min: K
+     readonly max: K
+     readonly body: (key: K, value: V) => void
+   }
   ): (self: RedBlackTree<K, V>) => void
   /**
    * Visit each node of the tree in order with key lower than max and greater
@@ -636,12 +636,12 @@ export const forEachBetween: {
    * @category traversing
    */
   <K, V>(
-    self: RedBlackTree<K, V>,
-    options: {
-      readonly min: K
-      readonly max: K
-      readonly body: (key: K, value: V) => void
-    }
+   self: RedBlackTree<K, V>,
+   options: {
+     readonly min: K
+     readonly max: K
+     readonly body: (key: K, value: V) => void
+   }
   ): void
 } = RBT.forEachBetween
 
@@ -666,9 +666,9 @@ export const reduce: {
    * @category folding
    */
   <Z, V, K>(
-    self: RedBlackTree<K, V>,
-    zero: Z,
-    f: (accumulator: Z, value: V, key: K) => Z
+   self: RedBlackTree<K, V>,
+   zero: Z,
+   f: (accumulator: Z, value: V, key: K) => Z
   ): Z
 } = RBT.reduce
 

package/src/Request.ts

@@ -232,9 +232,7 @@ export const completeEffect: {
    * @since 2.0.0
    * @category request completion
    */
-  <A extends Request<any, any>, R>(
-    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
-  ): (self: A) => Effect.Effect<void, never, R>
+  <A extends Request<any, any>, R>(effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>): (self: A) => Effect.Effect<void, never, R>
   /**
    * Complete a `Request` with the specified effectful computation, failing the
    * request with the error from the effect workflow if it fails, and completing
@@ -243,10 +241,7 @@ export const completeEffect: {
    * @since 2.0.0
    * @category request completion
    */
-  <A extends Request<any, any>, R>(
-    self: A,
-    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
-  ): Effect.Effect<void, never, R>
+  <A extends Request<any, any>, R>(self: A, effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>): Effect.Effect<void, never, R>
 } = internal.completeEffect
 
 /**

package/src/RequestResolver.ts

@@ -302,9 +302,7 @@ export const mapInputContext: {
    * @since 2.0.0
    * @category context
    */
-  <R0, R>(
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A, R0>
+  <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A, R0>
   /**
    * Provides this data source with part of its required context.
    *
@@ -434,9 +432,7 @@ export const provideContext: {
    * @since 2.0.0
    * @category context
    */
-  <R>(
-    context: Context.Context<R>
-  ): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A>
+  <R>(context: Context.Context<R>): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A>
   /**
    * Provides this data source with its required context.
    *
@@ -463,9 +459,7 @@ export const race: {
    * @since 2.0.0
    * @category combinators
    */
-  <A2 extends Request.Request<any, any>, R2>(
-    that: RequestResolver<A2, R2>
-  ): <A extends Request.Request<any, any>, R>(self: RequestResolver<A, R>) => RequestResolver<A2 | A, R2 | R>
+  <A2 extends Request.Request<any, any>, R2>(that: RequestResolver<A2, R2>): <A extends Request.Request<any, any>, R>(self: RequestResolver<A, R>) => RequestResolver<A2 | A, R2 | R>
   /**
    * Returns a new data source that executes requests by sending them to this
    * data source and that data source, returning the results from the first data
@@ -474,10 +468,7 @@ export const race: {
    * @since 2.0.0
    * @category combinators
    */
-  <A extends Request.Request<any, any>, R, A2 extends Request.Request<any, any>, R2>(
-    self: RequestResolver<A, R>,
-    that: RequestResolver<A2, R2>
-  ): RequestResolver<A | A2, R | R2>
+  <A extends Request.Request<any, any>, R, A2 extends Request.Request<any, any>, R2>(self: RequestResolver<A, R>, that: RequestResolver<A2, R2>): RequestResolver<A | A2, R | R2>
 } = internal.race
 
 /**
@@ -493,19 +484,12 @@ export const locally: {
    * @since 2.0.0
    * @category combinators
    */
-  <A>(
-    self: FiberRef<A>,
-    value: A
-  ): <R, B extends Request.Request<any, any>>(use: RequestResolver<B, R>) => RequestResolver<B, R>
+  <A>(self: FiberRef<A>, value: A): <R, B extends Request.Request<any, any>>(use: RequestResolver<B, R>) => RequestResolver<B, R>
   /**
    * Returns a new data source with a localized FiberRef
    *
    * @since 2.0.0
    * @category combinators
    */
-  <R, B extends Request.Request<any, any>, A>(
-    use: RequestResolver<B, R>,
-    self: FiberRef<A>,
-    value: A
-  ): RequestResolver<B, R>
+  <R, B extends Request.Request<any, any>, A>(use: RequestResolver<B, R>, self: FiberRef<A>, value: A): RequestResolver<B, R>
 } = core.resolverLocally

package/src/Runtime.ts

@@ -254,8 +254,8 @@ export const updateRuntimeFlags: {
    * @category runtime flags
    */
   <R>(
-    self: Runtime<R>,
-    f: (flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
+   self: Runtime<R>,
+   f: (flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
   ): Runtime<R>
 } = internal.updateRuntimeFlags
 
@@ -372,8 +372,8 @@ export const updateFiberRefs: {
    * @category fiber refs
    */
   <R>(
-    self: Runtime<R>,
-    f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
+   self: Runtime<R>,
+   f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
   ): Runtime<R>
 } = internal.updateFiberRefs
 

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