reduce(_ initial:combine:) => reduce(_ initialResult:accumulatingResultWith nextPartialResult)

Author: Dave Abrahams

benchmark/single-source/CaptureProp.swift

@@ -21,7 +21,7 @@ func benchCaptureProp<S : Sequence
 
   var it = s.makeIterator()
   let initial = it.next()!
-  return IteratorSequence(it).reduce(initial, combine: f)
+  return IteratorSequence(it).reduce(initial, accumulatingResultBy: f)
 }
 
 public func run_CaptureProp(_ N: Int) {

benchmark/single-source/MapReduce.swift

@@ -20,7 +20,7 @@ public func run_MapReduce(_ N: Int) {
   var c = 0
   for _ in 1...N*100 {
     numbers = numbers.map({$0 &+ 5})
-    c += numbers.reduce(0, combine: &+)
+    c += numbers.reduce(0, accumulatingResultBy: &+)
   }
   CheckResults(c != 0, "IncorrectResults in MapReduce")
 }

stdlib/public/core/Arrays.swift.gyb

@@ -99,10 +99,10 @@ if True:
 ///
 /// You can call any method on the slices that you might have called on the
 /// `absences` array. To learn which half had more absences, use the
-/// `reduce(_:combine:)` method to calculate each sum.
+/// `reduce(_:accumulatingResultBy:)` method to calculate each sum.
 ///
-///     let firstHalfSum = firstHalf.reduce(0, combine: +)
-///     let secondHalfSum = secondHalf.reduce(0, combine: +)
+///     let firstHalfSum = firstHalf.reduce(0, accumulatingResultBy: +)
+///     let secondHalfSum = secondHalf.reduce(0, accumulatingResultBy: +)
 ///
 ///     if firstHalfSum > secondHalfSum {
 ///         print("More absences in the first half.")

stdlib/public/core/Boolean.swift

@@ -42,7 +42,7 @@ public prefix func !<T : Boolean>(a: T) -> Bool {
 /// `lhs` evaluates to `true`. For example:
 ///
 ///     let measurements = [7.44, 6.51, 4.74, 5.88, 6.27, 6.12, 7.76]
-///     let sum = measurements.reduce(0, combine: +)
+///     let sum = measurements.reduce(0, accumulatingResultBy: +)
 ///
 ///     if measurements.count > 0 && sum / Double(measurements.count) < 6.5 {
 ///         print("Average measurement is less than 6.5")
@@ -121,7 +121,7 @@ public func || <T : Boolean, U : Boolean>(
 /// `lhs` evaluates to `true`. For example:
 ///
 ///     let measurements = [7.44, 6.51, 4.74, 5.88, 6.27, 6.12, 7.76]
-///     let sum = measurements.reduce(0, combine: +)
+///     let sum = measurements.reduce(0, accumulatingResultBy: +)
 ///
 ///     if measurements.count > 0 && sum / Double(measurements.count) < 6.5 {
 ///         print("Average measurement is less than 6.5")

stdlib/public/core/CompilerProtocols.swift

@@ -476,7 +476,7 @@ public protocol StringLiteralConvertible
 /// array as a parameter:
 ///
 ///     func sum(values: [Int]) -> Int {
-///         return values.reduce(0, combine: +)
+///         return values.reduce(0, accumulatingResultBy: +)
 ///     }
 ///
 ///     let sumOfFour = sum([5, 10, 15, 20])

stdlib/public/core/HashedCollections.swift.gyb

@@ -376,7 +376,7 @@ internal struct _UnmanagedAnyObjectArray {
 ///     }
 ///     // Prints "We have 4 primes."
 ///
-///     let primesSum = primes.reduce(0, combine: +)
+///     let primesSum = primes.reduce(0, accumulatingResultBy: +)
 ///     // 'primesSum' == 17
 ///
 ///     let primeStrings = primes.sorted().map(String.init)

stdlib/public/core/LazySequence.swift

@@ -37,7 +37,7 @@
 ///     extension Sequence {
 ///       /// Returns an array containing the results of
 ///       ///
-///       ///   p.reduce(initial, combine: combine)
+///       ///   p.reduce(initial, accumulatingResultBy: combine)
 ///       ///
 ///       /// for each prefix `p` of `self`, in order from shortest to
 ///       /// longest.  For example:

stdlib/public/core/Sequence.swift

@@ -61,9 +61,10 @@
 /// algorithms, however, may call for direct iterator use.
 ///
 /// One example is the `reduce1(_:)` method. Similar to the
-/// `reduce(_:combine:)` method defined in the standard library, which takes
-/// an initial value and a combining closure, `reduce1(_:)` uses the first
-/// element of the sequence as the initial value.
+/// `reduce(_:accumulatingResultBy:)` method defined in the standard
+/// library, which takes an initial value and a combining closure,
+/// `reduce1(_:)` uses the first element of the sequence as the
+/// initial value.
 ///
 /// Here's an implementation of the `reduce1(_:)` method. The sequence's
 /// iterator is used directly to retrieve the initial value before looping

stdlib/public/core/SequenceAlgorithms.swift.gyb

@@ -522,40 +522,44 @@ extension Sequence {
   /// Returns the result of calling the given combining closure with each
   /// element of this sequence and an accumulating value.
   ///
-  /// The `combine` closure is called sequentially with an accumulating
-  /// value initialized to `initial` and each element of the sequence. This
-  /// example shows how to find the sum of an array of numbers.
+  /// The `nextPartialResult` closure is called sequentially with an
+  /// accumulating value initialized to `initialResult` and each
+  /// element of the sequence. This example shows how to find the sum
+  /// of an array of numbers.
   ///
   ///     let numbers = [1, 2, 3, 4]
   ///     let addTwo: (Int, Int) -> Int = { x, y in x + y }
-  ///     let numberSum = numbers.reduce(0, combine: addTwo)
+  ///     let numberSum = numbers.reduce(0, accumulatingResultBy: addTwo)
   ///     // 'numberSum' == 10
   ///
-  /// When `numbers.reduce(_:combine:)` is called, the following steps
-  /// occur:
+  /// When `numbers.reduce(_:accumulatingResultBy:)` is called, the
+  /// following steps occur:
   ///
-  /// 1. The `combine` closure is called with the initial value and the
-  ///    first element of `numbers`, returning the sum: `1`.
+  /// 1. The `nextPartialResult` closure is called with the initial
+  ///    result and the first element of `numbers`, returning the sum:
+  ///    `1`.
   /// 2. The closure is called again repeatedly with the previous call's
   ///    return value and each element of the sequence.
   /// 3. When the sequence is exhausted, the last value returned from the
   ///    closure is returned to the caller.
   ///
   /// - Parameters:
-  ///   - initial: A value to use as the initial value for accumulation.
-  ///   - combine: A closure that combines an accumulating value and an
-  ///     element of the sequence into a new accumulating value, to be used
-  ///     in the next call of the `combine` closure or returned to the
-  ///     caller.
-  /// - Returns: The final accumulated value.
-  public func reduce<T>(
-    _ initial: T, combine: @noescape (T, ${GElement}) throws -> T
-  ) rethrows -> T {
-    var result = initial
+  ///   - initialResult: the initial accumulating value.
+  ///   - nextPartialResult: A closure that combines an accumulating
+  ///     value and an element of the sequence into a new accumulating
+  ///     value, to be used in the next call of the
+  ///     `nextPartialResult` closure or returned to the caller.
+    /// - Returns: The final accumulated value.
+  public func reduce<Result>(
+    _ initialResult: Result,
+    accumulatingResultBy nextPartialResult:
+      @noescape (partialResult: Result, ${GElement}) throws -> Result
+  ) rethrows -> Result {
+    var accumulator = initialResult
     for element in self {
-      result = try combine(result, element)
+      accumulator = try nextPartialResult(partialResult: accumulator, element)
     }
-    return result
+    return accumulator
   }
 }
 

test/1_stdlib/ErrorHandling.swift

@@ -233,7 +233,7 @@ ErrorHandlingTests.test("ErrorHandling/contains") {
 ErrorHandlingTests.test("ErrorHandling/reduce") {
   var loopCount = 0
   do {
-    let x: Int = try [1, 2, 3, 4, 5].reduce(0, combine: {
+    let x: Int = try [1, 2, 3, 4, 5].reduce(0) {
       (x: Int, y: Int) -> Int
     in
       loopCount += 1
@@ -242,7 +242,7 @@ ErrorHandlingTests.test("ErrorHandling/reduce") {
         throw SillyError.JazzHands
       }
       return total
-    })
+    }
     expectUnreachable()
   } catch {}
   expectEqual(loopCount, 3)

test/1_stdlib/NumericParsing.swift.gyb

@@ -146,7 +146,7 @@ tests.test("${Self}/Basics") {
   // Check that we can round-trip the string representation of 2^100,
   // which requires an exponent to express...
   let large =
-    repeatElement(1024 as ${Self}, count: 10).reduce(1, combine: *)
+    repeatElement(1024 as ${Self}, count: 10).reduce(1, accumulatingResultBy: *)
   let largeText = String(large)
   expectEqual(largeText, String(${Self}(largeText)!))
 

test/1_stdlib/Strideable.swift

@@ -71,7 +71,8 @@ StrideTestSuite.test("HalfOpen") {
     // Work on Ints
     expectEqual(
       sum,
-      stride(from: start, to: end, by: stepSize).reduce(0, combine: +))
+      stride(from: start, to: end, by: stepSize).reduce(
+        0, accumulatingResultBy: +))
 
     // Work on an arbitrary RandomAccessIndex
     expectEqual(
@@ -96,12 +97,15 @@ StrideTestSuite.test("Closed") {
     // Work on Ints
     expectEqual(
       sum,
-      stride(from: start, through: end, by: stepSize).reduce(0, combine: +))
+      stride(from: start, through: end, by: stepSize).reduce(
+        0, accumulatingResultBy: +))
 
     // Work on an arbitrary RandomAccessIndex
     expectEqual(
       sum,
-      stride(from: R(start), through: R(end), by: stepSize).reduce(0) { $0 + $1.x })
+      stride(from: R(start), through: R(end), by: stepSize).reduce(
+        0, accumulatingResultBy: { $0 + $1.x })
+    )
   }
 
   check(from: 1, through: 15, by: 3, sum: 35)  // 1 + 4 + 7 + 10 + 13

test/IDE/complete_from_stdlib.swift

@@ -149,7 +149,7 @@ func testArchetypeReplacement2<BAR : Equatable>(_ a: [BAR]) {
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         enumerated()[#EnumeratedSequence<[Equatable]>#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         min({#orderingBy: (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         max({#orderingBy: (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}
-// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reduce({#(initial): T#}, {#combine: (T, Equatable) throws -> T##(T, Equatable) throws -> T#})[' rethrows'][#T#]{{; name=.+}}
+// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reduce({#(initialResult): Result#}, {#accumulatingResultBy: (partialResult: Result, Equatable) throws -> Result##(partialResult: Result, Equatable) throws -> Result#})[' rethrows'][#Result#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         dropFirst({#(n): Int#})[#ArraySlice<Equatable>#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         flatMap({#(elementTransform): (Equatable) throws -> Sequence##(Equatable) throws -> Sequence#})[' rethrows'][#[SegmentOfResult.Iterator.Element]#]{{; name=.+}}
 

test/NameBinding/reference-dependencies.swift

@@ -139,7 +139,7 @@ func lookUpManyTopLevelNames() {
 
   // CHECK-DAG: !private "UInt"
   // CHECK-DAG: !private "+"
-  let _: UInt = [1, 2].reduce(0, combine: +)
+  let _: UInt = [1, 2].reduce(0, accumulatingResultBy: +)
 
   // CHECK-DAG: !private "-"
   let _: UInt = 3 - 2 - 1

test/Parse/semicolon.swift

@@ -44,7 +44,7 @@ for i in 1..<1000 {
     };
 }
 
-let six = (1..<3).reduce(0, combine: +);
+let six = (1..<3).reduce(0, accumulatingResultBy: +);
 
 func lessThanTwo(input: UInt) -> Bool {
     switch input {

test/Prototypes/CollectionTransformers.swift

@@ -1274,7 +1274,9 @@ public struct CollectionTransformerPipeline<
     )
   }
 
-  public func reduce<U>(_ initial: U, _ combine: (U, T) -> U) -> U {
+  public func reduce<U>(
+    _ initial: U, accumulatingResultBy combine: (U, T) -> U
+  ) -> U {
     return _runCollectionTransformer(_input, _step.reduce(initial, combine))
   }
 
@@ -1315,7 +1317,7 @@ t.test("fusion/map+reduce") {
   let result =
     transform(xs)
     .map { $0 * 2 }
-    .reduce(0, { $0 + $1 })
+    .reduce(0, accumulatingResultBy: { $0 + $1 })
   expectEqual(12, result)
 }
 
@@ -1324,7 +1326,7 @@ t.test("fusion/map+filter+reduce") {
   let result = transform(xs)
     .map { $0 * 2 }
     .filter { $0 != 0 }
-    .reduce(0, { $0 + $1 })
+    .reduce(0, accumulatingResultBy: { $0 + $1 })
   expectEqual(12, result)
 }