Continue renaming function

Author: CTMacUser

CHANGELOG.md

@@ -13,7 +13,7 @@ This project follows semantic versioning.
 - Bidirectional collections have a new `ends(with:)` method that matches
   the behavior of the standard library's `starts(with:)` method. ([#224])
 - Sequences that are already sorted can use the `countSortedDuplicates` and
-  `withoutSortedDuplicates` methods, with eager and lazy versions.
+  `deduplicateSorted` methods, with eager and lazy versions.
   The former returns each unique value paired with the count of
   that value's occurances.
   The latter returns each unique value,

Guides/README.md

@@ -25,14 +25,14 @@ These guides describe the design and intention behind the APIs included in the `
 #### Subsetting operations
 
 - [`compacted()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Compacted.md): Drops the `nil`s from a sequence or collection, unwrapping the remaining elements.
+- [`deduplicateSorted()`, `deduplicateSorted(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/SortedDuplicates.md): Given an already-sorted sequence and the sorting predicate, reduce all runs of a unique value to a single element each. Has eager and lazy variants.
 - [`partitioned(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): Returns the elements in a sequence or collection that do and do not match a given predicate.
 - [`randomSample(count:)`, `randomSample(count:using:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/RandomSampling.md): Randomly selects a specific number of elements from a collection.
 - [`randomStableSample(count:)`, `randomStableSample(count:using:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/RandomSampling.md): Randomly selects a specific number of elements from a collection, preserving their original relative order.
 - [`striding(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Stride.md): Returns every nth element of a collection.
 - [`suffix(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Suffix.md): Returns the suffix of a collection where all element pass a given predicate.
 - [`trimmingPrefix(while:)`, `trimmingSuffix(while)`, `trimming(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Trim.md): Returns a slice by trimming elements from a collection's start, end, or both. The mutating `trim...` methods trim a collection in place.
 - [`uniqued()`, `uniqued(on:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Unique.md): The unique elements of a collection, preserving their order.
-- [`withoutSortedDuplicates()`, `withoutSortedDuplicates(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/SortedDuplicates.md): Given an already-sorted sequence and the sorting predicate, reduce all runs of a unique value to a single element each. Has eager and lazy variants.
 - [`minAndMax()`, `minAndMax(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest and largest elements of a sequence.
 
 #### Partial sorting

Guides/SortedDuplicates.md

@@ -21,23 +21,23 @@ extension Sequence {
         by areInIncreasingOrder: (Element, Element) throws -> Bool
     ) rethrows -> [(value: Element, count: Int)]
 
-    public func withoutSortedDuplicates(
+    public func deduplicateSorted(
         by areInIncreasingOrder: (Element, Element) throws -> Bool
     ) rethrows -> [Element]
 }
 
 extension Sequence where Self.Element : Comparable {
     public func countSortedDuplicates() -> [(value: Element, count: Int)]
 
-    public func withoutSortedDuplicates() -> [Element]
+    public func deduplicateSorted() -> [Element]
 }
 
 extension LazySequenceProtocol {
     public func countSortedDuplicates(
         by areInIncreasingOrder: @escaping (Element, Element) -> Bool
     ) -> LazyCountDuplicatesSequence<Elements>
 
-    public func withoutSortedDuplicates(
+    public func deduplicateSorted(
         by areInIncreasingOrder: @escaping (Element, Element) -> Bool
     ) -> some (Sequence<Element> & LazySequenceProtocol)
 }
@@ -46,7 +46,7 @@ extension LazySequenceProtocol where Self.Element : Comparable {
     public func countSortedDuplicates()
      -> LazyCountDuplicatesSequence<Elements>
 
-    public func withoutSortedDuplicates()
+    public func deduplicateSorted()
      -> some (Sequence<Element> & LazySequenceProtocol)
 }
 

Sources/Algorithms/Documentation.docc/Filtering.md

@@ -21,11 +21,11 @@ let withNoNils = array.compacted()
 // Array(withNoNils) == [10, 30, 2, 3, 5]
 ```
 
-The `withoutSortedDuplicates()` methods remove consecutive elements of the same equivalence class from an already sorted sequence, turning a possibly non-decreasing sequence to a strictly-increasing one. The sorting predicate can be supplied.
+The `deduplicateSorted()` methods remove consecutive elements of the same equivalence class from an already sorted sequence, turning a possibly non-decreasing sequence to a strictly-increasing one. The sorting predicate can be supplied.
 
 ```swift
 let numbers = [0, 1, 2, 2, 2, 3, 5, 6, 6, 9, 10, 10]
-let deduplicated = numbers.withoutSortedDuplicates()
+let deduplicated = numbers.deduplicateSorted()
 // Array(deduplicated) == [0, 1, 2, 3, 5, 6, 9, 10]
 ```
 
@@ -44,10 +44,10 @@ let deduplicated = numbers.withoutSortedDuplicates()
 
 ### Removing Duplicates from a Sorted Sequence
 
-- ``Swift/Sequence/withoutSortedDuplicates(by:)``
-- ``Swift/Sequence/withoutSortedDuplicates()``
-- ``Swift/LazySequenceProtocol/withoutSortedDuplicates(by:)``
-- ``Swift/LazySequenceProtocol/withoutSortedDuplicates()``
+- ``Swift/Sequence/deduplicateSorted(by:)``
+- ``Swift/Sequence/deduplicateSorted()``
+- ``Swift/LazySequenceProtocol/deduplicateSorted(by:)``
+- ``Swift/LazySequenceProtocol/deduplicateSorted()``
 
 ### Supporting Types
 

Tests/SwiftAlgorithmsTests/SortedDuplicatesTests.swift

@@ -83,7 +83,7 @@ final class SortedDuplicatesTests: XCTestCase {
   /// Test the example code from the Overview.
   func testOverviewExample() {
     let numbers = [0, 1, 2, 2, 2, 3, 5, 6, 6, 9, 10, 10]
-    let deduplicated = numbers.withoutSortedDuplicates()
+    let deduplicated = numbers.deduplicateSorted()
     // Array(deduplicated) == [0, 1, 2, 3, 5, 6, 9, 10]
 
     expectEqualSequences(deduplicated, [0, 1, 2, 3, 5, 6, 9, 10])