effect 2.3.8 → 2.4.1

package/dist/dts/STM.d.ts

@@ -11,7 +11,7 @@ import type { TypeLambda } from "./HKT.js";
 import type * as Option from "./Option.js";
 import type { Pipeable } from "./Pipeable.js";
 import type { Predicate, Refinement } from "./Predicate.js";
-import type { Covariant, NoInfer } from "./Types.js";
+import type { Covariant, MergeRecord, NoInfer } from "./Types.js";
 import type * as Unify from "./Unify.js";
 /**
  * @since 2.0.0
@@ -101,10 +101,10 @@ declare module "./Context.js" {
  * @category models
  */
 declare module "./Either.js" {
-    interface Left<E, A> extends STM<A, E> {
+    interface Left<L, R> extends STM<R, L> {
         readonly _tag: "Left";
     }
-    interface Right<E, A> extends STM<A, E> {
+    interface Right<L, R> extends STM<R, L> {
         readonly _tag: "Right";
     }
 }
@@ -164,8 +164,8 @@ export declare const isSTM: (u: unknown) => u is STM<unknown, unknown, unknown>;
  * @category constructors
  */
 export declare const acquireUseRelease: {
-    <A, R2, E2, A2, R3, E3, A3>(use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): <R, E>(acquire: STM<A, E, R>) => Effect.Effect<A2, E2 | E3 | E, R2 | R3 | R>;
-    <R, E, A, R2, E2, A2, R3, E3, A3>(acquire: STM<A, E, R>, use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): Effect.Effect<A2, E | E2 | E3, R | R2 | R3>;
+    <A, A2, E2, R2, A3, E3, R3>(use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): <E, R>(acquire: STM<A, E, R>) => Effect.Effect<A2, E2 | E3 | E, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, A3, E3, R3>(acquire: STM<A, E, R>, use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): Effect.Effect<A2, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * @since 2.0.0
@@ -236,7 +236,7 @@ export declare const all: All.Signature;
  */
 export declare const as: {
     <A2>(value: A2): <A, E, R>(self: STM<A, E, R>) => STM<A2, E, R>;
-    <R, E, A, A2>(self: STM<A, E, R>, value: A2): STM<A2, E, R>;
+    <A, E, R, A2>(self: STM<A, E, R>, value: A2): STM<A2, E, R>;
 };
 /**
  * Maps the success value of this effect to an optional value.
@@ -275,8 +275,8 @@ export declare const attempt: <A>(evaluate: LazyArg<A>) => STM<A, unknown>;
  * @category error handling
  */
 export declare const catchAll: {
-    <E, R1, E1, B>(f: (e: E) => STM<B, E1, R1>): <R, A>(self: STM<A, E, R>) => STM<B | A, E1, R1 | R>;
-    <R, A, E, R1, E1, B>(self: STM<A, E, R>, f: (e: E) => STM<B, E1, R1>): STM<A | B, E1, R | R1>;
+    <E, B, E1, R1>(f: (e: E) => STM<B, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<B | A, E1, R1 | R>;
+    <A, E, R, B, E1, R1>(self: STM<A, E, R>, f: (e: E) => STM<B, E1, R1>): STM<A | B, E1, R | R1>;
 };
 /**
  * Recovers from some or all of the error cases.
@@ -285,8 +285,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchSome: {
-    <E, R2, E2, A2>(pf: (error: E) => Option.Option<STM<A2, E2, R2>>): <R, A>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>;
-    <R, A, E, R2, E2, A2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<STM<A2, E2, R2>>): STM<A | A2, E | E2, R | R2>;
+    <E, A2, E2, R2>(pf: (error: E) => Option.Option<STM<A2, E2, R2>>): <A, R>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<STM<A2, E2, R2>>): STM<A | A2, E | E2, R | R2>;
 };
 /**
  * Recovers from the specified tagged error.
@@ -297,14 +297,14 @@ export declare const catchSome: {
 export declare const catchTag: {
     <K extends E["_tag"] & string, E extends {
         _tag: string;
-    }, R1, E1, A1>(k: K, f: (e: Extract<E, {
+    }, A1, E1, R1>(k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => STM<A1, E1, R1>): <R, A>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, {
+    }>) => STM<A1, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, {
         _tag: K;
     }>, R1 | R>;
-    <R, E extends {
+    <A, E extends {
         _tag: string;
-    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: STM<A, E, R>, k: K, f: (e: Extract<E, {
+    }, R, K extends E["_tag"] & string, A1, E1, R1>(self: STM<A, E, R>, k: K, f: (e: Extract<E, {
         _tag: K;
     }>) => STM<A1, E1, R1>): STM<A | A1, E1 | Exclude<E, {
         _tag: K;
@@ -323,7 +323,7 @@ export declare const catchTags: {
         [K in E["_tag"]]+?: ((error: Extract<E, {
             _tag: K;
         }>) => STM<any, any, any>);
-    }>(cases: Cases): <R, A>(self: STM<A, E, R>) => STM<A | {
+    }>(cases: Cases): <A, R>(self: STM<A, E, R>) => STM<A | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<infer A, any, any> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
@@ -362,8 +362,8 @@ export declare const check: (predicate: LazyArg<boolean>) => STM<void>;
  * @category mutations
  */
 export declare const collect: {
-    <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: STM<A, E, R>) => STM<A2, E, R>;
-    <R, E, A, A2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<A2>): STM<A2, E, R>;
+    <A, A2>(pf: (a: A) => Option.Option<A2>): <E, R>(self: STM<A, E, R>) => STM<A2, E, R>;
+    <A, E, R, A2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<A2>): STM<A2, E, R>;
 };
 /**
  * Simultaneously filters and maps the value produced by this effect.
@@ -372,8 +372,8 @@ export declare const collect: {
  * @category mutations
  */
 export declare const collectSTM: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<STM<A2, E2, R2>>): <R, E>(self: STM<A, E, R>) => STM<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<A2, E2, R2>>): STM<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(pf: (a: A) => Option.Option<STM<A2, E2, R2>>): <E, R>(self: STM<A, E, R>) => STM<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<A2, E2, R2>>): STM<A2, E | E2, R | R2>;
 };
 /**
  * Commits this transaction atomically.
@@ -418,7 +418,7 @@ export declare const contextWith: <R0, R>(f: (environment: Context.Context<R0>)
  * @since 2.0.0
  * @category constructors
  */
