Instances of NonEmptyReducible are now available for implicit resolution

core/src/main/scala/cats/data/NonEmptyList.scala

@@ -539,7 +539,7 @@ sealed abstract private[data] class NonEmptyListInstances extends NonEmptyListIn
       def combineK[A](a: NonEmptyList[A], b: NonEmptyList[A]): NonEmptyList[A] =
         a.concatNel(b)
 
-      override def split[A](fa: NonEmptyList[A]): (A, List[A]) = (fa.head, fa.tail)
+      override def split[A](fa: NonEmptyList[A]): (A, List[A]) = catsDataNonEmptyReducibleNonEmptyList.split(fa)
 
       override def reduceLeft[A](fa: NonEmptyList[A])(f: (A, A) => A): A =
         fa.reduceLeft(f)
@@ -695,6 +695,11 @@ sealed abstract private[data] class NonEmptyListInstances0 extends NonEmptyListI
     new NonEmptyListPartialOrder[A] {
       val A0 = A
     }
+
+  implicit val catsDataNonEmptyReducibleNonEmptyList: NonEmptyReducible[NonEmptyList, List] =
+    new NonEmptyReducible[NonEmptyList, List]() {
+      override def split[A](fa: NonEmptyList[A]): (A, List[A]) = (fa.head, fa.tail)
+    }
 }
 
 sealed abstract private[data] class NonEmptyListInstances1 {

core/src/main/scala/cats/data/NonEmptyVector.scala

@@ -330,7 +330,7 @@ final class NonEmptyVector[+A] private (val toVector: Vector[A])
 }
 
 @suppressUnusedImportWarningForScalaVersionSpecific
