Reduce jar size by using abstract classes

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

@@ -23,7 +23,7 @@ package cats
 package instances
 
 abstract class AllInstancesBinCompat
-    extends AllInstances
+    extends AbstractAllInstances
     with AllInstancesBinCompat0
     with AllInstancesBinCompat1
     with AllInstancesBinCompat2
@@ -34,6 +34,8 @@ abstract class AllInstancesBinCompat
     with AllInstancesBinCompat7
     with AllInstancesBinCompat8
 
+abstract private[cats] class AbstractAllInstances extends AbstractAnyValInstances with AllInstances
+
 trait AllInstances
     extends AnyValInstances
     with BigIntInstances

core/src/main/scala-2.12/cats/instances/package.scala

@@ -77,7 +77,7 @@ package object instances {
   object string extends StringInstances
   object tailRec extends TailRecInstances
   object try_ extends TryInstances
-  object tuple extends TupleInstances with Tuple2InstancesBinCompat0
+  object tuple extends AbstractTupleInstances with Tuple2InstancesBinCompat0
   object unit extends UnitInstances
   object uuid extends UUIDInstances
   object vector extends VectorInstances with VectorInstancesBinCompat0

core/src/main/scala-2.13+/cats/data/NonEmptyLazyList.scala

@@ -514,9 +514,10 @@ sealed abstract private[data] class NonEmptyLazyListInstances extends NonEmptyLa
     NonEmptyLazyList
   ] & NonEmptyAlternative[NonEmptyLazyList] & Align[NonEmptyLazyList] =
     new AbstractNonEmptyInstances[LazyList, NonEmptyLazyList] with Align[NonEmptyLazyList] {
-
       def extract[A](fa: NonEmptyLazyList[A]): A = fa.head
 
+      override def split[A](fa: NonEmptyLazyList[A]): (A, LazyList[A]) = (fa.head, fa.tail)
+
       def nonEmptyTraverse[G[_]: Apply, A, B](fa: NonEmptyLazyList[A])(f: A => G[B]): G[NonEmptyLazyList[B]] = {
         def loop(head: A, tail: LazyList[A]): Eval[G[NonEmptyLazyList[B]]] =
           tail.headOption.fold(Eval.now(Apply[G].map(f(head))(NonEmptyLazyList(_)))) { h =>
@@ -526,9 +527,12 @@ sealed abstract private[data] class NonEmptyLazyListInstances extends NonEmptyLa
         loop(fa.head, fa.tail).value
       }
 
-      def reduceLeftTo[A, B](fa: NonEmptyLazyList[A])(f: A => B)(g: (B, A) => B): B = fa.reduceLeftTo(f)(g)
+      override def reduceLeftTo[A, B](fa: NonEmptyLazyList[A])(f: A => B)(g: (B, A) => B): B =
+        fa.reduceLeftTo(f)(g)
 
-      def reduceRightTo[A, B](fa: NonEmptyLazyList[A])(f: A => B)(g: (A, cats.Eval[B]) => cats.Eval[B]): cats.Eval[B] =
+      override def reduceRightTo[A, B](
+        fa: NonEmptyLazyList[A]
+      )(f: A => B)(g: (A, cats.Eval[B]) => cats.Eval[B]): cats.Eval[B] =
         fa.tail match {
           case head +: tail =>
             val nell = NonEmptyLazyList.fromLazyListPrepend(head, tail)

core/src/main/scala-2.13+/cats/data/ZipLazyList.scala

@@ -29,7 +29,7 @@ object ZipLazyList {
   def apply[A](value: LazyList[A]): ZipLazyList[A] = new ZipLazyList(value)
 
   implicit val catsDataAlternativeForZipLazyList: Alternative[ZipLazyList] & CommutativeApplicative[ZipLazyList] =
-    new Alternative[ZipLazyList] with CommutativeApplicative[ZipLazyList] {
+    new Apply.AbstractApply[ZipLazyList] with Alternative[ZipLazyList] with CommutativeApplicative[ZipLazyList] {
       def pure[A](x: A): ZipLazyList[A] = new ZipLazyList(LazyList.continually(x))
 
       override def map[A, B](fa: ZipLazyList[A])(f: (A) => B): ZipLazyList[B] =

core/src/main/scala-2.13+/cats/data/ZipStream.scala

@@ -31,7 +31,7 @@ object ZipStream {
   def apply[A](value: Stream[A]): ZipStream[A] = new ZipStream(value)
 
   implicit val catsDataAlternativeForZipStream: Alternative[ZipStream] & CommutativeApplicative[ZipStream] =
-    new Alternative[ZipStream] with CommutativeApplicative[ZipStream] {
+    new Apply.AbstractApply[ZipStream] with Alternative[ZipStream] with CommutativeApplicative[ZipStream] {
       def pure[A](x: A): ZipStream[A] = new ZipStream(Stream.continually(x))
 
       override def map[A, B](fa: ZipStream[A])(f: (A) => B): ZipStream[B] =

core/src/main/scala-2.13+/cats/instances/all.scala

@@ -23,7 +23,7 @@ package cats
 package instances
 
 abstract class AllInstancesBinCompat
-    extends AllInstances
+    extends AbstractAllInstances
     with AllInstancesBinCompat0
     with AllInstancesBinCompat1
     with AllInstancesBinCompat2
@@ -35,6 +35,8 @@ abstract class AllInstancesBinCompat
     with AllInstancesBinCompat8
     with AllInstancesBinCompat9
 
+abstract private[cats] class AbstractAllInstances extends AbstractAnyValInstances with AllInstances
+
 trait AllInstances
     extends AnyValInstances
     with ArraySeqInstances

core/src/main/scala-2.13+/cats/instances/arraySeq.scala

@@ -42,11 +42,13 @@ trait ArraySeqInstances extends cats.kernel.instances.ArraySeqInstances {
 private[cats] object ArraySeqInstances {
   final private val stdInstances
     : Traverse[ArraySeq] & Monad[ArraySeq] & Alternative[ArraySeq] & CoflatMap[ArraySeq] & Align[ArraySeq] =
-    new Traverse[ArraySeq]
+    new FlatMap.FoldableFlatMap[ArraySeq]
+      with Traverse[ArraySeq]
       with Monad[ArraySeq]
       with Alternative[ArraySeq]
       with CoflatMap[ArraySeq]
       with Align[ArraySeq] {
+
       def empty[A]: ArraySeq[A] =
         ArraySeq.untagged.empty
 

core/src/main/scala-2.13+/cats/instances/lazyList.scala

@@ -35,7 +35,8 @@ trait LazyListInstances extends cats.kernel.instances.LazyListInstances {
 
   implicit val catsStdInstancesForLazyList
     : Traverse[LazyList] & Alternative[LazyList] & Monad[LazyList] & CoflatMap[LazyList] & Align[LazyList] =
-    new Traverse[LazyList]
+    new FlatMap.FoldableFlatMap[LazyList]
+      with Traverse[LazyList]
       with Alternative[LazyList]
       with Monad[LazyList]
       with CoflatMap[LazyList]

core/src/main/scala-2.13+/cats/instances/package.scala

@@ -81,7 +81,7 @@ package object instances {
   object string extends StringInstances
   object tailRec extends TailRecInstances
   object try_ extends TryInstances
-  object tuple extends TupleInstances with Tuple2InstancesBinCompat0
+  object tuple extends AbstractTupleInstances with Tuple2InstancesBinCompat0
   object unit extends UnitInstances
   object uuid extends UUIDInstances
   object vector extends VectorInstances with VectorInstancesBinCompat0

core/src/main/scala-2.13+/cats/instances/stream.scala

@@ -34,7 +34,12 @@ trait StreamInstances extends cats.kernel.instances.StreamInstances {
   @deprecated("Use cats.instances.lazyList", "2.0.0-RC2")
   implicit val catsStdInstancesForStream
     : Traverse[Stream] & Alternative[Stream] & Monad[Stream] & CoflatMap[Stream] & Align[Stream] =
-    new Traverse[Stream] with Alternative[Stream] with Monad[Stream] with CoflatMap[Stream] with Align[Stream] {
+    new FlatMap.FoldableFlatMap[Stream]
+      with Traverse[Stream]
+      with Alternative[Stream]
+      with Monad[Stream]
+      with CoflatMap[Stream]
+      with Align[Stream] {
 
       def empty[A]: Stream[A] = Stream.Empty
 

core/src/main/scala/cats/Applicative.scala

@@ -352,7 +352,9 @@ private[cats] class ApplicativeMonoid[F[_], A](f: Applicative[F], monoid: Monoid
   def empty: F[A] = f.pure(monoid.empty)
 }
 
-private[cats] class ArrowApplicative[F[_, _], A](F: Arrow[F]) extends Applicative[F[A, *]] {
+private[cats] class ArrowApplicative[F[_, _], A](F: Arrow[F])
+    extends Apply.AbstractApply[F[A, *]]
+    with Applicative[F[A, *]] {
   def pure[B](b: B): F[A, B] = F.lift[A, B](_ => b)
   override def map[B, C](fb: F[A, B])(f: B => C): F[A, C] = F.rmap(fb)(f)
   def ap[B, C](ff: F[A, B => C])(fb: F[A, B]): F[A, C] =

core/src/main/scala/cats/Apply.scala

@@ -249,6 +249,7 @@ trait Apply[F[_]] extends Functor[F] with InvariantSemigroupal[F] with ApplyArit
 }
 
 object Apply {
+  abstract private[cats] class AbstractApply[F[_]] extends Apply[F]
 
   /**
    * This semigroup uses a product operation to combine `F`s.

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

@@ -54,7 +54,8 @@ private[cats] trait ComposedFunctorBifunctor[F[_], G[_, _]] extends Bifunctor[λ
     F.map(fab)(G.bimap(_)(f, g))
 }
 
-private[cats] trait ComposedApply[F[_], G[_]] extends Apply[λ[α => F[G[α]]]] with ComposedFunctor[F, G] { outer =>
+private[cats] trait ComposedApply[F[_], G[_]] extends Apply.AbstractApply[λ[α => F[G[α]]]] with ComposedFunctor[F, G] {
+  outer =>
   def F: Apply[F]
   def G: Apply[G]
 
@@ -65,7 +66,7 @@ private[cats] trait ComposedApply[F[_], G[_]] extends Apply[λ[α => F[G[α]]]]
     F.map2(fga, fgb)(G.product)
 }
 
-private[cats] trait ComposedApplicative[F[_], G[_]] extends Applicative[λ[α => F[G[α]]]] with ComposedApply[F, G] {
+private[cats] trait ComposedApplicative[F[_], G[_]] extends ComposedApply[F, G] with Applicative[λ[α => F[G[α]]]] {
   outer =>
   def F: Applicative[F]
   def G: Applicative[G]
@@ -87,17 +88,17 @@ private[cats] trait ComposedMonoidK[F[_], G[_]] extends MonoidK[λ[α => F[G[α]
 }
 
 private[cats] trait ComposedNonEmptyAlternative[F[_], G[_]]
-    extends NonEmptyAlternative[λ[α => F[G[α]]]]
-    with ComposedApplicative[F, G]
-    with ComposedSemigroupK[F, G] { outer =>
+    extends ComposedApplicative[F, G]
+    with ComposedSemigroupK[F, G]
+    with NonEmptyAlternative[λ[α => F[G[α]]]] { outer =>
 
   def F: NonEmptyAlternative[F]
 }
 
 private[cats] trait ComposedAlternative[F[_], G[_]]
-    extends Alternative[λ[α => F[G[α]]]]
-    with ComposedNonEmptyAlternative[F, G]
-    with ComposedMonoidK[F, G] { outer =>
+    extends ComposedNonEmptyAlternative[F, G]
+    with ComposedMonoidK[F, G]
+    with Alternative[λ[α => F[G[α]]]] { outer =>
 
   def F: Alternative[F]
 
@@ -106,7 +107,7 @@ private[cats] trait ComposedAlternative[F[_], G[_]]
   override def appendK[A](fa: F[G[A]], a: A): F[G[A]] = F.appendK(fa, G.pure(a))
 }
 
-private[cats] trait ComposedFoldable[F[_], G[_]] extends Foldable[λ[α => F[G[α]]]] { outer =>
+private[cats] trait ComposedFoldable[F[_], G[_]] extends Foldable.AbstractFoldable[λ[α => F[G[α]]]] { outer =>
   def F: Foldable[F]
   def G: Foldable[G]
 
@@ -124,9 +125,9 @@ private[cats] trait ComposedFoldable[F[_], G[_]] extends Foldable[λ[α => F[G[
 }
 
 private[cats] trait ComposedTraverse[F[_], G[_]]
-    extends Traverse[λ[α => F[G[α]]]]
-    with ComposedFoldable[F, G]
-    with ComposedFunctor[F, G] {
+    extends ComposedFoldable[F, G]
+    with ComposedFunctor[F, G]
+    with Traverse[λ[α => F[G[α]]]] {
   def F: Traverse[F]
   def G: Traverse[G]
 
@@ -138,17 +139,17 @@ private[cats] trait ComposedTraverse[F[_], G[_]]
 }
 
 private[cats] trait ComposedNonEmptyTraverse[F[_], G[_]]
-    extends NonEmptyTraverse[λ[α => F[G[α]]]]
+    extends ComposedReducible[F, G]
     with ComposedTraverse[F, G]
-    with ComposedReducible[F, G] {
+    with NonEmptyTraverse[λ[α => F[G[α]]]] {
   def F: NonEmptyTraverse[F]
   def G: NonEmptyTraverse[G]
 
   override def nonEmptyTraverse[H[_]: Apply, A, B](fga: F[G[A]])(f: A => H[B]): H[F[G[B]]] =
     F.nonEmptyTraverse(fga)(ga => G.nonEmptyTraverse(ga)(f))
 }
 
-private[cats] trait ComposedReducible[F[_], G[_]] extends Reducible[λ[α => F[G[α]]]] with ComposedFoldable[F, G] {
+private[cats] trait ComposedReducible[F[_], G[_]] extends ComposedFoldable[F, G] with Reducible[λ[α => F[G[α]]]] {
   outer =>
   def F: Reducible[F]
   def G: Reducible[G]

core/src/main/scala/cats/Eval.scala

@@ -390,7 +390,7 @@ object Eval extends EvalInstances {
 sealed abstract private[cats] class EvalInstances extends EvalInstances0 {
 
   implicit val catsBimonadForEval: Bimonad[Eval] & CommutativeMonad[Eval] =
-    new Bimonad[Eval] with StackSafeMonad[Eval] with CommutativeMonad[Eval] {
+    new FlatMap.AbstractFlatMap[Eval] with Bimonad[Eval] with StackSafeMonad[Eval] with CommutativeMonad[Eval] {
       override def map[A, B](fa: Eval[A])(f: A => B): Eval[B] = fa.map(f)
       def pure[A](a: A): Eval[A] = Now(a)
       def flatMap[A, B](fa: Eval[A])(f: A => Eval[B]): Eval[B] = fa.flatMap(f)
@@ -407,7 +407,7 @@ sealed abstract private[cats] class EvalInstances extends EvalInstances0 {
     }
 
   implicit val catsReducibleForEval: Reducible[Eval] =
-    new Reducible[Eval] {
+    new Foldable.AbstractFoldable[Eval] with Reducible[Eval] {
       def foldLeft[A, B](fa: Eval[A], b: B)(f: (B, A) => B): B =
         f(b, fa.value)
       def foldRight[A, B](fa: Eval[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =

core/src/main/scala/cats/FlatMap.scala

@@ -220,6 +220,8 @@ trait FlatMap[F[_]] extends Apply[F] with FlatMapArityFunctions[F] {
 }
 
 object FlatMap {
+  abstract private[cats] class AbstractFlatMap[F[_]] extends Apply.AbstractApply[F] with FlatMap[F]
+  abstract private[cats] class FoldableFlatMap[F[_]] extends AbstractFlatMap[F] with Foldable[F]
 
   /**
    * Summon an instance of [[FlatMap]] for `F`.

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

@@ -963,6 +963,8 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
 }
 
 object Foldable {
+  abstract private[cats] class AbstractFoldable[F[_]] extends Foldable[F]
+
   private val sentinel: Function1[Any, Any] = new scala.runtime.AbstractFunction1[Any, Any] {
     def apply(a: Any): Any = this
   }

core/src/main/scala/cats/NonEmptyReducible.scala

@@ -34,7 +34,15 @@ import cats.data.NonEmptyList
  * This class is only a helper, does not define a typeclass and should not be used outside of Cats.
  * Also see the discussion: PR #3541 and issue #3069.
  */
-abstract class NonEmptyReducible[F[_], G[_]](implicit G: Foldable[G]) extends Reducible[F] {
+abstract class NonEmptyReducible[F[_], G[_]](implicit foldable: Foldable[G])
+    extends Foldable.AbstractFoldable[F]
+    with NonEmptyReducibleTrait[F, G] {
+  final protected[cats] def G: Foldable[G] = foldable
+}
+
+private[cats] trait NonEmptyReducibleTrait[F[_], G[_]] extends Reducible[F] {
+  implicit protected[cats] def G: Foldable[G]
+
   def split[A](fa: F[A]): (A, G[A])
 
   def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B = {

core/src/main/scala/cats/Parallel.scala

@@ -100,7 +100,7 @@ trait Parallel[M[_]] extends NonEmptyParallel[M] {
    * then you can get `ApplicativeError[F, E]` from `MonadError[M, E]`.
    */
   def applicativeError[E](implicit E: MonadError[M, E]): ApplicativeError[F, E] =
-    new ApplicativeError[F, E] {
+    new Apply.AbstractApply[F] with ApplicativeError[F, E] {
 
       def raiseError[A](e: E): F[A] =
         parallel(MonadError[M, E].raiseError(e))

core/src/main/scala/cats/Representable.scala

@@ -103,7 +103,7 @@ trait Representable[F[_]] extends Serializable { self =>
     }
 }
 
-private trait RepresentableMonad[F[_], R] extends Monad[F] {
+abstract private class RepresentableMonad[F[_], R] extends FlatMap.AbstractFlatMap[F] with Monad[F] {
 
   def R: Representable.Aux[F, R]
 
@@ -125,7 +125,7 @@ private trait RepresentableMonad[F[_], R] extends Monad[F] {
     }
 }
 
-private trait RepresentableBimonad[F[_], R] extends RepresentableMonad[F, R] with Bimonad[F] {
+abstract private class RepresentableBimonad[F[_], R] extends RepresentableMonad[F, R] with Bimonad[F] {
 
   def M: Monoid[R]
 

core/src/main/scala/cats/Semigroupal.scala

@@ -66,7 +66,7 @@ trait Semigroupal[F[_]] extends Serializable {
   def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
 }
 
-object Semigroupal extends ScalaVersionSpecificSemigroupalInstances with SemigroupalArityFunctions {
+object Semigroupal extends SemigroupalArityFunctions with ScalaVersionSpecificSemigroupalInstances {
   implicit def catsSemigroupalForId: Semigroupal[Id] = catsInstancesForId
   implicit def catsSemigroupalForOption: Semigroupal[Option] = cats.instances.option.catsStdInstancesForOption
   implicit def catsSemigroupalForTry: Semigroupal[Try] = cats.instances.try_.catsStdInstancesForTry

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

@@ -27,9 +27,13 @@ abstract private[data] class AbstractNonEmptyInstances[F[_], NonEmptyF[_]](impli
   CF: CoflatMap[F],
   TF: Traverse[F],
   SF: Alternative[F]
-) extends Bimonad[NonEmptyF]
+) extends FlatMap.FoldableFlatMap[NonEmptyF]
+    with NonEmptyReducibleTrait[NonEmptyF, F]
+    with Bimonad[NonEmptyF]
     with NonEmptyTraverse[NonEmptyF]
     with NonEmptyAlternative[NonEmptyF] {
+
+  override def G: Foldable[F] = TF
   val monadInstance = MF.asInstanceOf[Monad[NonEmptyF]]
   val coflatMapInstance = CF.asInstanceOf[CoflatMap[NonEmptyF]]
   val traverseInstance = Traverse[F].asInstanceOf[Traverse[NonEmptyF]]
@@ -63,10 +67,10 @@ abstract private[data] class AbstractNonEmptyInstances[F[_], NonEmptyF[_]](impli
   def tailRecM[A, B](a: A)(f: A => NonEmptyF[Either[A, B]]): NonEmptyF[B] =
     monadInstance.tailRecM(a)(f)
 
-  def foldLeft[A, B](fa: NonEmptyF[A], b: B)(f: (B, A) => B): B =
+  override def foldLeft[A, B](fa: NonEmptyF[A], b: B)(f: (B, A) => B): B =
     traverseInstance.foldLeft(fa, b)(f)
 
-  def foldRight[A, B](fa: NonEmptyF[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
+  override def foldRight[A, B](fa: NonEmptyF[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
     traverseInstance.foldRight(fa, lb)(f)
 
   override def foldMap[A, B](fa: NonEmptyF[A])(f: A => B)(implicit B: Monoid[B]): B =

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

@@ -270,7 +270,7 @@ abstract private[data] class AndThenInstances0 extends AndThenInstances1 {
    * [[cats.Monad]] instance for [[AndThen]].
    */
   implicit def catsDataMonadForAndThen[T]: Monad[AndThen[T, *]] =
-    new Monad[AndThen[T, *]] {
+    new FlatMap.AbstractFlatMap[AndThen[T, *]] with Monad[AndThen[T, *]] {
       // Piggybacking on the instance for Function1
       private[this] val fn1 = instances.all.catsStdMonadForFunction1[T]
 

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

@@ -1397,7 +1397,13 @@ sealed abstract private[data] class ChainInstances extends ChainInstances1 {
 
   implicit val catsDataInstancesForChain
     : Traverse[Chain] & Alternative[Chain] & Monad[Chain] & CoflatMap[Chain] & Align[Chain] =
-    new Traverse[Chain] with Alternative[Chain] with Monad[Chain] with CoflatMap[Chain] with Align[Chain] {
+    new FlatMap.FoldableFlatMap[Chain]
+      with Traverse[Chain]
+      with Alternative[Chain]
+      with Monad[Chain]
+      with CoflatMap[Chain]
+      with Align[Chain] {
+
       def foldLeft[A, B](fa: Chain[A], b: B)(f: (B, A) => B): B =
         fa.foldLeft(b)(f)
       def foldRight[A, B](fa: Chain[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] = {

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

@@ -132,7 +132,9 @@ sealed abstract private[data] class CokleisliInstances1 {
     }
 }
 
-private[data] class CokleisliMonad[F[_], A] extends Monad[Cokleisli[F, A, *]] {
+private[data] class CokleisliMonad[F[_], A]
+    extends FlatMap.AbstractFlatMap[Cokleisli[F, A, *]]
+    with Monad[Cokleisli[F, A, *]] {
 
   def pure[B](x: B): Cokleisli[F, A, B] =
     Cokleisli.pure(x)