reduce(_ initial:combine:) => reduce(_ initialResult:_ 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, 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, &+)
   }
   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(_:)` method to calculate each sum.
 ///
-///     let firstHalfSum = firstHalf.reduce(0, combine: +)
-///     let secondHalfSum = secondHalf.reduce(0, combine: +)
+///     let firstHalfSum = firstHalf.reduce(0, +)
+///     let secondHalfSum = secondHalf.reduce(0, +)
 ///
 ///     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, +)
 ///
 ///     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, +)
 ///
 ///     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 ExpressibleByStringLiteral
 /// array as a parameter:
 ///
 ///     func sum(values: [Int]) -> Int {
-///         return values.reduce(0, combine: +)
+///         return values.reduce(0, +)
 ///     }
 ///
 ///     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, +)
 ///     // 'primesSum' == 17
 ///
 ///     let primeStrings = primes.sorted().map(String.init)

stdlib/public/core/LazySequence.swift

@@ -37,21 +37,21 @@
 ///     extension Sequence {
 ///       /// Returns an array containing the results of
 ///       ///
-///       ///   p.reduce(initial, combine: combine)
+///       ///   p.reduce(initial, nextPartialResult)
 ///       ///
 ///       /// for each prefix `p` of `self`, in order from shortest to
 ///       /// longest.  For example:
 ///       ///
-///       ///     (1..<6).scan(0, combine: +) // [0, 1, 3, 6, 10, 15]
+///       ///     (1..<6).scan(0, +) // [0, 1, 3, 6, 10, 15]
 ///       ///
 ///       /// - Complexity: O(N)
 ///       func scan<ResultElement>(
 ///         _ initial: ResultElement,
-///         combine: @noescape (ResultElement, Iterator.Element) -> ResultElement
+///         _ nextPartialResult: @noescape (ResultElement, Iterator.Element) -> ResultElement
 ///       ) -> [ResultElement] {
 ///         var result = [initial]
 ///         for x in self {
-///           result.append(combine(result.last!, x))
+///           result.append(nextPartialResult(result.last!, x))
 ///         }
 ///         return result
 ///       }
@@ -64,25 +64,25 @@
 ///       : IteratorProtocol {
 ///       mutating func next() -> ResultElement? {
 ///         return nextElement.map { result in
-///           nextElement = base.next().map { combine(result, $0) }
+///           nextElement = base.next().map { nextPartialResult(result, $0) }
 ///           return result
 ///         }
 ///       }
 ///       private var nextElement: ResultElement? // The next result of next().
 ///       private var base: Base                  // The underlying iterator.
-///       private let combine: (ResultElement, Base.Element) -> ResultElement
+///       private let nextPartialResult: (ResultElement, Base.Element) -> ResultElement
 ///     }
 ///     
 ///     struct LazyScanSequence<Base: Sequence, ResultElement>
 ///       : LazySequenceProtocol // Chained operations on self are lazy, too
 ///     {
 ///       func makeIterator() -> LazyScanIterator<Base.Iterator, ResultElement> {
 ///         return LazyScanIterator(
-///           nextElement: initial, base: base.makeIterator(), combine: combine)
+///           nextElement: initial, base: base.makeIterator(), nextPartialResult)
 ///       }
 ///       private let initial: ResultElement
 ///       private let base: Base
-///       private let combine:
+///       private let nextPartialResult:
 ///         (ResultElement, Base.Iterator.Element) -> ResultElement
 ///     }
 ///
@@ -91,20 +91,20 @@
 ///     extension LazySequenceProtocol {
 ///       /// Returns a sequence containing the results of
 ///       ///
-///       ///   p.reduce(initial, combine: combine)
+///       ///   p.reduce(initial, nextPartialResult)
 ///       ///
 ///       /// for each prefix `p` of `self`, in order from shortest to
 ///       /// longest.  For example:
 ///       ///
-///       ///     Array((1..<6).lazy.scan(0, combine: +)) // [0, 1, 3, 6, 10, 15]
+///       ///     Array((1..<6).lazy.scan(0, +)) // [0, 1, 3, 6, 10, 15]
 ///       ///
 ///       /// - Complexity: O(1)
 ///       func scan<ResultElement>(
 ///         _ initial: ResultElement,
-///         combine: (ResultElement, Iterator.Element) -> ResultElement
+///         _ nextPartialResult: (ResultElement, Iterator.Element) -> ResultElement
 ///       ) -> LazyScanSequence<Self, ResultElement> {
 ///         return LazyScanSequence(
-///           initial: initial, base: self, combine: combine)
+///           initial: initial, base: self, nextPartialResult)
 ///       }
 ///     }
 ///

stdlib/public/core/Sequence.swift

@@ -61,17 +61,18 @@
 /// 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(_:)` 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
 /// over the rest of the sequence.
 ///
 ///     extension Sequence {
 ///         func reduce1(
-///           combine: (Iterator.Element, Iterator.Element) -> Iterator.Element
+///           _ nextPartialResult: (Iterator.Element, Iterator.Element) -> Iterator.Element
 ///         ) -> Iterator.Element?
 ///         {
 ///             var i = makeIterator()
@@ -80,7 +81,7 @@
 ///             }
 ///
 ///             while let element = i.next() {
-///                 accumulated = combine(accumulated, element)
+///                 accumulated = nextPartialResult(accumulated, element)
 ///             }
 ///             return accumulated
 ///         }

stdlib/public/core/SequenceAlgorithms.swift.gyb

@@ -524,40 +524,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, addTwo)
   ///     // 'numberSum' == 10
   ///
-  /// When `numbers.reduce(_:combine:)` is called, the following steps
-  /// occur:
+  /// When `numbers.reduce(_:_:)` 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,
+    _ 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, *)
   let largeText = String(large)
   expectEqual(largeText, String(${Self}(largeText)!))
 

test/1_stdlib/Strideable.swift

@@ -66,14 +66,14 @@ StrideTestSuite.test("Double") {
     // Work on Doubles
     expectEqual(
       sum,
-      stride(from: start, to: end, by: stepSize).reduce(0.0, combine: +))
+      stride(from: start, to: end, by: stepSize).reduce(0.0, +))
   }
 
   func checkClosed(from start: Double, through end: Double, by stepSize: Double, sum: Double) {
     // Work on Doubles
     expectEqual(
       sum,
-      stride(from: start, through: end, by: stepSize).reduce(0.0, combine: +))
+      stride(from: start, through: end, by: stepSize).reduce(0.0, +))
   }
 
   checkOpen(from: 1.0, to: 15.0, by: 3.0, sum: 35.0)
@@ -104,7 +104,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, +))
 
     // Work on an arbitrary RandomAccessIndex
     expectEqual(
@@ -129,12 +130,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, +))
 
     // 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, { $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({#by: (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         max({#by: (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#}, {#(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({#(transform): (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, +)
 
   // 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, +);
 
 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, _ combine: (U, T) -> U
+  ) -> U {
     return _runCollectionTransformer(_input, _step.reduce(initial, combine))
   }