Drop StrictSeqOps and StrictIndexedSeqOps

Inline them into (Indexed)SeqOps and caps.Pure

Author: natsukagami

library/src/scala/collection/Factory.scala

@@ -707,7 +707,7 @@ object ClassTagSeqFactory {
   /** A SeqFactory that uses ClassTag.Any as the evidence for every element type. This may or may not be
     * sound depending on the use of the `ClassTag` by the collection implementation. */
   @SerialVersionUID(3L)
-  class AnySeqDelegate[CC[A] <: StrictSeqOps[A, Seq, Seq[A]]](delegate: ClassTagSeqFactory[CC])
+  class AnySeqDelegate[CC[A] <: SeqOps[A, Seq, Seq[A]] & caps.Pure](delegate: ClassTagSeqFactory[CC])
     extends ClassTagIterableFactory.AnyIterableDelegate[CC](delegate) with SeqFactory[CC]
 }
 

library/src/scala/collection/IndexedSeq.scala

@@ -23,8 +23,9 @@ import scala.math.Ordering
 
 /** Base trait for indexed sequences that have efficient `apply` and `length` */
 trait IndexedSeq[+A] extends Seq[A]
-  with StrictIndexedSeqOps[A, IndexedSeq, IndexedSeq[A]]
-  with IterableFactoryDefaults[A, IndexedSeq] {
+  with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]]
+  with IterableFactoryDefaults[A, IndexedSeq]
+  with caps.Pure {
   @nowarn("""cat=deprecation&origin=scala\.collection\.Iterable\.stringPrefix""")
   override protected[this] def stringPrefix: String = "IndexedSeq"
 
@@ -34,15 +35,6 @@ trait IndexedSeq[+A] extends Seq[A]
 @SerialVersionUID(3L)
 object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](immutable.IndexedSeq)
 
-transparent trait StrictIndexedSeqOps[+A, +CC[_] <: caps.Pure, +C] extends Any with StrictSeqOps[A, CC, C] with IndexedSeqOps[A, CC, C] {
-  override def map[B](f: A => B): CC[B] = iterableFactory.from(new IndexedSeqView.Map(this, f))
-  override def sliding(size: Int, step: Int): Iterator[C] = {
-    require(size >= 1 && step >= 1, f"size=$size%d and step=$step%d, but both must be positive")
-    val it = new IndexedSeqSlidingIterator[A, CC, C](this, size, step)
-    it.asInstanceOf[Iterator[C]] // TODO: seems like CC cannot figure this out yet
-  }
-}
-
 /** Base trait for indexed Seq operations */
 transparent trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self: IndexedSeqOps[A, CC, C]^ =>
 

library/src/scala/collection/LinearSeq.scala

@@ -35,7 +35,7 @@ trait LinearSeq[+A] extends Seq[A]
 object LinearSeq extends SeqFactory.Delegate[LinearSeq](immutable.LinearSeq)
 
 /** Base trait for linear Seq operations */
-transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends Any with StrictSeqOps[A, CC, C] { self =>
+transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends Any with SeqOps[A, CC, C] with caps.Pure { self =>
 
   /** @inheritdoc
    *

library/src/scala/collection/Seq.scala

@@ -27,7 +27,7 @@ import scala.annotation.nowarn
 trait Seq[+A]
   extends Iterable[A]
     with PartialFunction[Int, A]
-    with StrictSeqOps[A, Seq, Seq[A]]
+    with SeqOps[A, Seq, Seq[A]]
     with IterableFactoryDefaults[A, Seq]
     with Equals
     with caps.Pure {
@@ -58,13 +58,6 @@ trait Seq[+A]
 @SerialVersionUID(3L)
 object Seq extends SeqFactory.Delegate[Seq](immutable.Seq)
 
-/** Base trait for strict Seq operations.
-  *
-  * 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 {
-}
-
 /** Base trait for Seq operations
   *
   * @tparam A the element type of the collection

library/src/scala/collection/StrictOptimizedSeqOps.scala

@@ -20,7 +20,7 @@ import language.experimental.captureChecking
   * to take advantage of strict builders.
   */
 transparent trait StrictOptimizedSeqOps [+A, +CC[_] <: caps.Pure, +C]
-  extends Any with StrictSeqOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C] {
+  extends Any with SeqOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C] with caps.Pure {
 
   override def distinctBy[B](f: A -> B): C = {
     val builder = newSpecificBuilder

library/src/scala/collection/immutable/ArraySeq.scala

@@ -41,7 +41,8 @@ sealed abstract class ArraySeq[+A]
     with IndexedSeqOps[A, ArraySeq, ArraySeq[A]]
     with StrictOptimizedSeqOps[A, ArraySeq, ArraySeq[A]]
     with EvidenceIterableFactoryDefaults[A, ArraySeq, ClassTag]
-    with Serializable {
+    with Serializable
+    with caps.Pure {
 
   /** The tag of the element type. This does not have to be equal to the element type of this ArraySeq. A primitive
     * ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an array of a supertype

library/src/scala/collection/immutable/Seq.scala

@@ -31,7 +31,7 @@ trait Seq[+A] extends Iterable[A]
   * @define coll immutable sequence
   * @define Coll `immutable.Seq`
   */
-transparent trait SeqOps[+A, +CC[B] <: collection.StrictSeqOps[B, collection.Seq, collection.Seq[B]], +C] extends Any with collection.StrictSeqOps[A, CC, C]
+transparent trait SeqOps[+A, +CC[B] <: caps.Pure, +C] extends Any with collection.SeqOps[A, CC, C] with caps.Pure
 
 /**
   * $factoryInfo
@@ -120,9 +120,10 @@ object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](Vector) {
 }
 
 /** Base trait for immutable indexed Seq operations */
-transparent trait IndexedSeqOps[+A, +CC[B] <: collection.StrictSeqOps[B, collection.Seq, collection.Seq[B]], +C]
+transparent trait IndexedSeqOps[+A, +CC[B] <: caps.Pure, +C]
   extends SeqOps[A, CC, C]
-    with collection.StrictIndexedSeqOps[A, CC, C] {
+    with collection.IndexedSeqOps[A, CC, C]
+    with caps.Pure {
 
   override def slice(from: Int, until: Int): C = {
     // since we are immutable we can just share the same collection

library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala

@@ -21,11 +21,12 @@ import scala.collection.generic.CommonErrors
 
 /** Trait that overrides operations to take advantage of strict builders.
  */
-transparent trait StrictOptimizedSeqOps[+A, +CC[B] <: collection.StrictSeqOps[B, collection.Seq, collection.Seq[B]], +C]
+transparent trait StrictOptimizedSeqOps[+A, +CC[B] <: collection.SeqOps[B, collection.Seq, collection.Seq[B]] & caps.Pure, +C]
   extends Any
-    with StrictSeqOps[A, CC, C]
+    with SeqOps[A, CC, C]
     with collection.StrictOptimizedSeqOps[A, CC, C]
-    with StrictOptimizedIterableOps[A, CC, C] {
+    with StrictOptimizedIterableOps[A, CC, C]
+    with caps.Pure {
 
   override def distinctBy[B](f: A -> B): C = {
     if (lengthCompare(1) <= 0) coll

library/src/scala/collection/immutable/WrappedString.scala

@@ -36,8 +36,9 @@ import scala.collection.mutable.{Builder, StringBuilder}
   */
 @SerialVersionUID(3L)
 final class WrappedString(private val self: String) extends AbstractSeq[Char] with IndexedSeq[Char]
-  with StrictIndexedSeqOps[Char, IndexedSeq, WrappedString]
-  with Serializable {
+  with IndexedSeqOps[Char, IndexedSeq, WrappedString]
+  with Serializable
+  with caps.Pure {
 
   def apply(i: Int): Char = self.charAt(i)
 

library/src/scala/collection/mutable/IndexedSeq.scala

@@ -28,8 +28,9 @@ trait IndexedSeq[T] extends Seq[T]
 object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](ArrayBuffer)
 
 transparent trait IndexedSeqOps[A, +CC[_] <: caps.Pure, +C <: AnyRef]
-  extends scala.collection.StrictIndexedSeqOps[A, CC, C]
-    with SeqOps[A, CC, C] {
+  extends scala.collection.IndexedSeqOps[A, CC, C]
+    with SeqOps[A, CC, C]
+    with caps.Pure {
 
   /** Modifies this $coll by applying a function to all elements of this $coll.
     *