Add bridge between ApplicativeError and ApplicativeThrow

core/src/main/scala/cats/ApplicativeError.scala

@@ -21,7 +21,7 @@
 
 package cats
 
-import cats.ApplicativeError.CatchOnlyPartiallyApplied
+import cats.ApplicativeError.{CatchOnlyAsPartiallyApplied, CatchOnlyPartiallyApplied}
 import cats.data.{EitherT, Validated}
 import cats.data.Validated.{Invalid, Valid}
 
@@ -287,6 +287,30 @@ trait ApplicativeError[F[_], E] extends Applicative[F] {
   def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E] =
     new CatchOnlyPartiallyApplied[T, F, E](this)
 
+  /**
+   * Often E can be created from Throwable. Here we try to call pure or
+   * catch, adapt into E, and raise.
+   *
+   * Exceptions that cannot be adapted to E will be propagated outside of `F`
+   */
+  def catchNonFatalAs[A](adaptIfPossible: Throwable => Option[E])(a: => A): F[A] =
+    try pure(a)
+    catch {
+      case e if NonFatal(e) => adaptIfPossible(e).map(raiseError[A]).getOrElse(throw e)
+    }
+
+  /**
+   * Evaluates the specified block, catching exceptions of the specified type and maps them to `E`.
+   *
+   * Uncaught exceptions will be propagated outside of `F`
+   *
+   * Note: `catchOnlyAs` assumes that, if a specific exception type `T` is expected, there
+   * exists a mapping from `T` to `E`. If this is not the case, consider either manually
+   * rethrowing inside the mapping function, or using `catchNonFatalAs`
+   */
+  def catchOnlyAs[T >: Null <: Throwable]: CatchOnlyAsPartiallyApplied[T, F, E] =
+    new CatchOnlyAsPartiallyApplied[T, F, E](this)
+
   /**
    * If the error type is Throwable, we can convert from a scala.util.Try
    */
@@ -383,6 +407,16 @@ object ApplicativeError {
       }
   }
 
+  final private[cats] class CatchOnlyAsPartiallyApplied[T >: Null <: Throwable, F[_], E](
+    private val F: ApplicativeError[F, E]
+  ) extends AnyVal {
+    def apply[A](adapt: T => E)(f: => A)(implicit CT: ClassTag[T], NT: NotNull[T]): F[A] =
+      try F.pure(f)
+      catch {
+        case CT(t) => F.raiseError(adapt(t))
+      }
+  }
+
   /**
    * lift from scala.Option[A] to a F[A]
    *

tests/shared/src/test/scala/cats/tests/EitherSuite.scala

@@ -23,6 +23,7 @@ package cats.tests
 
 import cats._
 import cats.data.{EitherT, NonEmptyChain, NonEmptyList, NonEmptySet, NonEmptyVector, Validated}
+import cats.syntax.option._
 import cats.syntax.bifunctor._
 import cats.kernel.laws.discipline.{EqTests, MonoidTests, OrderTests, PartialOrderTests, SemigroupTests}
 import cats.laws.discipline._
@@ -136,6 +137,31 @@ class EitherSuite extends CatsSuite {
     assert(Either.catchNonFatal(throw new Throwable("blargh")).isLeft)
   }
 
+  test("ApplicativeError instance catchNonFatalAs maps exceptions to E") {
+    val res = ApplicativeError[Either[String, *], String].catchNonFatalAs(_.getMessage.some)("foo".toInt)
+    assert(res === Left("For input string: \"foo\""))
+  }
+
+  test("ApplicativeError instance catchNonFatalAs propagates unmappable exceptions") {
+    val _ = intercept[NumberFormatException] {
+      ApplicativeError[Either[String, *], String].catchNonFatalAs(_ => none[String])("foo".toInt)
+    }
+  }
+
+  test("ApplicativeError instance catchOnlyAs maps exceptions of the specified type to E") {
+    val res =
+      ApplicativeError[Either[String, *], String]
+        .catchOnlyAs[NumberFormatException](_.getMessage)("foo".toInt)
+    assert(res === Left("For input string: \"foo\""))
+  }
+
+  test("ApplicativeError instance catchOnlyAs propagates non-matching exceptions") {
+    val _ = intercept[NumberFormatException] {
+      ApplicativeError[Either[String, *], String]
+        .catchOnlyAs[IndexOutOfBoundsException](_.getMessage)("foo".toInt)
+    }
+  }
+
   test("fromTry is left for failed Try") {
     forAll { (t: Try[Int]) =>
       assert(t.isFailure === (Either.fromTry(t).isLeft))