Add immutable StrictOptimizedSeqOps to stdlib

Author: odersky

tests/pos-special/stdlib/collection/StrictOptimizedSeqOps.scala

@@ -19,7 +19,7 @@ import scala.annotation.unchecked.uncheckedCaptures
   * to take advantage of strict builders.
   */
 trait StrictOptimizedSeqOps [+A, +CC[_], +C]
-  extends AnyRef
+  extends Any
     with SeqOps[A, CC, C]
     with StrictOptimizedIterableOps[A, CC, C] {
 

tests/pos-special/stdlib/collection/immutable/Seq.scala

@@ -30,7 +30,7 @@ trait Seq[+A] extends Iterable[A]
   * @define coll immutable sequence
   * @define Coll `immutable.Seq`
   */
-trait SeqOps[+A, +CC[_], +C] extends AnyRef with collection.SeqOps[A, CC, C]
+trait SeqOps[+A, +CC[_], +C] extends Any with collection.SeqOps[A, CC, C]
 
 /**
   * $factoryInfo

tests/pos-special/stdlib/collection/immutable/StrictOptimizedSeqOps.scala

@@ -0,0 +1,82 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala
+package collection
+package immutable
+import language.experimental.captureChecking
+import annotation.unchecked.uncheckedCaptures
+
+/**
+  * Trait that overrides operations to take advantage of strict builders.
+  */
+trait StrictOptimizedSeqOps[+A, +CC[_], +C]
+  extends Any
+    with SeqOps[A, CC, C]
+    with collection.StrictOptimizedSeqOps[A, CC, C]
+    with StrictOptimizedIterableOps[A, CC, C] {
+
+  override def distinctBy[B](f: A -> B): C = {
+    if (lengthCompare(1) <= 0) coll
+    else {
+      val builder = newSpecificBuilder
+      val seen = mutable.HashSet.empty[B @uncheckedCaptures]
+      val it = this.iterator
+      var different = false
+      while (it.hasNext) {
+        val next = it.next()
+        if (seen.add(f(next))) builder += next else different = true
+      }
+      if (different) builder.result() else coll
+    }
+  }
+
+  override def updated[B >: A](index: Int, elem: B): CC[B] = {
+    if (index < 0) throw new IndexOutOfBoundsException(s"$index is out of bounds (min 0, max ${if (knownSize>=0) knownSize else "unknown"})")
+    val b = iterableFactory.newBuilder[B]
+    if (knownSize >= 0) {
+      b.sizeHint(size)
+    }
+    var i = 0
+    val it = iterator
+    while (i < index && it.hasNext) {
+      b += it.next()
+      i += 1
+    }
+    if (!it.hasNext) throw new IndexOutOfBoundsException(s"$index is out of bounds (min 0, max ${i-1})")
+    b += elem
+    it.next()
+    while (it.hasNext) b += it.next()
+    b.result()
+  }
+
+  override def patch[B >: A](from: Int, other: IterableOnce[B]^, replaced: Int): CC[B] = {
+    val b = iterableFactory.newBuilder[B]
+    var i = 0
+    val it = iterator
+    while (i < from && it.hasNext) {
+      b += it.next()
+      i += 1
+    }
+    b ++= other
+    i = replaced
+    while (i > 0 && it.hasNext) {
+      it.next()
+      i -= 1
+    }
+    while (it.hasNext) b += it.next()
+    b.result()
+  }
+
+  override def sorted[B >: A](implicit ord: Ordering[B]): C = super.sorted(ord)
+
+}