Merge pull request #4735 from danicheg/empty-map-instance

Add the `Empty[Map[A, B]]` instance in alleycats

Author: danicheg

alleycats-core/src/main/scala/alleycats/Empty.scala

@@ -24,6 +24,8 @@ package alleycats
 import cats.{Eq, Monoid}
 import cats.syntax.eq.*
 
+import scala.collection.immutable.SortedMap
+
 trait Empty[A] extends Serializable {
   def empty: A
 
@@ -78,8 +80,15 @@ object Empty extends EmptyInstances0 {
 }
 
 private[alleycats] trait EmptyInstances0 extends compat.IterableEmptyInstance with EmptyInstances1 {
+
   private[this] val emptyOptionSingleton: Empty[Option[Nothing]] = Empty(None)
   implicit def alleycatsEmptyForOption[A]: Empty[Option[A]] = emptyOptionSingleton.asInstanceOf[Empty[Option[A]]]
+
+  private[this] val emptyMapSingleton: Empty[Map[Nothing, Nothing]] = Empty(Map.empty)
+  implicit def alleycatsEmptyForMap[A, B]: Empty[Map[A, B]] = emptyMapSingleton.asInstanceOf[Empty[Map[A, B]]]
+
+  implicit def alleycatsEmptyForSortedMap[A: Ordering, B]: Empty[SortedMap[A, B]] =
+    Empty(SortedMap.empty[A, B])
 }
 
 private[alleycats] trait EmptyInstances1 extends EmptyInstances2 {

alleycats-core/src/test/scala/alleycats/SyntaxSuite.scala

@@ -24,6 +24,8 @@ package alleycats
 import cats.{Eq, Foldable}
 import alleycats.syntax.all.{catsSyntaxExtract, EmptyOps, ExtraFoldableOps}
 
+import scala.collection.immutable.SortedMap
+
 /**
  * Test that our syntax implicits are working.
  *
@@ -47,33 +49,45 @@ object SyntaxSuite {
   // pretend we have a value of type A
   def mock[A]: A = ???
 
-  def testEmpty[A: Empty]: Unit = {
+  def testEmpty[A: Empty](): Unit = {
     val x = mock[A]
     implicit val y: Eq[A] = mock[Eq[A]]
-    val a0: Boolean = x.isEmpty
-    val a1: Boolean = x.nonEmpty
+    val _ = x.isEmpty | x.nonEmpty
   }
 
-  def testOptionEmpty: Unit = {
+  def testOptionEmpty(): Unit = {
     case class A[T](x: T)
     case class B()
 
-    import alleycats.std.option.*
     implicit def emptyA[T: Empty]: Empty[A[T]] = new Empty[A[T]] {
       def empty: A[T] = A(Empty[T].empty)
     }
 
-    Empty[A[Option[B]]].empty
+    val _ = Empty[A[Option[B]]].empty
+  }
+
+  def testMapEmpty(): Any = {
+    case class Foo[A](foo: A)
+
+    val _ = Empty[Map[Foo[Int], Foo[String]]].empty
+  }
+
+  def testSortedMapEmpty(): Any = {
+    case class Foo[A](foo: A)
+
+    implicit def fooOrd[A: Ordering]: Ordering[Foo[A]] = Ordering.by(_.foo)
+
+    val _ = Empty[SortedMap[Foo[Int], Foo[String]]].empty
   }
 
-  def testFoldable[F[_]: Foldable, A]: Unit = {
+  def testFoldable[F[_]: Foldable, A](): Unit = {
     val x = mock[F[A]]
     val y = mock[A => Unit]
-    x.foreach(y)
+    val _ = x.foreach(y)
   }
 
-  def testExtract[F[_]: Extract, A]: Unit = {
+  def testExtract[F[_]: Extract, A](): Unit = {
     val x = mock[F[A]]
-    val y = x.extract
+    val _ = x.extract
   }
 }