Backport #2380 Add combineAllOption to Foldable

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

@@ -238,9 +238,7 @@ import Foldable.sentinel
    * Fold implemented using the given Monoid[A] instance.
    */
   def fold[A](fa: F[A])(implicit A: Monoid[A]): A =
-    foldLeft(fa, A.empty) { (acc, a) =>
-      A.combine(acc, a)
-    }
+    A.combineAll(cats.compat.FoldableCompat.toIterable(fa)(this))
 
   /**
    * Alias for [[fold]].

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

@@ -0,0 +1,12 @@
+package cats.compat
+
+import cats.{Eval, Foldable}
+
+private[cats] object FoldableCompat {
+
+  def toIterable[F[_], A](fa: F[A])(F: Foldable[F]): Iterable[A] =
+    F.foldRight[A, Stream[A]](fa, Eval.now(Stream.empty)) { (a, eb) =>
+        eb.map(Stream.cons(a, _))
+      }
+      .value
+}

core/src/main/scala/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
 
+      def toIterable[A](fa: Stream[A]): Iterable[A] = fa
+
       override def reduceLeftOption[A](fa: Stream[A])(f: (A, A) => A): Option[A] =
         fa.reduceLeftOption(f)
 

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

@@ -331,6 +331,18 @@ final class FoldableOps0[F[_], A](private val fa: F[A]) extends AnyVal {
    */
   def maximumByOption[B: Order](f: A => B)(implicit F: Foldable[F]): Option[A] =
     F.maximumOption(fa)(Order.by(f))
+
+  def combineAllOption(implicit ev: Semigroup[A], F: Foldable[F]): Option[A] =
+    if (F.isEmpty(fa)) None else ev.combineAllOption(toIterable)
+
+  /**
+   * Convert F[A] to an Iterable[A].
+   *
+   * This method may be overridden for the sake of performance, but implementers should take care
+   * not to force a full materialization of the collection.
+   */
+  def toIterable(implicit F: Foldable[F]): Iterable[A] =
+    cats.compat.FoldableCompat.toIterable(fa)(F)
 }
 
 final private[syntax] class FoldableOps1[F[_]](private val F: Foldable[F]) extends AnyVal {

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

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