Remove combinations() in favor of using 0...

Author: mdznr

Guides/Combinations.md

@@ -56,32 +56,6 @@ for combo in numbers(ofCounts: 2...3) {
 // [20, 30, 40]
 ```
 
-The `combinations()` method returns a sequence of *all* the different
-combinations of a collection’s elements in increasing order of size.
-
-```swift
-let numbers = [10, 20, 30, 40]
-for combo in numbers.combinations() {
-    print(combo)
-}
-// []
-// [10]
-// [20]
-// [30]
-// [40]
-// [10, 20]
-// [10, 30]
-// [10, 40]
-// [20, 30]
-// [20, 40]
-// [30, 40]
-// [10, 20, 30]
-// [10, 20, 40]
-// [10, 30, 40]
-// [20, 30, 40]
-// [10, 20, 30, 40]
-```
-
 ## Detailed Design
 
 The `combinations(ofCount:)` method is declared as a  `Collection` extension,

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:)`, `combinations()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of particular sizes of the elements in a collection.
+- [`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.
 - [`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

@@ -20,13 +20,6 @@ public struct Combinations<Base: Collection> {
   @usableFromInline
   internal let kRange: Range<Int>?
 
-  /// Initializes a `Combinations` for all combinations of `base` of all sizes.
-  /// - Parameter base: The collection to iterate over for combinations.
-  @usableFromInline
-  internal init(_ base: Base) {
-    self.init(base, kRange: 0...)
-  }
-  
   /// Initializes a `Combinations` for all combinations of `base` of size `k`.
   /// - Parameters:
   ///   - base: The collection to iterate over for combinations.
@@ -183,51 +176,6 @@ extension Combinations: LazySequenceProtocol where Base: LazySequenceProtocol {}
 extension Combinations: Equatable where Base: Equatable {}
 extension Combinations: Hashable where Base: Hashable {}
 
-//===----------------------------------------------------------------------===//
-// combinations()
-//===----------------------------------------------------------------------===//
-
-extension Collection {
-  /// Returns a collection of all the combinations of this collection's
-  /// elements, including the full collection and an empty collection
-  ///
-  /// This example prints the all the combinations from an array of letters:
-  ///
-  ///     let letters = ["A", "B", "C", "D"]
-  ///     for combo in letters.combinations() {
-  ///         print(combo.joined(separator: ", "))
-  ///     }
-  ///     //
-  ///     // A
-  ///     // B
-  ///     // C
-  ///     // D
-  ///     // A, B
-  ///     // A, C
-  ///     // A, D
-  ///     // B, C
-  ///     // B, D
-  ///     // C, D
-  ///     // A, B, C
-  ///     // A, B, D
-  ///     // A, C, D
-  ///     // B, C, D
-  ///     // A, B, C, D
-  ///
-  /// The returned collection presents combinations in a consistent order, where
-  /// the indices in each combination are in ascending lexicographical order,
-  /// and the size of the combinations are in increasing order.
-  /// That is, in the example above, the combinations in order are the elements
-  /// at `[]`, `[0]`, `[1]`, `[2]`, `[3]`, `[0, 1]`, `[0, 2]`, `[0, 3]`,
-  /// `[1, 2]`, `[1, 3]`, … `[0, 1, 2, 3]`.
-  ///
-  /// - Complexity: O(1)
-  @inlinable
-  public func combinations() -> Combinations<Self> {
-    return Combinations(self)
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // combinations(ofCounts:)
 //===----------------------------------------------------------------------===//
@@ -260,6 +208,30 @@ extension Collection {
   /// at `[0]`, `[1]`, `[2]`, `[3]`, `[0, 1]`, `[0, 2]`, `[0, 3]`, `[1, 2]`,
   /// `[1, 3]`, and finally `[2, 3]`.
   ///
+  /// This example prints _all_ the combinations (including an empty array and
+  /// the original collection) from an array of numbers:
+  ///
+  ///     let numbers = [10, 20, 30, 40]
+  ///     for combo in numbers.combinations() {
+  ///         print(combo)
+  ///     }
+  ///     // []
+  ///     // [10]
+  ///     // [20]
+  ///     // [30]
+  ///     // [40]
+  ///     // [10, 20]
+  ///     // [10, 30]
+  ///     // [10, 40]
+  ///     // [20, 30]
+  ///     // [20, 40]
+  ///     // [30, 40]
+  ///     // [10, 20, 30]
+  ///     // [10, 20, 40]
+  ///     // [10, 30, 40]
+  ///     // [20, 30, 40]
+  ///     // [10, 20, 30, 40]
+  ///
   /// If `kRange` is `0...0`, the resulting sequence has exactly one element, an
   /// empty array. If `k.upperBound` is greater than the number of elements in
   /// this sequence, the resulting sequence has no elements.

Tests/SwiftAlgorithmsTests/CombinationsTests.swift

@@ -64,7 +64,7 @@ final class CombinationsTests: XCTestCase {
     let c14 = c.combinations(ofCounts: ...3).count
     XCTAssertEqual(c14, 15)
 
-    let c15 = c.combinations().count
+    let c15 = c.combinations(ofCounts: 0...).count
     XCTAssertEqual(c15, 16)
   }
 
@@ -89,7 +89,7 @@ final class CombinationsTests: XCTestCase {
     let c6 = c.combinations(ofCounts: 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()
+    let c7 = c.combinations(ofCounts: 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)
@@ -121,6 +121,6 @@ final class CombinationsTests: XCTestCase {
     XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: 1...3))
     XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: 1...))
     XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: ...3))
-    XCTAssertLazySequence("ABC".lazy.combinations())
+    XCTAssertLazySequence("ABC".lazy.combinations(ofCounts: 0...))
   }
 }