add apply method for Mapref

std/shared/src/main/scala/cats/effect/std/MapRef.scala

@@ -45,6 +45,22 @@ trait MapRef[F[_], K, V] extends Function1[K, Ref[F, V]] {
 
 object MapRef extends MapRefCompanionPlatform {
 
+  /**
+   * the default Constructor for MapRef.
+   * If Async is available, it will use a ConcurrentHashMap, otherwise it will use a sharded immutable map.
+   */
+  def apply[F[_]: Concurrent, K, V](): F[MapRef[F, K, Option[V]]] = {
+
+    Concurrent[F] match {
+      case a: Async[_] =>
+        implicit val async: Async[F] = a
+        ofConcurrentHashMap()
+      case _ =>
+        ofShardedImmutableMap[F, K, V](Runtime.getRuntime.availableProcessors())
+    }
+
+  }
+
   /**
    * Creates a sharded map ref to reduce atomic contention on the Map, given an efficient and
    * equally distributed hash, the contention should allow for interaction like a general

tests/shared/src/test/scala/cats/effect/std/MapRefSpec.scala

@@ -16,18 +16,27 @@
 
 package cats.effect.std
 
-import cats._
+import cats.*
 import cats.data.State
-import cats.effect._
-import cats.implicits._
+import cats.effect.*
+import cats.effect.unsafe.implicits.global
+import cats.implicits.*
 
-import scala.concurrent.duration._
+import java.util.concurrent.ConcurrentHashMap
+import scala.concurrent.duration.*
 
 class MapRefSpec extends BaseSpec {
   private val smallDelay: IO[Unit] = IO.sleep(20.millis)
   private def awaitEqual[A: Eq](t: IO[A], success: A): IO[Unit] =
     t.flatMap(a => if (Eq[A].eqv(a, success)) IO.unit else smallDelay *> awaitEqual(t, success))
 
+  "MapRef[Async]()" should {
+    "be instance of ConcurrentHashMap" in real {
+        val mapRef =  MapRef[IO,Int, Int]().unsafeRunSync()
+      mapRef.isInstanceOf[ConcurrentHashMap[ Int, Int]] must_=== true
+
+    }
+  }
   "MapRef.ofSingleImmutableMapRef" should {
 
     "concurrent modifications" in real {