add attemptCase to ApplicativeErrorOps

Author: marcodippy

core/src/main/scala/cats/syntax/applicativeError.scala

@@ -3,6 +3,9 @@ package syntax
 
 import cats.data.Validated.{Invalid, Valid}
 import cats.data.{EitherT, Validated}
+import either._
+
+import scala.reflect.ClassTag
 
 trait ApplicativeErrorSyntax {
   implicit final def catsSyntaxApplicativeErrorId[E](e: E): ApplicativeErrorIdOps[E] =
@@ -83,6 +86,9 @@ final class ApplicativeErrorOps[F[_], E, A](private val fa: F[A]) extends AnyVal
   def attempt(implicit F: ApplicativeError[F, E]): F[Either[E, A]] =
     F.attempt(fa)
 
+  def attemptCase[EE](implicit F: ApplicativeError[F, E], tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]] =
+    F.recover(F.map(fa)(_.asRight[EE])) { case e: EE => e.asLeft[A] }
+
   def attemptT(implicit F: ApplicativeError[F, E]): EitherT[F, E, A] =
     F.attemptT(fa)
 

tests/src/test/scala/cats/tests/ApplicativeErrorSuite.scala

@@ -23,6 +23,21 @@ class ApplicativeErrorSuite extends CatsSuite {
     failed.attempt should ===(Option(Left(())))
   }
 
+  test("attemptCase[EE] syntax creates an F[Either[EE, A]]") {
+    trait Err
+    case class ErrA() extends Err
+    case class ErrB() extends Err
+
+    implicit val eqForErr: Eq[Err] = Eq.fromUniversalEquals[Err]
+    implicit val eqForErrA: Eq[ErrA] = Eq.fromUniversalEquals[ErrA]
+    implicit val eqForErrB: Eq[ErrB] = Eq.fromUniversalEquals[ErrB]
+
+    val failed: Either[Err, Int] = ErrA().raiseError[Either[Err, ?], Int]
+
+    failed.attemptCase[ErrA] should ===(ErrA().asLeft[Int].asRight[Err])
+    failed.attemptCase[ErrB] should ===(Either.left[Err, Either[ErrB, Int]](ErrA()))
+  }
+
   test("attemptT syntax creates an EitherT") {
     failed.attemptT should ===(EitherT[Option, Unit, Int](Option(Left(()))))
   }