Add MonadError instance for EitherT that recovers from F[_] errors.

core/src/main/scala/cats/data/EitherT.scala

@@ -1,6 +1,7 @@
 package cats
 package data
 
+import cats.arrow.FunctionK
 import cats.functor.Bifunctor
 import cats.instances.either._
 import cats.syntax.either._
@@ -91,6 +92,14 @@ final case class EitherT[F[_], A, B](value: F[Either[A, B]]) {
 
   def map[D](f: B => D)(implicit F: Functor[F]): EitherT[F, A, D] = bimap(identity, f)
 
+  def transformF[G[_]](fe: FunctionK[F, G]): EitherT[G, A, B] = EitherT(fe(value))
+
+  def recoverF[E](pf: PartialFunction[E, B])(implicit me: MonadError[F, E]): EitherT[F, A, B] =
+    EitherT(me.recover(value)(pf.andThen(b => Right(b))))
+
+  def recoverFWith[E](pf: PartialFunction[E, F[Either[A, B]]])(implicit me: MonadError[F, E]): EitherT[F, A, B] =
+    EitherT(me.recoverWith(value)(pf))
+
   def semiflatMap[D](f: B => F[D])(implicit F: Monad[F]): EitherT[F, A, D] =
     flatMap(b => EitherT.right(f(b)))
 
@@ -483,9 +492,13 @@ private[data] abstract class EitherTInstances1 extends EitherTInstances2 {
     new EitherTBitraverse[F] {
       val F0: Traverse[F] = F
     }
+
+  implicit def catsDataMonadErrorFForEitherT[F[_], E, L](implicit FE0: MonadError[F, E]): MonadError[EitherT[F, L, ?], E] =
+    new EitherTMonadErrorF[F, E, L] { implicit val F = FE0 }
 }
 
 private[data] abstract class EitherTInstances2 extends EitherTInstances3 {
+
   implicit def catsDataMonadErrorForEitherT[F[_], L](implicit F0: Monad[F]): MonadError[EitherT[F, L, ?], L] =
     new EitherTMonadError[F, L] {
       implicit val F = F0
@@ -547,6 +560,15 @@ private[data] trait EitherTMonad[F[_], L] extends Monad[EitherT[F, L, ?]] with E
     }))
 }
 
