MTL begone (#1751)

core/src/main/scala/cats/Alternative.scala

@@ -3,6 +3,25 @@ package cats
 import simulacrum.typeclass
 
 @typeclass trait Alternative[F[_]] extends Applicative[F] with MonoidK[F] { self =>
+  /**
+    * Fold over the inner structure to combine all of the values with
+    * our combine method inherited from MonoidK. The result is for us
+    * to accumulate all of the "interesting" values of the inner G, so
+    * if G is Option, we collect all the Some values, if G is Either,
+    * we collect all the Right values, etc.
+    */
+  def unite[G[_], A](fga: F[G[A]])(implicit FM: Monad[F], G: Foldable[G]): F[A] =
+    FM.flatMap(fga) { ga =>
+      G.foldLeft(ga, empty[A])((acc, a) => combineK(acc, pure(a)))
+    }
+
+  /** Separate the inner foldable values into the "lefts" and "rights" */
+  def separate[G[_, _], A, B](fgab: F[G[A, B]])(implicit FM: Monad[F], G: Bifoldable[G]): (F[A], F[B]) = {
+    val as = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(pure, _ => empty[A])(algebra[A]))
+    val bs = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(_ => empty[B], pure)(algebra[B]))
+    (as, bs)
+  }
+
   override def compose[G[_]: Applicative]: Alternative[λ[α => F[G[α]]]] =
     new ComposedAlternative[F, G] {
       val F = self

core/src/main/scala/cats/Composed.scala

@@ -79,22 +79,6 @@ private[cats] trait ComposedNonEmptyTraverse[F[_], G[_]] extends NonEmptyTravers
     F.nonEmptyTraverse(fga)(ga => G.nonEmptyTraverse(ga)(f))
 }
 
-private[cats] trait ComposedTraverseFilter[F[_], G[_]] extends TraverseFilter[λ[α => F[G[α]]]] with ComposedTraverse[F, G] {
-  def F: Traverse[F]
-  def G: TraverseFilter[G]
-
-  override def traverseFilter[H[_]: Applicative, A, B](fga: F[G[A]])(f: A => H[Option[B]]): H[F[G[B]]] =
-    F.traverse[H, G[A], G[B]](fga)(ga => G.traverseFilter(ga)(f))
-}
-
-private[cats] trait ComposedFunctorFilter[F[_], G[_]] extends FunctorFilter[λ[α => F[G[α]]]] with ComposedFunctor[F, G] {
-  def F: Functor[F]
-  def G: FunctorFilter[G]
-
-  override def mapFilter[A, B](fga: F[G[A]])(f: A => Option[B]): F[G[B]] =
-    F.map(fga)(G.mapFilter(_)(f))
-}
-
 private[cats] trait ComposedReducible[F[_], G[_]] extends Reducible[λ[α => F[G[α]]]] with ComposedFoldable[F, G] { outer =>
   def F: Reducible[F]
   def G: Reducible[G]

core/src/main/scala/cats/Functor.scala

@@ -68,12 +68,6 @@ import simulacrum.typeclass
       val G = Functor[G]
     }
 
-  def composeFilter[G[_]: FunctorFilter]: FunctorFilter[λ[α => F[G[α]]]] =
-    new ComposedFunctorFilter[F, G] {
-      val F = self
-      val G = FunctorFilter[G]
-    }
-
   override def composeContravariant[G[_]: Contravariant]: Contravariant[λ[α => F[G[α]]]] =
     new ComposedCovariantContravariant[F, G] {
       val F = self

core/src/main/scala/cats/Traverse.scala

@@ -92,12 +92,6 @@ import simulacrum.typeclass
       val G = Traverse[G]
     }
 
-  def composeFilter[G[_]: TraverseFilter]: TraverseFilter[λ[α => F[G[α]]]] =
-    new ComposedTraverseFilter[F, G] {
-      val F = self
-      val G = TraverseFilter[G]
-    }
-
   override def map[A, B](fa: F[A])(f: A => B): F[B] =
     traverse[Id, A, B](fa)(f)