effect 3.17.9 → 3.17.10

package/dist/dts/Either.d.ts

@@ -15,7 +15,7 @@ import * as Gen from "./Utils.js";
  * @category models
  * @since 2.0.0
  */
-export type Either<R, L = never> = Left<L, R> | Right<L, R>;
+export type Either<A, E = never> = Left<E, A> | Right<E, A>;
 /**
  * @category symbols
  * @since 2.0.0
@@ -30,13 +30,13 @@ export type TypeId = typeof TypeId;
  * @category models
  * @since 2.0.0
  */
-export interface Left<out L, out R> extends Pipeable, Inspectable {
+export interface Left<out E, out A> extends Pipeable, Inspectable {
     readonly _tag: "Left";
     readonly _op: "Left";
-    readonly left: L;
+    readonly left: E;
     readonly [TypeId]: {
-        readonly _R: Covariant<R>;
-        readonly _L: Covariant<L>;
+        readonly _R: Covariant<A>;
+        readonly _L: Covariant<E>;
     };
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: EitherUnify<this>;
@@ -46,13 +46,13 @@ export interface Left<out L, out R> extends Pipeable, Inspectable {
  * @category models
  * @since 2.0.0
  */
-export interface Right<out L, out R> extends Pipeable, Inspectable {
+export interface Right<out E, out A> extends Pipeable, Inspectable {
     readonly _tag: "Right";
     readonly _op: "Right";
-    readonly right: R;
+    readonly right: A;
     readonly [TypeId]: {
-        readonly _R: Covariant<R>;
-        readonly _L: Covariant<L>;
+        readonly _R: Covariant<A>;
+        readonly _L: Covariant<E>;
     };
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: EitherUnify<this>;
@@ -102,7 +102,7 @@ export declare namespace Either {
  * @category constructors
  * @since 2.0.0
  */
-export declare const right: <R>(right: R) => Either<R>;
+export declare const right: <A>(a: A) => Either<A>;
 declare const void_: Either<void>;
 export { 
 /**
@@ -117,7 +117,7 @@ void_ as void };
  * @category constructors
  * @since 2.0.0
  */
-export declare const left: <L>(left: L) => Either<never, L>;
+export declare const left: <E>(e: E) => Either<never, E>;
 /**
  * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use
  * the provided default as a `Left`.
@@ -151,7 +151,7 @@ export declare const fromNullable: {
      * @category constructors
      * @since 2.0.0
      */
-    <R, L>(onNullable: (right: R) => L): (self: R) => Either<NonNullable<R>, L>;
+    <A, E>(onNullable: (right: A) => E): (self: A) => Either<NonNullable<A>, E>;
     /**
      * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use
      * the provided default as a `Left`.
@@ -168,7 +168,7 @@ export declare const fromNullable: {
      * @category constructors
      * @since 2.0.0
      */
-    <R, L>(self: R, onNullable: (right: R) => L): Either<NonNullable<R>, L>;
+    <A, E>(self: A, onNullable: (right: A) => E): Either<NonNullable<A>, E>;
 };
 /**
  * @example
@@ -197,7 +197,7 @@ export declare const fromOption: {
      * @category constructors
      * @since 2.0.0
      */
-    <L>(onNone: () => L): <R>(self: Option<R>) => Either<R, L>;
+    <E>(onNone: () => E): <A>(self: Option<A>) => Either<A, E>;
     /**
      * @example
      * ```ts
@@ -211,14 +211,14 @@ export declare const fromOption: {
      * @category constructors
      * @since 2.0.0
      */
-    <R, L>(self: Option<R>, onNone: () => L): Either<R, L>;
+    <A, E>(self: Option<A>, onNone: () => E): Either<A, E>;
 };
 declare const try_: {
-    <R, L>(options: {
-        readonly try: LazyArg<R>;
-        readonly catch: (error: unknown) => L;
-    }): Either<R, L>;
-    <R>(evaluate: LazyArg<R>): Either<R, unknown>;
+    <A, E>(options: {
+        readonly try: LazyArg<A>;
+        readonly catch: (error: unknown) => E;
+    }): Either<A, E>;
+    <A>(evaluate: LazyArg<A>): Either<A, unknown>;
 };
 export { 
 /**
@@ -261,7 +261,7 @@ export declare const isEither: (input: unknown) => input is Either<unknown, unkn
  * @category guards
  * @since 2.0.0
  */
-export declare const isLeft: <R, L>(self: Either<R, L>) => self is Left<L, R>;
+export declare const isLeft: <A, E>(self: Either<A, E>) => self is Left<E, A>;
 /**
  * Determine if a `Either` is a `Right`.
  *
@@ -277,7 +277,7 @@ export declare const isLeft: <R, L>(self: Either<R, L>) => self is Left<L, R>;
  * @category guards
  * @since 2.0.0
  */
-export declare const isRight: <R, L>(self: Either<R, L>) => self is Right<L, R>;
+export declare const isRight: <A, E>(self: Either<A, E>) => self is Right<E, A>;
 /**
  * Converts a `Either` to an `Option` discarding the `Left`.
  *
@@ -293,7 +293,7 @@ export declare const isRight: <R, L>(self: Either<R, L>) => self is Right<L, R>;
  * @category getters
  * @since 2.0.0
  */
-export declare const getRight: <R, L>(self: Either<R, L>) => Option<R>;
+export declare const getRight: <A, E>(self: Either<A, E>) => Option<A>;
 /**
  * Converts a `Either` to an `Option` discarding the value.
  *
@@ -309,15 +309,15 @@ export declare const getRight: <R, L>(self: Either<R, L>) => Option<R>;
  * @category getters
  * @since 2.0.0
  */
-export declare const getLeft: <R, L>(self: Either<R, L>) => Option<L>;
+export declare const getLeft: <A, E>(self: Either<A, E>) => Option<E>;
 /**
  * @category equivalence
  * @since 2.0.0
  */
-export declare const getEquivalence: <R, L>({ left, right }: {
-    right: Equivalence.Equivalence<R>;
-    left: Equivalence.Equivalence<L>;
-}) => Equivalence.Equivalence<Either<R, L>>;
+export declare const getEquivalence: <A, E>({ left, right }: {
+    right: Equivalence.Equivalence<A>;
+    left: Equivalence.Equivalence<E>;
+}) => Equivalence.Equivalence<Either<A, E>>;
 /**
  * @category mapping
  * @since 2.0.0
@@ -327,18 +327,18 @@ export declare const mapBoth: {
      * @category mapping
      * @since 2.0.0
      */
-    <L, L2, R, R2>(options: {
-        readonly onLeft: (left: L) => L2;
-        readonly onRight: (right: R) => R2;
-    }): (self: Either<R, L>) => Either<R2, L2>;
+    <E, E2, A, A2>(options: {
+        readonly onLeft: (left: E) => E2;
+        readonly onRight: (right: A) => A2;
+    }): (self: Either<A, E>) => Either<A2, E2>;
     /**
      * @category mapping
      * @since 2.0.0
      */
-    <L, R, L2, R2>(self: Either<R, L>, options: {
-        readonly onLeft: (left: L) => L2;
-        readonly onRight: (right: R) => R2;
-    }): Either<R2, L2>;
+    <A, E, E2, A2>(self: Either<A, E>, options: {
+        readonly onLeft: (left: E) => E2;
+        readonly onRight: (right: A) => A2;
+    }): Either<A2, E2>;
 };
 /**
  * Maps the `Left` side of an `Either` value to a new `Either` value.
@@ -353,14 +353,14 @@ export declare const mapLeft: {
      * @category mapping
      * @since 2.0.0
      */
-    <L, L2>(f: (left: L) => L2): <R>(self: Either<R, L>) => Either<R, L2>;
+    <E, E2>(f: (left: E) => E2): <A>(self: Either<A, E>) => Either<A, E2>;
     /**
      * Maps the `Left` side of an `Either` value to a new `Either` value.
      *
      * @category mapping
      * @since 2.0.0
      */
-    <R, L, L2>(self: Either<R, L>, f: (left: L) => L2): Either<R, L2>;
+    <A, E, E2>(self: Either<A, E>, f: (left: E) => E2): Either<A, E2>;
 };
 /**
  * Maps the `Right` side of an `Either` value to a new `Either` value.
@@ -375,14 +375,14 @@ export declare const map: {
      * @category mapping
      * @since 2.0.0
      */
-    <R, R2>(f: (right: R) => R2): <L>(self: Either<R, L>) => Either<R2, L>;
+    <A, A2>(f: (right: A) => A2): <E>(self: Either<A, E>) => Either<A2, E>;
     /**
      * Maps the `Right` side of an `Either` value to a new `Either` value.
      *
      * @category mapping
      * @since 2.0.0
      */
-    <R, L, R2>(self: Either<R, L>, f: (right: R) => R2): Either<R2, L>;
+    <A, E, A2>(self: Either<A, E>, f: (right: A) => A2): Either<A2, E>;
 };
 /**
  * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function,
@@ -431,10 +431,10 @@ export declare const match: {
      * @category pattern matching
      * @since 2.0.0
      */
-    <L, B, R, C = B>(options: {
-        readonly onLeft: (left: L) => B;
-        readonly onRight: (right: R) => C;
-    }): (self: Either<R, L>) => B | C;
+    <E, B, A, C = B>(options: {
+        readonly onLeft: (left: E) => B;
+        readonly onRight: (right: A) => C;
+    }): (self: Either<A, E>) => B | C;
     /**
      * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function,
      * if the value is a `Right` the inner value is applied to the `onRight` function.
@@ -458,9 +458,9 @@ export declare const match: {
      * @category pattern matching
      * @since 2.0.0
      */
-    <R, L, B, C = B>(self: Either<R, L>, options: {
-        readonly onLeft: (left: L) => B;
-        readonly onRight: (right: R) => C;
+    <A, E, B, C = B>(self: Either<A, E>, options: {
+        readonly onLeft: (left: E) => B;
+        readonly onRight: (right: A) => C;
     }): B | C;
 };
 /**
@@ -655,7 +655,7 @@ export declare const filterOrLeft: {
      * @since 2.0.0
      * @category filtering & conditionals
      */
-    <R, B extends R, L2>(refinement: Refinement<NoInfer<R>, B>, orLeftWith: (right: NoInfer<R>) => L2): <L>(self: Either<R, L>) => Either<B, L2 | L>;
+    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orLeftWith: (right: NoInfer<A>) => E2): <E>(self: Either<A, E>) => Either<B, E2 | E>;
     /**
      * Filter the right value with the provided function.
      * If the predicate fails, set the left value with the result of the provided function.
@@ -686,7 +686,7 @@ export declare const filterOrLeft: {
      * @since 2.0.0
      * @category filtering & conditionals
      */
-    <R, L2>(predicate: Predicate<NoInfer<R>>, orLeftWith: (right: NoInfer<R>) => L2): <L>(self: Either<R, L>) => Either<R, L2 | L>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orLeftWith: (right: NoInfer<A>) => E2): <E>(self: Either<A, E>) => Either<A, E2 | E>;
     /**
      * Filter the right value with the provided function.
      * If the predicate fails, set the left value with the result of the provided function.
@@ -717,7 +717,7 @@ export declare const filterOrLeft: {
      * @since 2.0.0
      * @category filtering & conditionals
      */
-    <R, L, B extends R, L2>(self: Either<R, L>, refinement: Refinement<R, B>, orLeftWith: (right: R) => L2): Either<B, L | L2>;
+    <A, E, B extends A, E2>(self: Either<A, E>, refinement: Refinement<A, B>, orLeftWith: (right: A) => E2): Either<B, E | E2>;
     /**
      * Filter the right value with the provided function.
      * If the predicate fails, set the left value with the result of the provided function.
@@ -748,13 +748,13 @@ export declare const filterOrLeft: {
      * @since 2.0.0
      * @category filtering & conditionals
      */
-    <R, L, E2>(self: Either<R, L>, predicate: Predicate<R>, orLeftWith: (right: R) => E2): Either<R, L | E2>;
+    <A, E, E2>(self: Either<A, E>, predicate: Predicate<A>, orLeftWith: (right: A) => E2): Either<A, E | E2>;
 };
 /**
  * @category getters
  * @since 2.0.0
  */
-export declare const merge: <R, L>(self: Either<R, L>) => L | R;
+export declare const merge: <A, E>(self: Either<A, E>) => E | A;
 /**
  * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.
  *
@@ -786,7 +786,7 @@ export declare const getOrElse: {
      * @category getters
      * @since 2.0.0
      */
-    <L, R2>(onLeft: (left: L) => R2): <R>(self: Either<R, L>) => R2 | R;
+    <E, A2>(onLeft: (left: E) => A2): <A>(self: Either<A, E>) => A2 | A;
     /**
      * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.
      *
@@ -802,7 +802,7 @@ export declare const getOrElse: {
      * @category getters
      * @since 2.0.0
      */
-    <R, L, R2>(self: Either<R, L>, onLeft: (left: L) => R2): R | R2;
+    <A, E, A2>(self: Either<A, E>, onLeft: (left: E) => A2): A | A2;
 };
 /**
  * @example
@@ -817,7 +817,7 @@ export declare const getOrElse: {
  * @category getters
  * @since 2.0.0
  */
