Drop strict overrides from StrictMapOps and StrictSeqOps

The compiler can properly figure out the return types based on the Pure upper bound on CC

Author: natsukagami

library/src/scala/collection/Map.scala

@@ -93,40 +93,6 @@ trait Map[K, +V]
 /** 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 {
-
-  override def mapFactory: StrictMapFactory[CC]
-  override protected def fromSpecific(coll: IterableOnce[(K, V) @uncheckedVariance]^): C
-
-  @`inline` override protected def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]^): CC[K2, V2] = mapFactory.from(it)
-
-  override def map[K2, V2](f: ((K, V)) => (K2, V2)): CC[K2, V2] = mapFactory.from(new View.Map(this, f))
-
-  override def collect[K2, V2](pf: PartialFunction[(K, V), (K2, V2)]^): CC[K2, V2] =
-    mapFactory.from(new View.Collect(this, pf))
-
-  override def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]^): CC[K2, V2] = mapFactory.from(new View.FlatMap(this, f))
-
-  override def concat[V2 >: V](suffix: collection.IterableOnce[(K, V2)]^): CC[K, V2] = mapFactory.from(suffix match {
-    case it: Iterable[(K, V2)] => new View.Concat(this, it)
-    case _ => iterator.concat(suffix.iterator)
-  })
-
-  override def ++ [V2 >: V](xs: collection.IterableOnce[(K, V2)]^): CC[K, V2] = concat(xs)
-
-  @`inline` override def -- (keys: IterableOnce[K]^): C = {
-    lazy val keysSet = keys.iterator.to(immutable.Set)
-    fromSpecific(this.view.filterKeys(k => !keysSet.contains(k)))
-  }
-
-  @deprecated("Use ++ instead of ++: for collections of type Iterable", "2.13.0")
-  override def ++: [V1 >: V](that: IterableOnce[(K,V1)]^): CC[K,V1] = {
-    val thatIterable: Iterable[(K, V1)]^{that} = that match {
-      case that: Iterable[(K, V1)] => that
-      case that => View.from(that)
-    }
-    mapFactory.from(new View.Concat(thatIterable, this))
-  }
-
   // The original keySet implementation, with a lazy iterator over the keys,
   // is only correct if we have a strict Map.
   // We restore it here.

library/src/scala/collection/Seq.scala

@@ -63,25 +63,6 @@ object Seq extends SeqFactory.Delegate[Seq](immutable.Seq)
   * Contains strict overrides of SeqOps operations, where the parameters are also captured.
   */
 transparent trait StrictSeqOps[+A, +CC[B] <: caps.Pure, +C] extends Any with SeqOps[A, CC, C] with caps.Pure {
-  override def iterableFactory: StrictIterableFactory[CC]
-
-  override def prependedAll[B >: A](prefix: IterableOnce[B]^): CC[B] = iterableFactory.from(prefix match {
-    case prefix: Iterable[B] => new View.Concat(prefix, this)
-    case _ => prefix.iterator ++ iterator
-  })
-
-  @inline override final def ++: [B >: A](prefix: IterableOnce[B]^): CC[B] = prependedAll(prefix)
-
-  override def appendedAll[B >: A](suffix: IterableOnce[B]^): CC[B] = super.concat(suffix)
-
-  @inline override final def :++ [B >: A](suffix: IterableOnce[B]^): CC[B] = appendedAll(suffix)
-
-  @inline override final def concat[B >: A](suffix: IterableOnce[B]^): CC[B] = appendedAll(suffix)
-
-  override def reverseMap[B](f: A => B): CC[B] = iterableFactory.from(new View.Map(View.fromIteratorProvider(() => reverseIterator), f))
-
-  override def patch[B >: A](from: Int, other: IterableOnce[B]^, replaced: Int): CC[B] =
-    iterableFactory.from(new View.Patched(this, from, other, replaced))
 }
 
 /** Base trait for Seq operations
@@ -1042,11 +1023,11 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any
     * @return a `Found` value containing the index corresponding to the element in the
     *         sequence, or the `InsertionPoint` where the element would be inserted if
     *         the element is not in the sequence.
-    * 
+    *
     * @note if `to <= from`, the search space is empty, and an `InsertionPoint` at `from`
     *       is returned
     */
-  def search[B >: A](elem: B, from: Int, to: Int) (implicit ord: Ordering[B]): SearchResult = 
+  def search[B >: A](elem: B, from: Int, to: Int) (implicit ord: Ordering[B]): SearchResult =
     linearSearch(view.slice(from, to), elem, math.max(0, from))(ord)
 
   private[this] def linearSearch[B >: A](c: View[A]^, elem: B, offset: Int)