Follow up to #751

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

@@ -2,5 +2,20 @@ package cats
 
 import simulacrum.typeclass
 
-@typeclass trait Alternative[F[_]] extends Applicative[F] with MonoidK[F]
+@typeclass trait Alternative[F[_]] extends Applicative[F] with MonoidK[F] { self =>
+  /**
+   * Compose two Alternative intsances.
+   */
+  def compose[G[_]](implicit GG: Alternative[G]): Alternative[λ[α => F[G[α]]]] =
+    new CompositeAlternative[F, G] {
+      implicit def F: Alternative[F] = self
+      implicit def G: Alternative[G] = GG
+    }
+}
 
+trait CompositeAlternative[F[_], G[_]]
+  extends Alternative[λ[α => F[G[α]]]] with CompositeApplicative[F, G] with CompositeMonoidK[F, G] {
+
+  implicit def F: Alternative[F]
+  implicit def G: Alternative[G]
+}

core/src/main/scala/cats/MonoidK.scala

@@ -29,6 +29,15 @@ import simulacrum.typeclass
    */
   def empty[A]: F[A]
 
+  /**
+   * Compose two MonoidK intsances.
+   */
+  def compose[G[_]](implicit GG: MonoidK[G]): MonoidK[λ[α => F[G[α]]]] =
+    new CompositeMonoidK[F, G] {
+      implicit def F: MonoidK[F] = self
+      implicit def G: MonoidK[G] = GG
+    }
+
   /**
    * Given a type A, create a concrete Monoid[F[A]].
    */
@@ -38,3 +47,13 @@ import simulacrum.typeclass
       def combine(x: F[A], y: F[A]): F[A] = self.combine(x, y)
     }
 }
+
+trait CompositeMonoidK[F[_],G[_]]
+  extends MonoidK[λ[α => F[G[α]]]] {
+
+  implicit def F: MonoidK[F]
+  implicit def G: MonoidK[G]
+
+  def empty[A]: F[G[A]] = F.empty
+  def combine[A](x: F[G[A]], y: F[G[A]]): F[G[A]] = F.combine(x, y)
+}

core/src/main/scala/cats/data/OneAnd.scala

@@ -161,6 +161,12 @@ trait OneAndLowPriority1 extends OneAndLowPriority0 {
       def map[A, B](fa: OneAnd[F, A])(f: A => B): OneAnd[F, B] =
         OneAnd(f(fa.head), F.map(fa.tail)(f))
     }
+
+  implicit def oneAndReducible[F[_]](implicit foldable: Foldable[F]): Reducible[OneAnd[F, ?]] =
+    new NonEmptyReducible[OneAnd[F, ?], F] {
+      def split[A](fa: OneAnd[F, A]): (A, F[A]) = (fa.head, fa.tail)
+    }
+
 }
 
 object OneAnd extends OneAndInstances

tests/src/test/scala/cats/tests/ComposeTests.scala

@@ -2,7 +2,8 @@ package cats
 package tests
 
 import cats.data.{ NonEmptyList, NonEmptyVector, OneAnd }
-import cats.laws.discipline.{ ApplicativeTests, FoldableTests, MonoidalTests, SemigroupKTests, arbitrary, eq }, arbitrary._, eq._
+import cats.laws.discipline.{ AlternativeTests, ApplicativeTests, FoldableTests, MonoidKTests, MonoidalTests, SemigroupKTests }
+import cats.laws.discipline.{ arbitrary, eq }, arbitrary._, eq._
 import org.scalacheck.Arbitrary
 
 class ComposeTests extends CatsSuite {
@@ -12,6 +13,15 @@ class ComposeTests extends CatsSuite {
   implicit override val generatorDrivenConfig: PropertyCheckConfiguration =
     PropertyCheckConfig(maxSize = 5, minSuccessful = 20)
 
+  {
+    // Alternative composition
+
+    implicit val alternativeListVector: Alternative[Lambda[A => List[Vector[A]]]] = Alternative[List] compose Alternative[Vector]
+    implicit val iso = MonoidalTests.Isomorphisms.invariant[Lambda[A => List[Vector[A]]]]
+
+    checkAll("Alternative[Lambda[A => List[Vector[A]]]]", AlternativeTests[Lambda[A => List[Vector[A]]]].alternative[Int, Int, Int])
+  }
+
   {
     // Applicative composition
 
@@ -30,19 +40,18 @@ class ComposeTests extends CatsSuite {
   }
 
   {
-    // Reducible composition
+    // MonoidK composition
+
+    implicit val monoidKListVector: MonoidK[Lambda[A => List[Vector[A]]]] = MonoidK[List] compose MonoidK[Vector]
 
-    val nelReducible =
-      new NonEmptyReducible[NonEmptyList, List] {
-        def split[A](fa: NonEmptyList[A]): (A, List[A]) = (fa.head, fa.tail)
-      }
+    checkAll("MonoidK[Lambda[A => List[Vector[A]]]]", MonoidKTests[Lambda[A => List[Vector[A]]]].monoidK[Int])
+  }
 
-    val nevReducible =
-      new NonEmptyReducible[NonEmptyVector, Vector] {
-        def split[A](fa: NonEmptyVector[A]): (A, Vector[A]) = (fa.head, fa.tail)
-      }
+  {
+    // Reducible composition
 
-    implicit val reducibleListVector: Reducible[Lambda[A => NonEmptyList[NonEmptyVector[A]]]] = nelReducible compose nevReducible
+    implicit val reducibleListVector: Reducible[Lambda[A => NonEmptyList[NonEmptyVector[A]]]] =
+      Reducible[NonEmptyList] compose Reducible[NonEmptyVector]
 
     // No Reducible-specific laws, so check the Foldable laws are satisfied
     checkAll("Reducible[Lambda[A => List[Vector[A]]]]", FoldableTests[Lambda[A => NonEmptyList[NonEmptyVector[A]]]].foldable[Int, Int])