One of the blips in the performance charts seem...

One of the blips in the performance charts seems to implicate some
changes I made with slice to reduce the number of implementations and
surface area for inconsistencies and bugs. Altering those changes in a
more performance-mindful way, although I don't see anything here which
is likely to help much. Also fixing some wrong documentation about
copyToArray. No review.

1 files changed, 43 insertions, 3 deletions

diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala
index 458b26207e..b6713b65e4 100644
--- a/src/library/scala/collection/IterableLike.scala
+++ b/src/library/scala/collection/IterableLike.scala
@@ -90,9 +90,49 @@ self =>
     iterator.next
 
   override /*TraversableLike*/ def slice(from: Int, until: Int): Repr = {
-    val lo = from max 0
-    if (until <= lo) newBuilder.result
-    else newBuilder ++= (iterator drop lo take (until - lo)) result
+    val lo = math.max(from, 0)
+    val elems = until - lo
+    val b = newBuilder
+    if (elems <= 0) b.result
+    else {
+      b.sizeHintBounded(elems, this)
+      var i = 0
+      val it = iterator drop lo
+      while (i < elems && it.hasNext) {
+        b += it.next
+        i += 1
+      }
+      b.result
+    }
+  }
+
+  override /*TraversableLike*/ def take(n: Int): Repr = {
+    val b = newBuilder
+
+    if (n <= 0) b.result
+    else {
+      b.sizeHintBounded(n, this)
+      var i = 0
+      val it = iterator
+      while (i < n && it.hasNext) {
+        b += it.next
+        i += 1
+      }
+      b.result
+    }
+  }
+
+  override /*TraversableLike*/ def drop(n: Int): Repr = {
+    val b = newBuilder
+    val lo = math.max(0, n)
+    b.sizeHint(this, -lo)
+    var i = 0
+    val it = iterator
+    while (i < n && it.hasNext) {
+      it.next
+      i += 1
+    }
+    b ++= it result
   }
 
   override /*TraversableLike*/ def takeWhile(p: A => Boolean): Repr = {