EitherT exposes the nested Either's bifunctor properties

jnape · jnape · commit 9e238bf12bca · 2019-05-25T14:52:01.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/EitherT.java b/src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/EitherT.java
@@ -3,6 +3,7 @@
 import com.jnape.palatable.lambda.adt.Either;
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.builtin.Compose;
 import com.jnape.palatable.lambda.functor.builtin.Lazy;
 import com.jnape.palatable.lambda.monad.Monad;
@@ -20,7 +21,9 @@
  * @param <L> the left type
  * @param <R> the right type
  */
-public final class EitherT<M extends Monad<?, M>, L, R> implements MonadT<M, Either<L, ?>, R> {
+public final class EitherT<M extends Monad<?, M>, L, R> implements
+        Bifunctor<L, R, EitherT<M, ?, ?>>,
+        MonadT<M, Either<L, ?>, R> {
 
     private final Monad<Either<L, R>, M> melr;
 
@@ -100,6 +103,31 @@ public <B> EitherT<M, L, R> discardR(Applicative<B, MonadT<M, Either<L, ?>, ?>>
         return MonadT.super.discardR(appB).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public <L2, R2> EitherT<M, L2, R2> biMap(Fn1<? super L, ? extends L2> lFn,
+                                             Fn1<? super R, ? extends R2> rFn) {
+        return eitherT(melr.fmap(e -> e.biMap(lFn, rFn)));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public <L2> EitherT<M, L2, R> biMapL(Fn1<? super L, ? extends L2> fn) {
+        return (EitherT<M, L2, R>) Bifunctor.super.<L2>biMapL(fn);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public <R2> EitherT<M, L, R2> biMapR(Fn1<? super R, ? extends R2> fn) {
+        return (EitherT<M, L, R2>) Bifunctor.super.<R2>biMapR(fn);
+    }
+
     @Override
     public boolean equals(Object other) {
         return other instanceof EitherT<?, ?, ?> && Objects.equals(melr, ((EitherT<?, ?, ?>) other).melr);
diff --git a/src/test/java/com/jnape/palatable/lambda/monad/transformer/builtin/EitherTTest.java b/src/test/java/com/jnape/palatable/lambda/monad/transformer/builtin/EitherTTest.java
@@ -7,6 +7,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import testsupport.traits.ApplicativeLaws;
+import testsupport.traits.BifunctorLaws;
 import testsupport.traits.FunctorLaws;
 import testsupport.traits.MonadLaws;
 
@@ -22,7 +23,7 @@
 @RunWith(Traits.class)
 public class EitherTTest {
 
-    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class})
+    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, BifunctorLaws.class})
     public Subjects<EitherT<Identity<?>, String, Integer>> testSubject() {
         return subjects(eitherT(new Identity<>(left("foo"))), eitherT(new Identity<>(right(1))));
     }