-export declare const contextWithSTM: <R0, R, E, A>(f: (environment: Context.Context<R0>) => STM<A, E, R>) => STM<A, E, R0 | R>;
+export declare const contextWithSTM: <R0, A, E, R>(f: (environment: Context.Context<R0>) => STM<A, E, R>) => STM<A, E, R0 | R>;
 /**
  * Transforms the environment being provided to this effect with the specified
  * function.
@@ -458,7 +458,7 @@ export declare const dieSync: (evaluate: LazyArg<unknown>) => STM<never>;
  * @since 2.0.0
  * @category mutations
  */
-export declare const either: <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<E, A>, never, R>;
+export declare const either: <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<A, E>, never, R>;
 /**
  * Executes the specified finalization transaction whether or not this effect
  * succeeds. Note that as with all STM transactions, if the full transaction
@@ -469,7 +469,7 @@ export declare const either: <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<
  */
 export declare const ensuring: {
     <R1, B>(finalizer: STM<B, never, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, R1 | R>;
-    <R, E, A, R1, B>(self: STM<A, E, R>, finalizer: STM<B, never, R1>): STM<A, E, R | R1>;
+    <A, E, R, R1, B>(self: STM<A, E, R>, finalizer: STM<B, never, R1>): STM<A, E, R | R1>;
 };
 /**
  * Returns an effect that ignores errors and runs repeatedly until it
@@ -550,9 +550,9 @@ export declare const filterNot: {
  * @category filtering
  */
 export declare const filterOrDie: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
-    <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
-    <R, E, A, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<B, E, R>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A, E, R, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<B, E, R>;
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM<A, E, R>;
 };
 /**
@@ -563,9 +563,9 @@ export declare const filterOrDie: {
  * @category filtering
  */
 export declare const filterOrDieMessage: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
