Brought all the collections pure interfaces up ...

Brought all the collections pure interfaces up to date. No review.

6 files changed, 39 insertions, 29 deletions

diff --git a/src/library/scala/collection/interfaces/IterableMethods.scala b/src/library/scala/collection/interfaces/IterableMethods.scala
index db783f3642..9cc3e2c1ac 100644
--- a/src/library/scala/collection/interfaces/IterableMethods.scala
+++ b/src/library/scala/collection/interfaces/IterableMethods.scala
@@ -29,7 +29,6 @@ trait IterableMethods[+A, +This <: IterableLike[A, This] with Iterable[A]] exten
   def sameElements[B >: A](that: Iterable[B]): Boolean
   def sliding[B >: A](size: Int): Iterator[Iterable[A]]
   def sliding[B >: A](size: Int, step: Int): Iterator[Iterable[A]]
-  def sortWith(lt: (A, A) => Boolean)(implicit m: ClassManifest[A @uncheckedVariance]): This
   def takeRight(n: Int): Iterable[A]
   def zipAll[B, A1 >: A, That](that: Iterable[B], e1: A1, e2: B)(implicit bf: CanBuildFrom[This, (A1, B), That]): That
   def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[This, (A1, Int), That]): That
diff --git a/src/library/scala/collection/interfaces/MapMethods.scala b/src/library/scala/collection/interfaces/MapMethods.scala
index 49467e9401..a36a1c08f4 100644
--- a/src/library/scala/collection/interfaces/MapMethods.scala
+++ b/src/library/scala/collection/interfaces/MapMethods.scala
@@ -37,8 +37,8 @@ trait MapMethods[A, +B, +This <: MapLike[A, B, This] with Map[A, B]]
   def values: Iterable[B]
   def valuesIterator: Iterator[B]
   def default(key: A): B
-  def filterKeys(p: A => Boolean): DefaultMap[A, B]
-  def mapValues[C](f: B => C): DefaultMap[A, C]
+  def filterKeys(p: A => Boolean): Map[A, B]
+  def mapValues[C](f: B => C): Map[A, C]
   def updated [B1 >: B](key: A, value: B1): Map[A, B1]
   def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): Map[A, B1]
   def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): Map[A, B1]
diff --git a/src/library/scala/collection/interfaces/SeqMethods.scala b/src/library/scala/collection/interfaces/SeqMethods.scala
index 22c4b0034c..9d8bf13a20 100644
--- a/src/library/scala/collection/interfaces/SeqMethods.scala
+++ b/src/library/scala/collection/interfaces/SeqMethods.scala
@@ -26,6 +26,7 @@ trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMeth
   // concrete
   def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[This, B, That]): That
   def :+[B >: A, That](elem: B)(implicit bf: CanBuildFrom[This, B, That]): That
+  def combinations(n: Int): Iterator[This]
   def contains(elem: Any): Boolean
   def containsSlice[B](that: Seq[B]): Boolean
   def corresponds[B](that: Seq[B])(p: (A,B) => Boolean): Boolean
@@ -50,6 +51,7 @@ trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMeth
   def lengthCompare(len: Int): Int
   def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That
   def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[This, B, That]): That
+  def permutations: Iterator[This]
   def prefixLength(p: A => Boolean): Int
   def reverse: This
   def reverseIterator: Iterator[A]
@@ -63,6 +65,7 @@ trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMeth
   def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[This, B, That]): That
   def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That
 
-  override def view: SeqView[A, This]
-  override def view(from: Int, until: Int): SeqView[A, This]
+  // refinements
+  def view: SeqView[A, This]
+  def view(from: Int, until: Int): SeqView[A, This]
 }
diff --git a/src/library/scala/collection/interfaces/SetMethods.scala b/src/library/scala/collection/interfaces/SetMethods.scala
index 9f5d5cff3a..ffe141ed82 100644
--- a/src/library/scala/collection/interfaces/SetMethods.scala
+++ b/src/library/scala/collection/interfaces/SetMethods.scala
@@ -38,12 +38,15 @@ trait SetMethods[A, +This <: SetLike[A, This] with Set[A]]
   def - (elem: A): This
 
   // concrete
+  def & (that: Set[A]): This
+  def &~ (that: Set[A]): This
+  def + (elem1: A, elem2: A, elems: A*): This
   def apply(elem: A): Boolean
+  def diff(that: Set[A]): This
   def intersect(that: Set[A]): This
-  def &(that: Set[A]): This
+  def subsetOf(that: Set[A]): Boolean
+  def subsets(len: Int): Iterator[This]
+  def subsets: Iterator[This]
   def union(that: Set[A]): This
   def | (that: Set[A]): This
-  def diff(that: Set[A]): This
-  def &~(that: Set[A]): This
-  def subsetOf(that: Set[A]): Boolean
 }
diff --git a/src/library/scala/collection/interfaces/TraversableMethods.scala b/src/library/scala/collection/interfaces/TraversableMethods.scala
index fa684d88af..4a34b0b1ed 100644
--- a/src/library/scala/collection/interfaces/TraversableMethods.scala
+++ b/src/library/scala/collection/interfaces/TraversableMethods.scala
@@ -10,8 +10,6 @@ package scala.collection
 package interfaces
 
 import generic._