-export declare const getOrNull: <R, L>(self: Either<R, L>) => R | null;
+export declare const getOrNull: <A, E>(self: Either<A, E>) => A | null;
 /**
  * @example
  * ```ts
@@ -831,7 +831,7 @@ export declare const getOrNull: <R, L>(self: Either<R, L>) => R | null;
  * @category getters
  * @since 2.0.0
  */
-export declare const getOrUndefined: <R, L>(self: Either<R, L>) => R | undefined;
+export declare const getOrUndefined: <A, E>(self: Either<A, E>) => A | undefined;
 /**
  * Extracts the value of an `Either` or throws if the `Either` is `Left`.
  *
@@ -873,7 +873,7 @@ export declare const getOrThrowWith: {
      * @category getters
      * @since 2.0.0
      */
-    <L>(onLeft: (left: L) => unknown): <A>(self: Either<A, L>) => A;
+    <E>(onLeft: (left: E) => unknown): <A>(self: Either<A, E>) => A;
     /**
      * Extracts the value of an `Either` or throws if the `Either` is `Left`.
      *
@@ -894,7 +894,7 @@ export declare const getOrThrowWith: {
      * @category getters
      * @since 2.0.0
      */
-    <R, L>(self: Either<R, L>, onLeft: (left: L) => unknown): R;
+    <A, E>(self: Either<A, E>, onLeft: (left: E) => unknown): A;
 };
 /**
  * Extracts the value of an `Either` or throws if the `Either` is `Left`.
@@ -915,7 +915,7 @@ export declare const getOrThrowWith: {
  * @category getters
  * @since 2.0.0
  */
