Removed redundant type parameter for class Buil...

Removed redundant type parameter for class Builder

src/library/scala/Array.scala

@@ -27,7 +27,7 @@ object Array extends SequenceFactory[Array] {
 
   type Coll = Array[_]
   implicit def builderFactory[A]: BuilderFactory[A, Array[A], Coll] = new BuilderFactory[A, Array[A], Coll] { def apply(from: Coll) = newBuilder[A] }
-  def newBuilder[A]: Builder[A, Array[A], Any] = new ArrayBuffer[A].mapResult(_.toArray)
+  def newBuilder[A]: Builder[A, Array[A]] = new ArrayBuffer[A].mapResult(_.toArray)
 
   private def slowcopy(
                      src : AnyRef,
@@ -248,7 +248,7 @@ object Array extends SequenceFactory[Array] {
  */
 final class Array[A](_length: Int) extends Vector[A] with VectorTemplate[A, Array[A]] {
 
-  override protected[this] def newBuilder: Builder[A, Array[A], Any] = throw new Error()
+  override protected[this] def newBuilder: Builder[A, Array[A]] = throw new Error()
 
    /** Multidimensional array creation
     *  @deprecated use Array.ofDim instead

src/library/scala/Enumeration.scala

@@ -232,7 +232,7 @@ abstract class Enumeration(initial: Int, names: String*) {
       s
     }
     /** A builder object for value sets */
-    def newBuilder: Builder[Value, ValueSet, Any] = new AddingBuilder(empty)
+    def newBuilder: Builder[Value, ValueSet] = new AddingBuilder(empty)
     /** The implicit builder for value sets */
     implicit def builderFactory: BuilderFactory[Value, ValueSet, ValueSet] = new BuilderFactory[Value, ValueSet, ValueSet] { def apply(from: ValueSet) = newBuilder }
   }

src/library/scala/collection/Iterable.scala

@@ -33,7 +33,7 @@ import generic._
  */
 trait Iterable[+A] extends Traversable[A] with IterableTemplate[A, Iterable[A]] {
   override protected[this] def newBuilder = Iterable.newBuilder
-  override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Iterable[B]] = Iterable.newBuilder[B]
 
   /* The following methods are inherited from trait IterableTemplate
    *
@@ -51,7 +51,7 @@ object Iterable extends TraversableFactory[Iterable] {
 
   type Coll	= Iterable[_]
   implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, Iterable[A], Any] = immutable.Iterable.newBuilder[A]
+  def newBuilder[A]: Builder[A, Iterable[A]] = immutable.Iterable.newBuilder[A]
 
   def fromOld[A](it: scala.Iterable[A]): Iterable[A] = new Iterable[A] {
     def elements: Iterator[A] = Iterator.fromOld(it.elements)

src/library/scala/collection/LinearSequence.scala

@@ -28,11 +28,11 @@ import util.control.Breaks._
  */
 trait LinearSequence[+A] extends Sequence[A] with LinearSequenceTemplate[A, LinearSequence[A]] {
   override protected[this] def newBuilder = LinearSequence.newBuilder
-  override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, LinearSequence[B]] = LinearSequence.newBuilder[B]
 }
 
 object LinearSequence extends SequenceFactory[LinearSequence] {
   type Coll = LinearSequence[_]
   implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, LinearSequence[A], Any] = immutable.LinearSequence.newBuilder[A]
+  def newBuilder[A]: Builder[A, LinearSequence[A]] = immutable.LinearSequence.newBuilder[A]
 }

src/library/scala/collection/Map.scala

@@ -38,10 +38,10 @@ import generic._
 trait Map[A, +B] extends Iterable[(A, B)] with MapTemplate[A, B, Map[A, B]] {
   def empty: Map[A, B] = Map.empty
 
-  override protected[this] def newBuilder : Builder[(A, B), Map[A, B], Any] =
+  override protected[this] def newBuilder : Builder[(A, B), Map[A, B]] =
     throw new UnsupportedOperationException("Map.newBuilder")
 
-  def mapBuilder[A, B]: Builder[(A, B), Map[A, B], Any] = Map.newBuilder[A, B]
+  def mapBuilder[A, B]: Builder[(A, B), Map[A, B]] = Map.newBuilder[A, B]
 }
 
 /* Factory object for `Map` class */

src/library/scala/collection/Sequence.scala

@@ -30,14 +30,14 @@ import util.control.Breaks._
  */
 trait Sequence[+A] extends PartialFunction[Int, A] with Iterable[A] with SequenceTemplate[A, Sequence[A]] {
   override protected[this] def newBuilder = Sequence.newBuilder
-  override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Sequence[B]] = Sequence.newBuilder[B]
 }
 
 object Sequence extends SequenceFactory[Sequence] {
 
   type Coll = Sequence[_]
   implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, Sequence[A], Any] = immutable.Sequence.newBuilder[A]
