effect 2.2.5 → 2.3.1

package/src/internal/stm/stm.ts

@@ -22,23 +22,23 @@ import * as STMState from "./stm/stmState.js"
 /** @internal */
 export const acquireUseRelease = dual<
   <A, R2, E2, A2, R3, E3, A3>(
-    use: (resource: A) => STM.STM<R2, E2, A2>,
-    release: (resource: A) => STM.STM<R3, E3, A3>
+    use: (resource: A) => STM.STM<A2, E2, R2>,
+    release: (resource: A) => STM.STM<A3, E3, R3>
   ) => <R, E>(
-    acquire: STM.STM<R, E, A>
-  ) => Effect.Effect<R | R2 | R3, E | E2 | E3, A2>,
+    acquire: STM.STM<A, E, R>
+  ) => Effect.Effect<A2, E | E2 | E3, R | R2 | R3>,
   <R, E, A, R2, E2, A2, R3, E3, A3>(
-    acquire: STM.STM<R, E, A>,
-    use: (resource: A) => STM.STM<R2, E2, A2>,
-    release: (resource: A) => STM.STM<R3, E3, A3>
-  ) => Effect.Effect<R | R2 | R3, E | E2 | E3, A2>
+    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>(
-  acquire: STM.STM<R, E, A>,
-  use: (resource: A) => STM.STM<R2, E2, A2>,
-  release: (resource: A) => STM.STM<R3, E3, A3>
-): Effect.Effect<R | R2 | R3, E | E2 | E3, A2> =>
+  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> =>
   Effect.uninterruptibleMask((restore) => {
-    let state: STMState.STMState<E, A> = STMState.running
+    let state: STMState.STMState<A, E> = STMState.running
     return pipe(
       restore(
         core.unsafeAtomically(
@@ -85,23 +85,23 @@ export const acquireUseRelease = dual<
 
 /** @internal */
 export const as = dual<
-  <A2>(value: A2) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, E, A2>,
-  <R, E, A, A2>(self: STM.STM<R, E, A>, value: A2) => STM.STM<R, E, A2>
+  <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>
 >(2, (self, value) => pipe(self, core.map(() => value)))
 
 /** @internal */
-export const asSome = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, E, Option.Option<A>> =>
+export const asSome = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<Option.Option<A>, E, R> =>
   pipe(self, core.map(Option.some))
 
 /** @internal */
-export const asSomeError = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, Option.Option<E>, A> =>
+export const asSomeError = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<A, Option.Option<E>, R> =>
   pipe(self, mapError(Option.some))
 
 /** @internal */
-export const asUnit = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, E, void> => pipe(self, core.map(constVoid))
+export const asUnit = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<void, E, R> => pipe(self, core.map(constVoid))
 
 /** @internal */
-export const attempt = <A>(evaluate: LazyArg<A>): STM.STM<never, unknown, A> =>
+export const attempt = <A>(evaluate: LazyArg<A>): STM.STM<A, unknown> =>
   suspend(() => {
     try {
       return core.succeed(evaluate())
@@ -113,25 +113,17 @@ export const attempt = <A>(evaluate: LazyArg<A>): STM.STM<never, unknown, A> =>
 export const bind = dual<
   <N extends string, K, R2, E2, A>(
     tag: Exclude<N, keyof K>,
-    f: (_: K) => STM.STM<R2, E2, A>
-  ) => <R, E>(self: STM.STM<R, E, K>) => STM.STM<
-    R | R2,
-    E | E2,
-    Effect.MergeRecord<K, { [k in N]: A }>
-  >,
+    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>(
-    self: STM.STM<R, E, K>,
+    self: STM.STM<K, E, R>,
     tag: Exclude<N, keyof K>,
-    f: (_: K) => STM.STM<R2, E2, A>
-  ) => STM.STM<
-    R | R2,
-    E | E2,
-    Effect.MergeRecord<K, { [k in N]: A }>
-  >
+    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>(
-  self: STM.STM<R, E, K>,
+  self: STM.STM<K, E, R>,
   tag: Exclude<N, keyof K>,
-  f: (_: K) => STM.STM<R2, E2, A>
+  f: (_: K) => STM.STM<A, E2, R2>
 ) =>
   core.flatMap(self, (k) =>
     core.map(
@@ -141,22 +133,22 @@ export const bind = dual<
 
 /* @internal */
 export const bindTo = dual<
-  <N extends string>(tag: N) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<
-    R,
+  <N extends string>(tag: N) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<
+    Record<N, A>,
     E,
-    Record<N, A>
+    R
   >,
   <R, E, A, N extends string>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     tag: N
   ) => STM.STM<
-    R,
+    Record<N, A>,
     E,
-    Record<N, A>
+    R
   >
 >(
   2,
-  <R, E, A, N extends string>(self: STM.STM<R, E, A>, tag: N): STM.STM<R, E, Record<N, A>> =>
+  <R, E, A, 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>))
 )
 
@@ -165,21 +157,21 @@ export const let_ = dual<
   <N extends string, K, A>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
-  ) => <R, E>(self: STM.STM<R, E, K>) => STM.STM<
-    R,
+  ) => <R, E>(self: STM.STM<K, E, R>) => STM.STM<
+    Effect.MergeRecord<K, { [k in N]: A }>,
     E,
-    Effect.MergeRecord<K, { [k in N]: A }>
+    R
   >,
   <R, E, K, N extends string, A>(
-    self: STM.STM<R, E, K>,
+    self: STM.STM<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
   ) => STM.STM<
-    R,
+    Effect.MergeRecord<K, { [k in N]: A }>,
     E,
-    Effect.MergeRecord<K, { [k in N]: A }>
+    R
   >
->(3, <R, E, K, N extends string, A>(self: STM.STM<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A) =>
+>(3, <R, E, K, 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)
@@ -188,33 +180,33 @@ export const let_ = dual<
 /** @internal */
 export const catchSome = dual<
   <E, R2, E2, A2>(
-    pf: (error: E) => Option.Option<STM.STM<R2, E2, A2>>
+    pf: (error: E) => Option.Option<STM.STM<A2, E2, R2>>
   ) => <R, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E | E2, A2 | A>,
+    self: STM.STM<A, E, R>
+  ) => STM.STM<A2 | A, E | E2, R2 | R>,
   <R, A, E, R2, E2, A2>(
-    self: STM.STM<R, E, A>,
-    pf: (error: E) => Option.Option<STM.STM<R2, E2, A2>>
-  ) => STM.STM<R2 | R, E | E2, A2 | A>
+    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>(
-  self: STM.STM<R, E, A>,
-  pf: (error: E) => Option.Option<STM.STM<R2, E2, A2>>
-): STM.STM<R2 | R, E | E2, A2 | A> =>
+  self: STM.STM<A, E, R>,
+  pf: (error: E) => Option.Option<STM.STM<A2, E2, R2>>
+): STM.STM<A2 | A, E | E2, R2 | R> =>
   core.catchAll(
     self,
-    (e): STM.STM<R | R2, E | E2, A | A2> => Option.getOrElse(pf(e), () => core.fail(e))
+    (e): STM.STM<A | A2, E | E2, R | R2> => Option.getOrElse(pf(e), () => core.fail(e))
   ))
 
 export const catchTag = dual<
   <K extends E["_tag"] & string, E extends { _tag: string }, R1, E1, A1>(
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => STM.STM<R1, E1, A1>
-  ) => <R, A>(self: STM.STM<R, E, A>) => STM.STM<R | R1, Exclude<E, { _tag: K }> | E1, A | A1>,
+    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>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => STM.STM<R1, E1, A1>
-  ) => STM.STM<R | R1, Exclude<E, { _tag: K }> | E1, A | A1>
+    f: (e: Extract<E, { _tag: K }>) => STM.STM<A1, E1, R1>
+  ) => STM.STM<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>
 >(3, (self, k, f) =>
   core.catchAll(self, (e) => {
     if ("_tag" in e && e["_tag"] === k) {
@@ -232,18 +224,18 @@ export const catchTags: {
     }
   >(
     cases: Cases
-  ): <R, A>(self: STM.STM<R, E, A>) => STM.STM<
-    | R
+  ): <R, A>(self: STM.STM<A, E, R>) => STM.STM<
+    | A
     | {
-      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<infer R, any, any>) ? R : never
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<infer A, any, any>) ? A : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<any, infer E, any>) ? E : never
     }[keyof Cases],
-    | A
+    | R
     | {
-      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<any, any, infer A>) ? A : never
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<any, any, infer R>) ? R : never
     }[keyof Cases]
   >
   <
