feat: introduce isSome/isNone functions (#82)

Author: patrickmichalina

package-lock.json

@@ -38,11 +38,11 @@
     "istanbul": "^0.4.5",
     "jest": "24.5.0",
     "jest-junit": "^6.3.0",
-    "rollup": "^1.7.4",
+    "rollup": "^1.8.0",
     "semantic-release": "^15.13.3",
     "ts-jest": "^24.0.1",
     "ts-node": "^8.0.3",
-    "tslint": "^5.14.0",
+    "tslint": "^5.15.0",
     "tslint-immutable": "^5.5.2",
     "typescript": "^3.4.1",
     "uglify-js": "^3.5.3"

package.json

@@ -73,6 +73,16 @@ export interface IMaybe<T> extends IMonad<T> {
    */
   map<R>(f: (t: T) => R): IMaybe<R>
 
+  /**
+   * Returns true if value is not empty
+   */
+  isSome(): boolean
+
+  /**
+   * Return true if value is empty
+   */
+  isNone(): boolean
+
   /**
    * Combine multiple Maybe
    */

src/interfaces/maybe.interface.ts

@@ -2,6 +2,8 @@ import { IMaybe, IMaybePattern } from '../interfaces'
 
 const isEmpty = <T>(value: T) => value === null || value === undefined
 const isNotEmpty = <T>(value: T) => !isEmpty(value)
+const isSome = <T>(value: T) => () => isNotEmpty(value)
+const isNone = <T>(value: T) => () => isEmpty(value)
 const valueOr = <T>(value?: T) => (val: NonNullable<T>) => isEmpty(value) ? val : value as NonNullable<T>
 const valueOrUndefined = <T>(value?: T) => () => isEmpty(value) ? undefined : value as NonNullable<T>
 const toArray = <T>(value?: T) => () => isEmpty(value) ? [] : Array.isArray(value) ? value : [value as NonNullable<T>]
@@ -23,10 +25,11 @@ const filter = <T>(value?: T) =>
         ? maybe(value as NonNullable<T>)
         : maybe<T>()
 
-
 export const maybe = <T>(value?: T): IMaybe<NonNullable<T>> => {
   return {
     of: maybe,
+    isSome: isSome(value),
+    isNone: isNone(value),
     valueOr: valueOr(value),
     valueOrUndefined: valueOrUndefined(value),
     valueOrCompute: valueOrCompute(value),

src/monads/maybe.ts

@@ -425,4 +425,45 @@ describe('Maybe', () => {
       expect(maybeAString).toBeUndefined()
     })
   })
+
+  describe('isSome', () => {
+    it('false path', () => {
+      const sut = undefined as boolean | undefined
+      const sut2 = null as boolean | null
+
+      expect(maybe(sut).isSome()).toEqual(false)
+      expect(maybe(sut2).isSome()).toEqual(false)
+    })
+
+    it('true path', () => {
+      const sut = 'test' as string | undefined
+      const sut2 = 2 as number | undefined
+      const sut3 = false as boolean
+
+      expect(maybe(sut).isSome()).toEqual(true)
+      expect(maybe(sut2).isSome()).toEqual(true)
+      expect(maybe(sut3).isSome()).toEqual(true)
+      expect(maybe(sut).map(a => `${a}_1`).isSome()).toEqual(true)
+    })
+  })
+
+  describe('isNone', () => {
+    it('true path', () => {
+      const sut = undefined as boolean | undefined
+      const sut2 = null as boolean | null
+
+      expect(maybe(sut).isNone()).toEqual(true)
+      expect(maybe(sut2).isNone()).toEqual(true)
+    })
+
+    it('false path', () => {
+      const sut = 'test' as string | undefined
+      const sut2 = 2 as number | undefined
+      const sut3 = true as boolean | undefined
+
+      expect(maybe(sut).isNone()).toEqual(false)
+      expect(maybe(sut2).isNone()).toEqual(false)
+      expect(maybe(sut3).isNone()).toEqual(false)
+    })
+  })
 })