move instances into separate trait

core/src/main/scala/cats/Cartesian.scala

@@ -16,14 +16,4 @@ import simulacrum.typeclass
   def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
 }
 
-object Cartesian extends CartesianArityFunctions with KernelCartesianInstances
-
-/**
- * Cartesian instances for types that are housed in Kernel and therefore
- * can't have instances for Cats type classes in their companion objects.
- */
-private[cats] sealed trait KernelCartesianInstances {
-  implicit val catsInvariantSemigroup: Cartesian[Semigroup] = InvariantMonoidal.catsInvariantMonoidalSemigroup
-  implicit val catsInvariantMonoid: Cartesian[Monoid] = InvariantMonoidal.catsInvariantMonoidalMonoid
-  implicit val catsCartesianEq: Cartesian[Eq] = ContravariantCartesian.catsContravariantCartesianEq
-}
+object Cartesian extends CartesianArityFunctions

core/src/main/scala/cats/ContravariantCartesian.scala

@@ -14,13 +14,3 @@ import simulacrum.typeclass
       def G = Functor[G]
     }
 }
-
-object ContravariantCartesian extends KernelContravariantCartesianInstances
-
-private[cats] sealed trait KernelContravariantCartesianInstances {
-  implicit val catsContravariantCartesianEq: ContravariantCartesian[Eq] = new ContravariantCartesian[Eq] {
-    def contramap[A, B](fa: Eq[A])(fn: B => A): Eq[B] = fa.on(fn)
-    def product[A, B](fa: Eq[A], fb: Eq[B]): Eq[(A, B)] =
-      Eq.instance { (left, right) => fa.eqv(left._1, right._1) && fb.eqv(left._2, right._2) }
-  }
-}

core/src/main/scala/cats/InvariantMonoidal.scala

@@ -11,49 +11,3 @@ import simulacrum.typeclass
 @typeclass trait InvariantMonoidal[F[_]] extends Invariant[F] with Cartesian[F] {
   def pure[A](a: A): F[A]
 }
-
-object InvariantMonoidal extends KernelInvariantMonoidalInstances
-
-/**
- * InvariantMonoidal instances for types that are housed in cats.kernel and therefore
- * can't have instances for this type class in their companion objects.
- */
-private[cats] trait KernelInvariantMonoidalInstances {
-  implicit val catsInvariantMonoidalSemigroup: InvariantMonoidal[Semigroup] = new InvariantMonoidal[Semigroup] {
-    def product[A, B](fa: Semigroup[A], fb: Semigroup[B]): Semigroup[(A, B)] = new Semigroup[(A, B)] {
-      def combine(x: (A, B), y: (A, B)): (A, B) = fa.combine(x._1, y._1) -> fb.combine(x._2, y._2)
-    }
-
-    def imap[A, B](fa: Semigroup[A])(f: A => B)(g: B => A): Semigroup[B] = new Semigroup[B] {
-      def combine(x: B, y: B): B = f(fa.combine(g(x), g(y)))
-      override def combineAllOption(bs: TraversableOnce[B]): Option[B] =
-        fa.combineAllOption(bs.map(g)).map(f)
-    }
-
-    def pure[A](a: A): Semigroup[A] = new Semigroup[A] {
-      def combine(x: A, y: A): A = a
-      override def combineAllOption(as: TraversableOnce[A]): Option[A] =
-        if (as.isEmpty) None else Some(a)
-    }
-  }
-
-  implicit val catsInvariantMonoidalMonoid: InvariantMonoidal[Monoid] = new InvariantMonoidal[Monoid] {
-    def product[A, B](fa: Monoid[A], fb: Monoid[B]): Monoid[(A, B)] = new Monoid[(A, B)] {
-      val empty = fa.empty -> fb.empty
-      def combine(x: (A, B), y: (A, B)): (A, B) = fa.combine(x._1, y._1) -> fb.combine(x._2, y._2)
-    }
-
-    def imap[A, B](fa: Monoid[A])(f: A => B)(g: B => A): Monoid[B] = new Monoid[B] {
-      val empty = f(fa.empty)
-      def combine(x: B, y: B): B = f(fa.combine(g(x), g(y)))
-      override def combineAll(bs: TraversableOnce[B]): B =
-        f(fa.combineAll(bs.map(g)))
-    }
-
-    def pure[A](a: A): Monoid[A] = new Monoid[A] {
-      val empty = a
-      def combine(x: A, y: A): A = a
-      override def combineAll(as: TraversableOnce[A]): A = a
-    }
-  }
-}

core/src/main/scala/cats/functor/Contravariant.scala

@@ -28,32 +28,3 @@ import simulacrum.typeclass
       val G = Functor[G]
     }
 }
-
-object Contravariant extends KernelContravariantInstances
-
-/**
- * Convariant instances for types that are housed in cats.kernel and therefore
- * can't have instances for this type class in their companion objects.
- */
-private[functor] sealed trait KernelContravariantInstances {
-  implicit def catsFunctorContravariantForEq: Contravariant[Eq] =
-    ContravariantCartesian.catsContravariantCartesianEq
-
-  implicit val catsFunctorContravariantForPartialOrder: Contravariant[PartialOrder] =
-    new Contravariant[PartialOrder] {
-      /** Derive a `PartialOrder` for `B` given a `PartialOrder[A]` and a function `B => A`.
-       *
-       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
-       */
-      def contramap[A, B](fa: PartialOrder[A])(f: B => A): PartialOrder[B] = fa.on(f)
-    }
-
-  implicit val catsFunctorContravariantForOrder: Contravariant[Order] =
-    new Contravariant[Order] {
-      /** Derive an `Order` for `B` given an `Order[A]` and a function `B => A`.
-       *
-       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
-       */
-      def contramap[A, B](fa: Order[A])(f: B => A): Order[B] = fa.on(f)
-    }
-}