@@ -254,20 +246,20 @@ export const catchTags: {
       [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => STM.STM<any, any, any>
     }
   >(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     cases: Cases
   ): STM.STM<
-    | R
+    | A
     | {
-      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<infer R, any, any>) ? R : never
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<infer A, any, any>) ? A : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<any, infer E, any>) ? E : never
     }[keyof Cases],
-    | A
+    | R
     | {
-      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<any, any, infer A>) ? A : never
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => STM.STM<any, any, infer R>) ? R : never
     }[keyof Cases]
   >
 } = dual(2, (self, cases) =>
@@ -280,13 +272,12 @@ export const catchTags: {
   }))
 
 /** @internal */
-export const check = (predicate: LazyArg<boolean>): STM.STM<never, never, void> =>
-  suspend(() => predicate() ? unit : core.retry)
+export const check = (predicate: LazyArg<boolean>): STM.STM<void> => suspend(() => predicate() ? unit : core.retry)
 
 /** @internal */
 export const collect = dual<
-  <A, A2>(pf: (a: A) => Option.Option<A2>) => <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A2>,
-  <R, E, A, A2>(self: STM.STM<R, E, A>, pf: (a: A) => Option.Option<A2>) => STM.STM<R, E, A2>
+  <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>
 >(2, (self, pf) =>
   collectSTM(
     self,
@@ -296,14 +287,14 @@ export const collect = dual<
 /** @internal */
 export const collectSTM = dual<
   <A, R2, E2, A2>(
-    pf: (a: A) => Option.Option<STM.STM<R2, E2, A2>>
+    pf: (a: A) => Option.Option<STM.STM<A2, E2, R2>>
   ) => <R, E>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E2 | E, A2>,
+    self: STM.STM<A, E, R>
+  ) => STM.STM<A2, E2 | E, R2 | R>,
   <R, E, A, R2, E2, A2>(
-    self: STM.STM<R, E, A>,
-    pf: (a: A) => Option.Option<STM.STM<R2, E2, A2>>
-  ) => STM.STM<R2 | R, E2 | E, A2>
+    self: STM.STM<A, E, R>,
+    pf: (a: A) => Option.Option<STM.STM<A2, E2, R2>>
+  ) => STM.STM<A2, E2 | E, R2 | R>
 >(2, (self, pf) =>
   core.matchSTM(self, {
     onFailure: core.fail,
@@ -314,41 +305,41 @@ export const collectSTM = dual<
   }))
 
 /** @internal */
-export const commitEither = <R, E, A>(self: STM.STM<R, E, A>): Effect.Effect<R, E, A> =>
+export const commitEither = <A, E, R>(self: STM.STM<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.flatten(core.commit(either(self)))
 
 /** @internal */
-export const cond = <E, A>(
+export const cond = <A, E>(
   predicate: LazyArg<boolean>,
   error: LazyArg<E>,
   result: LazyArg<A>
-): STM.STM<never, E, A> => {
+): STM.STM<A, E> => {
   return suspend(
     () => predicate() ? core.sync(result) : core.failSync(error)
   )
 }
 
 /** @internal */
-export const either = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, Either.Either<E, A>> =>
+export const either = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<Either.Either<E, A>, never, R> =>
   match(self, { onFailure: Either.left, onSuccess: Either.right })
 
 /** @internal */
-export const eventually = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, E, A> =>
+export const eventually = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<A, E, R> =>
   core.matchSTM(self, { onFailure: () => eventually(self), onSuccess: core.succeed })
 
 /** @internal */
 export const every = dual<
-  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<R, E, boolean>) => (iterable: Iterable<A>) => STM.STM<R, E, boolean>,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>) => STM.STM<R, E, boolean>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<boolean, E, R>) => (iterable: Iterable<A>) => STM.STM<boolean, E, R>,
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>) => STM.STM<boolean, E, R>
 >(
   2,
   <A, R, E>(
     iterable: Iterable<A>,
-    predicate: (a: A) => STM.STM<R, E, boolean>
-  ): STM.STM<R, E, boolean> =>
+    predicate: (a: A) => STM.STM<boolean, E, R>
+  ): STM.STM<boolean, E, R> =>
     pipe(
       core.flatMap(core.sync(() => iterable[Symbol.iterator]()), (iterator) => {
-        const loop: STM.STM<R, E, boolean> = suspend(() => {
+        const loop: STM.STM<boolean, E, R> = suspend(() => {
           const next = iterator.next()
           if (next.done) {
             return core.succeed(true)
@@ -365,13 +356,13 @@ export const every = dual<
 
 /** @internal */
 export const exists = dual<
-  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<R, E, boolean>) => (iterable: Iterable<A>) => STM.STM<R, E, boolean>,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>) => STM.STM<R, E, boolean>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<boolean, E, R>) => (iterable: Iterable<A>) => STM.STM<boolean, E, R>,
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>) => STM.STM<boolean, E, R>
 >(
   2,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>): STM.STM<R, E, boolean> =>
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>): STM.STM<boolean, E, R> =>
     core.flatMap(core.sync(() => iterable[Symbol.iterator]()), (iterator) => {
-      const loop: STM.STM<R, E, boolean> = suspend(() => {
+      const loop: STM.STM<boolean, E, R> = suspend(() => {
         const next = iterator.next()
         if (next.done) {
           return core.succeed(false)
@@ -386,17 +377,15 @@ export const exists = dual<
 )
 
 /** @internal */
-export const fiberId: STM.STM<never, never, FiberId.FiberId> = core.effect<never, FiberId.FiberId>((_, fiberId) =>
-  fiberId
-)
+export const fiberId: STM.STM<FiberId.FiberId> = core.effect<never, FiberId.FiberId>((_, fiberId) => fiberId)
 
 /** @internal */
 export const filter = dual<
-  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<R, E, boolean>) => (iterable: Iterable<A>) => STM.STM<R, E, Array<A>>,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>) => STM.STM<R, E, Array<A>>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<boolean, E, R>) => (iterable: Iterable<A>) => STM.STM<Array<A>, E, R>,
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>) => STM.STM<Array<A>, E, R>
 >(
   2,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>): STM.STM<R, E, Array<A>> =>
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>): STM.STM<Array<A>, E, R> =>
     Array.from(iterable).reduce(
       (acc, curr) =>
         pipe(
@@ -409,17 +398,17 @@ export const filter = dual<
             return as
           })
         ),
-      core.succeed([]) as STM.STM<R, E, Array<A>>
+      core.succeed([]) as STM.STM<Array<A>, E, R>
     )
 )
 
 /** @internal */
 export const filterNot = dual<
-  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<R, E, boolean>) => (iterable: Iterable<A>) => STM.STM<R, E, Array<A>>,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>) => STM.STM<R, E, Array<A>>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM.STM<boolean, E, R>) => (iterable: Iterable<A>) => STM.STM<Array<A>, E, R>,
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>) => STM.STM<Array<A>, E, R>
 >(
   2,
-  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<R, E, boolean>): STM.STM<R, E, Array<A>> =>
+  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM.STM<boolean, E, R>): STM.STM<Array<A>, E, R> =>
     filter(iterable, (a) => negate(predicate(a)))
 )
 
@@ -428,20 +417,20 @@ export const filterOrDie: {
   <A, B extends A>(
     refinement: Refinement<NoInfer<A>, B>,
     defect: LazyArg<unknown>
-  ): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, B>
+  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>
   <A>(
     predicate: Predicate<NoInfer<A>>,
     defect: LazyArg<unknown>
-  ): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A>
+  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E, R>
   <R, E, A, B extends A>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     refinement: Refinement<A, B>,
     defect: LazyArg<unknown>
-  ): STM.STM<R, E, B>
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM.STM<R, E, A>
+  ): STM.STM<B, E, R>
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM.STM<A, E, R>
 } = dual(
   3,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM.STM<R, E, A> =>
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM.STM<A, E, R> =>
     filterOrElse(self, predicate, () => core.dieSync(defect))
 )
 