-export declare const getOrThrow: <R, L>(self: Either<R, L>) => R;
+export declare const getOrThrow: <A, E>(self: Either<A, E>) => A;
 /**
  * Returns `self` if it is a `Right` or `that` otherwise.
  *
@@ -929,14 +929,14 @@ export declare const orElse: {
      * @category error handling
      * @since 2.0.0
      */
-    <L, R2, L2>(that: (left: L) => Either<R2, L2>): <R>(self: Either<R, L>) => Either<R | R2, L2>;
+    <E, A2, E2>(that: (left: E) => Either<A2, E2>): <A>(self: Either<A, E>) => Either<A | A2, E2>;
     /**
      * Returns `self` if it is a `Right` or `that` otherwise.
      *
      * @category error handling
      * @since 2.0.0
      */
-    <R, L, R2, L2>(self: Either<R, L>, that: (left: L) => Either<R2, L2>): Either<R | R2, L2>;
+    <A, E, A2, E2>(self: Either<A, E>, that: (left: E) => Either<A2, E2>): Either<A | A2, E2>;
 };
 /**
  * @category sequencing
@@ -947,12 +947,12 @@ export declare const flatMap: {
      * @category sequencing
      * @since 2.0.0
      */
-    <R, R2, L2>(f: (right: R) => Either<R2, L2>): <L>(self: Either<R, L>) => Either<R2, L | L2>;
+    <A, A2, E2>(f: (right: A) => Either<A2, E2>): <E>(self: Either<A, E>) => Either<A2, E | E2>;
     /**
      * @category sequencing
      * @since 2.0.0
      */
