add catchNonFatal to MonadError

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

@@ -1,6 +1,8 @@
 package cats
 
 import cats.data.{Xor, XorT}
+import scala.util.{ Failure, Success, Try }
+import scala.util.control.NonFatal
 
 /**
  * An applicative that also allows you to raise and or handle an error value.
@@ -74,6 +76,34 @@ trait ApplicativeError[F[_], E] extends Applicative[F] {
   def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A] =
     handleErrorWith(fa)(e =>
       pf applyOrElse(e, raiseError))
+  /**
+   * Often E is Throwable. Here we try to call pure or catch
+   * and raise.
+   */
+  def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< E): F[A] =
+    try pure(a)
+    catch {
+      case NonFatal(e) => raiseError(e)
+    }
+
+  /**
+   * Often E is Throwable. Here we try to call pure or catch
+   * and raise
+   */
+  def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< E): F[A] =
+    try pure(a.value)
+    catch {
+      case NonFatal(e) => raiseError(e)
+    }
+
+  /**
+   * If the error type is Throwable, we can convert from a scala.util.Try
+   */
+  def fromTry[A](t: Try[A])(implicit ev: Throwable <:< E): F[A] =
+    t match {
+      case Success(a) => pure(a)
+      case Failure(e) => raiseError(e)
+    }
 }
 
 object ApplicativeError {

tests/src/test/scala/cats/tests/TryTests.scala

@@ -30,6 +30,31 @@ class TryTests extends CatsSuite {
     }
   }
 
+  test("catchNonFatal works") {
+    forAll { e: Either[String, Int] =>
+      val str = e.fold(identity, _.toString)
+      val res = MonadError[Try, Throwable].catchNonFatal(str.toInt)
+      // the above should just never cause an uncaught exception
+      // this is a somewhat bogus test:
+      res should not be (null)
+    }
+  }
+
+  test("catchNonFatalEval works") {
+    forAll { e: Either[String, Int] =>
+      val str = e.fold(identity, _.toString)
+      val res = MonadError[Try, Throwable].catchNonFatalEval(Eval.later(str.toInt))
+      // the above should just never cause an uncaught exception
+      // this is a somewhat bogus test:
+      res should not be (null)
+    }
+  }
+  test("fromTry works") {
+    forAll { t: Try[Int] =>
+      (MonadError[Try, Throwable].fromTry(t)) should === (t)
+    }
+  }
+
   // The following tests check laws which are a different formulation of
   // laws that are checked. Since these laws are more or less duplicates of
   // existing laws, we don't check them for all types that have the relevant