@@ -450,13 +439,13 @@ export const filterOrDieMessage: {
   <A, B extends A>(
     refinement: Refinement<NoInfer<A>, B>,
     message: string
-  ): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, B>
-  <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A>
-  <R, E, A, B extends A>(self: STM.STM<R, E, A>, refinement: Refinement<A, B>, message: string): STM.STM<R, E, B>
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>, message: string): STM.STM<R, E, A>
+  ): <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>
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>, message: string): STM.STM<A, E, R>
 } = dual(
   3,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>, message: string): STM.STM<R, E, A> =>
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>, message: string): STM.STM<A, E, R> =>
     filterOrElse(self, predicate, () => core.dieMessage(message))
 )
 
@@ -464,30 +453,30 @@ export const filterOrDieMessage: {
 export const filterOrElse: {
   <A, B extends A, R2, E2, C>(
     refinement: Refinement<NoInfer<A>, B>,
-    orElse: (a: NoInfer<A>) => STM.STM<R2, E2, C>
-  ): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R2 | R, E2 | E, B | C>
+    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>(
     predicate: Predicate<NoInfer<A>>,
-    orElse: (a: NoInfer<A>) => STM.STM<R2, E2, B>
-  ): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R2 | R, E2 | E, A | B>
+    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>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     refinement: Refinement<A, B>,
-    orElse: (a: A) => STM.STM<R2, E2, C>
-  ): STM.STM<R | R2, E | E2, B | C>
+    orElse: (a: A) => STM.STM<C, E2, R2>
+  ): STM.STM<B | C, E | E2, R | R2>
   <R, E, A, R2, E2, B>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     predicate: Predicate<A>,
-    orElse: (a: A) => STM.STM<R2, E2, B>
-  ): STM.STM<R | R2, E | E2, A | B>
+    orElse: (a: A) => STM.STM<B, E2, R2>
+  ): STM.STM<A | B, E | E2, R | R2>
 } = dual(
   3,
   <R, E, A, R2, E2, B>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     predicate: Predicate<A>,
-    orElse: (a: A) => STM.STM<R2, E2, B>
-  ): STM.STM<R | R2, E | E2, A | B> =>
-    core.flatMap(self, (a): STM.STM<R2, E2, A | B> => predicate(a) ? core.succeed(a) : orElse(a))
+    orElse: (a: A) => STM.STM<B, E2, R2>
+  ): STM.STM<A | B, E | E2, R | R2> =>
+    core.flatMap(self, (a): STM.STM<A | B, E2, R2> => predicate(a) ? core.succeed(a) : orElse(a))
 )
 
 /** @internal */
@@ -495,20 +484,20 @@ export const filterOrFail: {
   <A, B extends A, E2>(
     refinement: Refinement<NoInfer<A>, B>,
     orFailWith: (a: NoInfer<A>) => E2
-  ): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E2 | E, B>
+  ): <R, E>(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<R, E, A>) => STM.STM<R, E2 | E, A>
+  ): <R, E>(self: STM.STM<A, E, R>) => STM.STM<A, E2 | E, R>
   <R, E, A, B extends A, E2>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     refinement: Refinement<A, B>,
     orFailWith: (a: A) => E2
