Issue 3141

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

@@ -278,6 +278,26 @@ import Foldable.sentinel
     }
   }
 
+  /**
+    * Fold implemented using the given `Applicative[G]` and `Monoid[A]` instance.
+    *
+    * This method is identical to fold, except that we use `Applicative[G]` and `Monoid[A]`
+    * to combine a's inside an applicative G.
+    *
+    * For example:
+    *
+    * {{{
+    * scala> import cats.implicits._
+    * scala> val F = Foldable[List]
+    * scala> F.foldA(List(Right(1) :: Right(2) :: Nil)
+    * res0: Right[Int] = Right(3)
+    * }}}
+    */
+  def foldA[G[_], A](fga: F[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A] =
+    foldLeft(fga, G.pure(A.empty)) { (acc, ga) =>
+      G.map2(acc, ga)(A.combine)
+    }
+
   /**
    * Alias for [[foldM]].
    */

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

@@ -66,6 +66,22 @@ import simulacrum.typeclass
   def reduceLeftM[G[_], A, B](fa: F[A])(f: A => G[B])(g: (B, A) => G[B])(implicit G: FlatMap[G]): G[B] =
     reduceLeftTo(fa)(f)((gb, a) => G.flatMap(gb)(g(_, a)))
 
+  /**
+    * Reduce a `F[G[A]]` value using `Applicative[G]` and `Semigroup[A]`, a universal
+    * semigroup for `G[_]`.
+    *
+    * This method is a generalization of `reduce`.
+    */
+  def reduceA[G[_], A](fga: F[G[A]])(implicit G: Applicative[G], A: Semigroup[A]): G[A] =
+    reduceLeft(fga)((ga1, ga2) => G.map2(ga1, ga2)(A.combine))
+
+  /**
+    * Apply `f` to each applicative `ga` of `fga` and combine them using the
+    * given `Semigroup[B]`.
+    */
+  def reduceMapA[G[_], A, B](fga: F[G[A]])(f: A => B)(implicit G: Applicative[G], B: Semigroup[B]): G[B] =
+    reduceLeftTo(fga)(ga => G.map(ga)(f))((gb, ga) => G.map2(gb, G.map(ga)(f))(B.combine))
+
   /**
    * Monadic reducing by mapping the `A` values to `G[B]`. combining
    * the `B` values using the given `Semigroup[B]` instance.