4 out of 5 spelling bee champs say: Traversable

72 files changed, 409 insertions, 409 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala
index 84d34f62c4..f66cc96e38 100644
--- a/src/compiler/scala/tools/nsc/symtab/Types.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Types.scala
@@ -4479,7 +4479,7 @@ A type's typeSymbol should never be inspected directly.
     "scala.collection.immutable.List",
     "scala.collection.immutable.Nil",
     "scala.collection.Sequence",
-    "scala.collection.Traversible",
+    "scala.collection.Traversable",
     "scala.collection.Iterable",
     "scala.collection.mutable.StringBuilder",
     "scala.collection.Vector",
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala
index 502e7d95f4..501f08b15b 100755
--- a/src/library/scala/collection/Iterable.scala
+++ b/src/library/scala/collection/Iterable.scala
@@ -21,19 +21,19 @@ import generic._
  *  elements contained in the collection. They also provide a method `newBuilder`
  *  which creates a builder for collections of the same kind.
  *
- *  This trait implements Traversible's `foreach` method by stepping through
+ *  This trait implements Traversable's `foreach` method by stepping through
  *  all elements. Subclasses of `Iterable` should re-implement `foreach` with
  *  something more efficient, if possible.
  *
  *  This trait adds methods `elements`, `zip`, `zipAll`, `zipWithIndex`, `sameElements`,
- *  `takeRight`, `dropRight` to the methods inherited from trait `Traversible`.
+ *  `takeRight`, `dropRight` to the methods inherited from trait `Traversable`.
  *
  *  @author Martin Odersky
  *  @version 2.8
  */
-trait Iterable[+A] extends Traversible[A] with IterableTemplate[A, Iterable[A]] {
+trait Iterable[+A] extends Traversable[A] with IterableTemplate[A, Iterable[A]] {
   override protected[this] def newBuilder = Iterable.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
 
   /* The following methods are inherited from trait IterableTemplate
    *
@@ -46,11 +46,11 @@ trait Iterable[+A] extends Traversible[A] with IterableTemplate[A, Iterable[A]]
   */
 }
 
-/** Factory methods and utilities for instances of type Traversible */
-object Iterable extends TraversibleFactory[Iterable] {
+/** Factory methods and utilities for instances of type Traversable */
+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.traversibleBuilder[A] }
+  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 fromOld[A](it: scala.Iterable[A]): Iterable[A] = new Iterable[A] {
diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index d28959d857..efe3148851 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -48,7 +48,7 @@ package scala.collection
  */
 object JavaConversions {
   import java.{ lang => jl, util => ju }
-  import scala.collection.{ generic, immutable, mutable, Traversible }
+  import scala.collection.{ generic, immutable, mutable, Traversable }
   import scala.reflect.Manifest
 
   // Scala => Java
@@ -356,7 +356,7 @@ object JavaConversions {
     def update(i : Int, elem : A) = underlying.set(i, elem)
     def +:(elem : A) = { underlying.subList(0, 0).add(elem) ; this }
     def +=(elem : A) = underlying.add(elem)
-    def insertAll(i : Int, elems : Traversible[A]) = { val ins = underlying.subList(0, i) ;  elems.foreach(ins.add(_)) }
+    def insertAll(i : Int, elems : Traversable[A]) = { val ins = underlying.subList(0, i) ;  elems.foreach(ins.add(_)) }
     def remove(i : Int) = underlying.remove(i)
     def clear = underlying.clear
     def result = this
diff --git a/src/library/scala/collection/LinearSequence.scala b/src/library/scala/collection/LinearSequence.scala
index fc8d5e9a07..e6504376dc 100755
--- a/src/library/scala/collection/LinearSequence.scala
+++ b/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 traversibleBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = 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.traversibleBuilder[A] }
+  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]
 }
diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Sequence.scala
index 18f17d0513..8e099a2d63 100755
--- a/src/library/scala/collection/Sequence.scala
+++ b/src/library/scala/collection/Sequence.scala
@@ -30,13 +30,13 @@ 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 traversibleBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = 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.traversibleBuilder[A] }
+  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]
 
   /** @deprecated use View instead
diff --git a/src/library/scala/collection/Set.scala b/src/library/scala/collection/Set.scala
index 691953bdf1..44d6c159f3 100644
--- a/src/library/scala/collection/Set.scala
+++ b/src/library/scala/collection/Set.scala
@@ -23,14 +23,14 @@ import generic._
  */
 trait Set[A] extends (A => Boolean) with Iterable[A] with SetTemplate[A, Set[A]] {
   def empty = Set.empty
-  override def traversibleBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
 }
 
 /* Factory object for `Set` class */
 object Set extends SetFactory[Set] {
   def empty[A]: Set[A] = immutable.Set.empty[A]
   type Coll = Set[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
 }
 
 /* !!! what to do about this?
diff --git a/src/library/scala/collection/Traversible.scala b/src/library/scala/collection/Traversable.scala
index 886fd1c767..dc29ee4945 100755
--- a/src/library/scala/collection/Traversible.scala
+++ b/src/library/scala/collection/Traversable.scala
@@ -6,7 +6,7 @@
 **                          |/                                          **
 \*                                                                      */
 
-// $Id: Traversible.scala 15188 2008-05-24 15:01:02Z stepancheg $
+// $Id: Traversable.scala 15188 2008-05-24 15:01:02Z stepancheg $
 package scala.collection
 
 // import immutable.{List, Stream, Nil}
@@ -14,7 +14,7 @@ import mutable.{Buffer, ArrayBuffer, ListBuffer}
 import util.control.Breaks._
 import generic._
 
-/** A template trait for traversible collections.
+/** A template trait for traversable collections.
  *
  *  Collection classes mixing in this trait provide a method
  *  <code>foreach</code> which traverses all the
@@ -25,23 +25,23 @@ import generic._
  *  @author Martin Odersky
  *  @version 2.8
  */
-trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] {
-  protected[this] def newBuilder = Traversible.newBuilder
-  def traversibleBuilder[B]: Builder[B, Traversible[B], Any] = Traversible.newBuilder[B]
+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]
 
-  /* The following methods are inherited from TraversibleTemplate
+  /* The following methods are inherited from TraversableTemplate
    *
   override def isEmpty: Boolean
   override def size: Int
   override def hasDefiniteSize
-  override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, Traversible[A]]): That
-  override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, Traversible[A]]): That
-  override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, Traversible[A]]): That
-  override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, Traversible[A]]): That
-  override def filter(p: A => Boolean): Traversible[A]
-  override def remove(p: A => Boolean): Traversible[A]
-  override def partition(p: A => Boolean): (Traversible[A], Traversible[A])
-  override def groupBy[K](f: A => K): Map[K, Traversible[A]]
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, Traversable[A]]): That
+  override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, Traversable[A]]): That
+  override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, Traversable[A]]): That
+  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, Traversable[A]]): That
+  override def filter(p: A => Boolean): Traversable[A]
+  override def remove(p: A => Boolean): Traversable[A]
+  override def partition(p: A => Boolean): (Traversable[A], Traversable[A])
+  override def groupBy[K](f: A => K): Map[K, Traversable[A]]
   override def foreach(f: A => Unit): Unit
   override def forall(p: A => Boolean): Boolean
   override def exists(p: A => Boolean): Boolean
@@ -57,17 +57,17 @@ trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] {
   override def reduceRightOpt[B >: A](op: (A, B) => B): Option[B]
   override def head: A
   override def headOption: Option[A]
-  override def tail: Traversible[A]
+  override def tail: Traversable[A]
   override def last: A
   override def lastOption: Option[A]
-  override def init: Traversible[A]
-  override def take(n: Int): Traversible[A]
-  override def drop(n: Int): Traversible[A]
-  override def slice(from: Int, until: Int): Traversible[A]
-  override def takeWhile(p: A => Boolean): Traversible[A]
-  override def dropWhile(p: A => Boolean): Traversible[A]
-  override def span(p: A => Boolean): (Traversible[A], Traversible[A])
-  override def splitAt(n: Int): (Traversible[A], Traversible[A])
+  override def init: Traversable[A]
+  override def take(n: Int): Traversable[A]
+  override def drop(n: Int): Traversable[A]
+  override def slice(from: Int, until: Int): Traversable[A]
+  override def takeWhile(p: A => Boolean): Traversable[A]
+  override def dropWhile(p: A => Boolean): Traversable[A]
+  override def span(p: A => Boolean): (Traversable[A], Traversable[A])
+  override def splitAt(n: Int): (Traversable[A], Traversable[A])
   override def copyToBuffer[B >: A](dest: Buffer[B])
   override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int)
   override def copyToArray[B >: A](xs: Array[B], start: Int)
@@ -76,7 +76,7 @@ trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] {
   override def toIterable: Iterable[A]
   override def toSequence: Sequence[A]
   override def toStream: Stream[A]
-//  override def sortWith(lt : (A,A) => Boolean): Traversible[A]
+//  override def sortWith(lt : (A,A) => Boolean): Traversable[A]
   override def mkString(start: String, sep: String, end: String): String
   override def mkString(sep: String): String
   override def mkString: String
@@ -86,20 +86,20 @@ trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] {
   override def toString
   override def stringPrefix : String
   override def view
-  override def view(from: Int, until: Int): TraversibleView[A, Traversible[A]]
+  override def view(from: Int, until: Int): TraversableView[A, Traversable[A]]
   */
 }
 