-  ): STM.STM<R, E | E2, B>
-  <R, E, A, E2>(self: STM.STM<R, E, A>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<R, E | E2, A>
+  ): 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>
 } = dual(
   3,
-  <R, E, A, E2>(self: STM.STM<R, E, A>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<R, E | E2, A> =>
+  <R, E, A, E2>(self: STM.STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM.STM<A, E | E2, R> =>
     filterOrElse(
       self,
       predicate,
@@ -517,24 +506,24 @@ export const filterOrFail: {
 )
 
 /** @internal */
-export const flatten = <R, E, R2, E2, A>(self: STM.STM<R, E, STM.STM<R2, E2, A>>): STM.STM<R | R2, E | E2, A> =>
+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> =>
   core.flatMap(self, identity)
 
 /** @internal */
-export const flip = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, A, E> =>
+export const flip = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<E, A, R> =>
   core.matchSTM(self, { onFailure: core.succeed, onSuccess: core.fail })
 
 /** @internal */
 export const flipWith = dual<
   <R, A, E, R2, A2, E2>(
-    f: (stm: STM.STM<R, A, E>) => STM.STM<R2, A2, E2>
+    f: (stm: STM.STM<E, A, R>) => STM.STM<E2, A2, R2>
   ) => (
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R | R2, E | E2, A | A2>,
+    self: STM.STM<A, E, R>
+  ) => STM.STM<A | A2, E | E2, R | R2>,
   <R, A, E, R2, A2, E2>(
-    self: STM.STM<R, E, A>,
-    f: (stm: STM.STM<R, A, E>) => STM.STM<R2, A2, E2>
-  ) => STM.STM<R | R2, E | E2, A | A2>
+    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>
 >(2, (self, f) => flip(f(flip(self))))
 
 /** @internal */
@@ -542,11 +531,11 @@ export const match = dual<
   <E, A2, A, A3>(options: {
     readonly onFailure: (error: E) => A2
     readonly onSuccess: (value: A) => A3
-  }) => <R>(self: STM.STM<R, E, A>) => STM.STM<R, never, A2 | A3>,
-  <R, E, A2, A, A3>(self: STM.STM<R, E, A>, options: {
+  }) => <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: {
     readonly onFailure: (error: E) => A2
     readonly onSuccess: (value: A) => A3
-  }) => STM.STM<R, never, A2 | A3>
+  }) => STM.STM<A2 | A3, never, R>
 >(2, (self, { onFailure, onSuccess }) =>
   core.matchSTM(self, {
     onFailure: (e) => core.succeed(onFailure(e)),
@@ -556,31 +545,31 @@ export const match = dual<
 /** @internal */
 export const forEach = dual<
   {
-    <A, R, E, A2>(f: (a: A) => STM.STM<R, E, A2>, options?: {
+    <A, R, E, A2>(f: (a: A) => STM.STM<A2, E, R>, options?: {
       readonly discard?: false | undefined
-    }): (elements: Iterable<A>) => STM.STM<R, E, Array<A2>>
-    <A, R, E, A2>(f: (a: A) => STM.STM<R, E, A2>, options: {
+    }): (elements: Iterable<A>) => STM.STM<Array<A2>, E, R>
+    <A, R, E, A2>(f: (a: A) => STM.STM<A2, E, R>, options: {
       readonly discard: true
-    }): (elements: Iterable<A>) => STM.STM<R, E, void>
+    }): (elements: Iterable<A>) => STM.STM<void, E, R>
   },
   {
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM.STM<R, E, A2>, options?: {
+    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options?: {
       readonly discard?: false | undefined
-    }): STM.STM<R, E, Array<A2>>
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM.STM<R, E, A2>, options: {
+    }): STM.STM<Array<A2>, E, R>
+    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options: {
       readonly discard: true
-    }): STM.STM<R, E, void>
+    }): STM.STM<void, E, R>
   }
 >(
   (args) => predicate.isIterable(args[0]),
-  <A, R, E, A2>(iterable: Iterable<A>, f: (a: A) => STM.STM<R, E, A2>, options?: {
+  <A, R, E, A2>(iterable: Iterable<A>, f: (a: A) => STM.STM<A2, E, R>, options?: {
     readonly discard?: boolean | undefined
-  }): STM.STM<R, E, any> => {
+  }): STM.STM<any, E, R> => {
     if (options?.discard) {
       return pipe(
         core.sync(() => iterable[Symbol.iterator]()),
         core.flatMap((iterator) => {
-          const loop: STM.STM<R, E, void> = suspend(() => {
+          const loop: STM.STM<void, E, R> = suspend(() => {
             const next = iterator.next()
             if (next.done) {
               return unit
@@ -599,14 +588,14 @@ export const forEach = dual<
             array.push(elem)
             return array
           }),
-        core.succeed([]) as STM.STM<R, E, Array<A2>>
+        core.succeed([]) as STM.STM<Array<A2>, E, R>
       )
     )
   }
 )
 
 /** @internal */
-export const fromEither = <E, A>(either: Either.Either<E, A>): STM.STM<never, E, A> => {
+export const fromEither = <E, A>(either: Either.Either<E, A>): STM.STM<A, E> => {
   switch (either._tag) {
     case "Left": {
       return core.fail(either.left)
@@ -618,7 +607,7 @@ export const fromEither = <E, A>(either: Either.Either<E, A>): STM.STM<never, E,
 }
 
 /** @internal */
-export const fromOption = <A>(option: Option.Option<A>): STM.STM<never, Option.Option<never>, A> =>
+export const fromOption = <A>(option: Option.Option<A>): STM.STM<A, Option.Option<never>> =>
   Option.match(option, {
     onNone: () => core.fail(Option.none()),
     onSome: core.succeed
@@ -661,7 +650,7 @@ export const gen: typeof STM.gen = (f) =>
   })
 
 /** @internal */
-export const head = <R, E, A>(self: STM.STM<R, E, Iterable<A>>): STM.STM<R, Option.Option<E>, A> =>
+export const head = <A, E, R>(self: STM.STM<Iterable<A>, E, R>): STM.STM<A, Option.Option<E>, R> =>
   pipe(
     self,
     core.matchSTM({
@@ -682,55 +671,55 @@ export const head = <R, E, A>(self: STM.STM<R, E, Iterable<A>>): STM.STM<R, Opti
 export const if_ = dual<
   <R1, R2, E1, E2, A, A1>(
     options: {
-      readonly onTrue: STM.STM<R1, E1, A>
-      readonly onFalse: STM.STM<R2, E2, A1>
+      readonly onTrue: STM.STM<A, E1, R1>
+      readonly onFalse: STM.STM<A1, E2, R2>
     }
   ) => <R = never, E = never>(
-    self: STM.STM<R, E, boolean> | boolean
-  ) => STM.STM<R1 | R2 | R, E1 | E2 | E, A | A1>,
+    self: STM.STM<boolean, E, R> | boolean
+  ) => STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R>,
   {
     <R, E, R1, R2, E1, E2, A, A1>(
       self: boolean,
       options: {
-        readonly onTrue: STM.STM<R1, E1, A>
-        readonly onFalse: STM.STM<R2, E2, A1>
+        readonly onTrue: STM.STM<A, E1, R1>
+        readonly onFalse: STM.STM<A1, E2, R2>
       }
-    ): STM.STM<R1 | R2 | R, E1 | E2 | E, A | A1>
+    ): STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R>
     <R, E, R1, R2, E1, E2, A, A1>(
-      self: STM.STM<R, E, boolean>,
+      self: STM.STM<boolean, E, R>,
       options: {
-        readonly onTrue: STM.STM<R1, E1, A>
-        readonly onFalse: STM.STM<R2, E2, A1>
+        readonly onTrue: STM.STM<A, E1, R1>
+        readonly onFalse: STM.STM<A1, E2, R2>
       }
-    ): STM.STM<R1 | R2 | R, E1 | E2 | E, A | A1>
+    ): STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R>
   }
 >(
   (args) => typeof args[0] === "boolean" || core.isSTM(args[0]),
   <R, E, R1, R2, E1, E2, A, A1>(
-    self: STM.STM<R, E, boolean> | boolean,
+    self: STM.STM<boolean, E, R> | boolean,
     { onFalse, onTrue }: {
-      readonly onTrue: STM.STM<R1, E1, A>
-      readonly onFalse: STM.STM<R2, E2, A1>
+      readonly onTrue: STM.STM<A, E1, R1>
+      readonly onFalse: STM.STM<A1, E2, R2>
     }
   ) => {
     if (typeof self === "boolean") {
       return self ? onTrue : onFalse
     }
 
-    return core.flatMap(self, (bool): STM.STM<R1 | R2 | R, E1 | E2 | E, A | A1> => bool ? onTrue : onFalse)
+    return core.flatMap(self, (bool): STM.STM<A | A1, E1 | E2 | E, R1 | R2 | R> => bool ? onTrue : onFalse)
   }
 )
 
 /** @internal */
-export const ignore = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, void> =>
+export const ignore = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<void, never, R> =>
   match(self, { onFailure: () => unit, onSuccess: () => unit })
 
 /** @internal */
-export const isFailure = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, boolean> =>
+export const isFailure = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<boolean, never, R> =>
   match(self, { onFailure: constTrue, onSuccess: constFalse })
 
 /** @internal */
-export const isSuccess = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, boolean> =>
+export const isSuccess = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<boolean, never, R> =>
   match(self, { onFailure: constFalse, onSuccess: constTrue })
 
 /** @internal */
@@ -738,15 +727,15 @@ export const iterate = <R, E, Z>(
   initial: Z,
   options: {
     readonly while: (z: Z) => boolean
-    readonly body: (z: Z) => STM.STM<R, E, Z>
+    readonly body: (z: Z) => STM.STM<Z, E, R>
   }
-): STM.STM<R, E, Z> => iterateLoop(initial, options.while, options.body)
+): STM.STM<Z, E, R> => iterateLoop(initial, options.while, options.body)
 
 const iterateLoop = <R, E, Z>(
   initial: Z,
   cont: (z: Z) => boolean,
-  body: (z: Z) => STM.STM<R, E, Z>
-): STM.STM<R, E, Z> => {
+  body: (z: Z) => STM.STM<Z, E, R>
+): STM.STM<Z, E, R> => {
   if (cont(initial)) {
     return pipe(
       body(initial),
@@ -763,28 +752,28 @@ export const loop: {
     options: {
       readonly while: (z: Z) => boolean
       readonly step: (z: Z) => Z
-      readonly body: (z: Z) => STM.STM<R, E, A>
+      readonly body: (z: Z) => STM.STM<A, E, R>
       readonly discard?: false | undefined
     }
-  ): STM.STM<R, E, Array<A>>
+  ): STM.STM<Array<A>, E, R>
   <Z, R, E, A>(
     initial: Z,
     options: {
       readonly while: (z: Z) => boolean
       readonly step: (z: Z) => Z
-      readonly body: (z: Z) => STM.STM<R, E, A>
+      readonly body: (z: Z) => STM.STM<A, E, R>
       readonly discard: true
     }
-  ): STM.STM<R, E, void>
+  ): STM.STM<void, E, R>
 } = <Z, R, E, A>(
   initial: Z,
   options: {
     readonly while: (z: Z) => boolean
     readonly step: (z: Z) => Z
-    readonly body: (z: Z) => STM.STM<R, E, A>
+    readonly body: (z: Z) => STM.STM<A, E, R>
     readonly discard?: boolean | undefined
   }
-): STM.STM<R, E, any> =>
+): STM.STM<any, E, R> =>
   options.discard ?
     loopDiscardLoop(initial, options.while, options.step, options.body) :
     core.map(loopLoop(initial, options.while, options.step, options.body), (a) => Array.from(a))
@@ -793,8 +782,8 @@ const loopLoop = <Z, R, E, A>(
   initial: Z,
   cont: (z: Z) => boolean,
   inc: (z: Z) => Z,
-  body: (z: Z) => STM.STM<R, E, A>
-): STM.STM<R, E, Chunk.Chunk<A>> => {
+  body: (z: Z) => STM.STM<A, E, R>
+): STM.STM<Chunk.Chunk<A>, E, R> => {
   if (cont(initial)) {
     return pipe(
       body(initial),
@@ -808,8 +797,8 @@ const loopDiscardLoop = <Z, R, E, X>(
   initial: Z,
   cont: (z: Z) => boolean,
   inc: (z: Z) => Z,
-  body: (z: Z) => STM.STM<R, E, X>
-): STM.STM<R, E, void> => {
+  body: (z: Z) => STM.STM<X, E, R>
+): STM.STM<void, E, R> => {
   if (cont(initial)) {
     return pipe(
       body(initial),
@@ -821,9 +810,9 @@ const loopDiscardLoop = <Z, R, E, X>(
 
 /** @internal */
 export const mapAttempt = dual<
-  <A, B>(f: (a: A) => B) => <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, unknown, B>,
-  <R, E, A, B>(self: STM.STM<R, E, A>, f: (a: A) => B) => STM.STM<R, unknown, B>
->(2, <R, E, A, B>(self: STM.STM<R, E, A>, f: (a: A) => B): STM.STM<R, unknown, B> =>
+  <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> =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(e),
     onSuccess: (a) => attempt(() => f(a))
@@ -834,11 +823,11 @@ export const mapBoth = dual<
   <E, E2, A, A2>(options: {
     readonly onFailure: (error: E) => E2
     readonly onSuccess: (value: A) => A2
-  }) => <R>(self: STM.STM<R, E, A>) => STM.STM<R, E2, A2>,
-  <R, E, E2, A, A2>(self: STM.STM<R, E, A>, options: {
+  }) => <R>(self: STM.STM<A, E, R>) => STM.STM<A2, E2, R>,
+  <R, E, E2, A, A2>(self: STM.STM<A, E, R>, options: {
     readonly onFailure: (error: E) => E2
     readonly onSuccess: (value: A) => A2
-  }) => STM.STM<R, E2, A2>
+  }) => STM.STM<A2, E2, R>
 >(2, (self, { onFailure, onSuccess }) =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(onFailure(e)),
@@ -847,8 +836,8 @@ export const mapBoth = dual<
 
 /** @internal */
 export const mapError = dual<
-  <E, E2>(f: (error: E) => E2) => <R, A>(self: STM.STM<R, E, A>) => STM.STM<R, E2, A>,
-  <R, A, E, E2>(self: STM.STM<R, E, A>, f: (error: E) => E2) => STM.STM<R, E2, A>
+  <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>
 >(2, (self, f) =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(f(e)),
@@ -856,29 +845,29 @@ export const mapError = dual<
   }))
 
 /** @internal */
-export const merge = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, E | A> =>
+export const merge = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<E | A, never, R> =>
   core.matchSTM(self, { onFailure: (e) => core.succeed(e), onSuccess: core.succeed })
 
 /** @internal */
 export const mergeAll = dual<
-  <A2, A>(zero: A2, f: (a2: A2, a: A) => A2) => <R, E>(iterable: Iterable<STM.STM<R, E, A>>) => STM.STM<R, E, A2>,
-  <R, E, A2, A>(iterable: Iterable<STM.STM<R, E, A>>, zero: A2, f: (a2: A2, a: A) => A2) => STM.STM<R, E, A2>
+  <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>
 >(
   3,
-  <R, E, A2, A>(iterable: Iterable<STM.STM<R, E, A>>, zero: A2, f: (a2: A2, a: A) => A2): STM.STM<R, E, A2> =>
+  <R, E, A2, A>(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)),
-        core.succeed(zero) as STM.STM<R, E, A2>
+        core.succeed(zero) as STM.STM<A2, E, R>
       )
     )
 )
 
 /** @internal */
-export const negate = <R, E>(self: STM.STM<R, E, boolean>): STM.STM<R, E, boolean> => pipe(self, core.map((b) => !b))
+export const negate = <R, E>(self: STM.STM<boolean, E, R>): STM.STM<boolean, E, R> => pipe(self, core.map((b) => !b))
 
 /** @internal */
-export const none = <R, E, A>(self: STM.STM<R, E, Option.Option<A>>): STM.STM<R, Option.Option<E>, void> =>
+export const none = <A, E, R>(self: STM.STM<Option.Option<A>, E, R>): STM.STM<void, Option.Option<E>, R> =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(Option.some(e)),
     onSuccess: Option.match({
@@ -888,25 +877,25 @@ export const none = <R, E, A>(self: STM.STM<R, E, Option.Option<A>>): STM.STM<R,
   })
 
 /** @internal */
-export const option = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, Option.Option<A>> =>
+export const option = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<Option.Option<A>, never, R> =>
   match(self, { onFailure: () => Option.none(), onSuccess: Option.some })
 
 /** @internal */
-export const orDie = <R, E, A>(self: STM.STM<R, E, A>): STM.STM<R, never, A> => pipe(self, orDieWith(identity))
+export const orDie = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<A, never, R> => pipe(self, orDieWith(identity))
 
 /** @internal */
 export const orDieWith = dual<
-  <E>(f: (error: E) => unknown) => <R, A>(self: STM.STM<R, E, A>) => STM.STM<R, never, A>,
-  <R, A, E>(self: STM.STM<R, E, A>, f: (error: E) => unknown) => STM.STM<R, never, A>
+  <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>
 >(2, (self, f) => pipe(self, mapError(f), core.catchAll(core.die)))
 
 /** @internal */
 export const orElse = dual<
-  <R2, E2, A2>(that: LazyArg<STM.STM<R2, E2, A2>>) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R2 | R, E2, A2 | A>,
-  <R, E, A, R2, E2, A2>(self: STM.STM<R, E, A>, that: LazyArg<STM.STM<R2, E2, A2>>) => STM.STM<R2 | R, E2, A2 | A>
+  <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>
 >(
   2,
-  <R, E, A, R2, E2, A2>(self: STM.STM<R, E, A>, that: LazyArg<STM.STM<R2, E2, A2>>): STM.STM<R2 | R, E2, A2 | A> =>
+  <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> =>
     core.flatMap(core.effect<R, LazyArg<void>>((journal) => Journal.prepareResetJournal(journal)), (reset) =>
       pipe(
         core.orTry(self, () => core.flatMap(core.sync(reset), that)),
@@ -917,50 +906,50 @@ export const orElse = dual<
 /** @internal */
 export const orElseEither = dual<
   <R2, E2, A2>(
-    that: LazyArg<STM.STM<R2, E2, A2>>
-  ) => <R, E, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E2, Either.Either<A, A2>>,
+    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>(
-    self: STM.STM<R, E, A>,
-    that: LazyArg<STM.STM<R2, E2, A2>>
-  ) => STM.STM<R2 | R, E2, Either.Either<A, A2>>
+    self: STM.STM<A, E, R>,
+    that: LazyArg<STM.STM<A2, E2, R2>>
+  ) => STM.STM<Either.Either<A, A2>, E2, R2 | R>
 >(
   2,
   <R, E, A, R2, E2, A2>(
-    self: STM.STM<R, E, A>,
-    that: LazyArg<STM.STM<R2, E2, A2>>
-  ): STM.STM<R2 | R, E2, Either.Either<A, A2>> =>
+    self: STM.STM<A, E, R>,
+    that: LazyArg<STM.STM<A2, E2, R2>>
+  ): STM.STM<Either.Either<A, A2>, E2, R2 | R> =>
     orElse(core.map(self, Either.left), () => core.map(that(), Either.right))
 )
 
 /** @internal */
 export const orElseFail = dual<
-  <E2>(error: LazyArg<E2>) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, E2, A>,
-  <R, E, A, E2>(self: STM.STM<R, E, A>, error: LazyArg<E2>) => STM.STM<R, E2, A>
+  <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>
 >(
   2,
-  <R, E, A, E2>(self: STM.STM<R, E, A>, error: LazyArg<E2>): STM.STM<R, E2, A> =>
+  <R, E, A, 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>(
-    that: LazyArg<STM.STM<R2, Option.Option<E2>, A2>>
-  ) => <R, E, A>(
-    self: STM.STM<R, Option.Option<E>, A>
-  ) => STM.STM<R2 | R, Option.Option<E2 | E>, A2 | A>,
+    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>(
-    self: STM.STM<R, Option.Option<E>, A>,
-    that: LazyArg<STM.STM<R2, Option.Option<E2>, A2>>
-  ) => STM.STM<R2 | R, Option.Option<E2 | E>, A2 | A>
+    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>(
-    self: STM.STM<R, Option.Option<E>, A>,
-    that: LazyArg<STM.STM<R2, Option.Option<E2>, A2>>
-  ): STM.STM<R2 | R, Option.Option<E2 | E>, A2 | A> =>
+    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> =>
     core.catchAll(
       self,
       Option.match({
@@ -972,28 +961,28 @@ export const orElseOptional = dual<
 
 /** @internal */
 export const orElseSucceed = dual<
-  <A2>(value: LazyArg<A2>) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, never, A2 | A>,
-  <R, E, A, A2>(self: STM.STM<R, E, A>, value: LazyArg<A2>) => STM.STM<R, never, A2 | A>
+  <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>
 >(
   2,
-  <R, E, A, A2>(self: STM.STM<R, E, A>, value: LazyArg<A2>): STM.STM<R, never, A2 | A> =>
+  <R, E, A, A2>(self: STM.STM<A, E, R>, value: LazyArg<A2>): STM.STM<A2 | A, never, R> =>
     orElse(self, () => core.sync(value))
 )
 
 /** @internal */
 export const provideContext = dual<
-  <R>(env: Context.Context<R>) => <E, A>(self: STM.STM<R, E, A>) => STM.STM<never, E, A>,
-  <E, A, R>(self: STM.STM<R, E, A>, env: Context.Context<R>) => STM.STM<never, E, A>
+  <R>(env: Context.Context<R>) => <A, E>(self: STM.STM<A, E, R>) => STM.STM<A, E>,
+  <A, E, R>(self: STM.STM<A, E, R>, env: Context.Context<R>) => STM.STM<A, E>
 >(2, (self, env) => core.mapInputContext(self, (_: Context.Context<never>) => env))
 
 /** @internal */
 export const provideSomeContext = dual<
-  <R>(context: Context.Context<R>) => <R1, E, A>(self: STM.STM<R1, E, A>) => STM.STM<Exclude<R1, R>, E, A>,
-  <R, R1, E, A>(self: STM.STM<R1, E, A>, context: Context.Context<R>) => STM.STM<Exclude<R1, R>, E, A>
+  <R>(context: Context.Context<R>) => <R1, E, A>(self: STM.STM<A, E, R1>) => STM.STM<A, E, Exclude<R1, R>>,
+  <R, R1, E, A>(self: STM.STM<A, E, R1>, context: Context.Context<R>) => STM.STM<A, E, Exclude<R1, R>>
 >(2, <R, R1, E, A>(
-  self: STM.STM<R1, E, A>,
+  self: STM.STM<A, E, R1>,
   context: Context.Context<R>
-): STM.STM<Exclude<R1, R>, E, A> =>
+): STM.STM<A, E, Exclude<R1, R>> =>
   core.mapInputContext(
     self,
     (parent: Context.Context<Exclude<R1, R>>): Context.Context<R1> => Context.merge(parent, context) as any
@@ -1004,34 +993,34 @@ export const provideService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     resource: Context.Tag.Service<T>
-  ) => <R, E, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<Exclude<R, Context.Tag.Identifier<T>>, E, A>,
+  ) => <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>>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     tag: T,
     resource: Context.Tag.Service<T>
-  ) => STM.STM<Exclude<R, Context.Tag.Identifier<T>>, E, A>
+  ) => STM.STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>
 >(3, (self, tag, resource) => provideServiceSTM(self, tag, core.succeed(resource)))
 
 /** @internal */
 export const provideServiceSTM = dual<
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
-    stm: STM.STM<R1, E1, Context.Tag.Service<T>>
-  ) => <R, E, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A>,
+    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>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     tag: T,
-    stm: STM.STM<R1, E1, Context.Tag.Service<T>>
-  ) => STM.STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A>
+    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>(
-  self: STM.STM<R, E, A>,
+  self: STM.STM<A, E, R>,
   tag: T,
-  stm: STM.STM<R1, E1, Context.Tag.Service<T>>
-): STM.STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A> =>
+  stm: STM.STM<Context.Tag.Service<T>, E1, R1>
+): STM.STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>> =>
   core.contextWithSTM((env: Context.Context<R1 | Exclude<R, Context.Tag.Identifier<T>>>) =>
     core.flatMap(
       stm,
@@ -1045,15 +1034,15 @@ export const provideServiceSTM = dual<
 
 /** @internal */
 export const reduce = dual<
-  <S, A, R, E>(zero: S, f: (s: S, a: A) => STM.STM<R, E, S>) => (iterable: Iterable<A>) => STM.STM<R, E, S>,
-  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<R, E, S>) => STM.STM<R, E, S>
+  <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>
 >(
   3,
-  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<R, E, S>): STM.STM<R, E, S> =>
+  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<S, E, R>): STM.STM<S, E, R> =>
     suspend(() =>
       Array.from(iterable).reduce(
         (acc, curr) => pipe(acc, core.flatMap((s) => f(s, curr))),
-        core.succeed(zero) as STM.STM<R, E, S>
+        core.succeed(zero) as STM.STM<S, E, R>
       )
     )
 )
@@ -1061,47 +1050,47 @@ export const reduce = dual<
 /** @internal */
 export const reduceAll = dual<
   <R2, E2, A>(
-    initial: STM.STM<R2, E2, A>,
+    initial: STM.STM<A, E2, R2>,
     f: (x: A, y: A) => A
   ) => <R, E>(
-    iterable: Iterable<STM.STM<R, E, A>>
-  ) => STM.STM<R2 | R, E2 | E, A>,
+    iterable: Iterable<STM.STM<A, E, R>>
+  ) => STM.STM<A, E2 | E, R2 | R>,
   <R, E, R2, E2, A>(
-    iterable: Iterable<STM.STM<R, E, A>>,
-    initial: STM.STM<R2, E2, A>,
+    iterable: Iterable<STM.STM<A, E, R>>,
+    initial: STM.STM<A, E2, R2>,
     f: (x: A, y: A) => A
-  ) => STM.STM<R2 | R, E2 | E, A>
+  ) => STM.STM<A, E2 | E, R2 | R>
 >(3, <R, E, R2, E2, A>(
-  iterable: Iterable<STM.STM<R, E, A>>,
-  initial: STM.STM<R2, E2, A>,
+  iterable: Iterable<STM.STM<A, E, R>>,
+  initial: STM.STM<A, E2, R2>,
   f: (x: A, y: A) => A
-): STM.STM<R2 | R, E2 | E, A> =>
+): STM.STM<A, E2 | E, R2 | R> =>
   suspend(() =>
     Array.from(iterable).reduce(
       (acc, curr) => pipe(acc, core.zipWith(curr, f)),
-      initial as STM.STM<R | R2, E | E2, A>
+      initial as STM.STM<A, E | E2, R | R2>
     )
   ))
 
 /** @internal */
 export const reduceRight = dual<
-  <S, A, R, E>(zero: S, f: (s: S, a: A) => STM.STM<R, E, S>) => (iterable: Iterable<A>) => STM.STM<R, E, S>,
-  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<R, E, S>) => STM.STM<R, E, S>
+  <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>
 >(
   3,
-  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<R, E, S>): STM.STM<R, E, S> =>
+  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM.STM<S, E, R>): STM.STM<S, E, R> =>
     suspend(() =>
       Array.from(iterable).reduceRight(
         (acc, curr) => pipe(acc, core.flatMap((s) => f(s, curr))),
-        core.succeed(zero) as STM.STM<R, E, S>
+        core.succeed(zero) as STM.STM<S, E, R>
       )
     )
 )
 
 /** @internal */
 export const refineOrDie = dual<
-  <E, E2>(pf: (error: E) => Option.Option<E2>) => <R, A>(self: STM.STM<R, E, A>) => STM.STM<R, E2, A>,
-  <R, A, E, E2>(self: STM.STM<R, E, A>, pf: (error: E) => Option.Option<E2>) => STM.STM<R, E2, A>
+  <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>
 >(2, (self, pf) => refineOrDieWith(self, pf, identity))
 
 /** @internal */
@@ -1110,13 +1099,13 @@ export const refineOrDieWith = dual<
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
   ) => <R, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R, E2, A>,
