Fix foldA, reduceA, and reduceMapA short-circuiting

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

@@ -412,7 +412,7 @@ import Foldable.sentinel
    * `noop` usage description [[https://github.com/typelevel/simulacrum/issues/162 here]]
    */
   @noop def foldA[G[_], A](fga: F[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A] =
-    fold(fga)(Applicative.monoid)
+    foldMapA(fga)(identity)
 
   /**
    * Fold implemented by mapping `A` values into `B` in a context `G` and then

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

@@ -89,14 +89,14 @@ import simulacrum.{noop, typeclass}
    * `noop` usage description [[https://github.com/typelevel/simulacrum/issues/162 here]]
    */
   @noop def reduceA[G[_], A](fga: F[G[A]])(implicit G: Apply[G], A: Semigroup[A]): G[A] =
-    reduce(fga)(Apply.semigroup)
+    reduceMapA(fga)(identity)
 
   /**
    * Apply `f` to each `a` of `fa` and combine the result into Apply[G] using the
    * given `Semigroup[B]`.
    */
   def reduceMapA[G[_], A, B](fa: F[A])(f: A => G[B])(implicit G: Apply[G], B: Semigroup[B]): G[B] =
-    reduceLeftTo(fa)(f)((gb, a) => G.map2(gb, f(a))(B.combine))
+    reduceRightTo(fa)(f)((a, egb) => G.map2Eval(f(a), egb)(B.combine)).value
 
   /**
    * Monadic reducing by mapping the `A` values to `G[B]`. combining

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

@@ -470,6 +470,13 @@ class FoldableSuiteAdditional extends CatsSuite with ScalaVersionSpecificFoldabl
     assert(ns.foldA == "boom!!!".asLeft[Int])
   }
 
+  test(".foldA short-circuiting") {
+    implicit val F = foldableStreamWithDefaultImpl
+    val ns = Stream.from(1).map(n => if (n >= 100000) Left(n) else Right(n))
+
+    assert(F.foldA(ns) === Left(100000))
+  }
+
   test(".foldLeftM short-circuiting") {
     implicit val F = foldableStreamWithDefaultImpl
     val ns = Stream.continually(1)

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

@@ -99,6 +99,20 @@ class ReducibleSuiteAdditional extends CatsSuite {
 
     assert(xs.reduceMapM(i => if (i < n) Right(i) else Left(i)) === Left(n))
   }
+
+  test("reduceMapA should be stack-safe and short-circuiting if reduceRightTo is sufficiently lazy") {
+    val n = 100000
+    val xs = NES(0, Stream.from(1))
+
+    assert(xs.reduceMapA(i => if (i < n) Right(i) else Left(i)) === Left(n))
+  }
+
+  test("reduceA should be stack-safe and short-circuiting if reduceRightTo is sufficiently lazy") {
+    val n = 100000
+    val xs = NES(Right(0), Stream.from(1).map(i => if (i < n) Right(i) else Left(i)))
+
+    assert(xs.reduceA === Left(n))
+  }
 }
 
 abstract class ReducibleSuite[F[_]: Reducible](name: String)(implicit ArbFInt: Arbitrary[F[Int]],