Add missing methods to Iterator

gmethvin · gmethvin · commit ae50ed3bd0bb · 2018-07-10T12:37:33.000-07:00
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala
@@ -140,6 +140,8 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with Iterable
   @deprecated("Use toIterable instead", "2.13.0")
   final def toTraversable: Traversable[A] = toIterable
 
+  override def isTraversableAgain: Boolean = true
+
   /**
     * @return This collection as a `C`.
     */
@@ -223,9 +225,6 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with Iterable
     */
   def lastOption: Option[A] = if (isEmpty) None else Some(last)
 
-  @deprecated("Use .knownSize >=0 instead of .hasDefiniteSize", "2.13.0")
-  @`inline` final def hasDefiniteSize = knownSize >= 0
-
   /** A view over the elements of this collection. */
   def view: View[A] = View.fromIteratorProvider(() => iterator)
 
@@ -309,7 +308,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with Iterable
     */
   def withFilter(p: A => Boolean): collection.WithFilter[A, CC] = new IterableOps.WithFilter(this, p)
 
-  /** A pair of, first, all elements that satisfy prediacte `p` and, second,
+  /** A pair of, first, all elements that satisfy predicate `p` and, second,
     *  all elements that do not. Interesting because it splits a collection in two.
     *
     *  The default implementation provided here needs to traverse the collection twice.
diff --git a/src/library/scala/collection/IterableOnce.scala b/src/library/scala/collection/IterableOnce.scala
@@ -3,7 +3,7 @@ package collection
 
 import scala.language.{higherKinds, implicitConversions}
 import scala.annotation.unchecked.uncheckedVariance
-import scala.math.{Ordering, Numeric}
+import scala.math.{Numeric, Ordering}
 import scala.reflect.ClassTag
 import scala.collection.mutable.StringBuilder
 
@@ -357,6 +357,16 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
     */
   def knownSize: Int = -1
 
+  @deprecated("Use .knownSize >=0 instead of .hasDefiniteSize", "2.13.0")
+  @`inline` final def hasDefiniteSize = knownSize >= 0
+
+  /** Tests whether this $coll can be repeatedly traversed.  Always
+   *  true for Iterables and false for Iterators unless overridden.
+   *
+   *  @return   `true` if it is repeatedly traversable, `false` otherwise.
+   */
+  def isTraversableAgain: Boolean = false
+
   /** Apply `f` to each element for its side effects
     *  Note: [U] parameter needed to help scalac's type inference.
     */
@@ -627,6 +637,22 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
   @deprecated("Use `dest ++= coll` instead", "2.13.0")
   @inline final def copyToBuffer[B >: A](dest: mutable.Buffer[B]): Unit = dest ++= this
 
+  /** Copy elements to an array.
+   *
+   *  Fills the given array `xs` starting at index `start` with values of this $coll.
+   *
+   *  Copying will stop once either all the elements of this $coll have been copied,
+   *  or the end of the array is reached.
+   *
+   *  @param  xs     the array to fill.
+   *  @tparam B      the type of the elements of the array.
+   *
+   *  @usecase def copyToArray(xs: Array[A]): Unit
+   *
+   *  $willNotTerminateInf
+   */
+  def copyToArray[B >: A](xs: Array[B]): xs.type = copyToArray(xs, 0)
+
   /** Copy elements to an array.
     *
     *  Fills the given array `xs` starting at index `start` with values of this $coll.
@@ -642,7 +668,8 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
     *
     *  $willNotTerminateInf
     */
