fix: correct usage of maybe.apply (#198)

BREAKING CHANGE: apply signature changed

src/maybe/maybe.interface.ts

@@ -138,7 +138,9 @@ export interface IMaybe<T> extends IMonad<T> {
    * Apply a function wrapped in Maybe
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  apply(maybe: IMaybe<ReturnType<T extends (...args: any) => any ? T : any>>): IMaybe<T>
+  // apply(maybe: IMaybe<ReturnType<T extends (...args: any) => any ? T : any>>): IMaybe<T>
+
+  apply<R>(fab: IMaybe<(t: T) => R>): IMaybe<R>
 
   toResult<E>(error: E): IResult<T, E>
 }

src/maybe/maybe.spec.ts

@@ -573,18 +573,30 @@ describe('Maybe', () => {
   })
 
   describe('apply', () => {
+    it('should return none in nullish cases', () => {
+      const thisNone = maybe<number>()
+      const fnNone = maybe<(n: number) => number>()
+      const thisSome = maybe(5)
+      const fnSome = maybe((a: number) => a * 2)
+
+      expect(thisNone.apply(fnNone).isNone()).toBe(true)
+      expect(thisNone.apply(fnSome).isNone()).toBe(true)
+      expect(thisSome.apply(fnNone).isNone()).toBe(true)
+    })
+
     it('should apply the IMaybe<function>', () => {
-      const a = maybe((a: number) => a * 2)
-      const b = maybe(5)
+      const a = maybe(5) 
+      const b = maybe((a: number) => a * 2)
 
       expect(a.apply(b).valueOrThrow()).toBe(10)
     })
 
-    it('should apply the non-function maybe', () => {
+    it('should apply none objects gracefully', () => {
       const a = maybe(2)
-      const b = maybe(5)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const b: Maybe<(a: number) => number> = maybe(() => undefined as any)
 
-      expect(a.apply(b).valueOrThrow()).toBe(5)
+      expect(a.apply(b).isNone()).toBe(true)
     })
   })
 

src/maybe/maybe.ts

@@ -129,9 +129,8 @@ export class Maybe<T> implements IMaybe<T>  {
         : new Maybe<T>()
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public apply(maybe: IMaybe<ReturnType<T extends (...args: any) => any ? T : any>>): IMaybe<NonNullable<T>> {
-    return maybe.flatMap(a => this.map(b => typeof b === 'function' ? b(a) : a))
+  public apply<R>(maybeFn: IMaybe<(t: NonNullable<T>) => R>): IMaybe<NonNullable<R>> {
+    return this.flatMap(v => maybeFn.flatMapAuto(f => f(v)))
   }
 
   public toResult<E>(error: E): IResult<T, E> {