+    self: STM.STM<A, E, R>
+  ) => STM.STM<A, E2, R>,
   <R, A, E, E2>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
-  ) => STM.STM<R, E2, A>
+  ) => STM.STM<A, E2, R>
 >(3, (self, pf, f) =>
   core.catchAll(
     self,
@@ -1129,8 +1118,8 @@ export const refineOrDieWith = dual<
 
 /** @internal */
 export const reject = dual<
-  <A, E2>(pf: (a: A) => Option.Option<E2>) => <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E2 | E, A>,
-  <R, E, A, E2>(self: STM.STM<R, E, A>, pf: (a: A) => Option.Option<E2>) => STM.STM<R, E2 | E, A>
+  <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>
 >(2, (self, pf) =>
   rejectSTM(
     self,
@@ -1140,14 +1129,14 @@ export const reject = dual<
 /** @internal */
 export const rejectSTM = dual<
   <A, R2, E2>(
-    pf: (a: A) => Option.Option<STM.STM<R2, E2, E2>>
+    pf: (a: A) => Option.Option<STM.STM<E2, E2, R2>>
   ) => <R, E>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E2 | E, A>,
+    self: STM.STM<A, E, R>
+  ) => STM.STM<A, E2 | E, R2 | R>,
   <R, E, A, R2, E2>(
-    self: STM.STM<R, E, A>,
-    pf: (a: A) => Option.Option<STM.STM<R2, E2, E2>>
-  ) => STM.STM<R2 | R, E2 | E, A>
+    self: STM.STM<A, E, R>,
+    pf: (a: A) => Option.Option<STM.STM<E2, E2, R2>>
+  ) => STM.STM<A, E2 | E, R2 | R>
 >(2, (self, pf) =>
   core.flatMap(self, (a) =>
     Option.match(pf(a), {
@@ -1157,11 +1146,11 @@ export const rejectSTM = dual<
 
 /** @internal */
 export const repeatUntil = dual<
-  <A>(predicate: Predicate<A>) => <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A>,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>) => STM.STM<R, E, A>
+  <A>(predicate: Predicate<A>) => <R, E>(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))
 
-const repeatUntilLoop = <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>): STM.STM<R, E, A> =>
+const repeatUntilLoop = <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>): STM.STM<A, E, R> =>
   core.flatMap(self, (a) =>
     predicate(a) ?
       core.succeed(a) :
@@ -1169,11 +1158,11 @@ const repeatUntilLoop = <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A
 
 /** @internal */
 export const repeatWhile = dual<
-  <A>(predicate: Predicate<A>) => <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A>,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>) => STM.STM<R, E, A>
+  <A>(predicate: Predicate<A>) => <R, E>(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))
 
-const repeatWhileLoop = <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>): STM.STM<R, E, A> =>
+const repeatWhileLoop = <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>): STM.STM<A, E, R> =>
   pipe(
     core.flatMap(self, (a) =>
       predicate(a) ?
@@ -1183,42 +1172,42 @@ const repeatWhileLoop = <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A
 
 /** @internal */
 export const replicate = dual<
-  (n: number) => <R, E, A>(self: STM.STM<R, E, A>) => Array<STM.STM<R, E, A>>,
-  <R, E, A>(self: STM.STM<R, E, A>, n: number) => Array<STM.STM<R, E, A>>
+  (n: number) => <A, E, R>(self: STM.STM<A, E, R>) => Array<STM.STM<A, E, R>>,
+  <A, E, R>(self: STM.STM<A, E, R>, n: number) => Array<STM.STM<A, E, R>>
 >(2, (self, n) => Array.from({ length: n }, () => self))
 
 /** @internal */
 export const replicateSTM = dual<
-  (n: number) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, E, Array<A>>,
-  <R, E, A>(self: STM.STM<R, E, A>, n: number) => STM.STM<R, E, Array<A>>
+  (n: number) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<Array<A>, E, R>,
+  <A, E, R>(self: STM.STM<A, E, R>, n: number) => STM.STM<Array<A>, E, R>
 >(2, (self, n) => all(replicate(self, n)))
 
 /** @internal */
 export const replicateSTMDiscard = dual<
-  (n: number) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, E, void>,
-  <R, E, A>(self: STM.STM<R, E, A>, n: number) => STM.STM<R, E, void>
+  (n: number) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<void, E, R>,
+  <A, E, R>(self: STM.STM<A, E, R>, n: number) => STM.STM<void, E, R>
 >(2, (self, n) => all(replicate(self, n), { discard: true }))
 
 /** @internal */
 export const retryUntil = dual<
   {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, B>
-    <A>(predicate: Predicate<A>): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A>
+    <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>
   },
   {
-    <R, E, A, B extends A>(self: STM.STM<R, E, A>, refinement: Refinement<A, B>): STM.STM<R, E, B>
-    <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>): STM.STM<R, E, A>
+    <R, E, A, 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>
   }
 >(
   2,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>) =>
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>) =>
     core.matchSTM(self, { onFailure: core.fail, onSuccess: (a) => predicate(a) ? core.succeed(a) : core.retry })
 )
 
 /** @internal */
 export const retryWhile = dual<