-/** Factory methods and utilities for instances of type Traversible */
-object Traversible extends TraversibleFactory[Traversible] { self =>
+/** Factory methods and utilities for instances of type Traversable */
+object Traversable extends TraversableFactory[Traversable] { self =>
 
-  type Coll = Traversible[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Traversible[A], Coll] = new BuilderFactory[A, Traversible[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
-  def newBuilder[A]: Builder[A, Traversible[A], Any] = immutable.Traversible.newBuilder[A]
+  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]
 
   /** A wrapper class which adds `min` and `max` methods to iterables of an element type that has an Ordering.
    */
-  class ComparableTraversibleOps[A](self: Traversible[A], cmp: Ordering[A]) {
+  class ComparableTraversableOps[A](self: Traversable[A], cmp: Ordering[A]) {
 
     /** Returns the minimal element of the wrapped iterable `self` with respect to the given ordering `cmp` */
     def min: A = {
@@ -122,7 +122,7 @@ object Traversible extends TraversibleFactory[Traversible] { self =>
 
   /** A wrapper class which adds `sum` and `product` methods to iterables of an element type that is `Numeric`.
    */
-  class NumericTraversibleOps[A](self: Traversible[A], num: Numeric[A]) {
+  class NumericTraversableOps[A](self: Traversable[A], num: Numeric[A]) {
 
     /** Returns the sum of all elements of the wrapped iterable `self` with respect to the numeric operations in `num` */
     def sum: A = {
@@ -141,7 +141,7 @@ object Traversible extends TraversibleFactory[Traversible] { self =>
 
   /** A wrapper class which adds `flatten` and `transpose` methods to iterables or iterable element type`.
    */
-  class TraversibleTraversibleOps[This <: Traversible[Traversible[A]], A](self: This) {
+  class TraversableTraversableOps[This <: Traversable[Traversable[A]], A](self: This) {
 
     /** Returns the concatenation of all elements of the wrapped iterable `self` */
     def flatten[That](implicit bf: BuilderFactory[A, That, This]): That = {
@@ -154,7 +154,7 @@ object Traversible extends TraversibleFactory[Traversible] { 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))(Traversible.builderFactory[Builder[A, Row, This]]).toArray
+      val bs: Array[Builder[A, Row, This]] = self.head.map(_ => bf(self))(Traversable.builderFactory[Builder[A, Row, This]]).toArray
       for (xs <- self) {
         var i = 0
         for (x <- xs) {
@@ -170,7 +170,7 @@ object Traversible extends TraversibleFactory[Traversible] { self =>
 
   /** A wrapper class which adds an `unzip` method to iterable whose elements are pairs.
   	*/
-  class PairTraversibleOps[This <: Traversible[(A1, A2)], A1, A2](self: This) {
+  class PairTraversableOps[This <: Traversable[(A1, A2)], A1, A2](self: This) {
 
     /** Returns a pair of iterables consisting of the first, respectively second, component of all
      *  elements in the wrapped iterable `self`.
@@ -187,27 +187,27 @@ object Traversible extends TraversibleFactory[Traversible] { self =>
   }
 
   /** Implicit wrapper conversion of iterables with elements admitting comparison.
-   *  @see ComparableTraversibleOps
+   *  @see ComparableTraversableOps
    */
-  implicit def comparableTraversibleWrapper[A](self: Traversible[A])(implicit cmp: Ordering[A]) =
-    new ComparableTraversibleOps(self, cmp)
+  implicit def comparableTraversableWrapper[A](self: Traversable[A])(implicit cmp: Ordering[A]) =
+    new ComparableTraversableOps(self, cmp)
 
   /** Implicit wrapper conversion of iterables with numeric elements.
-   *  @see NumericTraversibleOps
+   *  @see NumericTraversableOps
    */
-  implicit def numericTraversibleWrapper[A](self: Traversible[A])(implicit num: Numeric[A]) =
-    new NumericTraversibleOps(self, num)
+  implicit def numericTraversableWrapper[A](self: Traversable[A])(implicit num: Numeric[A]) =
+    new NumericTraversableOps(self, num)
 
   /** Implicit wrapper conversion of iterables with iterable elements.
-   *  @see TraversibleTraversibleOps
+   *  @see TraversableTraversableOps
    */
-  implicit def traversibleTraversibleWrapper[This <: Traversible[Traversible[A]], A](self: This) =
-    new TraversibleTraversibleOps[This, A](self) // !!! error if type parameters are omitted
+  implicit def traversableTraversableWrapper[This <: Traversable[Traversable[A]], A](self: This) =
+    new TraversableTraversableOps[This, A](self) // !!! error if type parameters are omitted
 
   /** Implicit wrapper conversion of iterables with pairs as elements.
-   *  @see PairTraversibleOps
+   *  @see PairTraversableOps
    */
-  implicit def pairTraversibleWrapper[This <: Traversible[(A1, A2)], A1, A2](self: This) =
-    new PairTraversibleOps[This, A1, A2](self)
+  implicit def pairTraversableWrapper[This <: Traversable[(A1, A2)], A1, A2](self: This) =
+    new PairTraversableOps[This, A1, A2](self)
 }
 
diff --git a/src/library/scala/collection/TraversibleProxy.scala b/src/library/scala/collection/TraversableProxy.scala
index edff865af2..d452ab709d 100644
--- a/src/library/scala/collection/TraversibleProxy.scala
+++ b/src/library/scala/collection/TraversableProxy.scala
@@ -16,10 +16,10 @@ import generic._
 // Methods could be printed by  cat TraversibeTemplate.scala | egrep '^  (override )?def'
 
 
-/** This trait implements a proxy for traversible objects. It forwards
- *  all calls to a different traversible object
+/** This trait implements a proxy for traversable objects. It forwards
+ *  all calls to a different traversable object
  *
  *  @author  Martin Odersky
  *  @version 2.8
  */
-trait TraversibleProxy[+A] extends Traversible[A] with TraversibleProxyTemplate[A, Traversible[A]]
+trait TraversableProxy[+A] extends Traversable[A] with TraversableProxyTemplate[A, Traversable[A]]
diff --git a/src/library/scala/collection/Vector.scala b/src/library/scala/collection/Vector.scala
index fea38a774e..9010f01a1e 100755
--- a/src/library/scala/collection/Vector.scala
+++ b/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 traversibleBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Vector[B], Any] = 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.traversibleBuilder[A] }
+  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]
 }
diff --git a/src/library/scala/collection/generic/Addable.scala b/src/library/scala/collection/generic/Addable.scala
index ea45be91f3..21215cefac 100755
--- a/src/library/scala/collection/generic/Addable.scala
+++ b/src/library/scala/collection/generic/Addable.scala
@@ -46,7 +46,7 @@ trait Addable[A, +This <: Addable[A, This]] { self =>
    *
    *  @param iter     the iterable object.
    */
-  def ++ (iter: Traversible[A]): This = (thisCollection /: iter) (_ + _)
+  def ++ (iter: Traversable[A]): This = (thisCollection /: iter) (_ + _)
 
   /** Adds a number of elements provided by an iterator
    *  via its <code>elements</code> method and returns
diff --git a/src/library/scala/collection/generic/BufferTemplate.scala b/src/library/scala/collection/generic/BufferTemplate.scala
index a946c2bdb3..139d5f7316 100755
--- a/src/library/scala/collection/generic/BufferTemplate.scala
+++ b/src/library/scala/collection/generic/BufferTemplate.scala
@@ -33,7 +33,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
                    with SequenceTemplate[A, This]
 { self =>
 
-  import collection.{Iterable, Traversible}
+  import collection.{Iterable, Traversable}
 
 // Abstract methods from Vector:
 
@@ -87,7 +87,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  @param iter    the iterable object providing all elements to insert.
    *  @throws   IndexOutofBoundsException if the index is not valid
    */
-  def insertAll(n: Int, iter: Traversible[A])
+  def insertAll(n: Int, iter: Traversable[A])
 
 
   /** Removes the element on a given index position.
@@ -136,7 +136,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *
    *  @param iter  the iterable object.
    */
-  def ++:(iter: Traversible[A]): This = { for (x <- iter) x +: this; thisCollection }
+  def ++:(iter: Traversable[A]): This = { for (x <- iter) x +: this; thisCollection }
 
   /** Prepends a number of elements provided by an iterator
    *  The identity of the buffer is returned.
@@ -157,7 +157,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *
    *  @param iter  the iterable object.
    */
-  def appendAll(iter: Traversible[A]) { this ++= iter }
+  def appendAll(iter: Traversable[A]) { this ++= iter }
 
   /** Prepend given elements to this list.
    *
@@ -171,7 +171,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *
    *  @param iter  the iterable object.
    */
-  def prependAll(iter: Traversible[A]) { iter ++: this }
+  def prependAll(iter: Traversable[A]) { iter ++: this }
 
   /** Prepends a number of elements provided by an iterable object
    *  via its <code>elements</code> method. The identity of the
diff --git a/src/library/scala/collection/generic/Builder.scala b/src/library/scala/collection/generic/Builder.scala
index 675596da2b..686e684cf3 100755
--- a/src/library/scala/collection/generic/Builder.scala
+++ b/src/library/scala/collection/generic/Builder.scala
@@ -45,7 +45,7 @@ trait Builder[-Elem, +To, -From] extends Growable[Elem] {
       def +=(x: Elem) = self += x
       def clear() = self.clear()
       override def ++=(xs: Iterator[Elem]) = self ++= xs
-      override def ++=(xs: Traversible[Elem]) = self ++= xs
+      override def ++=(xs: Traversable[Elem]) = self ++= xs
       def result: NewTo = f(self.result)
     }
 }
diff --git a/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled b/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled
index 70451741f8..7edfc3b25e 100755
--- a/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled
+++ b/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled
@@ -2,7 +2,7 @@ package scala.collection.generic
 
 /** A template for companion objects of Sequence and subclasses thereof.
  */
-abstract class GenericSequenceFactory extends GenericTraversibleFactory {
+abstract class GenericSequenceFactory extends GenericTraversableFactory {
   
   type Coll <: Sequence[_]
   
diff --git a/src/library/scala/collection/generic/GenericTraversibleFactory.scala.disabled b/src/library/scala/collection/generic/GenericTraversableFactory.scala.disabled
index dece49de37..97e3997cba 100755
--- a/src/library/scala/collection/generic/GenericTraversibleFactory.scala.disabled
+++ b/src/library/scala/collection/generic/GenericTraversableFactory.scala.disabled
@@ -1,10 +1,10 @@
 package scala.collection.generic
 
-/** A template for companion objects of Traversible and subclasses thereof.
+/** A template for companion objects of Traversable and subclasses thereof.
  */
-abstract class GenericTraversibleFactory {
+abstract class GenericTraversableFactory {
   
-  type Coll <: Traversible[_]
+  type Coll <: Traversable[_]
 
  /** The empty iterable of type CC */
   def empty[A, That](implicit bf: Coll => Builder[A, That, Coll]): That = apply[A, That]()
@@ -21,7 +21,7 @@ abstract class GenericTraversibleFactory {
    *  @param xss the lists that are to be concatenated
    *  @return the concatenation of all the lists
    */
-  def concat[A, That](xss: Traversible[A]*)(implicit bf: Coll => Builder[A, That, Coll]): That = {
+  def concat[A, That](xss: Traversable[A]*)(implicit bf: Coll => Builder[A, That, Coll]): That = {
     val b = bf(thisCollection)
     for (xs <- Iterable.fromOld(xss))
       b ++= xs
diff --git a/src/library/scala/collection/generic/Growable.scala b/src/library/scala/collection/generic/Growable.scala
index 7c4c52413b..d664a60c19 100755
--- a/src/library/scala/collection/generic/Growable.scala
+++ b/src/library/scala/collection/generic/Growable.scala
@@ -47,7 +47,7 @@ trait Growable[-A] {
    *
    *  @param iter  the iterable object.
    */
-  def ++=(iter: Traversible[A]) { iter foreach += }
+  def ++=(iter: Traversable[A]) { iter foreach += }
 
   /** Clears the collection contents.
    */
diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala
index f783f8c8fd..142edbf509 100755
--- a/src/library/scala/collection/generic/IterableForwarder.scala
+++ b/src/library/scala/collection/generic/IterableForwarder.scala
@@ -25,7 +25,7 @@ import collection.mutable.Buffer
  *  @author  Martin Odersky
  *  @version 2.8
  */
-trait IterableForwarder[+A] extends Iterable[A] with TraversibleForwarder[A] {
+trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] {
 
   /** The iterable object to which calls are forwarded */
   protected def underlying: Iterable[A]
diff --git a/src/library/scala/collection/generic/IterableProxyTemplate.scala b/src/library/scala/collection/generic/IterableProxyTemplate.scala
index 577bfc24da..646cdbee11 100644
--- a/src/library/scala/collection/generic/IterableProxyTemplate.scala
+++ b/src/library/scala/collection/generic/IterableProxyTemplate.scala
@@ -22,7 +22,7 @@ import collection.mutable.Buffer
  *  @author  Martin Odersky
  *  @version 2.8
  */
-trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends IterableTemplate[A, This] with TraversibleProxyTemplate[A, This] {
+trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends IterableTemplate[A, This] with TraversableProxyTemplate[A, This] {
   override def elements: Iterator[A] = self.elements
   override def takeRight(n: Int): This = self.takeRight(n)
   override def dropRight(n: Int): This = self.dropRight(n)
diff --git a/src/library/scala/collection/generic/IterableTemplate.scala b/src/library/scala/collection/generic/IterableTemplate.scala
index e0ec5426a9..2df5b6a048 100755
--- a/src/library/scala/collection/generic/IterableTemplate.scala
+++ b/src/library/scala/collection/generic/IterableTemplate.scala
@@ -20,17 +20,17 @@ import util.control.Breaks._
  *  elements contained in the collection. They also provide a method `newBuilder`
  *  which creates a builder for collections of the same kind.
  *
- *  This trait implements Traversible's `foreach` method by stepping through
+ *  This trait implements Traversable's `foreach` method by stepping through
  *  all elements. Subclasses of `Iterable` should re-implement `foreach` with
  *  something more efficient, if possible.
  *
  *  This trait adds methods `elements`, `sameElements`,
- *  `takeRight`, `dropRight` to the methods inherited from trait `Traversible`.
+ *  `takeRight`, `dropRight` to the methods inherited from trait `Traversable`.
  *
  *  @author Martin Odersky
  *  @version 2.8
  */
-trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends TraversibleTemplate[A, This] { self =>
+trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends TraversableTemplate[A, This] { self =>
 
   /** Creates a new iterator over all elements contained in this
    *  iterable object.
@@ -40,7 +40,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
   def elements: Iterator[A]
 
   /** Apply a function <code>f</code> to all elements of this
-   *  traversible object.
+   *  traversable object.
    *
    *  @param  f   a function that is applied to every element.
    *  @note This method underlies the implementation of most other bulk operations.
@@ -140,7 +140,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
     !these.hasNext && !those.hasNext
   }
 
-  /** Returns a stream with all elements in this traversible object.
+  /** Returns a stream with all elements in this traversable object.
    */
   override def toStream: Stream[A] = elements.toStream
 
@@ -168,7 +168,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
   @deprecated def first: A = head
 
   /** @deprecated use headOption instead
-   *  <code>None</code> if traversible is empty.
+   *  <code>None</code> if traversable is empty.
    */
   @deprecated def firstOption: Option[A] = headOption
 
diff --git a/src/library/scala/collection/generic/IterableView.scala b/src/library/scala/collection/generic/IterableView.scala
index ab36b4550e..18ca7b2494 100755
--- a/src/library/scala/collection/generic/IterableView.scala
+++ b/src/library/scala/collection/generic/IterableView.scala
@@ -8,7 +8,7 @@
 package scala.collection.generic
 
 import Math.MAX_INT
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A base class for views of Iterables.
  *  @author Martin Odersky
@@ -17,6 +17,6 @@ import TraversibleView.NoBuilder
 trait IterableView[+A, +Coll <: Iterable[_]] extends IterableViewTemplate[A, Coll, IterableView[A, Coll]]
 
 object IterableView {
-  type Coll = TraversibleView[_, _]
+  type Coll = TraversableView[_, _]
   implicit def builderFactory[A]: BuilderFactory[A, IterableView[A, Iterable[_]], Coll] = new BuilderFactory[A, IterableView[A, Iterable[_]], Coll] { def apply(from: Coll) = new NoBuilder }
 }
diff --git a/src/library/scala/collection/generic/IterableViewTemplate.scala b/src/library/scala/collection/generic/IterableViewTemplate.scala
index 99b6e23a1a..f120e97ac4 100755
--- a/src/library/scala/collection/generic/IterableViewTemplate.scala
+++ b/src/library/scala/collection/generic/IterableViewTemplate.scala
@@ -8,7 +8,7 @@
 package scala.collection.generic
 
 import Math.MAX_INT
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A base class for views of Iterables.
  *  @author Martin Odersky
@@ -17,7 +17,7 @@ import TraversibleView.NoBuilder
 trait IterableViewTemplate[+A,
                            +Coll <: Iterable[_],
                            +This <: IterableView[A, Coll] with IterableViewTemplate[A, Coll, This]]
-extends Iterable[A] with IterableTemplate[A, This] with TraversibleView[A, Coll] with TraversibleViewTemplate[A, Coll, This]
+extends Iterable[A] with IterableTemplate[A, This] with TraversableView[A, Coll] with TraversableViewTemplate[A, Coll, This]
 { self =>
 
   trait Transformed[+B] extends IterableView[B, Coll] with super.Transformed[B]
@@ -53,9 +53,9 @@ extends Iterable[A] with IterableTemplate[A, This] with TraversibleView[A, Coll]
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
-  protected override def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that }
+  protected override def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected override def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
-  protected override def newFlatMapped[B](f: A => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
+  protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
   protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
   protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
   protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
diff --git a/src/library/scala/collection/generic/LazyBuilder.scala b/src/library/scala/collection/generic/LazyBuilder.scala
index 019827d5ad..fd9ddd33ef 100755
--- a/src/library/scala/collection/generic/LazyBuilder.scala
+++ b/src/library/scala/collection/generic/LazyBuilder.scala
@@ -18,10 +18,10 @@ import mutable.ListBuffer
  */
 abstract class LazyBuilder[Elem, +To, -From] extends Builder[Elem, To, From] {
   /** The different segments of elements to be added to the builder, represented as iterators */
-  protected var parts = new ListBuffer[Traversible[Elem]]
+  protected var parts = new ListBuffer[Traversable[Elem]]
   def +=(x: Elem) = { parts += List(x) }
   override def ++=(xs: Iterator[Elem]) { parts += xs.toStream }
-  override def ++=(xs: Traversible[Elem]) { parts += xs }
+  override def ++=(xs: Traversable[Elem]) { parts += xs }
   def result(): To
   def clear() { parts.clear() }
 }
diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala
index 3a5801c1df..989e29aa0d 100644
--- a/src/library/scala/collection/generic/MutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/MutableMapTemplate.scala
@@ -100,7 +100,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  @param iter     the iterable object.
    */
   //override
-  def ++(iter: Traversible[(A, B)]): this.type = { (this /: iter) (_ + _); this }
+  def ++(iter: Traversable[(A, B)]): this.type = { (this /: iter) (_ + _); this }
 
   /** Adds a number of elements provided by an iterator
    *  via its <code>elements</code> method and returns
diff --git a/src/library/scala/collection/generic/MutableVectorView.scala b/src/library/scala/collection/generic/MutableVectorView.scala
index 4b7ece1dab..ba91e9152c 100755
--- a/src/library/scala/collection/generic/MutableVectorView.scala
+++ b/src/library/scala/collection/generic/MutableVectorView.scala
@@ -11,7 +11,7 @@
 
 package scala.collection.generic
 
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A non-strict projection of an iterable.
  * @author Sean McDirmid
@@ -21,6 +21,6 @@ import TraversibleView.NoBuilder
 trait MutableVectorView[A, +Coll <: mutable.Vector[_]] extends MutableVectorViewTemplate[A, Coll, MutableVectorView[A, Coll]]
 
 object MutableVectorView {
-  type Coll = TraversibleView[_, _]
+  type Coll = TraversableView[_, _]
   implicit def builderFactory[A]: BuilderFactory[A, MutableVectorView[A, mutable.Vector[_]], Coll] = new BuilderFactory[A, MutableVectorView[A, mutable.Vector[_]], Coll] { def apply(from: Coll) = new NoBuilder }
 }
diff --git a/src/library/scala/collection/generic/MutableVectorViewTemplate.scala b/src/library/scala/collection/generic/MutableVectorViewTemplate.scala
index 22b46472c7..e612111e8c 100755
--- a/src/library/scala/collection/generic/MutableVectorViewTemplate.scala
+++ b/src/library/scala/collection/generic/MutableVectorViewTemplate.scala
@@ -11,7 +11,7 @@
 
 package scala.collection.generic
 
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A non-strict projection of an iterable.
  * @author Sean McDirmid
diff --git a/src/library/scala/collection/generic/SequenceFactory.scala b/src/library/scala/collection/generic/SequenceFactory.scala
index cb2762c4d0..b3ae8c7dd2 100755
--- a/src/library/scala/collection/generic/SequenceFactory.scala
+++ b/src/library/scala/collection/generic/SequenceFactory.scala
@@ -2,7 +2,7 @@ package scala.collection.generic
 
 /** A template for companion objects of Sequence and subclasses thereof.
  */
-abstract class SequenceFactory[CC[A] <: Sequence[A]] extends TraversibleFactory[CC] {
+abstract class SequenceFactory[CC[A] <: Sequence[A]] extends TraversableFactory[CC] {
 
   /** This method is called in a pattern match { case Sequence(...) => }.
    *
diff --git a/src/library/scala/collection/generic/SequenceView.scala b/src/library/scala/collection/generic/SequenceView.scala
index 56b15ac7dc..f9c26093cf 100755
--- a/src/library/scala/collection/generic/SequenceView.scala
+++ b/src/library/scala/collection/generic/SequenceView.scala
@@ -12,7 +12,7 @@
 package scala.collection.generic
 
 import Sequence.fill
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A non-strict projection of an iterable.
  * @author Sean McDirmid
@@ -22,7 +22,7 @@ import TraversibleView.NoBuilder
 trait SequenceView[+A, +Coll <: Sequence[_]] extends SequenceViewTemplate[A, Coll, SequenceView[A, Coll]]
 
 object SequenceView {
-  type Coll = TraversibleView[_, _]
+  type Coll = TraversableView[_, _]
   implicit def builderFactory[A]: BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] = new BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] { def apply(from: Coll) = new NoBuilder }
 }
 
diff --git a/src/library/scala/collection/generic/SequenceViewTemplate.scala b/src/library/scala/collection/generic/SequenceViewTemplate.scala
index 39283763ea..943fd9a80e 100755
--- a/src/library/scala/collection/generic/SequenceViewTemplate.scala
+++ b/src/library/scala/collection/generic/SequenceViewTemplate.scala
@@ -12,7 +12,7 @@
 package scala.collection.generic
 
 import Sequence.fill
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A non-strict projection of an iterable.
  * @author Sean McDirmid
@@ -133,9 +133,9 @@ trait SequenceViewTemplate[+A,
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
-  protected override def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that }
+  protected override def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected override def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
-  protected override def newFlatMapped[B](f: A => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
+  protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
   protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
   protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
   protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
diff --git a/src/library/scala/collection/generic/Shrinkable.scala b/src/library/scala/collection/generic/Shrinkable.scala
index 1c4987b90b..937ec2097e 100755
--- a/src/library/scala/collection/generic/Shrinkable.scala
+++ b/src/library/scala/collection/generic/Shrinkable.scala
@@ -46,7 +46,7 @@ trait Shrinkable[-A] {
    *
    *  @param iter  the iterable object.
    */
-  def --=(iter: Traversible[A]) { iter foreach -= }
+  def --=(iter: Traversable[A]) { iter foreach -= }
 }
 
 
diff --git a/src/library/scala/collection/generic/Subtractable.scala b/src/library/scala/collection/generic/Subtractable.scala
index 498b2faf5c..928ef939ae 100755
--- a/src/library/scala/collection/generic/Subtractable.scala
+++ b/src/library/scala/collection/generic/Subtractable.scala
@@ -46,7 +46,7 @@ trait Subtractable[A, +This <: Subtractable[A, This]] { self =>
    *
    *  @param iter     the iterable object.
    */
-  def --(iter: Traversible[A]): This = (thisCollection /: iter) (_ - _)
+  def --(iter: Traversable[A]): This = (thisCollection /: iter) (_ - _)
 
   /** Removes a number of elements provided by an iterator
    *  via its <code>elements</code> method and returns
diff --git a/src/library/scala/collection/generic/TraversibleFactory.scala b/src/library/scala/collection/generic/TraversableFactory.scala
index 7d054c1b81..244e0859a1 100755
--- a/src/library/scala/collection/generic/TraversibleFactory.scala
+++ b/src/library/scala/collection/generic/TraversableFactory.scala
@@ -1,8 +1,8 @@
  package scala.collection.generic
 
-/** A template for companion objects of Traversible and subclasses thereof.
+/** A template for companion objects of Traversable and subclasses thereof.
  */
-abstract class TraversibleFactory[CC[A] <: Traversible[A]] {
+abstract class TraversableFactory[CC[A] <: Traversable[A]] {
 
   /** The builder for this kind of collection.
    */
@@ -23,7 +23,7 @@ abstract class TraversibleFactory[CC[A] <: Traversible[A]] {
    *  @param xss the collections that are to be concatenated
    *  @return the concatenation of all the collections
    */
-  def concat[A](xss: Traversible[A]*): CC[A] = {
+  def concat[A](xss: Traversable[A]*): CC[A] = {
     val b = newBuilder[A]
     for (xs <- xss) b ++= xs
     b.result
diff --git a/src/library/scala/collection/generic/TraversibleForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala
index 855289d36c..219021f8e6 100755
--- a/src/library/scala/collection/generic/TraversibleForwarder.scala
+++ b/src/library/scala/collection/generic/TraversableForwarder.scala
@@ -14,22 +14,22 @@ package scala.collection.generic
 import mutable.Buffer
 // import immutable.{List, Nil, ::, Stream}
 
-/** This trait implements a forwarder for traversible objects. It forwards
+/** This trait implements a forwarder for traversable objects. It forwards
  *  all calls to a different iterable object, except for
  *
  *    - toString, hashCode, equals, stringPrefix
  *    - newBuilder, view
  *    - all calls creating a new iterable object of the same kind
  *
- *  The above methods are forwarded by subclass TraversibleProxy
+ *  The above methods are forwarded by subclass TraversableProxy
  *
  *  @author  Martin Odersky
  *  @version 2.8
  */
-trait TraversibleForwarder[+A] extends Traversible[A] {
+trait TraversableForwarder[+A] extends Traversable[A] {
 
   /** The iterable object to which calls are forwarded */
-  protected def underlying: Traversible[A]
+  protected def underlying: Traversable[A]
 
   // Iterable delegates
   // Iterable methods could be printed by  cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^  (override )?def'
diff --git a/src/library/scala/collection/generic/TraversibleProxyTemplate.scala b/src/library/scala/collection/generic/TraversableProxyTemplate.scala
index 0c17aa4121..0cd955d50a 100755
--- a/src/library/scala/collection/generic/TraversibleProxyTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableProxyTemplate.scala
@@ -16,22 +16,22 @@ import collection.mutable.Buffer
 // Methods could be printed by  cat TraversibeTemplate.scala | egrep '^  (override )?def'
 
 
-/** This trait implements a proxy for traversible objects. It forwards
- *  all calls to a different traversible object
+/** This trait implements a proxy for traversable objects. It forwards
+ *  all calls to a different traversable object
  *
  *  @author  Martin Odersky
  *  @version 2.8
  */
-trait TraversibleProxyTemplate[+A, +This <: TraversibleTemplate[A, This] with Traversible[A]] extends TraversibleTemplate[A, This] with Proxy {
+trait TraversableProxyTemplate[+A, +This <: TraversableTemplate[A, This] with Traversable[A]] extends TraversableTemplate[A, This] with Proxy {
   def self: This
 
   override def isEmpty: Boolean = self.isEmpty
   override def size: Int = self.size
   override def hasDefiniteSize = self.hasDefiniteSize
-  override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf)
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf)
   override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf)
   override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, This]): That = self.map(f)(bf)
-  override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = self.flatMap(f)(bf)
+  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = self.flatMap(f)(bf)
   override def filter(p: A => Boolean): This = self.filter(p)
   override def remove(p: A => Boolean): This = self.remove(p)
   override def partition(p: A => Boolean): (This, This) = self.partition(p)
@@ -80,5 +80,5 @@ trait TraversibleProxyTemplate[+A, +This <: TraversibleTemplate[A, This] with Tr
   override def toString = self.toString
   override def stringPrefix : String = self.stringPrefix
   override def view = self.view
-  override def view(from: Int, until: Int): TraversibleView[A, This] = self.view(from, until)
+  override def view(from: Int, until: Int): TraversableView[A, This] = self.view(from, until)
 }
diff --git a/src/library/scala/collection/generic/TraversibleTemplate.scala b/src/library/scala/collection/generic/TraversableTemplate.scala
index 2ec74ba874..7378abda51 100755
--- a/src/library/scala/collection/generic/TraversibleTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableTemplate.scala
@@ -6,14 +6,14 @@
 **                          |/                                          **
 \*                                                                      */
 
-// $Id: Traversible.scala 15188 2008-05-24 15:01:02Z stepancheg $
+// $Id: Traversable.scala 15188 2008-05-24 15:01:02Z stepancheg $
 package scala.collection.generic
 
 // import immutable.{List, Stream, Nil} //!!!
 import mutable.{Buffer, ArrayBuffer, ListBuffer}
 import util.control.Breaks._
 
-/** A template trait for traversible collections.
+/** A template trait for traversable collections.
  *
  *  Collection classes mixing in this trait provide a method
  *  <code>foreach</code> which traverses all the
@@ -24,12 +24,12 @@ import util.control.Breaks._
  *  @author Martin Odersky
  *  @version 2.8
  */
-trait TraversibleTemplate[+A, +This <: TraversibleTemplate[A, This] with Traversible[A]] {
+trait TraversableTemplate[+A, +This <: TraversableTemplate[A, This] with Traversable[A]] {
 self =>
 
   protected def thisCollection: This = this.asInstanceOf[This]
 
-  /** Create a new builder for this traversible type.
+  /** Create a new builder for this traversable type.
    */
   protected[this] def newBuilder: Builder[A, This, Any]
 
@@ -61,19 +61,19 @@ self =>
    */
   def hasDefiniteSize = true
 
-  /** Creates a new traversible of type `That` which contains all elements of this traversible
-   *  followed by all elements of another traversible
+  /** Creates a new traversable of type `That` which contains all elements of this traversable
+   *  followed by all elements of another traversable
    *
-   *  @param that   The traversible to append
+   *  @param that   The traversable to append
    */
-  def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = {
+  def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = {
     val b = bf(thisCollection)
     b ++= thisCollection
     b ++= that
     b.result
   }
 
-  /** Create a new traversible of type `That` which contains all elements of this traversible
+  /** Create a new traversable of type `That` which contains all elements of this traversable
    *  followed by all elements of an iterator
    *
    *  @param that  The iterator to append
@@ -85,13 +85,13 @@ self =>
     b.result
   }
 
-  /** Returns the traversible that results from applying the given function
-   *  <code>f</code> to each element of this traversible and collecing the results
-   *  in an traversible of type `That`.
+  /** Returns the traversable that results from applying the given function
+   *  <code>f</code> to each element of this traversable and collecing the results
+   *  in an traversable of type `That`.
    *
    *  @param f function to apply to each element.
    *  @return  <code>f(a<sub>0</sub>), ..., f(a<sub>n</sub>)</code> if this
-   *           traversible is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>.
+   *           traversable is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>.
    */
   def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, This]): That = {
     val b = bf(thisCollection)
@@ -100,22 +100,22 @@ self =>
   }
 
   /** Applies the given function <code>f</code> to each element of
-   *  this traversible, then concatenates the results in an traversible of type CC.
+   *  this traversable, then concatenates the results in an traversable of type CC.
    *
    *  @param f the function to apply on each element.
    *  @return  <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if
-   *           this traversible is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>.
+   *           this traversable is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>.
    */
-  def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = {
+  def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = {
     val b = bf(thisCollection)
     for (x <- this) b ++= f(x)
     b.result
   }
 
-  /** Returns all the elements of this traversible that satisfy the
+  /** Returns all the elements of this traversable that satisfy the
    *  predicate <code>p</code>. The order of the elements is preserved.
-   *  @param p the predicate used to filter the traversible.
-   *  @return the elements of this traversible satisfying <code>p</code>.
+   *  @param p the predicate used to filter the traversable.
+   *  @return the elements of this traversable satisfying <code>p</code>.
    */
   def filter(p: A => Boolean): This = {
     val b = newBuilder
@@ -124,22 +124,22 @@ self =>
     b.result
   }
 
-  /** Removes all elements of the traversible which satisfy the predicate
+  /** Removes all elements of the traversable which satisfy the predicate
    *  <code>p</code>. This is like <code>filter</code> with the
    *  predicate inversed.
    *
    *  @param p the predicate used to test elements
-   *  @return  the traversible without all elements that satisfy <code>p</code>
+   *  @return  the traversable without all elements that satisfy <code>p</code>
    */
   def remove(p: A => Boolean): This = filter(!p(_))
 
-  /** Partitions this traversible in two traversibles according to a predicate.
+  /** Partitions this traversable in two traversables according to a predicate.
    *
    *  @param p the predicate on which to partition
-   *  @return  a pair of traversibles: the traversible that satisfies the predicate
-   *           <code>p</code> and the traversible that does not.
-   *           The relative order of the elements in the resulting traversibles
-   *           is the same as in the original traversible.
+   *  @return  a pair of traversables: the traversable that satisfies the predicate
+   *           <code>p</code> and the traversable that does not.
+   *           The relative order of the elements in the resulting traversables
+   *           is the same as in the original traversable.
    */
   def partition(p: A => Boolean): (This, This) = {
     val l, r = newBuilder
@@ -147,7 +147,7 @@ self =>
     (l.result, r.result)
   }
 
-  /** Partion this traversible into a map of traversibles
+  /** Partion this traversable into a map of traversables
    *  according to some discriminator function.
    *  @invariant   (xs partition f)(k) = xs filter (x => f(x) == k)
    *
@@ -169,7 +169,7 @@ self =>
   }
 
   /** Apply a function <code>f</code> to all elements of this
-   *  traversible object.
+   *  traversable object.
    *
    *  @param  f   a function that is applied to every element.
    *  @note This method underlies the implementation of most other bulk operations.
@@ -178,7 +178,7 @@ self =>
   def foreach(f: A => Unit): Unit
 
   /** Return true iff the given predicate `p` yields true for all elements
-   *  of this traversible.
+   *  of this traversable.
    *
    *  @note May not terminate for infinite-sized collections.
    *  @param   p     the predicate
@@ -192,7 +192,7 @@ self =>
     result
   }
 
-  /** Return true iff there is an element in this traversible for which the
+  /** Return true iff there is an element in this traversable for which the
    *  given predicate `p` yields true.
    *
    *  @note May not terminate for infinite-sized collections.
@@ -207,7 +207,7 @@ self =>
     result
   }
 
-  /** Count the number of elements in the traversible which satisfy a predicate.
+  /** Count the number of elements in the traversable which satisfy a predicate.
    *
    *  @note Will not terminate for infinite-sized collections.
    *  @param p the predicate for which to count
@@ -221,13 +221,13 @@ self =>
     cnt
   }
 
-  /** Find and return the first element of the traversible object satisfying a
+  /** Find and return the first element of the traversable object satisfying a
    *  predicate, if any.
    *
    *  @note may not terminate for infinite-sized collections.
-   *  @note Might return different results for different runs, unless this traversible is ordered.
+   *  @note Might return different results for different runs, unless this traversable is ordered.
    *  @param p the predicate
-   *  @return an option containing the first element in the traversible object
+   *  @return an option containing the first element in the traversable object
    *  satisfying <code>p</code>, or <code>None</code> if none exists.
    */
   def find(p: A => Boolean): Option[A] = {
@@ -239,15 +239,15 @@ self =>
     result
   }
 
-  /** Combines the elements of this traversible object together using the binary
+  /** Combines the elements of this traversable object together using the binary
    *  function <code>f</code>, from left to right, and starting with
    *  the value <code>z</code>.
    *
    *  @note Will not terminate for infinite-sized collections.
-   *  @note Might return different results for different runs, unless this traversible is ordered, or
+   *  @note Might return different results for different runs, unless this traversable is ordered, or
    *        the operator is associative and commutative.
    *  @return <code>f(... (f(f(z, a<sub>0</sub>), a<sub>1</sub>) ...),
-   *          a<sub>n</sub>)</code> if the traversible is
+   *          a<sub>n</sub>)</code> if the traversable is
    *          <code>[a<sub>0</sub>, a<sub>1</sub>, ..., a<sub>n</sub>]</code>.
    */
   def foldLeft[B](z: B)(op: (B, A) => B): B = {
@@ -258,10 +258,10 @@ self =>
   }
 
   /** Similar to <code>foldLeft</code> but can be used as
-   *  an operator with the order of traversible and zero arguments reversed.
+   *  an operator with the order of traversable and zero arguments reversed.
    *  That is, <code>z /: xs</code> is the same as <code>xs foldLeft z</code>
    *  @note Will not terminate for infinite-sized collections.
-   *  @note Might return different results for different runs, unless this traversible is ordered, or
+   *  @note Might return different results for different runs, unless this traversable is ordered, or
    *        the operator is associative and commutative.
    */
   def /: [B](z: B)(op: (B, A) => B): B = foldLeft(z)(op)
@@ -290,16 +290,16 @@ self =>
    */
   def :\ [B](z: B)(op: (A, B) => B): B = foldRight(z)(op)
 
-  /** Combines the elements of this traversible object together using the binary
+  /** Combines the elements of this traversable object together using the binary
    *  operator <code>op</code>, from left to right
    *  @note Will not terminate for infinite-sized collections.
-   *  @note Might return different results for different runs, unless this traversible is ordered, or
+   *  @note Might return different results for different runs, unless this traversable is ordered, or
    *        the operator is associative and commutative.
    *  @param op  The operator to apply
    *  @return <code>op(... op(a<sub>0</sub>,a<sub>1</sub>), ..., a<sub>n</sub>)</code>
-      if the traversible object has elements
+      if the traversable object has elements
    *          <code>a<sub>0</sub>, a<sub>1</sub>, ..., a<sub>n</sub></code>.
-   *  @throws Predef.UnsupportedOperationException if the traversible object is empty.
+   *  @throws Predef.UnsupportedOperationException if the traversable object is empty.
    */
   def reduceLeft[B >: A](op: (B, A) => B): B = {
     if (isEmpty) throw new UnsupportedOperationException("empty.reduceLeft")
@@ -311,13 +311,13 @@ self =>
     result
   }
 
-  /** Combines the elements of this traversible object together using the binary
+  /** Combines the elements of this traversable object together using the binary
    *  operator <code>op</code>, from left to right
    *  @note Will not terminate for infinite-sized collections.
-   *  @note Might return different results for different runs, unless this traversible is ordered, or
+   *  @note Might return different results for different runs, unless this traversable is ordered, or
    *        the operator is associative and commutative.
    *  @param op  The operator to apply
-   *  @return  If the traversible is non-empty, the result of the operations as an Option, otherwise None.
+   *  @return  If the traversable is non-empty, the result of the operations as an Option, otherwise None.
    */
   def reduceLeftOpt[B >: A](op: (B, A) => B): Option[B] = {
     if (isEmpty) None else Some(reduceLeft(op))
@@ -355,10 +355,10 @@ self =>
     if (isEmpty) None else Some(reduceRight(op))
   }
 
-  /** The first element of this traversible.
+  /** The first element of this traversable.
    *
-   *  @note  Might return different results for different runs, unless this traversible is ordered
-   *  @throws Predef.NoSuchElementException if the traversible is empty.
+   *  @note  Might return different results for different runs, unless this traversable is ordered
+   *  @throws Predef.NoSuchElementException if the traversable is empty.
    */
   def head: A = {
     var result: () => A = () => throw new NoSuchElementException
@@ -371,22 +371,22 @@ self =>
     result()
   }
 
- /** Returns as an option the first element of this traversible
-   *  or <code>None</code> if traversible is empty.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+ /** Returns as an option the first element of this traversable
+   *  or <code>None</code> if traversable is empty.
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def headOption: Option[A] = if (isEmpty) None else Some(head)
 
-  /** An traversible consisting of all elements of this traversible
+  /** An traversable consisting of all elements of this traversable
    *  except the first one.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def tail: This = drop(1)
 
-  /** The last element of this traversible.
+  /** The last element of this traversable.
    *
-   *  @throws Predef.NoSuchElementException if the traversible is empty.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @throws Predef.NoSuchElementException if the traversable is empty.
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def last: A = {
     var lst = head
@@ -395,17 +395,17 @@ self =>
     lst
   }
 
-  /** Returns as an option the last element of this traversible or
-   *  <code>None</code> if traversible is empty.
+  /** Returns as an option the last element of this traversable or
+   *  <code>None</code> if traversable is empty.
    *
    *  @return the last element as an option.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def lastOption: Option[A] = if (isEmpty) None else Some(last)
 
-  /** An traversible consisting of all elements of this traversible except the last one.
+  /** An traversable consisting of all elements of this traversable except the last one.
    *  @throws Predef.UnsupportedOperationException if the stream is empty.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def init: This = {
     if (isEmpty) throw new UnsupportedOperationException("empty.init")
@@ -420,12 +420,12 @@ self =>
     b.result
   }
 
-  /** Return an traversible consisting only of the first <code>n</code>
-   *  elements of this traversible, or else the whole traversible, if it has less
+  /** Return an traversable consisting only of the first <code>n</code>
+   *  elements of this traversable, or else the whole traversable, if it has less
    *  than <code>n</code> elements.
    *
    *  @param n the number of elements to take
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def take(n: Int): This = {
     val b = newBuilder
@@ -440,13 +440,13 @@ self =>
     b.result
   }
 
-  /** Returns this traversible without its <code>n</code> first elements
-   *  If this traversible has less than <code>n</code> elements, the empty
-   *  traversible is returned.
+  /** Returns this traversable without its <code>n</code> first elements
+   *  If this traversable has less than <code>n</code> elements, the empty
+   *  traversable is returned.
    *
    *  @param n the number of elements to drop
-   *  @return  the new traversible
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @return  the new traversable
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def drop(n: Int): This = {
     val b = newBuilder
@@ -458,7 +458,7 @@ self =>
     b.result
   }
 
-  /** A sub-traversible starting at index `from`
+  /** A sub-traversable starting at index `from`
    *  and extending up to (but not including) index `until`.
    *
    *  @note c.slice(from, to)  is equivalent to (but possibly more efficient than)
@@ -466,7 +466,7 @@ self =>
    *
    *  @param from   The index of the first element of the returned subsequence
    *  @param until  The index of the element following the returned subsequence
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def slice(from: Int, until: Int): This = {
     val b = newBuilder
@@ -481,11 +481,11 @@ self =>
     b.result
   }
 
-  /** Returns the longest prefix of this traversible whose elements satisfy
+  /** Returns the longest prefix of this traversable whose elements satisfy
    *  the predicate <code>p</code>.
    *
    *  @param p the test predicate.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def takeWhile(p: A => Boolean): This = {
     val b = newBuilder
@@ -498,11 +498,11 @@ self =>
     b.result
   }
 
-  /** Returns the longest suffix of this traversible whose first element
+  /** Returns the longest suffix of this traversable whose first element
    *  does not satisfy the predicate <code>p</code>.
    *
    *  @param p the test predicate.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def dropWhile(p: A => Boolean): This = {
     val b = newBuilder
@@ -514,13 +514,13 @@ self =>
     b.result
   }
 
- /** Returns a pair consisting of the longest prefix of the traversible whose
-   *  elements all satisfy the given predicate, and the rest of the traversible.
+ /** Returns a pair consisting of the longest prefix of the traversable whose
+   *  elements all satisfy the given predicate, and the rest of the traversable.
    *
    *  @param p the test predicate
-   *  @return  a pair consisting of the longest prefix of the traversible whose
-   *           elements all satisfy <code>p</code>, and the rest of the traversible.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @return  a pair consisting of the longest prefix of the traversable whose
+   *           elements all satisfy <code>p</code>, and the rest of the traversable.
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def span(p: A => Boolean): (This, This) = {
     val l, r = newBuilder
@@ -532,13 +532,13 @@ self =>
     (l.result, r.result)
   }
 
-  /** Split the traversible at a given point and return the two parts thus
+  /** Split the traversable at a given point and return the two parts thus
    *  created.
    *
    *  @param n the position at which to split
-   *  @return  a pair of traversibles composed of the first <code>n</code>
+   *  @return  a pair of traversables composed of the first <code>n</code>
    *           elements, and the other elements.
-   *  @note  Might return different results for different runs, unless this traversible is ordered
+   *  @note  Might return different results for different runs, unless this traversable is ordered
    */
   def splitAt(n: Int): (This, This) = {
     val l, r = newBuilder
@@ -550,7 +550,7 @@ self =>
     (l.result, r.result)
   }
 
-  /** Copy all elements of this traversible to a given buffer
+  /** Copy all elements of this traversable to a given buffer
    *  @note Will not terminate for infinite-sized collections.
    *  @param  dest   The buffer to which elements are copied
    */
@@ -559,8 +559,8 @@ self =>
   }
 
   /** Fills the given array <code>xs</code> with at most `len` elements of
-   *  this traversible starting at position `start`.
-   *  Copying will stop once either the end of the current traversible is reached or
+   *  this traversable starting at position `start`.
+   *  Copying will stop once either the end of the current traversable is reached or
    *  `len` elements have been copied or the end of the array is reached.
    *
    *  @note Will not terminate for infinite-sized collections.
@@ -581,8 +581,8 @@ self =>
   }
 
   /** Fills the given array <code>xs</code> with the elements of
-   *  this traversible starting at position <code>start</code>
-   *  until either the end of the current traversible or the end of array `xs` is reached.
+   *  this traversable starting at position <code>start</code>
+   *  until either the end of the current traversable or the end of array `xs` is reached.
    *
    *  @note Will not terminate for infinite-sized collections.
    *  @param  xs the array to fill.
@@ -593,7 +593,7 @@ self =>
     copyToArray(xs, start, xs.length - start)
   }
 
-  /** Converts this traversible to a fresh Array containing all elements.
+  /** Converts this traversable to a fresh Array containing all elements.
    *  @note  Will not terminate for infinite-sized collections.
    */
   def toArray[B >: A]: Array[B] = {
@@ -602,34 +602,34 @@ self =>
     result
   }
 
-  /** Returns a list with all elements of this traversible object.
+  /** Returns a list with all elements of this traversable object.
    *  @note Will not terminate for infinite-sized collections.
    */
   def toList: List[A] = (new ListBuffer[A] ++ thisCollection).toList
 
-  /** Returns an iterable with all elements in this traversible object.
+  /** Returns an iterable with all elements in this traversable object.
    *  @note Will not terminate for infinite-sized collections.
    */
   def toIterable: Iterable[A] = toStream
 
-  /** Returns a sequence with all elements in this traversible object.
+  /** Returns a sequence with all elements in this traversable object.
    *  @note Will not terminate for infinite-sized collections.
    */
   def toSequence: Sequence[A] = toList
 
-  /** Returns a stream with all elements in this traversible object.
+  /** Returns a stream with all elements in this traversable object.
    */
   def toStream: Stream[A] = toList.toStream
 
-  /** Sort the traversible according to the comparison function
+  /** Sort the traversable according to the comparison function
    *  <code>&lt;(e1: a, e2: a) =&gt; Boolean</code>,
    *  which should be true iff <code>e1</code> is smaller than
    *  <code>e2</code>.
    *  The sort is stable. That is elements that are equal wrt `lt` appear in the
-   *  same order in the sorted traversible as in the original.
+   *  same order in the sorted traversable as in the original.
    *
    *  @param lt the comparison function
-   *  @return   a traversible sorted according to the comparison function
+   *  @return   a traversable sorted according to the comparison function
    *            <code>&lt;(e1: a, e2: a) =&gt; Boolean</code>.
    *  @ex <pre>
    *    List("Steve", "Tom", "John", "Bob")
@@ -645,7 +645,7 @@ self =>
   }
   */
 
-  /** Returns a string representation of this traversible object. The resulting string
+  /** Returns a string representation of this traversable object. The resulting string
    *  begins with the string <code>start</code> and is finished by the string
    *  <code>end</code>. Inside, the string representations of elements (w.r.t.
    *  the method <code>toString()</code>) are separated by the string
@@ -655,29 +655,29 @@ self =>
    *  @param start starting string.
    *  @param sep separator string.
    *  @param end ending string.
-   *  @return a string representation of this traversible object.
+   *  @return a string representation of this traversable object.
    */
   def mkString(start: String, sep: String, end: String): String =
     addString(new StringBuilder(), start, sep, end).toString
 
-  /** Returns a string representation of this traversible object. The string
+  /** Returns a string representation of this traversable object. The string
    *  representations of elements (w.r.t. the method <code>toString()</code>)
    *  are separated by the string <code>sep</code>.
    *
    *  @param sep separator string.
-   *  @return a string representation of this traversible object.
+   *  @return a string representation of this traversable object.
    */
   def mkString(sep: String): String =
     addString(new StringBuilder(), sep).toString
 
-  /** Returns a string representation of this traversible object. The string
+  /** Returns a string representation of this traversable object. The string
    *  representations of elements (w.r.t. the method <code>toString()</code>)
    *  follow each other without any separator string.
    */
   def mkString: String =
     addString(new StringBuilder()).toString
 
-  /** Write all elements of this traversible into given string builder.
+  /** Write all elements of this traversable into given string builder.
    *  The written text begins with the string <code>start</code> and is finished by the string
    *  <code>end</code>. Inside, the string representations of elements (w.r.t.
    *  the method <code>toString()</code>) are separated by the string
@@ -718,14 +718,14 @@ self =>
     string
   }
 
-  /** Creates a view of this traversible @see TraversibleView
+  /** Creates a view of this traversable @see TraversableView
    */
-  def view = new TraversibleView[A, This] {
+  def view = new TraversableView[A, This] {
     protected lazy val underlying = self.thisCollection
     override def foreach(f: A => Unit) = self foreach f
   }
 
-  /** A sub-traversible  starting at index `from`
+  /** A sub-traversable  starting at index `from`
    *  and extending up to (but not including) index `until`.
    *
    *  @param from   The index of the first element of the slice
@@ -736,7 +736,7 @@ self =>
    *  @note  Might return different results for different runs, unless this iterable is ordered
    *  @note view(from, to)  is equivalent to view.slice(from, to)
    */
-  def view(from: Int, until: Int): TraversibleView[A, This] = view.slice(from, until)
+  def view(from: Int, until: Int): TraversableView[A, This] = view.slice(from, until)
 }
 
 
diff --git a/src/library/scala/collection/generic/TraversibleView.scala b/src/library/scala/collection/generic/TraversableView.scala
index 8c45e9690d..19dfc7e447 100755
--- a/src/library/scala/collection/generic/TraversibleView.scala
+++ b/src/library/scala/collection/generic/TraversableView.scala
@@ -8,22 +8,22 @@
 package scala.collection.generic
 
 import Math.MAX_INT
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
-/** A base class for views of Traversible.
+/** A base class for views of Traversable.
  *  Every subclass has to implenment the foreach method
  *  @author Martin Odersky
  *  @version 2.8
  */
-trait TraversibleView[+A, +Coll <: Traversible[_]] extends TraversibleViewTemplate[A, Coll, TraversibleView[A, Coll]]
+trait TraversableView[+A, +Coll <: Traversable[_]] extends TraversableViewTemplate[A, Coll, TraversableView[A, Coll]]
 
-object TraversibleView {
-  class NoBuilder[A] extends Builder[A, Nothing, TraversibleView[_, _]] {
+object TraversableView {
+  class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] {
     def +=(elem: A) {}
     def elements: Iterator[A] = Iterator.empty
-    def result() = throw new UnsupportedOperationException("TraversibleView.Builder.result")
+    def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
     def clear() {}
   }
-  type Coll = TraversibleView[_, _]
-  implicit def builderFactory[A]: BuilderFactory[A, TraversibleView[A, Traversible[_]], Coll] = new BuilderFactory[A, TraversibleView[A, Traversible[_]], Coll] { def apply(from: Coll) = new NoBuilder }
+  type Coll = TraversableView[_, _]
+  implicit def builderFactory[A]: BuilderFactory[A, TraversableView[A, Traversable[_]], Coll] = new BuilderFactory[A, TraversableView[A, Traversable[_]], Coll] { def apply(from: Coll) = new NoBuilder }
 }
diff --git a/src/library/scala/collection/generic/TraversibleView.scala.1 b/src/library/scala/collection/generic/TraversableView.scala.1
index c0999f9b9c..a080c816fe 100755
--- a/src/library/scala/collection/generic/TraversibleView.scala.1
+++ b/src/library/scala/collection/generic/TraversableView.scala.1
@@ -8,15 +8,15 @@
 package scalay.collection.generic
 
 import Math.MAX_INT
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
-/** A base class for views of Traversible.
+/** A base class for views of Traversable.
  *  Every subclass has to implenment the foreach method
  */
-abstract class TraversibleView[+A, +Coll <: Traversible[_]] extends Traversible[A] { 
+abstract class TraversableView[+A, +Coll <: Traversable[_]] extends Traversable[A] { 
 self =>
 
-  type This >: this.type <: TraversibleView[A, Coll] { type This = self.This }
+  type This >: this.type <: TraversableView[A, Coll] { type This = self.This }
   protected val thisCollection: This = this
 
   protected[this] def newBuilder: Builder[A, This, This] = 
@@ -27,7 +27,7 @@ self =>
     b.result()
   }
 
-  trait Transformed[+B] extends TraversibleView[B, Coll]
+  trait Transformed[+B] extends TraversableView[B, Coll]
 
   /** pre: from >= 0  
    */
@@ -59,7 +59,7 @@ self =>
   }
 
   trait FlatMapped[B] extends Transformed[B] {
-    protected[this] val mapping: A => Traversible[B]
+    protected[this] val mapping: A => Traversable[B]
     override def foreach(f: B => Unit) {
       for (x <- self)
         for (y <- mapping(x))
@@ -69,7 +69,7 @@ self =>
   }
 
   trait Appended[B >: A] extends Transformed[B] {
-    protected[this] val rest: Traversible[B]
+    protected[this] val rest: Traversable[B]
     override def foreach(f: B => Unit) {
       for (x <- self) f(x)
       for (x <- rest) f(x)
@@ -109,7 +109,7 @@ self =>
     override def stringPrefix = self.stringPrefix+"D"
   }
   
-  override def ++[B >: A, That](that: Traversible[B])(implicit b: Builder[B, That, This]): That =
+  override def ++[B >: A, That](that: Traversable[B])(implicit b: Builder[B, That, This]): That =
     if (b.isInstanceOf[NoBuilder[_]]) newAppended(that).asInstanceOf[That]
     else super.++[B, That](that)(b) 
  
@@ -119,7 +119,7 @@ self =>
     if (b.isInstanceOf[NoBuilder[_]]) newMapped(f).asInstanceOf[That]
     else super.map[B, That](f)(b) 
 
-  override def flatMap[B, That](f: A => Traversible[B])(implicit b: Builder[B, That, This]): That =
+  override def flatMap[B, That](f: A => Traversable[B])(implicit b: Builder[B, That, This]): That =
     if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That]
     else super.flatMap[B, That](f)(b)
   
@@ -134,12 +134,12 @@ self =>
   override def splitAt(n: Int): (This, This) = (take(n), drop(n))
 }
 
-object TraversibleView {
-  class NoBuilder[A] extends Builder[A, Nothing, TraversibleView[_, _]] {
+object TraversableView {
+  class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] {
     def +=(elem: A) {}
     def elements: Iterator[A] = Iterator.empty
-    def result() = throw new UnsupportedOperationException("TraversibleView.Builder.result")
+    def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
     def clear() {}
   }
-  implicit def implicitBuilder[A]: Builder[A, TraversibleView[A, Traversible[_]], TraversibleView[_, _]] = new NoBuilder
+  implicit def implicitBuilder[A]: Builder[A, TraversableView[A, Traversable[_]], TraversableView[_, _]] = new NoBuilder
 }
diff --git a/src/library/scala/collection/generic/TraversibleViewTemplate.scala b/src/library/scala/collection/generic/TraversableViewTemplate.scala
index 7cb84d5cfc..c235c20360 100755
--- a/src/library/scala/collection/generic/TraversibleViewTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableViewTemplate.scala
@@ -8,17 +8,17 @@
 package scala.collection.generic
 
 import Math.MAX_INT
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
-/** A base class for views of Traversible.
+/** A base class for views of Traversable.
  *  Every subclass has to implenment the foreach method
  *  @author Martin Odersky
  *  @version 2.8
  */
-trait TraversibleViewTemplate[+A,
-                              +Coll <: Traversible[_],
-                              +This <: TraversibleView[A, Coll] with TraversibleViewTemplate[A, Coll, This]]
-  extends Traversible[A] with TraversibleTemplate[A, This] {
+trait TraversableViewTemplate[+A,
+                              +Coll <: Traversable[_],
+                              +This <: TraversableView[A, Coll] with TraversableViewTemplate[A, Coll, This]]
+  extends Traversable[A] with TraversableTemplate[A, This] {
 self =>
 
   override protected[this] def newBuilder: Builder[A, This, Any] =
@@ -32,7 +32,7 @@ self =>
     b.result()
   }
 
-  trait Transformed[+B] extends TraversibleView[B, Coll] {
+  trait Transformed[+B] extends TraversableView[B, Coll] {
     lazy val underlying = self.underlying
   }
 
@@ -66,7 +66,7 @@ self =>
   }
 
   trait FlatMapped[B] extends Transformed[B] {
-    protected[this] val mapping: A => Traversible[B]
+    protected[this] val mapping: A => Traversable[B]
     override def foreach(f: B => Unit) {
       for (x <- self)
         for (y <- mapping(x))
@@ -76,7 +76,7 @@ self =>
   }
 
   trait Appended[B >: A] extends Transformed[B] {
-    protected[this] val rest: Traversible[B]
+    protected[this] val rest: Traversable[B]
     override def foreach(f: B => Unit) {
       for (x <- self) f(x)
       for (x <- rest) f(x)
@@ -119,15 +119,15 @@ self =>
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
-  protected def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that }
+  protected def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
-  protected def newFlatMapped[B](f: A => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
+  protected def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
   protected def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
   protected def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
   protected def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
   protected def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
 
-  override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = {
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = {
     val b = bf(thisCollection)
     if (b.isInstanceOf[NoBuilder[_]]) newAppended(that).asInstanceOf[That]
     else super.++[B, That](that)(bf)
@@ -141,7 +141,7 @@ self =>
     else super.map[B, That](f)(bf)
   }
 
-  override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = {
+  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = {
     val b = bf(thisCollection)
     if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That]
     else super.flatMap[B, That](f)(bf)
diff --git a/src/library/scala/collection/generic/VectorView.scala b/src/library/scala/collection/generic/VectorView.scala
index 5460ac9f70..703a6a7496 100755
--- a/src/library/scala/collection/generic/VectorView.scala
+++ b/src/library/scala/collection/generic/VectorView.scala
@@ -11,7 +11,7 @@
 
 package scala.collection.generic
 
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A non-strict projection of an iterable.
  * @author Sean McDirmid
@@ -21,6 +21,6 @@ import TraversibleView.NoBuilder
 trait VectorView[+A, +Coll <: Vector[_]] extends VectorViewTemplate[A, Coll, VectorView[A, Coll]]
 
 object VectorView {
-  type Coll = TraversibleView[_, _]
+  type Coll = TraversableView[_, _]
   implicit def builderFactory[A]: BuilderFactory[A, VectorView[A, Vector[_]], Coll] = new BuilderFactory[A, VectorView[A, Vector[_]], Coll] { def apply(from: Coll) = new NoBuilder }
 }
diff --git a/src/library/scala/collection/generic/VectorViewTemplate.scala b/src/library/scala/collection/generic/VectorViewTemplate.scala
index e8744a3230..0d21b98691 100755
--- a/src/library/scala/collection/generic/VectorViewTemplate.scala
+++ b/src/library/scala/collection/generic/VectorViewTemplate.scala
@@ -11,7 +11,7 @@
 
 package scala.collection.generic
 
-import TraversibleView.NoBuilder
+import TraversableView.NoBuilder
 
 /** A non-strict projection of an iterable.
  * @author Sean McDirmid
@@ -66,9 +66,9 @@ trait VectorViewTemplate[+A,
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
-  protected override def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that }
+  protected override def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected override def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
-  protected override def newFlatMapped[B](f: A => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
+  protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
   protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
   protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
   protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala
index d5ee878c76..281ae45a60 100644
--- a/src/library/scala/collection/immutable/HashSet.scala
+++ b/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 traversibleBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B]
 
   protected var later: HashSet[A] = null
   protected var changedElem: A = _
@@ -132,7 +132,7 @@ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with mutable.Fla
   */
 object HashSet extends SetFactory[HashSet] {
   type Coll = HashSet[_]
-  implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def empty[A]: HashSet[A] = new HashSet
 }
 
diff --git a/src/library/scala/collection/immutable/Iterable.scala b/src/library/scala/collection/immutable/Iterable.scala
index 602ee1fffb..70eea1db11 100755
--- a/src/library/scala/collection/immutable/Iterable.scala
+++ b/src/library/scala/collection/immutable/Iterable.scala
@@ -9,15 +9,15 @@ import generic._
  *  @autor   Martin Odersky
  *  @version 2.8
  */
-trait Iterable[+A] extends Traversible[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self =>
+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 traversibleBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
 }
 
 /* A factory object for the trait `Iterable` */
-object Iterable extends TraversibleFactory[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.traversibleBuilder[A] }
+  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
 }
 
diff --git a/src/library/scala/collection/immutable/LinearSequence.scala b/src/library/scala/collection/immutable/LinearSequence.scala
index 0508ecca29..7583c8c27b 100755
--- a/src/library/scala/collection/immutable/LinearSequence.scala
+++ b/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 traversibleBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = 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.traversibleBuilder[A] }
+  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
 }
diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala
index 4670539917..503deecf06 100755
--- a/src/library/scala/collection/immutable/List.scala
+++ b/src/library/scala/collection/immutable/List.scala
@@ -25,7 +25,7 @@ import generic.{SequenceFactory, Builder, BuilderFactory, LinearSequenceTemplate
  */
 sealed abstract class List[+A] extends LinearSequence[A] with Product with LinearSequenceTemplate[A, List[A]] {
 
-  import collection.{Iterable, Traversible, Sequence, Vector}
+  import collection.{Iterable, Traversable, Sequence, Vector}
 
   /** Returns true if the list does not contain any elements.
    *  @return <code>true</code>, iff the list is empty.
@@ -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 traversibleBuilder[B]: Builder[B, List[B], Any] = List.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, List[B], Any] = List.newBuilder[B]
 
   // New methods in List
 
@@ -141,9 +141,9 @@ sealed abstract class List[+A] extends LinearSequence[A] with Product with Linea
   // Overridden methods from IterableTemplate or overloaded variants of such methods
 
   /** Create a new list which contains all elements of this list
-   *  followed by all elements of Traversible `that'
+   *  followed by all elements of Traversable `that'
    */
-  override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, List[A]]): That = {
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, List[A]]): That = {
     val b = bf(this)
     if (b.isInstanceOf[ListBuffer[_]]) (this ::: that.toList).asInstanceOf[That]
     else super.++(that)
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index bf56a76f72..9e52b1b93e 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -16,7 +16,7 @@ import generic._
 /** The canonical factory of <a href="ListSet.html">ListSet</a>'s */
 object ListSet extends SetFactory[ListSet] {
   type Coll = ListSet[_]
-  implicit def builderFactory[A]: BuilderFactory[A, ListSet[A], Coll] = new BuilderFactory[A, ListSet[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, ListSet[A], Coll] = new BuilderFactory[A, ListSet[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def empty[A] = new ListSet[A]
 }
 
@@ -41,7 +41,7 @@ class ListSet[A] extends Set[A] with SetTemplate[A, ListSet[A]] { self =>
   override def isEmpty: Boolean = true;
 
   override def empty = ListSet.empty
-  override def traversibleBuilder[B]: Builder[B, ListSet[B], Any] = ListSet.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, ListSet[B], Any] = ListSet.newBuilder[B]
 
   /** Checks if this set contains element <code>elem</code>.
    *
diff --git a/src/library/scala/collection/immutable/Sequence.scala b/src/library/scala/collection/immutable/Sequence.scala
index 5265912e11..03fe64711a 100755
--- a/src/library/scala/collection/immutable/Sequence.scala
+++ b/src/library/scala/collection/immutable/Sequence.scala
@@ -14,13 +14,13 @@ import generic._
  */
 trait Sequence[+A] extends Iterable[A] with collection.Sequence[A] with SequenceTemplate[A, Sequence[A]] {
   override protected[this] def newBuilder = Sequence.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B]
   override def hashCode = (Sequence.hashSeed /: this)(_ * 41 + _.hashCode)
 }
 
 object Sequence extends SequenceFactory[Sequence] {
   private val hashSeed = "Sequence".hashCode
   type Coll = Sequence[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  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] = new mutable.ListBuffer
 }
diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala
index 5819d38e03..f9f79db632 100644
--- a/src/library/scala/collection/immutable/Set.scala
+++ b/src/library/scala/collection/immutable/Set.scala
@@ -21,13 +21,13 @@ trait Set[A] extends Iterable[A] with collection.Set[A] with SetTemplate[A, Set[
 
   override def hashCode = (Set.hashSeed /: this)(_ * 41 + _.hashCode)
 
-  override def traversibleBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
 }
 
 object Set extends SetFactory[Set] {
   private val hashSeed = "Set".hashCode
   type Coll = Set[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def empty[A]: Set[A] = FlexSet.empty
 }
 
diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala
index 07ff59100f..7be6635853 100644
--- a/src/library/scala/collection/immutable/Stack.scala
+++ b/src/library/scala/collection/immutable/Stack.scala
@@ -68,14 +68,14 @@ class Stack[+A] extends Sequence[A] {
   def pushAll[B >: A](elems: Iterator[B]): Stack[B] =
     ((this: Stack[B]) /: elems)(_ push _)
 
-  /** Push all elements provided by the given traversible object onto
+  /** Push all elements provided by the given traversable object onto
    *  the stack. The last element returned by the iterable object
    *  will be on top of the new stack.
    *
    *  @param   elems      the iterable object.
    *  @return the stack with the new elements on top.
    */
-  def pushAll[B >: A](elems: collection.Traversible[B]): Stack[B] =
+  def pushAll[B >: A](elems: collection.Traversable[B]): Stack[B] =
     ((this: Stack[B]) /: elems)(_ push _)
 
   /** Returns the top element of the stack. An error is signaled if
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 656252c282..20e71181e7 100755
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -37,7 +37,7 @@ import generic.{SequenceFactory, Builder, BuilderFactory, LazyBuilder, LinearSeq
  */
 abstract class Stream[+A] extends LinearSequence[A] with LinearSequenceTemplate[A, Stream[A]] {
 self =>
-  import collection.{Traversible, Iterable, Sequence, Vector}
+  import collection.{Traversable, Iterable, Sequence, Vector}
 
   /** is this stream empty? */
   def isEmpty: Boolean
@@ -55,22 +55,22 @@ self =>
   /** Is the tail of this stream defined? */
   protected def tailDefined: Boolean
 
-  // Implementation of abstract method in Traversible
+  // Implementation of abstract method in Traversable
 
   /** The builder for stream objects.
    *  @note: This builder is lazy only in the sense that it does not go downs the spine
-   *         of traversibles taht are added as a whole. If more layzness can be achieved,
+   *         of traversables taht are added as a whole. If more layzness can be achieved,
    *         this builder should be bypassed.
    */
   override protected[this] def newBuilder = Stream.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Stream[B], Any] = Stream.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Stream[B], Any] = Stream.newBuilder[B]
 
   // New methods in Stream
 
   /** The stream resulting from the concatenation of this stream with the argument stream.
    *  @param rest   The stream that gets appended to this stream
    */
-  def append[B >: A](rest: => Traversible[B]): Stream[B] =
+  def append[B >: A](rest: => Traversable[B]): Stream[B] =
     if (isEmpty) rest.toStream else new Stream.Cons(head, tail append rest)
 
   /** Force evaluation of the whole stream and return it */
@@ -102,7 +102,7 @@ self =>
     loop(this, "")
   }
 
-  // Overridden methods from Traversible
+  // Overridden methods from Traversable
 
   override def toStream: Stream[A] = this
 
@@ -112,13 +112,13 @@ self =>
   }
 
   /** Create a new stream which contains all elements of this stream
-   *  followed by all elements of Traversible `that'
+   *  followed by all elements of Traversable `that'
    *  @note It's subtle why this works. We know that if the target type
    *  of the Builder That is either a Stream, or one of its supertypes, or undefined,
    *  then StreamBuilder will be chosen for the implicit.
    *  we recognize that fact and optimize to get more laziness.
    */
-  override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = {
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = {
     def loop(these: Stream[A]): Stream[B] =
       if (these.isEmpty) that.toStream else new Stream.Cons(these.head, loop(these.tail))
     if (bf.isInstanceOf[Stream.StreamBuilderFactory[_]]) loop(this).asInstanceOf[That]
@@ -152,7 +152,7 @@ self =>
    *  @return  <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if
    *           this stream is <code>[a<sub>0</sub>, ..., a<sub>n</sub>]</code>.
    */
-  override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = {
+  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = {
     def loop(these: Stream[A]): Stream[B] =
       if (these.isEmpty) Stream.Empty
       else {
@@ -368,7 +368,7 @@ self =>
 object Stream extends SequenceFactory[Stream] {
 
   type Coll = Stream[_]
-  class StreamBuilderFactory[A] extends BuilderFactory[A, Stream[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  class StreamBuilderFactory[A] extends BuilderFactory[A, Stream[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   implicit def builderFactory[A]: BuilderFactory[A, Stream[A], Coll] = new StreamBuilderFactory[A]
 
   /** Creates a new builder for a stream */
diff --git a/src/library/scala/collection/immutable/Traversable.scala b/src/library/scala/collection/immutable/Traversable.scala
new file mode 100755
index 0000000000..7adc2c3c6c
--- /dev/null
+++ b/src/library/scala/collection/immutable/Traversable.scala
@@ -0,0 +1,24 @@
+package scala.collection.immutable
+
+import generic._
+
+/** A subtrait of Traversable in package collection which represents traversables
+ *  that cannot be mutated.
+ *  !!! todo: revise equality
+ *  @author  Matthias Zenger
+ *  @autor   Martin Odersky
+ *  @version 2.8
+ */
+trait Traversable[+A] extends collection.Traversable[A] with TraversableTemplate[A, Traversable[A]] with Immutable { self =>
+  override protected[this] def newBuilder = Traversable.newBuilder
+  override def traversableBuilder[B]: Builder[B, Traversable[B], Any] = Traversable.newBuilder[B]
+}
+
+/* A factory object for the trait `Traversable` */
+object Traversable extends TraversableFactory[Traversable] {
+  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] = new mutable.ListBuffer
+}
+
+
diff --git a/src/library/scala/collection/immutable/Traversible.scala b/src/library/scala/collection/immutable/Traversible.scala
deleted file mode 100755
index 5236f59681..0000000000
--- a/src/library/scala/collection/immutable/Traversible.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-package scala.collection.immutable
-
-import generic._
-
-/** A subtrait of Traversible in package collection which represents traversibles
- *  that cannot be mutated.
- *  !!! todo: revise equality
- *  @author  Matthias Zenger
- *  @autor   Martin Odersky
- *  @version 2.8
- */
-trait Traversible[+A] extends collection.Traversible[A] with TraversibleTemplate[A, Traversible[A]] with Immutable { self =>
-  override protected[this] def newBuilder = Traversible.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Traversible[B], Any] = Traversible.newBuilder[B]
-}
-
-/* A factory object for the trait `Traversible` */
-object Traversible extends TraversibleFactory[Traversible] {
-  type Coll = Traversible[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Traversible[A], Coll] = new BuilderFactory[A, Traversible[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
-  def newBuilder[A]: Builder[A, Traversible[A], Any] = new mutable.ListBuffer
-}
-
-
diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala
index 7bb76c5518..5267683d1f 100755
--- a/src/library/scala/collection/immutable/Vector.scala
+++ b/src/library/scala/collection/immutable/Vector.scala
@@ -15,7 +15,7 @@ import mutable.ArrayBuffer
  */
 trait Vector[+A] extends Sequence[A] with collection.Vector[A] with VectorTemplate[A, Vector[A]] { self =>
   override protected[this] def newBuilder = Vector.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B]
 }
 
 object Vector extends SequenceFactory[Vector] {
@@ -24,6 +24,6 @@ object Vector extends SequenceFactory[Vector] {
     def length = buf.length
     def apply(idx: Int) = buf.apply(idx)
   }
-  implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  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] = new ArrayBuffer[A] mapResult (buf => new Impl(buf))
 }
diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala
index 82864cc7ee..a6e37a1449 100644
--- a/src/library/scala/collection/mutable/ArrayBuffer.scala
+++ b/src/library/scala/collection/mutable/ArrayBuffer.scala
@@ -30,7 +30,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
      with Builder[A, ArrayBuffer[A], Any]
      with ResizableArray[A] {
 
-  import collection.Traversible
+  import collection.Traversable
 
   def this() = this(16)
 
@@ -43,7 +43,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
   }
 
   override protected[this] def newBuilder = ArrayBuffer.newBuilder
-  override def traversibleBuilder[B]: Builder[B, ArrayBuffer[B], Any] = ArrayBuffer.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, ArrayBuffer[B], Any] = ArrayBuffer.newBuilder[B]
 
   /** Appends a single element to this buffer and returns
    *  the identity of the buffer. It takes constant time.
@@ -63,7 +63,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
    *  @param iter  the iterfable object.
    *  @return      the updated buffer.
    */
-  override def ++=(iter: Traversible[A]) = iter match {
+  override def ++=(iter: Traversable[A]) = iter match {
     case v: Vector[_] =>
       val n = v.length
       ensureSize(size0 + n)
@@ -95,7 +95,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
    *  @param iter  the iterable object.
    *  @return      the updated buffer.
    */
-  override def ++:(iter: Traversible[A]): this.type = { insertAll(0, iter); this }
+  override def ++:(iter: Traversable[A]): this.type = { insertAll(0, iter); this }
 
   /** Inserts new elements at the index <code>n</code>. Opposed to method
    *  <code>update</code>, this method will not replace an element with a
@@ -105,7 +105,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
    *  @param iter  the iterable object providing all elements to insert.
    *  @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
    */
-  def insertAll(n: Int, seq: Traversible[A]) {
+  def insertAll(n: Int, seq: Traversable[A]) {
     if ((n < 0) || (n > size0))
       throw new IndexOutOfBoundsException(n.toString)
     val xs = seq.toList
@@ -158,7 +158,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
 /* Factory object for `ArrayBuffer` class */
 object ArrayBuffer extends SequenceFactory[ArrayBuffer] {
   type Coll = ArrayBuffer[_]
-  implicit def builderFactory[A]: BuilderFactory[A, ArrayBuffer[A], Coll] = new BuilderFactory[A, ArrayBuffer[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, ArrayBuffer[A], Coll] = new BuilderFactory[A, ArrayBuffer[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def newBuilder[A]: Builder[A, ArrayBuffer[A], Any] = new ArrayBuffer[A]
 }
 
diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala
index 5fed53ae04..e020be6d6f 100644
--- a/src/library/scala/collection/mutable/Buffer.scala
+++ b/src/library/scala/collection/mutable/Buffer.scala
@@ -25,13 +25,13 @@ import generic._
 @cloneable
 trait Buffer[A] extends Sequence[A] with BufferTemplate[A, Buffer[A]] {
   override protected[this] def newBuilder = Buffer.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Buffer[B], Any] = Buffer.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Buffer[B], Any] = Buffer.newBuilder[B]
 }
 
 /* Factory object for `Buffer` trait */
 object Buffer extends SequenceFactory[Buffer] {
   type Coll = Buffer[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Buffer[A], Coll] = new BuilderFactory[A, Buffer[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, Buffer[A], Coll] = new BuilderFactory[A, Buffer[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def newBuilder[A]: Builder[A, Buffer[A], Any] = new ArrayBuffer
 }
 
diff --git a/src/library/scala/collection/mutable/DoubleLinkedList.scala b/src/library/scala/collection/mutable/DoubleLinkedList.scala
index 6b8174357a..4463ab55a5 100644
--- a/src/library/scala/collection/mutable/DoubleLinkedList.scala
+++ b/src/library/scala/collection/mutable/DoubleLinkedList.scala
@@ -23,12 +23,12 @@ import generic._
 @serializable
 class DoubleLinkedList[A]/*(_elem: A, _next: DoubleLinkedList[A])*/ extends LinearSequence[A] with DoubleLinkedListTemplate[A, DoubleLinkedList[A]] {
   override protected[this] def newBuilder = DoubleLinkedList.newBuilder
-  override def traversibleBuilder[B]: Builder[B, DoubleLinkedList[B], Any] = DoubleLinkedList.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, DoubleLinkedList[B], Any] = DoubleLinkedList.newBuilder[B]
 }
 
 object DoubleLinkedList extends SequenceFactory[DoubleLinkedList] {
   type Coll = DoubleLinkedList[_]
-  implicit def builderFactory[A]: BuilderFactory[A, DoubleLinkedList[A], Coll] = new BuilderFactory[A, DoubleLinkedList[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, DoubleLinkedList[A], Coll] = new BuilderFactory[A, DoubleLinkedList[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def newBuilder[A]: Builder[A, DoubleLinkedList[A], Any] = null // !!!
 }
 
diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala
index 14f2d00013..b849f8f731 100644
--- a/src/library/scala/collection/mutable/HashSet.scala
+++ b/src/library/scala/collection/mutable/HashSet.scala
@@ -23,7 +23,7 @@ import generic._
 class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with FlatHashTable[A] {
 
   override def empty = HashSet.empty
-  override def traversibleBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B]
 
   override def size = super.size
 
@@ -51,7 +51,7 @@ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with FlatHashTab
 /** Factory object for `HashSet` class */
 object HashSet extends SetFactory[HashSet] {
   type Coll = HashSet[_]
-  implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def empty[A]: HashSet[A] = new HashSet[A]
 }
 
diff --git a/src/library/scala/collection/mutable/Iterable.scala b/src/library/scala/collection/mutable/Iterable.scala
index 52a42c5e09..f45f077cfd 100755
--- a/src/library/scala/collection/mutable/Iterable.scala
+++ b/src/library/scala/collection/mutable/Iterable.scala
@@ -15,15 +15,15 @@ import generic._
  *  @autor   Martin Odersky
  *  @version 2.8
  */
-trait Iterable[A] extends Traversible[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self =>
+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 traversibleBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B]
 }
 
 /* A factory object for the trait `Iterable` */
-object Iterable extends TraversibleFactory[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.traversibleBuilder[A] }
+  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 ArrayBuffer
 }
 
diff --git a/src/library/scala/collection/mutable/LinearSequence.scala b/src/library/scala/collection/mutable/LinearSequence.scala
index d31da40386..01f38cbe54 100755
--- a/src/library/scala/collection/mutable/LinearSequence.scala
+++ b/src/library/scala/collection/mutable/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 traversibleBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = 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.traversibleBuilder[A] }
+  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 MutableList[A]
 }
diff --git a/src/library/scala/collection/mutable/LinkedList.scala b/src/library/scala/collection/mutable/LinkedList.scala
index 8c8ebd3b0f..cba50294df 100644
--- a/src/library/scala/collection/mutable/LinkedList.scala
+++ b/src/library/scala/collection/mutable/LinkedList.scala
@@ -25,12 +25,12 @@ class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSequence[A] wi
   elem = _elem
   next = _next
   override protected[this] def newBuilder = LinkedList.newBuilder
-  override def traversibleBuilder[B]: Builder[B, LinkedList[B], Any] = LinkedList.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, LinkedList[B], Any] = LinkedList.newBuilder[B]
 }
 
 object LinkedList extends SequenceFactory[LinkedList] {
   type Coll = LinkedList[_]
-  implicit def builderFactory[A]: BuilderFactory[A, LinkedList[A], Coll] = new BuilderFactory[A, LinkedList[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, LinkedList[A], Coll] = new BuilderFactory[A, LinkedList[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def newBuilder[A]: Builder[A, LinkedList[A], Any] = (new MutableList) mapResult ((l: MutableList[A]) => l.toLinkedList)
 }
 
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index 9374afc3db..5713560ee8 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -28,7 +28,7 @@ final class ListBuffer[A]
          with Builder[A, List[A], Any]
          with SequenceForwarder[A]
 {
-  import collection.Traversible
+  import collection.Traversable
 
   private var start: List[A] = Nil
   private var last0: ::[A] = _
@@ -38,7 +38,7 @@ final class ListBuffer[A]
   protected def underlying: immutable.Sequence[A] = start
 
   override protected[this] def newBuilder = ListBuffer.newBuilder[A]
-  override def traversibleBuilder[B]: Builder[B, ListBuffer[B], Any] = ListBuffer.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, ListBuffer[B], Any] = ListBuffer.newBuilder[B]
 
   /** The current length of the buffer
    */
@@ -131,7 +131,7 @@ final class ListBuffer[A]
    *  @param  iter  the iterable object providing all elements to insert.
    *  @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
    */
-  def insertAll(n: Int, seq: Traversible[A]) {
+  def insertAll(n: Int, seq: Traversable[A]) {
     try {
       if (exported) copy()
       var elems = seq.toList.reverse
@@ -319,7 +319,7 @@ final class ListBuffer[A]
 /* Factory object for `ListBuffer` class */
 object ListBuffer extends SequenceFactory[ListBuffer] {
   type Coll = ListBuffer[_]
-  implicit def builderFactory[A]: BuilderFactory[A, ListBuffer[A], Coll] = new BuilderFactory[A, ListBuffer[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, ListBuffer[A], Coll] = new BuilderFactory[A, ListBuffer[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def newBuilder[A]: Builder[A, ListBuffer[A], Any] = new AddingBuilder(new ListBuffer[A])
 }
 
diff --git a/src/library/scala/collection/mutable/ResizableArray.scala b/src/library/scala/collection/mutable/ResizableArray.scala
index 1d260cc275..0193bdf4b6 100644
--- a/src/library/scala/collection/mutable/ResizableArray.scala
+++ b/src/library/scala/collection/mutable/ResizableArray.scala
@@ -26,7 +26,7 @@ trait ResizableArray[A] extends Vector[A] with VectorTemplate[A, ResizableArray[
   import collection.Iterable // !!!
 
   override protected[this] def newBuilder = ResizableArray.newBuilder
-  override def traversibleBuilder[B]: Builder[B, ResizableArray[B], Any] = ResizableArray.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, ResizableArray[B], Any] = ResizableArray.newBuilder[B]
 
   protected def initialSize: Int = 16
   protected var array: Array[AnyRef] = new Array[AnyRef](initialSize max 1)
@@ -116,6 +116,6 @@ trait ResizableArray[A] extends Vector[A] with VectorTemplate[A, ResizableArray[
 
 object ResizableArray extends SequenceFactory[ResizableArray] {
   type Coll = Vector[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  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, ResizableArray[A], Any] = new ArrayBuffer[A]
 }
diff --git a/src/library/scala/collection/mutable/Sequence.scala b/src/library/scala/collection/mutable/Sequence.scala
index 01293924ac..04beb61535 100755
--- a/src/library/scala/collection/mutable/Sequence.scala
+++ b/src/library/scala/collection/mutable/Sequence.scala
@@ -15,13 +15,13 @@ import generic._
  */
 trait Sequence[A] extends Iterable[A] with collection.Sequence[A] with SequenceTemplate[A, Sequence[A]] with Unhashable {
   override protected[this] def newBuilder = Sequence.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B]
 
   def update(idx: Int, elem: A)
 }
 
 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.traversibleBuilder[A] }
+  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] = new ArrayBuffer
 }
diff --git a/src/library/scala/collection/mutable/Set.scala b/src/library/scala/collection/mutable/Set.scala
index d75b816564..c4b3013ce2 100644
--- a/src/library/scala/collection/mutable/Set.scala
+++ b/src/library/scala/collection/mutable/Set.scala
@@ -34,7 +34,7 @@ self =>
 
   override def empty = Set.empty
 
-  override def traversibleBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B]
 
   /** This method allows one to add or remove an element <code>elem</code>
    *  from this set depending on the value of parameter <code>included</code>.
@@ -108,7 +108,7 @@ self =>
  */
 object Set extends SetFactory[Set] {
   type Coll = Set[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
+  implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] }
   def empty[A]: Set[A] = HashSet.empty[A]
 }
 
diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala
index 0d554e01da..2ad08c68c4 100644
--- a/src/library/scala/collection/mutable/Stack.scala
+++ b/src/library/scala/collection/mutable/Stack.scala
@@ -63,13 +63,13 @@ class Stack[A] private (var elems: List[A]) extends collection.Sequence[A] with
   def pushAll(elems: Iterator[A]): this.type = { for (elem <- elems) { push(elem); () }; this }
 
   /** Push all elements provided by the given iterable object onto
-   *  the stack. The last element returned by the traversible object
+   *  the stack. The last element returned by the traversable object
    *  will be on top of the new stack.
    *
    *  @param   elems      the iterable object.
    *  @return the stack with the new elements on top.
    */
-  def pushAll(elems: collection.Traversible[A]): this.type = { for (elem <- elems) { push(elem); () }; this }
+  def pushAll(elems: collection.Traversable[A]): this.type = { for (elem <- elems) { push(elem); () }; this }
 
   /** @deprecated use pushAll */
   @deprecated def ++=(it: Iterator[A]): Unit = pushAll(it)
diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
index 03978d9d71..66dba50249 100644
--- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala
+++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
@@ -20,7 +20,7 @@ package scala.collection.mutable
  */
 trait SynchronizedBuffer[A] extends Buffer[A] {
 
-  import collection.Traversible
+  import collection.Traversable
 
   abstract override def length: Int = synchronized {
     super.length
@@ -57,7 +57,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
    *
    *  @param iter  the iterable object.
    */
-  override def ++(iter: Traversible[A]): Buffer[A] = synchronized {
+  override def ++(iter: Traversable[A]): Buffer[A] = synchronized {
     super.++(iter)
   }
 
@@ -66,7 +66,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
    *
    *  @param iter  the iterable object.
    */
-  override def ++=(iter: Traversible[A]): Unit = synchronized {
+  override def ++=(iter: Traversable[A]): Unit = synchronized {
     super.++=(iter)
   }
 
@@ -83,7 +83,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
    *
    *  @param iter  the iterable object.
    */
-  override def appendAll(iter: Traversible[A]): Unit = synchronized {
+  override def appendAll(iter: Traversable[A]): Unit = synchronized {
     super.appendAll(iter)
   }
 
@@ -102,7 +102,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
    *
    *  @param iter  the iterable object.
    */
-  override def ++:(iter: Traversible[A]): Buffer[A] = synchronized {
+  override def ++:(iter: Traversable[A]): Buffer[A] = synchronized {
     super.++:(iter)
   }
 
@@ -120,7 +120,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
    *
    *  @param iter  the iterable object.
    */
-  override def prependAll(elems: Traversible[A]): Unit = synchronized {
+  override def prependAll(elems: Traversable[A]): Unit = synchronized {
     super.prependAll(elems)
   }
 
@@ -142,7 +142,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
    *  @param n     the index where a new element will be inserted.
    *  @param iter  the iterable object providing all elements to insert.
    */
-  abstract override def insertAll(n: Int, iter: Traversible[A]): Unit = synchronized {
+  abstract override def insertAll(n: Int, iter: Traversable[A]): Unit = synchronized {
      super.insertAll(n, iter)
   }
 
diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala
index 6ca07f4fa5..6292b0daf0 100644
--- a/src/library/scala/collection/mutable/SynchronizedMap.scala
+++ b/src/library/scala/collection/mutable/SynchronizedMap.scala
@@ -21,7 +21,7 @@ package scala.collection.mutable
  */
 trait SynchronizedMap[A, B] extends Map[A, B] {
 
-  import collection.Traversible
+  import collection.Traversable
 
   override def mapBuilder[A, B]: Builder[(A, B), SynchronizedMap[A, B], Any] = SynchronizedMap.newBuilder[A, B]
 
@@ -86,7 +86,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
     super.+=(kv1, kv2, kvs: _*)
   }
 
-  override def ++=(map: Traversible[(A, B)]): Unit = synchronized {
+  override def ++=(map: Traversable[(A, B)]): Unit = synchronized {
     super.++=(map)
   }
 
@@ -102,7 +102,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
     super.-=(key1, key2, keys: _*)
   }
 
-  override def --=(keys: Traversible[A]): Unit = synchronized {
+  override def --=(keys: Traversable[A]): Unit = synchronized {
     super.--=(keys)
   }
 
diff --git a/src/library/scala/collection/mutable/SynchronizedQueue.scala b/src/library/scala/collection/mutable/SynchronizedQueue.scala
index 7ef88e867f..0b3f870a9f 100644
--- a/src/library/scala/collection/mutable/SynchronizedQueue.scala
+++ b/src/library/scala/collection/mutable/SynchronizedQueue.scala
@@ -20,7 +20,7 @@ package scala.collection.mutable
  *  @version 1.0, 03/05/2004
  */
 class SynchronizedQueue[A] extends Queue[A] {
-  import collection.Traversible
+  import collection.Traversable
 
   /** Checks if the queue is empty.
    *
@@ -40,7 +40,7 @@ class SynchronizedQueue[A] extends Queue[A] {
    *
    *  @param  iter        an iterable object
    */
-  override def ++=(iter: Traversible[A]): Unit = synchronized { super.++=(iter) }
+  override def ++=(iter: Traversable[A]): Unit = synchronized { super.++=(iter) }
 
   /** Adds all elements provided by an iterator
    *  at the end of the queue. The elements are prepended in the order they
diff --git a/src/library/scala/collection/mutable/SynchronizedSet.scala b/src/library/scala/collection/mutable/SynchronizedSet.scala
index f355e5879d..47396fdb84 100644
--- a/src/library/scala/collection/mutable/SynchronizedSet.scala
+++ b/src/library/scala/collection/mutable/SynchronizedSet.scala
@@ -19,7 +19,7 @@ package scala.collection.mutable
  *  @version 1.0, 08/07/2003
  */
 trait SynchronizedSet[A] extends Set[A] {
-  import collection.Traversible
+  import collection.Traversable
 
   abstract override def size: Int = synchronized {
     super.size
@@ -41,7 +41,7 @@ trait SynchronizedSet[A] extends Set[A] {
     super.+=(elem)
   }
 
-  override def ++=(that: Traversible[A]) = synchronized {
+  override def ++=(that: Traversable[A]) = synchronized {
     super.++=(that)
   }
 
@@ -53,7 +53,7 @@ trait SynchronizedSet[A] extends Set[A] {
     super.-=(elem)
   }
 
-  override def --=(that: Traversible[A]) = synchronized {
+  override def --=(that: Traversable[A]) = synchronized {
     super.--=(that)
   }
 
diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala
index 6d90f6a531..4c0f63cd76 100644
--- a/src/library/scala/collection/mutable/SynchronizedStack.scala
+++ b/src/library/scala/collection/mutable/SynchronizedStack.scala
@@ -20,7 +20,7 @@ package scala.collection.mutable
  *  @version 1.0, 03/05/2004
  */
 class SynchronizedStack[A] extends Stack[A] {
-  import collection.Traversible
+  import collection.Traversable
 
   /** Checks if the stack is empty.
    *
@@ -42,13 +42,13 @@ class SynchronizedStack[A] extends Stack[A] {
    */
   override def push(elem1: A, elem2: A, elems: A*): this.type = synchronized[this.type] { super.push(elem1, elem2, elems: _*) }
 
-  /** Pushes all elements provided by an <code>Traversible</code> object
+  /** Pushes all elements provided by an <code>Traversable</code> object
    *  on top of the stack. The elements are pushed in the order they
    *  are given out by the iterator.
    *
    *  @param  iter        an iterable object
    */
-  override def pushAll(elems: collection.Traversible[A]): this.type = synchronized[this.type] { super.pushAll(elems) }
+  override def pushAll(elems: collection.Traversable[A]): this.type = synchronized[this.type] { super.pushAll(elems) }
 
   /** Pushes all elements provided by an iterator
    *  on top of the stack. The elements are pushed in the order they
diff --git a/src/library/scala/collection/mutable/Traversable.scala b/src/library/scala/collection/mutable/Traversable.scala
new file mode 100755
index 0000000000..1f48205906
--- /dev/null
+++ b/src/library/scala/collection/mutable/Traversable.scala
@@ -0,0 +1,30 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala.collection.mutable
+
+import generic._
+
+/** A subtrait of collection.Traversable which represents traversables
+ *  that can be mutated.
+ *
+ *  @autor   Martin Odersky
+ *  @version 2.8
+ */
+trait Traversable[A] extends collection.Traversable[A] with TraversableTemplate[A, Traversable[A]] with Mutable { self =>
+  override protected[this] def newBuilder = Traversable.newBuilder
+  override def traversableBuilder[B]: Builder[B, Traversable[B], Any] = Traversable.newBuilder[B]
+}
+
+/* A factory object for the trait `Traversable` */
+object Traversable extends TraversableFactory[Traversable] {
+  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] = new ArrayBuffer
+}
+
+
diff --git a/src/library/scala/collection/mutable/Traversible.scala b/src/library/scala/collection/mutable/Traversible.scala
deleted file mode 100755
index b177c9ca5d..0000000000
--- a/src/library/scala/collection/mutable/Traversible.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-package scala.collection.mutable
-
-import generic._
-
-/** A subtrait of collection.Traversible which represents traversibles
- *  that can be mutated.
- *
- *  @autor   Martin Odersky
- *  @version 2.8
- */
-trait Traversible[A] extends collection.Traversible[A] with TraversibleTemplate[A, Traversible[A]] with Mutable { self =>
-  override protected[this] def newBuilder = Traversible.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Traversible[B], Any] = Traversible.newBuilder[B]
-}
-
-/* A factory object for the trait `Traversible` */
-object Traversible extends TraversibleFactory[Traversible] {
-  type Coll = Traversible[_]
-  implicit def builderFactory[A]: BuilderFactory[A, Traversible[A], Coll] = new BuilderFactory[A, Traversible[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] }
-  def newBuilder[A]: Builder[A, Traversible[A], Any] = new ArrayBuffer
-}
-
-
diff --git a/src/library/scala/collection/mutable/Vector.scala b/src/library/scala/collection/mutable/Vector.scala
index a253f4b64f..e3178475ad 100755
--- a/src/library/scala/collection/mutable/Vector.scala
+++ b/src/library/scala/collection/mutable/Vector.scala
@@ -14,11 +14,11 @@ import generic._
  */
 trait Vector[A] extends Sequence[A] with collection.Vector[A] with MutableVectorTemplate[A, Vector[A]] {
   override protected[this] def newBuilder = Vector.newBuilder
-  override def traversibleBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B]
+  override def traversableBuilder[B]: Builder[B, Vector[B], Any] = 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.traversibleBuilder[A] }
+  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] = new ArrayBuffer
 }
diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala
index 61bf769c2f..4bb18f6d31 100644
--- a/src/library/scala/runtime/BoxedArray.scala
+++ b/src/library/scala/runtime/BoxedArray.scala
@@ -35,9 +35,9 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray
   /** Creates new builder for this collection ==> move to subclasses
    *
    * */
-  override protected[this] def newBuilder = traversibleBuilder[A]
+  override protected[this] def newBuilder = traversableBuilder[A]
 
-  override def traversibleBuilder[B]: Builder[B, BoxedArray[B], Any] = new ArrayBuffer[B].mapResult {
+  override def traversableBuilder[B]: Builder[B, BoxedArray[B], Any] = new ArrayBuffer[B].mapResult {
     _.toArray.asInstanceOf[BoxedArray[B]]
   }
 
diff --git a/src/swing/scala/swing/BufferWrapper.scala b/src/swing/scala/swing/BufferWrapper.scala
index ce97123aff..ad2f5d4278 100644
--- a/src/swing/scala/swing/BufferWrapper.scala
+++ b/src/swing/scala/swing/BufferWrapper.scala
@@ -11,7 +11,7 @@ protected[swing] abstract class BufferWrapper[A] extends Buffer[A] { outer =>
     remove(0)
     insertAt(n, a)
   }
-  def insertAll(n: Int, elems: scala.collection.Traversible[A]) {
+  def insertAll(n: Int, elems: scala.collection.Traversable[A]) {
     var i = n
     for (el <- elems) {
       insertAt(i, el)