Use helper constructor for (Commutative)Monoid instances

joroKr21 · joroKr21 · commit 28f34874823f · 2022-08-11T14:38:15.000+03:00
diff --git a/algebra-core/src/main/scala/algebra/ring/Multiplicative.scala b/algebra-core/src/main/scala/algebra/ring/Multiplicative.scala
@@ -61,10 +61,8 @@ trait MultiplicativeCommutativeSemigroup[@sp(Int, Long, Float, Double) A] extend
 }
 
 trait MultiplicativeMonoid[@sp(Int, Long, Float, Double) A] extends Any with MultiplicativeSemigroup[A] {
-  override def multiplicative: Monoid[A] = new Monoid[A] {
-    def empty = one
-    def combine(x: A, y: A): A = times(x, y)
-  }
+  override def multiplicative: Monoid[A] =
+    Monoid.instance(one, times)
 
   def one: A
 
@@ -94,10 +92,8 @@ trait MultiplicativeCommutativeMonoid[@sp(Int, Long, Float, Double) A]
     extends Any
     with MultiplicativeMonoid[A]
     with MultiplicativeCommutativeSemigroup[A] {
-  override def multiplicative: CommutativeMonoid[A] = new CommutativeMonoid[A] {
-    def empty = one
-    def combine(x: A, y: A): A = times(x, y)
-  }
+  override def multiplicative: CommutativeMonoid[A] =
+    CommutativeMonoid.instance(one, times)
 }
 
 trait MultiplicativeGroup[@sp(Int, Long, Float, Double) A] extends Any with MultiplicativeMonoid[A] {
diff --git a/algebra-core/src/test/scala/algebra/Instances.scala b/algebra-core/src/test/scala/algebra/Instances.scala
diff --git a/core/src/main/scala/cats/CommutativeApplicative.scala b/core/src/main/scala/cats/CommutativeApplicative.scala
@@ -35,16 +35,11 @@ import cats.kernel.CommutativeMonoid
 trait CommutativeApplicative[F[_]] extends Applicative[F] with CommutativeApply[F]
 
 object CommutativeApplicative {
-  def commutativeMonoidFor[F[_]: CommutativeApplicative, A: CommutativeMonoid]: CommutativeMonoid[F[A]] =
-    new CommutativeMonoid[F[A]] {
-      override def empty: F[A] =
-        CommutativeApplicative[F]
-          .pure(CommutativeMonoid[A].empty)
-
-      override def combine(x: F[A], y: F[A]): F[A] =
-        CommutativeApplicative[F]
-          .map2(x, y)(CommutativeMonoid[A].combine)
-    }
+  def commutativeMonoidFor[F[_]: CommutativeApplicative, A: CommutativeMonoid]: CommutativeMonoid[F[A]] = {
+    val F = CommutativeApplicative[F]
+    val A = CommutativeMonoid[A]
+    CommutativeMonoid.instance(F.pure(A.empty), F.map2(_, _)(A.combine))
+  }
 
   /**
    * Summon an instance of [[CommutativeApplicative]] for `F`.
diff --git a/core/src/main/scala/cats/MonoidK.scala b/core/src/main/scala/cats/MonoidK.scala
@@ -73,7 +73,7 @@ trait MonoidK[F[_]] extends SemigroupK[F] { self =>
     ev.eqv(a, empty)
 
   /**
-   * Given a type A, create a concrete Monoid[F[A]].
+   * Given a type A, create a concrete `Monoid[F[A]]`.
    *
    * Example:
    * {{{
@@ -83,10 +83,7 @@ trait MonoidK[F[_]] extends SemigroupK[F] { self =>
    * }}}
    */
   override def algebra[A]: Monoid[F[A]] =
-    new Monoid[F[A]] {
-      def empty: F[A] = self.empty
-      def combine(x: F[A], y: F[A]): F[A] = self.combineK(x, y)
-    }
+    Monoid.instance(empty, combineK)
 
   /**
    * Given a kind G, create an "composed" MonoidK[F[G[_]]
diff --git a/core/src/main/scala/cats/UnorderedFoldable.scala b/core/src/main/scala/cats/UnorderedFoldable.scala
@@ -102,25 +102,25 @@ object UnorderedFoldable
     extends ScalaVersionSpecificTraverseInstances
     with cats.instances.NTupleUnorderedFoldableInstances {
 
-  private val orEvalMonoid: CommutativeMonoid[Eval[Boolean]] = new CommutativeMonoid[Eval[Boolean]] {
-    val empty: Eval[Boolean] = Eval.False
-
-    def combine(lx: Eval[Boolean], ly: Eval[Boolean]): Eval[Boolean] =
-      lx.flatMap {
-        case true  => Eval.True
-        case false => ly
-      }
-  }
-
-  private val andEvalMonoid: CommutativeMonoid[Eval[Boolean]] = new CommutativeMonoid[Eval[Boolean]] {
-    val empty: Eval[Boolean] = Eval.True
-
-    def combine(lx: Eval[Boolean], ly: Eval[Boolean]): Eval[Boolean] =
-      lx.flatMap {
-        case true  => ly
-        case false => Eval.False
-      }
-  }
+  private val orEvalMonoid: CommutativeMonoid[Eval[Boolean]] =
+    CommutativeMonoid.instance(
+      Eval.False,
+      (lx, ly) =>
+        lx.flatMap {
+          case true  => Eval.True
+          case false => ly
+        }
+    )
+
+  private val andEvalMonoid: CommutativeMonoid[Eval[Boolean]] =
+    CommutativeMonoid.instance(
+      Eval.True,
+      (lx, ly) =>
+        lx.flatMap {
+          case true  => ly
+          case false => Eval.False
+        }
+    )
 
   implicit def catsNonEmptyTraverseForId: NonEmptyTraverse[Id] = catsInstancesForId
   implicit def catsTraverseForOption: Traverse[Option] = cats.instances.option.catsStdInstancesForOption
diff --git a/core/src/main/scala/cats/arrow/Category.scala b/core/src/main/scala/cats/arrow/Category.scala
@@ -36,10 +36,7 @@ trait Category[F[_, _]] extends Compose[F] { self =>
     }
 
   override def algebra[A]: Monoid[F[A, A]] =
-    new Monoid[F[A, A]] {
-      def empty: F[A, A] = id
-      def combine(f1: F[A, A], f2: F[A, A]): F[A, A] = self.compose(f1, f2)
-    }
+    Monoid.instance(id, compose)
 }
 
 object Category {
diff --git a/core/src/main/scala/cats/data/Chain.scala b/core/src/main/scala/cats/data/Chain.scala
@@ -1198,10 +1198,7 @@ object Chain extends ChainInstances with ChainCompanionCompat {
 
 sealed abstract private[data] class ChainInstances extends ChainInstances1 {
   implicit def catsDataMonoidForChain[A]: Monoid[Chain[A]] =
-    new Monoid[Chain[A]] {
-      def empty: Chain[A] = Chain.nil
-      def combine(c: Chain[A], c2: Chain[A]): Chain[A] = Chain.concat(c, c2)
-    }
+    Monoid.instance(Chain.nil, Chain.concat)
 
   implicit val catsDataInstancesForChain
     : Traverse[Chain] with Alternative[Chain] with Monad[Chain] with CoflatMap[Chain] with Align[Chain] =
diff --git a/core/src/main/scala/cats/data/Const.scala b/core/src/main/scala/cats/data/Const.scala
@@ -145,13 +145,7 @@ sealed abstract private[data] class ConstInstances extends ConstInstances0 {
     }
 
   implicit def catsDataMonoidForConst[A: Monoid, B]: Monoid[Const[A, B]] =
-    new Monoid[Const[A, B]] {
-      def empty: Const[A, B] =
-        Const.empty
-
-      def combine(x: Const[A, B], y: Const[A, B]): Const[A, B] =
-        x.combine(y)
-    }
+    Monoid.instance(Const.empty, _ combine _)
 
   implicit val catsDataBifoldableForConst: Bifoldable[Const] =
     new Bifoldable[Const] {
diff --git a/core/src/main/scala/cats/data/Validated.scala b/core/src/main/scala/cats/data/Validated.scala
@@ -915,10 +915,7 @@ sealed abstract private[data] class ValidatedInstances extends ValidatedInstance
     }
 
   implicit def catsDataMonoidForValidated[A, B](implicit A: Semigroup[A], B: Monoid[B]): Monoid[Validated[A, B]] =
-    new Monoid[Validated[A, B]] {
-      def empty: Validated[A, B] = Valid(B.empty)
-      def combine(x: Validated[A, B], y: Validated[A, B]): Validated[A, B] = x.combine(y)
-    }
+    Monoid.instance(Valid(B.empty), _ combine _)
 
   implicit def catsDataOrderForValidated[A: Order, B: Order]: Order[Validated[A, B]] =
     new Order[Validated[A, B]] {
diff --git a/core/src/main/scala/cats/instances/invariant.scala b/core/src/main/scala/cats/instances/invariant.scala
@@ -30,17 +30,10 @@ trait InvariantMonoidalInstances {
   implicit def catsSemigroupalForMonoid: InvariantSemigroupal[Monoid] =
     new InvariantSemigroupal[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)
-        }
+        Monoid.instance((fa.empty, fb.empty), (x, y) => 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] {
-          def empty: B = f(fa.empty)
-
-          def combine(x: B, y: B): B = f(fa.combine(g(x), g(y)))
-        }
+        Monoid.instance(f(fa.empty), (x, y) => f(fa.combine(g(x), g(y))))
     }
 
   implicit val catsInvariantMonoidalSemigroup: InvariantMonoidal[Semigroup] = new InvariantMonoidal[Semigroup] {
diff --git a/docs/typeclasses/monoid.md b/docs/typeclasses/monoid.md
@@ -24,10 +24,8 @@ Many types that form a `Semigroup` also form a `Monoid`, such as `Int`s (with `0
 ```scala mdoc:reset:silent
 import cats.Monoid
 
-implicit val intAdditionMonoid: Monoid[Int] = new Monoid[Int] {
-  def empty: Int = 0
-  def combine(x: Int, y: Int): Int = x + y
-}
+implicit val intAdditionMonoid: Monoid[Int] =
+  Monoid.instance(0, _ + _)
 
 val x = 1
 ```
@@ -93,18 +91,18 @@ lift into `Option` to get a `Monoid`.
 ```scala mdoc:silent
 import cats.implicits._
 
-implicit def optionMonoid[A: Semigroup]: Monoid[Option[A]] = new Monoid[Option[A]] {
-  def empty: Option[A] = None
-
-  def combine(x: Option[A], y: Option[A]): Option[A] =
-    x match {
+implicit def optionMonoid[A: Semigroup]: Monoid[Option[A]] =
+  Monoid.instance(
+    None,
+    (x, y) => x match {
       case None => y
       case Some(xv) =>
         y match {
           case None => x
           case Some(yv) => Some(xv |+| yv)
         }
     }
+  )
 }
 ```
 
diff --git a/kernel/src/main/scala/cats/kernel/CommutativeMonoid.scala b/kernel/src/main/scala/cats/kernel/CommutativeMonoid.scala
@@ -43,10 +43,9 @@ object CommutativeMonoid extends MonoidFunctions[CommutativeMonoid] {
   /**
    * Create a `CommutativeMonoid` instance from the given function and empty value.
    */
-  @inline def instance[A](emptyValue: A, cmb: (A, A) => A): CommutativeMonoid[A] =
+  @inline def instance[@sp(Int, Long, Float, Double) A](emptyValue: A, cmb: (A, A) => A): CommutativeMonoid[A] =
     new CommutativeMonoid[A] {
       override val empty: A = emptyValue
-
       override def combine(x: A, y: A): A = cmb(x, y)
     }
 }
diff --git a/kernel/src/main/scala/cats/kernel/Monoid.scala b/kernel/src/main/scala/cats/kernel/Monoid.scala
@@ -137,10 +137,9 @@ object Monoid extends MonoidFunctions[Monoid] {
   /**
    * Create a `Monoid` instance from the given function and empty value.
    */
-  @inline def instance[A](emptyValue: A, cmb: (A, A) => A): Monoid[A] =
+  @inline def instance[@sp(Int, Long, Float, Double) A](emptyValue: A, cmb: (A, A) => A): Monoid[A] =
     new Monoid[A] {
       override val empty: A = emptyValue
-
       override def combine(x: A, y: A): A = cmb(x, y)
     }
 }
diff --git a/kernel/src/main/scala/cats/kernel/instances/EitherInstances.scala b/kernel/src/main/scala/cats/kernel/instances/EitherInstances.scala
@@ -41,10 +41,9 @@ trait EitherInstances extends EitherInstances0 {
     }
 
   implicit def catsDataMonoidForEither[A, B](implicit B: Monoid[B]): Monoid[Either[A, B]] =
-    new Monoid[Either[A, B]] {
-      def empty: Either[A, B] =
-        Right(B.empty)
-      def combine(x: Either[A, B], y: Either[A, B]): Either[A, B] =
+    Monoid.instance(
+      Right(B.empty),
+      (x, y) =>
         x match {
           case left @ Left(_) => left
           case Right(xx) =>
@@ -53,7 +52,7 @@ trait EitherInstances extends EitherInstances0 {
               case Right(yy)      => Right(B.combine(xx, yy))
             }
         }
-    }
+    )
 }
 
 private[instances] trait EitherInstances0 extends EitherInstances1 {
diff --git a/laws/src/main/scala/cats/laws/TraverseLaws.scala b/laws/src/main/scala/cats/laws/TraverseLaws.scala
@@ -87,10 +87,8 @@ trait TraverseLaws[F[_]] extends FunctorLaws[F] with FoldableLaws[F] with Unorde
   def traverseOrderConsistent[A](fa: F[A]): IsEq[Option[A]] = {
     class FirstOption[T](val o: Option[T])
 
-    implicit val firstOptionMonoid: Monoid[FirstOption[A]] = new Monoid[FirstOption[A]] {
-      def empty = new FirstOption(None)
-      def combine(x: FirstOption[A], y: FirstOption[A]) = new FirstOption(x.o.orElse(y.o))
-    }
+    implicit val firstOptionMonoid: Monoid[FirstOption[A]] =
+      Monoid.instance(new FirstOption(None), (x, y) => new FirstOption(x.o.orElse(y.o)))
 
     def liftId[T](a: T): Id[T] = a
     def store[T](a: T): Const[FirstOption[T], T] = Const(new FirstOption(Some(a)))
diff --git a/laws/src/main/scala/cats/laws/discipline/MiniInt.scala b/laws/src/main/scala/cats/laws/discipline/MiniInt.scala
@@ -88,10 +88,8 @@ object MiniInt {
     def inverse(x: MiniInt): MiniInt = -x
   }
 
-  val miniIntMultiplication: CommutativeMonoid[MiniInt] = new CommutativeMonoid[MiniInt] {
-    val empty = MiniInt.one
-    def combine(x: MiniInt, y: MiniInt): MiniInt = x * y
-  }
+  val miniIntMultiplication: CommutativeMonoid[MiniInt] =
+    CommutativeMonoid.instance(MiniInt.one, _ * _)
 
   val miniIntOr: BoundedSemilattice[MiniInt] = new BoundedSemilattice[MiniInt] {
     val empty = MiniInt.zero
diff --git a/tests/shared/src/test/scala/cats/tests/AlgebraInvariantSuite.scala b/tests/shared/src/test/scala/cats/tests/AlgebraInvariantSuite.scala
diff --git a/tests/shared/src/test/scala/cats/tests/RepresentableSuite.scala b/tests/shared/src/test/scala/cats/tests/RepresentableSuite.scala

Original file line number	Diff line number	Diff line change
`@@ -36,10 +36,7 @@ trait Category[F[_, _]] extends Compose[F] { self =>`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`override def algebra[A]: Monoid[F[A, A]] =`
`39`		`- new Monoid[F[A, A]] {`
`40`		`- def empty: F[A, A] = id`
`41`		`- def combine(f1: F[A, A], f2: F[A, A]): F[A, A] = self.compose(f1, f2)`
`42`		`- }`
	`39`	`+ Monoid.instance(id, compose)`
`43`	`40`	`}`
`44`	`41`
`45`	`42`	`object Category {`