-  <A>(predicate: Predicate<A>) => <R, E>(self: STM.STM<R, E, A>) => STM.STM<R, E, A>,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: Predicate<A>) => STM.STM<R, E, A>
+  <A>(predicate: Predicate<A>) => <R, E>(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) =>
@@ -1228,14 +1217,14 @@ export const retryWhile = dual<
 /** @internal */
 export const partition = dual<
   <R, E, A, A2>(
-    f: (a: A) => STM.STM<R, E, A2>
+    f: (a: A) => STM.STM<A2, E, R>
   ) => (
     elements: Iterable<A>
-  ) => STM.STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>,
+  ) => STM.STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>,
   <R, E, A, A2>(
     elements: Iterable<A>,
-    f: (a: A) => STM.STM<R, E, A2>
-  ) => STM.STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
+    f: (a: A) => STM.STM<A2, E, R>
+  ) => STM.STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>
 >(2, (elements, f) =>
   pipe(
     forEach(elements, (a) => either(f(a))),
@@ -1243,7 +1232,7 @@ export const partition = dual<
   ))
 
 /** @internal */
-export const some = <R, E, A>(self: STM.STM<R, E, Option.Option<A>>): STM.STM<R, Option.Option<E>, A> =>
+export const some = <A, E, R>(self: STM.STM<Option.Option<A>, E, R>): STM.STM<A, Option.Option<E>, R> =>
   core.matchSTM(self, {
     onFailure: (e) => core.fail(Option.some(e)),
     onSuccess: Option.match({
@@ -1279,24 +1268,24 @@ export const all = ((
 }) as STM.All.Signature
 
 /** @internal */
-export const succeedNone: STM.STM<never, never, Option.Option<never>> = core.succeed(Option.none())
+export const succeedNone: STM.STM<Option.Option<never>> = core.succeed(Option.none())
 
 /** @internal */
-export const succeedSome = <A>(value: A): STM.STM<never, never, Option.Option<A>> => core.succeed(Option.some(value))
+export const succeedSome = <A>(value: A): STM.STM<Option.Option<A>> => core.succeed(Option.some(value))
 
 /** @internal */
 export const summarized = dual<
   <R2, E2, A2, A3>(
-    summary: STM.STM<R2, E2, A2>,
+    summary: STM.STM<A2, E2, R2>,
     f: (before: A2, after: A2) => A3
-  ) => <R, E, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E2 | E, [A3, A]>,
+  ) => <A, E, R>(
+    self: STM.STM<A, E, R>
+  ) => STM.STM<[A3, A], E2 | E, R2 | R>,
   <R, E, A, R2, E2, A2, A3>(
-    self: STM.STM<R, E, A>,
-    summary: STM.STM<R2, E2, A2>,
+    self: STM.STM<A, E, R>,
+    summary: STM.STM<A2, E2, R2>,
     f: (before: A2, after: A2) => A3
-  ) => STM.STM<R2 | R, E2 | E, [A3, A]>
+  ) => STM.STM<[A3, A], E2 | E, R2 | R>
 >(3, (self, summary, f) =>
   core.flatMap(summary, (start) =>
     core.flatMap(self, (value) =>
@@ -1306,15 +1295,15 @@ export const summarized = dual<
       ))))
 
 /** @internal */
-export const suspend = <R, E, A>(evaluate: LazyArg<STM.STM<R, E, A>>): STM.STM<R, E, A> => flatten(core.sync(evaluate))
+export const suspend = <A, E, R>(evaluate: LazyArg<STM.STM<A, E, R>>): STM.STM<A, E, R> => flatten(core.sync(evaluate))
 
 /** @internal */
 export const tap: {
-  <A, R2, E2, _>(f: (a: A) => STM.STM<R2, E2, _>): <R, E>(self: STM.STM<R, E, A>) => STM.STM<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, _>(self: STM.STM<R, E, A>, f: (a: A) => STM.STM<R2, E2, _>): STM.STM<R | R2, E | E2, A>
+  <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>
 } = dual(
   2,
-  <R, E, A, R2, E2, _>(self: STM.STM<R, E, A>, f: (a: A) => STM.STM<R2, E2, _>): STM.STM<R | R2, E | E2, A> =>
+  <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> =>
     core.flatMap(self, (a) => as(f(a), a))
 )
 
@@ -1322,19 +1311,19 @@ export const tap: {
 export const tapBoth = dual<
   <E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
     options: {
-      readonly onFailure: (error: XE) => STM.STM<R2, E2, A2>
-      readonly onSuccess: (value: XA) => STM.STM<R3, E3, A3>
+      readonly onFailure: (error: XE) => STM.STM<A2, E2, R2>
+      readonly onSuccess: (value: XA) => STM.STM<A3, E3, R3>
     }
   ) => <R>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R3 | R, E | E2 | E3, A>,
+    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>(
-    self: STM.STM<R, E, A>,
+    self: STM.STM<A, E, R>,
     options: {
-      readonly onFailure: (error: XE) => STM.STM<R2, E2, A2>
-      readonly onSuccess: (value: XA) => STM.STM<R3, E3, A3>
+      readonly onFailure: (error: XE) => STM.STM<A2, E2, R2>
+      readonly onSuccess: (value: XA) => STM.STM<A3, E3, R3>
     }
-  ) => STM.STM<R2 | R3 | R, E | E2 | E3, A>
+  ) => STM.STM<A, E | E2 | E3, R2 | R3 | R>
 >(2, (self, { onFailure, onSuccess }) =>
   core.matchSTM(self, {
     onFailure: (e) => pipe(onFailure(e as any), core.zipRight(core.fail(e))),
@@ -1344,12 +1333,12 @@ export const tapBoth = dual<
 /** @internal */
 export const tapError: {
   <E, R2, E2, _>(
-    f: (error: NoInfer<E>) => STM.STM<R2, E2, _>
-  ): <R, A>(self: STM.STM<R, E, A>) => STM.STM<R2 | R, E | E2, A>
-  <R, A, E, R2, E2, _>(self: STM.STM<R, E, A>, f: (error: E) => STM.STM<R2, E2, _>): STM.STM<R | R2, E | E2, A>
+    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>
 } = dual(
   2,
-  <R, A, E, R2, E2, _>(self: STM.STM<R, E, A>, f: (error: E) => STM.STM<R2, E2, _>): STM.STM<R | R2, E | E2, A> =>
+  <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> =>
     core.matchSTM(self, {
       onFailure: (e) => core.zipRight(f(e), core.fail(e)),
       onSuccess: core.succeed
@@ -1361,8 +1350,8 @@ export const try_: {
   <A, E>(options: {
     readonly try: LazyArg<A>
     readonly catch: (u: unknown) => E
-  }): STM.STM<never, E, A>
-  <A>(try_: LazyArg<A>): STM.STM<never, unknown, A>
+  }): STM.STM<A, E>
+  <A>(try_: LazyArg<A>): STM.STM<A, unknown>
 } = <A, E>(
   arg: LazyArg<A> | {
     readonly try: LazyArg<A>
@@ -1380,12 +1369,12 @@ export const try_: {
 }
 
 /** @internal */
-export const unit: STM.STM<never, never, void> = core.succeed(void 0)
+export const unit: STM.STM<void> = core.succeed(void 0)
 
 /** @internal */
 export const unless = dual<
-  (predicate: LazyArg<boolean>) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, E, Option.Option<A>>,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: LazyArg<boolean>) => STM.STM<R, E, Option.Option<A>>
+  (predicate: LazyArg<boolean>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<Option.Option<A>, E, R>,
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: LazyArg<boolean>) => STM.STM<Option.Option<A>, E, R>
 >(2, (self, predicate) =>
   suspend(
     () => predicate() ? succeedNone : asSome(self)
@@ -1394,14 +1383,14 @@ export const unless = dual<
 /** @internal */
 export const unlessSTM = dual<
   <R2, E2>(
-    predicate: STM.STM<R2, E2, boolean>
-  ) => <R, E, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E2 | E, Option.Option<A>>,
+    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>(
-    self: STM.STM<R, E, A>,
-    predicate: STM.STM<R2, E2, boolean>
-  ) => STM.STM<R2 | R, E2 | E, Option.Option<A>>
+    self: STM.STM<A, E, R>,
+    predicate: STM.STM<boolean, E2, R2>
+  ) => STM.STM<Option.Option<A>, E2 | E, R2 | R>
 >(2, (self, predicate) =>
   core.flatMap(
     predicate,
@@ -1409,7 +1398,7 @@ export const unlessSTM = dual<
   ))
 
 /** @internal */
-export const unsome = <R, E, A>(self: STM.STM<R, Option.Option<E>, A>): STM.STM<R, E, Option.Option<A>> =>
+export const unsome = <A, E, R>(self: STM.STM<A, Option.Option<E>, R>): STM.STM<Option.Option<A>, E, R> =>
   core.matchSTM(self, {
     onFailure: Option.match({
       onNone: () => core.succeed(Option.none()),
@@ -1421,14 +1410,14 @@ export const unsome = <R, E, A>(self: STM.STM<R, Option.Option<E>, A>): STM.STM<
 /** @internal */
 export const validateAll = dual<
   <R, E, A, B>(
-    f: (a: A) => STM.STM<R, E, B>
+    f: (a: A) => STM.STM<B, E, R>
   ) => (
     elements: Iterable<A>
-  ) => STM.STM<R, RA.NonEmptyArray<E>, Array<B>>,
+  ) => STM.STM<Array<B>, RA.NonEmptyArray<E>, R>,
   <R, E, A, B>(
     elements: Iterable<A>,
-    f: (a: A) => STM.STM<R, E, B>
-  ) => STM.STM<R, RA.NonEmptyArray<E>, Array<B>>
+    f: (a: A) => STM.STM<B, E, R>
+  ) => STM.STM<Array<B>, RA.NonEmptyArray<E>, R>
 >(
   2,
   (elements, f) =>
@@ -1440,14 +1429,14 @@ export const validateAll = dual<
 
 /** @internal */
 export const validateFirst = dual<
-  <R, E, A, B>(f: (a: A) => STM.STM<R, E, B>) => (elements: Iterable<A>) => STM.STM<R, Array<E>, B>,
-  <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM.STM<R, E, B>) => STM.STM<R, Array<E>, B>
+  <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>
 >(2, (elements, f) => flip(forEach(elements, (a) => flip(f(a)))))
 
 /** @internal */
 export const when = dual<
-  (predicate: LazyArg<boolean>) => <R, E, A>(self: STM.STM<R, E, A>) => STM.STM<R, E, Option.Option<A>>,
-  <R, E, A>(self: STM.STM<R, E, A>, predicate: LazyArg<boolean>) => STM.STM<R, E, Option.Option<A>>
+  (predicate: LazyArg<boolean>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<Option.Option<A>, E, R>,
+  <A, E, R>(self: STM.STM<A, E, R>, predicate: LazyArg<boolean>) => STM.STM<Option.Option<A>, E, R>
 >(2, (self, predicate) =>
   suspend(
     () => predicate() ? asSome(self) : succeedNone
@@ -1456,14 +1445,14 @@ export const when = dual<
 /** @internal */
 export const whenSTM = dual<
   <R2, E2>(
-    predicate: STM.STM<R2, E2, boolean>
-  ) => <R, E, A>(
-    self: STM.STM<R, E, A>
-  ) => STM.STM<R2 | R, E2 | E, Option.Option<A>>,
+    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>(
-    self: STM.STM<R, E, A>,
-    predicate: STM.STM<R2, E2, boolean>
-  ) => STM.STM<R2 | R, E2 | E, Option.Option<A>>
+    self: STM.STM<A, E, R>,
+    predicate: STM.STM<boolean, E2, R2>
+  ) => STM.STM<Option.Option<A>, E2 | E, R2 | R>
 >(2, (self, predicate) =>
   core.flatMap(
     predicate,