effect 3.17.9 → 3.17.10

package/src/Either.ts

@@ -22,7 +22,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
@@ -41,13 +41,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>
@@ -59,13 +59,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>
@@ -117,7 +117,7 @@ export declare namespace Either {
  * @category constructors
  * @since 2.0.0
  */
-export const right: <R>(right: R) => Either<R> = either.right
+export const right: <A>(a: A) => Either<A> = either.right
 
 const void_: Either<void> = right(void 0)
 export {
@@ -135,7 +135,7 @@ export {
  * @category constructors
  * @since 2.0.0
  */
-export const left: <L>(left: L) => Either<never, L> = either.left
+export const left: <E>(e: E) => Either<never, E> = either.left
 
 /**
  * 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
@@ -170,7 +170,7 @@ export 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`.
@@ -187,10 +187,10 @@ export 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>
 } = dual(
   2,
-  <R, L>(self: R, onNullable: (right: R) => L): Either<NonNullable<R>, L> =>
+  <A, E>(self: A, onNullable: (right: A) => E): Either<NonNullable<A>, E> =>
     self == null ? left(onNullable(self)) : right(self)
 )
 
@@ -221,7 +221,7 @@ export 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
@@ -235,21 +235,21 @@ export 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>
 } = either.fromOption
 
 const try_: {
-  <R, L>(
+  <A, E>(
     options: {
-      readonly try: LazyArg<R>
-      readonly catch: (error: unknown) => L
+      readonly try: LazyArg<A>
+      readonly catch: (error: unknown) => E
     }
-  ): Either<R, L>
-  <R>(evaluate: LazyArg<R>): Either<R, unknown>
-} = (<R, L>(
-  evaluate: LazyArg<R> | {
-    readonly try: LazyArg<R>
-    readonly catch: (error: unknown) => L
+  ): Either<A, E>
+  <A>(evaluate: LazyArg<A>): Either<A, unknown>
+} = (<A, E>(
+  evaluate: LazyArg<A> | {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
   }
 ) => {
   if (isFunction(evaluate)) {
@@ -311,7 +311,7 @@ export const isEither: (input: unknown) => input is Either<unknown, unknown> = e
  * @category guards
  * @since 2.0.0
  */
-export const isLeft: <R, L>(self: Either<R, L>) => self is Left<L, R> = either.isLeft
+export const isLeft: <A, E>(self: Either<A, E>) => self is Left<E, A> = either.isLeft
 
 /**
  * Determine if a `Either` is a `Right`.
@@ -328,7 +328,7 @@ export const isLeft: <R, L>(self: Either<R, L>) => self is Left<L, R> = either.i
  * @category guards
  * @since 2.0.0
  */
-export const isRight: <R, L>(self: Either<R, L>) => self is Right<L, R> = either.isRight
+export const isRight: <A, E>(self: Either<A, E>) => self is Right<E, A> = either.isRight
 
 /**
  * Converts a `Either` to an `Option` discarding the `Left`.
@@ -345,7 +345,7 @@ export const isRight: <R, L>(self: Either<R, L>) => self is Right<L, R> = either
  * @category getters
  * @since 2.0.0
  */
-export const getRight: <R, L>(self: Either<R, L>) => Option<R> = either.getRight
+export const getRight: <A, E>(self: Either<A, E>) => Option<A> = either.getRight
 
 /**
  * Converts a `Either` to an `Option` discarding the value.
@@ -362,16 +362,16 @@ export const getRight: <R, L>(self: Either<R, L>) => Option<R> = either.getRight
  * @category getters
  * @since 2.0.0
  */
-export const getLeft: <R, L>(self: Either<R, L>) => Option<L> = either.getLeft
+export const getLeft: <A, E>(self: Either<A, E>) => Option<E> = either.getLeft
 
 /**
  * @category equivalence
  * @since 2.0.0
  */
-export const getEquivalence = <R, L>({ left, right }: {
-  right: Equivalence.Equivalence<R>
-  left: Equivalence.Equivalence<L>
-}): Equivalence.Equivalence<Either<R, L>> =>
+export const getEquivalence = <A, E>({ left, right }: {
+  right: Equivalence.Equivalence<A>
+  left: Equivalence.Equivalence<E>
+}): Equivalence.Equivalence<Either<A, E>> =>
   Equivalence.make((x, y) =>
     isLeft(x) ?
       isLeft(y) && left(x.left, y.left) :
@@ -387,29 +387,29 @@ export const mapBoth: {
    * @category mapping
    * @since 2.0.0
    */
-  <L, L2, R, R2>(
+  <E, E2, A, A2>(
     options: {
-      readonly onLeft: (left: L) => L2
-      readonly onRight: (right: R) => R2
+      readonly onLeft: (left: E) => E2
+      readonly onRight: (right: A) => A2
     }
-  ): (self: Either<R, L>) => Either<R2, L2>
+  ): (self: Either<A, E>) => Either<A2, E2>
   /**
    * @category mapping
    * @since 2.0.0
    */
-  <L, R, L2, R2>(
-    self: Either<R, L>,
+  <A, E, E2, A2>(
+    self: Either<A, E>,
     options: {
-      readonly onLeft: (left: L) => L2
-      readonly onRight: (right: R) => R2
+      readonly onLeft: (left: E) => E2
+      readonly onRight: (right: A) => A2
     }
-  ): Either<R2, L2>
+  ): Either<A2, E2>
 } = dual(
   2,
-  <L, R, L2, R2>(self: Either<R, L>, { onLeft, onRight }: {
-    readonly onLeft: (left: L) => L2
-    readonly onRight: (right: R) => R2
-  }): Either<R2, L2> => isLeft(self) ? left(onLeft(self.left)) : right(onRight(self.right))
+  <A, E, E2, A2>(self: Either<A, E>, { onLeft, onRight }: {
+    readonly onLeft: (left: E) => E2
+    readonly onRight: (right: A) => A2
+  }): Either<A2, E2> => isLeft(self) ? left(onLeft(self.left)) : right(onRight(self.right))
 )
 
 /**
@@ -425,17 +425,17 @@ export 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>
 } = dual(
   2,
-  <R, L1, L2>(self: Either<R, L1>, f: (left: L1) => L2): Either<R, L2> =>
+  <A, E, E2>(self: Either<A, E>, f: (left: E) => E2): Either<A, E2> =>
     isLeft(self) ? left(f(self.left)) : right(self.right)
 )
 
@@ -452,17 +452,17 @@ export 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>
 } = dual(
   2,
-  <R1, L, R2>(self: Either<R1, L>, f: (right: R1) => R2): Either<R2, L> =>
+  <A, E, A2>(self: Either<A, E>, f: (right: A) => A2): Either<A2, E> =>
     isRight(self) ? right(f(self.right)) : left(self.left)
 )
 
@@ -513,12 +513,12 @@ export const match: {
    * @category pattern matching
    * @since 2.0.0
    */
-  <L, B, R, C = B>(
+  <E, B, A, C = B>(
     options: {
-      readonly onLeft: (left: L) => B
-      readonly onRight: (right: R) => C
+      readonly onLeft: (left: E) => B
+      readonly onRight: (right: A) => C
     }
-  ): (self: Either<R, L>) => B | 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.
@@ -542,18 +542,18 @@ export const match: {
    * @category pattern matching
    * @since 2.0.0
    */
-  <R, L, B, C = B>(
-    self: Either<R, L>,
+  <A, E, B, C = B>(
+    self: Either<A, E>,
     options: {
-      readonly onLeft: (left: L) => B
-      readonly onRight: (right: R) => C
+      readonly onLeft: (left: E) => B
+      readonly onRight: (right: A) => C
     }
   ): B | C
 } = dual(
   2,
-  <R, L, B, C = B>(self: Either<R, L>, { onLeft, onRight }: {
-    readonly onLeft: (left: L) => B
-    readonly onRight: (right: R) => C
+  <A, E, B, C = B>(self: Either<A, E>, { onLeft, onRight }: {
+    readonly onLeft: (left: E) => B
+    readonly onRight: (right: A) => C
   }): B | C => isLeft(self) ? onLeft(self.left) : onRight(self.right)
 )
 
@@ -754,10 +754,10 @@ export 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.
@@ -788,7 +788,7 @@ export 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.
@@ -819,11 +819,11 @@ export 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.
@@ -854,18 +854,18 @@ export 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>
-} = dual(3, <R, L, E2>(
-  self: Either<R, L>,
-  predicate: Predicate<R>,
-  orLeftWith: (right: R) => E2
-): Either<R, L | E2> => flatMap(self, (r) => predicate(r) ? right(r) : left(orLeftWith(r))))
+  <A, E, E2>(self: Either<A, E>, predicate: Predicate<A>, orLeftWith: (right: A) => E2): Either<A, E | E2>
+} = dual(3, <A, E, E2>(
+  self: Either<A, E>,
+  predicate: Predicate<A>,
+  orLeftWith: (right: A) => E2
+): Either<A, E | E2> => flatMap(self, (r) => predicate(r) ? right(r) : left(orLeftWith(r))))
 
 /**
  * @category getters
  * @since 2.0.0
  */
-export const merge: <R, L>(self: Either<R, L>) => L | R = match({
+export const merge: <A, E>(self: Either<A, E>) => E | A = match({
   onLeft: identity,
   onRight: identity
 })
@@ -901,7 +901,7 @@ export 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`.
    *
@@ -917,10 +917,10 @@ export 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
 } = dual(
   2,
-  <R, L, B>(self: Either<R, L>, onLeft: (left: L) => B): R | B => isLeft(self) ? onLeft(self.left) : self.right
+  <A, E, A2>(self: Either<A, E>, onLeft: (left: E) => A2): A | A2 => isLeft(self) ? onLeft(self.left) : self.right
 )
 
 /**
@@ -936,7 +936,7 @@ export const getOrElse: {
  * @category getters
  * @since 2.0.0
  */
-export const getOrNull: <R, L>(self: Either<R, L>) => R | null = getOrElse(constNull)
+export const getOrNull: <A, E>(self: Either<A, E>) => A | null = getOrElse(constNull)
 
 /**
  * @example
@@ -951,7 +951,7 @@ export const getOrNull: <R, L>(self: Either<R, L>) => R | null = getOrElse(const
  * @category getters
  * @since 2.0.0
  */
-export const getOrUndefined: <R, L>(self: Either<R, L>) => R | undefined = getOrElse(constUndefined)
+export const getOrUndefined: <A, E>(self: Either<A, E>) => A | undefined = getOrElse(constUndefined)
 
 /**
  * Extracts the value of an `Either` or throws if the `Either` is `Left`.
@@ -994,7 +994,7 @@ export 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`.
    *
@@ -1015,8 +1015,8 @@ export const getOrThrowWith: {
    * @category getters
    * @since 2.0.0
    */
-  <R, L>(self: Either<R, L>, onLeft: (left: L) => unknown): R
-} = dual(2, <R, L>(self: Either<R, L>, onLeft: (left: L) => unknown): R => {
+  <A, E>(self: Either<A, E>, onLeft: (left: E) => unknown): A
+} = dual(2, <A, E>(self: Either<A, E>, onLeft: (left: E) => unknown): A => {
   if (isRight(self)) {
     return self.right
   }
@@ -1043,7 +1043,7 @@ export const getOrThrowWith: {
  * @category getters
  * @since 2.0.0
  */
-export const getOrThrow: <R, L>(self: Either<R, L>) => R = getOrThrowWith(() =>
+export const getOrThrow: <A, E>(self: Either<A, E>) => A = getOrThrowWith(() =>
   new Error("getOrThrow called on a Left")
 )
 
@@ -1060,17 +1060,17 @@ export 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>
 } = dual(
   2,
-  <R1, L1, R2, L2>(self: Either<R1, L1>, that: (left: L1) => Either<R2, L2>): Either<R1 | R2, L2> =>
+  <A, E, A2, E2>(self: Either<A, E>, that: (left: E) => Either<A2, E2>): Either<A | A2, E2> =>
     isLeft(self) ? that(self.left) : right(self.right)
 )
 
@@ -1083,15 +1083,15 @@ export 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>
 } = dual(
   2,
-  <R1, L1, R2, L2>(self: Either<R1, L1>, f: (right: R1) => Either<R2, L2>): Either<R2, L1 | L2> =>
+  <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2>): Either<A2, E | E2> =>
     isLeft(self) ? left(self.left) : f(self.right)
 )
 
@@ -1108,59 +1108,59 @@ export 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>
 } = dual(
   2,
-  <R, L, R2, L2>(self: Either<R, L>, f: (right: R) => Either<R2, L2> | Either<R2, L2>): Either<R2, L | L2> =>
+  <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2> | Either<A2, E2>): Either<A2, E | E2> =>
     flatMap(self, (a) => {
       const b = isFunction(f) ? f(a) : f
       return isEither(b) ? b : right(b)
@@ -1176,15 +1176,15 @@ export 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>
 } = dual(
   3,
-  <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> =>
     flatMap(self, (r) => map(that, (r2) => f(r, r2)))
 )
 
@@ -1197,15 +1197,15 @@ export 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>
 } = dual(
   2,
-  <R, R2, L, L2>(self: Either<(right: R) => R2, L>, that: Either<R, L2>): Either<R2, L | L2> =>
+  <A, E, A2, E2>(self: Either<(right: A) => A2, E>, that: Either<A, E2>): Either<A2, E | E2> =>
     zipWith(self, that, (f, a) => f(a))
 )
 
@@ -1233,13 +1233,13 @@ export const ap: {
 export 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
+    { -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 R, infer L>>] ? Either<Array<R>, L>
+  : [I] extends [Iterable<Either<infer A, infer E>>] ? Either<Array<A>, E>
   : 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[keyof I] extends never ? never : [I[keyof I]] extends [Either<any, infer E>] ? E : never
   > = (
     input: Iterable<Either<any, any>> | Record<string, Either<any, any>>
   ): Either<any, any> => {
@@ -1272,7 +1272,7 @@ export const all: <const I extends Iterable<Either<any, any>> | Record<string, E
  * @since 2.0.0
  * @category mapping
  */
-export const flip = <R, L>(self: Either<R, L>): Either<L, R> => isLeft(self) ? right(self.left) : left(self.right)
+export const flip = <A, E>(self: Either<A, E>): Either<E, A> => isLeft(self) ? right(self.left) : left(self.right)
 
 const adapter = Gen.adapter<EitherTypeLambda>()
 
@@ -1396,7 +1396,7 @@ export 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<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
+  <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 }, 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`.
    *
@@ -1428,11 +1428,11 @@ export const bind: {
    * @category do notation
    * @since 2.0.0
    */
-  <A extends object, L1, N extends string, B, L2>(
-    self: Either<A, L1>,
+  <A extends object, E, N extends string, B, E2>(
+    self: Either<A, E>,
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Either<B, L2>
-  ): Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
+    f: (a: NoInfer<A>) => Either<B, E2>
+  ): Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E | E2>
 } = doNotation.bind<EitherTypeLambda>(map, flatMap)
 
 /**
@@ -1498,7 +1498,7 @@ export 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`.
    *
@@ -1530,19 +1530,19 @@ export 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>
 } = doNotation.bindTo<EitherTypeLambda>(map)
 
 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>
 } = doNotation.let_<EitherTypeLambda>(map)
 
 export {