-    <R, L, R2, L2>(self: Either<R, L>, f: (right: R) => Either<R2, L2>): Either<R2, L | L2>;
+    <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2>): Either<A2, E | E2>;
 };
 /**
  * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
@@ -967,56 +967,56 @@ export declare const andThen: {
      * @category sequencing
      * @since 2.0.0
      */
-    <R, R2, L2>(f: (right: R) => Either<R2, L2>): <L>(self: Either<R, L>) => Either<R2, L | L2>;
+    <A, A2, E2>(f: (right: A) => Either<A2, E2>): <E>(self: Either<A, E>) => Either<A2, E | E2>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R2, L2>(f: Either<R2, L2>): <L, R1>(self: Either<R1, L>) => Either<R2, L | L2>;
+    <A2, E2>(f: Either<A2, E2>): <E, A>(self: Either<A, E>) => Either<A2, E | E2>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R, R2>(f: (right: R) => R2): <L>(self: Either<R, L>) => Either<R2, L>;
+    <A, A2>(f: (right: A) => A2): <E>(self: Either<A, E>) => Either<A2, E>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R2>(right: NotFunction<R2>): <R1, L>(self: Either<R1, L>) => Either<R2, L>;
+    <A2>(right: NotFunction<A2>): <A, E>(self: Either<A, E>) => Either<A2, E>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R, L, R2, L2>(self: Either<R, L>, f: (right: R) => Either<R2, L2>): Either<R2, L | L2>;
+    <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2>): Either<A2, E | E2>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R, L, R2, L2>(self: Either<R, L>, f: Either<R2, L2>): Either<R2, L | L2>;
+    <A, E, A2, E2>(self: Either<A, E>, f: Either<A2, E2>): Either<A2, E | E2>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R, L, R2>(self: Either<R, L>, f: (right: R) => R2): Either<R2, L>;
+    <A, E, A2>(self: Either<A, E>, f: (right: A) => A2): Either<A2, E>;
     /**
      * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
      *
      * @category sequencing
      * @since 2.0.0
      */
