Port tests for Semigroup and Monoid

core/src/main/scala-3/cats/derived/DerivedCommutativeMonoid.scala

@@ -0,0 +1,21 @@
+package cats.derived
+
+import cats.kernel.CommutativeMonoid
+import shapeless3.deriving.K0
+
+import scala.compiletime.*
+
+type DerivedCommutativeMonoid[A] = Derived[CommutativeMonoid[A]]
+object DerivedCommutativeMonoid:
+  type Or[A] = Derived.Or[CommutativeMonoid[A]]
+  inline def apply[A]: CommutativeMonoid[A] =
+    import DerivedCommutativeMonoid.given
+    summonInline[DerivedCommutativeMonoid[A]].instance
+
+  given [A](using inst: K0.ProductInstances[Or, A]): DerivedCommutativeMonoid[A] =
+    given K0.ProductInstances[CommutativeMonoid, A] = inst.unify
+    new Product[CommutativeMonoid, A] {}
+
+  trait Product[F[x] <: CommutativeMonoid[x], A](using inst: K0.ProductInstances[F, A])
+      extends DerivedMonoid.Product[F, A],
+        CommutativeMonoid[A]

core/src/main/scala-3/cats/derived/DerivedCommutativeSemigroup.scala

@@ -0,0 +1,21 @@
+package cats.derived
+
+import cats.kernel.CommutativeSemigroup
+import shapeless3.deriving.K0
+
+import scala.compiletime.*
+
+type DerivedCommutativeSemigroup[A] = Derived[CommutativeSemigroup[A]]
+object DerivedCommutativeSemigroup:
+  type Or[A] = Derived.Or[CommutativeSemigroup[A]]
+  inline def apply[A]: CommutativeSemigroup[A] =
+    import DerivedCommutativeSemigroup.given
+    summonInline[DerivedCommutativeSemigroup[A]].instance
+
+  given [A](using inst: K0.ProductInstances[Or, A]): DerivedCommutativeSemigroup[A] =
+    given K0.ProductInstances[CommutativeSemigroup, A] = inst.unify
+    new Product[CommutativeSemigroup, A] {}
+
+  trait Product[F[x] <: CommutativeSemigroup[x], A](using inst: K0.ProductInstances[F, A])
+      extends DerivedSemigroup.Product[F, A],
+        CommutativeSemigroup[A]

core/src/main/scala-3/cats/derived/DerivedMonoid.scala

@@ -0,0 +1,22 @@
+package cats.derived
+
+import cats.Monoid
+import shapeless3.deriving.K0
+
+import scala.compiletime.*
+
+type DerivedMonoid[A] = Derived[Monoid[A]]
+object DerivedMonoid:
+  type Or[A] = Derived.Or[Monoid[A]]
+  inline def apply[A]: Monoid[A] =
+    import DerivedMonoid.given
+    summonInline[DerivedMonoid[A]].instance
+
+  given [A](using inst: K0.ProductInstances[Or, A]): DerivedMonoid[A] =
+    given K0.ProductInstances[Monoid, A] = inst.unify
+    new Product[Monoid, A] {}
+
+  trait Product[F[x] <: Monoid[x], A](using inst: K0.ProductInstances[F, A])
+      extends DerivedSemigroup.Product[F, A],
+        Monoid[A]:
+    val empty: A = inst.construct([A] => (F: F[A]) => F.empty)

core/src/main/scala-3/cats/derived/DerivedSemigroup.scala

@@ -0,0 +1,20 @@
+package cats.derived
+
+import cats.Semigroup
+import shapeless3.deriving.K0
+
+import scala.compiletime.*
+
+type DerivedSemigroup[A] = Derived[Semigroup[A]]
+object DerivedSemigroup:
+  type Or[A] = Derived.Or[Semigroup[A]]
+  inline def apply[A]: Semigroup[A] =
+    import DerivedSemigroup.given
+    summonInline[DerivedSemigroup[A]].instance
+
+  given [A](using inst: K0.ProductInstances[Or, A]): DerivedSemigroup[A] =
+    given K0.ProductInstances[Semigroup, A] = inst.unify
+    new Product[Semigroup, A] {}
+
+  trait Product[F[x] <: Semigroup[x], A](using inst: K0.ProductInstances[F, A]) extends Semigroup[A]:
+    def combine(x: A, y: A): A = inst.map2(x, y)([A] => (F: F[A], x: A, y: A) => F.combine(x, y))

core/src/main/scala-3/cats/derived/package.scala

@@ -2,29 +2,22 @@ package cats.derived
 
 import alleycats.*
 import cats.*
-import shapeless3.deriving.K0
+import cats.kernel.{CommutativeSemigroup, CommutativeMonoid}
 
 import scala.util.NotGiven
 
 extension (E: Empty.type) inline def derived[A]: Empty[A] = DerivedEmpty[A]
