feat: introduce util functions (#15)

BREAKING CHANGE: separated interfaces/monads/util into their own folders. Any previously referenced interfaces must be changed to import from "typescript-monads/interfaces".

Author: patrickmichalina

package.json

@@ -20,6 +20,7 @@
   ],
   "scripts": {
     "test": "jest",
+    "test.watch": "jest --watch",
     "build": "tsc",
     "dist": "node_modules/.bin/ts-node ./scripts/publish-prep.ts",
     "lint": "tslint --project tsconfig.json --config tslint.json"
@@ -48,14 +49,15 @@
   "jest": {
     "testURL": "http://localhost",
     "collectCoverage": true,
+    "collectCoverageFrom": ["src/**/*.ts"],
     "reporters": [
       "default",
       "jest-junit"
     ],
     "transform": {
       "^.+\\.tsx?$": "ts-jest"
     },
-    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(ts?)$",
     "moduleFileExtensions": [
       "ts",
       "tsx",

src/index.ts

@@ -1,4 +1,4 @@
-export { monad, IMonad } from './monad'
-export { maybe, IMaybe, IMaybePattern } from './maybe'
-export { either, IEither, IEitherPattern } from './either'
-export { reader, IReader } from './reader'
+export { monad } from './monads/monad'
+export { maybe } from './monads/maybe'
+export { either } from './monads/either'
+export { reader } from './monads/reader'

src/interfaces/either.interface.ts

@@ -0,0 +1,12 @@
+export interface IEither<L, R> {
+  isLeft(): boolean
+  isRight(): boolean
+  match<T>(pattern: IEitherPattern<L, R, T>): T
+  map<T>(f: (r: R) => T): IEither<L, T>
+  flatMap<T>(f: (r: R) => IEither<L, T>): IEither<L, T>
+}
+
+export interface IEitherPattern<L, R, T> {
+  left(l: L): T
+  right(r: R): T
+}

src/interfaces/index.ts

@@ -0,0 +1,4 @@
+export { IEither, IEitherPattern } from './either.interface'
+export { IMaybe, IMaybePattern } from './maybe.interface'
+export { mapping, IMonad } from './monad.interface'
+export { IReader } from './reader.interface'

src/maybe.ts renamed to src/interfaces/maybe.interface.ts

@@ -1,4 +1,4 @@
-import { IMonad } from "./monad"
+import { IMonad } from "./monad.interface"
 
 /**
  * Define a contract to unwrap Maybe object
@@ -51,16 +51,4 @@ export interface IMaybe<T> extends IMonad<T> {
 
   // tslint:disable-next-line:readonly-array
   of(x?: T, ...args: any[]): IMaybe<T>
-}
-
-export function maybe<T>(value?: T): IMaybe<T> {
-  return {
-    of: (x) => maybe(x),
-    valueOr: (val: T) => value === null || value === undefined ? val : value,
-    valueOrCompute: (f: () => T) => value === null || value === undefined ? f() : value,
-    tap: (obj: IMaybePattern<T, void>) => value === null || value === undefined ? obj.none() : obj.some(value),
-    match: <R>(pattern: IMaybePattern<T, R>) => value === null || value === undefined ? pattern.none() : pattern.some(value),
-    map: <R>(f: (t: T) => R) => value === null || value === undefined ? maybe<R>() : maybe<R>(f(value)),
-    flatMap: <R>(f: (d: T) => IMaybe<R>) => value === null || value === undefined ? maybe<R>() : f(value)
-  }
 }

src/interfaces/monad.interface.ts

@@ -0,0 +1,7 @@
+// tslint:disable:readonly-array
+export type mapping<T, U> = (x: T, ...args: any[]) => U
+
+export interface IMonad<T> {
+  of(x: T, ...args: any[]): IMonad<T>
+  flatMap<U>(f: mapping<T, IMonad<U>>): IMonad<U>
+}

src/interfaces/reader.interface.ts

@@ -0,0 +1,6 @@
+export interface IReader<E, A> {
+  of(fn: (config: E) => A): IReader<E, A>,
+  run(config: E): A,
+  map<B>(fn: (val: A) => B): IReader<E, B>
+  flatMap<B>(fn: (val: A) => IReader<E, B>): IReader<E, B>,
+}

src/either.ts renamed to src/monads/either.ts

@@ -1,15 +1,4 @@
-export interface IEither<L, R> {
-  isLeft(): boolean
-  isRight(): boolean
-  match<T>(pattern: IEitherPattern<L, R, T>): T
-  map<T>(f: (r: R) => T): IEither<L, T>
-  flatMap<T>(f: (r: R) => IEither<L, T>): IEither<L, T>
-}
-
-export interface IEitherPattern<L, R, T> {
-  left(l: L): T
-  right(r: R): T
-}
+import { IEither, IEitherPattern } from "../interfaces"
 
 function exists<T>(t: T) {
   return t !== null && t !== undefined

src/monads/maybe.ts

@@ -0,0 +1,13 @@
+import { IMaybe, IMaybePattern } from "../interfaces"
+
+export function maybe<T>(value?: T): IMaybe<T> {
+  return {
+    of: (x) => maybe(x),
+    valueOr: (val: T) => value === null || value === undefined ? val : value,
+    valueOrCompute: (f: () => T) => value === null || value === undefined ? f() : value,
+    tap: (obj: IMaybePattern<T, void>) => value === null || value === undefined ? obj.none() : obj.some(value),
+    match: <R>(pattern: IMaybePattern<T, R>) => value === null || value === undefined ? pattern.none() : pattern.some(value),
+    map: <R>(f: (t: T) => R) => value === null || value === undefined ? maybe<R>() : maybe<R>(f(value)),
+    flatMap: <R>(f: (d: T) => IMaybe<R>) => value === null || value === undefined ? maybe<R>() : f(value)
+  }
+}

src/monad.ts renamed to src/monads/monad.ts

@@ -1,11 +1,6 @@
-// tslint:disable:readonly-array
-export type mapping<T, U> = (x: T, ...args: any[]) => U
-
-export interface IMonad<T> {
-  of(x: T, ...args: any[]): IMonad<T>
-  flatMap<U>(f: mapping<T, IMonad<U>>): IMonad<U>
-}
+import { mapping, IMonad } from "../interfaces"
 
+// tslint:disable:readonly-array
 export function monad<T>(x: T, ...args: any[]): IMonad<T> {
   return {
     of: (x: T, ...args: any[]) => monad<T>(x, ...args),