-    <R, L, R2>(self: Either<R, L>, f: NotFunction<R2>): Either<R2, L>;
+    <A, E, A2>(self: Either<A, E>, f: NotFunction<A2>): Either<A2, E>;
 };
 /**
  * @category zipping
@@ -1027,12 +1027,12 @@ export declare const zipWith: {
      * @category zipping
      * @since 2.0.0
      */
-    <R2, L2, R, B>(that: Either<R2, L2>, f: (right: R, right2: R2) => B): <L>(self: Either<R, L>) => Either<B, L2 | L>;
+    <A2, E2, A, B>(that: Either<A2, E2>, f: (right: A, right2: A2) => B): <E>(self: Either<A, E>) => Either<B, E2 | E>;
     /**
      * @category zipping
      * @since 2.0.0
      */
-    <R, L, R2, L2, B>(self: Either<R, L>, that: Either<R2, L2>, f: (right: R, right2: R2) => B): Either<B, L | L2>;
+    <A, E, A2, E2, B>(self: Either<A, E>, that: Either<A2, E2>, f: (right: A, right2: A2) => B): Either<B, E | E2>;
 };
 /**
  * @category combining
@@ -1043,12 +1043,12 @@ export declare const ap: {
      * @category combining
      * @since 2.0.0
      */
-    <R, L2>(that: Either<R, L2>): <R2, L>(self: Either<(right: R) => R2, L>) => Either<R2, L | L2>;
+    <A, E2>(that: Either<A, E2>): <A2, E>(self: Either<(right: A) => A2, E>) => Either<A2, E | E2>;
     /**
      * @category combining
      * @since 2.0.0
      */
