Issue 2891 - Ambiguous Vector instances

kernel/src/main/scala/cats/kernel/instances/ListInstances.scala

@@ -13,14 +13,16 @@ trait ListInstances extends ListInstances1 {
 }
 
 private[instances] trait ListInstances1 extends ListInstances2 {
-  implicit def catsKernelStdPartialOrderForList[A: PartialOrder]: PartialOrder[List[A]] =
-    new ListPartialOrder[A]
-
   implicit def catsKernelStdHashForList[A: Hash]: Hash[List[A]] =
     new ListHash[A]
 }
 
-private[instances] trait ListInstances2 {
+private[instances] trait ListInstances2 extends ListInstances3 {
+  implicit def catsKernelStdPartialOrderForList[A: PartialOrder]: PartialOrder[List[A]] =
+    new ListPartialOrder[A]
+}
+
+private[instances] trait ListInstances3 {
   implicit def catsKernelStdEqForList[A: Eq]: Eq[List[A]] =
     new ListEq[A]
 }

kernel/src/main/scala/cats/kernel/instances/QueueInstances.scala

@@ -13,14 +13,16 @@ trait QueueInstances extends QueueInstances1 {
 }
 
 private[instances] trait QueueInstances1 extends QueueInstances2 {
-  implicit def catsKernelStdPartialOrderForQueue[A: PartialOrder]: PartialOrder[Queue[A]] =
-    new QueuePartialOrder[A]
-
   implicit def catsKernelStdHashForQueue[A: Hash]: Hash[Queue[A]] =
     new QueueHash[A]
 }
 
-private[instances] trait QueueInstances2 {
+private[instances] trait QueueInstances2 extends QueueInstances3 {
+  implicit def catsKernelStdPartialOrderForQueue[A: PartialOrder]: PartialOrder[Queue[A]] =
+    new QueuePartialOrder[A]
+}
+
+private[instances] trait QueueInstances3 {
   implicit def catsKernelStdEqForQueue[A: Eq]: Eq[Queue[A]] =
     new QueueEq[A]
 }

kernel/src/main/scala/cats/kernel/instances/VectorInstances.scala

@@ -6,19 +6,22 @@ import compat.scalaVersionSpecific._
 trait VectorInstances extends VectorInstances1 {
   implicit def catsKernelStdOrderForVector[A: Order]: Order[Vector[A]] =
     new VectorOrder[A]
+
   implicit def catsKernelStdMonoidForVector[A]: Monoid[Vector[A]] =
     new VectorMonoid[A]
 }
 
 private[instances] trait VectorInstances1 extends VectorInstances2 {
-  implicit def catsKernelStdPartialOrderForVector[A: PartialOrder]: PartialOrder[Vector[A]] =
-    new VectorPartialOrder[A]
-
   implicit def catsKernelStdHashForVector[A: Hash]: Hash[Vector[A]] =
     new VectorHash[A]
 }
 
-private[instances] trait VectorInstances2 {
+private[instances] trait VectorInstances2 extends VectorInstances3 {
+  implicit def catsKernelStdPartialOrderForVector[A: PartialOrder]: PartialOrder[Vector[A]] =
+    new VectorPartialOrder[A]
+}
+
+private[instances] trait VectorInstances3 {
   implicit def catsKernelStdEqForVector[A: Eq]: Eq[Vector[A]] =
     new VectorEq[A]
 }

tests/src/test/scala-2.13+/cats/tests/ScalaVersionSpecific.scala

@@ -123,11 +123,9 @@ trait ScalaVersionSpecificParallelSuite { self: ParallelSuite =>
   }
 
   // Can't test Parallel here, as Applicative[ZipLazyList].pure doesn't terminate
-  checkAll("Parallel[LazyList]",
-           NonEmptyParallelTests[LazyList].nonEmptyParallel[Int, String])
+  checkAll("Parallel[LazyList]", NonEmptyParallelTests[LazyList].nonEmptyParallel[Int, String])
 
-  checkAll("Parallel[NonEmptyLazyList]",
-           ParallelTests[NonEmptyLazyList].parallel[Int, String])
+  checkAll("Parallel[NonEmptyLazyList]", ParallelTests[NonEmptyLazyList].parallel[Int, String])
 }
 
 trait ScalaVersionSpecificRegressionSuite { self: RegressionSuite =>

tests/src/test/scala/cats/tests/ListSuite.scala

@@ -59,4 +59,15 @@ class ListSuite extends CatsSuite {
       l.show should ===(l.toString)
     }
   }
+
+  test("the instance for `Eq[List[A]]` is not ambiguous when A has a Hash and a PartialOrder") {
+
+    import cats.kernel.{Hash, PartialOrder}
+
+    trait A
+    implicit def po: PartialOrder[A] = ???
+    implicit def ho: Hash[A] = ???
+
+    lazy val _ = implicitly[Eq[List[A]]]
+  }
 }

tests/src/test/scala/cats/tests/QueueSuite.scala

@@ -32,4 +32,15 @@ class QueueSuite extends CatsSuite {
     Queue(1, 2, 3).show should ===("Queue(1, 2, 3)")
     Queue.empty[Int].show should ===("Queue()")
   }
+
+  test("the instance for `Eq[Queue[A]]` is not ambiguous when A has a Hash and a PartialOrder") {
+
+    import cats.kernel.{Hash, PartialOrder}
+
+    trait A
+    implicit def po: PartialOrder[A] = ???
+    implicit def ho: Hash[A] = ???
+
+    lazy val _ = implicitly[Eq[Queue[A]]]
+  }
 }

tests/src/test/scala/cats/tests/VectorSuite.scala

@@ -54,4 +54,15 @@ class VectorSuite extends CatsSuite {
   test("toNev on empty vector returns None") {
     assert(Vector.empty[Int].toNev == None)
   }
+
+  test("the instance for `Eq[Vector[A]]` is not ambiguous when A has a Hash and a PartialOrder") {
+
+    import cats.kernel.{Hash, PartialOrder}
+
+    trait A
+    implicit def po: PartialOrder[A] = ???
+    implicit def ho: Hash[A] = ???
+
+    lazy val _ = implicitly[Eq[Vector[A]]]
+  }
 }