Add Try instances

core/src/main/scala/cats/std/future.scala

@@ -34,9 +34,6 @@ trait FutureInstances extends FutureInstances1 {
 
       override def map[A, B](fa: Future[A])(f: A => B): Future[B] = fa.map(f)
     }
-
-  implicit def futureGroup[A: Group](implicit ec: ExecutionContext): Group[Future[A]] =
-    new FutureGroup[A]
 }
 
 private[std] sealed trait FutureInstances1 extends FutureInstances2 {
@@ -63,10 +60,3 @@ private[cats] class FutureMonoid[A](implicit A: Monoid[A], ec: ExecutionContext)
   def empty: Future[A] =
     Future.successful(A.empty)
 }
-
-private[cats] class FutureGroup[A](implicit A: Group[A], ec: ExecutionContext) extends FutureMonoid[A] with Group[Future[A]] {
-  def inverse(fx: Future[A]): Future[A] =
-    fx.map(_.inverse)
-  override def remove(fx: Future[A], fy: Future[A]): Future[A] =
-    (fx zip fy).map { case (x, y) => x |-| y }
-}

core/src/main/scala/cats/std/package.scala

@@ -28,6 +28,6 @@ package object std {
   object bigInt     extends BigIntInstances
   object bigDecimal extends BigDecimalInstances
 
-  object `try`      extends TryInstances
+  object try_      extends TryInstances
   object tuple      extends TupleInstances
 }

core/src/main/scala/cats/std/try.scala

@@ -56,21 +56,23 @@ trait TryInstances extends TryInstances1 {
       override def map[A, B](ta: Try[A])(f: A => B): Try[B] = ta.map(f)
     }
 
-  implicit def tryGroup[A: Group]: Group[Try[A]] =
-    new TryGroup[A]
-
   implicit def showTry[A](implicit A: Show[A]): Show[Try[A]] =
     new Show[Try[A]] {
       def show(fa: Try[A]): String = fa match {
         case Success(a) => s"Success(${A.show(a)})"
         case Failure(e) => s"Failure($e)"
       }
     }
-  implicit def eqTry[A](implicit A: Eq[A]): Eq[Try[A]] =
+  /**
+   * you may with to do equality by making `implicit val eqT: Eq[Throwable] = Eq.allEqual`
+   * doing a fine grained equality on Throwable can make the code very execution
+   * order dependent
+   */
+  implicit def eqTry[A, T](implicit A: Eq[A], T: Eq[Throwable]): Eq[Try[A]] =
     new Eq[Try[A]] {
       def eqv(x: Try[A], y: Try[A]): Boolean = (x, y) match {
         case (Success(a), Success(b)) => A.eqv(a, b)
-        case (Failure(_), Failure(_)) => true // all failures are equivalent
+        case (Failure(a), Failure(b)) => T.eqv(a, b)
         case _ => false
       }
     }
@@ -102,13 +104,3 @@ private[cats] class TrySemigroup[A: Semigroup] extends Semigroup[Try[A]] {
 private[cats] class TryMonoid[A](implicit A: Monoid[A]) extends TrySemigroup[A] with Monoid[Try[A]] {
   def empty: Try[A] = Success(A.empty)
 }
-
-private[cats] class TryGroup[A](implicit A: Group[A]) extends TryMonoid[A] with Group[Try[A]] {
-  def inverse(fx: Try[A]): Try[A] =
-    fx.map(_.inverse)
-  override def remove(fx: Try[A], fy: Try[A]): Try[A] =
-    for {
-      x <- fx
-      y <- fy
-    } yield x |-| y
-}