move Map instance for Each and FilterIndex from unsafe module to core

core/shared/src/main/scala/monocle/function/Each.scala

@@ -59,6 +59,16 @@ object Each extends EachFunctions {
 
   implicit def lazyListEach[A]: Each[LazyList[A], A] = fromTraverse
 
+  implicit def defaultMapEach[K, V]: Each[Map[K, V], V] =
+    Each(
+      new Traversal[Map[K, V], V] {
+        def modifyF[F[_]: Applicative](f: V => F[V])(s: Map[K, V]): F[Map[K, V]] =
+          s.foldLeft(Applicative[F].pure(Map.empty[K, V])) { case (acc, (k, v)) =>
+            Applicative[F].map2(f(v), acc)((head, tail) => tail + (k -> head))
+          }
+      }
+    )
+
   implicit def listMapEach[K, V]: Each[ListMap[K, V], V] =
     Each(
       new Traversal[ListMap[K, V], V] {

core/shared/src/main/scala/monocle/function/FilterIndex.scala

@@ -59,6 +59,22 @@ object FilterIndex extends FilterIndexFunctions {
   implicit def lazyListFilterIndex[A]: FilterIndex[LazyList[A], Int, A] =
     fromTraverse(_.zipWithIndex)
 
+  implicit def mapFilterIndex[K, V]: FilterIndex[Map[K, V], K, V] =
+    new FilterIndex[Map[K, V], K, V] {
+      import cats.syntax.applicative._
+      import cats.syntax.functor._
+
+      def filterIndex(predicate: K => Boolean) =
+        new Traversal[Map[K, V], V] {
+          def modifyF[F[_]: Applicative](f: V => F[V])(s: Map[K, V]): F[Map[K, V]] =
+            s.toList
+              .traverse { case (k, v) =>
+                (if (predicate(k)) f(v) else v.pure[F]).tupleLeft(k)
+              }
+              .map(_.toMap)
+        }
+    }
+
   implicit def sortedMapFilterIndex[K, V](implicit ok: Order[K]): FilterIndex[SortedMap[K, V], K, V] =
     new FilterIndex[SortedMap[K, V], K, V] {
       import cats.syntax.applicative._

docs/src/main/mdoc/modules.md

@@ -9,10 +9,10 @@ In an attempt to be modular, Monocle is broken up into several modules:
   type class instances for standard library types and cats data types
 * *macro* - macros to simplify the generation of optics
 * *laws* - laws for the optics and type classes
+* *refined* - optics and type class instances using refinement types from [refined](https://github.com/fthomas/refined)
 * *generic* (deprecated) - optics and type class instances for `HList` and `Coproduct` from [shapeless](https://github.com/milessabin/shapeless)
 * *state* (deprecated) - conversion between optics and `State` or `Reader`
-* *refined* - optics and type class instances using refinement types from [refined](https://github.com/fthomas/refined)
-* *unsafe* - optics that do not fully satisfy laws but that are very convenient. More details [here](unsafe_module.html)
+* *unsafe* (deprecated) - optics that do not fully satisfy laws but that are very convenient. More details [here](unsafe_module.html)
 * *tests* - tests that check optics and type class instances satisfy laws
 * *bench* - benchmarks using jmh to measure optics performances
 * *docs* - source for this website

example/src/test/scala/monocle/HttpRequestExample.scala

@@ -1,7 +1,6 @@
 package monocle
 
 import monocle.macros.{GenIso, GenLens, GenPrism}
-import monocle.unsafe.MapTraversal._
 
 /** Show how could we use Monocle to handle custom case classes, objects
   */

example/src/test/scala/monocle/JsonExample.scala

@@ -2,7 +2,6 @@ package monocle
 
 import alleycats.std.all._
 import monocle.function.Plated
-import monocle.unsafe.MapTraversal._
 
 /** Show how could we use Optics to manipulate some Json AST
   */

test/shared/src/test/scala/monocle/function/EachSpec.scala

@@ -3,14 +3,11 @@ package monocle.function
 import cats.kernel.Eq
 import monocle.MonocleSuite
 import monocle.law.discipline.function.EachTests
-import scala.collection.immutable.ListMap
 
 class EachSpec extends MonocleSuite {
-  implicit val eqListMap: Eq[ListMap[String, String]] = Eq.fromUniversalEquals
+  implicit val eqListMap: Eq[Map[String, String]] = Eq.fromUniversalEquals
 
   implicit val slistEach: Each[CList, Char] = Each.fromIso(CList.toList)
 
   checkAll("fromIso", EachTests[CList, Char])
-
-  checkAll("ListMap", EachTests[ListMap[String, String], String])
 }

test/shared/src/test/scala/monocle/function/FilterIndexSpec.scala

@@ -1,12 +1,11 @@
 package monocle.function
 
-import cats.Order
 import monocle.MonocleSuite
 import monocle.law.discipline.function.FilterIndexTests
 
 class FilterIndexSpec extends MonocleSuite {
-  implicit def mmapFilterIndex[K: Order, V]: FilterIndex[MSorteMap[K, V], K, V] =
-    FilterIndex.fromIso(MSorteMap.toSortedMap)
+  implicit def mmapFilterIndex[K, V]: FilterIndex[MMap[K, V], K, V] =
+    FilterIndex.fromIso(MMap.toMap)
 
-  checkAll("fromIso", FilterIndexTests[MSorteMap[Int, String], Int, String])
+  checkAll("fromIso", FilterIndexTests[MMap[Int, String], Int, String])
 }

test/shared/src/test/scala/monocle/std/ListMapSpec.scala

@@ -0,0 +1,13 @@
+package monocle.std
+
+import cats.kernel.Eq
+import monocle.MonocleSuite
+import monocle.law.discipline.function._
+
+import scala.collection.immutable.ListMap
+
+class ListMapSpec extends MonocleSuite {
+  implicit val eqListMap: Eq[ListMap[Int, String]] = Eq.fromUniversalEquals
+
+  checkAll("each Map", EachTests[ListMap[Int, String], String])
+}

test/shared/src/test/scala/monocle/std/MapSpec.scala

@@ -4,6 +4,7 @@ import monocle.MonocleSuite
 import monocle.law.discipline.function._
 
 import scala.annotation.nowarn
+import scala.collection.immutable.Map
 
 class MapSpec extends MonocleSuite {
   checkAll("at Map", AtTests[Map[Int, String], Int, Option[String]])

unsafe/src/main/scala/monocle/unsafe/MapTraversal.scala

@@ -12,6 +12,7 @@ import monocle.function.{Each, FilterIndex}
 
 import scala.collection.immutable.Map
 
+@deprecated("use optic.filter(predicate)", since = "3.0.0-M1")
 object MapTraversal {
   implicit def mapEach[K, V]: Each[Map[K, V], V] = fromTraverse[Map[K, *], V]