feat(maybe): introduce flatMapAuto (#68)

Author: patrickmichalina

src/interfaces/maybe.interface.ts

@@ -73,6 +73,11 @@ export interface IMaybe<T> extends IMonad<T> {
    */
   flatMap<R>(f: (t: T) => IMaybe<R>): IMaybe<R>
 
+  /**
+   * Combine multiple Maybe, automatically wrapping predicate
+   */
+  flatMapAuto<R>(f: (t: T) => R): IMaybe<NonNullable<R>>
+
   /**
    * Apply a predicate which if met, continues the Maybe chain,
    * otherwise return an empty Maybe

src/monads/maybe.ts

@@ -12,6 +12,8 @@ const tapSome = <T>(value?: T) => (fn: (val: NonNullable<T>) => void) => isNotEm
 const match = <T>(value?: T) => <R>(pattern: IMaybePattern<T, R>) => isEmpty(value) ? pattern.none() : pattern.some(value as NonNullable<T>)
 const map = <T>(value?: T) => <R>(fn: (t: NonNullable<T>) => R) => isEmpty(value) ? maybe<R>() : maybe<R>(fn(value as NonNullable<T>))
 const flatMap = <T>(value?: T) => <R>(fn: (d: NonNullable<T>) => IMaybe<R>) => isEmpty(value) ? maybe<R>() : fn(value as NonNullable<T>)
+const flatMapAuto = <T>(value?: T) => <R>(fn: (d: NonNullable<T>) => R) => isEmpty(value) ? maybe<R>() : maybe<R>(fn(value as NonNullable<T>))
+
 const filter = <T>(value?: T) =>
   (fn: (d: NonNullable<T>) => boolean) =>
     isEmpty(value)
@@ -34,6 +36,7 @@ export const maybe = <T>(value?: T): IMaybe<NonNullable<T>> => {
     match: match(value),
     map: map(value),
     flatMap: flatMap(value),
+    flatMapAuto: flatMapAuto(value),
     filter: filter(value)
   }
 }

test/monads/maybe.spec.ts

@@ -1,4 +1,4 @@
-import { maybe } from "../../src"
+import { maybe } from '../../src'
 
 describe('Maybe', () => {
   describe('when returning a value by default', () => {
@@ -373,4 +373,42 @@ describe('Maybe', () => {
       expect(maybeThing).toEqual(['actual input'])
     })
   })
+
+  describe('flatMapAuto', () => {
+    it('should flatMapAuto', () => {
+      const sut = {
+        thing: undefined
+      } as { readonly thing: string | undefined } | undefined
+
+      const maybeAString = maybe(sut)
+        .flatMapAuto(a => a.thing)
+        .valueOrUndefined()
+
+      expect(maybeAString).toBeUndefined()
+    })
+
+    it('should flatMapAuto inner', () => {
+      const sut = {
+        thing: 'testval'
+      } as { readonly thing: string | undefined } | undefined
+
+      const maybeAString = maybe(sut)
+        .flatMapAuto(a => a.thing)
+        .map(a => a + 1)
+        .valueOrUndefined()
+
+      expect(maybeAString).toEqual('testval1')
+    })
+
+    it('should flatMapAuto with intial input as empty', () => {
+      const sut = undefined as { readonly thing: string | undefined } | undefined
+
+      const maybeAString = maybe(sut)
+        .flatMapAuto(a => a.thing)
+        .map(a => a + 1)
+        .valueOrUndefined()
+
+      expect(maybeAString).toBeUndefined()
+    })
+  })
 })