In "Iterable" and in all its subclasses, "itera...

In "Iterable" and in all its subclasses, "iterator" replaces "elements"
(and assorted changes).

121 files changed, 470 insertions, 391 deletions

diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala
index 820195be3c..0ea2b9f972 100644
--- a/src/library/scala/Array.scala
+++ b/src/library/scala/Array.scala
@@ -92,70 +92,70 @@ object Array extends SequenceFactory[Array] {
   override def apply[A](xs: A*): Array[A] = {
     val array = new Array[A](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Boolean*): Array[Boolean] = {
     val array = new Array[Boolean](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Byte*): Array[Byte] = {
     val array = new Array[Byte](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Short*): Array[Short] = {
     val array = new Array[Short](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Char*): Array[Char] = {
     val array = new Array[Char](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Int*): Array[Int] = {
     val array = new Array[Int](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Long*): Array[Long] = {
     val array = new Array[Long](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Float*): Array[Float] = {
     val array = new Array[Float](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Double*): Array[Double] = {
     val array = new Array[Double](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
   def apply(xs: Unit*): Array[Unit] = {
     val array = new Array[Unit](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
diff --git a/src/library/scala/Console.scala b/src/library/scala/Console.scala
index f22c272e4e..31672ac8e6 100644
--- a/src/library/scala/Console.scala
+++ b/src/library/scala/Console.scala
@@ -406,7 +406,7 @@ object Console {
   private def textParams(s: Seq[Any]): Array[AnyRef] = {
     val res = new Array[AnyRef](s.length)
     var i: Int = 0
-    val iter = s.elements
+    val iter = s.iterator
     while (iter.hasNext) {
       res(i) = iter.next match {
         case x: Boolean => java.lang.Boolean.valueOf(x)
diff --git a/src/library/scala/Either.scala b/src/library/scala/Either.scala
index 0f0105b482..9fbb4b71ba 100644
--- a/src/library/scala/Either.scala
+++ b/src/library/scala/Either.scala
@@ -189,7 +189,7 @@ object Either {
      * <code>Seq</code> if this is a <code>Right</code>.
      */
     def toSeq = e match {
-      case Left(a) => Seq.singleton(a)
+      case Left(a) => Seq(a)
       case Right(_) => Seq.empty
     }
 
@@ -291,7 +291,7 @@ object Either {
      */
     def toSeq = e match {
       case Left(_) => Seq.empty
-      case Right(b) => Seq.singleton(b)
+      case Right(b) => Seq(b)
     }
 
     /**
diff --git a/src/library/scala/Enumeration.scala b/src/library/scala/Enumeration.scala
index d91e59f867..e5800a209e 100644
--- a/src/library/scala/Enumeration.scala
+++ b/src/library/scala/Enumeration.scala
@@ -44,7 +44,7 @@ import scala.collection.generic.{Builder, BuilderFactory, AddingBuilder, SetTemp
  *
  *    <b>def</b> isWorkingDay(d: WeekDay) = ! (d == Sat || d == Sun)
  *
- *    WeekDay.elements filter isWorkingDay foreach println
+ *    WeekDay.iterator filter isWorkingDay foreach println
  *  }</pre>
  *
  *  @param initial The initial value from which to count the integers that
@@ -95,7 +95,7 @@ abstract class Enumeration(initial: Int, names: String*) {
   protected var nextId = initial
 
   /** The string to use to name the next created value. */
-  protected var nextName = names.elements
+  protected var nextName = names.iterator
 
   /** The highest integer amongst those used to identify values in this
     * enumeration. */
@@ -219,7 +219,7 @@ abstract class Enumeration(initial: Int, names: String*) {
     def contains(v: Value) = ids contains (v.id)
     def + (value: Value) = new ValueSet(ids + value.id)
     def - (value: Value) = new ValueSet(ids - value.id)
-    def elements = ids.elements map Enumeration.this.apply
+    def iterator = ids.iterator map Enumeration.this.apply
     override def stringPrefix = Enumeration.this + ".ValueSet"
   }
 
@@ -249,42 +249,42 @@ abstract class Enumeration(initial: Int, names: String*) {
   @deprecated def valueOf(s: String) = values.find(_.toString == s)
 
   /** A new iterator over all values of this enumeration.
-   *  @deprecated use values.elements instead
+   *  @deprecated use values.iterator instead
    */
-  @deprecated final def elements: Iterator[Value] = values.elements
+  @deprecated final def iterator: Iterator[Value] = values.iterator
 
   /** Apply a function f to all values of this enumeration.
    *  @deprecated use values.foreach instead
    */
-  @deprecated def foreach(f: Value => Unit): Unit = elements foreach f
+  @deprecated def foreach(f: Value => Unit): Unit = this.iterator foreach f
 
   /** Apply a predicate p to all values of this enumeration and return
     * true, iff the predicate yields true for all values.
    *  @deprecated use values.forall instead
    */
-  @deprecated def forall(p: Value => Boolean): Boolean = elements forall p
+  @deprecated def forall(p: Value => Boolean): Boolean = this.iterator forall p
 
   /** Apply a predicate p to all values of this enumeration and return
     * true, iff there is at least one value for which p yields true.
     *  @deprecated use values.exists instead
     */
-  @deprecated def exists(p: Value => Boolean): Boolean = elements exists p
+  @deprecated def exists(p: Value => Boolean): Boolean = this.iterator exists p
 
   /** Returns an iterator resulting from applying the given function f to each
     * value of this enumeration.
     *  @deprecated use values.map instead
     */
-  @deprecated def map[B](f: Value => B): Iterator[B] = elements map f
+  @deprecated def map[B](f: Value => B): Iterator[B] = this.iterator map f
 
   /** Applies the given function f to each value of this enumeration, then
     * concatenates the results.
     *  @deprecated use values.flatMap instead
     */
-  @deprecated def flatMap[B](f: Value => Iterator[B]): Iterator[B] = elements flatMap f
+  @deprecated def flatMap[B](f: Value => Iterator[B]): Iterator[B] = this.iterator flatMap f
 
   /** Returns all values of this enumeration that satisfy the predicate p.
     * The order of values is preserved.
     *  @deprecated use values.filter instead
     */
-  @deprecated def filter(p: Value => Boolean): Iterator[Value] = elements filter p
+  @deprecated def filter(p: Value => Boolean): Iterator[Value] = this.iterator filter p
 }
diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala
index a1fe76c074..f6cbd94748 100644
--- a/src/library/scala/Option.scala
+++ b/src/library/scala/Option.scala
@@ -104,8 +104,8 @@ sealed abstract class Option[+A] extends Product {
   /** An singleton iterator returning the option's value if it is nonempty
    *  or the empty iterator if the option is empty.
    */
-  def elements: Iterator[A] =
-    if (isEmpty) Iterator.empty else Iterator.fromValues(this.get)
+  def iterator: Iterator[A] =
+    if (isEmpty) Iterator.empty else Iterator.single(this.get)
 
   /** A singleton list containing the option's value if it is nonempty
    *  or the empty list if the option is empty.
diff --git a/src/library/scala/Ordering.scala b/src/library/scala/Ordering.scala
index 663af258dd..467a46f724 100644
--- a/src/library/scala/Ordering.scala
+++ b/src/library/scala/Ordering.scala
@@ -160,8 +160,8 @@ object Ordering
   implicit def Iterable[T](implicit ord : Ordering[T]) : Ordering[Iterable[T]] =
   new Ordering[Iterable[T]] {
     def compare(x : Iterable[T], y : Iterable[T]) : Int = {
-      val xe = x.elements;
-      val ye = y.elements;
+      val xe = x.iterator;
+      val ye = y.iterator;
 
       while (xe.hasNext && ye.hasNext){
         val res = ord.compare(xe.next, ye.next);
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index c1a7024117..2c11c9a106 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -161,7 +161,7 @@ object Predef {
   def println() = Console.println()
   def println(x: Any) = Console.println(x)
   def printf(text: String, xs: Any*) = Console.printf(text, xs: _*)
-  def format(text: String, xs: Any*) = Console.format(text, xs: _*)
+  def format(text: String, xs: Any*) = stringWrapper(text).format(xs: _*)
 
   def readLine(): String = Console.readLine()
   def readLine(text: String, args: Any*) = Console.readLine(text, args)
@@ -209,8 +209,8 @@ object Predef {
       val self = xs
       def compare(that: Iterable[A]): Int = {
         var res = 0
-        val these = xs.elements
-        val those = that.elements
+        val these = xs.iterator
+        val those = that.iterator
         while (res == 0 && these.hasNext)
           res = if (those.hasNext) these.next compare those.next else 1
         if (res == 0) {
diff --git a/src/library/scala/Product.scala b/src/library/scala/Product.scala
index fd310f8fcf..b9a60e4c95 100644
--- a/src/library/scala/Product.scala
+++ b/src/library/scala/Product.scala
@@ -32,13 +32,17 @@ trait Product extends AnyRef {
    */
   def productArity: Int
 
-  def productElements: Iterator[Any] = new Iterator[Any] {
+  def productIterator: Iterator[Any] = new Iterator[Any] {
     private var c: Int = 0
     private val cmax = productArity
     def hasNext = c < cmax
     def next() = { val result = productElement(c); c += 1; result }
   }
 
+  /** @deprecated use productIterator instead
+   */
+  @deprecated def productElements: Iterator[Any] = productIterator
+
   /**
    *  By default the empty string. Implementations may override this
    *  method in order to prepend a string prefix to the result of the
diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala
index 4d8d64702d..89cf68b3b0 100644
--- a/src/library/scala/Tuple2.scala
+++ b/src/library/scala/Tuple2.scala
@@ -21,8 +21,8 @@ object Tuple2 {
 /* !!! todo: enable
   class IterableOps[CC[+B] <: Iterable[B] with IterableTemplate[CC, B @uncheckedVariance], A1, A2](tuple: (CC[A1], Iterable[A2])) {
     def zip: CC[(A1, A2)] = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[(A1, A2)]
         // : needed because otherwise it picks Iterable's builder.
       while (elems1.hasNext && elems2.hasNext)
@@ -30,37 +30,37 @@ object Tuple2 {
       b.result
     }
     def map[B](f: (A1, A2) => B): CC[B] = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[B]
       while (elems1.hasNext && elems2.hasNext)
         b += f(elems1.next, elems2.next)
       b.result
     }
     def flatMap[B](f: (A1, A2) => CC[B]): CC[B] = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[B]
       while (elems1.hasNext && elems2.hasNext)
         b ++= f(elems1.next, elems2.next)
       b.result
     }
     def foreach[U](f: (A1, A2) => U) {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       while (elems1.hasNext && elems2.hasNext)
         f(elems1.next, elems2.next)
     }
     def forall(p: (A1, A2) => Boolean): Boolean = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       while (elems1.hasNext && elems2.hasNext)
         if (!p(elems1.next, elems2.next)) return false
       true
     }
     def exists(p: (A1, A2) => Boolean): Boolean = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       while (elems1.hasNext && elems2.hasNext)
         if (p(elems1.next, elems2.next)) return true
       false
diff --git a/src/library/scala/Tuple2.scala.notyet b/src/library/scala/Tuple2.scala.notyet
index bed6bd3a9a..050a8d2536 100644
--- a/src/library/scala/Tuple2.scala.notyet
+++ b/src/library/scala/Tuple2.scala.notyet
@@ -16,45 +16,45 @@ package scala
 object Tuple2 {
   class IterableOps[CC[+B] <: Iterable[B], A1, A2](tuple: (CC[A1], Iterable[A2])) {
     def zip: CC[(A1, A2)] = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       val b = tuple._1.newBuilder[B]
       while (elems1.hasNext && elems2.hasNext)
         b += ((elems1.next, elems2.next))
       b.result
     }
     def map[B](f: (A1, A2) => B): CC[B] = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       val b = tuple._1.newBuilder[B]
       while (elems1.hasNext && elems2.hasNext)
         b += f(elems1.next, elems2.next)
       b.result
     }
     def flatMap[B](f: (A1, A2) => CC[B]) CC[B] = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       val b = tuple._1.newBuilder[B]
       while (elems1.hasNext && elems2.hasNext)
         b ++= f(elems1.next, elems2.next)
       b.result
     }
     def foreach(f: (A1, A2) => Unit) {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       while (elems1.hasNext && elems2.hasNext)
         f(elems1.next, elems2.next)
     }
     def forall(p: (A1, A2) => Boolean): Boolean = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       while (elems1.hasNext && elems2.hasNext)
         if (!p(elems1.next, elems2.next)) return false
       true
     }
     def exists(p: (A1, A2) => Boolean): Boolean = {
-      val elems1 = tuple._1.elements
-      val elems2 = tuple._2.elements
+      val elems1 = tuple._1.iterator
+      val elems2 = tuple._2.iterator
       while (elems1.hasNext && elems2.hasNext)
         if (p(elems1.next, elems2.next)) return true
       false
diff --git a/src/library/scala/collection/DefaultMap.scala b/src/library/scala/collection/DefaultMap.scala
index fe5b7a2c1b..bb3a0defa0 100644
--- a/src/library/scala/collection/DefaultMap.scala
+++ b/src/library/scala/collection/DefaultMap.scala
@@ -17,7 +17,7 @@ import generic._
  * Instances that inherit from DefaultMap[A, B] still have to define:
  *
  *   def get(key: A): Option[B]
- *   def elements: Iterator[(A, B)]
+ *   def iterator: Iterator[(A, B)]
  *
  * It refers back to the original map.
  *
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala
index 1ec5dccd7c..179ff99d92 100644
--- a/src/library/scala/collection/Iterable.scala
+++ b/src/library/scala/collection/Iterable.scala
@@ -38,7 +38,7 @@ trait Iterable[+A] extends Traversable[A]
 
   /* The following methods are inherited from trait IterableTemplate
    *
-  override def elements: Iterator[A]
+  override def iterator: Iterator[A]
   override def takeRight(n: Int): Iterable[A]
   override def dropRight(n: Int): Iterable[A]
   override def sameElements[B >: A](that: Iterable[B]): Boolean
@@ -58,7 +58,7 @@ object Iterable extends TraversableFactory[Iterable] {
    *  @deprecated use seq.min instead
    */
   @deprecated def min[A <% Ordered[A]](seq: Iterable[A]): A = {
-    val xs = seq.elements
+    val xs = seq.iterator
     if (!xs.hasNext) throw new IllegalArgumentException("min(<empty>)")
     var min = xs.next
     while (xs.hasNext) {
@@ -72,7 +72,7 @@ object Iterable extends TraversableFactory[Iterable] {
    *  @deprecated use seq.max iConstead
    */
   @deprecated def max[A <% Ordered[A]](seq: Iterable[A]): A = {
-    val xs = seq.elements
+    val xs = seq.iterator
     if (!xs.hasNext) throw new IllegalArgumentException("max(<empty>)")
     var max = xs.next
     while (xs.hasNext) {
diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
index a38cc6f360..5ebe0df11e 100644
--- a/src/library/scala/collection/Iterator.scala
+++ b/src/library/scala/collection/Iterator.scala
@@ -43,14 +43,14 @@ object Iterator {
   /** Creates an iterator with given elements
    *  @param elems  The elements returned one-by-one from the iterator
    */
-  def apply[A](elems: A*): Iterator[A] = elems.elements
+  def apply[A](elems: A*): Iterator[A] = elems.iterator
 
   /** Concatenates the given argument iterators into a single iterator.
    *
    *  @param its the argument iterators that are to be concatenated
    *  @return the concatenation of all the argument iterators
    */
-  @deprecated def concat[A](xss: Iterator[A]*): Iterator[A] = xss.elements.flatten
+  @deprecated def concat[A](xss: Iterator[A]*): Iterator[A] = xss.iterator.flatten
 
   /** An iterator that returns the results of some element computation a number of times.
    *  @param   len  The number of elements returned
@@ -165,14 +165,14 @@ object Iterator {
   implicit def iteratorIteratorWrapper[A](its: Iterator[Iterator[A]]): IteratorIteratorOps[A] =
     new IteratorIteratorOps[A](its)
 
-  /** @deprecated  use `xs.elements` instead
+  /** @deprecated  use `xs.iterator` or `Iterator(xs)` instead
    */
-  @deprecated def fromValues[a](xs: a*) = xs.elements
+  @deprecated def fromValues[a](xs: a*) = xs.iterator
 
   /**
    *  @param xs the array of elements
-   *  @see also: Vector.elements and slice
-   *  @deprecated  use `xs.elements` instead
+   *  @see also: Vector.iterator and slice
+   *  @deprecated  use `xs.iterator` instead
    */
   @deprecated def fromArray[a](xs: Array[a]): Iterator[a] =
     fromArray(xs, 0, xs.length)
@@ -181,23 +181,23 @@ object Iterator {
    *  @param xs     the array of elements
    *  @param start  the start index
    *  @param length  the length
-   *  @see also: Vector.elements and slice
-   *  @deprecated  use `xs.slice(start, start + length).elements` instead
+   *  @see also: Vector.iterator and slice
+   *  @deprecated  use `xs.slice(start, start + length).iterator` instead
    */
   @deprecated def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] =
-    xs.slice(start, start + length).elements
+    xs.slice(start, start + length).iterator
 
   /**
    *  @param str the given string
    *  @return    the iterator on <code>str</code>
-   *  @deprecated replaced by <code>str.elements</code>
+   *  @deprecated replaced by <code>str.iterator</code>
    */
-  @deprecated def fromString(str: String): Iterator[Char] = str.elements
+  @deprecated def fromString(str: String): Iterator[Char] = str.iterator
 
   /**
    *  @param n the product arity
    *  @return  the iterator on <code>Product&lt;n&gt;</code>.
-   *  @deprecated use product.productElements instead
+   *  @deprecated use product.productIterator instead
    */
   @deprecated def fromProduct(n: Product): Iterator[Any] = new Iterator[Any] {
     private var c: Int = 0
diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index 3509d13373..968329614c 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -323,18 +323,21 @@ object JavaConversions {
   }
 
   case class IterableWrapper[A](underlying : Iterable[A]) extends ju.AbstractCollection[A] {
-    def iterator = underlying.elements
+    def iterator = underlying.iterator
+	@deprecated def elements = iterator
     def size = underlying.size
     override def isEmpty = underlying.isEmpty
   }
 
   case class JIterableWrapper[A](underlying : jl.Iterable[A]) extends Iterable[A] {
-    def elements = underlying.iterator
+    def iterator = underlying.iterator
+	@deprecated def elements = iterator
     def newBuilder[B] = new mutable.ArrayBuffer[B]
   }
 
   case class JCollectionWrapper[A](underlying : ju.Collection[A]) extends Iterable[A] {
-    def elements = underlying.iterator
+    def iterator = underlying.iterator
+	@deprecated def elements = iterator
     override def size = underlying.size
     override def isEmpty = underlying.isEmpty
     def newBuilder[B] = new mutable.ArrayBuffer[B]
@@ -351,7 +354,8 @@ object JavaConversions {
   case class JListWrapper[A](val underlying : ju.List[A]) extends mutable.Buffer[A] {
     def length = underlying.size
     override def isEmpty = underlying.isEmpty
-    override def elements : Iterator[A] = underlying.iterator
+    override def iterator : Iterator[A] = underlying.iterator
+    @deprecated def elements = iterator
     def apply(i : Int) = underlying.get(i)
     def update(i : Int, elem : A) = underlying.set(i, elem)
     def +:(elem : A) = { underlying.subList(0, 0).add(elem) ; this }
@@ -374,7 +378,7 @@ object JavaConversions {
       }
     }
     def iterator = new ju.Iterator[A] {
-      val ui = underlying.elements
+      val ui = underlying.iterator
       var prev : Option[A] = None
 
       def hasNext = ui.hasNext
@@ -384,12 +388,15 @@ object JavaConversions {
         case _ => throw new IllegalStateException("next must be called at least once before remove")
       }
     }
+
+	@deprecated def elements = iterator
   }
 
   case class JSetWrapper[A](underlying : ju.Set[A]) extends mutable.Set[A] with generic.MutableSetTemplate[A, JSetWrapper[A]] {
     override def size = underlying.size
 
-    def elements = underlying.iterator
+    def iterator = underlying.iterator
+    @deprecated def elements = iterator
 
     def contains(elem: A): Boolean = underlying.contains(elem)
 
@@ -429,7 +436,7 @@ object JavaConversions {
       def size = self.size
 
       def iterator = new ju.Iterator[ju.Map.Entry[A, B]] {
-        val ui = underlying.elements
+        val ui = underlying.iterator
         var prev : Option[A] = None
 
         def hasNext = ui.hasNext
@@ -448,6 +455,8 @@ object JavaConversions {
           }
         }
 
+	    @deprecated def elements = iterator
+
         def remove = prev match {
           case Some(k) => val v = self.remove(k.asInstanceOf[AnyRef]) ; prev = None ; v
           case _ => throw new IllegalStateException("next must be called at least once before remove")
@@ -484,7 +493,7 @@ object JavaConversions {
       if (r != null) Some(r) else None
     }
 
-    def elements = new Iterator[(A, B)] {
+    def iterator = new Iterator[(A, B)] {
       val ui = underlying.entrySet.iterator
       def hasNext = ui.hasNext
       def next = { val e = ui.next ; (e.getKey, e.getValue) }
diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala
index 0cc1f33404..72afa218c2 100644
--- a/src/library/scala/collection/Map.scala
+++ b/src/library/scala/collection/Map.scala
@@ -18,7 +18,7 @@ import generic._
  *  (where This is the type of the map in question):
  *
  *   def get(key: A): Option[B]
- *   def elements: Iterator[(A, B)]
+ *   def iterator: Iterator[(A, B)]
  *   def + [B1 >: B](kv: (A, B1)): This
  *   def -(key: A): This
  *
diff --git a/src/library/scala/collection/RollbackIterator.scala.disabled b/src/library/scala/collection/RollbackIterator.scala.disabled
index 09ef4b6c3e..2dc011deee 100644
--- a/src/library/scala/collection/RollbackIterator.scala.disabled
+++ b/src/library/scala/collection/RollbackIterator.scala.disabled
@@ -46,7 +46,7 @@ class RollbackIterator[+A](underlying: Iterator[A]) extends BufferedIterator.Def
       if (g.isEmpty) {
         //putBack(rollback(0))
         val sz = oldLength.getOrElse(0)
-        val i = rollback.drop(sz).reverse.elements
+        val i = rollback.drop(sz).reverse.iterator
         while (i.hasNext) putBack(i.next)
         if (oldLength.isEmpty) rollback = null          
         else rollback.reduceToSize(sz)
diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Sequence.scala
index c5853355d4..d85ae1c306 100644
--- a/src/library/scala/collection/Sequence.scala
+++ b/src/library/scala/collection/Sequence.scala
@@ -20,7 +20,7 @@ import util.control.Breaks._
  *  of type <code>A</code>.
  *  It adds the following methods to class Iterable:
  *   `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLengh`,
- *   `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reversedElements`,
+ *   `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reverseIterator`,
  *   `startsWith`, `endsWith`, `indexOfSeq`.
  *
  *
diff --git a/src/library/scala/collection/generic/BitSetTemplate.scala b/src/library/scala/collection/generic/BitSetTemplate.scala
index f5c5a64d4e..e7fa26534c 100644
--- a/src/library/scala/collection/generic/BitSetTemplate.scala
+++ b/src/library/scala/collection/generic/BitSetTemplate.scala
@@ -33,7 +33,7 @@ trait BitSetTemplate[+This <: BitSetTemplate[This] with Set[Int]] extends SetTem
     s
   }
 
-  def elements = new Iterator[Int] {
+  def iterator = new Iterator[Int] {
     private var current = 0
     private val end = nwords * WordLength
     def hasNext: Boolean = {
@@ -45,6 +45,8 @@ trait BitSetTemplate[+This <: BitSetTemplate[This] with Set[Int]] extends SetTem
       else Iterator.empty.next
   }
 
+  @deprecated def elements = iterator
+
   override def foreach[B](f: Int => B) {
     for (i <- 0 until nwords) {
       val w = word(i)
@@ -136,7 +138,7 @@ object BitSetTemplate {
 
   private val pc1: Array[Int] = {
     def countBits(x: Int): Int = if (x == 0) 0 else x % 2 + countBits(x >>> 1)
-    Array.fromFunction(countBits _)(256)
+    Array.tabulate(256)(countBits _)
   }
 
   private def popCount(w: Long): Int = {
diff --git a/src/library/scala/collection/generic/BufferTemplate.scala b/src/library/scala/collection/generic/BufferTemplate.scala
index 74f61870d3..53d74a2d45 100644
--- a/src/library/scala/collection/generic/BufferTemplate.scala
+++ b/src/library/scala/collection/generic/BufferTemplate.scala
@@ -116,7 +116,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
   }
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.(thisCollection /: elems) (_ plus _)
    *
    *  @param iter  the iterable object.
@@ -138,7 +138,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
   def append(elems: A*) { this ++= elems }
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method.
+   *  via its <code>iterator</code> method.
    *
    *  @param iter  the iterable object.
    */
@@ -151,7 +151,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
   def prepend(elems: A*) { elems ++: this }
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -159,7 +159,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
   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
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -209,7 +209,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
     case Remove(NoLo, x)        => this -= x
 
     case Reset()                => clear
-    case s: Script[_]           => s.elements foreach <<
+    case s: Script[_]           => s.iterator foreach <<
     case _                      => throw new UnsupportedOperationException("message " + cmd + " not understood")
   }
 
diff --git a/src/library/scala/collection/generic/ImmutableMapTemplate.scala b/src/library/scala/collection/generic/ImmutableMapTemplate.scala
index b001e72a08..6c5331689e 100644
--- a/src/library/scala/collection/generic/ImmutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/ImmutableMapTemplate.scala
@@ -16,7 +16,7 @@ package scala.collection.generic
  *  (where This is the type of the map in question):
  *
  *   def get(key: A): Option[B]
- *   def elements: Iterator[(A, B)]
+ *   def iterator: Iterator[(A, B)]
  *   def + [B1 >: B](kv: (A, B)): Map[A, B1]
  *   def - (key: A): This
  *
diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala
index 142edbf509..5593f1a4f5 100644
--- a/src/library/scala/collection/generic/IterableForwarder.scala
+++ b/src/library/scala/collection/generic/IterableForwarder.scala
@@ -33,6 +33,6 @@ trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] {
   // Iterable delegates
   // Iterable methods could be printed by  cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^  (override )?def'
 
-  override def elements = underlying.elements
+  override def iterator = underlying.iterator
   override def sameElements[B >: A](that: Iterable[B]): Boolean = underlying.sameElements(that)
 }
diff --git a/src/library/scala/collection/generic/IterableProxyTemplate.scala b/src/library/scala/collection/generic/IterableProxyTemplate.scala
index 646cdbee11..d154d33621 100644
--- a/src/library/scala/collection/generic/IterableProxyTemplate.scala
+++ b/src/library/scala/collection/generic/IterableProxyTemplate.scala
@@ -23,7 +23,7 @@ import collection.mutable.Buffer
  *  @version 2.8
  */
 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 iterator: Iterator[A] = self.iterator
   override def takeRight(n: Int): This = self.takeRight(n)
   override def dropRight(n: Int): This = self.dropRight(n)
   override def sameElements[B >: A](that: Iterable[B]): Boolean = self.sameElements(that)
diff --git a/src/library/scala/collection/generic/IterableTemplate.scala b/src/library/scala/collection/generic/IterableTemplate.scala
index c540f5d3c9..7a0fb122f1 100644
--- a/src/library/scala/collection/generic/IterableTemplate.scala
+++ b/src/library/scala/collection/generic/IterableTemplate.scala
@@ -16,7 +16,7 @@ import util.control.Breaks._
 /** A template trait for iterable collections.
  *
  *  Collection classes mixing in this trait provide a method
- *  <code>elements</code> which returns an iterator over all the
+ *  <code>iterator</code> which returns an iterator over all the
  *  elements contained in the collection. They also provide a method `newBuilder`
  *  which creates a builder for collections of the same kind.
  *
@@ -24,7 +24,7 @@ import util.control.Breaks._
  *  all elements. Subclasses of `Iterable` should re-implement `foreach` with
  *  something more efficient, if possible.
  *
- *  This trait adds methods `elements`, `sameElements`,
+ *  This trait adds methods `iterator`, `sameElements`,
  *  `takeRight`, `dropRight` to the methods inherited from trait `Traversable`.
  *
  *  @author Martin Odersky
@@ -37,7 +37,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    *
    *  @return the new iterator
    */
-  def elements: Iterator[A]
+  def iterator: Iterator[A]
 
   /** Apply a function <code>f</code> to all elements of this
    *  traversable object.
@@ -46,15 +46,15 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    *              The result (of arbitrary type U) of function `f` is discarded.
    *
    *  @note This method underlies the implementation of most other bulk operations.
-   *        Implementing `foreach` with `elements` is often suboptimal.
+   *        Implementing `foreach` with `iterator` is often suboptimal.
    *        So `foreach` should be overridden in concrete collection classes if a more
    *        efficient implementation is available.
    */
-  def foreach[U](f: A => U): Unit = elements.foreach(f)
+  def foreach[U](f: A => U): Unit = this.iterator.foreach(f)
 
   /** Does this iterable contain no elements?
    */
-  override def isEmpty: Boolean = !elements.hasNext
+  override def isEmpty: Boolean = !this.iterator.hasNext
 
   /** Combines the elements of this iterable together using the binary
    *  function <code>f</code>, from right to left, and starting with
@@ -67,7 +67,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    *          if the iterable is <code>[a<sub>0</sub>, a1, ..., a<sub>n</sub>]</code>.
    */
   override def foldRight[B](z: B)(op: (A, B) => B): B =
-    elements.foldRight(z)(op)
+    this.iterator.foldRight(z)(op)
 
   /** Combines the elements of this iterable object together using the binary
    *  operator <code>op</code>, from right to left
@@ -83,7 +83,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    *  @throws Predef.UnsupportedOperationException if the iterator is empty.
    */
   override def reduceRight[B >: A](op: (A, B) => B): B =
-    elements.reduceRight(op)
+    this.iterator.reduceRight(op)
 
   /** The iterable itself */
   override def toIterable: Iterable[A] = thisCollection
@@ -93,7 +93,11 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    *  @note  Might return different results for different runs, unless this iterable is ordered
    *  @throws Predef.NoSuchElementException if the iterable is empty.
    */
-  override def head: A = if (isEmpty) throw new NoSuchElementException else elements.next
+  override def head: A =
+    if (isEmpty)
+      throw new NoSuchElementException
+    else
+      this.iterator.next
 
   /** Returns the rightmost <code>n</code> elements from this iterable.
    *
@@ -102,7 +106,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    */
   def takeRight(n: Int): This = {
     val b = newBuilder
-    val lead = elements drop n
+    val lead = this.iterator drop n
     var go = false
     for (x <- this) {
       if (lead.hasNext) lead.next
@@ -119,7 +123,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    */
   def dropRight(n: Int): This = {
     val b = newBuilder
-    val lead = elements drop n
+    val lead = iterator drop n
     breakable {
       for (x <- this) {
         if (!lead.hasNext) break
@@ -138,8 +142,8 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    *  @note  Might return different results for different runs, unless this iterable is ordered
    */
   def sameElements[B >: A](that: Iterable[B]): Boolean = {
-    val these = this.elements
-    val those = that.elements
+    val these = this.iterator
+    val those = that.iterator
     var res = true
     while (res && these.hasNext && those.hasNext) {
       res = (these.next == those.next)
@@ -149,13 +153,13 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
 
   /** Returns a stream with all elements in this traversable object.
    */
-  override def toStream: Stream[A] = elements.toStream
+  override def toStream: Stream[A] = iterator.toStream
 
   /** Creates a view of this iterable @see IterableView
    */
   override def view = new IterableView[A, This] {
     protected lazy val underlying = self.thisCollection
-    override def elements = self.elements
+    override def iterator = self.iterator
   }
 
   /** A sub-iterable view  starting at index `from`
diff --git a/src/library/scala/collection/generic/IterableViewTemplate.scala b/src/library/scala/collection/generic/IterableViewTemplate.scala
index f120e97ac4..950f8bb52a 100644
--- a/src/library/scala/collection/generic/IterableViewTemplate.scala
+++ b/src/library/scala/collection/generic/IterableViewTemplate.scala
@@ -23,31 +23,31 @@ extends Iterable[A] with IterableTemplate[A, This] with TraversableView[A, Coll]
   trait Transformed[+B] extends IterableView[B, Coll] with super.Transformed[B]
 
   trait Sliced extends Transformed[A] with super.Sliced {
-    override def elements = self.elements slice (from, until)
+    override def iterator = self.iterator slice (from, until)
   }
 
   trait Mapped[B] extends Transformed[B] with super.Mapped[B] {
-    override def elements = self.elements map mapping
+    override def iterator = self.iterator map mapping
   }
 
   trait FlatMapped[B] extends Transformed[B] with super.FlatMapped[B] {
-    override def elements = self.elements flatMap (mapping(_).toIterable.elements)
+    override def iterator = self.iterator flatMap (mapping(_).toIterable.iterator)
   }
 
   trait Appended[B >: A] extends Transformed[B] with super.Appended[B] {
-    override def elements = self.elements ++ rest.toIterable.elements
+    override def iterator = self.iterator ++ rest.toIterable.iterator
   }
 
   trait Filtered extends Transformed[A] with super.Filtered {
-    override def elements = self.elements filter pred
+    override def iterator = self.iterator filter pred
   }
 
   trait TakenWhile extends Transformed[A] with super.TakenWhile {
-    override def elements = self.elements takeWhile pred
+    override def iterator = self.iterator takeWhile pred
   }
 
   trait DroppedWhile extends Transformed[A] with super.DroppedWhile {
-    override def elements = self.elements dropWhile pred
+    override def iterator = self.iterator dropWhile pred
   }
 
   /** Boilerplate method, to override in each subclass
diff --git a/src/library/scala/collection/generic/LinearSequenceTemplate.scala b/src/library/scala/collection/generic/LinearSequenceTemplate.scala
index 6c13e71beb..b87a417fd7 100644
--- a/src/library/scala/collection/generic/LinearSequenceTemplate.scala
+++ b/src/library/scala/collection/generic/LinearSequenceTemplate.scala
@@ -60,7 +60,7 @@ trait LinearSequenceTemplate[+A, +This <: LinearSequenceTemplate[A, This] with L
 
   /** Returns the elements in the sequence as an iterator
    */
-  override def elements: Iterator[A] = new Iterator[A] {
+  override def iterator: Iterator[A] = new Iterator[A] {
     var these = self
     def hasNext: Boolean = !these.isEmpty
     def next: A =
@@ -70,6 +70,8 @@ trait LinearSequenceTemplate[+A, +This <: LinearSequenceTemplate[A, This] with L
     override def toList: List[A] = these.toList
   }
 
+  @deprecated def elements = iterator
+
   /** Apply the given function <code>f</code> to each element of this linear sequence
    *  (while respecting the order of the elements).
    *
diff --git a/src/library/scala/collection/generic/LinkedListTemplate.scala b/src/library/scala/collection/generic/LinkedListTemplate.scala
index 0be2562996..e3de5031a9 100644
--- a/src/library/scala/collection/generic/LinkedListTemplate.scala
+++ b/src/library/scala/collection/generic/LinkedListTemplate.scala
@@ -69,7 +69,7 @@ trait LinkedListTemplate[A, This >: Null <: Sequence[A] with LinkedListTemplate[
     else None
   }
 
-  override def elements: Iterator[A] = new Iterator[A] {
+  override def iterator: Iterator[A] = new Iterator[A] {
     var elems = self
     def hasNext = (elems ne null)
     def next = {
diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala
index 0af8543370..ff67a1a379 100644
--- a/src/library/scala/collection/generic/MapTemplate.scala
+++ b/src/library/scala/collection/generic/MapTemplate.scala
@@ -16,7 +16,7 @@ package scala.collection.generic
  *  (where `This` is the type of the map in question):
  *
  *   def get(key: A): Option[B]
- *   def elements: Iterator[(A, B)]
+ *   def iterator: Iterator[(A, B)]
  *   def + [B1 >: B](kv: (A, B1)): This
  *   def -(key: A): This
  *
@@ -50,7 +50,9 @@ self =>
   def get(key: A): Option[B]
 
   /** An iterator yielding all key/value mappings of this map. */
-  def elements: Iterator[(A, B)]
+  def iterator: Iterator[(A, B)]
+
+  @deprecated def elements = iterator
 
   /** Add a key/value pair to this map, returning a new map.
    *  @param    kv the key/value pair
@@ -110,44 +112,52 @@ self =>
    */
   def isDefinedAt(key: A) = contains(key)
 
-  /** Creates an iterator for all keys.
-   *
-   *  @return an iterator over all keys.
+  /**
+   *  @return the keys of this map as a set.
    */
-  def keys: Iterator[A] = new Iterator[A] {
-    val iter = self.elements
-    def hasNext = iter.hasNext
-    def next = iter.next._1
-  }
+  def keys: Set[A] = new DefaultKeySet
 
   protected class DefaultKeySet extends Set[A] {
     def contains(key : A) = self.contains(key)
-    def elements = self.elements.map(_._1)
+    def iterator = self.iterator.map(_._1)
+    @deprecated def elements = iterator
     def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
     def - (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
     override def size = self.size
     override def foreach[B](f: A => B) = for ((k, v) <- self) f(k)
   }
 
-  /** @return the keys of this map as a set.
+  /** @deprecated use `keys` instead
+   *
+   *  @return the keys of this map as a set.
    */
-  def keySet: Set[A] = new DefaultKeySet
+  @deprecated def keySet: collection.Set[A] = new DefaultKeySet
 
-  /** Creates an iterator for a contained values.
+  /** Creates an iterator for all keys.
    *
-   *  @return an iterator over all values.
+   *  @return an iterator over all keys.
    */
-  def values: Iterator[B] = new Iterator[B] {
-    val iter = self.elements
+  def keysIterator: Iterator[A] = new Iterator[A] {
+    val iter = self.iterator
     def hasNext = iter.hasNext
-    def next = iter.next._2
+    def next = iter.next._1
   }
 
   /** @return the values of this map as a set.
    *  @note  Can't return a Set[B] here because sets are non-variant.
    *         The operation is overridden with the sharper type in MutableMapTemplate.
    */
-  def valueSet: immutable.Set[_ <: B] = immutable.Set.empty[B] ++ (self map (_._2))
+  def values: collection.Set[_ <: B] = immutable.Set.empty[B] ++ (self map (_._2))
+
+  /** Creates an iterator for a contained values.
+   *
+   *  @return an iterator over all values.
+   */
+  def valuesIterator: Iterator[B] = new Iterator[B] {
+    val iter = self.iterator
+    def hasNext = iter.hasNext
+    def next = iter.next._2
+  }
 
   /** The default value for the map, returned when a key is not found
    *  The method implemented here yields an error,
@@ -164,7 +174,7 @@ self =>
    */
   def filterKeys(p: A => Boolean) = new DefaultMap[A, B] {
     override def foreach[C](f: ((A, B)) => C): Unit = for (kv <- self) if (p(kv._1)) f(kv)
-    def elements = self.elements.filter(kv => p(kv._1))
+    def iterator = self.iterator.filter(kv => p(kv._1))
     override def contains(key: A) = self.contains(key) && p(key)
     def get(key: A) = if (!p(key)) None else self.get(key)
   }
@@ -174,7 +184,7 @@ self =>
    */
   def mapValues[C](f: B => C) = new DefaultMap[A, C] {
     override def foreach[D](g: ((A, C)) => D): Unit = for ((k, v) <- self) g((k, f(v)))
-    def elements = for ((k, v) <- self.elements) yield (k, f(v))
+    def iterator = for ((k, v) <- self.iterator) yield (k, f(v))
     override def size = self.size
     override def contains(key: A) = self.contains(key)
     def get(key: A) = self.get(key).map(f)
@@ -226,7 +236,7 @@ self =>
    *  @return    a string showing all mappings
    */
   override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder =
-    elements.map { case (k, v) => k+" -> "+v }.addString(b, start, sep, end)
+    this.iterator.map { case (k, v) => k+" -> "+v }.addString(b, start, sep, end)
 
   /** Compares two maps structurally; i.e. checks if all mappings
    *  contained in this map are also contained in the other map,
diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala
index 9ccb13787b..6d6d05a119 100644
--- a/src/library/scala/collection/generic/MutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/MutableMapTemplate.scala
@@ -15,7 +15,7 @@ package scala.collection.generic
  *  To implement a concrete mutable map, you need to provide implementations of the following methods:
  *
  *   def get(key: A): Option[B]
- *   def elements: Iterator[(A, B)]
+ *   def iterator: Iterator[(A, B)]
  *   def += (kv: (A, B)): this.type
  *   def -= (key: A): this.type
  *
@@ -104,7 +104,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
     this += elem1 += elem2 ++= elems
 
   /** Adds a number of elements provided by a traversable object
-   *  via its <code>elements</code> method and returns
+   *  via its <code>iterator</code> method and returns
    *  either the collection itself (if it is mutable), or a new collection
    *  with the added elements.
    *  @deprecated  This operation will create a new map in the future. To add
@@ -116,7 +116,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
   @deprecated def ++(iter: Traversable[(A, B)]): this.type = { for (elem <- iter) +=(elem); this }
 
   /** Adds a number of elements provided by an iterator
-   *  via its <code>elements</code> method and returns
+   *  via its <code>iterator</code> method and returns
    *  the collection itself.
    *  @deprecated  This operation will create a new map in the future. To add
    *               elements as a side effect to an existing map and return
@@ -163,7 +163,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
   /** Removes all elements from the set. After this operation is completed,
    *  the set will be empty.
    */
-  def clear() { for ((k, v) <- elements) -=(k) }
+  def clear() { for ((k, v) <- this.iterator) -=(k) }
 
   /** Check if this map maps <code>key</code> to a value.
     * Return that value if it exists, otherwise put <code>default</code>
@@ -181,7 +181,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    * @param f  The transformation to apply
    */
   def transform(f: (A, B) => B): this.type = {
-    elements foreach {
+    this.iterator foreach {
       case (key, value) => update(key, f(key, value))
     }
     this
@@ -199,10 +199,10 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
   }
 
   /** @return the values of this map as a set */
-  override def valueSet: immutable.Set[B] = immutable.Set.empty[B] ++ (self map (_._2))
+  override def values: collection.immutable.Set[B] = immutable.Set.empty[B] ++ (self map (_._2))
 
   override def clone(): This =
-    empty ++ thisCollection
+    empty ++= thisCollection
 
   /** The result when this map is used as a builder */
   def result: This = thisCollection
diff --git a/src/library/scala/collection/generic/MutableSetTemplate.scala b/src/library/scala/collection/generic/MutableSetTemplate.scala
index bd2a094c96..40386fe27b 100644
--- a/src/library/scala/collection/generic/MutableSetTemplate.scala
+++ b/src/library/scala/collection/generic/MutableSetTemplate.scala
@@ -17,7 +17,7 @@ import script._
  *  To implement a concrete mutable set, you need to provide implementations of the following methods:
  *
  *  def contains(elem: A): Boolean
- *  def elements: Iterator[A]
+ *  def iterator: Iterator[A]
  *  def += (elem: A): this.type
  *  def -= (elem: A): this.type
  *
@@ -204,7 +204,7 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
      case Include(_, x)     => this += x
      case Remove(_, x)      => this -= x
      case Reset()           => clear
-     case s: Script[_]      => s.elements foreach <<
+     case s: Script[_]      => s.iterator foreach <<
      case _                 => throw new UnsupportedOperationException("message " + cmd + " not understood")
    }
 }
\ No newline at end of file
diff --git a/src/library/scala/collection/generic/MutableVectorTemplate.scala b/src/library/scala/collection/generic/MutableVectorTemplate.scala
index cfc65de9ec..a0cdfb0765 100644
--- a/src/library/scala/collection/generic/MutableVectorTemplate.scala
+++ b/src/library/scala/collection/generic/MutableVectorTemplate.scala
@@ -18,7 +18,7 @@ trait MutableVectorTemplate[A, +This <: MutableVectorTemplate[A, This] with muta
    */
   override def view = new MutableVectorView[A, This] {
     protected lazy val underlying = self.thisCollection
-    override def elements = self.elements
+    override def iterator = self.iterator
     override def length = self.length
     override def apply(idx: Int) = self.apply(idx)
     override def update(idx: Int, elem: A) = self.update(idx, elem)
diff --git a/src/library/scala/collection/generic/SequenceForwarder.scala b/src/library/scala/collection/generic/SequenceForwarder.scala
index bf92128d41..354509da13 100644
--- a/src/library/scala/collection/generic/SequenceForwarder.scala
+++ b/src/library/scala/collection/generic/SequenceForwarder.scala
@@ -41,7 +41,7 @@ trait SequenceForwarder[+A] extends Sequence[A] with IterableForwarder[A] {
   override def prefixLength(p: A => Boolean) = underlying.prefixLength(p)
   override def indexWhere(p: A => Boolean, from: Int): Int = underlying.indexWhere(p, from)
   override def indexOf[B >: A](elem: B, from: Int): Int = underlying.indexOf(elem, from)
-  override def reversedElements: Iterator[A] = underlying.reversedElements
+  override def reverseIterator: Iterator[A] = underlying.reverseIterator
   override def startsWith[B](that: Sequence[B], offset: Int): Boolean = underlying.startsWith(that, offset)
   override def endsWith[B](that: Sequence[B]): Boolean = underlying.endsWith(that)
   override def indexOfSeq[B >: A](that: Sequence[B]): Int = underlying.indexOfSeq(that)
diff --git a/src/library/scala/collection/generic/SequenceProxyTemplate.scala b/src/library/scala/collection/generic/SequenceProxyTemplate.scala
index 1854267ad8..f6fed763b5 100644
--- a/src/library/scala/collection/generic/SequenceProxyTemplate.scala
+++ b/src/library/scala/collection/generic/SequenceProxyTemplate.scala
@@ -41,7 +41,7 @@ trait SequenceProxyTemplate[+A, +This <: SequenceTemplate[A, This] with Sequence
   override def lastIndexWhere(p: A => Boolean): Int = self.lastIndexWhere(p, length - 1)
   override def lastIndexWhere(p: A => Boolean, end: Int): Int = self.lastIndexWhere(p)
   override def reverse: This = self.reverse
-  override def reversedElements: Iterator[A] = self.reversedElements
+  override def reverseIterator: Iterator[A] = self.reverseIterator
   override def startsWith[B](that: Sequence[B], offset: Int): Boolean = self.startsWith(that, offset)
   override def startsWith[B](that: Sequence[B]): Boolean = self.startsWith(that)
   override def endsWith[B](that: Sequence[B]): Boolean = self.endsWith(that)
diff --git a/src/library/scala/collection/generic/SequenceTemplate.scala b/src/library/scala/collection/generic/SequenceTemplate.scala
index 8efbe9ebb8..736a230613 100644
--- a/src/library/scala/collection/generic/SequenceTemplate.scala
+++ b/src/library/scala/collection/generic/SequenceTemplate.scala
@@ -20,7 +20,7 @@ import generic._
  *  of type <code>A</code>.
  *  It adds the following methods to class Iterable:
  *   `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLengh`,
- *   `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reversedElements`,
+ *   `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reverseIterator`,
  *   `startsWith`, `endsWith`, `indexOfSeq`, , `zip`, `zipAll`, `zipWithIndex`.
  *
  *
@@ -77,8 +77,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    */
   def zip[A1 >: A, B, That](that: Sequence[B])(implicit bf: BuilderFactory[(A1, B), That, This]): That = {
     val b = bf(thisCollection)
-    val these = this.elements
-    val those = that.elements
+    val these = this.iterator
+    val those = that.iterator
     while (these.hasNext && those.hasNext)
       b += ((these.next, those.next))
     b.result
@@ -106,8 +106,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    */
   def zipAll[B, A1 >: A, That](that: Sequence[B], thisElem: A1, thatElem: B)(implicit bf: BuilderFactory[(A1, B), That, This]): That = {
     val b = bf(thisCollection)
-    val these = this.elements
-    val those = that.elements
+    val these = this.iterator
+    val those = that.iterator
     while (these.hasNext && those.hasNext)
       b += ((these.next, those.next))
     while (these.hasNext)
@@ -242,7 +242,7 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    */
   def lastIndexWhere(p: A => Boolean, end: Int): Int = {
     var i = length - 1
-    val it = reversedElements
+    val it = reverseIterator
     while (it.hasNext && { val elem = it.next; (i > end || !p(elem)) }) i -= 1
     i
   }
@@ -266,7 +266,10 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
 
   /** The elements of this sequence in reversed order
    */
-  def reversedElements: Iterator[A] = reverse.elements
+  def reverseIterator: Iterator[A] = reverse.iterator
+
+  /** @deprecated use `reverseIterator` instead */
+  @deprecated def reversedElements = reverseIterator
 
   /**
    * Checks whether the argument sequence is contained at the
@@ -282,8 +285,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    * @see String.startsWith
    */
   def startsWith[B](that: Sequence[B], offset: Int): Boolean = {
-    val i = elements.drop(offset)
-    val j = that.elements
+    val i = this.iterator.drop(offset)
+    val j = that.iterator
     while (j.hasNext && i.hasNext) {
       if (i.next != j.next) return false
     }
@@ -302,8 +305,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    *  @see String.endsWith
    */
   def endsWith[B](that: Sequence[B]): Boolean = {
-    val i = this.elements.drop(length - that.length)
-    val j = that.elements
+    val i = this.iterator.drop(length - that.length)
+    val j = that.iterator
     while (i.hasNext && j.hasNext && i.next == j.next) ()
     !j.hasNext
   }
@@ -467,7 +470,7 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
 
   override def view = new SequenceView[A, This] {
     protected lazy val underlying = self.thisCollection
-    override def elements = self.elements
+    override def iterator = self.iterator
     override def length = self.length
     override def apply(idx: Int) = self.apply(idx)
   }
@@ -476,8 +479,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
 
   override def equals(that: Any): Boolean = that match {
     case that1: Sequence[a] =>
-      val these = this.elements
-      val those = that1.elements
+      val these = this.iterator
+      val those = that1.iterator
       while (these.hasNext && those.hasNext && these.next() == those.next()) {}
       !these.hasNext && !those.hasNext
     case _ =>
@@ -507,8 +510,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    *   <code>(s1, s2) forall { case (x, y) => f(x, y) }</code>
    */
   @deprecated def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = {
-    val i = this.elements
-    val j = that.elements
+    val i = this.iterator
+    val j = that.iterator
     while (i.hasNext && j.hasNext && f(i.next, j.next)) ()
     !i.hasNext && !j.hasNext
   }
diff --git a/src/library/scala/collection/generic/SequenceViewTemplate.scala b/src/library/scala/collection/generic/SequenceViewTemplate.scala
index 943fd9a80e..b11696ebaf 100644
--- a/src/library/scala/collection/generic/SequenceViewTemplate.scala
+++ b/src/library/scala/collection/generic/SequenceViewTemplate.scala
@@ -102,7 +102,7 @@ trait SequenceViewTemplate[+A,
   }
 
   trait Reversed extends Transformed[A] {
-    override def elements: Iterator[A] = self.reversedElements
+    override def iterator: Iterator[A] = self.reverseIterator
     override def length: Int = self.length
     override def apply(idx: Int): A = self.apply(length - 1 - idx)
     override def stringPrefix = super.stringPrefix+"R"
@@ -113,7 +113,7 @@ trait SequenceViewTemplate[+A,
     protected[this] val patch: Sequence[B]
     protected[this] val replaced: Int
     private val plen = patch.length
-    override def elements: Iterator[B] = self.elements patch (from, patch.elements, replaced)
+    override def iterator: Iterator[B] = self.iterator patch (from, patch.iterator, replaced)
     override def length: Int = self.length + plen - replaced
     override def apply(idx: Int): B =
       if (idx < from) self.apply(idx)
@@ -124,7 +124,7 @@ trait SequenceViewTemplate[+A,
 
   trait Zipped[B] extends Transformed[(A, B)] {
     protected[this] val other: Sequence[B]
-    override def elements: Iterator[(A, B)] = self.elements zip other.elements
+    override def iterator: Iterator[(A, B)] = self.iterator zip other.iterator
     override def length = self.length min other.length
     override def apply(idx: Int): (A, B) = (self.apply(idx), other.apply(idx))
     override def stringPrefix = super.stringPrefix+"Z"
diff --git a/src/library/scala/collection/generic/SetTemplate.scala b/src/library/scala/collection/generic/SetTemplate.scala
index 4556f81976..cce6ec4229 100644
--- a/src/library/scala/collection/generic/SetTemplate.scala
+++ b/src/library/scala/collection/generic/SetTemplate.scala
@@ -15,7 +15,7 @@ package scala.collection.generic
  *  (where `This` is the type of the set in question):
  *
  *   def contains(key: A): Boolean
- *   def elements: Iterator[A]
+ *   def iterator: Iterator[A]
  *   def +(elem: A): This
  *   def -(elem: A): This
  *
diff --git a/src/library/scala/collection/generic/Sorted.scala b/src/library/scala/collection/generic/Sorted.scala
index 007629811f..a8e45cc3a4 100644
--- a/src/library/scala/collection/generic/Sorted.scala
+++ b/src/library/scala/collection/generic/Sorted.scala
@@ -27,7 +27,7 @@ trait Sorted[K, +This <: Sorted[K, This]] extends Ranged[K, This] {
    */
   def to(to: K): This = {
     // tough!
-    val i = keySet.from(to).elements;
+    val i = keySet.from(to).iterator;
     if (!i.hasNext) return thisCollection
     val next = i.next;
     if (next == to) {
@@ -37,7 +37,7 @@ trait Sorted[K, +This <: Sorted[K, This]] extends Ranged[K, This] {
   }
 
   protected def hasAll(j: Iterator[K]): Boolean = {
-    val i = keySet.elements;
+    val i = keySet.iterator;
     if (!i.hasNext) return !j.hasNext;
     var in = i.next;
     while (j.hasNext) {
diff --git a/src/library/scala/collection/generic/SortedSetTemplate.scala b/src/library/scala/collection/generic/SortedSetTemplate.scala
index 4d02e93ba0..189131173b 100644
--- a/src/library/scala/collection/generic/SortedSetTemplate.scala
+++ b/src/library/scala/collection/generic/SortedSetTemplate.scala
@@ -32,7 +32,7 @@ self =>
   override def range(from: A, until: A): This = rangeImpl(Some(from), Some(until))
 
   override def subsetOf(that: Set[A]): Boolean = that match {
-    case that: SortedSet[_] => that.hasAll(elements)
+    case that: SortedSet[_] => that.hasAll(this.iterator)
     case that => super.subsetOf(that)
   }
 }
diff --git a/src/library/scala/collection/generic/TraversableTemplate.scala b/src/library/scala/collection/generic/TraversableTemplate.scala
index 721ee16df4..32402217c8 100644
--- a/src/library/scala/collection/generic/TraversableTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableTemplate.scala
@@ -657,7 +657,7 @@ self =>
   /** 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
+  def toList: List[A] = (new ListBuffer[A] ++= thisCollection).toList
 
   /** Returns an iterable with all elements in this traversable object.
    *  @note Will not terminate for infinite-sized collections.
diff --git a/src/library/scala/collection/generic/TraversableView.scala b/src/library/scala/collection/generic/TraversableView.scala
index c89639bab1..deacb1b5bb 100644
--- a/src/library/scala/collection/generic/TraversableView.scala
+++ b/src/library/scala/collection/generic/TraversableView.scala
@@ -20,7 +20,8 @@ trait TraversableView[+A, +Coll <: Traversable[_]] extends TraversableViewTempla
 object TraversableView {
   class NoBuilder[A] extends Builder[A, Nothing] {
     def +=(elem: A): this.type = this
-    def elements: Iterator[A] = Iterator.empty
+    def iterator: Iterator[A] = Iterator.empty
+    @deprecated def elements = iterator
     def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
     def clear() {}
   }
diff --git a/src/library/scala/collection/generic/TraversableView.scala.1 b/src/library/scala/collection/generic/TraversableView.scala.1
index a080c816fe..916f1182ff 100755
--- a/src/library/scala/collection/generic/TraversableView.scala.1
+++ b/src/library/scala/collection/generic/TraversableView.scala.1
@@ -137,7 +137,8 @@ self =>
 object TraversableView {
   class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] {
     def +=(elem: A) {}
-    def elements: Iterator[A] = Iterator.empty
+    def iterator: Iterator[A] = Iterator.empty
+    @deprecated def elements = iterator
     def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
     def clear() {}
   }
diff --git a/src/library/scala/collection/generic/VectorTemplate.scala b/src/library/scala/collection/generic/VectorTemplate.scala
index 2c1d8496d5..549485ed40 100644
--- a/src/library/scala/collection/generic/VectorTemplate.scala
+++ b/src/library/scala/collection/generic/VectorTemplate.scala
@@ -24,7 +24,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend
 
   // Overridden methods from IterableTemplate
 
-  /** The iterator returned by the elements method
+  /** The iterator returned by the iterator method
    */
   protected class Elements(start: Int, end: Int) extends scala.collection.BufferedIterator[A] {
     private var i = start
@@ -52,7 +52,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend
       else this
   }
 
-  override def elements: Iterator[A] = new Elements(0, length)
+  override def iterator: Iterator[A] = new Elements(0, length)
 
   override def isEmpty: Boolean = { length == 0 }
 
@@ -205,7 +205,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend
     b.result
   }
 
-  override def reversedElements: Iterator[A] = new Iterator[A] {
+  override def reverseIterator: Iterator[A] = new Iterator[A] {
     private var i = self.length
     def hasNext: Boolean = 0 < i
     def next: A =
@@ -229,7 +229,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend
     case _ =>
       var i = offset
       val thisLen = length
-      val thatElems = that.elements
+      val thatElems = that.iterator
       while (i < thisLen && thatElems.hasNext && this(i) == thatElems.next()) {
         i += 1
       }
@@ -272,7 +272,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend
 
   override def view = new VectorView[A, This] {
     protected lazy val underlying = self.thisCollection
-    override def elements = self.elements
+    override def iterator = self.iterator
     override def length = self.length
     override def apply(idx: Int) = self.apply(idx)
   }
diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala
index 351cbf60d8..c20dc017f8 100644
--- a/src/library/scala/collection/immutable/HashMap.scala
+++ b/src/library/scala/collection/immutable/HashMap.scala
@@ -107,9 +107,9 @@ class HashMap[A, +B] extends Map[A,B] with ImmutableMapTemplate[A, B, HashMap[A,
     s
   }
 
-  def elements = synchronized {
+  def iterator = synchronized {
     makeCopyIfUpdated()
-    entries map {e => (e.key, getValue(e))}
+    entriesIterator map {e => (e.key, getValue(e))}
   }
 
   private def getValue(e: Entry) =
diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala
index 86efa9c6c6..215fe80914 100644
--- a/src/library/scala/collection/immutable/HashSet.scala
+++ b/src/library/scala/collection/immutable/HashSet.scala
@@ -81,11 +81,11 @@ class HashSet[A] extends Set[A]
     s
   }
 
-  override def elements = synchronized {
+  override def iterator = synchronized {
     makeCopyIfUpdated()
     // note need to cache because (later versions of) set might be mutated while elements are traversed.
-    val cached = new mutable.ArrayBuffer() ++ super.elements
-    cached.elements
+    val cached = new mutable.ArrayBuffer() ++= super.iterator
+    cached.iterator
   }
 
   private def logLimit: Int = Math.sqrt(table.length).toInt
diff --git a/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled b/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled
index 7733c17bec..0cdfc4a988 100644
--- a/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled
+++ b/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled
@@ -104,7 +104,10 @@ sealed abstract class ImmutableIterator[+A] {
 
   /** Converts this immutable iterator into a conventional iterator.
    */
-  def elements: Iterator[A] = new Elements
+  def iterator: Iterator[A] = new Elements
+
+  @deprecated def elements = iterator
+  
 }
 
 
diff --git a/src/library/scala/collection/immutable/IntMap.scala b/src/library/scala/collection/immutable/IntMap.scala
index a7b66628bb..32ad7fca42 100644
--- a/src/library/scala/collection/immutable/IntMap.scala
+++ b/src/library/scala/collection/immutable/IntMap.scala
@@ -145,7 +145,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T]
   /**
    * Iterator over key, value pairs of the map in unsigned order of the keys.
    */
-  def elements : Iterator[(Int, T)] = this match {
+  def iterator : Iterator[(Int, T)] = this match {
     case IntMap.Nil => Iterator.empty;
     case _ => new IntMapEntryIterator(this);
   }
@@ -159,7 +159,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T]
     case IntMap.Nil => {};
   }
 
-  override def keys : Iterator[Int] = this match {
+  override def keysIterator : Iterator[Int] = this match {
     case IntMap.Nil => Iterator.empty;
     case _ => new IntMapKeyIterator(this);
   }
@@ -176,7 +176,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T]
     case IntMap.Nil => {}
   }
 
-  override def values : Iterator[T] = this match {
+  override def valuesIterator : Iterator[T] = this match {
     case IntMap.Nil => Iterator.empty;
     case _ => new IntMapValueIterator(this);
   }
diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala
index 9a205e97c4..38ddfee8b5 100644
--- a/src/library/scala/collection/immutable/List.scala
+++ b/src/library/scala/collection/immutable/List.scala
@@ -74,7 +74,7 @@ sealed abstract class List[+A] extends LinearSequence[A]
    */
   def :::[B >: A](prefix: List[B]): List[B] =
     if (isEmpty) prefix
-    else (new ListBuffer[B] ++ prefix).prependToList(this)
+    else (new ListBuffer[B] ++= prefix).prependToList(this)
 
   /** Reverse the given prefix and append the current list to that.
    *  This function is equivalent to an application of <code>reverse</code>
@@ -807,7 +807,7 @@ object List extends SequenceFactory[List] {
    *           <code>[a<sub>0</sub>, ..., a<sub>k</sub>]</code>,
    *           <code>[b<sub>0</sub>, ..., b<sub>l</sub>]</code> and
    *           <code>n = min(k,l)</code>
-   *  @deprecated  use (xs, ys).forall(f) instead
+   *  @deprecated  use (xs, ys).exists(f) instead
    */
   @deprecated def exists2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = {
     var xc = xs
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index 5c57715409..816018bf28 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -86,14 +86,14 @@ class ListMap[A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, ListMap[A
 
   /** Returns an iterator over key-value pairs.
    */
-  def elements: Iterator[(A,B)] =
+  def iterator: Iterator[(A,B)] =
     new Iterator[(A,B)] {
       var self: ListMap[A,B] = ListMap.this
       def hasNext = !self.isEmpty
       def next: (A,B) =
         if (!hasNext) throw new NoSuchElementException("next on empty iterator")
         else { val res = (self.key, self.value); self = self.next; res }
-    }.toList.reverse.elements
+    }.toList.reverseIterator
 
   protected def key: A = throw new NoSuchElementException("empty map")
   protected def value: B = throw new NoSuchElementException("empty map")
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index 210413171b..8dc961a308 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -62,7 +62,7 @@ class ListSet[A] extends Set[A]
    *  @throws Predef.NoSuchElementException
    *  @return the new iterator
    */
-  def elements: Iterator[A] = new Iterator[A] {
+  def iterator: Iterator[A] = new Iterator[A] {
     var that: ListSet[A] = self;
     def hasNext = !that.isEmpty;
     def next: A =
@@ -70,6 +70,8 @@ class ListSet[A] extends Set[A]
       else { val res = that.elem; that = that.next; res }
   }
 
+  @deprecated def elements = iterator
+
   /**
    *  @throws Predef.NoSuchElementException
    */
diff --git a/src/library/scala/collection/immutable/LongMap.scala b/src/library/scala/collection/immutable/LongMap.scala
index f30f9eb17d..346e97345f 100644
--- a/src/library/scala/collection/immutable/LongMap.scala
+++ b/src/library/scala/collection/immutable/LongMap.scala
@@ -146,7 +146,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T
   /**
    * Iterator over key, value pairs of the map in unsigned order of the keys.
    */
-  def elements : Iterator[(Long, T)] = this match {
+  def iterator: Iterator[(Long, T)] = this match {
     case LongMap.Nil => Iterator.empty;
     case _ => new LongMapEntryIterator(this);
   }
@@ -160,7 +160,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T
     case LongMap.Nil => {};
   }
 
-  override def keys : Iterator[Long] = this match {
+  override def keysIterator : Iterator[Long] = this match {
     case LongMap.Nil => Iterator.empty;
     case _ => new LongMapKeyIterator(this);
   }
@@ -177,7 +177,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T
     case LongMap.Nil => {}
   }
 
-  override def values : Iterator[T] = this match {
+  override def valuesIterator : Iterator[T] = this match {
     case LongMap.Nil => Iterator.empty;
     case _ => new LongMapValueIterator(this);
   }
diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala
index 103d8f3d5a..ef3c3006f0 100644
--- a/src/library/scala/collection/immutable/Map.scala
+++ b/src/library/scala/collection/immutable/Map.scala
@@ -48,7 +48,7 @@ object Map extends ImmutableMapFactory[Map] {
   class WithDefault[A, +B](underlying: Map[A, B], d: A => B) extends Map[A, B] {
     override def size = underlying.size
     def get(key: A) = underlying.get(key)
-    def elements = underlying.elements
+    def iterator = underlying.iterator
     override def empty = new WithDefault(underlying.empty, d)
     override def updated[B1 >: B](key: A, value: B1): WithDefault[A, B1] = new WithDefault[A, B1](underlying.updated[B1](key, value), d)
     def + [B1 >: B](kv: (A, B1)): WithDefault[A, B1] = updated(kv._1, kv._2)
@@ -60,7 +60,7 @@ object Map extends ImmutableMapFactory[Map] {
   class EmptyMap[A, +B] extends Map[A, B] {
     override def size: Int = 0
     def get(key: A): Option[B] = None
-    def elements: Iterator[(A, B)] = Iterator.empty
+    def iterator: Iterator[(A, B)] = Iterator.empty
     override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = new Map1(key, value)
     def + [B1 >: B](kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
     def - (key: A): Map[A, B] = this
@@ -71,7 +71,7 @@ object Map extends ImmutableMapFactory[Map] {
     override def size = 1
     def get(key: A): Option[B] =
       if (key == key1) Some(value1) else None
-    def elements = Iterator((key1, value1))
+    def iterator = Iterator((key1, value1))
     override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1) new Map1(key1, value)
       else new Map2(key1, value1, key, value)
@@ -90,7 +90,7 @@ object Map extends ImmutableMapFactory[Map] {
       if (key == key1) Some(value1)
       else if (key == key2) Some(value2)
       else None
-    def elements = Iterator((key1, value1), (key2, value2))
+    def iterator = Iterator((key1, value1), (key2, value2))
     override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1) new Map2(key1, value, key2, value2)
       else if (key == key2) new Map2(key1, value1, key2, value)
@@ -113,7 +113,7 @@ object Map extends ImmutableMapFactory[Map] {
       else if (key == key2) Some(value2)
       else if (key == key3) Some(value3)
       else None
-    def elements = Iterator((key1, value1), (key2, value2), (key3, value3))
+    def iterator = Iterator((key1, value1), (key2, value2), (key3, value3))
     override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1)      new Map3(key1, value, key2, value2, key3, value3)
       else if (key == key2) new Map3(key1, value1, key2, value, key3, value3)
@@ -139,7 +139,7 @@ object Map extends ImmutableMapFactory[Map] {
       else if (key == key3) Some(value3)
       else if (key == key4) Some(value4)
       else None
-    def elements = Iterator((key1, value1), (key2, value2), (key3, value3), (key4, value4))
+    def iterator = Iterator((key1, value1), (key2, value2), (key3, value3), (key4, value4))
     override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1)      new Map4(key1, value, key2, value2, key3, value3, key4, value4)
       else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4)
diff --git a/src/library/scala/collection/immutable/PagedSeq.scala b/src/library/scala/collection/immutable/PagedSeq.scala
index 85eca5777b..fe34195238 100644
--- a/src/library/scala/collection/immutable/PagedSeq.scala
+++ b/src/library/scala/collection/immutable/PagedSeq.scala
@@ -34,7 +34,7 @@ object PagedSeq {
 
   /** Constructs a character sequence from a character iterable */
   def fromIterable[T](source: Iterable[T]): PagedSeq[T] =
-    fromIterator(source.elements)
+    fromIterator(source.iterator)
 
   /** Constructs a character sequence from a string iterator */
   def fromStrings(source: Iterator[String]): PagedSeq[Char] = {
@@ -55,7 +55,7 @@ object PagedSeq {
 
   /** Constructs a character sequence from a string iterable */
   def fromStrings(source: Iterable[String]): PagedSeq[Char] =
-    fromStrings(source.elements)
+    fromStrings(source.iterator)
 
   /** Constructs a character sequence from a line iterator
    *  Lines do not contain trailing `\n' characters; The method inserts
@@ -77,7 +77,7 @@ object PagedSeq {
    *  a line separator `\n' between any two lines in the sequence.
    */
   def fromLines(source: Iterable[String]): PagedSeq[Char] =
-    fromLines(source.elements)
+    fromLines(source.iterator)
 
   /** Constructs a character sequence from an input reader
    */
@@ -180,7 +180,7 @@ class PagedSeq[T] protected (more: (Array[T], Int, Int) => Int,
   /** Convert sequence to string */
   override def toString = {
     val buf = new StringBuilder
-    for (ch <- elements) buf append ch
+    for (ch <- PagedSeq.this.iterator) buf append ch
     buf.toString
   }
 }
diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala
index f7d2da9a09..dd61c2271c 100644
--- a/src/library/scala/collection/immutable/Queue.scala
+++ b/src/library/scala/collection/immutable/Queue.scala
@@ -29,7 +29,7 @@ object Queue {
 class Queue[+A](elem: A*) extends Seq[A] {
 
   protected val in: List[A] = Nil
-  protected val out: List[A] = elem.elements.toList
+  protected val out: List[A] = elem.iterator.toList
 
   protected def mkQueue[A](i: List[A], o: List[A]): Queue[A] =
     new Queue[A]() {
@@ -56,7 +56,7 @@ class Queue[+A](elem: A*) extends Seq[A] {
 
   /** Returns the elements in the list as an iterator
    */
-  override def elements: Iterator[A] = (out ::: in.reverse).elements
+  override def iterator: Iterator[A] = (out ::: in.reverse).iterator
 
   /** Checks if the queue is empty.
    *
@@ -96,7 +96,7 @@ class Queue[+A](elem: A*) extends Seq[A] {
    */
   @deprecated def +[B >: A](iter: Iterable[B]) = {
     var q: List[B] = in
-    iter.elements.foreach(e => q = e :: q)
+    iter.iterator.foreach(e => q = e :: q)
     mkQueue(q, out)
   }
 
@@ -110,7 +110,7 @@ class Queue[+A](elem: A*) extends Seq[A] {
    */
   def enqueue[B >: A](iter: Iterable[B]) = {
     var q: List[B] = in
-    iter.elements.foreach(e => q = e :: q)
+    iter.iterator.foreach(e => q = e :: q)
     mkQueue(q, out)
   }
 
diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala
index c50dba65f5..a13250363d 100644
--- a/src/library/scala/collection/immutable/RedBlack.scala
+++ b/src/library/scala/collection/immutable/RedBlack.scala
@@ -32,7 +32,8 @@ abstract class RedBlack[A] {
     /** @deprecated use foreach instead */
     @deprecated def visit[T](input : T)(f : (T,A,B) => Tuple2[Boolean,T]) : Tuple2[Boolean,T];
     def toStream: Stream[(A,B)]
-    def elements: Iterator[Pair[A, B]]
+    def iterator: Iterator[(A, B)]
+    @deprecated def elements = iterator
     def upd[B1 >: B](k: A, v: B1): Tree[B1]
     def del(k: A): Tree[B]
     def smallest: NonEmpty[B]
@@ -87,8 +88,8 @@ abstract class RedBlack[A] {
     def toStream: Stream[(A,B)] =
       left.toStream append Stream((key,value)) append right.toStream
 
-    def elements: Iterator[Pair[A, B]] =
-      left.elements append Iterator.single(Pair(key, value)) append right.elements
+    def iterator: Iterator[(A, B)] =
+      left.iterator append Iterator.single(Pair(key, value)) append right.iterator
 
     def foreach[U](f: (A, B) =>  U) {
       left foreach f
@@ -129,7 +130,7 @@ abstract class RedBlack[A] {
     def upd[B](k: A, v: B): Tree[B] = RedTree(k, v, Empty, Empty)
     def del(k: A): Tree[Nothing] = this
     def smallest: NonEmpty[Nothing] = throw new NoSuchElementException("empty map")
-    def elements: Iterator[Pair[A, Nothing]] = Iterator.empty
+    def iterator: Iterator[(A, Nothing)] = Iterator.empty
     def toStream: Stream[(A,Nothing)] = Stream.empty
 
     def foreach[U](f: (A, Nothing) =>  U) {}
diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala
index 78aaa54f1c..8acf786358 100644
--- a/src/library/scala/collection/immutable/Set.scala
+++ b/src/library/scala/collection/immutable/Set.scala
@@ -17,7 +17,7 @@ import generic._
  *  have to provide functionality for the abstract methods in Set:
  *
  *  def contains(elem: A): Boolean
- *  def elements: Iterator[A]
+ *  def iterator: Iterator[A]
  *  def + (elem: A): This
  *  def - (elem: A): This
  *
@@ -48,7 +48,8 @@ object Set extends SetFactory[Set] {
     def contains(elem: A): Boolean = false
     def + (elem: A): Set[A] = new Set1(elem)
     def - (elem: A): Set[A] = this
-    def elements: Iterator[A] = Iterator.empty
+    def iterator: Iterator[A] = Iterator.empty
+    @deprecated def elements = iterator
     override def foreach[U](f: A =>  U): Unit = {}
   }
 
@@ -64,8 +65,9 @@ object Set extends SetFactory[Set] {
     def - (elem: A): Set[A] =
       if (elem == elem1) new EmptySet[A]
       else this
-    def elements: Iterator[A] =
+    def iterator: Iterator[A] =
       Iterator(elem1)
+    @deprecated def elements = iterator
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1)
     }
@@ -84,8 +86,9 @@ object Set extends SetFactory[Set] {
       if (elem == elem1) new Set1(elem2)
       else if (elem == elem2) new Set1(elem1)
       else this
-    def elements: Iterator[A] =
+    def iterator: Iterator[A] =
       Iterator(elem1, elem2)
+    @deprecated def elements = iterator
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1); f(elem2)
     }
@@ -105,8 +108,9 @@ object Set extends SetFactory[Set] {
       else if (elem == elem2) new Set2(elem1, elem3)
       else if (elem == elem3) new Set2(elem1, elem2)
       else this
-    def elements: Iterator[A] =
+    def iterator: Iterator[A] =
       Iterator(elem1, elem2, elem3)
+    @deprecated def elements = iterator
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1); f(elem2); f(elem3)
     }
@@ -127,8 +131,9 @@ object Set extends SetFactory[Set] {
       else if (elem == elem3) new Set3(elem1, elem2, elem4)
       else if (elem == elem4) new Set3(elem1, elem2, elem3)
       else this
-    def elements: Iterator[A] =
+    def iterator: Iterator[A] =
       Iterator(elem1, elem2, elem3, elem4)
+    @deprecated def elements = iterator
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1); f(elem2); f(elem3); f(elem4)
     }
diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala
index 7be6635853..04e9251bec 100644
--- a/src/library/scala/collection/immutable/Stack.scala
+++ b/src/library/scala/collection/immutable/Stack.scala
@@ -105,7 +105,7 @@ class Stack[+A] extends Sequence[A] {
    *
    *  @return an iterator over all stack elements.
    */
-  override def elements: Iterator[A] = new Iterator[A] {
+  override def iterator: Iterator[A] = new Iterator[A] {
     private var cur = Stack.this
     def hasNext: Boolean = !cur.isEmpty
     def next: A = { val r = top; cur = cur.pop; r }
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 7b5e3f7659..538e9d85fe 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -184,7 +184,7 @@ self =>
    *  @param p the predicate used to filter the stream.
    *  @return the elements of this stream satisfying <code>p</code>.
    */
-  override def partition(p: A => Boolean): (Stream[A], Stream[A]) = (filter(p(_)), remove(p(_)))
+  override def partition(p: A => Boolean): (Stream[A], Stream[A]) = (filter(p(_)), filterNot(p(_)))
 
   /** Returns a stream formed from this stream and the specified stream
    *  <code>that</code> by associating each element of the former with
@@ -200,7 +200,7 @@ self =>
     def loop(these: Stream[A], elems2: Iterator[B]): Stream[(A1, B)] =
       if (these.isEmpty || !elems2.hasNext) Stream.Empty
       else new Stream.Cons((these.head, elems2.next), loop(these.tail, elems2))
-    if (bf.isInstanceOf[Stream.StreamBuilderFactory[_]]) loop(this, that.elements).asInstanceOf[That]
+    if (bf.isInstanceOf[Stream.StreamBuilderFactory[_]]) loop(this, that.iterator).asInstanceOf[That]
     else super.zip[A1, B, That](that)
   }
 
@@ -378,7 +378,7 @@ object Stream extends SequenceFactory[Stream] {
    *         this builder should be bypassed.
    */
   class StreamBuilder[A] extends LazyBuilder[A, Stream[A]] {
-    def result: Stream[A] = (for (xs <- parts.elements; x <- xs.toIterable.elements) yield x).toStream
+    def result: Stream[A] = (for (xs <- parts.iterator; x <- xs.toIterable.iterator) yield x).toStream
   }
 
   object Empty extends Stream[Nothing] {
@@ -507,7 +507,7 @@ object Stream extends SequenceFactory[Stream] {
   /** The concatenation of a sequence of streams
    * @deprecated use xs.flatten instead
    */
-  def concat[A](xs: Iterable[Stream[A]]): Stream[A] = concat(xs.elements)
+  def concat[A](xs: Iterable[Stream[A]]): Stream[A] = concat(xs.iterator)
 
   /** The concatenation of all streams returned by an iterator
    * @deprecated use xs.toStream.flatten instead
diff --git a/src/library/scala/collection/immutable/TreeHashMap.scala b/src/library/scala/collection/immutable/TreeHashMap.scala
index 780a69dfde..1b45a8b5b8 100644
--- a/src/library/scala/collection/immutable/TreeHashMap.scala
+++ b/src/library/scala/collection/immutable/TreeHashMap.scala
@@ -36,7 +36,7 @@ object TreeHashMap {
  * @author David MacIver
  */
 class TreeHashMap[Key, +Value] private (private val underlying : IntMap[AssocMap[Key, Value]]) extends scala.collection.immutable.Map[Key, Value]{
-  def elements : Iterator[(Key, Value)] = new Iterator[(Key, Value)]{
+  def iterator : Iterator[(Key, Value)] = new Iterator[(Key, Value)]{
     val assocIt = new AssocMapIterator(AssocMap.empty[Key, Value]);
     val intIterator = underlying.values;
 
@@ -182,7 +182,9 @@ private[collection] sealed abstract class AssocMap[Key, +Value] extends immutabl
     case Nil() => AssocMap.empty;
   }
 
-  def elements : Iterator[(Key, Value)] = new AssocMapIterator(this);
+  def iterator : Iterator[(Key, Value)] = new AssocMapIterator(this)
+
+  @deprecated def elements = iterator
 
   override final def foreach[U](f : ((Key, Value)) =>  U) = this match {
     case Cons(key, value, tail) => { f((key, value)); tail.foreach(f); }
diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala
index 2298a64ba7..cff70586ab 100644
--- a/src/library/scala/collection/immutable/TreeMap.scala
+++ b/src/library/scala/collection/immutable/TreeMap.scala
@@ -112,7 +112,7 @@ class TreeMap[A, +B](override val size: Int, t: RedBlack[A]#Tree[B])(implicit va
    *
    *  @return the new iterator
    */
-  def elements: Iterator[(A, B)] = tree.toStream.elements
+  def iterator: Iterator[(A, B)] = tree.toStream.iterator
 
   override def toStream: Stream[(A, B)] = tree.toStream
 
diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala
index 0f352356b8..93faa59b45 100644
--- a/src/library/scala/collection/immutable/TreeSet.scala
+++ b/src/library/scala/collection/immutable/TreeSet.scala
@@ -82,7 +82,9 @@ class TreeSet[A <% Ordered[A]](override val size: Int, t: RedBlack[A]#Tree[Unit]
    *
    *  @return the new iterator
    */
-  def elements: Iterator[A] = tree.toStream.elements map (_._1)
+  def iterator: Iterator[A] = tree.toStream.iterator map (_._1)
+
+  @deprecated def elements = iterator
 
   override def toStream: Stream[A] = tree.toStream map (_._1)
 
diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala
index ae17cc33b4..d25c55f4af 100644
--- a/src/library/scala/collection/mutable/ArrayBuffer.scala
+++ b/src/library/scala/collection/mutable/ArrayBuffer.scala
@@ -58,7 +58,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
   }
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterfable object.
@@ -91,7 +91,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
   }
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -148,7 +148,7 @@ class ArrayBuffer[A](override protected val initialSize: Int)
    *
    *  @return an <code>ArrayBuffer</code> with the same elements.
    */
-  override def clone(): ArrayBuffer[A] = new ArrayBuffer[A] ++ this
+  override def clone(): ArrayBuffer[A] = new ArrayBuffer[A] ++= this
 
   def result: ArrayBuffer[A] = this
 
diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala
index 8461191ff8..cae18452f3 100644
--- a/src/library/scala/collection/mutable/ArrayStack.scala
+++ b/src/library/scala/collection/mutable/ArrayStack.scala
@@ -153,7 +153,7 @@ class ArrayStack[T] private(private var table : Array[AnyRef],
   /**
    * Iterates over the stack in fifo order.
    */
-  def elements = new Iterator[T]{
+  def iterator: Iterator[T] = new Iterator[T]{
     var currentIndex = index;
     def hasNext = currentIndex > 0;
     def next = {
@@ -162,6 +162,8 @@ class ArrayStack[T] private(private var table : Array[AnyRef],
     }
   }
 
+  @deprecated def elements = iterator
+
   override def foreach[U](f : T =>  U){
     var currentIndex = index;
     while(currentIndex > 0){
diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala
index f430cae83d..b45e151da9 100644
--- a/src/library/scala/collection/mutable/BufferProxy.scala
+++ b/src/library/scala/collection/mutable/BufferProxy.scala
@@ -27,7 +27,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
 
   def length: Int = self.length
 
-  override def elements: Iterator[A] = self.elements
+  override def iterator: Iterator[A] = self.iterator
 
   def apply(n: Int): A = self.apply(n)
 
@@ -48,7 +48,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
   override def readOnly = self.readOnly
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -57,7 +57,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
   override def ++(iter: Iterable[A]): Buffer[A] = self.++(iter)
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method.
+   *  via its <code>iterator</code> method.
    *
    *  @param iter  the iterable object.
    */
@@ -70,7 +70,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
   override def append(elems: A*): Unit = self.++=(elems)
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method.
+   *  via its <code>iterator</code> method.
    *
    *  @param iter  the iterable object.
    */
@@ -84,7 +84,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
   def +:(elem: A): Buffer[A] = self.+:(elem)
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -98,7 +98,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
   override def prepend(elems: A*): Unit = self.prependAll(elems)
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
diff --git a/src/library/scala/collection/mutable/DefaultMapModel.scala b/src/library/scala/collection/mutable/DefaultMapModel.scala
index 9acf089506..f76a54c739 100644
--- a/src/library/scala/collection/mutable/DefaultMapModel.scala
+++ b/src/library/scala/collection/mutable/DefaultMapModel.scala
@@ -40,6 +40,7 @@ trait DefaultMapModel[A, B] extends Map[A, B] {
 
   def += (kv: (A, B)): this.type = { put(kv._1, kv._2); this }
 
-  def elements = entries map {e => (e.key, e.value)}
+  def iterator = entries map {e => (e.key, e.value)}
+
 }
 
diff --git a/src/library/scala/collection/mutable/FlatHashTable.scala b/src/library/scala/collection/mutable/FlatHashTable.scala
index dd09af381e..de926e8108 100644
--- a/src/library/scala/collection/mutable/FlatHashTable.scala
+++ b/src/library/scala/collection/mutable/FlatHashTable.scala
@@ -113,7 +113,7 @@ trait FlatHashTable[A] {
     None
   }
 
-  def elements = new Iterator[A] {
+  def iterator = new Iterator[A] {
     private var i = 0
     def hasNext: Boolean = {
       while (i < table.length && (null == table(i))) i += 1
@@ -124,6 +124,8 @@ trait FlatHashTable[A] {
       else Iterator.empty.next
   }
 
+  @deprecated def elements = iterator
+
   private def growTable() {
     val oldtable = table
     table = new Array[AnyRef](table.length * 2)
diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala
index f8ba594d4c..255358ae1f 100644
--- a/src/library/scala/collection/mutable/HashMap.scala
+++ b/src/library/scala/collection/mutable/HashMap.scala
@@ -54,7 +54,7 @@ class HashMap[A, B] extends Map[A, B]
 
   def -=(key: A): this.type = { removeEntry(key); this }
 
-  def elements = entries map {e => (e.key, e.value)}
+  def iterator = entriesIterator map {e => (e.key, e.value)}
 }
 
 /** This class implements mutable maps using a hashtable.
diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala
index d5eba30552..20e5a1e6b5 100644
--- a/src/library/scala/collection/mutable/HashSet.scala
+++ b/src/library/scala/collection/mutable/HashSet.scala
@@ -48,7 +48,7 @@ class HashSet[A] extends Set[A]
     }
   }
 
-  override def clone(): HashSet[A] = new HashSet[A] ++ this
+  override def clone(): HashSet[A] = new HashSet[A] ++= this
 }
 
 /** Factory object for `HashSet` class */
diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala
index ada2df83b3..be0a84bd41 100644
--- a/src/library/scala/collection/mutable/HashTable.scala
+++ b/src/library/scala/collection/mutable/HashTable.scala
@@ -111,7 +111,7 @@ trait HashTable[A] extends AnyRef {
 
   /** An iterator returning all entries
    */
-  protected def entries: Iterator[Entry] = new Iterator[Entry] {
+  protected def entriesIterator: Iterator[Entry] = new Iterator[Entry] {
     val iterTable = table
     var idx = table.length - 1
     var es = iterTable(idx).asInstanceOf[Entry]
@@ -131,6 +131,11 @@ trait HashTable[A] extends AnyRef {
     }
   }
 
+  /** An iterator returning all entries
+   *  @deprecated use entriesIterator instead
+   */
+  @deprecated protected def entries: Iterator[Entry] = entriesIterator
+
   /** Remove all entries from table
    */
   def clear() {
diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala
index 6f2ab4b160..25fe640c2a 100644
--- a/src/library/scala/collection/mutable/History.scala
+++ b/src/library/scala/collection/mutable/History.scala
@@ -38,8 +38,8 @@ class History[A, B] extends AnyRef with Subscriber[A, B] with Collection[(B, A)]
   }
 
   override def size: Int = log.length
-  def elements: Iterator[(B, A)] = log.elements
-  def events: Iterator[A] = log.elements.map { case (_, e) => e }
+  def iterator: Iterator[(B, A)] = log.iterator
+  def events: Iterator[A] = log.iterator.map { case (_, e) => e }
 
   def clear(): Unit = log.clear
 }
diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
index 12c8140d8a..86d8facfc4 100644
--- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -40,13 +40,17 @@ extends Map[A, B]
 
   override def isDefinedAt(key: A) = imap.isDefinedAt(key)
 
-  override def keys: Iterator[A] = imap.keys
+  override def keys: collection.Set[A] = imap.keys
 
-  override def keySet: collection.Set[A] = imap.keySet
+  override def keysIterator: Iterator[A] = imap.keysIterator
 
-  override def values: Iterator[B] = imap.values
+  override def values: collection.Set[A] = imap.values
 
-  def elements: Iterator[(A, B)] = imap.elements
+  override def valuesIterator: Iterator[B] = imap.valuesIterator
+
+  def iterator: Iterator[(A, B)] = imap.iterator
+
+  @deprecated def elements = iterator
 
   override def toList: List[(A, B)] = imap.toList
 
diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
index af25841f84..bac4f95246 100644
--- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
@@ -39,7 +39,9 @@ class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A]
 
   override def toString = set.toString
 
-  def elements: Iterator[A] = set.elements
+  def iterator: Iterator[A] = set.iterator
+
+  @deprecated override def elements: Iterator[A] = iterator
 
   def +=(elem: A): this.type = { set = set + elem; this }
 
diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala
index 29e77fb01c..c43a3ee2f4 100644
--- a/src/library/scala/collection/mutable/LinkedHashMap.scala
+++ b/src/library/scala/collection/mutable/LinkedHashMap.scala
@@ -75,7 +75,7 @@ class LinkedHashMap[A, B] extends Map[A, B]
   def += (kv: (A, B)): this.type = { put(kv._1, kv._2); this }
   def -=(key: A): this.type = { remove(key); this }
 
-  def elements: Iterator[(A, B)] = new Iterator[(A, B)] {
+  def iterator: Iterator[(A, B)] = new Iterator[(A, B)] {
     private var cur = firstEntry
     def hasNext = cur ne null
     def next =
@@ -83,7 +83,7 @@ class LinkedHashMap[A, B] extends Map[A, B]
       else Iterator.empty.next
   }
 
-  override def keys: Iterator[A] = new Iterator[A] {
+  override def keysIterator: Iterator[A] = new Iterator[A] {
     private var cur = firstEntry
     def hasNext = cur ne null
     def next =
@@ -91,7 +91,7 @@ class LinkedHashMap[A, B] extends Map[A, B]
       else Iterator.empty.next
   }
 
-  override def values: Iterator[B] = new Iterator[B] {
+  override def valuesIterator: Iterator[B] = new Iterator[B] {
     private var cur = firstEntry
     def hasNext = cur ne null
     def next = { val res = cur.value; cur = cur.later; res }
diff --git a/src/library/scala/collection/mutable/LinkedHashSet.scala b/src/library/scala/collection/mutable/LinkedHashSet.scala
index 14f6b18722..f2825db975 100644
--- a/src/library/scala/collection/mutable/LinkedHashSet.scala
+++ b/src/library/scala/collection/mutable/LinkedHashSet.scala
@@ -47,7 +47,7 @@ class LinkedHashSet[A] extends Set[A]
     super.clear()
   }
 
-  override def elements = ordered.elements
+  override def iterator = ordered.iterator
 
   override def foreach[U](f: A => U) = ordered foreach f
 }
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index a83f620699..c75e18dcd1 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -277,7 +277,7 @@ final class ListBuffer[A]
     this
   }
 
-  override def elements = new Iterator[A] {
+  override def iterator = new Iterator[A] {
     var cursor: List[A] = null
     def hasNext: Boolean = !start.isEmpty && cursor != last0
     def next(): A =
@@ -309,7 +309,7 @@ final class ListBuffer[A]
    *
    *  @return a <code>ListBuffer</code> with the same elements.
    */
-  override def clone(): ListBuffer[A] = (new ListBuffer[A]) ++ this
+  override def clone(): ListBuffer[A] = (new ListBuffer[A]) ++= this
 
   /** Defines the prefix of the string representation.
    *
diff --git a/src/library/scala/collection/mutable/ListMap.scala b/src/library/scala/collection/mutable/ListMap.scala
index 8b8e5d87a6..a0d844cb5d 100644
--- a/src/library/scala/collection/mutable/ListMap.scala
+++ b/src/library/scala/collection/mutable/ListMap.scala
@@ -23,7 +23,7 @@ class ListMap[A, B] extends Map[A, B] with MutableMapTemplate[A, B, ListMap[A, B
   private var siz: Int = 0
 
   def get(key: A): Option[B] = elems find (_._1 == key) map (_._2)
-  def elements: Iterator[(A, B)] = elems.elements
+  def iterator: Iterator[(A, B)] = elems.iterator
   def += (kv: (A, B)) = { elems = remove(kv._1, elems); elems = kv :: elems; siz += 1; this }
   def -= (key: A) = { elems = remove(key, elems); this }
 
diff --git a/src/library/scala/collection/mutable/Map.scala b/src/library/scala/collection/mutable/Map.scala
index 94e376cd67..eab5b426a8 100644
--- a/src/library/scala/collection/mutable/Map.scala
+++ b/src/library/scala/collection/mutable/Map.scala
@@ -26,7 +26,7 @@ trait Map[A, B]
     override def size = self.size
     override def update(key: A, value: B) = self.update(key, value)
     override def - (elem: A) = self - elem
-    override def elements = self.elements
+    override def iterator = self.iterator
     override def foreach[U](f: ((A, B)) =>  U) = self.foreach(f)
     override def empty[C] = self.empty[C]
     def get(key: A) = self.get(key)
diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala
index 605d511f05..a2a283f2c4 100644
--- a/src/library/scala/collection/mutable/MutableList.scala
+++ b/src/library/scala/collection/mutable/MutableList.scala
@@ -92,8 +92,8 @@ class MutableList[A] extends LinearSequence[A] with LinearSequenceTemplate[A, Mu
 
   /** Returns an iterator over all elements of this list.
    */
-  override def elements: Iterator[A] =
-    if (first0 eq null) Iterator.empty else first0.elements
+  override def iterator: Iterator[A] =
+    if (first0 eq null) Iterator.empty else first0.iterator
 
   override def last = last0.elem
 
diff --git a/src/library/scala/collection/mutable/OpenHashMap.scala b/src/library/scala/collection/mutable/OpenHashMap.scala
index 5a0810cfe4..8373b4fdde 100644
--- a/src/library/scala/collection/mutable/OpenHashMap.scala
+++ b/src/library/scala/collection/mutable/OpenHashMap.scala
@@ -165,7 +165,7 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl
    * An iterator over the elements of this map. Use of this iterator follows the same
    * contract for concurrent modification as the foreach method.
    */
-  def elements = new Iterator[(Key, Value)]{
+  def iterator = new Iterator[(Key, Value)]{
     var index = 0;
     val initialModCount = modCount;
 
@@ -184,6 +184,9 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl
     }
   }
 
+  /** @deprecated use `iterator` instead */
+  @deprecated override def elements: Iterator[(Key, Value)] = iterator
+
   override def clone : OpenHashMap[Key, Value] = {
     val it = new OpenHashMap[Key, Value]
     foreachUndeletedEntry(entry => it.put(entry.key, entry.hash, entry.value.get));
diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala
index d013497389..1665c38dac 100644
--- a/src/library/scala/collection/mutable/PriorityQueue.scala
+++ b/src/library/scala/collection/mutable/PriorityQueue.scala
@@ -88,7 +88,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] with CloneableCol
    *
    *  @param  iter        an iterable object
    */
-  def ++=(iter: Iterable[A]): Unit = this ++= iter.elements
+  def ++=(iter: Iterable[A]): Unit = this ++= iter.iterator
 
   /** Adds all elements provided by an iterator into the priority queue.
    *
@@ -138,7 +138,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] with CloneableCol
    *
    *  @return  an iterator over all elements sorted in descending order.
    */
-  override def elements: Iterator[A] = new Iterator[A] {
+  override def iterator: Iterator[A] = new Iterator[A] {
     val as: Array[AnyRef] = new Array[AnyRef](size0)
     Array.copy(array, 0, as, 0, size0)
     var i = size0 - 1
@@ -158,7 +158,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] with CloneableCol
    */
   override def equals(obj: Any): Boolean = obj match {
     case that: PriorityQueue[_] =>
-      (this.elements zip that.elements) forall {
+      (this.iterator zip that.iterator) forall {
         case (thiselem, thatelem) => thiselem == thatelem
       }
     case _ =>
diff --git a/src/library/scala/collection/mutable/PriorityQueueProxy.scala b/src/library/scala/collection/mutable/PriorityQueueProxy.scala
index 7eab4df05e..de909fa470 100644
--- a/src/library/scala/collection/mutable/PriorityQueueProxy.scala
+++ b/src/library/scala/collection/mutable/PriorityQueueProxy.scala
@@ -31,7 +31,7 @@ abstract class PriorityQueueProxy[A <% Ordered[A]] extends PriorityQueue[A]
    *
    *  @return the new iterator
    */
-  override def elements: Iterator[A] = self.elements
+  override def iterator: Iterator[A] = self.iterator
 
   /** Returns the length of this priority queue.
    */
diff --git a/src/library/scala/collection/mutable/QueueProxy.scala b/src/library/scala/collection/mutable/QueueProxy.scala
index cfe364108a..cd3ca80c5e 100644
--- a/src/library/scala/collection/mutable/QueueProxy.scala
+++ b/src/library/scala/collection/mutable/QueueProxy.scala
@@ -90,7 +90,7 @@ trait QueueProxy[A] extends Queue[A] with SeqProxy[A] {
    *
    *  @return an iterator over all queue elements.
    */
-  override def elements: Iterator[A] = self.elements
+  override def iteratoor: Iterator[A] = self.iterator
 
   /** This method clones the queue.
    *
diff --git a/src/library/scala/collection/mutable/Set.scala b/src/library/scala/collection/mutable/Set.scala
index 8118f8a58f..d17dee1753 100644
--- a/src/library/scala/collection/mutable/Set.scala
+++ b/src/library/scala/collection/mutable/Set.scala
@@ -17,7 +17,7 @@ import generic._
  *  have to provide functionality for the abstract methods in Set:
  *
  *  def contains(elem: A): Boolean
- *  def elements: Iterator[A]
+ *  def iterator: Iterator[A]
  *  def += (elem: A): this.type
  *  def -= (elem: A): this.type
  *
diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala
index b63a07dbb1..b079a94f92 100644
--- a/src/library/scala/collection/mutable/Stack.scala
+++ b/src/library/scala/collection/mutable/Stack.scala
@@ -111,7 +111,7 @@ class Stack[A] private (var elems: List[A]) extends collection.Sequence[A] with
    *
    *  @return an iterator over all stack elements.
    */
-  override def elements: Iterator[A] = elems.elements
+  override def iterator: Iterator[A] = elems.iterator
 
   /** Creates a list of all stack elements in LIFO order.
    *
diff --git a/src/library/scala/collection/mutable/StackProxy.scala b/src/library/scala/collection/mutable/StackProxy.scala
index 1833af0f33..cb7f180849 100644
--- a/src/library/scala/collection/mutable/StackProxy.scala
+++ b/src/library/scala/collection/mutable/StackProxy.scala
@@ -94,7 +94,7 @@ trait StackProxy[A] extends Stack[A] with SeqProxy[A] {
    *
    *  @return an iterator over all stack elements.
    */
-  override def elements: Iterator[A] = self.elements
+  override def iterator: Iterator[A] = self.iterator
 
   /** Creates a list of all stack elements in FIFO order.
    *
diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
index 4209dff391..58c8d749bb 100644
--- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala
+++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
@@ -26,8 +26,8 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
     super.length
   }
 
-  abstract override def elements: Iterator[A] = synchronized {
-    super.elements
+  abstract override def iterator: Iterator[A] = synchronized {
+    super.iterator
   }
 
   abstract override def apply(n: Int): A = synchronized {
@@ -52,7 +52,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -62,7 +62,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method.
+   *  via its <code>iterator</code> method.
    *
    *  @param iter  the iterable object.
    */
@@ -79,7 +79,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Appends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method.
+   *  via its <code>iterator</code> method.
    *
    *  @param iter  the iterable object.
    */
@@ -97,7 +97,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
@@ -115,7 +115,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Prepends a number of elements provided by an iterable object
-   *  via its <code>elements</code> method. The identity of the
+   *  via its <code>iterator</code> method. The identity of the
    *  buffer is returned.
    *
    *  @param iter  the iterable object.
diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala
index 4b30ce5d4b..61c9b50568 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] {
 
   abstract override def get(key: A): Option[B] = synchronized { super.get(key) }
-  abstract override def elements: Iterator[(A, B)] = synchronized { super.elements }
+  abstract override def iterator: Iterator[(A, B)] = synchronized { super.iterator }
   abstract override def += (kv: (A, B)): this.type = synchronized[this.type] { super.+=(kv) }
   abstract override def -= (key: A): this.type = synchronized[this.type] { super.-=(key) }
 
@@ -33,11 +33,13 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
   override def getOrElseUpdate(key: A, default: => B): B = synchronized { super.getOrElseUpdate(key, default) }
   override def transform(f: (A, B) => B): this.type = synchronized[this.type] { super.transform(f) }
   override def retain(p: (A, B) => Boolean): this.type = synchronized[this.type] { super.retain(p) }
-  override def valueSet = synchronized { super.valueSet }
+  override def values: collection.immutable.Set[B] = synchronized { super.values }
+  override def valuesIterator: Iterator[B] = synchronized { super.valuesIterator }
   override def clone() = synchronized { super.clone() }
   override def foreach[U](f: ((A, B)) => U) = synchronized { super.foreach(f) }
   override def apply(key: A): B = synchronized { super.apply(key) }
-  override def keys: Iterator[A] = synchronized { super.keys }
+  override def keys: collection.Set[A] = synchronized { super.keys }
+  override def keysIterator: Iterator[A] = synchronized { super.keysIterator }
   override def isEmpty: Boolean = synchronized { super.isEmpty }
   override def contains(key: A): Boolean = synchronized {super.contains(key) }
   override def isDefinedAt(key: A) = synchronized { super.isDefinedAt(key) }
diff --git a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
index f500b46aa0..65cb592f0b 100644
--- a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
+++ b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
@@ -77,7 +77,7 @@ class SynchronizedPriorityQueue[A <% Ordered[A]] extends PriorityQueue[A] {
    *
    *  @return  an iterator over all elements sorted in descending order.
    */
-  override def elements: Iterator[A] = synchronized { super.elements }
+  override def iterator: Iterator[A] = synchronized { super.iterator }
 
   /** Checks if two queues are structurally identical.
    *
diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala
index 4c0f63cd76..740449ffe7 100644
--- a/src/library/scala/collection/mutable/SynchronizedStack.scala
+++ b/src/library/scala/collection/mutable/SynchronizedStack.scala
@@ -84,7 +84,7 @@ class SynchronizedStack[A] extends Stack[A] {
    *
    *  @return an iterator over all stack elements.
    */
-  override def elements: Iterator[A] = synchronized { super.elements }
+  override def iterator: Iterator[A] = synchronized { super.iterator }
 
   /** Creates a list of all stack elements in FIFO order.
    *
diff --git a/src/library/scala/collection/script/Message.scala b/src/library/scala/collection/script/Message.scala
index 670a8a426a..c4bf81eebc 100644
--- a/src/library/scala/collection/script/Message.scala
+++ b/src/library/scala/collection/script/Message.scala
@@ -72,7 +72,7 @@ class Script[A] extends ArrayBuffer[Message[A]] with Message[A] {
 
   override def toString(): String = {
     var res = "Script("
-    var it = elements
+    var it = this.iterator
     var i = 1
     while (it.hasNext) {
       if (i > 1)
diff --git a/src/library/scala/io/BytePickle.scala b/src/library/scala/io/BytePickle.scala
index ad2be7b9b2..135d608eb9 100644
--- a/src/library/scala/io/BytePickle.scala
+++ b/src/library/scala/io/BytePickle.scala
@@ -69,8 +69,8 @@ object BytePickle {
         case Def() => Array.concat(s, (List[Byte](1)).toArray)
       };
     def appU(s: Array[Byte]): (RefDef, Array[Byte]) =
-      if (s(0) == 0) (Ref(), s.subArray(1, s.length))
-      else (Def(), s.subArray(1, s.length));
+      if (s(0) == 0) (Ref(), s.slice(1, s.length))
+      else (Def(), s.slice(1, s.length));
   }
 
   val REF = 0
@@ -91,7 +91,7 @@ object BytePickle {
         } while ((b & 0x80) != 0);
         x
       }
-      (readNat, s.subArray(num, s.length))
+      (readNat, s.slice(num, s.length))
     }
   }
 
@@ -260,7 +260,7 @@ object BytePickle {
         } while ((b & 0x80) != 0);
         x
       }
-      (readNat, new UnPicklerState(s.stream.subArray(num, s.stream.length), s.dict))
+      (readNat, new UnPicklerState(s.stream.slice(num, s.stream.length), s.dict))
     }
   }
 
@@ -268,7 +268,7 @@ object BytePickle {
     def appP(b: Byte, s: PicklerState): PicklerState =
       new PicklerState(Array.concat(s.stream, (List[Byte](b)).toArray), s.dict);
     def appU(s: UnPicklerState): (Byte, UnPicklerState) =
-      (s.stream(0), new UnPicklerState(s.stream.subArray(1, s.stream.length), s.dict));
+      (s.stream(0), new UnPicklerState(s.stream.slice(1, s.stream.length), s.dict));
   }
 
   def string: SPU[String] =
diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala
index 3b79202b41..03c2e4dc00 100644
--- a/src/library/scala/io/Source.scala
+++ b/src/library/scala/io/Source.scala
@@ -68,7 +68,7 @@ object Source {
    *  @return      ...
    */
   def fromChars(chars: Array[Char]): Source = {
-    val it = chars.elements
+    val it = chars.iterator
     new Source {
       def reset() = fromChars(chars)
       val iter = it
@@ -81,7 +81,7 @@ object Source {
    *  @return  ...
    */
   def fromString(s: String): Source = {
-    val it = s.elements
+    val it = s.iterator
     new Source {
       def reset() = fromString(s)
       val iter = it
diff --git a/src/library/scala/io/UTF8Codec.scala b/src/library/scala/io/UTF8Codec.scala
index 6d5e569971..d07354b117 100644
--- a/src/library/scala/io/UTF8Codec.scala
+++ b/src/library/scala/io/UTF8Codec.scala
@@ -85,7 +85,7 @@ object UTF8Codec {
   def encode(s: String): Array[Byte] = {
     val dst = new Array[Byte](s.length() * 3)
     val len = encode(s, dst, 0)
-    dst.subArray(0, len)
+    dst.slice(0, len)
   }
 
   def decode(src: Array[Byte], from: Int,
diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala
index 04bb00113c..91651a9cec 100644
--- a/src/library/scala/runtime/BoxedArray.scala
+++ b/src/library/scala/runtime/BoxedArray.scala
@@ -86,10 +86,10 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray
     }
     val buf = new StringBuilder()
     buf.append(start)
-    val elems = elements
-    if (elems.hasNext) buf.append(_deepToString(elems.next))
-    while (elems.hasNext) {
-      buf.append(sep); buf.append(_deepToString(elems.next))
+    val iter = this.iterator
+    if (iter.hasNext) buf.append(_deepToString(iter.next))
+    while (iter.hasNext) {
+      buf.append(sep); buf.append(_deepToString(iter.next))
     }
     buf.append(end)
     buf.toString
@@ -108,8 +108,8 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray
         x1.equals(x2)
     }
     def _sameElements(a1: BoxedArray[_], a2: BoxedArray[_]): Boolean = {
-      val it1 = a1.elements
-      val it2 = a2.elements
+      val it1 = a1.iterator
+      val it2 = a2.iterator
       var res = true
       while (res && it1.hasNext && it2.hasNext)
         res = _deepEquals(it1.next, it2.next)
diff --git a/src/library/scala/runtime/RichString.scala b/src/library/scala/runtime/RichString.scala
index 470cefabfe..6fc8f1e9a6 100644
--- a/src/library/scala/runtime/RichString.scala
+++ b/src/library/scala/runtime/RichString.scala
@@ -97,7 +97,7 @@ class RichString(val self: String) extends Proxy with Vector[Char] with VectorTe
    *    <li>FF - form feed   (0x0C hex)</li>
    *  </ul>
    */
-  def linesWithSeparators = new Iterator[String] {
+  def linesWithSeparators: Iterator[String] = new Iterator[String] {
     private val len = self.length
     private var index = 0
     def hasNext: Boolean = index < len
@@ -117,6 +117,13 @@ class RichString(val self: String) extends Proxy with Vector[Char] with VectorTe
   def lines: Iterator[String] =
     linesWithSeparators map (line => new RichString(line).stripLineEnd)
 
+  /** Return all lines in this string in an iterator, excluding trailing line
+   *  end characters, i.e. apply <code>.stripLineEnd</code> to all lines
+   *  returned by <code>linesWithSeparators</code>.
+   */
+  def linesIterator: Iterator[String] =
+    linesWithSeparators map (line => new RichString(line).stripLineEnd)
+
   /** Returns this string with first character converted to upper case */
   def capitalize: String =
     if (self == null) null
diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala
index 78298a16e6..86aa61aec2 100644
--- a/src/library/scala/runtime/ScalaRunTime.scala
+++ b/src/library/scala/runtime/ScalaRunTime.scala
@@ -21,7 +21,7 @@ object ScalaRunTime {
   def forceBoxedArray[A <: Any](xs: Seq[A]): Array[A] = {
     val array = new Array[A](xs.length)
     var i = 0
-    for (x <- xs.elements) { array(i) = x; i += 1 }
+    for (x <- xs.iterator) { array(i) = x; i += 1 }
     array
   }
 
diff --git a/src/library/scala/testing/SUnit.scala b/src/library/scala/testing/SUnit.scala
index 22e5a8dfdd..1a333397a7 100644
--- a/src/library/scala/testing/SUnit.scala
+++ b/src/library/scala/testing/SUnit.scala
@@ -128,7 +128,7 @@ object SUnit {
       buf.length
 
     def failures() =
-      buf.elements map { x => new TestFailure(x) }
+      buf.iterator map { x => new TestFailure(x) }
   }
 
   /** The class <code>TestSuite</code> runs a composite of test cases.
diff --git a/src/library/scala/util/automata/BaseBerrySethi.scala b/src/library/scala/util/automata/BaseBerrySethi.scala
index d35e84fd83..6960407ebf 100644
--- a/src/library/scala/util/automata/BaseBerrySethi.scala
+++ b/src/library/scala/util/automata/BaseBerrySethi.scala
@@ -45,7 +45,7 @@ abstract class BaseBerrySethi {
   protected def compFirst(r: RegExp): immutable.Set[Int] = r match {
     case x:Alt =>
       var tmp = emptySet
-      val it = x.rs.elements                       // union
+      val it = x.rs.iterator                       // union
       while (it.hasNext) { tmp = tmp ++ compFirst(it.next) }
       tmp
     case Eps =>
@@ -55,7 +55,7 @@ abstract class BaseBerrySethi {
       compFirst(x.r)
     case x:Sequ =>
       var tmp = emptySet;
-      val it = x.rs.elements;                       // union
+      val it = x.rs.iterator;                       // union
       while (it.hasNext) {
 	val z = it.next
 	tmp = tmp ++ compFirst(z)
@@ -73,7 +73,7 @@ abstract class BaseBerrySethi {
   protected def compLast(r: RegExp): immutable.Set[Int] = r match {
     case x:Alt =>
       var tmp = emptySet
-      val it = x.rs.elements                      // union
+      val it = x.rs.iterator                      // union
       while (it.hasNext) { tmp = tmp ++ compFirst(it.next) }
       tmp
     case Eps =>
@@ -83,7 +83,7 @@ abstract class BaseBerrySethi {
       compLast(x.r)
     case x:Sequ =>
       var tmp = emptySet
-      val it = x.rs.elements.toList.reverse.elements       // union
+      val it = x.rs.iterator.toList.reverse.iterator       // union
       while (it.hasNext) {
         val z = it.next
         tmp = tmp ++ compLast(z)
@@ -109,7 +109,7 @@ abstract class BaseBerrySethi {
     var fol = emptySet
     if (r.length > 0) {//non-empty expr
 
-      val it = r.elements.toList.reverse.elements
+      val it = r.iterator.toList.reverse.iterator
 
       fol = fol + pos // don't modify pos !
       while (it.hasNext) {
@@ -137,7 +137,7 @@ abstract class BaseBerrySethi {
 
       case x:Alt =>
         var first = emptySet
-        val it = x.rs.elements.toList.reverse.elements
+        val it = x.rs.iterator.toList.reverse.iterator
         while (it.hasNext)
           first = first ++ compFollow1(fol, it.next);
         first
@@ -157,7 +157,7 @@ abstract class BaseBerrySethi {
 
       case x:Sequ =>
         var first = emptySet
-        val it = x.rs.elements.toList.reverse.elements
+        val it = x.rs.iterator.toList.reverse.iterator
         while (it.hasNext) {
           val p = it.next
           first = compFollow1(fol, p)
@@ -181,10 +181,10 @@ abstract class BaseBerrySethi {
   protected def traverse(r: RegExp): Unit = r match {
     // (is tree automaton stuff, more than Berry-Sethi)
     case x:Alt =>
-      val it = x.rs.elements
+      val it = x.rs.iterator
       while (it.hasNext) traverse(it.next)
     case x:Sequ =>
-      val it = x.rs.elements
+      val it = x.rs.iterator
       while (it.hasNext) traverse(it.next)
     case x:Meta =>
       traverse(x.r)
diff --git a/src/library/scala/util/automata/WordBerrySethi.scala b/src/library/scala/util/automata/WordBerrySethi.scala
index 873f85cf4f..02632ac327 100644
--- a/src/library/scala/util/automata/WordBerrySethi.scala
+++ b/src/library/scala/util/automata/WordBerrySethi.scala
@@ -140,7 +140,7 @@ abstract class WordBerrySethi extends BaseBerrySethi {
 
     // determine "Sethi-length" of the regexp
     //activeBinders = new Vector()
-    var it = subexpr.elements
+    var it = subexpr.iterator
     while (it.hasNext)
       traverse(it.next)
 
@@ -167,7 +167,7 @@ abstract class WordBerrySethi extends BaseBerrySethi {
     var j = 0; while (j < pos) {
       //Console.println("WBS.collectTrans, j = "+j)
       val fol = this.follow(j)
-      val it = fol.elements
+      val it = fol.iterator
       while (it.hasNext) {
         val k = it.next
         if (pos == k)
@@ -218,7 +218,7 @@ abstract class WordBerrySethi extends BaseBerrySethi {
         }
 
         val initialsArr = new Array[Int](initials.size)
-        val it = initials.elements
+        val it = initials.iterator
 
         {
           var k = 0; while (k < initials.size) {
diff --git a/src/library/scala/util/parsing/ast/Binders.scala b/src/library/scala/util/parsing/ast/Binders.scala
index 75ce3b28d0..addcc1d9fd 100644
--- a/src/library/scala/util/parsing/ast/Binders.scala
+++ b/src/library/scala/util/parsing/ast/Binders.scala
@@ -102,17 +102,17 @@ trait Binders extends AbstractSyntax with Mappable {
      * For a typical let-binding, this is just the variable name. For an argument list to a method body,
      * there is one binder per formal argument.
      */
-    def elements = substitution.keys
+    def iterator = substitution.keysIterator
 
     /** Return the `i'th binder in this scope.*/
-    def apply(i: Int): binderType = elements.toList(i)
+    def apply(i: Int): binderType = this.iterator.toList(i)
 
     /** Returns true if this container has a binder equal (==) to `b'
      */
     def binds(b: binderType): Boolean = substitution.contains(b)
 
     def indexFor(b: binderType): Option[Int] = {
-      val iter = elements.counted
+      val iter = this.iterator.counted
       for (that <- iter) {
         if (that.name == b.name) // TODO: why do name equals and structural equals differ?
           return Some(iter.count)
@@ -164,10 +164,10 @@ trait Binders extends AbstractSyntax with Mappable {
      */
     def getElementFor(b: binderType): Element = substitution(b)
 
-    override def toString: String =  elements.toList.mkString("[",", ","]")+"!"+id // TODO show substitution?
+    override def toString: String =  this.iterator.toList.mkString("[",", ","]")+"!"+id // TODO show substitution?
 
     /** Returns a list of strings that represent the binder elements, each tagged with this scope's id.*/
-    def bindersToString: List[String] = (for(val b <- elements) yield b+"!"+id).toList
+    def bindersToString: List[String] = (for(b <- this.iterator) yield b+"!"+id).toList
 
     /** Return a new inheriting scope that won't check whether binding is respected until the scope is left (so as to support forward references) **/
     def allowForwardRef: Scope[binderType] = this // TODO
@@ -276,7 +276,7 @@ trait Binders extends AbstractSyntax with Mappable {
   implicit def ScopeIsMappable[bt <: NameElement <% Mappable[bt]](scope: Scope[bt]): Mappable[Scope[bt]] =
     new Mappable[Scope[bt]] {
       def gmap(f: Mapper): Scope[bt] = { val newScope = new Scope[bt]()
-        for(val b <- scope) newScope.addBinder(f(b))
+        for(b <- scope) newScope.addBinder(f(b))
         newScope
       }
     }
diff --git a/src/library/scala/util/parsing/combinator/PackratParsers.scala b/src/library/scala/util/parsing/combinator/PackratParsers.scala
index f99c5e6ae5..da09eff597 100644
--- a/src/library/scala/util/parsing/combinator/PackratParsers.scala
+++ b/src/library/scala/util/parsing/combinator/PackratParsers.scala
@@ -184,7 +184,7 @@ trait PackratParsers extends Parsers {
         if(evalSet contains p){
           //something in cache, and p is in the evalSet
           //remove the rule from the evalSet of the Head
-          h.evalSet = h.evalSet.remove(_==p)
+          h.evalSet = h.evalSet.filterNot(_==p)
           val tempRes = p(in)
           //we know that cached has an entry here
           val tempEntry: MemoEntry[_] = cached.get // match {case Some(x: MemoEntry[_]) => x}
diff --git a/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala b/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala
index 6596312ece..b2328bba0e 100644
--- a/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala
+++ b/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala
@@ -132,7 +132,7 @@ trait BindingParsers extends Parsers with Binders {
     val oldEnv = binderEnv // save old environment
 
     // bring binders in the scope in scope
-    for(val b <- scope) binderEnv = binderEnv.extend(b, scope)
+    for(b <- scope) binderEnv = binderEnv.extend(b, scope)
 
     // return the result of running block (in which these binders are in scope)
     // before returning, the binderEnv is restored to its old value
diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala
index f41bb4e749..85bddbef16 100644
--- a/src/library/scala/xml/Elem.scala
+++ b/src/library/scala/xml/Elem.scala
@@ -80,7 +80,7 @@ object Elem {
     */
    override def text = {
      val sb = new StringBuilder()
-     val it = child.elements
+     val it = child.iterator
      while (it.hasNext)
        sb.append(it.next.text)
      sb.toString()
diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala
index d947e40ee3..aafedf7702 100644
--- a/src/library/scala/xml/MetaData.scala
+++ b/src/library/scala/xml/MetaData.scala
@@ -164,7 +164,7 @@ abstract class MetaData extends Iterable[MetaData] {
     that match {
       case m: MetaData =>
         var res = (this.length == m.length) && (this.hashCode() == m.hashCode())
-        val it = this.elements
+        val it = this.iterator
         while (res && it.hasNext) { res = it.next.containedIn1(m) }
         res
       case _ =>
@@ -172,7 +172,7 @@ abstract class MetaData extends Iterable[MetaData] {
     }
 
   /** returns an iterator on attributes */
-  def elements: Iterator[MetaData] = new Iterator[MetaData] {
+  def iterator: Iterator[MetaData] = new Iterator[MetaData] {
     var x: MetaData = MetaData.this
     def hasNext = Null != x
     def next = {
diff --git a/src/library/scala/xml/NodeBuffer.scala b/src/library/scala/xml/NodeBuffer.scala
index cde6870ead..d83876e255 100644
--- a/src/library/scala/xml/NodeBuffer.scala
+++ b/src/library/scala/xml/NodeBuffer.scala
@@ -47,13 +47,13 @@ class NodeBuffer extends scala.collection.mutable.ArrayBuffer[Node] {
           this &+ it.next
 
       case n:Node =>
-        super.+(n)
+        super.+=(n)
 
       case ns:Iterable[_] =>
-        this &+ ns.elements
+        this &+ ns.iterator
 
       case d =>
-        super.+(new Atom(d))
+        super.+=(new Atom(d))
     }
     this
   }
diff --git a/src/library/scala/xml/NodeSeq.scala b/src/library/scala/xml/NodeSeq.scala
index c17b99b2e6..13e0566893 100644
--- a/src/library/scala/xml/NodeSeq.scala
+++ b/src/library/scala/xml/NodeSeq.scala
@@ -45,7 +45,7 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
 
   def theSeq: Seq[Node]
   def length = theSeq.length
-  override def elements = theSeq.elements
+  override def iterator = theSeq.iterator
   def apply(i: Int): Node = theSeq.apply(i)
 
   def apply(f: Node => Boolean): NodeSeq = filter(f)
@@ -76,10 +76,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
   def \(that: String): NodeSeq = that match {
     case "_" =>
       var zs: List[Node] = Nil
-      val it = this.elements
+      val it = this.iterator
       while (it.hasNext) {
         val x = it.next
-        val jt = x.child.elements
+        val jt = x.child.iterator
         while (jt.hasNext) {
           val y = jt.next
           if (y.typeTag$ != -1)
@@ -114,10 +114,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
 
     case _   =>
       var zs: List[Node] = Nil
-      val it = this.elements
+      val it = this.iterator
       while (it.hasNext) {
         val x = it.next
-        val jt = x.child.elements
+        val jt = x.child.iterator
         while (jt.hasNext) {
           val y = jt.next
           if (y.label == that)
@@ -145,10 +145,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
   def \\ (that: String): NodeSeq = that match {
     case "_" =>
       var zs: List[Node] = Nil
-      val it = this.elements
+      val it = this.iterator
       while (it.hasNext) {
         val x = it.next
-        val jt = x.descendant_or_self.elements
+        val jt = x.descendant_or_self.iterator
         while (jt.hasNext) {
           val y = jt.next
           if (y.typeTag$ != -1)
@@ -159,14 +159,14 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
 
     case _ if that.charAt(0) == '@' =>
       var zs: List[Node] = Nil
-      val it = this.elements
+      val it = this.iterator
       while (it.hasNext) {
         val x = it.next
-        val jt = x.descendant_or_self.elements
+        val jt = x.descendant_or_self.iterator
         while (jt.hasNext) {
           val y = jt.next
           if (y.typeTag$ != -1) {
-            val kt = (y \ that).elements
+            val kt = (y \ that).iterator
             while (kt.hasNext) {
               zs = (kt.next)::zs
             }
@@ -177,10 +177,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
 
     case _ =>
       var zs: List[Node] = Nil
-      val it = this.elements
+      val it = this.iterator
       while (it.hasNext) {
         val x = it.next
-        val jt = x.descendant_or_self.elements
+        val jt = x.descendant_or_self.iterator
         while (jt.hasNext) {
           val y = jt.next
           if (y.typeTag$ != -1 && y.label == that)
@@ -190,7 +190,7 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
     zs.reverse
   }
 
-  override def toString(): String = theSeq.elements.foldLeft ("") {
+  override def toString(): String = theSeq.iterator.foldLeft ("") {
     (s: String, x: Node) => s + x.toString()
   }
 /*
@@ -209,7 +209,7 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
 
   def text: String = {
     val sb = new StringBuilder()
-    val it = elements
+    val it = this.iterator
     while (it.hasNext) {
       sb.append(it.next.text)
     }
diff --git a/src/library/scala/xml/Null.scala b/src/library/scala/xml/Null.scala
index b269672b8c..5885201acd 100644
--- a/src/library/scala/xml/Null.scala
+++ b/src/library/scala/xml/Null.scala
@@ -21,7 +21,7 @@ case object Null extends MetaData {
   /** returns its argument */
   def copy(next: MetaData) = next
 
-  override def elements = Iterator.empty
+  override def iterator = Iterator.empty
 
   override def filter(f: MetaData => Boolean): MetaData = this
 
diff --git a/src/library/scala/xml/Parsing.scala b/src/library/scala/xml/Parsing.scala
index 076a6e7074..7d5545233f 100644
--- a/src/library/scala/xml/Parsing.scala
+++ b/src/library/scala/xml/Parsing.scala
@@ -30,7 +30,7 @@ object Parsing {
 
   /** <pre>(#x20 | #x9 | #xD | #xA)+</pre> */
   final def isSpace(cs: Seq[Char]): Boolean = {
-    val it = cs.elements
+    val it = cs.iterator
     it.hasNext && it.forall { isSpace }
   }
 
@@ -75,7 +75,7 @@ object Parsing {
   def isName(s: String): Boolean =
     if (s.length() > 0) {
       val z: Seq[Char] = s
-      val y = z.elements
+      val y = z.iterator
       if (isNameStart(y.next)) {
         while (y.hasNext && isNameChar(y.next)) {}
         !y.hasNext
@@ -97,7 +97,7 @@ object Parsing {
   def checkPubID(s: String): Boolean =
     if (s.length() > 0) {
       val z:Seq[Char] = s
-      val y = z.elements
+      val y = z.iterator
       while (y.hasNext && isPubIDChar(y.next)) {}
       !y.hasNext
     } else true
diff --git a/src/library/scala/xml/PrettyPrinter.scala b/src/library/scala/xml/PrettyPrinter.scala
index 11b219d99d..e97a2e0f59 100644
--- a/src/library/scala/xml/PrettyPrinter.scala
+++ b/src/library/scala/xml/PrettyPrinter.scala
@@ -91,7 +91,7 @@ class PrettyPrinter( width:Int, step:Int ) {
       items = Box(ind, s) :: items
       cur += s.length
     } else try {
-      for (b <- cut(s, ind).elements)  // break it up
+      for (b <- cut(s, ind).iterator)  // break it up
         items = b :: items
     } catch {
       case _:BrokenException => makePara(ind, s) // give up, para
@@ -168,7 +168,7 @@ class PrettyPrinter( width:Int, step:Int ) {
       case _:Atom[_] | _:Comment | _:EntityRef | _:ProcInstr =>
         makeBox( ind, node.toString().trim() )
       case g @ Group(xs) =>
-        traverse(xs.elements, pscope, ind)
+        traverse(xs.iterator, pscope, ind)
       case _ =>
         val test = {
           val sb = new StringBuilder()
@@ -184,7 +184,7 @@ class PrettyPrinter( width:Int, step:Int ) {
           if (stg.length < width - cur) { // start tag fits
             makeBox(ind, stg)
             makeBreak()
-            traverse(node.child.elements, node.scope, ind + step)
+            traverse(node.child.iterator, node.scope, ind + step)
             makeBox(ind, etg)
           } else if (len2 < width - cur) {
             // <start label + attrs + tag + content + end tag
@@ -192,7 +192,7 @@ class PrettyPrinter( width:Int, step:Int ) {
             makeBreak() // todo: break the rest in pieces
             /*{ //@todo
              val sq:Seq[String] = stg.split(" ");
-             val it = sq.elements;
+             val it = sq.iterator;
              it.next;
              for (c <- it) {
                makeBox(ind+len2-2, c)
@@ -201,7 +201,7 @@ class PrettyPrinter( width:Int, step:Int ) {
              }*/
             makeBox(ind, stg.substring(len2, stg.length))
             makeBreak()
-            traverse(node.child.elements, node.scope, ind + step)
+            traverse(node.child.iterator, node.scope, ind + step)
             makeBox(cur, etg)
             makeBreak()
           } else { // give up
@@ -300,7 +300,7 @@ class PrettyPrinter( width:Int, step:Int ) {
    *  @param sb   the string buffer to which to append to
    */
   def formatNodes(nodes: Seq[Node], pscope: NamespaceBinding, sb: StringBuilder): Unit =
-    for (n <- nodes.elements) {
+    for (n <- nodes.iterator) {
       sb.append(format(n, pscope))
     }
 
diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala
index f7f7171580..635585f79c 100644
--- a/src/library/scala/xml/Utility.scala
+++ b/src/library/scala/xml/Utility.scala
@@ -102,7 +102,7 @@ object Utility extends AnyRef with parsing.TokenTests
    * @return     ...
    */
   final def escape(text: String, s: StringBuilder): StringBuilder = {
-    for (c <- text.elements) c match {
+    for (c <- text.iterator) c match {
       case '<' => s.append("&lt;")
       case '>' => s.append("&gt;")
       case '&' => s.append("&amp;")
@@ -141,7 +141,7 @@ object Utility extends AnyRef with parsing.TokenTests
    */
   def collectNamespaces(nodes: Seq[Node]): Set[String] = {
     var m = new HashSet[String]()
-    val it = nodes.elements
+    val it = nodes.iterator
     while (it.hasNext)
       collectNamespaces(it.next, m);
     m
@@ -247,7 +247,7 @@ object Utility extends AnyRef with parsing.TokenTests
 
     if (children.isEmpty) return
     else if (children forall isAtomAndNotText) { // add space
-      val it = children.elements
+      val it = children.iterator
       val f = it.next
       toXML(f, pscope, sb)
       while (it.hasNext) {
@@ -285,7 +285,7 @@ object Utility extends AnyRef with parsing.TokenTests
     + scpeHash * 31
     + {
       var c = 0
-      val i = children.elements
+      val i = children.iterator
       while(i.hasNext) c = c * 41 + i.next.hashCode
       c
     }
@@ -379,7 +379,7 @@ object Utility extends AnyRef with parsing.TokenTests
     val sb  = new StringBuilder
     var rfb: StringBuilder = null
     val nb = new NodeBuffer()
-    val it = zs.elements
+    val it = zs.iterator
     while (it.hasNext) {
       var c = it.next
       c match {
diff --git a/src/library/scala/xml/dtd/ContentModel.scala b/src/library/scala/xml/dtd/ContentModel.scala
index a1e2ea0aa5..24d7840ec3 100644
--- a/src/library/scala/xml/dtd/ContentModel.scala
+++ b/src/library/scala/xml/dtd/ContentModel.scala
@@ -35,7 +35,7 @@ object ContentModel extends WordExp {
   def getLabels(r: RegExp): scala.collection.Set[String] = {
     val s = new scala.collection.mutable.HashSet[String]()
     def traverse1(xs: Seq[RegExp]) {
-      val it = xs.elements
+      val it = xs.iterator
       while (it.hasNext) traverse(it.next)
     }
     def traverse(r: RegExp) {
@@ -54,7 +54,7 @@ object ContentModel extends WordExp {
 
   /* precond: rs.length >= 1 */
   private def buildString(rs: Seq[RegExp], sb: StringBuilder, sep: Char) {
-    val it = rs.elements
+    val it = rs.iterator
     val fst = it.next
     buildString(fst, sb)
     for (z <- it) {
@@ -136,7 +136,7 @@ case class MIXED(r: ContentModel.RegExp) extends DFAContentModel {
     def cond(n:Node) =
       !n.isInstanceOf[Text] && !n.isInstanceOf[SpecialNode];
 Console.println("ns = "+ns);
-    val jt = ns.elements;
+    val jt = ns.iterator;
     def hasNext = jt.hasNext;
     def next = {
       var r: Node = jt.next;
@@ -162,7 +162,7 @@ Console.println("ns = "+ns);
 case class  ELEMENTS(r:ContentModel.RegExp) extends DFAContentModel {
   /*
   def getIterator(ns:NodeSeq) = new Iterator[String] {
-    val jt = ns.elements.buffered;
+    val jt = ns.iterator.buffered;
     def hasNext = jt.hasNext;
     def next = {
       var r: Node = jt.next;
diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala
index de969cab64..53fe483bc2 100644
--- a/src/library/scala/xml/dtd/ElementValidator.scala
+++ b/src/library/scala/xml/dtd/ElementValidator.scala
@@ -58,8 +58,8 @@ class ElementValidator() extends Function1[Node,Boolean] {
             case _ =>
               x.namespace eq null
           }}
-          . map { x => ElemName(x.label) }
-          . elements;
+          .map { x => ElemName(x.label) }
+          .iterator;
 
   /** check attributes, return true if md corresponds to attribute declarations in adecls.
    */
@@ -71,7 +71,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
     var ok = new scala.collection.mutable.BitSet(adecls.length);
     def find(Key:String): AttrDecl = {
       var attr: AttrDecl = null;
-      val jt = adecls.elements; while(j < adecls.length) {
+      val jt = adecls.iterator; while(j < adecls.length) {
         jt.next match {
           case a @ AttrDecl(Key, _, _) => attr = a; ok += j; j = adecls.length;
           case _                       => j = j + 1;
@@ -79,7 +79,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
       }
       attr
     }
-    val it = md.elements; while(it.hasNext) {
+    val it = md.iterator; while(it.hasNext) {
       val attr = it.next
       j = 0
       find(attr.key) match {
@@ -99,7 +99,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
 
     //val missing = ok.toSet(false); FIXME: it doesn't seem to be used anywhere
     j = 0
-    var kt = adecls.elements
+    var kt = adecls.iterator
     while (kt.hasNext) {
       kt.next match {
         case AttrDecl(key, tpe, REQUIRED) if !ok(j) =>
@@ -129,7 +129,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
       val j = exc.length
       def find(Key: String): Boolean = {
         var res = false
-        val jt = branches.elements
+        val jt = branches.iterator
         while (jt.hasNext && !res)
           jt.next match { // !!! check for match translation problem
             case ContentModel.Letter(ElemName(Key)) => res = true;
diff --git a/src/library/scala/xml/dtd/Scanner.scala b/src/library/scala/xml/dtd/Scanner.scala
index 0bb8d99b74..49f36aabf9 100644
--- a/src/library/scala/xml/dtd/Scanner.scala
+++ b/src/library/scala/xml/dtd/Scanner.scala
@@ -28,7 +28,7 @@ class Scanner extends Tokens with parsing.TokenTests {
   /** initializes the scanner on input s */
   final def initScanner(s: String) {
     value = ""
-    it = (s).elements
+    it = (s).iterator
     token = 1+END
     next
     nextToken
@@ -50,7 +50,7 @@ class Scanner extends Tokens with parsing.TokenTests {
   }
 
   final def accS(ds: Seq[Char]) {
-    val jt = ds.elements
+    val jt = ds.iterator
     while (jt.hasNext) { acc(jt.next) }
   }
 
diff --git a/src/library/scala/xml/dtd/ValidationException.scala b/src/library/scala/xml/dtd/ValidationException.scala
index 4425167a03..a05233a031 100644
--- a/src/library/scala/xml/dtd/ValidationException.scala
+++ b/src/library/scala/xml/dtd/ValidationException.scala
@@ -34,7 +34,7 @@ object MakeValidationException {
   def fromMissingAttribute(allKeys: scala.collection.Set[String]) = {
     val sb = new StringBuilder("missing value for REQUIRED attribute")
     if (allKeys.size > 1) sb.append('s');
-    val it = allKeys.elements
+    val it = allKeys.iterator
     while (it.hasNext) {
       sb.append('\'').append(it.next).append('\'')
     }
diff --git a/src/library/scala/xml/factory/NodeFactory.scala b/src/library/scala/xml/factory/NodeFactory.scala
index 9a00548c2c..4d5743548d 100644
--- a/src/library/scala/xml/factory/NodeFactory.scala
+++ b/src/library/scala/xml/factory/NodeFactory.scala
@@ -31,8 +31,8 @@ trait NodeFactory[A <: Node] {
   /** faster equality, because */
   def eqElements(ch1:Seq[Node], ch2:Seq[Node]): Boolean = {
     (ch1.length == ch2.length) && {
-      val it1 = ch1.elements;
-      val it2 = ch2.elements;
+      val it1 = ch1.iterator;
+      val it2 = ch2.iterator;
       var res = true;
       while(res && it1.hasNext) {
         res = it1.next.eq(it2.next);
@@ -53,7 +53,7 @@ trait NodeFactory[A <: Node] {
     val hash    = Utility.hashCode( pre, name, attrSeq.hashCode(), scpe.hashCode(), children ) ;
     cache.get( hash ) match {
       case Some(list) => // find structurally equal
-        val it     = list.elements;
+        val it     = list.iterator;
         val lookup = it.find { x => nodeEquals(x, pre, name, attrSeq, scpe, children) };
         lookup match {
           case Some(x) =>
diff --git a/src/library/scala/xml/parsing/FactoryAdapter.scala b/src/library/scala/xml/parsing/FactoryAdapter.scala
index d997a23676..4c09988151 100644
--- a/src/library/scala/xml/parsing/FactoryAdapter.scala
+++ b/src/library/scala/xml/parsing/FactoryAdapter.scala
@@ -93,7 +93,7 @@ abstract class FactoryAdapter extends DefaultHandler() {
     if (!capture) return
     if (!normalizeWhitespace) {
       // compliant: report every character
-      return buffer.append(ch, offset, length)
+      return buffer.appendAll(ch, offset, length)
     }
 
     // normalizing whitespace is not compliant, but useful
diff --git a/src/library/scala/xml/parsing/MarkupParser.scala b/src/library/scala/xml/parsing/MarkupParser.scala
index 1d41ee4a1a..369c0010e7 100644
--- a/src/library/scala/xml/parsing/MarkupParser.scala
+++ b/src/library/scala/xml/parsing/MarkupParser.scala
@@ -269,7 +269,7 @@ trait MarkupParser extends AnyRef with TokenTests { self:  MarkupParser with Mar
   }
 
   def xToken(that: Seq[Char]): Unit = {
-    val it = that.elements;
+    val it = that.iterator;
     while (it.hasNext)
       xToken(it.next);
   }
@@ -1173,7 +1173,7 @@ trait MarkupParser extends AnyRef with TokenTests { self:  MarkupParser with Mar
    */
   def normalizeAttributeValue(attval: String): String = {
     val s: Seq[Char] = attval
-    val it = s.elements
+    val it = s.iterator
     while (it.hasNext) {
       it.next match {
         case ' '|'\t'|'\n'|'\r' =>
diff --git a/src/library/scala/xml/parsing/TokenTests.scala b/src/library/scala/xml/parsing/TokenTests.scala
index 1e7f920f0c..2fd6e39ec7 100644
--- a/src/library/scala/xml/parsing/TokenTests.scala
+++ b/src/library/scala/xml/parsing/TokenTests.scala
@@ -25,7 +25,7 @@ trait TokenTests {
 
   /** (#x20 | #x9 | #xD | #xA)+ */
   final def isSpace(cs: Seq[Char]): Boolean = {
-    val it = cs.elements;
+    val it = cs.iterator;
     it.hasNext && it.forall { isSpace };
   }
 
@@ -72,7 +72,7 @@ trait TokenTests {
    */
   def isName(s: String): Boolean = {
     if( s.length() > 0 ) {
-      val y           = s.elements;
+      val y           = s.iterator;
       if (isNameStart(y.next)) {
         while (y.hasNext && isNameChar(y.next)) {};
         !y.hasNext
@@ -105,7 +105,7 @@ trait TokenTests {
    * @param ianaEncoding The IANA encoding name.
    */
   def isValidIANAEncoding(ianaEncoding: Seq[Char]): Boolean = {
-    val it = ianaEncoding.elements;
+    val it = ianaEncoding.iterator;
     if (!it.hasNext)
       return false;
 
@@ -131,7 +131,7 @@ trait TokenTests {
   def checkPubID(s: String): Boolean = {
     //Console.println("checkPubID of \""+s+"\"");
     if (s.length() > 0) {
-      val y = s.elements;
+      val y = s.iterator;
       var c = ' ';
       while (y.hasNext && isPubIDChar(c)) {
         //Console.println(c);
diff --git a/src/library/scala/xml/persistent/CachedFileStorage.scala b/src/library/scala/xml/persistent/CachedFileStorage.scala
index 31f02597b8..19d232deee 100644
--- a/src/library/scala/xml/persistent/CachedFileStorage.scala
+++ b/src/library/scala/xml/persistent/CachedFileStorage.scala
@@ -78,7 +78,7 @@ extends java.lang.Thread with scala.util.logging.Logged {
     val res = ConstructingParser.fromSource(src,false).document.docElem(0)
     switch
     log("[load done]")
-    res.child.elements
+    res.child.iterator
   }
 
   /** saves the XML to file */
diff --git a/src/library/scala/xml/persistent/IndexedStorage.scala b/src/library/scala/xml/persistent/IndexedStorage.scala
index d6720eac1d..979a048b63 100644
--- a/src/library/scala/xml/persistent/IndexedStorage.scala
+++ b/src/library/scala/xml/persistent/IndexedStorage.scala
@@ -40,7 +40,7 @@ extends CachedFileStorage(file) {
   }
 
   def nodes: Iterator[Node] = synchronized {
-    theMap.values
+    theMap.valuesIterator
   }
 
   def lookup(n: A): Option[Node] = theMap.get(n)
diff --git a/src/library/scala/xml/persistent/SetStorage.scala b/src/library/scala/xml/persistent/SetStorage.scala
index c5af1eff5e..90c59f80c3 100644
--- a/src/library/scala/xml/persistent/SetStorage.scala
+++ b/src/library/scala/xml/persistent/SetStorage.scala
@@ -27,7 +27,7 @@ class SetStorage(file: File) extends CachedFileStorage(file) {
   {
     val it = super.initialNodes
     dirty = it.hasNext
-    for(val x <- it) {
+    for(x <- it) {
       theSet += x;
     }
   }
@@ -38,6 +38,6 @@ class SetStorage(file: File) extends CachedFileStorage(file) {
 
   def -= (e: Node): Unit = synchronized { this.dirty = true; theSet -= e }
 
-  def nodes = synchronized { theSet.elements }
+  def nodes = synchronized { theSet.iterator }
 
 }
diff --git a/src/library/scala/xml/transform/BasicTransformer.scala b/src/library/scala/xml/transform/BasicTransformer.scala
index 926cb624b7..d75b339e82 100644
--- a/src/library/scala/xml/transform/BasicTransformer.scala
+++ b/src/library/scala/xml/transform/BasicTransformer.scala
@@ -29,7 +29,7 @@ abstract class BasicTransformer extends Function1[Node,Node] {
    */
   protected def buffer(pos: Int, ns: Seq[Node]): NodeBuffer = {
     val nb = new NodeBuffer()
-    var jt = ns.elements
+    var jt = ns.iterator
     var j = 0; while (j < pos-1) {
       nb.append(jt.next)
       j += 1
@@ -45,7 +45,7 @@ abstract class BasicTransformer extends Function1[Node,Node] {
   protected def freeze(nb: NodeBuffer): Seq[Node] = {
     val arr = new Array[Node](nb.length)
     var i = 0
-    val it = nb.elements; while (it.hasNext) {
+    val it = nb.iterator; while (it.hasNext) {
       arr(i) = it.next
       i += 1
     }
@@ -62,7 +62,7 @@ abstract class BasicTransformer extends Function1[Node,Node] {
    *  @return   ...
    */
   protected def unchanged(n: Node, ns: Seq[Node]) =
-    single(ns) && (ns.elements.next.eq(n))
+    single(ns) && (ns.iterator.next.eq(n))
 
   /** Call transform(Node) for each node in ns, append results
    *  to NodeBuffer.
@@ -78,7 +78,7 @@ abstract class BasicTransformer extends Function1[Node,Node] {
    */
   def transform(ns: Seq[Node]): Seq[Node] = {
     var i = 0
-    val it = ns.elements
+    val it = ns.iterator
     try {
       while (it.hasNext) {
         val n = it.next
@@ -114,7 +114,7 @@ abstract class BasicTransformer extends Function1[Node,Node] {
     val seq = transform(n)
     if (!single(seq))
       throw new UnsupportedOperationException("transform must return single node for root");
-    else seq.elements.next
+    else seq.iterator.next
   }
 }
 
diff --git a/src/library/scala/xml/transform/RuleTransformer.scala b/src/library/scala/xml/transform/RuleTransformer.scala
index 32a21f7e74..682d7f2f2b 100644
--- a/src/library/scala/xml/transform/RuleTransformer.scala
+++ b/src/library/scala/xml/transform/RuleTransformer.scala
@@ -14,7 +14,7 @@ package scala.xml.transform
 class RuleTransformer(rules: RewriteRule*) extends BasicTransformer {
   override def transform(n: Node): Seq[Node] = {
     var m: Seq[Node] = super.transform(n)
-    val it = rules.elements; while (it.hasNext) {
+    val it = rules.iterator; while (it.hasNext) {
       val rule = it.next
       val m2 = rule.transform(m)
       //if(!m2.eq(m)) Console.println("applied rule \""+rule.name+"\"");