Rename uniquingKeysWith → resolvingConflictsWith

Author: amomchilov

Guides/Keyed.md

@@ -22,7 +22,7 @@ Duplicate keys throw an error by default. Alternatively, you can provide a closu
 let fruits = ["Apricot", "Banana", "Apple", "Cherry", "Blackberry", "Avocado", "Coconut"]
 let fruitsByLetter = fruits.keyed(
     by: { $0.first! },
-    uniquingKeysWith: { key, old, new in new } // Always pick the latest fruit
+    resolvingConflictsWith: { key, old, new in new } // Always pick the latest fruit
 )
 // Results in:
 // [
@@ -34,7 +34,7 @@ let fruitsByLetter = fruits.keyed(
 
 ## Detailed Design
 
-The `keyed(by:)` and `keyed(by:uniquingKeysWith:)` methods are declared in an `Sequence` extension, both returning `[Key: Element]`.
+The `keyed(by:)` and `keyed(by:resolvingConflictsWith:)` methods are declared in an `Sequence` extension, both returning `[Key: Element]`.
 
 ```swift
 extension Sequence {
@@ -44,7 +44,7 @@ extension Sequence {
 
     public func keyed<Key>(
         by keyForValue: (Element) throws -> Key,
-        uniquingKeysWith combine: ((Key, Element, Element) throws -> Element)? = nil
+        resolvingConflictsWith resolve: ((Key, Element, Element) throws -> Element)? = nil
     ) rethrows -> [Key: Element]
 }
 ```

README.md

@@ -48,7 +48,7 @@ Read more about the package, and the intent behind it, in the [announcement on s
 - [`grouped(by:)](https://github.com/apple/swift-algorithms/blob/main/Guides/Grouped.md): Group up elements using the given closure, returning a Dictionary of those groups, keyed by the results of the closure.
 - [`indexed()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Indexed.md): Iterate over tuples of a collection's indices and elements. 
 - [`interspersed(with:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Intersperse.md): Place a value between every two elements of a sequence.
-- [`keyed(by:)`, `keyed(by:uniquingKeysBy:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Keyed.md): Returns a Dictionary that associates elements of a sequence with the keys returned by the given closure.
+- [`keyed(by:)`, `keyed(by:resolvingConflictsBy:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Keyed.md): Returns a Dictionary that associates elements of a sequence with the keys returned by the given closure.
 - [`partitioningIndex(where:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): Returns the starting index of the partition of a collection that matches a predicate.
 - [`reductions(_:)`, `reductions(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Reductions.md): Returns all the intermediate states of reducing the elements of a sequence or collection.
 - [`split(maxSplits:omittingEmptySubsequences:whereSeparator)`, `split(separator:maxSplits:omittingEmptySubsequences)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Split.md): Lazy versions of the Standard Library's eager operations that split sequences and collections into subsequences separated by the specified separator element.

Sources/Algorithms/Keyed.swift

@@ -35,49 +35,41 @@ extension Sequence {
   public func keyed<Key>(
     by keyForValue: (Element) throws -> Key
   ) throws -> [Key: Element] {
-    var result = [Key: Element]()
-
-    for element in self {
-      let key = try keyForValue(element)
-
-      if let previousElement = result.updateValue(element, forKey: key) {
-        throw KeysAreNotUnique(key: key, previousElement: previousElement, conflictingElement: element)
-      }
-    }
-
-    return result
+    try self.keyed(by: keyForValue, resolvingConflictsWith: {
+       throw KeysAreNotUnique(key: $0, previousElement: $1, conflictingElement: $2)
+    })
   }
 
   /// Creates a new Dictionary from the elements of `self`, keyed by the
   /// results returned by the given `keyForValue` closure. As the dictionary is
-  /// built, the initializer calls the `combine` closure with the current and
-  /// new values for any duplicate keys. Pass a closure as `combine` that
+  /// built, the initializer calls the `resolve` closure with the current and
+  /// new values for any duplicate keys. Pass a closure as `resolve` that
   /// returns the value to use in the resulting dictionary: The closure can
   /// choose between the two values, combine them to produce a new value, or
   /// even throw an error.
   ///
   /// - Parameters:
   ///   - keyForValue: A closure that returns a key for each element in `self`.
-  ///   - combine: A closure that is called with the values for any duplicate
+  ///   - resolve: A closure that is called with the values for any duplicate
   ///     keys that are encountered. The closure returns the desired value for
   ///     the final dictionary.
   @inlinable
   public func keyed<Key>(
     by keyForValue: (Element) throws -> Key,
-    uniquingKeysWith combine: (Key, Element, Element) throws -> Element
+    resolvingConflictsWith resolve: (Key, Element, Element) throws -> Element
   ) rethrows -> [Key: Element] {
     var result = [Key: Element]()
 
     for element in self {
       let key = try keyForValue(element)
 
       if let oldValue = result.updateValue(element, forKey: key) {
-        let valueToKeep = try combine(key, oldValue, element)
+        let valueToKeep = try resolve(key, oldValue, element)
 
         // This causes a second look-up for the same key. The standard library can avoid that
         // by calling `mutatingFind` to get access to the bucket where the value will end up,
         // and updating in place.
-        // Swift Algorithms doesn't have access to that API, so we make due.
+        // Swift Algorithms doesn't have access to that API, so we make do.
         // When this gets merged into the standard library, we should optimize this.
         result[key] = valueToKeep
       }

Tests/SwiftAlgorithmsTests/KeyedTests.swift

@@ -41,16 +41,16 @@ final class KeyedTests: XCTestCase {
   }
 
   func testNonUniqueKeysWithMergeFunction() {
-    var combineCallHistory = [(key: Character, current: String, new: String)]()
+    var resolveCallHistory = [(key: Character, current: String, new: String)]()
     let expectedCallHistory = [
       (key: "A", current: "Apple", new: "Avocado"),
       (key: "C", current: "Cherry", new: "Coconut"),
     ]
 
     let d = ["Apple", "Avocado", "Banana", "Cherry", "Coconut"].keyed(
       by: { $0.first! },
-      uniquingKeysWith: { key, older, newer in
-        combineCallHistory.append((key, older, newer))
+      resolvingConflictsWith: { key, older, newer in
+        resolveCallHistory.append((key, older, newer))
         return "\(older)-\(newer)"
       }
     )
@@ -62,7 +62,7 @@ final class KeyedTests: XCTestCase {
     XCTAssertNil(d["D"])
 
     XCTAssertEqual(
-      combineCallHistory.map(String.init(describing:)), // quick/dirty workaround: tuples aren't Equatable
+      resolveCallHistory.map(String.init(describing:)), // quick/dirty workaround: tuples aren't Equatable
       expectedCallHistory.map(String.init(describing:))
     )
   }
@@ -83,7 +83,7 @@ final class KeyedTests: XCTestCase {
     let error = SampleError()
 
     XCTAssertThrowsError(
-      try input.keyed(by: { $0.first! }, uniquingKeysWith: { _, _, _ in throw error })
+      try input.keyed(by: { $0.first! }, resolvingConflictsWith: { _, _, _ in throw error })
     ) { thrownError in
       XCTAssertIdentical(error, thrownError as? SampleError)
     }