-
-extension (S: Semigroup.type)
-  inline def derived[A](using gen: K0.ProductGeneric[A]): Semigroup[A] =
-    new ProductSemigroup[Semigroup, A] {}
-
-extension (M: Monoid.type)
-  inline def derived[A](using gen: K0.ProductGeneric[A]): Monoid[A] =
-    new ProductMonoid[Monoid, A] {}
-
+extension (S: Semigroup.type) inline def derived[A]: Semigroup[A] = DerivedSemigroup[A]
+extension (M: Monoid.type) inline def derived[A]: Monoid[A] = DerivedMonoid[A]
+extension (S: CommutativeSemigroup.type) inline def derived[A]: CommutativeSemigroup[A] = DerivedCommutativeSemigroup[A]
+extension (S: CommutativeMonoid.type) inline def derived[A]: CommutativeMonoid[A] = DerivedCommutativeMonoid[A]
 extension (F: Foldable.type) inline def derived[F[_]]: Foldable[F] = DerivedFoldable[F]
 extension (F: Functor.type) inline def derived[F[_]]: Functor[F] = DerivedFunctor[F]
 extension (F: Reducible.type) inline def derived[F[_]]: Reducible[F] = DerivedReducible[F]
 extension (F: Traverse.type) inline def derived[F[_]]: Traverse[F] = DerivedTraverse[F]
 
 object semiauto
-    extends CommutativeMonoidDerivation,
-      CommutativeSemigroupDerivation,
-      ContravariantDerivation,
+    extends ContravariantDerivation,
       EmptyKDerivation,
       EqDerivation,
       HashDerivation,
@@ -37,6 +30,10 @@ object semiauto
       Instances:
 
   inline def empty[A]: Empty[A] = DerivedEmpty[A]
+  inline def semigroup[A]: Semigroup[A] = DerivedSemigroup[A]
+  inline def monoid[A]: Monoid[A] = DerivedMonoid[A]
+  inline def commutativeSemigroup[A]: CommutativeSemigroup[A] = DerivedCommutativeSemigroup[A]
+  inline def commutativeMonoid[A]: CommutativeMonoid[A] = DerivedCommutativeMonoid[A]
   inline def foldable[F[_]]: Foldable[F] = DerivedFoldable[F]
   inline def functor[F[_]]: Functor[F] = DerivedFunctor[F]
   inline def reducible[F[_]]: Reducible[F] = DerivedReducible[F]
@@ -46,6 +43,18 @@ object auto:
   object empty:
     inline given [A](using NotGiven[Empty[A]]): Empty[A] = DerivedEmpty[A]
 
+  object semigroup:
+    inline given [A](using NotGiven[Semigroup[A]]): Semigroup[A] = DerivedSemigroup[A]
+
+  object monoid:
+    inline given [A](using NotGiven[Monoid[A]]): Monoid[A] = DerivedMonoid[A]
+
+  object commutativeSemigroup:
+    inline given [A](using NotGiven[CommutativeSemigroup[A]]): CommutativeSemigroup[A] = DerivedCommutativeSemigroup[A]
+
+  object commutativeMonoid:
+    inline given [A](using NotGiven[CommutativeMonoid[A]]): CommutativeMonoid[A] = DerivedCommutativeMonoid[A]
+
   object functor:
     inline given [F[_]](using NotGiven[Functor[F]]): Functor[F] = DerivedFunctor[F]
 

core/src/test/scala-3/cats/derived/CommutativeMonoidSuite.scala

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2016 Miles Sabin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cats.derived
+
+import cats.Eq
+import cats.kernel.{CommutativeMonoid, CommutativeSemigroup}
+import cats.kernel.laws.discipline.{CommutativeMonoidTests, SerializableTests}
+import org.scalacheck.Arbitrary
+
+import scala.compiletime.*
+
+class CommutativeMonoidSuite extends KittensSuite:
+  import CommutativeMonoidSuite.*
+  import TestDefns.*
+
+  inline def commutativeMonoidTests[A]: CommutativeMonoidTests[A] =
+    CommutativeMonoidTests[A](summonInline)
+
+  inline def testCommutativeMonoid(inline context: String): Unit =
+    checkAll(s"$context.CommutativeMonoid[Foo]", commutativeMonoidTests[CommutativeFoo].commutativeMonoid)
+    // FIXME: Doesn't work
+    //checkAll(s"$context.CommutativeMonoid[Recursive]", commutativeMonoidTests[Recursive].commutativeMonoid)
+    checkAll(s"$context.CommutativeMonoid[Box[Mul]]", commutativeMonoidTests[Box[Mul]].commutativeMonoid)
+    checkAll(
+      s"$context.CommutativeMonoid is Serializable",
+      SerializableTests.serializable(summonInline[CommutativeMonoid[CommutativeFoo]])
+    )
+    test(s"$context.CommutativeMonoid respects existing instances") {
+      val box = summonInline[CommutativeMonoid[Box[Mul]]]
+      assert(box.empty == Box(Mul(1)))
+      assert(box.combine(Box(Mul(5)), Box(Mul(5))) == Box(Mul(25)))
+    }
+
+  locally {
+    import auto.commutativeMonoid.given
+    testCommutativeMonoid("auto")
+  }
+
+  locally {
+    import semiInstances.given
+    testCommutativeMonoid("semiauto")
+  }
+
+end CommutativeMonoidSuite
+
+object CommutativeMonoidSuite:
+  import TestDefns.*
+
+  object semiInstances:
+    given CommutativeMonoid[CommutativeFoo] = semiauto.commutativeMonoid
+    given CommutativeMonoid[Recursive] = semiauto.commutativeMonoid
+    given CommutativeMonoid[Box[Mul]] = semiauto.commutativeMonoid
+
+  final case class Mul(value: Int)
+  object Mul:
+    given Eq[Mul] = Eq.fromUniversalEquals
+    given Arbitrary[Mul] = Arbitrary(Arbitrary.arbitrary[Int].map(apply))
+    given CommutativeMonoid[Mul] with
+      val empty = Mul(1)
+      def combine(x: Mul, y: Mul) = Mul(x.value * y.value)
+
+end CommutativeMonoidSuite