-import mutable.Buffer
-import scala.reflect.ClassManifest
 
 /**
  * @since 2.8
@@ -27,7 +25,8 @@ trait TraversableMethods[+A, +This <: TraversableLike[A, This]] extends Traversa
   def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[This, B, That]): That
 
   // new collections
-  def ++[B >: A, That](xs: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That
+  def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That
+  def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That
 
   // element retrieval
   def head: A
@@ -40,12 +39,14 @@ trait TraversableMethods[+A, +This <: TraversableLike[A, This]] extends Traversa
   def dropWhile(p: A => Boolean): Traversable[A]
   def filter(p: A => Boolean): Traversable[A]
   def filterNot(p: A => Boolean): Traversable[A]
-  def withFilter(p: A => Boolean): FilterMonadic[A, Traversable[A]]
   def init: Traversable[A]
+  def inits: Iterator[This]
   def slice(from: Int, until: Int): Traversable[A]
   def tail: Traversable[A]
+  def tails: Iterator[This]
   def take(n: Int): Traversable[A]
   def takeWhile(p: A => Boolean): Traversable[A]
+  def withFilter(p: A => Boolean): FilterMonadic[A, Traversable[A]]
 
   // subdivisions
   def groupBy[K](f: A => K): Map[K, Traversable[A]]
@@ -54,8 +55,6 @@ trait TraversableMethods[+A, +This <: TraversableLike[A, This]] extends Traversa
   def splitAt(n: Int): (Traversable[A], Traversable[A])
 
   // info
-  def count(p: A => Boolean): Int
-  def size: Int
   def stringPrefix: String
 
   // views
diff --git a/src/library/scala/collection/interfaces/TraversableOnceMethods.scala b/src/library/scala/collection/interfaces/TraversableOnceMethods.scala
index 72f28de6e9..8967e15a34 100644
--- a/src/library/scala/collection/interfaces/TraversableOnceMethods.scala
+++ b/src/library/scala/collection/interfaces/TraversableOnceMethods.scala
@@ -9,41 +9,41 @@
 package scala.collection
 package interfaces
 
-import mutable.Buffer
-
 trait TraversableOnceMethods[+A] {
   self: TraversableOnce[A] =>
 
   def foreach[U](f: A => U): Unit
+  def size: Int
   protected[this] def reversed: TraversableOnce[A]
 
   // tests
-  def isEmpty: Boolean
-  def nonEmpty: Boolean
   def hasDefiniteSize: Boolean
+  def isEmpty: Boolean
   def isTraversableAgain: Boolean
+  def nonEmpty: Boolean
 
   // applying a predicate
-  def forall(p: A => Boolean): Boolean
+  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
+  def count(p: A => Boolean): Int
   def exists(p: A => Boolean): Boolean
   def find(p: A => Boolean): Option[A]
-  def count(p: A => Boolean): Int
+  def forall(p: A => Boolean): Boolean
 
   // folds
   def /:[B](z: B)(op: (B, A) => B): B
   def :\[B](z: B)(op: (A, B) => B): B
   def foldLeft[B](z: B)(op: (B, A) => B): B
   def foldRight[B](z: B)(op: (A, B) => B): B
-  def reduceLeft[B >: A](op: (B, A) => B): B
-  def reduceRight[B >: A](op: (A, B) => B): B
   def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
+  def reduceLeft[B >: A](op: (B, A) => B): B
   def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
+  def reduceRight[B >: A](op: (A, B) => B): B
 
   // copies
-  def copyToBuffer[B >: A](dest: Buffer[B]): Unit
-  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit
-  def copyToArray[B >: A](xs: Array[B], start: Int): Unit
   def copyToArray[B >: A](xs: Array[B]): Unit
+  def copyToArray[B >: A](xs: Array[B], start: Int): Unit
+  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit
+  def copyToBuffer[B >: A](dest: mutable.Buffer[B]): Unit
 
   // conversions
   def toArray[B >: A : ClassManifest]: Array[B]
@@ -53,16 +53,22 @@ trait TraversableOnceMethods[+A] {
   def toIterator: Iterator[A]
   def toList: List[A]
   def toMap[T, U](implicit ev: A <:< (T, U)): immutable.Map[T, U]
+  def toParIterable: parallel.ParIterable[A]
+  def toParMap[T, U](implicit ev: A <:< (T, U)): parallel.ParMap[T, U]
+  def toParSeq: parallel.ParSeq[A]
+  def toParSet[B >: A]: parallel.ParSet[B]
   def toSeq: Seq[A]
   def toSet[B >: A]: immutable.Set[B]
   def toStream: Stream[A]
   def toTraversable: Traversable[A]
 
   // type-constrained folds
-  def sum[B >: A](implicit num: Numeric[B]): B
-  def product[B >: A](implicit num: Numeric[B]): B
-  def min[B >: A](implicit cmp: Ordering[B]): A
+  def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A
   def max[B >: A](implicit cmp: Ordering[B]): A
+  def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A
+  def min[B >: A](implicit cmp: Ordering[B]): A
+  def product[B >: A](implicit num: Numeric[B]): B
+  def sum[B >: A](implicit num: Numeric[B]): B
 
   // strings
   def mkString(start: String, sep: String, end: String): String