-    <R, R2, L, L2>(self: Either<(right: R) => R2, L>, that: Either<R, L2>): Either<R2, L | L2>;
+    <A, A2, E, E2>(self: Either<(right: A) => A2, E>, that: Either<A, E2>): Either<A2, E | E2>;
 };
 /**
  * Takes a structure of `Either`s and returns an `Either` of values with the same structure.
@@ -1071,10 +1071,10 @@ export declare const ap: {
  * @since 2.0.0
  */
 export declare const all: <const I extends Iterable<Either<any, any>> | Record<string, Either<any, any>>>(input: I) => [I] extends [ReadonlyArray<Either<any, any>>] ? Either<{
-    -readonly [K in keyof I]: [I[K]] extends [Either<infer R, any>] ? R : never;
-}, I[number] extends never ? never : [I[number]] extends [Either<any, infer L>] ? L : never> : [I] extends [Iterable<Either<infer R, infer L>>] ? Either<Array<R>, L> : Either<{
-    -readonly [K in keyof I]: [I[K]] extends [Either<infer R, any>] ? R : never;
-}, I[keyof I] extends never ? never : [I[keyof I]] extends [Either<any, infer L>] ? L : never>;
+    -readonly [K in keyof I]: [I[K]] extends [Either<infer A, any>] ? A : never;
+}, I[number] extends never ? never : [I[number]] extends [Either<any, infer E>] ? E : never> : [I] extends [Iterable<Either<infer A, infer E>>] ? Either<Array<A>, E> : Either<{
+    -readonly [K in keyof I]: [I[K]] extends [Either<infer A, any>] ? A : never;
+}, I[keyof I] extends never ? never : [I[keyof I]] extends [Either<any, infer E>] ? E : never>;
 /**
  * Returns an `Either` that swaps the error/success cases. This allows you to
  * use all methods on the error channel, possibly before flipping back.
@@ -1082,7 +1082,7 @@ export declare const all: <const I extends Iterable<Either<any, any>> | Record<s
  * @since 2.0.0
  * @category mapping
  */
-export declare const flip: <R, L>(self: Either<R, L>) => Either<L, R>;
+export declare const flip: <A, E>(self: Either<A, E>) => Either<E, A>;
 /**
  * @category generators
  * @since 2.0.0
@@ -1183,9 +1183,9 @@ export declare const bind: {
      * @category do notation
      * @since 2.0.0
      */
-    <N extends string, A extends object, B, L2>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Either<B, L2>): <L1>(self: Either<A, L1>) => Either<{
+    <N extends string, A extends object, B, E2>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Either<B, E2>): <E>(self: Either<A, E>) => Either<{
         [K in N | keyof A]: K extends keyof A ? A[K] : B;
-    }, L1 | L2>;
+    }, E | E2>;
     /**
      * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
      *
@@ -1217,9 +1217,9 @@ export declare const bind: {
      * @category do notation
      * @since 2.0.0
      */
-    <A extends object, L1, N extends string, B, L2>(self: Either<A, L1>, name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Either<B, L2>): Either<{
+    <A extends object, E, N extends string, B, E2>(self: Either<A, E>, name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Either<B, E2>): Either<{
         [K in N | keyof A]: K extends keyof A ? A[K] : B;
-    }, L1 | L2>;
+    }, E | E2>;
 };
 /**
  * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
@@ -1284,9 +1284,9 @@ export declare const bindTo: {
      * @category do notation
      * @since 2.0.0
      */
-    <N extends string>(name: N): <R, L>(self: Either<R, L>) => Either<{
-        [K in N]: R;
-    }, L>;
+    <N extends string>(name: N): <A, E>(self: Either<A, E>) => Either<{
+        [K in N]: A;
+    }, E>;
     /**
      * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
      *
@@ -1318,17 +1318,17 @@ export declare const bindTo: {
      * @category do notation
      * @since 2.0.0
      */
-    <R, L, N extends string>(self: Either<R, L>, name: N): Either<{
-        [K in N]: R;
-    }, L>;
+    <A, E, N extends string>(self: Either<A, E>, name: N): Either<{
+        [K in N]: A;
+    }, E>;
 };
 declare const let_: {
-    <N extends string, R extends object, B>(name: Exclude<N, keyof R>, f: (r: NoInfer<R>) => B): <L>(self: Either<R, L>) => Either<{
-        [K in N | keyof R]: K extends keyof R ? R[K] : B;
-    }, L>;
-    <R extends object, L, N extends string, B>(self: Either<R, L>, name: Exclude<N, keyof R>, f: (r: NoInfer<R>) => B): Either<{
-        [K in N | keyof R]: K extends keyof R ? R[K] : B;
-    }, L>;
+    <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (r: NoInfer<A>) => B): <E>(self: Either<A, E>) => Either<{
+        [K in N | keyof A]: K extends keyof A ? A[K] : B;
+    }, E>;
+    <A extends object, E, N extends string, B>(self: Either<A, E>, name: Exclude<N, keyof A>, f: (r: NoInfer<A>) => B): Either<{
+        [K in N | keyof A]: K extends keyof A ? A[K] : B;
+    }, E>;
 };
 export { 
 /**