Replace "Traversable" by corresponding "Iterable" in doc comments.

Author: flomebul

library/src/scala/Array.scala

@@ -429,7 +429,7 @@ object Array {
    *
    *  @param  n   The number of elements in the array
    *  @param  f   The function computing element values
-   *  @return A traversable consisting of elements `f(0),f(1), ..., f(n - 1)`
+   *  @return An `Array` consisting of elements `f(0),f(1), ..., f(n - 1)`
    */
   def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T] = {
     if (n <= 0) {

library/src/scala/Option.scala

@@ -122,7 +122,7 @@ object Option {
  * }}}
  *
  *  @note Many of the methods in here are duplicative with those
- *  in the Traversable hierarchy, but they are duplicated for a reason:
+ *  in the Iterable hierarchy, but they are duplicated for a reason:
  *  the implicit conversion tends to leave one with an Iterable in
  *  situations where one could have retained an Option.
  *

library/src/scala/collection/Iterable.scala

@@ -719,7 +719,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with Iterable
     *  right hand operand. The element type of the $coll is the most specific superclass encompassing
     *  the element types of the two operands.
     *
-    *  @param suffix   the traversable to append.
+    *  @param suffix   the iterable to append.
     *  @tparam B     the element type of the returned collection.
     *  @return       a new $coll which contains all elements
     *                of this $coll followed by all elements of `suffix`.

library/src/scala/collection/IterableOnce.scala

@@ -437,8 +437,8 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
     */
   def flatMap[B](f: A => IterableOnce[B]): CC[B]
 
-  /** Converts this $coll of traversable collections into
-    *  a $coll formed by the elements of these traversable
+  /** Converts this $coll of iterable collections into
+    *  a $coll formed by the elements of these iterable
     *  collections.
     *
     *    The resulting collection's type will be guided by the
@@ -458,9 +458,9 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
     *    // ys == Set(1, 2, 3)
     *    }}}
     *
-    *  @tparam B the type of the elements of each traversable collection.
+    *  @tparam B the type of the elements of each iterable collection.
     *  @param asIterable an implicit conversion which asserts that the element
-    *          type of this $coll is a `GenTraversable`.
+    *          type of this $coll is an `Iterable`.
     *  @return a new $coll resulting from concatenating all element ${coll}s.
     */
   def flatten[B](implicit asIterable: A => IterableOnce[B]): CC[B]
@@ -818,7 +818,7 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
 
   /** Tests whether the $coll is empty.
     *
-    *  Note: Implementations in subclasses that are not repeatedly traversable must take
+    *  Note: Implementations in subclasses that are not repeatedly iterable must take
     *  care not to consume any elements when `isEmpty` is called.
     *
     *  @return    `true` if the $coll contains no elements, `false` otherwise.

library/src/scala/collection/Map.scala

@@ -324,7 +324,7 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
     *  right hand operand. The element type of the $coll is the most specific superclass encompassing
     *  the element types of the two operands.
     *
-    *  @param suffix   the traversable to append.
+    *  @param suffix   the iterable to append.
     *  @return       a new $coll which contains all elements
     *                of this $coll followed by all elements of `suffix`.
     */

library/src/scala/collection/mutable/Queue.scala

@@ -60,10 +60,10 @@ class Queue[A] protected (array: Array[AnyRef], start: Int, end: Int)
     */
   def enqueue(elem1: A, elem2: A, elems: A*): this.type = enqueue(elem1).enqueue(elem2).enqueueAll(elems)
 
-  /** Enqueues all elements in the given traversable object into the queue. The
-    *  last element in the traversable object will be on front of the new queue.
+  /** Enqueues all elements in the given iterable object into the queue. The
+    *  last element in the iterable object will be on front of the new queue.
     *
-    *  @param elems the traversable object.
+    *  @param elems the iterable object.
     *  @return this
     */
   def enqueueAll(elems: scala.collection.IterableOnce[A]): this.type = this ++= elems

library/src/scala/collection/mutable/Stack.scala

@@ -70,10 +70,10 @@ class Stack[A] protected (array: Array[AnyRef], start: Int, end: Int)
     prepend(elem1).prepend(elem2).pushAll(elems)
   }
 
-  /** Push all elements in the given traversable object onto the stack. The
-    *  last element in the traversable object will be on top of the new stack.
+  /** Push all elements in the given iterable object onto the stack. The
+    *  last element in the iterable object will be on top of the new stack.
     *
-    *  @param elems the traversable object.
+    *  @param elems the iterable object.
     *  @return the stack with the new elements on top.
     */
   def pushAll(elems: scala.collection.IterableOnce[A]): this.type =