Remove partitioned(upTo:)

Author: mdznr

Guides/Partition.md

@@ -56,18 +56,6 @@ print(shortNames)
 // Prints "["Kim", "Karl"]"
 ```
 
-There’s also a function to partition a collection into a prefix and a suffix, up
-to but not including a given index:
-
-```swift
-let cast = ["Vivien", "Marlon", "Kim", "Karl"]
-let (callbacks, alternates) = cast.partitioned(upTo: 2)
-print(callbacks)
-// Prints "["Vivien", "Marlon"]"
-print(alternates)
-// Prints "["Kim", "Karl"]"
-```
-
 ## Detailed Design
 
 All mutating methods are declared as extensions to `MutableCollection`.

Sources/Algorithms/Partition.swift

@@ -344,28 +344,11 @@ extension Collection {
         }
       })
 
-    let collections = elements.partitioned(upTo: midPoint)
-    return _tupleMap(collections, { Array($0) })
-  }
-}
-
-//===----------------------------------------------------------------------===//
-// partitioned(upTo:)
-//===----------------------------------------------------------------------===//
-
-extension Collection {
-  /// Splits the receiving collection into two at the specified index
-  /// - Parameter index: The index within the receiver to split the collection
-  /// - Returns: A tuple with the first and second parts of the receiving
-  /// collection after splitting it
-  /// - Note: The first subsequence in the returned tuple does *not* include
-  /// the element at `index`. That element is in the second subsequence.
-  /// - Complexity: O(*1*)
-  @inlinable
-  public func partitioned(upTo index: Index) -> (SubSequence, SubSequence) {
+    let lhs = elements[..<midPoint]
+    let rhs = elements[midPoint...]
     return (
-      self[self.startIndex..<index],
-      self[index..<self.endIndex]
+      Array(lhs),
+      Array(rhs)
     )
   }
 }

Tests/SwiftAlgorithmsTests/PartitionTests.swift

@@ -169,27 +169,4 @@ final class PartitionTests: XCTestCase {
     XCTAssertEqual(s3.0, ["B"])
     XCTAssertEqual(s3.1, ["a", "c", "d"])
   }
-  
-  func testPartitionedUpToIndex() throws {
-    let s0 = ["A", "B", "C", "D"].partitioned(upTo: 0)
-    let s1 = ["A", "B", "C", "D"].partitioned(upTo: 1)
-    let s2 = ["A", "B", "C", "D"].partitioned(upTo: 2)
-    let s3 = ["A", "B", "C", "D"].partitioned(upTo: 3)
-    let s4 = ["A", "B", "C", "D"].partitioned(upTo: 4)
-    
-    XCTAssertEqual(s0.0, [])
-    XCTAssertEqual(s0.1, ["A", "B", "C", "D"])
-    
-    XCTAssertEqual(s1.0, ["A"])
-    XCTAssertEqual(s1.1, ["B", "C", "D"])
-    
-    XCTAssertEqual(s2.0, ["A", "B"])
-    XCTAssertEqual(s2.1, ["C", "D"])
-    
-    XCTAssertEqual(s3.0, ["A", "B", "C"])
-    XCTAssertEqual(s3.1, ["D"])
-    
-    XCTAssertEqual(s4.0, ["A", "B", "C", "D"])
-    XCTAssertEqual(s4.1, [])
-  }
 }