Fix errors in the scaladoc

Author: marcelocenerine

src/main/scala/strawman/collection/ArrayOps.scala

@@ -52,9 +52,9 @@ class ArrayOps[A](val xs: Array[A])
 
   def ++[B >: A : ClassTag](xs: Iterable[B]): Array[B] = fromTaggedIterable(View.Concat(toIterable, xs))
 
-  def zip[B: ClassTag](xs: Iterable[B]): Array[(A, B)] = zipWith(xs)((_, _))
+  def zip[B: ClassTag](that: Iterable[B]): Array[(A, B)] = zipWith(that)((_, _))
 
-  def zipWith[B, R: ClassTag](xs: Iterable[B])(f: (A, B) => R): Array[R] = fromTaggedIterable(View.ZipWith(toIterable, xs, f))
+  def zipWith[B, R: ClassTag](that: Iterable[B])(f: (A, B) => R): Array[R] = fromTaggedIterable(View.ZipWith(toIterable, that, f))
 }
 
 case class ArrayView[A](xs: Array[A]) extends IndexedView[A] {

src/main/scala/strawman/collection/Iterable.scala

@@ -829,34 +829,32 @@ trait IterableOps[+A, +CC[X], +C] extends Any {
     *  by combining corresponding elements in pairs.
     *  If one of the two collections is longer than the other, its remaining elements are ignored.
     *
-    *  @param   xs  The iterable providing the second half of each result pair
+    *  @param   that  The iterable providing the second half of each result pair
     *  @tparam  B     the type of the second half of the returned pairs
-    *  @return        a new collection of type `That` containing pairs consisting of
-    *                 corresponding elements of this $coll and `that`. The length
-    *                 of the returned collection is the minimum of the lengths of this $coll and `that`.
+    *  @return        a new $coll containing pairs consisting of corresponding elements of this $coll and `that`.
+    *                 The length of the returned collection is the minimum of the lengths of this $coll and `that`.
     */
-  def zip[B](xs: Iterable[B]): CC[(A @uncheckedVariance, B)] = zipWith(xs)((_, _))
-
+  def zip[B](that: Iterable[B]): CC[(A @uncheckedVariance, B)] = zipWith(that)((_, _))
   // sound bcs of VarianceNote
 
-  /** Returns a $coll formed by the result of applying a function to each pair of corresponding elements
-    * from this $coll and another iterable collection. It is semantically equivalent to `(xs zip ys) map f`.
+  /** Returns a $coll formed by the result of applying a function to each pair of corresponding elements from
+    * this $coll and another iterable collection. It is semantically equivalent to `(xs zip ys) map f`.
     * If one of the two collections is longer than the other, its remaining elements are ignored.
     *
-    *  @param   xs  The iterable providing the second half of each combined pair
+    *  @param   that  The iterable providing the second half of each combined pair
     *  @param   f   The function to apply to each pair of elements
     *  @tparam  B     the type of the elements in the second half of the combined pairs
     *  @tparam  R     the type of the elements in the resulting collection
-    *  @return        a new collection of type `That` containing the results of applying the given function `f`
-    *                 to each pair of corresponding elements of this $coll and `that`. The length
-    *                 of the returned collection is the minimum of the lengths of this $coll and `that`.
+    *  @return        a new $coll containing the results of applying the given function `f` to each pair of
+    *                 corresponding elements of this $coll and `that`. The length of the returned collection
+    *                 is the minimum of the lengths of this $coll and `that`.
     */
-  def zipWith[B, R](xs: Iterable[B])(f: (A, B) => R): CC[R] = fromIterable(View.ZipWith(toIterable, xs, f))
+  def zipWith[B, R](that: Iterable[B])(f: (A, B) => R): CC[R] = fromIterable(View.ZipWith(toIterable, that, f))
 
   /** Zips this $coll with its indices.
     *
-    *  @return        A new collection of type `That` containing pairs consisting of all elements of this
-    *                 $coll paired with their index. Indices start at `0`.
+    *  @return        A new $coll containing pairs consisting of all elements of this $coll paired with their index.
+    *                 Indices start at `0`.
     *  @example
     *    `List("a", "b", "c").zipWithIndex == List(("a", 0), ("b", 1), ("c", 2))`
     */

src/main/scala/strawman/collection/SortedSet.scala

@@ -38,11 +38,11 @@ trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   def flatMap[B : Ordering](f: A => IterableOnce[B]): CC[B] = sortedFromIterable(View.FlatMap(toIterable, f))
 
   /** Zip. Interesting because it requires to align to source collections. */
-  def zip[B](xs: Iterable[B])(implicit ev: Ordering[(A @uncheckedVariance, B)]): CC[(A @uncheckedVariance, B)] = // sound bcs of VarianceNote
-    zipWith(xs)((_, _))(ev)
+  def zip[B](that: Iterable[B])(implicit ev: Ordering[(A @uncheckedVariance, B)]): CC[(A @uncheckedVariance, B)] = // sound bcs of VarianceNote
+    zipWith(that)((_, _))(ev)
 
-  def zipWith[B, R](xs: Iterable[B])(f: (A, B) => R)(implicit ev: Ordering[R]): CC[R] =
-    sortedFromIterable(View.ZipWith(toIterable, xs, f))
+  def zipWith[B, R](that: Iterable[B])(f: (A, B) => R)(implicit ev: Ordering[R]): CC[R] =
+    sortedFromIterable(View.ZipWith(toIterable, that, f))
 
   def collect[B: Ordering](pf: scala.PartialFunction[A, B]): CC[B] = flatMap(a =>
     if (pf.isDefinedAt(a)) View.Single(pf(a))

src/main/scala/strawman/collection/View.scala

@@ -184,7 +184,7 @@ object View extends IterableFactory[View] {
   }
 
   /** A view that generalizes the zip operation by applying a function to each pair of elements
-    * in the underlying collection and another collection or iterator.
+    * in the underlying collection and another collection.
     */
   case class ZipWith[A, B, R](underlying: Iterable[A], other: Iterable[B], f: (A, B) => R) extends View[R] {
     def iterator() = underlying.iterator().zipWith(other)(f)

src/main/scala/strawman/collection/immutable/ImmutableArray.scala

@@ -76,14 +76,14 @@ class ImmutableArray[+A] private[collection] (private val elements: scala.Array[
         ImmutableArray.fromIterable(View.Concat(xs, toIterable))
     }
 
-  override def zipWith[B, R](xs: collection.Iterable[B])(f: (A, B) => R): ImmutableArray[R] =
-    xs match {
+  override def zipWith[B, R](that: collection.Iterable[B])(f: (A, B) => R): ImmutableArray[R] =
+    that match {
       case bs: ImmutableArray[B] =>
         ImmutableArray.tabulate(length min bs.length) { i =>
           f(apply(i), bs(i))
         }
       case _ =>
-        ImmutableArray.fromIterable(View.ZipWith(toIterable, xs, f))
+        ImmutableArray.fromIterable(View.ZipWith(toIterable, that, f))
     }
 
   override def partition(p: A => Boolean): (ImmutableArray[A], ImmutableArray[A]) = {

src/main/scala/strawman/collection/immutable/LazyList.scala

@@ -172,9 +172,9 @@ sealed abstract class LazyList[+A]
       else prefix.lazyAppendAll(nonEmptyPrefix.tail.flatMap(f))
     }
 
-  override final def zipWith[B, R](xs: collection.Iterable[B])(f: (A, B) => R): LazyList[R] =
-    if (this.isEmpty || xs.isEmpty) LazyList.empty
-    else LazyList.cons(f(this.head, xs.head), this.tail.zipWith(xs.tail)(f))
+  override final def zipWith[B, R](that: collection.Iterable[B])(f: (A, B) => R): LazyList[R] =
+    if (this.isEmpty || that.isEmpty) LazyList.empty
+    else LazyList.cons(f(this.head, that.head), this.tail.zipWith(that.tail)(f))
 
   override final def zipWithIndex: LazyList[(A, Int)] = this.zip(LazyList.from(0))
 }

test/junit/src/test/scala/strawman/collection/ArrayOpsTest.scala

@@ -14,23 +14,23 @@ class ArrayOpsTest {
     val array: ArrayOps[Int] = Array(1, 2, 3)
     val result: Array[(Int, String)] = array.zip(List("a", "b", "c"))
 
-    assertArrayEquals(Array((1, "a"), (2, "b"), (3, "c")).asInstanceOf[Array[AnyRef]], result.asInstanceOf[Array[AnyRef]])
+    assertTrue(result.sameElements(Array((1, "a"), (2, "b"), (3, "c"))))
   }
 
   @Test
   def hasCorrectOverloadedZipWhenInputHasMoreElements: Unit = {
     val array: ArrayOps[Int] = Array(1, 2)
     val result: Array[(Int, String)] = array.zip(List("a", "b", "c"))
 
-    assertArrayEquals(Array((1, "a"), (2, "b")).asInstanceOf[Array[AnyRef]], result.asInstanceOf[Array[AnyRef]])
+    assertTrue(result.sameElements(Array((1, "a"), (2, "b"))))
   }
 
   @Test
   def hasCorrectOverloadedZipWhenInputHasLessElements: Unit = {
     val array: ArrayOps[Int] = Array(1, 2, 3)
     val result: Array[(Int, String)] = array.zip(List("a", "b"))
 
-    assertArrayEquals(Array((1, "a"), (2, "b")).asInstanceOf[Array[AnyRef]], result.asInstanceOf[Array[AnyRef]])
+    assertTrue(result.sameElements(Array((1, "a"), (2, "b"))))
   }
 
   @Test