MaybeT implements MonadError

Author: jnape

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Changed
 - `IterateT#unfold` now only computes a single `Pure` for the given input
 - `ReaderT#fmap` and `StateT#fmap` avoid unnecessary calls to `pure`
+- `MaybeT` implements `MonadError`
 
 ### Added
 - `$`, function application represented as a higher-order `Fn2`

src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/MaybeT.java

@@ -1,6 +1,7 @@
 package com.jnape.palatable.lambda.monad.transformer.builtin;
 
 import com.jnape.palatable.lambda.adt.Maybe;
+import com.jnape.palatable.lambda.adt.Unit;
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.recursion.RecursiveResult;
 import com.jnape.palatable.lambda.functions.specialized.Lift;
@@ -9,13 +10,16 @@
 import com.jnape.palatable.lambda.functor.builtin.Compose;
 import com.jnape.palatable.lambda.functor.builtin.Lazy;
 import com.jnape.palatable.lambda.monad.Monad;
+import com.jnape.palatable.lambda.monad.MonadError;
 import com.jnape.palatable.lambda.monad.MonadRec;
 import com.jnape.palatable.lambda.monad.transformer.MonadT;
 
 import java.util.Objects;
 
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+import static com.jnape.palatable.lambda.functions.Fn0.fn0;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 import static com.jnape.palatable.lambda.functions.recursion.RecursiveResult.terminate;
 
@@ -26,7 +30,7 @@
  * @param <A> the carrier type
  */
 public final class MaybeT<M extends MonadRec<?, M>, A> implements
-        MonadT<M, A, MaybeT<M, ?>, MaybeT<?, ?>> {
+        MonadT<M, A, MaybeT<M, ?>, MaybeT<?, ?>>, MonadError<Unit, A, MaybeT<M, ?>> {
 
     private final MonadRec<Maybe<A>, M> mma;
 
@@ -67,6 +71,24 @@ public MaybeT<M, A> or(MaybeT<M, A> other) {
                                                              a -> mMaybeA.pure(just(a)))));
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public MaybeT<M, A> throwError(Unit unit) {
+        return maybeT(mma.pure(nothing()));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public MaybeT<M, A> catchError(Fn1<? super Unit, ? extends Monad<A, MaybeT<M, ?>>> recoveryFn) {
+        return maybeT(mma.flatMap(maybeA -> maybeA.match(
+                fn0(() -> recoveryFn.apply(UNIT).<MaybeT<M, A>>coerce().runMaybeT()),
+                a -> mma.pure(just(a)))));
+    }
+
     /**
      * {@inheritDoc}
      */

src/test/java/com/jnape/palatable/lambda/monad/transformer/builtin/MaybeTTest.java

@@ -22,14 +22,18 @@
 import static com.jnape.palatable.lambda.adt.Either.right;
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.GT.gt;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.LT.lt;
 import static com.jnape.palatable.lambda.functor.builtin.Identity.pureIdentity;
 import static com.jnape.palatable.lambda.functor.builtin.Lazy.lazy;
 import static com.jnape.palatable.lambda.io.IO.io;
-import static com.jnape.palatable.lambda.monad.transformer.builtin.MaybeT.*;
+import static com.jnape.palatable.lambda.monad.transformer.builtin.MaybeT.liftMaybeT;
+import static com.jnape.palatable.lambda.monad.transformer.builtin.MaybeT.maybeT;
+import static com.jnape.palatable.lambda.monad.transformer.builtin.MaybeT.pureMaybeT;
 import static com.jnape.palatable.traitor.framework.Subjects.subjects;
 import static org.junit.Assert.assertEquals;
+import static testsupport.assertion.MonadErrorAssert.assertLaws;
 
 @RunWith(Traits.class)
 public class MaybeTTest {
@@ -41,6 +45,13 @@ public class MaybeTTest {
                         maybeT(left("foo")));
     }
 
+    @Test
+    public void monadError() {
+        assertLaws(subjects(maybeT(new Identity<>(nothing())), maybeT(new Identity<>(just(1)))),
+                   UNIT,
+                   e -> maybeT(new Identity<>(just(2))));
+    }
+
     @Test
     public void lazyZip() {
         assertEquals(maybeT(right(just(2))),