effect 2.3.8 → 2.4.1

package/src/internal/stm/stm.ts

@@ -8,11 +8,11 @@ import type * as FiberId from "../../FiberId.js"
 import type { LazyArg } from "../../Function.js"
 import { constFalse, constTrue, constVoid, dual, identity, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
-import * as predicate from "../../Predicate.js"
 import type { Predicate, Refinement } from "../../Predicate.js"
+import * as predicate from "../../Predicate.js"
 import * as RA from "../../ReadonlyArray.js"
 import type * as STM from "../../STM.js"
-import type { NoInfer } from "../../Types.js"
+import type { MergeRecord, NoInfer } from "../../Types.js"
 import * as effectCore from "../core.js"
 import * as SingleShotGen from "../singleShotGen.js"
 import * as core from "./core.js"
@@ -21,18 +21,18 @@ import * as STMState from "./stm/stmState.js"
 
 /** @internal */
 export const acquireUseRelease = dual<
-  <A, R2, E2, A2, R3, E3, A3>(
+  <A, A2, E2, R2, A3, E3, R3>(
     use: (resource: A) => STM.STM<A2, E2, R2>,
     release: (resource: A) => STM.STM<A3, E3, R3>
-  ) => <R, E>(
+  ) => <E, R>(
     acquire: STM.STM<A, E, R>
   ) => Effect.Effect<A2, E | E2 | E3, R | R2 | R3>,
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     acquire: STM.STM<A, E, R>,
     use: (resource: A) => STM.STM<A2, E2, R2>,
     release: (resource: A) => STM.STM<A3, E3, R3>
   ) => Effect.Effect<A2, E | E2 | E3, R | R2 | R3>
->(3, <R, E, A, R2, E2, A2, R3, E3, A3>(
+>(3, <A, E, R, A2, E2, R2, A3, E3, R3>(
   acquire: STM.STM<A, E, R>,
   use: (resource: A) => STM.STM<A2, E2, R2>,
   release: (resource: A) => STM.STM<A3, E3, R3>
@@ -86,7 +86,7 @@ export const acquireUseRelease = dual<
 /** @internal */
 export const as = dual<
   <A2>(value: A2) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A2, E, R>,
-  <R, E, A, A2>(self: STM.STM<A, E, R>, value: A2) => STM.STM<A2, E, R>
+  <A, E, R, A2>(self: STM.STM<A, E, R>, value: A2) => STM.STM<A2, E, R>
 >(2, (self, value) => pipe(self, core.map(() => value)))
 
 /** @internal */
@@ -111,16 +111,16 @@ export const attempt = <A>(evaluate: LazyArg<A>): STM.STM<A, unknown> =>
   })
 
 export const bind = dual<
-  <N extends string, K, R2, E2, A>(
+  <N extends string, K, A, E2, R2>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => STM.STM<A, E2, R2>
-  ) => <R, E>(self: STM.STM<K, E, R>) => STM.STM<Effect.MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>,
-  <R, E, N extends string, K, R2, E2, A>(
+  ) => <E, R>(self: STM.STM<K, E, R>) => STM.STM<MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>,
+  <K, E, R, N extends string, A, E2, R2>(
     self: STM.STM<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => STM.STM<A, E2, R2>
-  ) => STM.STM<Effect.MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
->(3, <R, E, N extends string, K, R2, E2, A>(
+  ) => STM.STM<MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
+>(3, <K, E, R, N extends string, A, E2, R2>(
   self: STM.STM<K, E, R>,
   tag: Exclude<N, keyof K>,
   f: (_: K) => STM.STM<A, E2, R2>
@@ -128,7 +128,7 @@ export const bind = dual<
   core.flatMap(self, (k) =>
     core.map(
       f(k),
-      (a): Effect.MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
+      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
     )))
 
 /* @internal */
@@ -138,7 +138,7 @@ export const bindTo = dual<
     E,
     R
   >,
-  <R, E, A, N extends string>(
+  <A, E, R, N extends string>(
     self: STM.STM<A, E, R>,
     tag: N
   ) => STM.STM<
@@ -148,7 +148,7 @@ export const bindTo = dual<
   >
 >(
   2,
-  <R, E, A, N extends string>(self: STM.STM<A, E, R>, tag: N): STM.STM<Record<N, A>, E, R> =>
+  <A, E, R, N extends string>(self: STM.STM<A, E, R>, tag: N): STM.STM<Record<N, A>, E, R> =>
     core.map(self, (a) => ({ [tag]: a } as Record<N, A>))
 )
 
@@ -157,38 +157,38 @@ export const let_ = dual<
   <N extends string, K, A>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
-  ) => <R, E>(self: STM.STM<K, E, R>) => STM.STM<
-    Effect.MergeRecord<K, { [k in N]: A }>,
+  ) => <E, R>(self: STM.STM<K, E, R>) => STM.STM<
+    MergeRecord<K, { [k in N]: A }>,
     E,
     R
   >,
-  <R, E, K, N extends string, A>(
+  <K, E, R, N extends string, A>(
     self: STM.STM<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
   ) => STM.STM<
-    Effect.MergeRecord<K, { [k in N]: A }>,
+    MergeRecord<K, { [k in N]: A }>,
     E,
     R
   >
->(3, <R, E, K, N extends string, A>(self: STM.STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A) =>
+>(3, <K, E, R, N extends string, A>(self: STM.STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A) =>
   core.map(
     self,
-    (k): Effect.MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: f(k) } as any)
+    (k): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: f(k) } as any)
   ))
 
 /** @internal */
 export const catchSome = dual<
-  <E, R2, E2, A2>(
+  <E, A2, E2, R2>(
     pf: (error: E) => Option.Option<STM.STM<A2, E2, R2>>
-  ) => <R, A>(
+  ) => <A, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A2 | A, E | E2, R2 | R>,
-  <R, A, E, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: STM.STM<A, E, R>,
     pf: (error: E) => Option.Option<STM.STM<A2, E2, R2>>
   ) => STM.STM<A2 | A, E | E2, R2 | R>
->(2, <R, A, E, R2, E2, A2>(
+>(2, <A, E, R, A2, E2, R2>(
   self: STM.STM<A, E, R>,
   pf: (error: E) => Option.Option<STM.STM<A2, E2, R2>>
 ): STM.STM<A2 | A, E | E2, R2 | R> =>
@@ -197,12 +197,13 @@ export const catchSome = dual<
     (e): STM.STM<A | A2, E | E2, R | R2> => Option.getOrElse(pf(e), () => core.fail(e))
   ))
 
+/** @internal */
 export const catchTag = dual<
-  <K extends E["_tag"] & string, E extends { _tag: string }, R1, E1, A1>(
+  <K extends E["_tag"] & string, E extends { _tag: string }, A1, E1, R1>(
     k: K,
     f: (e: Extract<E, { _tag: K }>) => STM.STM<A1, E1, R1>
-  ) => <R, A>(self: STM.STM<A, E, R>) => STM.STM<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>,
-  <R, E extends { _tag: string }, A, K extends E["_tag"] & string, R1, E1, A1>(
+  ) => <A, R>(self: STM.STM<A, E, R>) => STM.STM<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>,
+  <A, E extends { _tag: string }, R, K extends E["_tag"] & string, A1, E1, R1>(
     self: STM.STM<A, E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => STM.STM<A1, E1, R1>
@@ -224,7 +225,7 @@ export const catchTags: {
     }
   >(
     cases: Cases
-  ): <R, A>(self: STM.STM<A, E, R>) => STM.STM<
+  ): <A, R>(self: STM.STM<A, E, R>) => STM.STM<
     | A
     | {
       [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<infer A, any, any>) ? A : never
@@ -276,8 +277,8 @@ export const check = (predicate: LazyArg<boolean>): STM.STM<void> => suspend(()
 
 /** @internal */
 export const collect = dual<
-  <A, A2>(pf: (a: A) => Option.Option<A2>) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<A2, E, R>,
-  <R, E, A, A2>(self: STM.STM<A, E, R>, pf: (a: A) => Option.Option<A2>) => STM.STM<A2, E, R>
+  <A, A2>(pf: (a: A) => Option.Option<A2>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A2, E, R>,
+  <A, E, R, A2>(self: STM.STM<A, E, R>, pf: (a: A) => Option.Option<A2>) => STM.STM<A2, E, R>
 >(2, (self, pf) =>
   collectSTM(
     self,
@@ -286,12 +287,12 @@ export const collect = dual<
 
 /** @internal */
 export const collectSTM = dual<
-  <A, R2, E2, A2>(
+  <A, A2, E2, R2>(
     pf: (a: A) => Option.Option<STM.STM<A2, E2, R2>>
-  ) => <R, E>(
+  ) => <E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A2, E2 | E, R2 | R>,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: STM.STM<A, E, R>,
     pf: (a: A) => Option.Option<STM.STM<A2, E2, R2>>
   ) => STM.STM<A2, E2 | E, R2 | R>
@@ -320,7 +321,7 @@ export const cond = <A, E>(
 }
 
 /** @internal */
-export const either = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<Either.Either<E, A>, never, R> =>
+export const either = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<Either.Either<A, E>, never, R> =>
   match(self, { onFailure: Either.left, onSuccess: Either.right })
 
 /** @internal */
@@ -417,12 +418,12 @@ export const filterOrDie: {
   <A, B extends A>(
     refinement: Refinement<NoInfer<A>, B>,
     defect: LazyArg<unknown>
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
   <A>(
     predicate: Predicate<NoInfer<A>>,
     defect: LazyArg<unknown>
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
-  <R, E, A, B extends A>(
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
+  <A, E, R, B extends A>(
     self: STM.STM<A, E, R>,
     refinement: Refinement<A, B>,
     defect: LazyArg<unknown>
@@ -439,9 +440,9 @@ export const filterOrDieMessage: {
   <A, B extends A>(
     refinement: Refinement<NoInfer<A>, B>,
     message: string
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
-  <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
-  <R, E, A, B extends A>(self: STM.STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM.STM<B, E, R>
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
+  <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
+  <A, E, R, B extends A>(self: STM.STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM.STM<B, E, R>
   <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>, message: string): STM.STM<A, E, R>
 } = dual(
   3,
@@ -451,27 +452,27 @@ export const filterOrDieMessage: {
 
 /** @internal */
 export const filterOrElse: {
-  <A, B extends A, R2, E2, C>(
+  <A, B extends A, C, E2, R2>(
     refinement: Refinement<NoInfer<A>, B>,
     orElse: (a: NoInfer<A>) => STM.STM<C, E2, R2>
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<B | C, E2 | E, R2 | R>
-  <A, R2, E2, B>(
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<B | C, E2 | E, R2 | R>
+  <A, B, E2, R2>(
     predicate: Predicate<NoInfer<A>>,
     orElse: (a: NoInfer<A>) => STM.STM<B, E2, R2>
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A | B, E2 | E, R2 | R>
-  <R, E, A, B extends A, R2, E2, C>(
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<A | B, E2 | E, R2 | R>
+  <A, E, R, B extends A, C, E2, R2>(
     self: STM.STM<A, E, R>,
     refinement: Refinement<A, B>,
     orElse: (a: A) => STM.STM<C, E2, R2>
   ): STM.STM<B | C, E | E2, R | R2>
-  <R, E, A, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: STM.STM<A, E, R>,
     predicate: Predicate<A>,
     orElse: (a: A) => STM.STM<B, E2, R2>
   ): STM.STM<A | B, E | E2, R | R2>
 } = dual(
   3,
-  <R, E, A, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: STM.STM<A, E, R>,
     predicate: Predicate<A>,
     orElse: (a: A) => STM.STM<B, E2, R2>
@@ -484,20 +485,20 @@ export const filterOrFail: {
   <A, B extends A, E2>(
     refinement: Refinement<NoInfer<A>, B>,
     orFailWith: (a: NoInfer<A>) => E2
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, E2 | E, R>
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, E2 | E, R>
   <A, E2>(
     predicate: Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
-  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R>
-  <R, E, A, B extends A, E2>(
+  ): <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R>
+  <A, E, R, B extends A, E2>(
     self: STM.STM<A, E, R>,
     refinement: Refinement<A, B>,
     orFailWith: (a: A) => E2
   ): STM.STM<B, E | E2, R>
-  <R, E, A, E2>(self: STM.STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<A, E | E2, R>
+  <A, E, R, E2>(self: STM.STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<A, E | E2, R>
 } = dual(
   3,
-  <R, E, A, E2>(self: STM.STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<A, E | E2, R> =>
+  <A, E, R, E2>(self: STM.STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<A, E | E2, R> =>
     filterOrElse(
       self,
       predicate,
@@ -506,7 +507,7 @@ export const filterOrFail: {
 )
 
 /** @internal */
-export const flatten = <R, E, R2, E2, A>(self: STM.STM<STM.STM<A, E2, R2>, E, R>): STM.STM<A, E | E2, R | R2> =>
+export const flatten = <A, E2, R2, E, R>(self: STM.STM<STM.STM<A, E2, R2>, E, R>): STM.STM<A, E | E2, R | R2> =>
   core.flatMap(self, identity)
 
 /** @internal */
@@ -515,12 +516,12 @@ export const flip = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<E, A, R> =>
 
 /** @internal */
 export const flipWith = dual<
-  <R, A, E, R2, A2, E2>(
+  <E, A, R, E2, A2, R2>(
     f: (stm: STM.STM<E, A, R>) => STM.STM<E2, A2, R2>
   ) => (
     self: STM.STM<A, E, R>
   ) => STM.STM<A | A2, E | E2, R | R2>,
-  <R, A, E, R2, A2, E2>(
+  <A, E, R, E2, A2, R2>(
     self: STM.STM<A, E, R>,
     f: (stm: STM.STM<E, A, R>) => STM.STM<E2, A2, R2>
   ) => STM.STM<A | A2, E | E2, R | R2>
@@ -532,7 +533,7 @@ export const match = dual<
     readonly onFailure: (error: E) => A2
     readonly onSuccess: (value: A) => A3
   }) => <R>(self: STM.STM<A, E, R>) => STM.STM<A2 | A3, never, R>,
-  <R, E, A2, A, A3>(self: STM.STM<A, E, R>, options: {
+  <A, E, R, A2, A3>(self: STM.STM<A, E, R>, options: {
     readonly onFailure: (error: E) => A2
     readonly onSuccess: (value: A) => A3
   }) => STM.STM<A2 | A3, never, R>
@@ -545,24 +546,24 @@ export const match = dual<
 /** @internal */
 export const forEach = dual<
   {
-    <A, R, E, A2>(f: (a: A) => STM.STM<A2, E, R>, options?: {
+    <A, A2, E, R>(f: (a: A) => STM.STM<A2, E, R>, options?: {
       readonly discard?: false | undefined
     }): (elements: Iterable<A>) => STM.STM<Array<A2>, E, R>
-    <A, R, E, A2>(f: (a: A) => STM.STM<A2, E, R>, options: {
+    <A, A2, E, R>(f: (a: A) => STM.STM<A2, E, R>, options: {
       readonly discard: true
     }): (elements: Iterable<A>) => STM.STM<void, E, R>
   },
   {
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options?: {
+    <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options?: {
       readonly discard?: false | undefined
     }): STM.STM<Array<A2>, E, R>
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options: {
+    <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options: {
       readonly discard: true
     }): STM.STM<void, E, R>
   }
 >(
   (args) => predicate.isIterable(args[0]),
-  <A, R, E, A2>(iterable: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options?: {
+  <A, A2, E, R>(iterable: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options?: {
     readonly discard?: boolean | undefined
   }): STM.STM<any, E, R> => {
     if (options?.discard) {
@@ -595,7 +596,7 @@ export const forEach = dual<
 )
 
 /** @internal */
-export const fromEither = <E, A>(either: Either.Either<E, A>): STM.STM<A, E> => {
+export const fromEither = <A, E>(either: Either.Either<A, E>): STM.STM<A, E> => {
   switch (either._tag) {
     case "Left": {
       return core.fail(either.left)
@@ -669,44 +670,44 @@ export const head = <A, E, R>(self: STM.STM<Iterable<A>, E, R>): STM.STM<A, Opti
 
 /** @internal */
 export const if_ = dual<
-  <R1, R2, E1, E2, A, A1>(
+  <A, E1, R1, A2, E2, R2>(
     options: {
       readonly onTrue: STM.STM<A, E1, R1>
-      readonly onFalse: STM.STM<A1, E2, R2>
+      readonly onFalse: STM.STM<A2, E2, R2>
     }
-  ) => <R = never, E = never>(
+  ) => <E = never, R = never>(
     self: STM.STM<boolean, E, R> | boolean
-  ) => STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R>,
+  ) => STM.STM<A | A2, E1 | E2 | E, R1 | R2 | R>,
   {
-    <R, E, R1, R2, E1, E2, A, A1>(
+    <A, E1, R1, A2, E2, R2, E = never, R = never>(
       self: boolean,
       options: {
         readonly onTrue: STM.STM<A, E1, R1>
-        readonly onFalse: STM.STM<A1, E2, R2>
+        readonly onFalse: STM.STM<A2, E2, R2>
       }
-    ): STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R>
-    <R, E, R1, R2, E1, E2, A, A1>(
+    ): STM.STM<A | A2, E1 | E2 | E, R1 | R2 | R>
+    <E, R, A, E1, R1, A2, E2, R2>(
       self: STM.STM<boolean, E, R>,
       options: {
         readonly onTrue: STM.STM<A, E1, R1>
-        readonly onFalse: STM.STM<A1, E2, R2>
+        readonly onFalse: STM.STM<A2, E2, R2>
       }
-    ): STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R>
+    ): STM.STM<A | A2, E1 | E2 | E, R1 | R2 | R>
   }
 >(
   (args) => typeof args[0] === "boolean" || core.isSTM(args[0]),
-  <R, E, R1, R2, E1, E2, A, A1>(
+  <E, R, A, E1, R1, A2, E2, R2>(
     self: STM.STM<boolean, E, R> | boolean,
     { onFalse, onTrue }: {
       readonly onTrue: STM.STM<A, E1, R1>
-      readonly onFalse: STM.STM<A1, E2, R2>
+      readonly onFalse: STM.STM<A2, E2, R2>
     }
   ) => {
     if (typeof self === "boolean") {
       return self ? onTrue : onFalse
     }
 
-    return core.flatMap(self, (bool): STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R> => bool ? onTrue : onFalse)
+    return core.flatMap(self, (bool): STM.STM<A | A2, E1 | E2 | E, R1 | R2 | R> => bool ? onTrue : onFalse)
   }
 )
 
@@ -723,7 +724,7 @@ export const isSuccess = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<boolean, nev
   match(self, { onFailure: constFalse, onSuccess: constTrue })
 
 /** @internal */
-export const iterate = <R, E, Z>(
+export const iterate = <Z, E, R>(
   initial: Z,
   options: {
     readonly while: (z: Z) => boolean
@@ -731,7 +732,7 @@ export const iterate = <R, E, Z>(
   }
 ): STM.STM<Z, E, R> => iterateLoop(initial, options.while, options.body)
 
-const iterateLoop = <R, E, Z>(
+const iterateLoop = <Z, E, R>(
   initial: Z,
   cont: (z: Z) => boolean,
   body: (z: Z) => STM.STM<Z, E, R>
@@ -747,7 +748,7 @@ const iterateLoop = <R, E, Z>(
 
 /** @internal */
 export const loop: {
-  <Z, R, E, A>(
+  <Z, A, E, R>(
     initial: Z,
     options: {
       readonly while: (z: Z) => boolean
@@ -756,7 +757,7 @@ export const loop: {
       readonly discard?: false | undefined
     }
   ): STM.STM<Array<A>, E, R>
-  <Z, R, E, A>(
+  <Z, A, E, R>(
     initial: Z,
     options: {
       readonly while: (z: Z) => boolean
@@ -765,7 +766,7 @@ export const loop: {
       readonly discard: true
     }
   ): STM.STM<void, E, R>
-} = <Z, R, E, A>(
+} = <Z, A, E, R>(
   initial: Z,
   options: {
     readonly while: (z: Z) => boolean
@@ -778,7 +779,7 @@ export const loop: {
     loopDiscardLoop(initial, options.while, options.step, options.body) :
     core.map(loopLoop(initial, options.while, options.step, options.body), (a) => Array.from(a))
 
-const loopLoop = <Z, R, E, A>(
+const loopLoop = <Z, A, E, R>(
   initial: Z,
   cont: (z: Z) => boolean,
   inc: (z: Z) => Z,
@@ -810,9 +811,9 @@ const loopDiscardLoop = <Z, R, E, X>(
 
 /** @internal */
 export const mapAttempt = dual<
-  <A, B>(f: (a: A) => B) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, unknown, R>,
-  <R, E, A, B>(self: STM.STM<A, E, R>, f: (a: A) => B) => STM.STM<B, unknown, R>
->(2, <R, E, A, B>(self: STM.STM<A, E, R>, f: (a: A) => B): STM.STM<B, unknown, R> =>
+  <A, B>(f: (a: A) => B) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, unknown, R>,
+  <A, E, R, B>(self: STM.STM<A, E, R>, f: (a: A) => B) => STM.STM<B, unknown, R>
+>(2, <A, E, R, B>(self: STM.STM<A, E, R>, f: (a: A) => B): STM.STM<B, unknown, R> =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(e),
     onSuccess: (a) => attempt(() => f(a))
@@ -824,7 +825,7 @@ export const mapBoth = dual<
     readonly onFailure: (error: E) => E2
     readonly onSuccess: (value: A) => A2
   }) => <R>(self: STM.STM<A, E, R>) => STM.STM<A2, E2, R>,
-  <R, E, E2, A, A2>(self: STM.STM<A, E, R>, options: {
+  <A, E, R, E2, A2>(self: STM.STM<A, E, R>, options: {
     readonly onFailure: (error: E) => E2
     readonly onSuccess: (value: A) => A2
   }) => STM.STM<A2, E2, R>
@@ -836,8 +837,8 @@ export const mapBoth = dual<
 
 /** @internal */
 export const mapError = dual<
-  <E, E2>(f: (error: E) => E2) => <R, A>(self: STM.STM<A, E, R>) => STM.STM<A, E2, R>,
-  <R, A, E, E2>(self: STM.STM<A, E, R>, f: (error: E) => E2) => STM.STM<A, E2, R>
+  <E, E2>(f: (error: E) => E2) => <A, R>(self: STM.STM<A, E, R>) => STM.STM<A, E2, R>,
+  <A, E, R, E2>(self: STM.STM<A, E, R>, f: (error: E) => E2) => STM.STM<A, E2, R>
 >(2, (self, f) =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(f(e)),
@@ -850,11 +851,11 @@ export const merge = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<E | A, never, R>
 
 /** @internal */
 export const mergeAll = dual<
-  <A2, A>(zero: A2, f: (a2: A2, a: A) => A2) => <R, E>(iterable: Iterable<STM.STM<A, E, R>>) => STM.STM<A2, E, R>,
-  <R, E, A2, A>(iterable: Iterable<STM.STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2) => STM.STM<A2, E, R>
+  <A2, A>(zero: A2, f: (a2: A2, a: A) => A2) => <E, R>(iterable: Iterable<STM.STM<A, E, R>>) => STM.STM<A2, E, R>,
+  <A, E, R, A2>(iterable: Iterable<STM.STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2) => STM.STM<A2, E, R>
 >(
   3,
-  <R, E, A2, A>(iterable: Iterable<STM.STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM.STM<A2, E, R> =>
+  <A, E, R, A2>(iterable: Iterable<STM.STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM.STM<A2, E, R> =>
     suspend(() =>
       Array.from(iterable).reduce(
         (acc, curr) => pipe(acc, core.zipWith(curr, f)),
@@ -864,7 +865,7 @@ export const mergeAll = dual<
 )
 
 /** @internal */
-export const negate = <R, E>(self: STM.STM<boolean, E, R>): STM.STM<boolean, E, R> => pipe(self, core.map((b) => !b))
+export const negate = <E, R>(self: STM.STM<boolean, E, R>): STM.STM<boolean, E, R> => pipe(self, core.map((b) => !b))
 
 /** @internal */
 export const none = <A, E, R>(self: STM.STM<Option.Option<A>, E, R>): STM.STM<void, Option.Option<E>, R> =>
@@ -885,17 +886,17 @@ export const orDie = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<A, never, R> =>
 
 /** @internal */
 export const orDieWith = dual<
-  <E>(f: (error: E) => unknown) => <R, A>(self: STM.STM<A, E, R>) => STM.STM<A, never, R>,
-  <R, A, E>(self: STM.STM<A, E, R>, f: (error: E) => unknown) => STM.STM<A, never, R>
+  <E>(f: (error: E) => unknown) => <A, R>(self: STM.STM<A, E, R>) => STM.STM<A, never, R>,
+  <A, E, R>(self: STM.STM<A, E, R>, f: (error: E) => unknown) => STM.STM<A, never, R>
 >(2, (self, f) => pipe(self, mapError(f), core.catchAll(core.die)))
 
 /** @internal */
 export const orElse = dual<
-  <R2, E2, A2>(that: LazyArg<STM.STM<A2, E2, R2>>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A2 | A, E2, R2 | R>,
-  <R, E, A, R2, E2, A2>(self: STM.STM<A, E, R>, that: LazyArg<STM.STM<A2, E2, R2>>) => STM.STM<A2 | A, E2, R2 | R>
+  <A2, E2, R2>(that: LazyArg<STM.STM<A2, E2, R2>>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A2 | A, E2, R2 | R>,
+  <A, E, R, A2, E2, R2>(self: STM.STM<A, E, R>, that: LazyArg<STM.STM<A2, E2, R2>>) => STM.STM<A2 | A, E2, R2 | R>
 >(
   2,
-  <R, E, A, R2, E2, A2>(self: STM.STM<A, E, R>, that: LazyArg<STM.STM<A2, E2, R2>>): STM.STM<A2 | A, E2, R2 | R> =>
+  <A, E, R, A2, E2, R2>(self: STM.STM<A, E, R>, that: LazyArg<STM.STM<A2, E2, R2>>): STM.STM<A2 | A, E2, R2 | R> =>
     core.flatMap(core.effect<R, LazyArg<void>>((journal) => Journal.prepareResetJournal(journal)), (reset) =>
       pipe(
         core.orTry(self, () => core.flatMap(core.sync(reset), that)),
@@ -905,48 +906,48 @@ export const orElse = dual<
 
 /** @internal */
 export const orElseEither = dual<
-  <R2, E2, A2>(
+  <A2, E2, R2>(
     that: LazyArg<STM.STM<A2, E2, R2>>
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
-  ) => STM.STM<Either.Either<A, A2>, E2, R2 | R>,
-  <R, E, A, R2, E2, A2>(
+  ) => STM.STM<Either.Either<A2, A>, E2, R2 | R>,
+  <A, E, R, A2, E2, R2>(
     self: STM.STM<A, E, R>,
     that: LazyArg<STM.STM<A2, E2, R2>>
-  ) => STM.STM<Either.Either<A, A2>, E2, R2 | R>
+  ) => STM.STM<Either.Either<A2, A>, E2, R2 | R>
 >(
   2,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: STM.STM<A, E, R>,
     that: LazyArg<STM.STM<A2, E2, R2>>
-  ): STM.STM<Either.Either<A, A2>, E2, R2 | R> =>
+  ): STM.STM<Either.Either<A2, A>, E2, R2 | R> =>
     orElse(core.map(self, Either.left), () => core.map(that(), Either.right))
 )
 
 /** @internal */
 export const orElseFail = dual<
   <E2>(error: LazyArg<E2>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E2, R>,
-  <R, E, A, E2>(self: STM.STM<A, E, R>, error: LazyArg<E2>) => STM.STM<A, E2, R>
+  <A, E, R, E2>(self: STM.STM<A, E, R>, error: LazyArg<E2>) => STM.STM<A, E2, R>
 >(
   2,
-  <R, E, A, E2>(self: STM.STM<A, E, R>, error: LazyArg<E2>): STM.STM<A, E2, R> =>
+  <A, E, R, E2>(self: STM.STM<A, E, R>, error: LazyArg<E2>): STM.STM<A, E2, R> =>
     orElse(self, () => core.failSync(error))
 )
 
 /** @internal */
 export const orElseOptional = dual<
-  <R2, E2, A2>(
+  <A2, E2, R2>(
     that: LazyArg<STM.STM<A2, Option.Option<E2>, R2>>
   ) => <A, E, R>(
     self: STM.STM<A, Option.Option<E>, R>
   ) => STM.STM<A2 | A, Option.Option<E2 | E>, R2 | R>,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: STM.STM<A, Option.Option<E>, R>,
     that: LazyArg<STM.STM<A2, Option.Option<E2>, R2>>
   ) => STM.STM<A2 | A, Option.Option<E2 | E>, R2 | R>
 >(
   2,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: STM.STM<A, Option.Option<E>, R>,
     that: LazyArg<STM.STM<A2, Option.Option<E2>, R2>>
   ): STM.STM<A2 | A, Option.Option<E2 | E>, R2 | R> =>
@@ -962,10 +963,10 @@ export const orElseOptional = dual<
 /** @internal */
 export const orElseSucceed = dual<
   <A2>(value: LazyArg<A2>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A2 | A, never, R>,
-  <R, E, A, A2>(self: STM.STM<A, E, R>, value: LazyArg<A2>) => STM.STM<A2 | A, never, R>
+  <A, E, R, A2>(self: STM.STM<A, E, R>, value: LazyArg<A2>) => STM.STM<A2 | A, never, R>
 >(
   2,
-  <R, E, A, A2>(self: STM.STM<A, E, R>, value: LazyArg<A2>): STM.STM<A2 | A, never, R> =>
+  <A, E, R, A2>(self: STM.STM<A, E, R>, value: LazyArg<A2>): STM.STM<A2 | A, never, R> =>
     orElse(self, () => core.sync(value))
 )
 
@@ -996,7 +997,7 @@ export const provideService = dual<
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>,
-  <R, E, A, T extends Context.Tag<any, any>>(
+  <A, E, R, T extends Context.Tag<any, any>>(
     self: STM.STM<A, E, R>,
     tag: T,
     resource: Context.Tag.Service<T>
@@ -1005,18 +1006,18 @@ export const provideService = dual<
 
 /** @internal */
 export const provideServiceSTM = dual<
-  <T extends Context.Tag<any, any>, R1, E1>(
+  <T extends Context.Tag<any, any>, E1, R1>(
     tag: T,
     stm: STM.STM<Context.Tag.Service<T>, E1, R1>
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>,
-  <R, E, A, T extends Context.Tag<any, any>, R1, E1>(
+  <A, E, R, T extends Context.Tag<any, any>, E1, R1>(
     self: STM.STM<A, E, R>,
     tag: T,
     stm: STM.STM<Context.Tag.Service<T>, E1, R1>
   ) => STM.STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>
->(3, <R, E, A, T extends Context.Tag<any, any>, R1, E1>(
+>(3, <A, E, R, T extends Context.Tag<any, any>, E1, R1>(
   self: STM.STM<A, E, R>,
   tag: T,
   stm: STM.STM<Context.Tag.Service<T>, E1, R1>
@@ -1034,8 +1035,8 @@ export const provideServiceSTM = dual<
 
 /** @internal */
 export const reduce = dual<
-  <S, A, R, E>(zero: S, f: (s: S, a: A) => STM.STM<S, E, R>) => (iterable: Iterable<A>) => STM.STM<S, E, R>,
-  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<S, E, R>) => STM.STM<S, E, R>
+  <S, A, E, R>(zero: S, f: (s: S, a: A) => STM.STM<S, E, R>) => (iterable: Iterable<A>) => STM.STM<S, E, R>,
+  <S, A, E, R>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<S, E, R>) => STM.STM<S, E, R>
 >(
   3,
   <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<S, E, R>): STM.STM<S, E, R> =>
@@ -1049,18 +1050,18 @@ export const reduce = dual<
 
 /** @internal */
 export const reduceAll = dual<
-  <R2, E2, A>(
+  <A, E2, R2>(
     initial: STM.STM<A, E2, R2>,
     f: (x: A, y: A) => A
-  ) => <R, E>(
+  ) => <E, R>(
     iterable: Iterable<STM.STM<A, E, R>>
   ) => STM.STM<A, E2 | E, R2 | R>,
-  <R, E, R2, E2, A>(
+  <A, E, R, E2, R2>(
     iterable: Iterable<STM.STM<A, E, R>>,
     initial: STM.STM<A, E2, R2>,
     f: (x: A, y: A) => A
   ) => STM.STM<A, E2 | E, R2 | R>
->(3, <R, E, R2, E2, A>(
+>(3, <A, E, R, E2, R2>(
   iterable: Iterable<STM.STM<A, E, R>>,
   initial: STM.STM<A, E2, R2>,
   f: (x: A, y: A) => A
@@ -1089,8 +1090,8 @@ export const reduceRight = dual<
 
 /** @internal */
 export const refineOrDie = dual<
-  <E, E2>(pf: (error: E) => Option.Option<E2>) => <R, A>(self: STM.STM<A, E, R>) => STM.STM<A, E2, R>,
-  <R, A, E, E2>(self: STM.STM<A, E, R>, pf: (error: E) => Option.Option<E2>) => STM.STM<A, E2, R>
+  <E, E2>(pf: (error: E) => Option.Option<E2>) => <A, R>(self: STM.STM<A, E, R>) => STM.STM<A, E2, R>,
+  <A, E, R, E2>(self: STM.STM<A, E, R>, pf: (error: E) => Option.Option<E2>) => STM.STM<A, E2, R>
 >(2, (self, pf) => refineOrDieWith(self, pf, identity))
 
 /** @internal */
@@ -1098,10 +1099,10 @@ export const refineOrDieWith = dual<
   <E, E2>(
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
-  ) => <R, A>(
+  ) => <A, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A, E2, R>,
-  <R, A, E, E2>(
+  <A, E, R, E2>(
     self: STM.STM<A, E, R>,
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
@@ -1118,8 +1119,8 @@ export const refineOrDieWith = dual<
 
 /** @internal */
 export const reject = dual<
-  <A, E2>(pf: (a: A) => Option.Option<E2>) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R>,
-  <R, E, A, E2>(self: STM.STM<A, E, R>, pf: (a: A) => Option.Option<E2>) => STM.STM<A, E2 | E, R>
+  <A, E2>(pf: (a: A) => Option.Option<E2>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R>,
+  <A, E, R, E2>(self: STM.STM<A, E, R>, pf: (a: A) => Option.Option<E2>) => STM.STM<A, E2 | E, R>
 >(2, (self, pf) =>
   rejectSTM(
     self,
@@ -1128,12 +1129,12 @@ export const reject = dual<
 
 /** @internal */
 export const rejectSTM = dual<
-  <A, R2, E2>(
+  <A, E2, R2>(
     pf: (a: A) => Option.Option<STM.STM<E2, E2, R2>>
-  ) => <R, E>(
+  ) => <E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A, E2 | E, R2 | R>,
-  <R, E, A, R2, E2>(
+  <A, E, R, E2, R2>(
     self: STM.STM<A, E, R>,
     pf: (a: A) => Option.Option<STM.STM<E2, E2, R2>>
   ) => STM.STM<A, E2 | E, R2 | R>
@@ -1146,7 +1147,7 @@ export const rejectSTM = dual<
 
 /** @internal */
 export const repeatUntil = dual<
-  <A>(predicate: Predicate<A>) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>,
+  <A>(predicate: Predicate<A>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>,
   <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>) => STM.STM<A, E, R>
 >(2, (self, predicate) => repeatUntilLoop(self, predicate))
 
@@ -1158,7 +1159,7 @@ const repeatUntilLoop = <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A
 
 /** @internal */
 export const repeatWhile = dual<
-  <A>(predicate: Predicate<A>) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>,
+  <A>(predicate: Predicate<A>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>,
   <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>) => STM.STM<A, E, R>
 >(2, (self, predicate) => repeatWhileLoop(self, predicate))
 
@@ -1191,11 +1192,11 @@ export const replicateSTMDiscard = dual<
 /** @internal */
 export const retryUntil = dual<
   {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
-    <A>(predicate: Predicate<A>): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
+    <A>(predicate: Predicate<A>): <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
   },
   {
-    <R, E, A, B extends A>(self: STM.STM<A, E, R>, refinement: Refinement<A, B>): STM.STM<B, E, R>
+    <A, E, R, B extends A>(self: STM.STM<A, E, R>, refinement: Refinement<A, B>): STM.STM<B, E, R>
     <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>): STM.STM<A, E, R>
   }
 >(
@@ -1206,7 +1207,7 @@ export const retryUntil = dual<
 
 /** @internal */
 export const retryWhile = dual<
-  <A>(predicate: Predicate<A>) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>,
+  <A>(predicate: Predicate<A>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>,
   <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>) => STM.STM<A, E, R>
 >(
   2,
@@ -1216,12 +1217,12 @@ export const retryWhile = dual<
 
 /** @internal */
 export const partition = dual<
-  <R, E, A, A2>(
+  <A, A2, E, R>(
     f: (a: A) => STM.STM<A2, E, R>
   ) => (
     elements: Iterable<A>
   ) => STM.STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>,
-  <R, E, A, A2>(
+  <A, A2, E, R>(
     elements: Iterable<A>,
     f: (a: A) => STM.STM<A2, E, R>
   ) => STM.STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>
@@ -1275,13 +1276,13 @@ export const succeedSome = <A>(value: A): STM.STM<Option.Option<A>> => core.succ
 
 /** @internal */
 export const summarized = dual<
-  <R2, E2, A2, A3>(
+  <A2, E2, R2, A3>(
     summary: STM.STM<A2, E2, R2>,
     f: (before: A2, after: A2) => A3
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<[A3, A], E2 | E, R2 | R>,
-  <R, E, A, R2, E2, A2, A3>(
+  <A, E, R, A2, E2, R2, A3>(
     self: STM.STM<A, E, R>,
     summary: STM.STM<A2, E2, R2>,
     f: (before: A2, after: A2) => A3
@@ -1299,17 +1300,17 @@ export const suspend = <A, E, R>(evaluate: LazyArg<STM.STM<A, E, R>>): STM.STM<A
 
 /** @internal */
 export const tap: {
-  <A, R2, E2, _>(f: (a: A) => STM.STM<_, E2, R2>): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R2 | R>
-  <R, E, A, R2, E2, _>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<_, E2, R2>): STM.STM<A, E | E2, R | R2>
+  <A, X, E2, R2>(f: (a: A) => STM.STM<X, E2, R2>): <E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R2 | R>
+  <A, E, R, X, E2, R2>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<X, E2, R2>): STM.STM<A, E | E2, R | R2>
 } = dual(
   2,
-  <R, E, A, R2, E2, _>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<_, E2, R2>): STM.STM<A, E | E2, R | R2> =>
+  <A, E, R, X, E2, R2>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<X, E2, R2>): STM.STM<A, E | E2, R | R2> =>
     core.flatMap(self, (a) => as(f(a), a))
 )
 
 /** @internal */
 export const tapBoth = dual<
-  <E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
+  <XE extends E, A2, E2, R2, XA extends A, A3, E3, R3, A, E>(
     options: {
       readonly onFailure: (error: XE) => STM.STM<A2, E2, R2>
       readonly onSuccess: (value: XA) => STM.STM<A3, E3, R3>
@@ -1317,7 +1318,7 @@ export const tapBoth = dual<
   ) => <R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A, E | E2 | E3, R2 | R3 | R>,
-  <R, E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
+  <A, E, R, XE extends E, A2, E2, R2, XA extends A, A3, E3, R3>(
     self: STM.STM<A, E, R>,
     options: {
       readonly onFailure: (error: XE) => STM.STM<A2, E2, R2>
@@ -1332,13 +1333,13 @@ export const tapBoth = dual<
 
 /** @internal */
 export const tapError: {
-  <E, R2, E2, _>(
-    f: (error: NoInfer<E>) => STM.STM<_, E2, R2>
-  ): <R, A>(self: STM.STM<A, E, R>) => STM.STM<A, E | E2, R2 | R>
-  <R, A, E, R2, E2, _>(self: STM.STM<A, E, R>, f: (error: E) => STM.STM<_, E2, R2>): STM.STM<A, E | E2, R | R2>
+  <E, X, E2, R2>(
+    f: (error: NoInfer<E>) => STM.STM<X, E2, R2>
+  ): <A, R>(self: STM.STM<A, E, R>) => STM.STM<A, E | E2, R2 | R>
+  <A, E, R, X, E2, R2>(self: STM.STM<A, E, R>, f: (error: E) => STM.STM<X, E2, R2>): STM.STM<A, E | E2, R | R2>
 } = dual(
   2,
-  <R, A, E, R2, E2, _>(self: STM.STM<A, E, R>, f: (error: E) => STM.STM<_, E2, R2>): STM.STM<A, E | E2, R | R2> =>
+  <A, E, R, X, E2, R2>(self: STM.STM<A, E, R>, f: (error: E) => STM.STM<X, E2, R2>): STM.STM<A, E | E2, R | R2> =>
     core.matchSTM(self, {
       onFailure: (e) => core.zipRight(f(e), core.fail(e)),
       onSuccess: core.succeed
@@ -1382,12 +1383,12 @@ export const unless = dual<
 
 /** @internal */
 export const unlessSTM = dual<
-  <R2, E2>(
+  <E2, R2>(
     predicate: STM.STM<boolean, E2, R2>
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<Option.Option<A>, E2 | E, R2 | R>,
-  <R, E, A, R2, E2>(
+  <A, E, R, E2, R2>(
     self: STM.STM<A, E, R>,
     predicate: STM.STM<boolean, E2, R2>
   ) => STM.STM<Option.Option<A>, E2 | E, R2 | R>
@@ -1409,12 +1410,12 @@ export const unsome = <A, E, R>(self: STM.STM<A, Option.Option<E>, R>): STM.STM<
 
 /** @internal */
 export const validateAll = dual<
-  <R, E, A, B>(
+  <A, B, E, R>(
     f: (a: A) => STM.STM<B, E, R>
   ) => (
     elements: Iterable<A>
   ) => STM.STM<Array<B>, RA.NonEmptyArray<E>, R>,
-  <R, E, A, B>(
+  <A, B, E, R>(
     elements: Iterable<A>,
     f: (a: A) => STM.STM<B, E, R>
   ) => STM.STM<Array<B>, RA.NonEmptyArray<E>, R>
@@ -1429,8 +1430,8 @@ export const validateAll = dual<
 
 /** @internal */
 export const validateFirst = dual<
-  <R, E, A, B>(f: (a: A) => STM.STM<B, E, R>) => (elements: Iterable<A>) => STM.STM<B, Array<E>, R>,
-  <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM.STM<B, E, R>) => STM.STM<B, Array<E>, R>
+  <A, B, E, R>(f: (a: A) => STM.STM<B, E, R>) => (elements: Iterable<A>) => STM.STM<B, Array<E>, R>,
+  <A, B, E, R>(elements: Iterable<A>, f: (a: A) => STM.STM<B, E, R>) => STM.STM<B, Array<E>, R>
 >(2, (elements, f) => flip(forEach(elements, (a) => flip(f(a)))))
 
 /** @internal */
@@ -1444,12 +1445,12 @@ export const when = dual<
 
 /** @internal */
 export const whenSTM = dual<
-  <R2, E2>(
+  <E2, R2>(
     predicate: STM.STM<boolean, E2, R2>
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<Option.Option<A>, E2 | E, R2 | R>,
-  <R, E, A, R2, E2>(
+  <A, E, R, E2, R2>(
     self: STM.STM<A, E, R>,
     predicate: STM.STM<boolean, E2, R2>
   ) => STM.STM<Option.Option<A>, E2 | E, R2 | R>