This commit make somse changes to some of our basic ops:

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

@@ -45,10 +45,12 @@ package object cats {
   type Order[A] = algebra.Order[A]
   type Semigroup[A] = algebra.Semigroup[A]
   type Monoid[A] = algebra.Monoid[A]
+  type Group[A] = algebra.Group[A]
 
   val Eq = algebra.Eq
   val PartialOrder = algebra.PartialOrder
   val Order = algebra.Order
   val Semigroup = algebra.Semigroup
   val Monoid = algebra.Monoid
+  val Group = algebra.Group
 }

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

@@ -12,12 +12,14 @@ trait AllSyntax
     with FlatMapSyntax
     with FoldableSyntax
     with FunctorSyntax
+    with GroupSyntax
     with InvariantSyntax
     with MonadCombineSyntax
     with MonadFilterSyntax
     with OrderSyntax
     with PartialOrderSyntax
     with ProfunctorSyntax
+    with ReducibleSyntax
     with SemigroupSyntax
     with SemigroupKSyntax
     with Show.ToShowOps

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

@@ -4,10 +4,11 @@ package syntax
 import cats.macros.Ops
 
 trait EqSyntax {
-  implicit def eqSyntax[A: Eq](a: A): EqOps[A] = new EqOps[A](a)
+  implicit def eqSyntax[A: Eq](a: A): EqOps[A] =
+    new EqOps[A](a)
 }
 