-    <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
-    <R, E, A, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM<B, E, R>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A, E, R, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM<B, E, R>;
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, message: string): STM<A, E, R>;
 };
 /**
@@ -575,10 +575,10 @@ export declare const filterOrDieMessage: {
  * @category filtering
  */
 export declare const filterOrElse: {
-    <A, B extends A, R2, E2, C>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => STM<C, E2, R2>): <R, E>(self: STM<A, E, R>) => STM<B | C, E2 | E, R2 | R>;
-    <A, R2, E2, B>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => STM<B, E2, R2>): <R, E>(self: STM<A, E, R>) => STM<A | B, E2 | E, R2 | R>;
-    <R, E, A, B extends A, R2, E2, C>(self: STM<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => STM<C, E2, R2>): STM<B | C, E | E2, R | R2>;
-    <R, E, A, R2, E2, B>(self: STM<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => STM<B, E2, R2>): STM<A | B, E | E2, R | R2>;
+    <A, B extends A, C, E2, R2>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => STM<C, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<B | C, E2 | E, R2 | R>;
+    <A, B, E2, R2>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => STM<B, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<A | B, E2 | E, R2 | R>;
+    <A, E, R, B extends A, C, E2, R2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => STM<C, E2, R2>): STM<B | C, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: STM<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => STM<B, E2, R2>): STM<A | B, E | E2, R | R2>;
 };
 /**
  * Fails with the specified error if the predicate fails.
@@ -587,10 +587,10 @@ export declare const filterOrElse: {
  * @category filtering
  */
 export declare const filterOrFail: {
-    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: STM<A, E, R>) => STM<B, E2 | E, R>;
-    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
-    <R, E, A, B extends A, E2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): STM<B, E | E2, R>;
-    <R, E, A, E2>(self: STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM<A, E | E2, R>;
+    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: STM<A, E, R>) => STM<B, E2 | E, R>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
+    <A, E, R, B extends A, E2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): STM<B, E | E2, R>;
+    <A, E, R, E2>(self: STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM<A, E | E2, R>;
 };
 /**
  * Feeds the value produced by this effect to the specified function, and then
@@ -600,8 +600,8 @@ export declare const filterOrFail: {
  * @category sequencing
  */
 export declare const flatMap: {
-    <A, R1, E1, A2>(f: (a: A) => STM<A2, E1, R1>): <R, E>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
-    <R, E, A, R1, E1, A2>(self: STM<A, E, R>, f: (a: A) => STM<A2, E1, R1>): STM<A2, E | E1, R | R1>;
+    <A, A2, E1, R1>(f: (a: A) => STM<A2, E1, R1>): <E, R>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
+    <A, E, R, A2, E1, R1>(self: STM<A, E, R>, f: (a: A) => STM<A2, E1, R1>): STM<A2, E | E1, R | R1>;
 };
 /**
  * Flattens out a nested `STM` effect.
@@ -609,7 +609,7 @@ export declare const flatMap: {
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flatten: <R, E, R2, E2, A>(self: STM<STM<A, E2, R2>, E, R>) => STM<A, E | E2, R | R2>;
+export declare const flatten: <A, E2, R2, E, R>(self: STM<STM<A, E2, R2>, E, R>) => STM<A, E2 | E, R2 | R>;
 /**
  * Flips the success and failure channels of this transactional effect. This
  * allows you to use all methods on the error channel, possibly before
@@ -627,8 +627,8 @@ export declare const flip: <A, E, R>(self: STM<A, E, R>) => STM<E, A, R>;
  * @category mutations
  */
 export declare const flipWith: {
-    <R, A, E, R2, A2, E2>(f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): (self: STM<A, E, R>) => STM<A | A2, E | E2, R | R2>;
-    <R, A, E, R2, A2, E2>(self: STM<A, E, R>, f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): STM<A | A2, E | E2, R | R2>;
+    <E, A, R, E2, A2, R2>(f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): (self: STM<A, E, R>) => STM<A | A2, E | E2, R | R2>;
+    <A, E, R, E2, A2, R2>(self: STM<A, E, R>, f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): STM<A | A2, E | E2, R | R2>;
 };
 /**
  * Folds over the `STM` effect, handling both failure and success, but not
@@ -642,7 +642,7 @@ export declare const match: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
     }): <R>(self: STM<A, E, R>) => STM<A2 | A3, never, R>;
-    <R, E, A2, A, A3>(self: STM<A, E, R>, options: {
+    <A, E, R, A2, A3>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
     }): STM<A2 | A3, never, R>;
@@ -654,11 +654,11 @@ export declare const match: {
  * @category folding
  */
 export declare const matchSTM: {
-    <E, R1, E1, A1, A, R2, E2, A2>(options: {
+    <E, A1, E1, R1, A, A2, E2, R2>(options: {
         readonly onFailure: (e: E) => STM<A1, E1, R1>;
         readonly onSuccess: (a: A) => STM<A2, E2, R2>;
     }): <R>(self: STM<A, E, R>) => STM<A1 | A2, E1 | E2, R1 | R2 | R>;
-    <R, E, R1, E1, A1, A, R2, E2, A2>(self: STM<A, E, R>, options: {
+    <A, E, R, A1, E1, R1, A2, E2, R2>(self: STM<A, E, R>, options: {
         readonly onFailure: (e: E) => STM<A1, E1, R1>;
         readonly onSuccess: (a: A) => STM<A2, E2, R2>;
     }): STM<A1 | A2, E1 | E2, R | R1 | R2>;
@@ -671,16 +671,16 @@ export declare const matchSTM: {
  * @category traversing
  */
 export declare const forEach: {
-    <A, R, E, A2>(f: (a: A) => STM<A2, E, R>, options?: {
+    <A, A2, E, R>(f: (a: A) => STM<A2, E, R>, options?: {
         readonly discard?: false | undefined;
-    }): (elements: Iterable<A>) => STM<Array<A2>, E, R>;
-    <A, R, E, A2>(f: (a: A) => STM<A2, E, R>, options: {
+    } | undefined): (elements: Iterable<A>) => STM<Array<A2>, E, R>;
+    <A, A2, E, R>(f: (a: A) => STM<A2, E, R>, options: {
         readonly discard: true;
     }): (elements: Iterable<A>) => STM<void, E, R>;
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options?: {
+    <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options?: {
         readonly discard?: false | undefined;
-    }): STM<Array<A2>, E, R>;
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options: {
+    } | undefined): STM<Array<A2>, E, R>;
+    <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options: {
         readonly discard: true;
     }): STM<void, E, R>;
 };
@@ -690,7 +690,7 @@ export declare const forEach: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEither: <E, A>(either: Either.Either<E, A>) => STM<A, E>;
+export declare const fromEither: <A, E>(either: Either.Either<A, E>) => STM<A, E>;
 /**
  * Lifts an `Option` into a `STM`.
  *
@@ -743,18 +743,23 @@ export declare const gen: <Eff extends STMGen<any, any, any>, AEff>(f: (resume:
  */
 export declare const head: <A, E, R>(self: STM<Iterable<A>, E, R>) => STM<A, Option.Option<E>, R>;
 declare const if_: {
-    <R1, R2, E1, E2, A, A1>(options: {
+    <A, E1, R1, A2, E2, R2>(options: {
         readonly onTrue: STM<A, E1, R1>;
-        readonly onFalse: STM<A1, E2, R2>;
-    }): <R = never, E = never>(self: boolean | STM<boolean, E, R>) => STM<A | A1, E1 | E2 | E, R1 | R2 | R>;
-    <R, E, R1, R2, E1, E2, A, A1>(self: boolean, options: {
+        readonly onFalse: STM<A2, E2, R2>; /**
+         * Flattens out a nested `STM` effect.
+         *
+         * @since 2.0.0
+         * @category sequencing
+         */
+    }): <E = never, R = never>(self: boolean | STM<boolean, E, R>) => STM<A | A2, E1 | E2 | E, R1 | R2 | R>;
+    <A, E1, R1, A2, E2, R2, E = never, R = never>(self: boolean, options: {
         readonly onTrue: STM<A, E1, R1>;
-        readonly onFalse: STM<A1, E2, R2>;
-    }): STM<A | A1, E | E1 | E2, R | R1 | R2>;
-    <R, E, R1, R2, E1, E2, A, A1>(self: STM<boolean, E, R>, options: {
+        readonly onFalse: STM<A2, E2, R2>;
+    }): STM<A | A2, E1 | E2 | E, R1 | R2 | R>;
+    <E, R, A, E1, R1, A2, E2, R2>(self: STM<boolean, E, R>, options: {
         readonly onTrue: STM<A, E1, R1>;
-        readonly onFalse: STM<A1, E2, R2>;
-    }): STM<A | A1, E | E1 | E2, R | R1 | R2>;
+        readonly onFalse: STM<A2, E2, R2>;
+    }): STM<A | A2, E | E1 | E2, R | R1 | R2>;
 };
 export { 
 /**
@@ -816,7 +821,7 @@ export declare const isSuccess: <A, E, R>(self: STM<A, E, R>) => STM<boolean, ne
  * @since 2.0.0
  * @category constructors
  */
-export declare const iterate: <R, E, Z>(initial: Z, options: {
+export declare const iterate: <Z, E, R>(initial: Z, options: {
     readonly while: Predicate<Z>;
     readonly body: (z: Z) => STM<Z, E, R>;
 }) => STM<Z, E, R>;
@@ -840,14 +845,14 @@ export declare const iterate: <R, E, Z>(initial: Z, options: {
  * @category constructors
  */
 export declare const loop: {
-    <Z, R, E, A>(initial: Z, options: {
-        readonly while: Predicate<Z>;
+    <Z, A, E, R>(initial: Z, options: {
+        readonly while: (z: Z) => boolean;
         readonly step: (z: Z) => Z;
         readonly body: (z: Z) => STM<A, E, R>;
         readonly discard?: false | undefined;
     }): STM<Array<A>, E, R>;
-    <Z, R, E, A>(initial: Z, options: {
-        readonly while: Predicate<Z>;
+    <Z, A, E, R>(initial: Z, options: {
+        readonly while: (z: Z) => boolean;
         readonly step: (z: Z) => Z;
         readonly body: (z: Z) => STM<A, E, R>;
         readonly discard: true;
@@ -860,8 +865,8 @@ export declare const loop: {
  * @category mapping
  */
 export declare const map: {
-    <A, B>(f: (a: A) => B): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
-    <R, E, A, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, E, R>;
+    <A, B>(f: (a: A) => B): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A, E, R, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, E, R>;
 };
 /**
  * Maps the value produced by the effect with the specified function that may
@@ -872,8 +877,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapAttempt: {
-    <A, B>(f: (a: A) => B): <R, E>(self: STM<A, E, R>) => STM<B, unknown, R>;
-    <R, E, A, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, unknown, R>;
+    <A, B>(f: (a: A) => B): <E, R>(self: STM<A, E, R>) => STM<B, unknown, R>;
+    <A, E, R, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, unknown, R>;
 };
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped
@@ -887,7 +892,7 @@ export declare const mapBoth: {
         readonly onFailure: (error: E) => E2;
         readonly onSuccess: (value: A) => A2;
     }): <R>(self: STM<A, E, R>) => STM<A2, E2, R>;
-    <R, E, E2, A, A2>(self: STM<A, E, R>, options: {
+    <A, E, R, E2, A2>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: E) => E2;
         readonly onSuccess: (value: A) => A2;
     }): STM<A2, E2, R>;
@@ -899,8 +904,8 @@ export declare const mapBoth: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (error: E) => E2): <R, A>(self: STM<A, E, R>) => STM<A, E2, R>;
-    <R, A, E, E2>(self: STM<A, E, R>, f: (error: E) => E2): STM<A, E2, R>;
+    <E, E2>(f: (error: E) => E2): <A, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <A, E, R, E2>(self: STM<A, E, R>, f: (error: E) => E2): STM<A, E2, R>;
 };
 /**
  * Returns a new effect where the error channel has been merged into the
@@ -917,8 +922,8 @@ export declare const merge: <A, E, R>(self: STM<A, E, R>) => STM<E | A, never, R
  * @category constructors
  */
 export declare const mergeAll: {
-    <A2, A>(zero: A2, f: (a2: A2, a: A) => A2): <R, E>(iterable: Iterable<STM<A, E, R>>) => STM<A2, E, R>;
-    <R, E, A2, A>(iterable: Iterable<STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM<A2, E, R>;
+    <A2, A>(zero: A2, f: (a2: A2, a: A) => A2): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A2, E, R>;
+    <A, E, R, A2>(iterable: Iterable<STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM<A2, E, R>;
 };
 /**
  * Returns a new effect where boolean value of this effect is negated.
@@ -926,7 +931,7 @@ export declare const mergeAll: {
  * @since 2.0.0
  * @category mutations
  */
-export declare const negate: <R, E>(self: STM<boolean, E, R>) => STM<boolean, E, R>;
+export declare const negate: <E, R>(self: STM<boolean, E, R>) => STM<boolean, E, R>;
 /**
  * Requires the option produced by this value to be `None`.
  *
@@ -957,8 +962,8 @@ export declare const orDie: <A, E, R>(self: STM<A, E, R>) => STM<A, never, R>;
  * @category error handling
  */
 export declare const orDieWith: {
-    <E>(f: (error: E) => unknown): <R, A>(self: STM<A, E, R>) => STM<A, never, R>;
-    <R, A, E>(self: STM<A, E, R>, f: (error: E) => unknown): STM<A, never, R>;
+    <E>(f: (error: E) => unknown): <A, R>(self: STM<A, E, R>) => STM<A, never, R>;
+    <A, E, R>(self: STM<A, E, R>, f: (error: E) => unknown): STM<A, never, R>;
 };
 /**
  * Tries this effect first, and if it fails or retries, tries the other
@@ -968,8 +973,8 @@ export declare const orDieWith: {
  * @category error handling
  */
 export declare const orElse: {
-    <R2, E2, A2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, E2, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<A | A2, E2, R | R2>;
+    <A2, E2, R2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<A | A2, E2, R | R2>;
 };
 /**
  * Returns a transactional effect that will produce the value of this effect
@@ -980,8 +985,8 @@ export declare const orElse: {
  * @category error handling
  */
 export declare const orElseEither: {
-    <R2, E2, A2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<A, A2>, E2, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<Either.Either<A, A2>, E2, R | R2>;
+    <A2, E2, R2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<A2, A>, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<Either.Either<A2, A>, E2, R | R2>;
 };
 /**
  * Tries this effect first, and if it fails or retries, fails with the
@@ -992,7 +997,7 @@ export declare const orElseEither: {
  */
 export declare const orElseFail: {
     <E2>(error: LazyArg<E2>): <A, E, R>(self: STM<A, E, R>) => STM<A, E2, R>;
-    <R, E, A, E2>(self: STM<A, E, R>, error: LazyArg<E2>): STM<A, E2, R>;
+    <A, E, R, E2>(self: STM<A, E, R>, error: LazyArg<E2>): STM<A, E2, R>;
 };
 /**
  * Returns an effect that will produce the value of this effect, unless it
@@ -1003,8 +1008,8 @@ export declare const orElseFail: {
  * @category error handling
  */
 export declare const orElseOptional: {
-    <R2, E2, A2>(that: LazyArg<STM<A2, Option.Option<E2>, R2>>): <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<A2 | A, Option.Option<E2 | E>, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: STM<A, Option.Option<E>, R>, that: LazyArg<STM<A2, Option.Option<E2>, R2>>): STM<A | A2, Option.Option<E | E2>, R | R2>;
+    <A2, E2, R2>(that: LazyArg<STM<A2, Option.Option<E2>, R2>>): <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<A2 | A, Option.Option<E2 | E>, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: STM<A, Option.Option<E>, R>, that: LazyArg<STM<A2, Option.Option<E2>, R2>>): STM<A | A2, Option.Option<E | E2>, R | R2>;
 };
 /**
  * Tries this effect first, and if it fails or retries, succeeds with the
@@ -1015,7 +1020,7 @@ export declare const orElseOptional: {
  */
 export declare const orElseSucceed: {
     <A2>(value: LazyArg<A2>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, never, R>;
-    <R, E, A, A2>(self: STM<A, E, R>, value: LazyArg<A2>): STM<A | A2, never, R>;
+    <A, E, R, A2>(self: STM<A, E, R>, value: LazyArg<A2>): STM<A | A2, never, R>;
 };
 /**
  * Tries this effect first, and if it enters retry, then it tries the other
@@ -1025,8 +1030,8 @@ export declare const orElseSucceed: {
  * @category error handling
  */
 export declare const orTry: {
-    <R1, E1, A1>(that: LazyArg<STM<A1, E1, R1>>): <A, E, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | E, R1 | R>;
-    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: LazyArg<STM<A1, E1, R1>>): STM<A | A1, E | E1, R | R1>;
+    <A1, E1, R1>(that: LazyArg<STM<A1, E1, R1>>): <A, E, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | E, R1 | R>;
+    <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: LazyArg<STM<A1, E1, R1>>): STM<A | A1, E | E1, R | R1>;
 };
 /**
  * Feeds elements of type `A` to a function `f` that returns an effect.
@@ -1036,8 +1041,8 @@ export declare const orTry: {
  * @category traversing
  */
 export declare const partition: {
-    <R, E, A, A2>(f: (a: A) => STM<A2, E, R>): (elements: Iterable<A>) => STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
-    <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>): STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
+    <A, A2, E, R>(f: (a: A) => STM<A2, E, R>): (elements: Iterable<A>) => STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
+    <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>): STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
 };
 /**
  * Provides the transaction its required environment, which eliminates its
@@ -1070,7 +1075,7 @@ export declare const provideSomeContext: {
  */
 export declare const provideService: {
     <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
-    <R, E, A, T extends Context.Tag<any, any>>(self: STM<A, E, R>, tag: T, resource: Context.Tag.Service<T>): STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>>(self: STM<A, E, R>, tag: T, resource: Context.Tag.Service<T>): STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Provides the effect with the single service it requires. If the transactional
@@ -1080,8 +1085,8 @@ export declare const provideService: {
  * @category context
  */
 export declare const provideServiceSTM: {
-    <T extends Context.Tag<any, any>, R1, E1>(tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
-    <R, E, A, T extends Context.Tag<any, any>, R1, E1>(self: STM<A, E, R>, tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): STM<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <T extends Context.Tag<any, any>, E1, R1>(tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>, E1, R1>(self: STM<A, E, R>, tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): STM<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Folds an `Iterable<A>` using an effectual function f, working sequentially
@@ -1091,8 +1096,8 @@ export declare const provideServiceSTM: {
  * @category constructors
  */
 export declare const reduce: {
-    <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
-    <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
+    <S, A, E, R>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
+    <S, A, E, R>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
 };
 /**
  * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
@@ -1101,8 +1106,8 @@ export declare const reduce: {
  * @category constructors
  */
 export declare const reduceAll: {
-    <R2, E2, A>(initial: STM<A, E2, R2>, f: (x: A, y: A) => A): <R, E>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>;
-    <R, E, R2, E2, A>(iterable: Iterable<STM<A, E, R>>, initial: STM<A, E2, R2>, f: (x: A, y: A) => A): STM<A, E | E2, R | R2>;
+    <A, E2, R2>(initial: STM<A, E2, R2>, f: (x: A, y: A) => A): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(iterable: Iterable<STM<A, E, R>>, initial: STM<A, E2, R2>, f: (x: A, y: A) => A): STM<A, E | E2, R | R2>;
 };
 /**
  * Folds an `Iterable<A>` using an effectual function f, working sequentially
@@ -1122,8 +1127,8 @@ export declare const reduceRight: {
  * @category mutations
  */
 export declare const refineOrDie: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: STM<A, E, R>) => STM<A, E2, R>;
-    <R, A, E, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>): STM<A, E2, R>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>): <A, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <A, E, R, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>): STM<A, E2, R>;
 };
 /**
  * Keeps some of the errors, and terminates the fiber with the rest, using the
@@ -1133,8 +1138,8 @@ export declare const refineOrDie: {
  * @category mutations
  */
 export declare const refineOrDieWith: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: STM<A, E, R>) => STM<A, E2, R>;
-    <R, A, E, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): STM<A, E2, R>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <A, E, R, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): STM<A, E2, R>;
 };
 /**
  * Fail with the returned value if the `PartialFunction` matches, otherwise
@@ -1144,8 +1149,8 @@ export declare const refineOrDieWith: {
  * @category mutations
  */
 export declare const reject: {
-    <A, E2>(pf: (a: A) => Option.Option<E2>): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
-    <R, E, A, E2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<E2>): STM<A, E | E2, R>;
+    <A, E2>(pf: (a: A) => Option.Option<E2>): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
+    <A, E, R, E2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<E2>): STM<A, E | E2, R>;
 };
 /**
  * Continue with the returned computation if the specified partial function
@@ -1156,8 +1161,8 @@ export declare const reject: {
  * @category mutations
  */
 export declare const rejectSTM: {
-    <A, R2, E2>(pf: (a: A) => Option.Option<STM<E2, E2, R2>>): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<E2, E2, R2>>): STM<A, E | E2, R | R2>;
+    <A, E2, R2>(pf: (a: A) => Option.Option<STM<E2, E2, R2>>): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<E2, E2, R2>>): STM<A, E | E2, R | R2>;
 };
 /**
  * Repeats this `STM` effect until its result satisfies the specified
@@ -1175,7 +1180,7 @@ export declare const rejectSTM: {
  * @category mutations
  */
 export declare const repeatUntil: {
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1195,7 +1200,7 @@ export declare const repeatUntil: {
  * @category mutations
  */
 export declare const repeatWhile: {
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1247,9 +1252,9 @@ export declare const retry: STM<never>;
  * @category mutations
  */
 export declare const retryUntil: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
-    <R, E, A, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>): STM<B, E, R>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A, E, R, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>): STM<B, E, R>;
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1260,7 +1265,7 @@ export declare const retryUntil: {
  * @category mutations
  */
 export declare const retryWhile: {
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1300,8 +1305,8 @@ export declare const succeedSome: <A>(value: A) => STM<Option.Option<A>>;
  * @category mutations
  */
 export declare const summarized: {
-    <R2, E2, A2, A3>(summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): <A, E, R>(self: STM<A, E, R>) => STM<[A3, A], E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2, A3>(self: STM<A, E, R>, summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): STM<[A3, A], E | E2, R | R2>;
+    <A2, E2, R2, A3>(summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): <A, E, R>(self: STM<A, E, R>) => STM<[A3, A], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, A3>(self: STM<A, E, R>, summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): STM<[A3, A], E | E2, R | R2>;
 };
 /**
  * Suspends creation of the specified transaction lazily.
@@ -1325,8 +1330,8 @@ export declare const sync: <A>(evaluate: () => A) => STM<A>;
  * @category sequencing
  */
 export declare const tap: {
-    <A, R2, E2, _>(f: (a: A) => STM<_, E2, R2>): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, _>(self: STM<A, E, R>, f: (a: A) => STM<_, E2, R2>): STM<A, E | E2, R | R2>;
+    <A, X, E2, R2>(f: (a: A) => STM<X, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: STM<A, E, R>, f: (a: A) => STM<X, E2, R2>): STM<A, E | E2, R | R2>;
 };
 /**
  * "Peeks" at both sides of an transactional effect.
@@ -1335,11 +1340,11 @@ export declare const tap: {
  * @category sequencing
  */
 export declare const tapBoth: {
-    <E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(options: {
+    <XE extends E, A2, E2, R2, XA extends A, A3, E3, R3, A, E>(options: {
         readonly onFailure: (error: XE) => STM<A2, E2, R2>;
         readonly onSuccess: (value: XA) => STM<A3, E3, R3>;
     }): <R>(self: STM<A, E, R>) => 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<A, E, R>, options: {
+    <A, E, R, XE extends E, A2, E2, R2, XA extends A, A3, E3, R3>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: XE) => STM<A2, E2, R2>;
         readonly onSuccess: (value: XA) => STM<A3, E3, R3>;
     }): STM<A, E | E2 | E3, R | R2 | R3>;
@@ -1351,8 +1356,8 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, R2, E2, _>(f: (error: NoInfer<E>) => STM<_, E2, R2>): <R, A>(self: STM<A, E, R>) => STM<A, E | E2, R2 | R>;
-    <R, A, E, R2, E2, _>(self: STM<A, E, R>, f: (error: E) => STM<_, E2, R2>): STM<A, E | E2, R | R2>;
+    <E, X, E2, R2>(f: (error: NoInfer<E>) => STM<X, E2, R2>): <A, R>(self: STM<A, E, R>) => STM<A, E | E2, R2 | R>;
+    <A, E, R, X, E2, R2>(self: STM<A, E, R>, f: (error: E) => STM<X, E2, R2>): STM<A, E | E2, R | R2>;
 };
 declare const try_: {
     <A, E>(options: {
@@ -1387,8 +1392,8 @@ export declare const unless: {
  * @category mutations
  */
 export declare const unlessSTM: {
-    <R2, E2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
+    <E2, R2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
 };
 /**
  * Converts an option on errors into an option on values.
@@ -1415,8 +1420,8 @@ export declare const unit: STM<void>;
  * @category mutations
  */
 export declare const validateAll: {
-    <R, E, A, B>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<Array<B>, [E, ...Array<E>], R>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<Array<B>, [E, ...Array<E>], R>;
+    <A, B, E, R>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<Array<B>, [E, ...Array<E>], R>;
+    <A, B, E, R>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<Array<B>, [E, ...Array<E>], R>;
 };
 /**
  * Feeds elements of type `A` to `f` until it succeeds. Returns first success
@@ -1426,8 +1431,8 @@ export declare const validateAll: {
  * @category mutations
  */
 export declare const validateFirst: {
-    <R, E, A, B>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<B, Array<E>, R>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<B, Array<E>, R>;
+    <A, B, E, R>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<B, Array<E>, R>;
+    <A, B, E, R>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<B, Array<E>, R>;
 };
 /**
  * The moral equivalent of `if (p) exp`.
@@ -1446,8 +1451,8 @@ export declare const when: {
  * @category mutations
  */
 export declare const whenSTM: {
-    <R2, E2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
+    <E2, R2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
 };
 /**
  * Sequentially zips this value with the specified one.
@@ -1456,8 +1461,8 @@ export declare const whenSTM: {
  * @category zipping
  */
 export declare const zip: {
-    <R1, E1, A1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<[A, A1], E1 | E, R1 | R>;
-    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<[A, A1], E | E1, R | R1>;
+    <A1, E1, R1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<[A, A1], E1 | E, R1 | R>;
+    <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<[A, A1], E | E1, R | R1>;
 };
 /**
  * Sequentially zips this value with the specified one, discarding the second
@@ -1467,8 +1472,8 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <R1, E1, A1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | R>;
-    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A, E | E1, R | R1>;
+    <A1, E1, R1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | R>;
+    <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A, E | E1, R | R1>;
 };
 /**
  * Sequentially zips this value with the specified one, discarding the first
@@ -1478,8 +1483,8 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <R1, E1, A1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A1, E1 | E, R1 | R>;
-    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A1, E | E1, R | R1>;
+    <A1, E1, R1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A1, E1 | E, R1 | R>;
+    <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A1, E | E1, R | R1>;
 };
 /**
  * Sequentially zips this value with the specified one, combining the values
@@ -1489,8 +1494,8 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <R1, E1, A1, A, A2>(that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): <R, E>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
-    <R, E, R1, E1, A1, A, A2>(self: STM<A, E, R>, that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): STM<A2, E | E1, R | R1>;
+    <A1, E1, R1, A, A2>(that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): <E, R>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
+    <A, E, R, A1, E1, R1, A2>(self: STM<A, E, R>, that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): STM<A2, E | E1, R | R1>;
 };
 /**
  * This function takes an iterable of `STM` values and returns a new
@@ -1522,18 +1527,18 @@ export declare const Do: STM<{}>;
  * @since 2.0.0
  */
 export declare const bind: {
-    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): <R, E>(self: STM<K, E, R>) => STM<Effect.MergeRecord<K, {
+    <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, {
         [k in N]: A;
     }>, E2 | E, R2 | R>;
-    <R, E, N extends string, K, R2, E2, A>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): STM<Effect.MergeRecord<K, {
+    <K, E, R, N extends string, A, E2, R2>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): STM<MergeRecord<K, {
         [k in N]: A;
     }>, E | E2, R | R2>;
 };
 declare const let_: {
-    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: STM<K, E, R>) => STM<Effect.MergeRecord<K, {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, {
         [k in N]: A;
     }>, E, R>;
-    <R, E, K, N extends string, A>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A): STM<Effect.MergeRecord<K, {
+    <K, E, R, N extends string, A>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A): STM<MergeRecord<K, {
         [k in N]: A;
     }>, E, R>;
 };
@@ -1549,6 +1554,6 @@ let_ as let };
  */
 export declare const bindTo: {
     <N extends string>(tag: N): <A, E, R>(self: STM<A, E, R>) => STM<Record<N, A>, E, R>;
-    <R, E, A, N extends string>(self: STM<A, E, R>, tag: N): STM<Record<N, A>, E, R>;
+    <A, E, R, N extends string>(self: STM<A, E, R>, tag: N): STM<Record<N, A>, E, R>;
 };
 //# sourceMappingURL=STM.d.ts.map