add MonadError (#47)

Author: gcanti

src/Either.js

@@ -8,6 +8,7 @@ import type { Foldable } from './Foldable'
 import type { Applicative } from './Applicative'
 import type { Traversable } from './Traversable'
 import type { Semigroup } from './Semigroup'
+import type { MonadError } from './MonadError'
 
 import { HKT } from './HKT'
 import { unsafeCoerce } from './Unsafe'
@@ -126,6 +127,21 @@ export function traverse<F, L, A, B>(applicative: Applicative<F>, f: (a: A) => H
   return applicative.map(of, f(a.value0))
 }
 
+export function getMonadError<E>(): MonadError<E, HKT<IsEither, E>> {
+  return {
+    of,
+    map,
+    ap,
+    chain,
+    throwError<A>(e: E): Either<E, A> {
+      return left(e)
+    },
+    catchError<A>(ma: Either<E, A>, handler: (e: E) => Either<E, A>): Either<E, A> {
+      return either(handler, right, ma)
+    }
+  }
+}
+
 export function concat<L, R>(semigroup: Semigroup<R>): (fx: Either<L, R>, fy: Either<L, R>) => Either<L, R> {
   return function concat(fx, fy) {
     const x = prj(fx)

src/Maybe.js

@@ -11,6 +11,8 @@ import type { Alternative } from './Alternative'
 import type { Extend } from './Extend'
 import type { Setoid } from './Setoid'
 import type { Traversable } from './Traversable'
+import type { MonadError } from './MonadError'
+
 import { id } from './Identity'
 
 class IsMaybe {}
@@ -121,6 +123,15 @@ export function traverse<F, A, B>(applicative: Applicative<F>, f: (a: A) => HKT<
   return applicative.map(of, f(a))
 }
 
+export function throwError<A>(e: void): Maybe<A> { // eslint-disable-line no-unused-vars
+  return Nothing
+}
+
+export function catchError<A>(ma: Maybe<A>, handler: (e: void) => Maybe<A>): Maybe<A> {
+  const a = prj(ma)
+  return a == null ? handler() : ma
+}
+
 export function getSetoid<A>(setoid: Setoid<A>): Setoid<Maybe<A>> {
   return {
     equals(fx, fy) {
@@ -185,12 +196,15 @@ if (false) { // eslint-disable-line
     alt,
     pempty,
     extend,
-    traverse
+    traverse,
+    throwError,
+    catchError
   }: Monad<IsMaybe> &
      Foldable<IsMaybe> &
      Alt<IsMaybe> &
      Plus<IsMaybe> &
      Alternative<IsMaybe> &
      Extend<IsMaybe> &
-     Traversable<IsMaybe>)
+     Traversable<IsMaybe> &
+     MonadError<*, IsMaybe>)
 }

src/MonadError.js

@@ -0,0 +1,44 @@
+// @flow
+import type { Monad } from './Monad'
+import type { Maybe } from './Maybe'
+
+import { HKT } from './HKT'
+import * as maybe from './Maybe'
+
+// The `MonadError` type class represents those monads which support errors via
+// `throwError` and `catchError`.
+//
+// - `throwError e` throws the error `e`
+// - `catchError x f` calls the error handler `f` if an error is thrown during the
+//   evaluation of `x`.
+//
+// An implementation is provided for `ErrorT`, and for other monad transformers
+// defined in this library.
+//
+// Laws:
+//
+// - Left zero: `throwError e >>= f = throwError e`
+// - Catch: `catchError (throwError e) f = f e`
+// - Pure: `catchError (pure a) f = pure a`
+//
+
+export interface MonadError<E, M> extends Monad<M> {
+  throwError<A>(e: E): HKT<M, A>,
+  catchError<A>(ma: HKT<M, A>, handler: (e: E) => HKT<M, A>): HKT<M, A>
+}
+
+// This function allows you to provide a predicate for selecting the
+// exceptions that you're interested in, and handle only those exceptons.
+// If the inner computation throws an exception, and the predicate returns
+// Nothing, then the whole computation will still fail with that exception.
+export function catchJust<E, M, A, B>(
+    monadError: MonadError<E, M>,
+    predicate: (e: E) => Maybe<B>,
+    ma: HKT<M, A>,
+    handler: (b: B) => HKT<M, A>
+  ): HKT<M, A> {
+  return monadError.catchError(ma, e => {
+    const b = maybe.prj(predicate(e))
+    return b == null ? monadError.throwError(e) : handler(b)
+  })
+}