core/src/test/scala-3/cats/derived/CommutativeMonoidTests.scala

@@ -1,9 +1,7 @@
 package cats.derived
 
-import alleycats.*
-import cats.*
 import cats.kernel.CommutativeMonoid
-import cats.derived.semiauto.*
+import cats.derived.*
 
 class CommutativeMonoidTests { //
   case class Foo(i: Int, b: Option[Int]) derives CommutativeMonoid

core/src/test/scala-3/cats/derived/CommutativeSemigroupSuite.scala

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2015 Miles Sabin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cats.derived
+
+import cats.Eq
+import cats.kernel.CommutativeSemigroup
+import cats.kernel.laws.discipline.{CommutativeSemigroupTests, SerializableTests}
+import org.scalacheck.Arbitrary
+
+import scala.compiletime.*
+
+class CommutativeSemigroupSuite extends KittensSuite:
+  import CommutativeSemigroupSuite.*
+  import TestDefns.*
+
+  inline def commutativeSemigroupTests[A]: CommutativeSemigroupTests[A] =
+    CommutativeSemigroupTests[A](summonInline)
+
+  inline def testCommutativeSemigroup(inline context: String): Unit =
+    checkAll(
+      s"$context.CommutativeSemigroup[CommutativeFoo]",
+      commutativeSemigroupTests[CommutativeFoo].commutativeSemigroup
+    )
+    // FIXME: Doesn't work
+    //checkAll(s"$context.CommutativeSemigroup[Recursive]", commutativeSemigroupTests[Recursive].commutativeSemigroup)
+    checkAll(s"$context.CommutativeSemigroup[Box[Mul]]", commutativeSemigroupTests[Box[Mul]].commutativeSemigroup)
+    checkAll(
+      s"$context.CommutativeSemigroup is Serializable",
+      SerializableTests.serializable(summonInline[CommutativeSemigroup[CommutativeFoo]])
+    )
+    test(s"$context.CommutativeSemigroup respects existing instances") {
+      val box = summonInline[CommutativeSemigroup[Box[Mul]]]
+      assert(box.combine(Box(Mul(5)), Box(Mul(5))).content.value == 25)
+    }
+
+  locally {
+    import auto.commutativeSemigroup.given
+    testCommutativeSemigroup("auto")
+  }
+
+  locally {
+    import semiInstances.given
+    testCommutativeSemigroup("semiauto")
+  }
+
+end CommutativeSemigroupSuite
+
+object CommutativeSemigroupSuite:
+  import TestDefns.*
+
+  object semiInstances:
+    given CommutativeSemigroup[CommutativeFoo] = semiauto.commutativeSemigroup
+    given CommutativeSemigroup[Recursive] = semiauto.commutativeSemigroup
+    given CommutativeSemigroup[Box[Mul]] = semiauto.commutativeSemigroup
+
+  final case class Mul(value: Int)
+  object Mul:
+    given Eq[Mul] = Eq.fromUniversalEquals
+    given Arbitrary[Mul] = Arbitrary(Arbitrary.arbitrary[Int].map(apply))
+    given CommutativeSemigroup[Mul] = (x, y) => Mul(x.value * y.value)
+
+end CommutativeSemigroupSuite

core/src/test/scala-3/cats/derived/CommutativeSemigroupTests.scala

@@ -1,9 +1,7 @@
 package cats.derived
 
-import alleycats.*
-import cats.*
 import cats.kernel.CommutativeSemigroup
-import cats.derived.semiauto.*
+import cats.derived.*
 
 class CommutativeSemigroupTests { //
   case class Foo(i: Int, b: Option[Int]) derives CommutativeSemigroup