Add Contravariant instance for Eq and test Show instance.

core/src/main/scala/cats/functor/Contravariant.scala

@@ -29,7 +29,22 @@ import simulacrum.typeclass
     }
 }
 
-object Contravariant {
+object Contravariant extends KernelContravariantInstances
+
+/**
+ * Convariant instances for types that are housed in cats.kernel and therefore
+ * can't have instances for this type class in their companion objects.
+ */
+private[functor] sealed trait KernelContravariantInstances {
+  implicit val catsFunctorContravariantForEq: Contravariant[Eq] =
+    new Contravariant[Eq] {
+      /** Derive a `Eq` for `B` given a `Eq[A]` and a function `B => A`.
+       *
+       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
+       */
+      def contramap[A, B](fa: Eq[A])(f: B => A): Eq[B] = fa.on(f)
+    }
+
   implicit val catsFunctorContravariantForPartialOrder: Contravariant[PartialOrder] =
     new Contravariant[PartialOrder] {
       /** Derive a `PartialOrder` for `B` given a `PartialOrder[A]` and a function `B => A`.

laws/src/main/scala/cats/laws/discipline/Arbitrary.scala

@@ -83,6 +83,11 @@ object arbitrary extends ArbitraryInstances0 {
   implicit def catsLawsArbitraryForFn0[A: Arbitrary]: Arbitrary[() => A] =
     Arbitrary(getArbitrary[A].map(() => _))
 
+  implicit def catsLawsArbitraryForEq[A: Arbitrary]: Arbitrary[Eq[A]] =
+    Arbitrary(Gen.oneOf(
+      new Eq[A] { def eqv(x: A, y: A) = true },
+      new Eq[A] { def eqv(x: A, y: A) = false }))
+
   implicit def catsLawsArbitraryForPartialOrder[A: Arbitrary]: Arbitrary[PartialOrder[A]] =
     Arbitrary(Gen.oneOf(
       PartialOrder.from[A]((_: A, _: A) => Double.NaN),

laws/src/main/scala/cats/laws/discipline/Eq.scala

@@ -31,6 +31,22 @@ object eq {
     }
   }
 
+  /**
+   * Create an approximation of Eq[Eq[A]] by generating 100 values for A
+   * and comparing the application of the two eqv functions
+   */
+  implicit def catsLawsEqForEq[A](implicit arbA: Arbitrary[(A, A)], booleanEq: Eq[Boolean]): Eq[Eq[A]] = new Eq[Eq[A]] {
+    def eqv(f: Eq[A], g: Eq[A]): Boolean = {
+      val samples = List.fill(100)(arbA.arbitrary.sample).collect {
+        case Some(a) => a
+        case None => sys.error("Could not generate arbitrary values to compare two Eq[A]")
+      }
+      samples.forall {
+        case (l, r) => booleanEq.eqv(f.eqv(l, r), g.eqv(l, r))
+      }
+    }
+  }
+
   /**
    * Create an approximation of Eq[PartialOrder[A]] by generating 100 values for A
    * and comparing the application of the two compare functions

tests/src/test/scala/cats/tests/KernelContravariantTests.scala

@@ -7,6 +7,9 @@ import cats.laws.discipline.{ContravariantTests, SerializableTests}
 import cats.laws.discipline.eq._
 
 class KernelContravariantTests extends CatsSuite {
+  checkAll("Contravariant[Eq]", ContravariantTests[Eq].contravariant[Int, Int, Int])
+  checkAll("Contravariant[Eq]", SerializableTests.serializable(Contravariant[Eq]))
+
   checkAll("Contravariant[PartialOrder]", ContravariantTests[PartialOrder].contravariant[Int, Int, Int])
   checkAll("Contravariant[PartialOrder]", SerializableTests.serializable(Contravariant[PartialOrder]))
 

tests/src/test/scala/cats/tests/ShowTests.scala

@@ -0,0 +1,12 @@
+package cats
+package tests
+
+import cats.functor.Contravariant
+import cats.laws.discipline.arbitrary._
+import cats.laws.discipline.{ContravariantTests, SerializableTests}
+import cats.laws.discipline.eq._
+
+class ShowTests extends CatsSuite {
+  checkAll("Contravariant[Show]", ContravariantTests[Show].contravariant[Int, Int, Int])
+  checkAll("Contravariant[Show]", SerializableTests.serializable(Contravariant[Show]))
+}