Make Bifoldable extend Any, add syntax, remove currying from bifoldMap

core/src/main/scala/cats/Bifoldable.scala

@@ -3,15 +3,15 @@ package cats
 /**
  * A type class abstracting over types that give rise to two independent [[cats.Foldable]]s.
  */
-trait Bifoldable[F[_, _]] extends Serializable { self =>
+trait Bifoldable[F[_, _]] extends Any with Serializable { self =>
   /** Collapse the structure with a left-associative function */
   def bifoldLeft[A, B, C](fab: F[A, B], c: C)(f: (C, A) => C, g: (C, B) => C): C
 
   /** Collapse the structure with a right-associative function */
   def bifoldRight[A, B, C](fab: F[A, B], c: Eval[C])(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C]
 
   /** Collapse the structure by mapping each element to an element of a type that has a [[cats.Monoid]] */
-  def bifoldMap[A, B, C](fab: F[A, B])(f: A => C)(g: B => C)(implicit C: Monoid[C]): C =
+  def bifoldMap[A, B, C](fab: F[A, B])(f: A => C, g: B => C)(implicit C: Monoid[C]): C =
     bifoldLeft(fab, C.empty)(
       (c: C, a: A) => C.combine(c, f(a)),
       (c: C, b: B) => C.combine(c, g(b))

core/src/main/scala/cats/MonadCombine.scala

@@ -21,8 +21,8 @@ import simulacrum.typeclass
 
   /** Separate the inner foldable values into the "lefts" and "rights" */
   def separate[G[_, _], A, B](fgab: F[G[A, B]])(implicit G: Bifoldable[G]): (F[A], F[B]) = {
-    val as = flatMap(fgab)(gab => G.bifoldMap(gab)(pure)(_ => empty[A])(algebra[A]))
-    val bs = flatMap(fgab)(gab => G.bifoldMap(gab)(_ => empty[B])(pure)(algebra[B]))
+    val as = flatMap(fgab)(gab => G.bifoldMap(gab)(pure, _ => empty[A])(algebra[A]))
+    val bs = flatMap(fgab)(gab => G.bifoldMap(gab)(_ => empty[B], pure)(algebra[B]))
     (as, bs)
   }
 }

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

@@ -4,6 +4,7 @@ package syntax
 trait AllSyntax
     extends ApplySyntax
     with BifunctorSyntax
+    with BifoldableSyntax
     with CartesianSyntax
     with CoflatMapSyntax
     with ComonadSyntax

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

@@ -0,0 +1,18 @@
+package cats
+package syntax
+
+trait BifoldableSyntax {
+  implicit def bifoldableSyntax[F[_, _]: Bifoldable, A, B](fab: F[A, B]): BifoldableOps[F, A, B] =
+    new BifoldableOps[F, A, B](fab)
+}
+
+final class BifoldableOps[F[_, _], A, B](fab: F[A, B])(implicit F: Bifoldable[F]) {
+  def bifoldLeft[C](c: C)(f: (C, A) => C, g: (C, B) => C): C =
+    F.bifoldLeft(fab, c)(f, g)
+
+  def bifoldRight[C](c: Eval[C])(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] =
+    F.bifoldRight(fab, c)(f, g)
+
+  def bifoldMap[C](f: A => C, g: B => C)(implicit C: Monoid[C]): C =
+    F.bifoldMap(fab)(f, g)
+}

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

@@ -4,6 +4,7 @@ package object syntax {
   object all extends AllSyntax
   object apply extends ApplySyntax
   object bifunctor extends BifunctorSyntax
+  object bifoldable extends BifoldableSyntax
   object cartesian extends CartesianSyntax
   object coflatMap extends CoflatMapSyntax
   object coproduct extends CoproductSyntax

laws/src/main/scala/cats/laws/BifoldableLaws.scala

@@ -9,15 +9,15 @@ trait BifoldableLaws[F[_, _]] {
       (c: C, a: A) => C.combine(c, f(a)),
       (c: C, b: B) => C.combine(c, g(b))
     )
-    expected <-> F.bifoldMap(fab)(f)(g)
+    expected <-> F.bifoldMap(fab)(f, g)
   }
 
   def bifoldRightConsistentWithBifoldMap[A, B, C](fab: F[A, B], f: A => C, g: B => C)(implicit C: Monoid[C]): IsEq[C] = {
     val expected = F.bifoldRight(fab, Later(C.empty))(
       (a: A, ec: Eval[C]) => ec.map(c => C.combine(f(a), c)),
       (b: B, ec: Eval[C]) => ec.map(c => C.combine(g(b), c))
     )
-    expected.value <-> F.bifoldMap(fab)(f)(g)
+    expected.value <-> F.bifoldMap(fab)(f, g)
   }
 }
 

tests/src/test/scala/cats/tests/SyntaxTests.scala

@@ -185,4 +185,20 @@ class SyntaxTests extends AllInstances with AllSyntax {
     val fz4: F[Z] = (fa |@| fb |@| fc).map(f2)
     val fz5: F[Z] = (fa |@| fb |@| fc).apWith(ff2)
   }
+
+  def testBifoldable[F[_, _]: Bifoldable, A, B, C, D: Monoid]: Unit = {
+    val fab = mock[F[A, B]]
+
+    val f0 = mock[(C, A) => C]
+    val g0 = mock[(C, B) => C]
+    val c0 = fab.bifoldLeft(mock[C])(f0, g0)
+
+    val f1 = mock[(A, Eval[C]) => Eval[C]]
+    val g1 = mock[(B, Eval[C]) => Eval[C]]
+    val c1 = fab.bifoldRight(mock[Eval[C]])(f1, g1)
+
+    val f2 = mock[A => D]
+    val g2 = mock[B => D]
+    val d0 = fab.bifoldMap(f2, g2)
+  }
 }