-class EqOps[A](lhs: A)(implicit A: Eq[A]) {
+class EqOps[A: Eq](lhs: A) {
   def ===(rhs: A): Boolean = macro Ops.binop[A, Boolean]
   def =!=(rhs: A): Boolean = macro Ops.binop[A, Boolean]
 }

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

@@ -16,5 +16,5 @@ trait FoldableSyntax extends Foldable.ToFoldableOps with FoldableSyntax1 {
 
 class NestedFoldableOps[F[_], G[_], A](fga: F[G[A]])(implicit F: Foldable[F]) {
   def sequence_[B](implicit G: Applicative[G]): G[Unit] = F.sequence_(fga)
-  def foldK(fga: F[G[A]])(implicit G: MonoidK[G]): G[A] = F.foldK(fga)
+  def foldK(implicit G: MonoidK[G]): G[A] = F.foldK(fga)
 }

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

@@ -0,0 +1,15 @@
+package cats
+package syntax
+
+import cats.macros.Ops
+
+trait GroupSyntax {
+  // TODO: use simulacrum instances eventually
+  implicit def groupSyntax[A: Group](a: A): GroupOps[A] =
+    new GroupOps[A](a)
+}
+
+class GroupOps[A: Group](lhs: A) {
+  def |-|(rhs: A): A = macro Ops.binop[A, A]
+  def remove(rhs: A): A = macro Ops.binop[A, A]
+}

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

@@ -4,10 +4,15 @@ package syntax
 import cats.macros.Ops
 
 trait OrderSyntax {
-  implicit def orderSyntax[A: Order](a: A): OrderOps[A] = new OrderOps[A](a)
+  implicit def orderSyntax[A: Order](a: A): OrderOps[A] =
+    new OrderOps[A](a)
 }
 
-class OrderOps[A](lhs: A)(implicit A: Order[A]) {
+class OrderOps[A: Order](lhs: A) {
+  def <(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def <=(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def >(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def >=(rhs: A): Boolean = macro Ops.binop[A, Boolean]
   def compare(rhs: A): Int = macro Ops.binop[A, Int]
   def min(rhs: A): A = macro Ops.binop[A, A]
   def max(rhs: A): A = macro Ops.binop[A, A]

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

@@ -15,5 +15,5 @@ trait ReducibleSyntax extends Reducible.ToReducibleOps with ReducibleSyntax1 {
 }
 
 final class NestedReducibleOps[F[_], G[_], A](fga: F[G[A]])(implicit F: Reducible[F]) {
-  def reduceK(fga: F[G[A]])(implicit G: MonoidK[G]): G[A] = F.foldK(fga)
+  def reduceK(implicit G: SemigroupK[G]): G[A] = F.reduceK(fga)
 }

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

@@ -1,14 +1,16 @@
 package cats
 package syntax
 
+import cats.macros.Ops
+
 trait SemigroupSyntax {
   // TODO: use simulacrum instances eventually
   implicit def semigroupSyntax[A: Semigroup](a: A): SemigroupOps[A] =
     new SemigroupOps[A](a)
 }
 
-class SemigroupOps[A](lhs: A)(implicit A: Semigroup[A]) {
-  def |+|(rhs: A): A = A.combine(lhs, rhs)
-  def combine(rhs: A): A = A.combine(lhs, rhs)
-  def combineN(rhs: Int): A = A.combineN(lhs, rhs)
+class SemigroupOps[A: Semigroup](lhs: A) {
+  def |+|(rhs: A): A = macro Ops.binop[A, A]
+  def combine(rhs: A): A = macro Ops.binop[A, A]
+  def combineN(rhs: Int): A = macro Ops.binop[A, A]
 }

tests/src/test/scala/cats/tests/CatsSuite.scala

@@ -3,7 +3,7 @@ package tests
 
 import cats.std.AllInstances
 import cats.syntax.AllSyntax
-import org.scalatest.FunSuite
+import org.scalatest.{ FunSuite, Matchers }
 import org.typelevel.discipline.scalatest.Discipline
 
 import org.scalacheck.{Arbitrary, Gen}
@@ -15,16 +15,15 @@ import scala.util.{Failure, Success, Try}
  * An opinionated stack of traits to improve consistency and reduce
  * boilerplate in Cats tests.
  */
-trait CatsSuite extends FunSuite with Discipline with AllInstances with AllSyntax with TestInstances
+trait CatsSuite extends FunSuite with Matchers with Discipline with AllInstances with AllSyntax with TestInstances {
+  // disable scalatest's ===
+  override def convertToEqualizer[T](left: T): Equalizer[T] = ???
+}
 
 sealed trait TestInstances {
   // To be replaced by https://github.com/rickynils/scalacheck/pull/170
-  implicit def arbitraryTry[A : Arbitrary]: Arbitrary[Try[A]] =
-    Arbitrary {
-      for {
-        success <- arbitrary[Boolean]
-        t       <- if (success) arbitrary[A].map(Success(_))
-                   else Gen.const(Failure(new Throwable {}))
-      } yield t
-    }
+  implicit def arbitraryTry[A: Arbitrary]: Arbitrary[Try[A]] =
+    Arbitrary(Gen.oneOf(
+      arbitrary[A].map(Success(_)),
+      arbitrary[Throwable].map(Failure(_))))
 }

tests/src/test/scala/cats/tests/LazyTests.scala

@@ -7,9 +7,6 @@ import scala.math.min
 
 class LazyTests extends CatsSuite {
 
-  // disable scalatest ===
-  override def convertToEqualizer[T](left: T): Equalizer[T] = ???
-
   /**
    * Class for spooky side-effects and action-at-a-distance.
    *

tests/src/test/scala/cats/tests/SyntaxTests.scala

@@ -0,0 +1,181 @@
+package cats
+package tests
+
+import algebra.laws.GroupLaws
+import cats.functor.{Invariant, Contravariant}
+import cats.laws.discipline.SerializableTests
+
+import org.scalacheck.{Arbitrary}
+import org.scalatest.prop.PropertyChecks
+import scala.reflect.runtime.universe.TypeTag
+
+/**
+ * Test that our syntax implicits are working.
+ *
+ * Each method should correspond to one type class worth of syntax.
+ * Ideally, we should be testing every operator or method that we
+ * expect to add to generic parameters. This file is a safeguard
+ * against accidentally breaking (or removing) syntax which was
+ * otherwise untested.
+ *
+ * The strategy here is to create "mock" values of particular types,
+ * and then ensure that the syntax we want is available. We never plan
+ * to run any of these methods, so we don't need real values. All
+ * values in the methods should be generic -- we rely on parametricity
+ * to guarantee that the syntax will be available for any type with
+ * the proper type class instance(s).
+ *
+ * None of these tests should ever run, or do any runtime checks.
+ */
+class SyntaxTests extends CatsSuite with PropertyChecks {
+
+  // pretend we have a value of type A
+  def mock[A]: A = ???
+
+  def testSemigroup[A: Semigroup]: Unit = {
+    val x = mock[A]
+    val y = mock[A]
+    val z: A = x |+| y
+  }
+
+  def testGroup[A: Group](x: A, y: A): Unit = {
+    val x = mock[A]
+    val y = mock[A]
+    val z: A = x |-| y
+  }
+
+  def testEq[A: Eq]: Unit = {
+    val x = mock[A]
+    val y = mock[A]
+    val b0: Boolean = x === y
+    val b1: Boolean = x =!= y
+  }
+
+  def testPartialOrder[A: PartialOrder]: Unit = {
+    val x = mock[A]
+    val y = mock[A]
+    val b0: Boolean = x < y
+    val b1: Boolean = x <= y
+    val b2: Boolean = x > y
+    val b3: Boolean = x >= y
+    val f: Double = x partialCompare y
+    val oi: Option[Int] = x tryCompare y
+    val oz0: Option[A] = x pmin y
+    val oz1: Option[A] = x pmax y
+  }
+
+  def testOrder[A: Order]: Unit = {
+    val x = mock[A]
+    val y = mock[A]
+    val i: Int = x compare y
+    val z0: A = x min y
+    val z1: A = x max y
+  }
+
+  def testInvariantFunctor[F[_]: Invariant, A, B]: Unit = {
+    val fa = mock[F[A]]
+    val f = mock[A => B]
+    val g = mock[B => A]
+    val fb: F[B] = fa.imap(f)(g)
+  }
+
+  def testInvariantFunctor[F[_]: Contravariant, A, B]: Unit = {
+    val fa = mock[F[A]]
+    val f = mock[B => A]
+    val fb: F[B] = fa.contramap(f)
+  }
+
+  def testFoldable[F[_]: Foldable, G[_]: Applicative: MonoidK, A: Monoid, B, Z]: Unit = {
+    val fa = mock[F[A]]
+    val b = mock[B]
+    val f1 = mock[(B, A) => B]
+    val b0: B = fa.foldLeft(b)(f1)
+    val a0: A = fa.fold
+
+    val f2 = mock[A => Fold[B]]
+    val lb0: Lazy[B] = fa.foldRight(Lazy(b))(f2)
+
+    val fz = mock[F[Z]]
+    val f3 = mock[Z => A]
+    val a1: A = fz.foldMap(f3)
+
+    val f4 = mock[A => G[B]]
+    val gu0: G[Unit] = fa.traverse_(f4)
+
+    val fga = mock[F[G[A]]]
+    val gu1: G[Unit] = fga.sequence_
+    val ga: G[A] = fga.foldK
+
+    val f5 = mock[A => Boolean]
+    val oa: Option[A] = fa.find(f5)
+
+    val as0: List[A] = fa.toList
+    val as1: List[A] = fa.filter_(f5)
+    val as2: List[A] = fa.dropWhile_(f5)
+  }
+
+  def testReducible[F[_]: Reducible, G[_]: Apply: SemigroupK, A: Semigroup, B, Z]: Unit = {
+    val fa = mock[F[A]]
+    val f1 = mock[(A, A) => A]
+    val a1: A = fa.reduceLeft(f1)
+
+    val f2 = mock[A => Fold[A]]
+    val la: Lazy[A] = fa.reduceRight(f2)
+
+    val a2: A = fa.reduce
+
+    val fga = mock[F[G[A]]]
+    val ga: G[A] = fga.reduceK
+
+    val fz = mock[F[Z]]
+    val f3 = mock[Z => A]
+    val a3: A = fz.reduceMap(f3)
+
+    val f4 = mock[A => B]
+    val f5 = mock[(B, A) => B]
+    val b1: B = fa.reduceLeftTo(f4)(f5)
+
+    val f6 = mock[A => Fold[B]]
+    val lb: Lazy[B] = fa.reduceRightTo(f4)(f6)
+
+    val f7 = mock[A => G[B]]
+    val gu1: G[Unit] = fa.traverse1_(f7)
+
+    val gu2: G[Unit] = fga.sequence1_
+  }
+
+  def testFunctor[F[_]: Functor, A, B]: Unit = {
+    val fa = mock[F[A]]
+    val f = mock[A => B]
+    val fb0: F[B] = fa.map(f)
+    val fu: F[Unit] = fa.void
+    val fab: F[(A, B)] = fa.fproduct(f)
+
+    val b = mock[B]
+    val fb1: F[B] = fa.as(b)
+  }
+
+  def testApply[F[_]: Apply, A, B, C, D, Z]: Unit = {
+    val fa = mock[F[A]]
+    val fab = mock[F[A => B]]
+    val fb0: F[B] = fa.ap(fab)
+
+    val fb = mock[F[B]]
+    val fabz = mock[F[(A, B) => Z]]
+    val fz0: F[Z] = fa.ap2(fb)(fabz)
+
+    val f = mock[(A, B) => Z]
+    val fz1: F[Z] = fa.map2(fb)(f)
+
+    val f1 = mock[(A, B) => Z]
+    val ff1 = mock[F[(A, B) => Z]]
+    val fz2: F[Z] = (fa |@| fb).map(f1)
+    val fz3: F[Z] = (fa |@| fb).ap(ff1)
+
+    val fc = mock[F[C]]
+    val f2 = mock[(A, B, C) => Z]
+    val ff2 = mock[F[(A, B, C) => Z]]
+    val fz4: F[Z] = (fa |@| fb |@| fc).map(f2)
+    val fz5: F[Z] = (fa |@| fb |@| fc).ap(ff2)
+  }
+}