+  def newBuilder[A]: Builder[A, Sequence[A]] = immutable.Sequence.newBuilder[A]
 
   /** @deprecated use View instead
    */

src/library/scala/collection/Set.scala

@@ -23,7 +23,7 @@ import generic._
  */
 trait Set[A] extends (A => Boolean) with Iterable[A] with SetTemplate[A, Set[A]] {
   def empty = Set.empty
-  override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Set[B]] = Set.newBuilder[B]
 }
 
 /* Factory object for `Set` class */

src/library/scala/collection/SortedMap.scala

@@ -20,7 +20,7 @@ import generic._
 trait SortedMap[A, +B] extends Map[A, B] with SortedMapTemplate[A, B, SortedMap[A, B]] {
   /** Needs to be overridden in subclasses. */
   override def empty: SortedMap[A, B] = throw new UnsupportedOperationException("SortedMap.empty")
-  override protected[this] def newBuilder : Builder[(A, B), SortedMap[A, B], Any] =
+  override protected[this] def newBuilder : Builder[(A, B), SortedMap[A, B]] =
     throw new UnsupportedOperationException("SortedMap.newBuilder")
 
 }

src/library/scala/collection/Traversable.scala

@@ -27,7 +27,7 @@ import generic._
  */
 trait Traversable[+A] extends TraversableTemplate[A, Traversable[A]] {
   protected[this] def newBuilder = Traversable.newBuilder
-  def traversableBuilder[B]: Builder[B, Traversable[B], Any] = Traversable.newBuilder[B]
+  def traversableBuilder[B]: Builder[B, Traversable[B]] = Traversable.newBuilder[B]
 
   /* The following methods are inherited from TraversableTemplate
    *
@@ -95,7 +95,7 @@ object Traversable extends TraversableFactory[Traversable] { self =>
 
   type Coll = Traversable[_]
   implicit def builderFactory[A]: BuilderFactory[A, Traversable[A], Coll] = new BuilderFactory[A, Traversable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, Traversable[A], Any] = immutable.Traversable.newBuilder[A]
+  def newBuilder[A]: Builder[A, Traversable[A]] = immutable.Traversable.newBuilder[A]
 
   /** A wrapper class which adds `min` and `max` methods to iterables of an element type that has an Ordering.
    */
@@ -154,7 +154,7 @@ object Traversable extends TraversableFactory[Traversable] { self =>
     /** Returns the transposition of the wrapped iterable `self`: rows become columns and columns become rows.
      */
     def transpose[Row, That](implicit bf: BuilderFactory[A, Row, This], bbf: BuilderFactory[Row, That, This]): That = {
-      val bs: Array[Builder[A, Row, This]] = self.head.map(_ => bf(self))(Traversable.builderFactory[Builder[A, Row, This]]).toArray
+      val bs: Array[Builder[A, Row]] = self.head.map(_ => bf(self))(Traversable.builderFactory[Builder[A, Row]]).toArray
       for (xs <- self) {
         var i = 0
         for (x <- xs) {

src/library/scala/collection/Vector.scala

@@ -23,11 +23,11 @@ import mutable.ArrayBuffer
  */
 trait Vector[+A] extends Sequence[A] with VectorTemplate[A, Vector[A]] {
   override protected[this] def newBuilder = Vector.newBuilder
-  override def traversableBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Vector[B]] = Vector.newBuilder[B]
 }
 
 object Vector extends SequenceFactory[Vector] {
   type Coll = Vector[_]
   implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, Vector[A], Any] = mutable.Vector.newBuilder[A]
+  def newBuilder[A]: Builder[A, Vector[A]] = mutable.Vector.newBuilder[A]
 }

src/library/scala/collection/generic/AddingBuilder.scala

@@ -18,7 +18,7 @@ package scala.collection.generic
  *  @param empty   The empty element of the collection.
  */
 class AddingBuilder[A, Coll <: Addable[A, Coll] with Iterable[A] with IterableTemplate[A, Coll]](empty: Coll)
-extends Builder[A, Coll, Any] {
+extends Builder[A, Coll] {
   protected var elems: Coll = empty
   def +=(x: A) { elems = elems + x }
   def clear() { elems = empty }

src/library/scala/collection/generic/Builder.scala

@@ -15,7 +15,7 @@ package scala.collection.generic
  *  to the builder with += and then converting to the required collection type with
  *  `result`.
  */
-trait Builder[-Elem, +To, -From] extends Growable[Elem] {
+trait Builder[-Elem, +To] extends Growable[Elem] {
 
   /** Adds a single element to the builder.
    *  @param elem The element to be added
@@ -39,8 +39,8 @@ trait Builder[-Elem, +To, -From] extends Growable[Elem] {
    *  a given function is applied to the current builder's result.
    *  @param  f   the function to apply to the builder's result
    */
-  def mapResult[NewTo](f: To => NewTo): Builder[Elem, NewTo, From] =
-    new Builder[Elem, NewTo, From] with Proxy {
+  def mapResult[NewTo](f: To => NewTo): Builder[Elem, NewTo] =
+    new Builder[Elem, NewTo] with Proxy {
       val self = Builder.this
       def +=(x: Elem) = self += x
       def clear() = self.clear()

src/library/scala/collection/generic/BuilderFactory.scala

@@ -15,5 +15,5 @@ package scala.collection.generic
 trait BuilderFactory[-Elem, +To, -From] {
 
   /** Creates a new builder */
-  def apply(from: From): Builder[Elem, To, From]
+  def apply(from: From): Builder[Elem, To]
 }

src/library/scala/collection/generic/ImmutableMapBuilder.scala

@@ -18,7 +18,7 @@ package scala.collection.generic
  *  @param empty   The empty element of the collection.
  */
 class ImmutableMapBuilder[A, B, Coll <: immutable.Map[A, B] with MapTemplate[A, B, Coll]](empty: Coll)
-extends Builder[(A, B), Coll, Any] {
+extends Builder[(A, B), Coll] {
   protected var elems: Coll = empty
   def +=(x: (A, B)) { elems = (elems + x).asInstanceOf[Coll] }
   def clear() { elems = empty }

src/library/scala/collection/generic/ImmutableMapFactory.scala

@@ -4,7 +4,7 @@ package scala.collection.generic
  */
 abstract class ImmutableMapFactory[CC[A, +B] <: immutable.Map[A, B] with MapTemplate[A, B, CC[A, B]]] {
 
-  def newBuilder[A, B]: Builder[(A, B), CC[A, B], Any] = new ImmutableMapBuilder[A, B, CC[A, B]](empty[A, B])
+  def newBuilder[A, B]: Builder[(A, B), CC[A, B]] = new ImmutableMapBuilder[A, B, CC[A, B]](empty[A, B])
 
   def empty[A, B]: CC[A, B]
 

src/library/scala/collection/generic/ImmutableMapTemplate.scala

@@ -31,7 +31,7 @@ trait ImmutableMapTemplate[A, +B, +This <: ImmutableMapTemplate[A, B, This] with
   extends MapTemplate[A, B, This] {
 self =>
 
-  override protected[this] def newBuilder: Builder[(A, B), This, Any] = new ImmutableMapBuilder[A, B, This](empty)
+  override protected[this] def newBuilder: Builder[(A, B), This] = new ImmutableMapBuilder[A, B, This](empty)
 
   /** This function transforms all the values of mappings contained
    *  in this map with function <code>f</code>.

src/library/scala/collection/generic/LazyBuilder.scala

@@ -16,7 +16,7 @@ import mutable.ListBuffer
 /** A builder that constructs its result lazily. Iterators or iterables to
  *  be added to this builder with `++=` are not evaluated until `result` is called.
  */
-abstract class LazyBuilder[Elem, +To, -From] extends Builder[Elem, To, From] {
+abstract class LazyBuilder[Elem, +To] extends Builder[Elem, To] {
   /** The different segments of elements to be added to the builder, represented as iterators */
   protected var parts = new ListBuffer[Traversable[Elem]]
   def +=(x: Elem) = { parts += List(x) }

src/library/scala/collection/generic/MutableMapBuilder.scala

@@ -18,7 +18,7 @@ package scala.collection.generic
  *  @param empty   The empty element of the collection.
  */
 class MutableMapBuilder[A, B, Coll <: mutable.Map[A, B] with MapTemplate[A, B, Coll]](empty: Coll)
-extends Builder[(A, B), Coll, Any] {
+extends Builder[(A, B), Coll] {
   protected var elems: Coll = empty
   def +=(x: (A, B)) { elems += x }
   def clear() { elems = empty }

src/library/scala/collection/generic/MutableMapFactory.scala

@@ -4,7 +4,7 @@ package scala.collection.generic
  */
 abstract class MutableMapFactory[CC[A, B] <: mutable.Map[A, B] with MutableMapTemplate[A, B, CC[A, B]]] {
 
-  def newBuilder[A, B]: Builder[(A, B), CC[A, B], Any] = new MutableMapBuilder(empty[A, B])
+  def newBuilder[A, B]: Builder[(A, B), CC[A, B]] = new MutableMapBuilder(empty[A, B])
 
   def empty[A, B]: CC[A, B]
 

src/library/scala/collection/generic/MutableMapTemplate.scala

@@ -29,13 +29,13 @@ package scala.collection.generic
  */
 trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with mutable.Map[A, B]]
   extends MapTemplate[A, B, This]
-     with Builder[(A, B), This, Any]
+     with Builder[(A, B), This]
      with Growable[(A, B)]
      with Shrinkable[A]
      with Cloneable[This]
 { self =>
 
-  override protected[this] def newBuilder: Builder[(A, B), This, Any] = new MutableMapBuilder[A, B, This](empty.asInstanceOf[This]) // !!! concrete overrides abstract problem
+  override protected[this] def newBuilder: Builder[(A, B), This] = new MutableMapBuilder[A, B, This](empty.asInstanceOf[This]) // !!! concrete overrides abstract problem
 
   /** This method allows one to add a new mapping from <code>key</code>
    *  to <code>value</code> to the map. If the map already contains a

src/library/scala/collection/generic/SetBuilder.scala

@@ -18,7 +18,7 @@ package scala.collection.generic
  *  @param empty   The empty element of the collection.
  */
 class SetBuilder[A, Coll <: Addable[A, Coll] with Iterable[A] with IterableTemplate[A, Coll]](empty: Coll)
-extends Builder[A, Coll, Any] {
+extends Builder[A, Coll] {
   protected var elems: Coll = empty
   def +=(x: A) { elems = elems + x }
   def clear() { elems = empty }

src/library/scala/collection/generic/SetFactory.scala

@@ -4,7 +4,7 @@ package scala.collection.generic
  */
 abstract class SetFactory[CC[A] <: Set[A] with SetTemplate[A, CC[A]]] {
 
-  def newBuilder[A]: Builder[A, CC[A], Any] = new AddingBuilder[A, CC[A]](empty[A])
+  def newBuilder[A]: Builder[A, CC[A]] = new AddingBuilder[A, CC[A]](empty[A])
 
   def empty[A]: CC[A]
 

src/library/scala/collection/generic/SetTemplate.scala

@@ -30,7 +30,7 @@ trait SetTemplate[A, +This <: SetTemplate[A, This] with Set[A]] extends Iterable
 
   def empty: This
 
-  override protected[this] def newBuilder: Builder[A, This, Any] = new AddingBuilder[A, This](empty)
+  override protected[this] def newBuilder: Builder[A, This] = new AddingBuilder[A, This](empty)
 
   /** Checks if this set contains element <code>elem</code>.
    *

src/library/scala/collection/generic/TraversableFactory.scala

@@ -6,7 +6,7 @@ abstract class TraversableFactory[CC[A] <: Traversable[A]] {
 
   /** The builder for this kind of collection.
    */
-  def newBuilder[A]: Builder[A, CC[A], Any]
+  def newBuilder[A]: Builder[A, CC[A]]
 
  /** The empty iterable of type CC */
   def empty[A]:  CC[A] = newBuilder[A].result

src/library/scala/collection/generic/TraversableTemplate.scala

@@ -31,7 +31,7 @@ self =>
 
   /** Create a new builder for this traversable type.
    */
-  protected[this] def newBuilder: Builder[A, This, Any]
+  protected[this] def newBuilder: Builder[A, This]
 
   /** Is this collection empty?
    */
@@ -156,7 +156,7 @@ self =>
    *        return a new collection.
    */
   def groupBy[K](f: A => K): Map[K, This] = {
-    var m = Map[K, Builder[A, This, Any]]()
+    var m = Map[K, Builder[A, This]]()
     for (elem <- this) {
       val key = f(elem)
       val bldr = m get key match {

src/library/scala/collection/generic/TraversableView.scala

@@ -18,7 +18,7 @@ import TraversableView.NoBuilder
 trait TraversableView[+A, +Coll <: Traversable[_]] extends TraversableViewTemplate[A, Coll, TraversableView[A, Coll]]
 
 object TraversableView {
-  class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] {
+  class NoBuilder[A] extends Builder[A, Nothing] {
     def +=(elem: A) {}
     def elements: Iterator[A] = Iterator.empty
     def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")

src/library/scala/collection/generic/TraversableViewTemplate.scala

@@ -21,7 +21,7 @@ trait TraversableViewTemplate[+A,
   extends Traversable[A] with TraversableTemplate[A, This] {
 self =>
 
-  override protected[this] def newBuilder: Builder[A, This, Any] =
+  override protected[this] def newBuilder: Builder[A, This] =
     throw new UnsupportedOperationException(this+".newBuilder")
 
   protected def underlying: Coll

src/library/scala/collection/immutable/HashMap.scala

@@ -37,7 +37,7 @@ class HashMap[A, +B] extends Map[A,B] with ImmutableMapTemplate[A, B, HashMap[A,
   protected var deltaSize: Int = _
 
   override def empty = HashMap.empty[A, B]
-  override def mapBuilder[A, B]: Builder[(A, B), HashMap[A, B], Any] = HashMap.newBuilder[A, B]
+  override def mapBuilder[A, B]: Builder[(A, B), HashMap[A, B]] = HashMap.newBuilder[A, B]
 
   def get(key: A): Option[B] = synchronized {
     var m: HashMap[A, _ >: B] = this

src/library/scala/collection/immutable/HashSet.scala

@@ -28,7 +28,7 @@ import generic._
 class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with mutable.FlatHashTable[A] {
 
   override def empty = HashSet.empty
-  override def traversableBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, HashSet[B]] = HashSet.newBuilder[B]
 
   protected var later: HashSet[A] = null
   protected var changedElem: A = _

src/library/scala/collection/immutable/Iterable.scala

@@ -11,13 +11,13 @@ import generic._
  */
 trait Iterable[+A] extends Traversable[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self =>
   override protected[this] def newBuilder = Iterable.newBuilder
-  override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Iterable[B]] = Iterable.newBuilder[B]
 }
 
 /* A factory object for the trait `Iterable` */
 object Iterable extends TraversableFactory[Iterable] {
   type Coll = Iterable[_]
   implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, Iterable[A], Any] = new mutable.ListBuffer
+  def newBuilder[A]: Builder[A, Iterable[A]] = new mutable.ListBuffer
 }
 

src/library/scala/collection/immutable/LinearSequence.scala

@@ -7,11 +7,11 @@ import generic._
  */
 trait LinearSequence[+A] extends Sequence[A] with collection.LinearSequence[A] with LinearSequenceTemplate[A, LinearSequence[A]] {
   override protected[this] def newBuilder = LinearSequence.newBuilder
-  override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, LinearSequence[B]] = LinearSequence.newBuilder[B]
 }
 
 object LinearSequence extends SequenceFactory[LinearSequence] {
   type Coll = LinearSequence[_]
   implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
-  def newBuilder[A]: Builder[A, LinearSequence[A], Any] = new mutable.ListBuffer
+  def newBuilder[A]: Builder[A, LinearSequence[A]] = new mutable.ListBuffer
 }

src/library/scala/collection/immutable/List.scala

@@ -48,7 +48,7 @@ sealed abstract class List[+A] extends LinearSequence[A] with Product with Linea
 
   /** Creates a list buffer as builder for this class */
   override protected[this] def newBuilder = List.newBuilder
-  override def traversableBuilder[B]: Builder[B, List[B], Any] = List.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, List[B]] = List.newBuilder[B]
 
   // New methods in List
 
@@ -490,7 +490,7 @@ object List extends SequenceFactory[List] {
 
   type Coll = List[_]
   implicit def builderFactory[A]: BuilderFactory[A, List[A], Coll] = new BuilderFactory[A, List[A], Coll] { def apply(from: Coll) = new ListBuffer[A] }
-  def newBuilder[A]: Builder[A, List[A], Any] = new ListBuffer[A]
+  def newBuilder[A]: Builder[A, List[A]] = new ListBuffer[A]
 
   override def empty[A]: List[A] = Nil