feat: added funtion equals for Either

Author: richecr

src/either/Either.ts

@@ -7,10 +7,13 @@ export interface Either<L, R> {
   chain<U>(fn: (value: R) => Either<L, U>): Either<L, U>;
   unwrapOr(defaultValue: R): R;
   match<T>(cases: { left: (left: L) => T; right: (right: R) => T }): T;
+  equals(other: Either<L, R>): boolean;
+
+  extract(): L | R;
 }
 
 export class Right<L, R> implements Either<L, R> {
-  constructor(private readonly value: R) {}
+  constructor(private readonly value: R) { }
 
   isLeft(): boolean {
     return false;
@@ -39,10 +42,18 @@ export class Right<L, R> implements Either<L, R> {
   match<T>(cases: { left: (left: L) => T; right: (right: R) => T }): T {
     return cases.right(this.value);
   }
+
+  equals(other: Either<L, R>): boolean {
+    return other.isRight() ? this.value === other.extract() : false;
+  }
+
+  extract(): R {
+    return this.value;
+  }
 }
 
 export class Left<L, R = unknown> implements Either<L, R> {
-  constructor(private readonly value: L) {}
+  constructor(private readonly value: L) { }
 
   isLeft(): boolean {
     return true;
@@ -71,6 +82,14 @@ export class Left<L, R = unknown> implements Either<L, R> {
   match<T>(cases: { left: (left: L) => T; right: (right: R) => T }): T {
     return cases.left(this.value);
   }
+
+  equals(other: Either<L, R>): boolean {
+    return other.isLeft() ? this.value === other.extract() : false;
+  }
+
+  extract(): L {
+    return this.value;
+  }
 }
 
 export const tryCatch = <L = unknown, R = unknown>(
@@ -138,3 +157,9 @@ export const matchE = <L, R, T>(
 ) => (either: Either<L, R>): T => {
   return either.match(cases);
 };
+
+export const equalsE = <L, R>(
+  other: Either<L, R>
+) => (either: Either<L, R>): boolean => {
+  return either.equals(other);
+};

tests/either.test.ts

@@ -1,5 +1,6 @@
 import { pipe } from "rambda";
 import { chainE, fromAsync, fromPromise, Left, mapE, mapLeftE, matchE, Right, tryCatch, unwrapOrE } from "../src/either";
+import { equalsE } from "../src/either/Either";
 
 describe("Either", () => {
   it("Right.map applies function to value", () => {
@@ -88,6 +89,30 @@ describe("Either", () => {
     expect(new Left("x").isLeft()).toBe(true);
   });
 
+  it("Right.equals returns true for equal Right values", () => {
+    const a = new Right(42);
+    const b = new Right(42);
+    expect(a.equals(b)).toBe(true);
+  });
+
+  it("Left.equals returns true for equal Left values", () => {
+    const a = new Left("error");
+    const b = new Left("error");
+    expect(a.equals(b)).toBe(true);
+  });
+
+  it("Right.equals returns false for different Right values", () => {
+    const a = new Right(42);
+    const b = new Right(43);
+    expect(a.equals(b)).toBe(false);
+  });
+
+  it("Left.equals returns false for different Left values", () => {
+    const a = new Left("error");
+    const b = new Left("different error");
+    expect(a.equals(b)).toBe(false);
+  });
+
   it("tryCatch should return Right when function succeeds", () => {
     const result = tryCatch(() => JSON.parse('{"a":1}'));
     expect(result.isRight()).toBe(true);
@@ -294,4 +319,53 @@ describe("Either - Curried Helpers", () => {
     );
     expect(result).toBe("error: Bad Request");
   });
+
+  it("should return true for equal Right values with curried equals", () => {
+    const result = pipe(
+      new Right(42),
+      equalsE(new Right(42))
+    );
+    expect(result).toBe(true);
+  });
+
+  it("should return false for different Right values with curried equals", () => {
+    const result = pipe(
+      new Right(42),
+      equalsE(new Right(43))
+    );
+    expect(result).toBe(false);
+  });
+
+  it("should return true for equal Left values with curried equals", () => {
+    const result = pipe(
+      new Left("error"),
+      equalsE(new Left("error"))
+    );
+    expect(result).toBe(true);
+  });
+
+  it("should return false for different Left values with curried equals", () => {
+    const result = pipe(
+      new Left("error"),
+      equalsE(new Left("different error"))
+    );
+    expect(result).toBe(false);
+  });
+
+  it("should return false for different Left and Right values with curried equals", () => {
+    const result = pipe(
+      new Left<string, number>("error"),
+      equalsE(new Right(42))
+    );
+    expect(result).toBe(false);
+  });
+
+  it("should return false for different Right and Left values with curried equals", () => {
+    const result = pipe(
+      new Right<string, number>(42),
+      equalsE(new Left("error"))
+    );
+    expect(result).toBe(false);
+  });
+
 });