Add combineAllOption to Foldable

core/src/main/scala-2.12/cats/compat/FoldableCompat.scala

@@ -0,0 +1,22 @@
+package cats
+package compat
+
+private[cats] trait FoldableCompat[F[_]] { this: Foldable[F] =>
+
+  def iterable[A](fa: F[A]): Stream[A] =
+    foldRight[A, Stream[A]](fa, Eval.now(Stream.empty)) { (a, eb) =>
+      eb.map(Stream.cons(a, _))
+    }.value
+}
+
+private[cats] object FoldableCompat {
+
+  trait ToFoldableCompatOps {
+    implicit final def foldableCompatSyntax[F[_], A](fa: F[A]): FoldableCompatAllOps[F, A] =
+      new FoldableCompatAllOps(fa)
+  }
+
+  final class FoldableCompatAllOps[F[_], A](private val fa: F[A]) extends AnyVal {
+    def iterable(implicit F: Foldable[F]): Stream[A] = F.iterable(fa)
+  }
+}

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

@@ -140,6 +140,8 @@ trait StreamInstances extends cats.kernel.instances.StreamInstances {
 
       override def toList[A](fa: Stream[A]): List[A] = fa.toList
 
+      override def iterable[A](fa: Stream[A]): Stream[A] = fa
+
       override def reduceLeftOption[A](fa: Stream[A])(f: (A, A) => A): Option[A] =
         fa.reduceLeftOption(f)
 

core/src/main/scala-2.13+/cats/compat/FoldableCompat.scala

@@ -0,0 +1,22 @@
+package cats
+package compat
+
+private[cats] trait FoldableCompat[F[_]] { this: Foldable[F] =>
+
+  def iterable[A](fa: F[A]): LazyList[A] =
+    foldRight[A, LazyList[A]](fa, Eval.now(LazyList.empty)) { (a, eb) =>
+      eb.map(LazyList.cons(a, _))
+    }.value
+}
+
+private[cats] object FoldableCompat {
+
+  trait ToFoldableCompatOps {
+    implicit final def foldableCompatSyntax[F[_], A](fa: F[A]): FoldableCompatAllOps[F, A] =
+      new FoldableCompatAllOps(fa)
+  }
+
+  final class FoldableCompatAllOps[F[_], A](private val fa: F[A]) extends AnyVal {
+    def iterable(implicit F: Foldable[F]): LazyList[A] = F.iterable(fa)
+  }
+}

core/src/main/scala-2.13+/cats/instances/lazyList.scala

@@ -118,6 +118,8 @@ trait LazyListInstances extends cats.kernel.instances.LazyListInstances {
 
       override def toList[A](fa: LazyList[A]): List[A] = fa.toList
 
+      override def iterable[A](fa: LazyList[A]): LazyList[A] = fa
+
       override def reduceLeftOption[A](fa: LazyList[A])(f: (A, A) => A): Option[A] =
         fa.reduceLeftOption(f)
 

core/src/main/scala-2.13+/cats/instances/stream.scala

@@ -141,6 +141,8 @@ trait StreamInstances extends cats.kernel.instances.StreamInstances {
 
       override def toList[A](fa: Stream[A]): List[A] = fa.toList
 
+      override def iterable[A](fa: Stream[A]): LazyList[A] = LazyList.from(fa)
+
       override def reduceLeftOption[A](fa: Stream[A])(f: (A, A) => A): Option[A] =
         fa.reduceLeftOption(f)
 

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

@@ -28,7 +28,7 @@ import Foldable.sentinel
  *
  * See: [[http://www.cs.nott.ac.uk/~pszgmh/fold.pdf A tutorial on the universality and expressiveness of fold]]
  */
-@typeclass trait Foldable[F[_]] extends UnorderedFoldable[F] { self =>
+@typeclass trait Foldable[F[_]] extends cats.compat.FoldableCompat[F] with UnorderedFoldable[F] { self =>
 
   /**
    * Left associative fold on 'F' using the function 'f'.
@@ -275,6 +275,9 @@ import Foldable.sentinel
    */
   def combineAll[A: Monoid](fa: F[A]): A = fold(fa)
 
+  def combineAllOption[A](fa: F[A])(implicit ev: Semigroup[A]): Option[A] =
+    if (isEmpty(fa)) None else ev.combineAllOption(iterable(fa))
+
   /**
    * Fold implemented by mapping `A` values into `B` and then
    * combining them using the given `Monoid[B]` instance.

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

@@ -1,7 +1,11 @@
 package cats
 package syntax
 
-trait FoldableSyntax extends Foldable.ToFoldableOps with UnorderedFoldable.ToUnorderedFoldableOps {
+trait FoldableSyntax
+    extends Foldable.ToFoldableOps
+    with cats.compat.FoldableCompat.ToFoldableCompatOps
+    with UnorderedFoldable.ToUnorderedFoldableOps {
+
   implicit final def catsSyntaxNestedFoldable[F[_]: Foldable, G[_], A](fga: F[G[A]]): NestedFoldableOps[F, G, A] =
     new NestedFoldableOps[F, G, A](fga)
 

tests/src/test/scala-2.12/cats/tests/NonEmptyStreamSuite.scala

@@ -157,7 +157,7 @@ class NonEmptyStreamSuite extends CatsSuite {
 }
 
 class ReducibleNonEmptyStreamSuite extends ReducibleSuite[NonEmptyStream]("NonEmptyStream") {
-  def iterator[T](nes: NonEmptyStream[T]): Iterator[T] =
+  override def iterator[T](nes: NonEmptyStream[T]): Iterator[T] =
     (nes.head #:: nes.tail).iterator
 
   def range(start: Long, endInclusive: Long): NonEmptyStream[Long] = {

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

@@ -133,7 +133,7 @@ class NonEmptyLazyListSuite extends CatsSuite {
 }
 
 class ReducibleNonEmptyLazyListSuite extends ReducibleSuite[NonEmptyLazyList]("NonEmptyLazyList") {
-  def iterator[T](nel: NonEmptyLazyList[T]): Iterator[T] = nel.toLazyList.iterator
+  override def iterator[T](nel: NonEmptyLazyList[T]): Iterator[T] = nel.toLazyList.iterator
 
   def range(start: Long, endInclusive: Long): NonEmptyLazyList[Long] =
     NonEmptyLazyList(start, (start + 1L).to(endInclusive): _*)

tests/src/test/scala/cats/tests/FoldableSuite.scala

@@ -214,6 +214,19 @@ abstract class FoldableSuite[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
+  test(s"Foldable[$name].combineAllOption") {
+    forAll { (fa: F[Int]) =>
+      val list = fa.toList
+      fa.combineAllOption should ===(list.combineAllOption)
+    }
+  }
+
+  test(s"Foldable[$name].iterable") {
+    forAll { (fa: F[Int]) =>
+      fa.iterable.toList should ===(iterator(fa).toList)
+    }
+  }
+
   test(s"Foldable[$name].intercalate") {
     forAll { (fa: F[String], a: String) =>
       fa.intercalate(a) should ===(fa.toList.mkString(a))