fix: dictionary literal with duplicate keys now sums counts, Also added validateCount helper for consistent count validation.

Author: Thomas Heinis

Sources/DataStructuresKit/Collections/Bag.swift

@@ -130,6 +130,14 @@ public struct Bag<Element: Hashable> {
     }
   }
 
+  // MARK: - Validation
+
+  /// Validates that a count is positive.
+  @usableFromInline
+  internal static func validateCount(_ count: Int) -> Bool {
+    count > 0
+  }
+  
   // MARK: - Initialization
 
   /// Creates an empty bag.
@@ -175,8 +183,9 @@ public struct Bag<Element: Hashable> {
   /// let bag = Bag(["apple": 3, "banana": 2])
   /// print(bag.totalCount) // 5
   /// ```
+  @inlinable
   public init(_ counts: [Element: Int]) {
-    precondition(counts.values.allSatisfy { $0 > 0 }, "All counts must be positive")
+    precondition(counts.values.allSatisfy(Self.validateCount), "All counts must be positive")
     let total = counts.values.reduce(0, +)
     self.storage = Storage(counts: counts, totalCount: total)
   }
@@ -315,7 +324,7 @@ public struct Bag<Element: Hashable> {
   /// ```
   @inlinable
   public mutating func insert(_ element: Element, count: Int) {
-    precondition(count > 0, "Count must be positive")
+    precondition(Self.validateCount(count), "Count must be positive")
     ensureUnique()
     storage.counts[element, default: 0] += count
     storage.totalCount += count
@@ -363,7 +372,7 @@ public struct Bag<Element: Hashable> {
   @inlinable
   @discardableResult
   public mutating func remove(_ element: Element, count: Int) -> Int {
-    precondition(count > 0, "Count must be positive")
+    precondition(Self.validateCount(count), "Count must be positive")
     guard let current = storage.counts[element] else { return 0 }
 
     ensureUnique()
@@ -546,7 +555,7 @@ extension Bag: ExpressibleByDictionaryLiteral {
     self.storage = Storage()
     for (element, count) in elements {
       precondition(count > 0, "All counts must be positive")
-      storage.counts[element] = count
+      storage.counts[element, default: 0] += count
       storage.totalCount += count
     }
   }

Tests/DataStructuresKitTests/CollectionsTests/BagTests.swift

@@ -312,4 +312,60 @@ struct BagTests {
     #expect(bag.uniqueCount == 9)
     #expect(bag.totalCount == 12)
   }
+  
+  @Test("Dictionary literal with duplicate keys sums counts")
+  func testDictionaryLiteralDuplicateKeys() {
+      let bag: Bag<String> = ["a": 1, "a": 2, "b": 3]
+      
+      #expect(bag.count(of: "a") == 3)
+      #expect(bag.count(of: "b") == 3)
+      #expect(bag.uniqueCount == 2)
+      #expect(bag.totalCount == 6)
+  }
+}
+
+@Test("Dictionary literal basic usage")
+func testDictionaryLiteralBasic() {
+    let bag: Bag<String> = ["apple": 3, "banana": 2]
+    
+    #expect(bag.count(of: "apple") == 3)
+    #expect(bag.count(of: "banana") == 2)
+    #expect(bag.uniqueCount == 2)
+    #expect(bag.totalCount == 5)
+}
+
+@Test("Dictionary literal single element")
+func testDictionaryLiteralSingleElement() {
+    let bag: Bag<String> = ["only": 5]
+    
+    #expect(bag.count(of: "only") == 5)
+    #expect(bag.uniqueCount == 1)
+    #expect(bag.totalCount == 5)
+}
+
+@Test("Dictionary literal empty")
+func testDictionaryLiteralEmpty() {
+    let bag: Bag<String> = [:]
+    
+    #expect(bag.isEmpty)
+    #expect(bag.uniqueCount == 0)
+    #expect(bag.totalCount == 0)
+}
+
+@Test("Dictionary literal with count of 1")
+func testDictionaryLiteralCountOfOne() {
+    let bag: Bag<String> = ["a": 1, "b": 1, "c": 1]
+    
+    #expect(bag.count(of: "a") == 1)
+    #expect(bag.count(of: "b") == 1)
+    #expect(bag.count(of: "c") == 1)
+    #expect(bag.uniqueCount == 3)
+    #expect(bag.totalCount == 3)
+}
+
+@Test("Count validation rejects zero and negative")
+func testCountValidation() {
+    #expect(Bag<String>.validateCount(1) == true)
+    #expect(Bag<String>.validateCount(0) == false)
+    #expect(Bag<String>.validateCount(-5) == false)
 }