core/src/main/scala/cats/functor/Invariant.scala

@@ -27,14 +27,3 @@ import simulacrum.typeclass
       val G = Contravariant[G]
     }
 }
-
-object Invariant extends KernelInvariantInstances
-
-/**
- * Invariant instances for types that are housed in cats.kernel and therefore
- * can't have instances for this type class in their companion objects.
- */
-private[functor] sealed trait KernelInvariantInstances {
-  implicit val catsFunctorInvariantForSemigroup: Invariant[Semigroup] = InvariantMonoidal.catsInvariantMonoidalSemigroup
-  implicit val catsFunctorInvariantForMonoid: Invariant[Monoid] = InvariantMonoidal.catsInvariantMonoidalMonoid
-}

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

@@ -5,8 +5,13 @@ trait AllInstances
   extends FunctionInstances
   with    StringInstances
   with    EitherInstances
+  with    EqInstances
   with    ListInstances
   with    OptionInstances
+  with    OrderInstances
+  with    MonoidInstances
+  with    PartialOrderInstances
+  with    SemigroupInstances
   with    SetInstances
   with    StreamInstances
   with    VectorInstances

core/src/main/scala/cats/instances/eq.scala

@@ -0,0 +1,10 @@
+package cats
+package instances
+
+trait EqInstances {
+  implicit val catsContravariantCartesianEq: ContravariantCartesian[Eq] = new ContravariantCartesian[Eq] {
+    def contramap[A, B](fa: Eq[A])(fn: B => A): Eq[B] = fa.on(fn)
+    def product[A, B](fa: Eq[A], fb: Eq[B]): Eq[(A, B)] =
+      Eq.instance { (left, right) => fa.eqv(left._1, right._1) && fb.eqv(left._2, right._2) }
+  }
+}

core/src/main/scala/cats/instances/monoid.scala

@@ -0,0 +1,26 @@
+package cats
+package instances
+
+trait MonoidInstances {
+
+  implicit val catsInvariantMonoidalMonoid: InvariantMonoidal[Monoid] = new InvariantMonoidal[Monoid] {
+    def product[A, B](fa: Monoid[A], fb: Monoid[B]): Monoid[(A, B)] = new Monoid[(A, B)] {
+      val empty = fa.empty -> fb.empty
+      def combine(x: (A, B), y: (A, B)): (A, B) = fa.combine(x._1, y._1) -> fb.combine(x._2, y._2)
+    }
+
+    def imap[A, B](fa: Monoid[A])(f: A => B)(g: B => A): Monoid[B] = new Monoid[B] {
+      val empty = f(fa.empty)
+      def combine(x: B, y: B): B = f(fa.combine(g(x), g(y)))
+      override def combineAll(bs: TraversableOnce[B]): B =
+        f(fa.combineAll(bs.map(g)))
+    }
+
+    def pure[A](a: A): Monoid[A] = new Monoid[A] {
+      val empty = a
+      def combine(x: A, y: A): A = a
+      override def combineAll(as: TraversableOnce[A]): A = a
+    }
+  }
+
+}

core/src/main/scala/cats/instances/order.scala

@@ -0,0 +1,16 @@
+package cats
+package instances
+
+import cats.functor.Contravariant
+
+trait OrderInstances {
+
+  implicit val catsFunctorContravariantForOrder: Contravariant[Order] =
+    new Contravariant[Order] {
+      /** Derive an `Order` for `B` given an `Order[A]` and a function `B => A`.
+       *
+       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
+       */
+      def contramap[A, B](fa: Order[A])(f: B => A): Order[B] = fa.on(f)
+    }
+}

core/src/main/scala/cats/instances/partialOrder.scala

@@ -0,0 +1,15 @@
+package cats
+package instances
+
+import cats.functor.Contravariant
+
+trait PartialOrderInstances {
+  implicit val catsFunctorContravariantForPartialOrder: Contravariant[PartialOrder] =
+    new Contravariant[PartialOrder] {
+      /** Derive a `PartialOrder` for `B` given a `PartialOrder[A]` and a function `B => A`.
+       *
+       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
+       */
+      def contramap[A, B](fa: PartialOrder[A])(f: B => A): PartialOrder[B] = fa.on(f)
+    }
+}

core/src/main/scala/cats/instances/semigroup.scala

@@ -0,0 +1,24 @@
+package cats
+package instances
+
+trait SemigroupInstances {
+
+  implicit val catsInvariantMonoidalSemigroup: InvariantMonoidal[Semigroup] = new InvariantMonoidal[Semigroup] {
+    def product[A, B](fa: Semigroup[A], fb: Semigroup[B]): Semigroup[(A, B)] = new Semigroup[(A, B)] {
+      def combine(x: (A, B), y: (A, B)): (A, B) = fa.combine(x._1, y._1) -> fb.combine(x._2, y._2)
+    }
+
+    def imap[A, B](fa: Semigroup[A])(f: A => B)(g: B => A): Semigroup[B] = new Semigroup[B] {
+      def combine(x: B, y: B): B = f(fa.combine(g(x), g(y)))
+      override def combineAllOption(bs: TraversableOnce[B]): Option[B] =
+        fa.combineAllOption(bs.map(g)).map(f)
+    }
+
+    def pure[A](a: A): Semigroup[A] = new Semigroup[A] {
+      def combine(x: A, y: A): A = a
+      override def combineAllOption(as: TraversableOnce[A]): Option[A] =
+        if (as.isEmpty) None else Some(a)
+    }
+  }
+
+}