feat: introduce tapThru, tapThruSome, tapThruNone (#196)

Author: patrickmichalina

src/maybe/maybe.interface.ts

@@ -73,6 +73,21 @@ export interface IMaybe<T> extends IMonad<T> {
    */
   tapSome(f: (val: T) => void): void
 
+  /**
+   * Execute functions with side-effects.
+   */
+  tapThru(val: Partial<IMaybePattern<T, void>>): IMaybe<T>
+
+  /**
+   * Execute a function with side-effects when maybe is a none.
+   */
+  tapThruNone(f: () => void): IMaybe<T>
+
+  /**
+   * Execute a function with side-effects when maybe is a some.
+   */
+  tapThruSome(f: (val: T) => void): IMaybe<T>
+
   /**
    * Unwrap and apply MaybePattern functions
    */

src/maybe/maybe.spec.ts

@@ -1,4 +1,4 @@
-import { maybe } from './public_api'
+import { maybe, none } from './public_api'
 import { Maybe } from './maybe'
 
 describe('Maybe', () => {
@@ -616,4 +616,64 @@ describe('Maybe', () => {
       expect(sut.unwrapFail()).toEqual(new Error('oops'))
     })
   })
+
+  describe('tapThruSome', () => {
+    it('should tapThruSome', () => {
+      // eslint-disable-next-line prefer-const
+      let variable: undefined | number = undefined
+      const hasSome = maybe(1)
+      const sut = hasSome.tapThruSome((v) => {
+        variable = v + 9
+      })
+      expect(sut.isSome()).toBeTruthy()
+      expect(sut.valueOrThrowErr()).toEqual(1)
+      expect(variable).toEqual(10)
+      expect(sut).toBeInstanceOf(Maybe)
+    })
+  })
+
+  describe('tapThruNone', () => {
+    it('should tapThruNone', () => {
+      // eslint-disable-next-line prefer-const
+      let variable: undefined | string = undefined
+      const hasSome = none<string>()
+      const sut = hasSome.tapThruNone(() => {
+        variable = 'whatever'
+      })
+      expect(sut.isNone()).toBeTruthy()
+      expect(sut.valueOrUndefined()).toBeUndefined()
+      expect(variable).toEqual('whatever')
+      expect(sut).toBeInstanceOf(Maybe)
+    })
+  })
+
+  describe('tapThru', () => {
+    it('should tap on some ', () => {
+      // eslint-disable-next-line prefer-const
+      let variable: undefined | string = undefined
+      const hasSome = maybe<string>('hi there')
+      const sut = hasSome.tapThru({
+        none: () => {},
+        some: (v) => { variable = v + ' joe'}
+      })
+      expect(sut.isSome()).toBeTruthy()
+      expect(sut.valueOrThrowErr()).toBeTruthy()
+      expect(variable).toEqual('hi there joe')
+      expect(sut).toBeInstanceOf(Maybe)
+    })
+
+    it('should tap on none ', () => {
+      // eslint-disable-next-line prefer-const
+      let variable: undefined | string = undefined
+      const hasSome = none<string>()
+      const sut = hasSome.tapThru({
+        none: () => { variable = 'sorry joe' },
+        some: (v) => { variable = v + ' joe' }
+      })
+      expect(sut.isNone()).toBeTruthy()
+      expect(sut.valueOrUndefined()).toBeUndefined()
+      expect(variable).toEqual('sorry joe')
+      expect(sut).toBeInstanceOf(Maybe)
+    })
+  })
 })

src/maybe/maybe.ts

@@ -5,7 +5,7 @@ import { IMaybePattern, IMaybe } from './maybe.interface'
 export class Maybe<T> implements IMaybe<T>  {
 
   constructor(private readonly value?: T | null) { }
-
+  
   public of(value: T): IMaybe<T> {
     return new Maybe<T>(value)
   }
@@ -66,6 +66,21 @@ export class Maybe<T> implements IMaybe<T>  {
     (this.isSome()) && fn(this.value as NonNullable<T>)
   }
 
+  public tapThru(val: Partial<IMaybePattern<T, void>>): IMaybe<T> {
+    this.tap(val)
+    return this
+  }
+
+  public tapThruNone(fn: () => void): IMaybe<T> {
+    this.tapNone(fn)
+    return this
+  }
+
+  public tapThruSome(fn: (val: T) => void): IMaybe<T> {
+    this.tapSome(fn)
+    return this
+  }
+
   public match<R>(pattern: IMaybePattern<T, R>): R {
     return this.isNone()
       ? pattern.none()