feat: adds equality checks and extraction methods to Maybe

Author: richecr

src/maybe/Maybe.ts

@@ -6,10 +6,13 @@ export interface Maybe<T> {
   chain<U>(fn: (value: T) => Maybe<U>): Maybe<U>;
   unwrapOr(defaultValue: T): T;
   match<U>(cases: { just: (value: T) => U; nothing: () => U }): U;
+  equals(other: Maybe<T>): boolean;
+
+  extract(): T;
 }
 
 export class Just<T> implements Maybe<T> {
-  constructor(private readonly value: T) {}
+  constructor(private readonly value: T) { }
 
   isJust(): boolean {
     return true;
@@ -34,6 +37,14 @@ export class Just<T> implements Maybe<T> {
   match<U>(cases: { just: (value: T) => U; nothing: () => U }): U {
     return cases.just(this.value);
   }
+
+  equals(other: Maybe<T>): boolean {
+    return other.isJust() ? this.value === other.extract() : false;
+  }
+
+  extract(): T {
+    return this.value;
+  }
 }
 
 export class Nothing<T> implements Maybe<T> {
@@ -60,6 +71,14 @@ export class Nothing<T> implements Maybe<T> {
   match<U>(cases: { just: (value: T) => U; nothing: () => U }): U {
     return cases.nothing();
   }
+
+  equals(other: Maybe<T>): boolean {
+    return other.isNothing();
+  }
+
+  extract(): T {
+    return undefined as T;
+  }
 }
 
 export const fromNullable = <T>(value: T | null | undefined): Maybe<T> => {
@@ -87,3 +106,7 @@ export const matchM = <T, U>(
 ) => (maybe: Maybe<T>): U => {
   return maybe.match(cases);
 };
+
+export const equalsM = <T>(other: Maybe<T>) => (maybe: Maybe<T>): boolean => {
+  return maybe.equals(other);
+};

tests/maybe.test.ts

@@ -1,5 +1,6 @@
 import { pipe } from "rambda";
 import { Just, Nothing, fromNullable, chainM, mapM, unwrapOrM, matchM } from "../src/maybe";
+import { equalsM } from "../src/maybe/Maybe";
 
 describe("Maybe", () => {
   it("should map over Just", () => {
@@ -45,6 +46,28 @@ describe("Maybe", () => {
     expect(justMsg).toBe("Temos value");
     expect(nothingMsg).toBe("Nada aqui");
   });
+
+  it("should check equality between Just and Nothing", () => {
+    const just1 = new Just(10);
+    const just2 = new Just(10);
+    const nothing1 = new Nothing<number>();
+    const nothing2 = new Nothing<number>();
+
+    expect(just1.equals(just2)).toBe(true);
+    expect(just1.equals(nothing1)).toBe(false);
+    expect(nothing1.equals(nothing2)).toBe(true);
+  });
+
+  it("should check equality with different values", () => {
+    const just1 = new Just(10);
+    const just2 = new Just(20);
+    const nothing1 = new Nothing<number>();
+    const nothing2 = new Nothing<number>();
+
+    expect(just1.equals(just2)).toBe(false);
+    expect(just1.equals(nothing1)).toBe(false);
+    expect(nothing1.equals(nothing2)).toBe(true);
+  });
 });
 
 describe("Maybe fromNullable", () => {
@@ -134,6 +157,29 @@ describe("Maybe - Curried Helpers", () => {
     );
     expect(result).toBe("Nada aqui");
   });
+
+  it("should check equality with curried equals", () => {
+    const just1 = new Just(10);
+    const just2 = new Just(10);
+    const nothing1 = new Nothing<number>();
+    const nothing2 = new Nothing<number>();
+
+    expect(pipe(just1, equalsM(just2))).toBe(true);
+    expect(pipe(just1, equalsM(nothing1))).toBe(false);
+    expect(pipe(nothing1, equalsM(nothing2))).toBe(true);
+  });
+
+  it("should check extract value from Just", () => {
+    const just = new Just(10);
+    const result = just.extract();
+    expect(result).toBe(10);
+  });
+
+  it("should check extract value from Nothing", () => {
+    const nothing = new Nothing<number>();
+    const result = nothing.extract();
+    expect(result).toBe(undefined);
+  });
 });