Drop StrictMapOps and replace them with caps.Pure bounds

Author: natsukagami

library/src/scala/collection/Iterable.scala

@@ -1045,7 +1045,7 @@ trait MapFactoryDefaults[K, +V,
 trait SortedMapFactoryDefaults[K, +V,
     +CC[x, y] <:  Map[x, y] with SortedMapOps[x, y, CC, CC[x, y]] with UnsortedCC[x, y],
     +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with Iterable[x],
-    +UnsortedCC[x, y] <: Map[x, y]] extends SortedMapOps[K, V, CC, CC[K, V @uncheckedVariance]] with StrictMapOps[K, V, UnsortedCC, CC[K, V @uncheckedVariance]] {
+    +UnsortedCC[x, y] <: Map[x, y]] extends SortedMapOps[K, V, CC, CC[K, V @uncheckedVariance]] with MapOps[K, V, UnsortedCC, CC[K, V @uncheckedVariance]] with caps.Pure {
   self: IterableOps[(K, V), WithFilterCC, _] =>
 
   override def empty: CC[K, V @uncheckedVariance] = sortedMapFactory.empty(using ordering)

library/src/scala/collection/Map.scala

@@ -24,7 +24,7 @@ import scala.util.hashing.MurmurHash3
 /** Base Map type */
 trait Map[K, +V]
   extends Iterable[(K, V)]
-    with StrictMapOps[K, V, Map, Map[K, V]]
+    with MapOps[K, V, Map, Map[K, V]]
     with MapFactoryDefaults[K, V, Map, Iterable]
     with Equals
     with caps.Pure {
@@ -89,14 +89,6 @@ trait Map[K, +V]
   override def toString(): String = super[Iterable].toString() // Because `Function1` overrides `toString` too
 }
 
-/** Map operations for strict maps. */
-transparent trait StrictMapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _] with caps.Pure, +C]
-  extends MapOps[K, V, CC, C] with caps.Pure {
-  // The original keySet implementation, with a lazy iterator over the keys,
-  // is only correct if we have a strict Map.
-  // We restore it here.
-}
-
 /** Base Map implementation type
   *
   * @tparam K Type of keys
@@ -220,12 +212,12 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
 
   /** A generic trait that is reused by keyset implementations.
     * Note that this version of KeySet copies all the keys into an interval val.
-    * See [[StrictMapOps.LazyKeySet]] for a version that lazily captures the map.
+    * See [[MapOps.LazyKeySet]] for a version that lazily captures the map.
     */
   protected trait GenKeySet { this: Set[K] =>
     // CC note: this is unavoidable to make the KeySet pure.
     private[MapOps] val allKeys = MapOps.this.keysIterator.toSet
-    // We restore the lazy behavior in StrictMapOps
+    // We restore the lazy behavior in LazyKeySet
     def iterator: Iterator[K] =
       allKeys.iterator
     def contains(key: K): Boolean = allKeys.contains(key)

library/src/scala/collection/SeqMap.scala

@@ -31,8 +31,9 @@ import scala.annotation.nowarn
   */
 
 trait SeqMap[K, +V] extends Map[K, V]
-  with StrictMapOps[K, V, SeqMap, SeqMap[K, V]]
-  with MapFactoryDefaults[K, V, SeqMap, Iterable] {
+  with MapOps[K, V, SeqMap, SeqMap[K, V]]
+  with MapFactoryDefaults[K, V, SeqMap, Iterable]
+  with caps.Pure {
   @nowarn("""cat=deprecation&origin=scala\.collection\.Iterable\.stringPrefix""")
   override protected[this] def stringPrefix: String = "SeqMap"
 

library/src/scala/collection/SortedMap.scala

@@ -51,8 +51,9 @@ trait SortedMap[K, +V]
 }
 
 transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _] with caps.Pure, +C <: SortedMapOps[K, V, CC, C]]
-  extends StrictMapOps[K, V, Map, C]
-     with SortedOps[K, C] {
+  extends MapOps[K, V, Map, C]
+     with SortedOps[K, C]
+     with caps.Pure {
 
   /** The companion object of this sorted map, providing various factory methods.
     *

library/src/scala/collection/immutable/Map.scala

@@ -64,7 +64,8 @@ trait Map[K, +V]
   */
 transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
   extends IterableOps[(K, V), Iterable, C]
-    with collection.StrictMapOps[K, V, CC, C] {
+    with collection.MapOps[K, V, CC, C]
+    with caps.Pure {
 
   protected def coll: C with CC[K, V]
 

library/src/scala/collection/mutable/Map.scala

@@ -68,11 +68,12 @@ trait Map[K, V]
   */
 transparent trait MapOps[K, V, +CC[X, Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
   extends IterableOps[(K, V), Iterable, C]
-    with collection.StrictMapOps[K, V, CC, C]
+    with collection.MapOps[K, V, CC, C]
     with Cloneable[C]
     with Builder[(K, V), C]
     with Growable[(K, V)]
-    with Shrinkable[K] {
+    with Shrinkable[K]
+    with caps.Pure {
 
   def result(): C = coll