Drop StrictMapFactory in favor of caps.Pure constraints

Author: natsukagami

library/src/scala/collection/Factory.scala

@@ -412,14 +412,6 @@ trait MapFactory[+CC[_, _]] extends Serializable { self =>
   implicit def mapFactory[K, V]: Factory[(K, V), CC[K, V]] = MapFactory.toFactory(this)
 }
 
-/** Like MapFactory, but with a strict constructor. */
-trait StrictMapFactory[+CC[_, _] <: caps.Pure] extends MapFactory[CC] {
-  /**
-   * A collection of type Map generated from given iterable object.
-   */
-  def from[K, V](it: IterableOnce[(K, V)]^): CC[K, V]
-}
-
 object MapFactory {
 
   /**
@@ -446,7 +438,7 @@ object MapFactory {
     }
 
   @SerialVersionUID(3L)
-  class Delegate[C[_, _] <: caps.Pure](delegate: StrictMapFactory[C]) extends StrictMapFactory[C] {
+  class Delegate[C[_, _] <: caps.Pure](delegate: MapFactory[C]) extends MapFactory[C] {
     override def apply[K, V](elems: (K, V)*): C[K, V] = delegate.apply(elems: _*)
     def from[K, V](it: IterableOnce[(K, V)]^): C[K, V] = delegate.from(it)
     def empty[K, V]: C[K, V] = delegate.empty

library/src/scala/collection/Map.scala

@@ -30,7 +30,7 @@ trait Map[K, +V]
     with Equals
     with caps.Pure {
 
-  def mapFactory: scala.collection.StrictMapFactory[Map] = Map
+  def mapFactory: scala.collection.MapFactory[Map] = Map
 
   def canEqual(that: Any): Boolean = true
 

library/src/scala/collection/SeqMap.scala

@@ -36,7 +36,7 @@ trait SeqMap[K, +V] extends Map[K, V]
   @nowarn("""cat=deprecation&origin=scala\.collection\.Iterable\.stringPrefix""")
   override protected[this] def stringPrefix: String = "SeqMap"
 
-  override def mapFactory: StrictMapFactory[SeqMap] = SeqMap
+  override def mapFactory: MapFactory[SeqMap] = SeqMap
 }
 
 object SeqMap extends MapFactory.Delegate[immutable.SeqMap](immutable.SeqMap)

library/src/scala/collection/concurrent/TrieMap.scala

@@ -713,7 +713,7 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater
 
   def this() = this(Hashing.default, Equiv.universal)
 
-  override def mapFactory: StrictMapFactory[TrieMap] = TrieMap
+  override def mapFactory: MapFactory[TrieMap] = TrieMap
 
   /* internal methods */
 
@@ -1040,7 +1040,7 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater
 
 
 @SerialVersionUID(3L)
-object TrieMap extends StrictMapFactory[TrieMap] {
+object TrieMap extends MapFactory[TrieMap] {
 
   def empty[K, V]: TrieMap[K, V] = new TrieMap[K, V]
 

library/src/scala/collection/immutable/HashMap.scala

@@ -24,7 +24,7 @@ import scala.collection.Hashing.improve
 import scala.collection.Stepper.EfficientSplit
 import scala.collection.generic.DefaultSerializable
 import scala.collection.mutable, mutable.ReusableBuilder
-import scala.collection.{Iterator, StrictMapFactory, MapFactoryDefaults, Stepper, StepperShape, mutable}
+import scala.collection.{Iterator, MapFactory, MapFactoryDefaults, Stepper, StepperShape, mutable}
 import scala.runtime.AbstractFunction2
 import scala.runtime.Statics.releaseFence
 import scala.util.hashing.MurmurHash3
@@ -50,7 +50,7 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode:
   // This release fence is present because rootNode may have previously been mutated during construction.
   releaseFence()
 
-  override def mapFactory: StrictMapFactory[HashMap] = HashMap
+  override def mapFactory: MapFactory[HashMap] = HashMap
 
   override def knownSize: Int = rootNode.size
 
@@ -2194,7 +2194,7 @@ private final class MapNodeRemoveAllSetNodeIterator[K](rootSetNode: SetNode[K])
   * @define coll immutable champ hash map
   */
 @SerialVersionUID(3L)
-object HashMap extends StrictMapFactory[HashMap] {
+object HashMap extends MapFactory[HashMap] {
 
   @transient
   private final val EmptyMap = new HashMap(MapNode.empty)

library/src/scala/collection/immutable/ListMap.scala

@@ -50,7 +50,7 @@ sealed class ListMap[K, +V]
     with MapFactoryDefaults[K, V, ListMap, Iterable]
     with DefaultSerializable {
 
-  override def mapFactory: StrictMapFactory[ListMap] = ListMap
+  override def mapFactory: MapFactory[ListMap] = ListMap
 
   override def size: Int = 0
 
@@ -129,7 +129,7 @@ sealed class ListMap[K, +V]
   * @define coll list map
   */
 @SerialVersionUID(3L)
-object ListMap extends StrictMapFactory[ListMap] {
+object ListMap extends MapFactory[ListMap] {
   /**
     * Represents an entry in the `ListMap`.
     */

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

@@ -30,7 +30,7 @@ trait Map[K, +V]
      with MapOps[K, V, Map, Map[K, V]]
      with MapFactoryDefaults[K, V, Map, Iterable] {
 
-  override def mapFactory: scala.collection.StrictMapFactory[Map] = Map
+  override def mapFactory: scala.collection.MapFactory[Map] = Map
 
   override final def toMap[K2, V2](implicit ev: (K, V) <:< (K2, V2)): Map[K2, V2] = Map.from(this.asInstanceOf[Map[K2, V2]])
 
@@ -172,7 +172,7 @@ transparent trait StrictOptimizedMapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _]
   * @define Coll `immutable.Map`
   */
 @SerialVersionUID(3L)
-object Map extends StrictMapFactory[Map] {
+object Map extends MapFactory[Map] {
 
   @SerialVersionUID(3L)
   class WithDefault[K, +V](val underlying: Map[K, V], val defaultValue: K -> V)
@@ -189,7 +189,7 @@ object Map extends StrictMapFactory[Map] {
 
     override def isEmpty: Boolean = underlying.isEmpty
 
-    override def mapFactory: StrictMapFactory[Map] = underlying.mapFactory
+    override def mapFactory: MapFactory[Map] = underlying.mapFactory
 
     override def concat [V2 >: V](xs: collection.IterableOnce[(K, V2)]^): WithDefault[K, V2] =
       new WithDefault(underlying.concat(xs), defaultValue)

library/src/scala/collection/immutable/SeqMap.scala

@@ -40,11 +40,11 @@ trait SeqMap[K, +V]
     with collection.SeqMap[K, V]
     with MapOps[K, V, SeqMap, SeqMap[K, V]]
     with MapFactoryDefaults[K, V, SeqMap, Iterable] {
-  override def mapFactory: StrictMapFactory[SeqMap] = SeqMap
+  override def mapFactory: MapFactory[SeqMap] = SeqMap
 }
 
 
-object SeqMap extends StrictMapFactory[SeqMap] {
+object SeqMap extends MapFactory[SeqMap] {
   def empty[K, V]: SeqMap[K, V] = EmptySeqMap.asInstanceOf[SeqMap[K, V]]
 
   def from[K, V](it: collection.IterableOnce[(K, V)]^): SeqMap[K, V] =

library/src/scala/collection/immutable/TreeSeqMap.scala

@@ -61,7 +61,7 @@ final class TreeSeqMap[K, +V] private (
 
   override protected[this] def className: String = "TreeSeqMap"
 
-  override def mapFactory: StrictMapFactory[TreeSeqMap] = TreeSeqMap
+  override def mapFactory: MapFactory[TreeSeqMap] = TreeSeqMap
 
   override val size = mapping.size
 
@@ -289,7 +289,7 @@ final class TreeSeqMap[K, +V] private (
   @`inline` private[this] def value(p: (_, V)) = p._2
   @`inline` private[this] def binding(k: K) = mapping(k).copy(_1 = k)
 }
-object TreeSeqMap extends StrictMapFactory[TreeSeqMap] {
+object TreeSeqMap extends MapFactory[TreeSeqMap] {
   sealed trait OrderBy
   object OrderBy {
     case object Insertion extends OrderBy

library/src/scala/collection/immutable/VectorMap.scala

@@ -168,7 +168,7 @@ final class VectorMap[K, +V] private (
     }
   }
 
-  override def mapFactory: StrictMapFactory[VectorMap] = VectorMap
+  override def mapFactory: MapFactory[VectorMap] = VectorMap
 
   override def contains(key: K): Boolean = underlying.contains(key)
 
@@ -221,7 +221,7 @@ final class VectorMap[K, +V] private (
   }
 }
 
-object VectorMap extends StrictMapFactory[VectorMap] {
+object VectorMap extends MapFactory[VectorMap] {
   //Class to mark deleted slots in 'fields'.
   //When one or more consecutive slots are deleted, the 'distance' of the first 'Tombstone'
   // represents the distance to the location of the next undeleted slot (or the last slot in 'fields' +1 if it does not exist).