Merge pull request scala#6513 from szeiger/wip/iterableonceops-fold

Add IterableOnceOps.fold

Author: szeiger

src/library/scala/collection/ArrayOps.scala

@@ -553,6 +553,17 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
     v
   }
 
+  /** Folds the elements of this array using the specified associative binary operator.
+    *
+    *  @tparam A1     a type parameter for the binary operator, a supertype of `A`.
+    *  @param z       a neutral element for the fold operation; may be added to the result
+    *                 an arbitrary number of times, and must not change the result (e.g., `Nil` for list concatenation,
+    *                 0 for addition, or 1 for multiplication).
+    *  @param op      a binary operator that must be associative.
+    *  @return        the result of applying the fold operator `op` between all the elements and `z`, or `z` if this array is empty.
+    */
+  @`inline` final def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 = foldLeft(z)(op)
+
   /** Builds a new array by applying a function to all elements of this array.
     *
     *  @param f      the function to apply to each element.

src/library/scala/collection/IterableOnce.scala

@@ -113,6 +113,9 @@ final class IterableOnceExtensionMethods[A](private val it: IterableOnce[A]) ext
   @deprecated("Use .iterator().foldRight instead of .foldLeft on IterableOnce", "2.13.0")
   @`inline` def foldRight[B](z: B)(op: (A, B) => B): B = it.iterator().foldRight(z)(op)
 
+  @deprecated("Use .iterator().fold instead of .fold on IterableOnce", "2.13.0")
+  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 = it.iterator().fold(z)(op)
+
   @deprecated("Use .iterator().foldLeft instead of /: on IterableOnce", "2.13.0")
   @`inline` def /: [B](z: B)(op: (B, A) => B): B = foldLeft[B](z)(op)
 
@@ -465,6 +468,22 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
   @deprecated("Use foldRight instead of :\\", "2.13.0")
   @`inline` final def :\ [B](z: B)(op: (A, B) => B): B = foldRight[B](z)(op)
 
+  /** Folds the elements of this $coll using the specified associative binary operator.
+    * The default implementation in `IterableOnce` is equivalent to `foldLeft` but may be
+    * overridden for more efficient traversal orders.
+    *
+    *  $undefinedorder
+    *  $willNotTerminateInf
+    *
+    *  @tparam A1     a type parameter for the binary operator, a supertype of `A`.
+    *  @param z       a neutral element for the fold operation; may be added to the result
+    *                 an arbitrary number of times, and must not change the result (e.g., `Nil` for list concatenation,
+    *                 0 for addition, or 1 for multiplication).
+    *  @param op      a binary operator that must be associative.
+    *  @return        the result of applying the fold operator `op` between all the elements and `z`, or `z` if this $coll is empty.
+    */
+  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 = foldLeft(z)(op)
+
   /** Reduces the elements of this $coll using the specified associative binary operator.
     *
     *  $undefinedorder

test/benchmarks/src/main/scala/scala/collection/DistinctBenchmark.scala

@@ -33,7 +33,7 @@ class DistinctBenchmark {
       b2 += i.toString
     }
 
-    val adjustCollectionType = collectionType match {
+    val adjustCollectionType: (Seq[String] => Seq[String]) = collectionType match {
       case "List" => (col: Seq[String]) => col.toList
       case "Vector" => (col: Seq[String]) => col.toVector
     }

test/benchmarks/src/main/scala/scala/collection/mutable/ArrayOpsBenchmark.scala

@@ -18,11 +18,13 @@ class ArrayOpsBenchmark {
   var size: Int = _
   var integers: List[Int] = _
   var strings: List[String] = _
+  var integersA: Array[Int] = _
 
 
   @Setup(Level.Trial) def initNumbers: Unit = {
     integers = (1 to size).toList
     strings = integers.map(_.toString)
+    integersA = integers.toArray
   }
 
   @Benchmark def appendInteger(bh: Blackhole): Unit = {
@@ -56,4 +58,12 @@ class ArrayOpsBenchmark {
     }
     bh.consume(arr)
   }
+
+  @Benchmark def foldLeftSum(bh: Blackhole): Unit = {
+    bh.consume(integersA.foldLeft(0){ (z,n) => z + n })
+  }
+
+  @Benchmark def foldSum(bh: Blackhole): Unit = {
+    bh.consume(integersA.fold(0){ (a,b) => a + b })
+  }
 }

test/benchmarks/src/main/scala/scala/collection/mutable/OpenHashMapRunner.scala

@@ -48,7 +48,7 @@ object OpenHashMapRunner extends JmhRunner {
 
 
   def main(args: Array[String]) {
-    import scala.collection.JavaConversions._
+    import scala.collection.JavaConverters._
 
     val opts = new CommandLineOptions(args: _*)
     var builder = new OptionsBuilder().parent(opts).jvmArgsPrepend("-Xmx6000m")
@@ -72,7 +72,7 @@ object OpenHashMapRunner extends JmhRunner {
     def addToDataset(key: String, result: RunResult): Unit =
       datasetByName.getOrElseUpdate(key, SortedSet.empty(ordering)) += result
 
-    results.foreach { result =>
+    results.asScala.foreach { result =>
       addToDataset(result.label, result)
 
       // Create another data set for trials that track memory usage

test/benchmarks/src/main/scala/scala/util/matching/RegexUnapplyBenchmark.scala

@@ -25,20 +25,14 @@ class RegexUnapplyBenchmark {
   @Benchmark def t8022CharSequence(bh: Blackhole): Unit = {
     val full = t8022CharSequenceRegex
     val text = "   When I use this operator: *"
-    // Testing 2.10.x compatibility of the return types of unapplySeq
-    val x :: Nil = full.unapplySeq(text: Any).get
     val y :: Nil = full.unapplySeq(text: CharSequence).get
-    bh.consume(x)
     bh.consume(y)
   }
 
   @Benchmark def t8022Match(bh: Blackhole): Unit = {
     val R = t8022MatchRegex
     val matchh = R.findFirstMatchIn("a1").get
-    // Testing 2.10.x compatibility of the return types of unapplySeq
-    val x :: Nil = R.unapplySeq(matchh: Any).get
     val y :: Nil = R.unapplySeq(matchh).get
-    bh.consume(x)
     bh.consume(y)
   }
 

test/junit/scala/collection/ArrayOpsTest.scala

@@ -32,4 +32,12 @@ class ArrayOpsTest {
     val a = Array(1,2,3)
     assertEquals(List(3,2,1), a.reverseIterator.toList)
   }
+
+  @Test
+  def folds: Unit = {
+    val a = Array(1,2,3)
+    assertEquals(6, a.foldLeft(0){ (a, b) => a+b })
+    assertEquals(6, a.foldRight(0){ (a, b) => a+b })
+    assertEquals(6, a.fold(0){ (a, b) => a+b })
+  }
 }