Update Foldable/Reducible intercalate to reduce complexity

core/src/main/scala/cats/Foldable.scala

@@ -1,6 +1,7 @@
 package cats
 
 import scala.collection.mutable
+import cats.instances.list._
 import cats.instances.long._
 import simulacrum.typeclass
 
@@ -402,9 +403,20 @@ import simulacrum.typeclass
    * }}}
    */
   def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A =
-    reduceLeftOption(fa){ (acc, aa) =>
-      A.combine(acc, A.combine(a, aa))
-    }.getOrElse(A.empty)
+    Foldable[List].combineAll(intersperseList(toList(fa), a))
+
+  protected def intersperseList[A](xs: List[A], x: A): List[A] = {
+    val bld = List.newBuilder[A]
+    val it = xs.iterator
+    if (it.hasNext) {
+      bld += it.next
+      while(it.hasNext) {
+        bld += x
+        bld += it.next
+      }
+    }
+    bld.result
+  }
 
   def compose[G[_]: Foldable]: Foldable[λ[α => F[G[α]]]] =
     new ComposedFoldable[F, G] {

core/src/main/scala/cats/Reducible.scala

@@ -171,10 +171,11 @@ import simulacrum.typeclass
    * }}}
    */
   def intercalate1[A](fa: F[A], a: A)(implicit A: Semigroup[A]): A =
-    reduceLeft(fa)((acc, aa) => A.combine(acc, A.combine(a, aa)))
-
-  override def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A =
-    intercalate1(fa, a)
+    toNonEmptyList(fa) match {
+      case NonEmptyList(hd, Nil) => hd
+      case NonEmptyList(hd, tl) =>
+        Reducible[NonEmptyList].reduce(NonEmptyList(hd, a :: intersperseList(tl, a)))
+    }
 }
 
 /**

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

@@ -250,6 +250,11 @@ private[data] sealed trait NonEmptyVectorInstances {
         go(f(a))
         NonEmptyVector.fromVectorUnsafe(buf.result())
       }
+
+      override def toList[A](fa: NonEmptyVector[A]): List[A] = fa.toVector.toList
+
+      override def toNonEmptyList[A](fa: NonEmptyVector[A]): NonEmptyList[A] =
+        NonEmptyList(fa.head, fa.tail.toList)
     }
 
   implicit def catsDataEqForNonEmptyVector[A](implicit A: Eq[A]): Eq[NonEmptyVector[A]] =

core/src/main/scala/cats/instances/list.scala

@@ -82,6 +82,8 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
 
       override def foldM[G[_], A, B](fa: List[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =
         Foldable.iteratorFoldM(fa.toIterator, z)(f)
+
+      override def toList[A](fa: List[A]): List[A] = fa
     }
 
   implicit def catsStdShowForList[A:Show]: Show[List[A]] =

core/src/main/scala/cats/instances/set.scala

@@ -30,6 +30,8 @@ trait SetInstances extends cats.kernel.instances.SetInstances {
 
       override def foldM[G[_], A, B](fa: Set[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =
         Foldable.iteratorFoldM(fa.toIterator, z)(f)
+
+      override def toList[A](fa: Set[A]): List[A] = fa.toList
     }
 
   implicit def catsStdShowForSet[A:Show]: Show[Set[A]] = new Show[Set[A]] {

core/src/main/scala/cats/instances/stream.scala

@@ -109,6 +109,8 @@ trait StreamInstances extends cats.kernel.instances.StreamInstances {
 
       override def foldM[G[_], A, B](fa: Stream[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =
         Foldable.iteratorFoldM(fa.toIterator, z)(f)
+
+      override def toList[A](fa: Stream[A]): List[A] = fa.toList
     }
 
   implicit def catsStdShowForStream[A: Show]: Show[Stream[A]] =

core/src/main/scala/cats/instances/vector.scala

@@ -89,6 +89,8 @@ trait VectorInstances extends cats.kernel.instances.VectorInstances {
 
       override def foldM[G[_], A, B](fa: Vector[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =
         Foldable.iteratorFoldM(fa.toIterator, z)(f)
+
+      override def toList[A](fa: Vector[A]): List[A] = fa.toList
     }
 
   implicit def catsStdShowForVector[A:Show]: Show[Vector[A]] =