Keep latest instead of throwing on collision

Author: amomchilov

Guides/Keyed.md

@@ -6,29 +6,29 @@
 Stores the elements of a sequence as the values of a Dictionary, keyed by the result of the given closure.
 
 ```swift
-let fruits = ["Apple", "Banana", "Cherry"]
-let fruitByLetter = try! fruits.keyed(by: { $0.first! })
+let fruits = ["Apricot", "Banana", "Apple", "Cherry", "Blackberry", "Avocado", "Coconut"]
+let fruitByLetter = fruits.keyed(by: { $0.first! })
 // Results in:
 // [
-//     "A": "Apple",
-//     "B": "Banana",
-//     "C": "Cherry",
+//     "A": "Avocado",
+//     "B": "Blackberry",
+//     "C": "Coconut",
 // ]
 ```
 
-Duplicate keys throw an error by default. Alternatively, you can provide a closure which specifies which value to keep:
+On a key-collision, the latest element is kept by default. Alternatively, you can provide a closure which specifies which value to keep:
 
 ```swift
 let fruits = ["Apricot", "Banana", "Apple", "Cherry", "Blackberry", "Avocado", "Coconut"]
 let fruitsByLetter = fruits.keyed(
     by: { $0.first! },
-    resolvingConflictsWith: { key, old, new in new } // Always pick the latest fruit
+    resolvingConflictsWith: { key, old, new in old } // Always pick the first fruit
 )
 // Results in:
 // [
-//     "A": "Avocado",
-//     "B": "Blackberry"],
-//     "C": "Coconut",
+//     "A": "Apricot",
+//     "B": "Banana",
+//     "C": "Cherry",
 // ]
 ```
 
@@ -40,7 +40,7 @@ The `keyed(by:)` and `keyed(by:resolvingConflictsWith:)` methods are declared in
 extension Sequence {
     public func keyed<Key>(
         by keyForValue: (Element) throws -> Key
-    ) throws -> [Key: Element]
+    ) rethrows -> [Key: Element]
 
     public func keyed<Key>(
         by keyForValue: (Element) throws -> Key,

Sources/Algorithms/Keyed.swift

@@ -9,35 +9,20 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct KeysAreNotUnique<Key, Element>: Error {
-  public let key: Key
-  public let previousElement: Element
-  public let conflictingElement: Element
-
-  @inlinable
-  public init(key: Key, previousElement: Element, conflictingElement: Element) {
-    self.key = key
-    self.previousElement = previousElement
-    self.conflictingElement = conflictingElement
-  }
-}
-
 extension Sequence {
   /// Creates a new Dictionary from the elements of `self`, keyed by the
-  /// results returned by the given `keyForValue` closure. Deriving the
-  /// same duplicate key for more than one element of `self` will cause
-  /// an error to be thrown.
+  /// results returned by the given `keyForValue` closure.
+  ///
+  /// If the key derived for a new element collides with an existing key from a previous element,
+  /// the latest value will be kept.
   ///
   /// - Parameters:
   ///   - keyForValue: A closure that returns a key for each element in `self`.
-  /// - Throws: `KeysAreNotUnique ` if two values map to the same key (via `keyForValue`).
   @inlinable
   public func keyed<Key>(
     by keyForValue: (Element) throws -> Key
-  ) throws -> [Key: Element] {
-    try self.keyed(by: keyForValue, resolvingConflictsWith: {
-       throw KeysAreNotUnique(key: $0, previousElement: $1, conflictingElement: $2)
-    })
+  ) rethrows -> [Key: Element] {
+    return try self.keyed(by: keyForValue, resolvingConflictsWith: { _, old, new in new })
   }
 
   /// Creates a new Dictionary from the elements of `self`, keyed by the

Tests/SwiftAlgorithmsTests/KeyedTests.swift

@@ -16,7 +16,7 @@ final class KeyedTests: XCTestCase {
   private class SampleError: Error {}
 
   func testUniqueKeys() {
-    let d = try! ["Apple", "Banana", "Cherry"].keyed(by: { $0.first! })
+    let d = ["Apple", "Banana", "Cherry"].keyed(by: { $0.first! })
     XCTAssertEqual(d.count, 3)
     XCTAssertEqual(d["A"]!, "Apple")
     XCTAssertEqual(d["B"]!, "Banana")
@@ -25,19 +25,16 @@ final class KeyedTests: XCTestCase {
   }
 
   func testEmpty() {
-    let d = try! EmptyCollection<String>().keyed(by: { $0.first! })
+    let d = EmptyCollection<String>().keyed(by: { $0.first! })
     XCTAssertEqual(d.count, 0)
   }
 
   func testNonUniqueKeys() throws {
-    XCTAssertThrowsError(
-      try ["Apple", "Avocado", "Banana", "Cherry"].keyed(by: { $0.first! })
-    ) { thrownError in
-      let e = thrownError as! KeysAreNotUnique<Character, String>
-      XCTAssertEqual(e.key, "A")
-      XCTAssertEqual(e.previousElement, "Apple")
-      XCTAssertEqual(e.conflictingElement, "Avocado")
-    }
+    let d = ["Apple", "Avocado", "Banana", "Cherry"].keyed(by: { $0.first! })
+    XCTAssertEqual(d.count, 3)
+    XCTAssertEqual(d["A"]!, "Avocado", "On a key-collision, keyed(by:) should take the latest value.")
+    XCTAssertEqual(d["B"]!, "Banana")
+    XCTAssertEqual(d["C"]!, "Cherry")
   }
 
   func testNonUniqueKeysWithMergeFunction() {