+private[data] trait EitherTMonadErrorF[F[_], E, L] extends MonadError[EitherT[F, L, ?], E] with EitherTMonad[F, L] {
+  implicit val F: MonadError[F, E]
+
+  def handleErrorWith[A](fea: EitherT[F, L, A])(f: E => EitherT[F, L, A]): EitherT[F, L, A] =
+    EitherT(F.handleErrorWith(fea.value)(f(_).value))
+
+  def raiseError[A](e: E): EitherT[F, L, A] = EitherT.left(F.raiseError(e))
+}
+
 private[data] trait EitherTMonadError[F[_], L] extends MonadError[EitherT[F, L, ?], L] with EitherTMonad[F, L] {
   def handleErrorWith[A](fea: EitherT[F, L, A])(f: L => EitherT[F, L, A]): EitherT[F, L, A] =
     EitherT(F.flatMap(fea.value) {

tests/src/test/scala/cats/tests/EitherTTests.scala

@@ -1,12 +1,14 @@
 package cats
 package tests
 
+import cats.arrow.FunctionK
 import cats.data.EitherT
 import cats.functor.Bifunctor
 import cats.functor._
 import cats.laws.discipline._
 import cats.laws.discipline.arbitrary._
-import cats.kernel.laws.{OrderLaws, GroupLaws}
+import cats.kernel.laws.{GroupLaws, OrderLaws}
+
 
 class EitherTTests extends CatsSuite {
   implicit val iso = CartesianTests.Isomorphisms.invariant[EitherT[ListWrapper, String, ?]](EitherT.catsDataFunctorForEitherT(ListWrapper.functor))
@@ -46,17 +48,24 @@ class EitherTTests extends CatsSuite {
 
   {
     //if a Monad is defined
+    import cats.instances.option
+
     implicit val F = ListWrapper.monad
     implicit val eq0 = EitherT.catsDataEqForEitherT[ListWrapper, String, Either[String, Int]]
     implicit val eq1 = EitherT.catsDataEqForEitherT[EitherT[ListWrapper, String, ?], String, Int](eq0)
+    implicit val eq2 = EitherT.catsDataEqForEitherT[Option, String, Either[String, String]]
+    implicit val eq3 = EitherT.catsDataEqForEitherT[EitherT[Option, String, ?], String, String](eq2)
+    implicit val me = EitherT.catsDataMonadErrorFForEitherT[Option, Unit, String](option.catsStdInstancesForOption)
 
     Functor[EitherT[ListWrapper, String, ?]]
     Applicative[EitherT[ListWrapper, String, ?]]
     Monad[EitherT[ListWrapper, String, ?]]
     MonadTrans[EitherT[?[_], String, ?]]
 
     checkAll("EitherT[ListWrapper, String, Int]", MonadErrorTests[EitherT[ListWrapper, String, ?], String].monadError[Int, Int, Int])
+    checkAll("EitherT[Option, String, String]", MonadErrorTests[EitherT[Option, String, ?], Unit].monadError[String, String, String])
     checkAll("MonadError[EitherT[List, ?, ?]]", SerializableTests.serializable(MonadError[EitherT[ListWrapper, String, ?], String]))
+    checkAll("MonadError[EitherT[Option, ?, ?]]", SerializableTests.serializable(MonadError[EitherT[Option, String, ?], Unit]))
     checkAll("MonadTrans[EitherT[?[_], String, ?]]", MonadTransTests[EitherT[?[_], String, ?]].monadTrans[ListWrapper, Int, Int])
   }
 
@@ -219,9 +228,33 @@ class EitherTTests extends CatsSuite {
     eithert.recoverWith { case "noteithert" => EitherT.pure[Id, String](5) } should === (eithert)
   }
 
-  test("recoverWith ignores the right side") {
-    val eithert = EitherT.pure[Id, String](10)
-    eithert.recoverWith { case "eithert" => EitherT.pure[Id, String](5) } should === (eithert)
+  test("recoverF recovers handled values") {
+    val et: EitherT[Option, String, Int] = EitherT.right[String](Option.empty[Int])
+    et.recoverF[Unit] { case u => 5 }.value.get should === (Right(5))
+  }
+
+  test("recoverF ignores the non error in F") {
+    val et: EitherT[Option, String, Int] = EitherT.right[String](Some(1))
+    et.recoverFWith[Unit] { case u => Some(Right(5)) }.value.get should === (Right(1))
+  }
+
+  test("recoverFWith recovers handled values") {
+    val et: EitherT[Option, String, Int] = EitherT.right[String](Option.empty[Int])
+    et.recoverFWith[Unit] { case u => Some(Right(5)) }.value.get should === (Right(5))
+  }
+
+  test("recoverFWith ignores the non error in F") {
+    val et: EitherT[Option, String, Int] = EitherT.right[String](Some(1))
+    et.recoverFWith[Unit] { case u => Some(Right(5)) }.value.get should === (Right(1))
+  }
+
+  test("transformF consistent with transforming value") {
+    val toOptionK: FunctionK[List, Option] = new FunctionK[List, Option] {
+      def apply[A](fa: List[A]): Option[A] = fa.headOption
+    }
+    forAll { (eithert: EitherT[List, String, Int])  =>
+      eithert.transformF(toOptionK).value should === (toOptionK(eithert.value))
+    }
   }
 
   test("transform consistent with value.map") {
@@ -339,6 +372,17 @@ class EitherTTests extends CatsSuite {
     }
   }
 
+  test("collectRight with Id consistent with Either foldRight") {
+    val et: EitherT[Option, String, Int] = EitherT.pure(1)
+    et.collectRight should === (Some(1))
+  }
+
+  test("applyAlt with Id consistent with EitherT map") {
+    forAll { (et: EitherT[Id, String, Int], f: Int => String) =>
+      et.applyAlt(EitherT.pure(f)) should === (et.map(f))
+    }
+  }
+
   test("merge with Id consistent with Either merge") {
     forAll { (x: EitherT[Id, Int, Int]) =>
       x.merge should === (x.value.merge)