Rename combinations(ofCounts:) to combinations(ofCount:)

Author: mdznr

Guides/Combinations.md

@@ -36,13 +36,13 @@ for combo in numbers2.combinations(ofCount: 2) {
 // [10, 10]
 ```
 
-The `combinations(ofCounts:)` method returns a sequence of all the different
-combinations of the given sizes of a collection’s elements in increasing order
-of size.
+Given a range, the `combinations(ofCount:)` method returns a sequence of all
+the different combinations of the given sizes of a collection’s elements in
+increasing order of size.
 
 ```swift
 let numbers = [10, 20, 30, 40]
-for combo in numbers(ofCounts: 2...3) {
+for combo in numbers(ofCount: 2...3) {
     print(combo)
 }
 // [10, 20]

README.md

@@ -8,7 +8,7 @@ Read more about the package, and the intent behind it, in the [announcement on s
 
 #### Combinations / permutations
 
-- [`combinations(ofCount:)`, `combinations(ofCounts:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of particular sizes of the elements in a collection.
+- [`combinations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of particular sizes of the elements in a collection.
 - [`permutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a particular size of the elements in a collection, or of the full collection.
 
 #### Mutating algorithms

Sources/Algorithms/Combinations.swift

@@ -184,7 +184,7 @@ extension Combinations: Equatable where Base: Equatable {}
 extension Combinations: Hashable where Base: Hashable {}
 
 //===----------------------------------------------------------------------===//
-// combinations(ofCounts:)
+// combinations(ofCount:)
 //===----------------------------------------------------------------------===//
 
 extension Collection {
@@ -195,7 +195,7 @@ extension Collection {
   /// four colors:
   ///
   ///     let colors = ["fuchsia", "cyan", "mauve", "magenta"]
-  ///     for combo in colors.combinations(ofCounts: 1...2) {
+  ///     for combo in colors.combinations(ofCount: 1...2) {
   ///         print(combo.joined(separator: ", "))
   ///     }
   ///     // fuchsia
@@ -249,17 +249,11 @@ extension Collection {
   /// - Complexity: O(1)
   @inlinable
   public func combinations<R: RangeExpression>(
-    ofCounts kRange: R
+    ofCount kRange: R
   ) -> Combinations<Self> where R.Bound == Int {
     return Combinations(self, kRange: kRange)
   }
-}
-
-//===----------------------------------------------------------------------===//
-// combinations(ofCount:)
-//===----------------------------------------------------------------------===//
-
-extension Collection {
+  
   /// Returns a collection of combinations of this collection's elements, with
   /// each combination having the specified number of elements.
   ///

Tests/SwiftAlgorithmsTests/CombinationsTests.swift

@@ -31,40 +31,40 @@ final class CombinationsTests: XCTestCase {
     let c4 = c.combinations(ofCount: 4).count
     XCTAssertEqual(c4, 1)
 
-    let c5 = c.combinations(ofCounts: 0...0).count
+    let c5 = c.combinations(ofCount: 0...0).count
     XCTAssertEqual(c5, 1)
 
-    let c6 = c.combinations(ofCounts: 1...1).count
+    let c6 = c.combinations(ofCount: 1...1).count
     XCTAssertEqual(c6, 4)
 
-    let c7 = c.combinations(ofCounts: 1...2).count
+    let c7 = c.combinations(ofCount: 1...2).count
     XCTAssertEqual(c7, 10)
 
-    let c8 = c.combinations(ofCounts: 1...3).count
+    let c8 = c.combinations(ofCount: 1...3).count
     XCTAssertEqual(c8, 14)
 
-    let c9 = c.combinations(ofCounts: 2...4).count
+    let c9 = c.combinations(ofCount: 2...4).count
     XCTAssertEqual(c9, 11)
 
     // `k` greater than element count results in same number of combinations
-    let c10 = c.combinations(ofCounts: 3...10).count
+    let c10 = c.combinations(ofCount: 3...10).count
     XCTAssertEqual(c10, 5)
 
     // `k` greater than element count results in same number of combinations
-    let c11 = c.combinations(ofCounts: 4...10).count
+    let c11 = c.combinations(ofCount: 4...10).count
     XCTAssertEqual(c11, 1)
 
     // `k` entirely greater than element count results in no combinations
-    let c12 = c.combinations(ofCounts: 5...10).count
+    let c12 = c.combinations(ofCount: 5...10).count
     XCTAssertEqual(c12, 0)
 
-    let c13 = c.combinations(ofCounts: 0...).count
+    let c13 = c.combinations(ofCount: 0...).count
     XCTAssertEqual(c13, 16)
 
-    let c14 = c.combinations(ofCounts: ...3).count
+    let c14 = c.combinations(ofCount: ...3).count
     XCTAssertEqual(c14, 15)
 
-    let c15 = c.combinations(ofCounts: 0...).count
+    let c15 = c.combinations(ofCount: 0...).count
     XCTAssertEqual(c15, 16)
   }
 
@@ -83,44 +83,44 @@ final class CombinationsTests: XCTestCase {
     let c4 = c.combinations(ofCount: 4)
     XCTAssertEqual(["ABCD"], c4.map { String($0) })
 
-    let c5 = c.combinations(ofCounts: 2...4)
+    let c5 = c.combinations(ofCount: 2...4)
     XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c5.map { String($0) })
 
-    let c6 = c.combinations(ofCounts: 0...4)
+    let c6 = c.combinations(ofCount: 0...4)
     XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c6.map { String($0) })
 
-    let c7 = c.combinations(ofCounts: 0...)
+    let c7 = c.combinations(ofCount: 0...)
     XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c7.map { String($0) })
 
-    let c8 = c.combinations(ofCounts: ...4)
+    let c8 = c.combinations(ofCount: ...4)
     XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c8.map { String($0) })
 
-    let c9 = c.combinations(ofCounts: ...3)
+    let c9 = c.combinations(ofCount: ...3)
     XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD"], c9.map { String($0) })
 
-    let c10 = c.combinations(ofCounts: 1...)
+    let c10 = c.combinations(ofCount: 1...)
     XCTAssertEqual(["A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c10.map { String($0) })
   }
 
   func testEmpty() {
     // `k == 0` results in one zero-length combination
     XCTAssertEqualSequences([[]], "".combinations(ofCount: 0))
-    XCTAssertEqualSequences([[]], "".combinations(ofCounts: 0...0))
+    XCTAssertEqualSequences([[]], "".combinations(ofCount: 0...0))
     XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0))
-    XCTAssertEqualSequences([[]], "ABCD".combinations(ofCounts: 0...0))
+    XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
 
     // `k` greater than element count results in zero combinations
     XCTAssertEqualSequences([], "".combinations(ofCount: 5))
-    XCTAssertEqualSequences([], "".combinations(ofCounts: 5...10))
+    XCTAssertEqualSequences([], "".combinations(ofCount: 5...10))
     XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5))
-    XCTAssertEqualSequences([], "ABCD".combinations(ofCounts: 5...10))
+    XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5...10))
   }
 
   func testCombinationsLazy() {
     XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
-    XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: 1...3))
-    XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: 1...))
-    XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: ...3))
-    XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: 0...))
+    XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...3))
+    XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...))
+    XCTAssertLazySequence("ABC".lazy.combinations(ofCount: ...3))
+    XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 0...))
   }
 }