-sealed abstract private[data] class NonEmptyVectorInstances {
+sealed abstract private[data] class NonEmptyVectorInstances extends NonEmptyVectorInstances0 {
 
   implicit val catsDataInstancesForNonEmptyVector: SemigroupK[NonEmptyVector]
     with Bimonad[NonEmptyVector]
@@ -345,7 +345,7 @@ sealed abstract private[data] class NonEmptyVectorInstances {
       def combineK[A](a: NonEmptyVector[A], b: NonEmptyVector[A]): NonEmptyVector[A] =
         a.concatNev(b)
 
-      override def split[A](fa: NonEmptyVector[A]): (A, Vector[A]) = (fa.head, fa.tail)
+      override def split[A](fa: NonEmptyVector[A]): (A, Vector[A]) = catsDataNonEmptyReducibleNonEmptyVector.split(fa)
 
       override def size[A](fa: NonEmptyVector[A]): Long = fa.length.toLong
 
@@ -498,6 +498,13 @@ sealed abstract private[data] class NonEmptyVectorInstances {
 
 }
 
+sealed abstract private[data] class NonEmptyVectorInstances0 {
+  implicit val catsDataNonEmptyReducibleNonEmptyVector: NonEmptyReducible[NonEmptyVector, Vector] =
+    new NonEmptyReducible[NonEmptyVector, Vector]() {
+      override def split[A](fa: NonEmptyVector[A]): (A, Vector[A]) = (fa.head, fa.tail)
+    }
+}
+
 object NonEmptyVector extends NonEmptyVectorInstances with Serializable {
 
   def apply[A](head: A, tail: Vector[A]): NonEmptyVector[A] =

tests/src/test/scala/cats/tests/NonEmptyListSuite.scala

@@ -1,6 +1,6 @@
 package cats.tests
 
-import cats.{Align, Bimonad, Eval, NonEmptyTraverse, Now, Reducible, SemigroupK, Show}
+import cats.{Align, Bimonad, Eval, Foldable, NonEmptyTraverse, Now, Reducible, SemigroupK, Show, UnorderedFoldable}
 import cats.data.{NonEmptyList, NonEmptyMap, NonEmptySet, NonEmptyVector}
 import cats.data.NonEmptyList.ZipNonEmptyList
 import cats.kernel.{Eq, Order, PartialOrder, Semigroup}
@@ -371,6 +371,11 @@ class NonEmptyListSuite extends NonEmptyCollectionSuite[List, NonEmptyList, NonE
       assert(nel.toNev === (NonEmptyVector.fromVectorUnsafe(Vector.empty[Int] ++ nel.toList.toVector)))
     }
   }
+
+  // ensure absence of implicit resolution conflict
+  implicitly[Reducible[NonEmptyList]]
+  implicitly[Foldable[NonEmptyList]]
+  implicitly[UnorderedFoldable[NonEmptyList]]
 }
 
 @deprecated("to be able to test deprecated methods", since = "1.0.0-RC1")

tests/src/test/scala/cats/tests/NonEmptyVectorSuite.scala

@@ -14,7 +14,8 @@ import cats.{
   Reducible,
   SemigroupK,
   Show,
-  Traverse
+  Traverse,
+  UnorderedFoldable
 }
 import cats.data.NonEmptyVector
 import cats.data.NonEmptyVector.ZipNonEmptyVector
@@ -84,6 +85,11 @@ class NonEmptyVectorSuite extends NonEmptyCollectionSuite[Vector, NonEmptyVector
   implicitly[Comonad[NonEmptyVector]]
   implicitly[Bimonad[NonEmptyVector]]
 
+  // ensure absence of implicit resolution conflict
+  implicitly[Reducible[NonEmptyVector]]
+  implicitly[Foldable[NonEmptyVector]]
+  implicitly[UnorderedFoldable[NonEmptyVector]]
+
   checkAll("NonEmptyVector[Int]", BimonadTests[NonEmptyVector].bimonad[Int, Int, Int])
   checkAll("Bimonad[NonEmptyVector]", SerializableTests.serializable(Bimonad[NonEmptyVector]))
 

tests/src/test/scala/cats/tests/ReducibleSuite.scala

@@ -1,7 +1,7 @@
 package cats.tests
 
 import cats.{Eval, NonEmptyReducible, Now, Reducible}
-import cats.data.NonEmptyList
+import cats.data.{NonEmptyList, NonEmptyVector}
 import cats.kernel.Eq
 import cats.syntax.either._
 import cats.syntax.foldable._
@@ -22,14 +22,31 @@ class ReducibleSuiteAdditional extends CatsSuite {
       if (a === goal) Now(true) else lb
     }
 
+  {
+    import cats.Foldable
+    import cats.UnorderedFoldable
+
+    implicitly[Reducible[NonEmptyList]]
+    implicitly[Foldable[NonEmptyList]]
+    implicitly[UnorderedFoldable[NonEmptyList]]
+
+  }
+
   test("Reducible[NonEmptyList] default get/size implementation") {
-    val R = new NonEmptyReducible[NonEmptyList, List] {
-      def split[A](nel: NonEmptyList[A]): (A, List[A]) = (nel.head, nel.tail)
-    }
-    val nel = NonEmptyList.of(1, 2, 3)
-    assert(R.get(nel)(1L) === (nel.get(1L)))
-    assert(R.size(nel) === (nel.size.toLong))
-    assert(R.get(nel)(4L) === (None))
+    testDefaultGetAndSize(1, 2, 3) { (head, tail) => NonEmptyList(head, tail.toList) }
+  }
+
+  test("Reducible[NonEmptyVector] default get/size implementation") {
+    testDefaultGetAndSize(1, 2, 3) { (head, tail) => NonEmptyVector(head, tail.toVector) }
+  }
+
+  def testDefaultGetAndSize[F[_], G[_]](head: Int, tail: Int*)(
+    c: (Int, Seq[Int]) => F[Int]
+  )(implicit R: NonEmptyReducible[F, G]) = {
+    val f: F[Int] = c(head, tail)
+    assert(R.get(f)(1L) === (f.get(1L)))
+    assert(R.size(f) === (f.size.toLong))
+    assert(R.get(f)(4L) === (None))
   }
 
   test("Reducible[NonEmptyList]") {