-  def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type = {
+
+  def copyToArray[B >: A](xs: Array[B], start: Int): xs.type = {
     val xsLen = xs.length
     val it = iterator
     var i = start
@@ -914,7 +941,9 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
   def collectFirst[B](pf: PartialFunction[A, B]): Option[B] = {
     // Presumably the fastest way to get in and out of a partial function is for a sentinel function to return itself
     // (Tested to be lower-overhead than runWith.  Would be better yet to not need to (formally) allocate it)
-    val sentinel: scala.Function1[A, Any] = new scala.runtime.AbstractFunction1[A, Any]{ def apply(a: A) = this }
+    val sentinel: scala.Function1[A, Any] = new scala.runtime.AbstractFunction1[A, Any] {
+      def apply(a: A) = this
+    }
     val it = iterator
     while (it.hasNext) {
       val x = pf.applyOrElse(it.next(), sentinel)
@@ -923,6 +952,30 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
     None
   }
 
+  @deprecated("`aggregate` is not relevant for sequential collections. Use `foldLeft(z)(seqop)` instead.", "2.13.0")
+  def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B = foldLeft(z)(seqop)
+
+  /** Tests whether every element of this collection's iterator relates to the
+   *  corresponding element of another collection by satisfying a test predicate.
+   *
+   *  @param   that    the other collection
+   *  @param   p       the test predicate, which relates elements from both collections
+   *  @tparam  B       the type of the elements of `that`
+   *  @return          `true` if both collections have the same length and
+   *                   `p(x, y)` is `true` for all corresponding elements `x` of this iterator
+   *                   and `y` of `that`, otherwise `false`
+   */
+  def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean = {
+    val a = iterator
+    val b = that.iterator
+
+    while (a.hasNext && b.hasNext) {
+      if (!p(a.next(), b.next())) return false
+    }
+
+    a.hasNext == b.hasNext
+  }
+
   /** Displays all elements of this $coll in a string using start, end, and
     *  separator strings.
     *
diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
@@ -267,6 +267,47 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
     }
   }
 
+  /** A copy of this $coll with an element value appended until a given target length is reached.
+   *
+   *  @param   len   the target length
+   *  @param   elem  the padding value
+   *  @tparam B      the element type of the returned $coll.
+   *  @return a new $coll consisting of
+   *          all elements of this $coll followed by the minimal number of occurrences of `elem` so
+   *          that the resulting collection has a length of at least `len`.
+   */
+  def padTo[B >: A](len: Int, elem: B): Iterator[B] = {
+    val it = this
+    new AbstractIterator[B] {
+      private[this] var i = 0
+
+      def next(): B = {
+        val b =
+          if (it.hasNext) it.next()
+          else if (i < len) elem
+          else Iterator.empty.next()
+        i += 1
+        b
+      }
+
+      def hasNext: Boolean = it.hasNext || i < len
+    }
+  }
+
+  /** Partitions this iterator in two iterators according to a predicate.
+   *
+   *  @param p the predicate on which to partition
+   *  @return  a pair of iterators: the iterator that satisfies the predicate
+   *           `p` and the iterator that does not.
+   *           The relative order of the elements in the resulting iterators
+   *           is the same as in the original iterator.
+   *  @note    Reuse: $consumesOneAndProducesTwoIterators
+   */
+  def partition(p: A => Boolean): (Iterator[A], Iterator[A]) = {
+    val (a, b) = duplicate
+    (a filter p, b filterNot p)
+  }
+
   /** Returns an iterator which groups this iterator into fixed size
    *  blocks.  Example usages:
    *  {{{
@@ -341,6 +382,9 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
     def hasNext: Boolean = current.hasNext
   }
 
+  @deprecated("Call scanRight on an Iterable instead.", "2.13.0")
+  def scanRight[B](z: B)(op: (A, B) => B): Iterator[B] = ArrayBuffer.from(this).scanRight(z)(op).iterator
+
   def indexWhere(p: A => Boolean, from: Int = 0): Int = {
     var i = math.max(from, 0)
     drop(from)
diff --git a/src/library/scala/collection/View.scala b/src/library/scala/collection/View.scala
@@ -310,19 +310,8 @@ object View extends IterableFactory[View] {
 
   @SerialVersionUID(3L)
   class PadTo[A](underlying: SomeIterableOps[A], len: Int, elem: A) extends AbstractView[A] {
-    def iterator: Iterator[A] = new AbstractIterator[A] {
-      private[this] var i = 0
-      private[this] val it = underlying.iterator
-      def next(): A = {
-        val a =
-          if (it.hasNext) it.next()
-          else if (i < len) elem
-          else Iterator.empty.next()
-        i += 1
-        a
-      }
-      def hasNext: Boolean = it.hasNext || i < len
-    }
+    def iterator: Iterator[A] = underlying.iterator.padTo(len, elem)
+
     override def knownSize: Int = if (underlying.knownSize >= 0) underlying.knownSize max len else -1
   }
 
diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala
@@ -152,7 +152,7 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
 
   override protected[this] def stringPrefix = "ArrayBuffer"
 
-  override def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type = copyToArray[B](xs, start, length)
+  override def copyToArray[B >: A](xs: Array[B], start: Int): xs.type = copyToArray[B](xs, start, length)
 
   override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): xs.type = {
     val l = scala.math.min(scala.math.min(len, length), xs.length-start)
diff --git a/src/library/scala/collection/mutable/ArraySeq.scala b/src/library/scala/collection/mutable/ArraySeq.scala
@@ -60,7 +60,7 @@ abstract class ArraySeq[T]
   /** Clones this object, including the underlying Array. */
   override def clone(): ArraySeq[T] = ArraySeq.make(array.clone()).asInstanceOf[ArraySeq[T]]
 
-  override def copyToArray[B >: T](xs: Array[B], start: Int = 0): xs.type = copyToArray[B](xs, start, length)
+  override def copyToArray[B >: T](xs: Array[B], start: Int): xs.type = copyToArray[B](xs, start, length)
 
   override def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): xs.type = {
     val l = scala.math.min(scala.math.min(len, length), xs.length-start)
diff --git a/test/junit/scala/collection/IteratorTest.scala b/test/junit/scala/collection/IteratorTest.scala
@@ -404,6 +404,29 @@ class IteratorTest {
     assertSame(Iterator.empty, iteratorBuilder.result())
   }
 
+  @Test def partition: Unit = {
+    val it = Iterator(1, 2, 3, 4, 5, 6, 7)
+    val (even, odd) = it.partition(n => (n & 1) == 0)
+    assertSameElements(List.from(even), List(2, 4, 6))
+    assertSameElements(List.from(odd), List(1, 3, 5, 7))
+  }
+
+  @Test def padTo: Unit = {
+    val it = Iterator(2, 4, 6, 8)
+    val padded = it.padTo(7, 10)
+    assertSameElements(List.from(padded), List(2, 4, 6, 8, 10, 10, 10))
+  }
+
+  @Test def corresponds: Unit = {
+    val it = Iterator(1, 2, 3, 4, 5)
+    assertTrue(it.corresponds(Seq(1, 4, 9, 16, 25)) { (a, b) => b == a*a })
+  }
+
+  @Test def aggregate: Unit = {
+    val result = Iterator('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })
+    assertEquals(result, 294)
+  }
+
   @Test def copyToArray(): Unit = {
     def check(a: Array[Int], start: Int, end: Int) = {
       var i = 0
