Rename duplicate-stripping functions

Author: CTMacUser

Sources/Algorithms/SortedDuplicates.swift

@@ -85,7 +85,7 @@ extension Sequence {
   ///
   /// - Complexity: O(`n`), where *n* is the length of this sequence.
   @inlinable
-  public func withoutSortedDuplicates(
+  public func deduplicateSorted(
     by areInIncreasingOrder: (Element, Element) throws -> Bool
   ) rethrows -> [Element] {
     try countSortedDuplicates(by: areInIncreasingOrder).map(\.value)
@@ -121,8 +121,8 @@ extension Sequence where Element: Comparable {
   ///
   /// - Complexity: O(`n`), where *n* is the length of this sequence.
   @inlinable
-  public func withoutSortedDuplicates() -> [Element] {
-    withoutSortedDuplicates(by: <)
+  public func deduplicateSorted() -> [Element] {
+    deduplicateSorted(by: <)
   }
 }
 
@@ -157,7 +157,7 @@ extension LazySequenceProtocol {
   /// - Returns: A sequence that lazily generates the first element of
   ///   each equivalence class present in this sequence.
   @inlinable
-  public func withoutSortedDuplicates(
+  public func deduplicateSorted(
     by areInIncreasingOrder: @escaping (Element, Element) -> Bool
   ) -> some (Sequence<Element> & LazySequenceProtocol) {
     countSortedDuplicates(by: areInIncreasingOrder).lazy.map(\.value)
@@ -188,10 +188,10 @@ extension LazySequenceProtocol where Element: Comparable {
   /// - Returns: A sequence that lazily generates the first element of
   ///   each value.
   @inlinable
-  public func withoutSortedDuplicates() -> some (
+  public func deduplicateSorted() -> some (
     Sequence<Element> & LazySequenceProtocol
   ) {
-    withoutSortedDuplicates(by: <)
+    deduplicateSorted(by: <)
   }
 }
 

Tests/SwiftAlgorithmsTests/SortedDuplicatesTests.swift

@@ -20,27 +20,27 @@ final class SortedDuplicatesTests: XCTestCase {
     let emptyStringCounts = emptyString.countSortedDuplicates()
     expectEqualCollections(emptyStringCounts.map(\.value), [])
     expectEqualCollections(emptyStringCounts.map(\.count), [])
-    expectEqualCollections(emptyString.withoutSortedDuplicates(), [])
+    expectEqualCollections(emptyString.deduplicateSorted(), [])
 
     let lazyEmptyStringCounts = emptyString.lazy.countSortedDuplicates()
     expectEqualSequences(lazyEmptyStringCounts.map(\.value), [])
     expectEqualSequences(lazyEmptyStringCounts.map(\.count), [])
-    expectEqualSequences(emptyString.lazy.withoutSortedDuplicates(), [])
+    expectEqualSequences(emptyString.lazy.deduplicateSorted(), [])
   }
 
   /// Test counting over a single-element sequence.
   func testSingle() {
     let aString = "a"
     let aStringCounts = aString.countSortedDuplicates()
-    let aStringValues = aString.withoutSortedDuplicates()
+    let aStringValues = aString.deduplicateSorted()
     expectEqualCollections(aStringCounts.map(\.value), ["a"])
     expectEqualCollections(aStringCounts.map(\.count), [1])
     expectEqualCollections(aStringValues, ["a"])
 
     let lazyAStringCounts = aString.lazy.countSortedDuplicates()
     expectEqualSequences(lazyAStringCounts.map(\.value), ["a"])
     expectEqualSequences(lazyAStringCounts.map(\.count), [1])
-    expectEqualSequences(aString.lazy.withoutSortedDuplicates(), ["a"])
+    expectEqualSequences(aString.lazy.deduplicateSorted(), ["a"])
   }
 
   /// Test counting over a repeated element.
@@ -51,10 +51,10 @@ final class SortedDuplicatesTests: XCTestCase {
     let lazyLettersCounts = letters.lazy.countSortedDuplicates()
     expectEqualCollections(lettersCounts.map(\.value), ["b"])
     expectEqualCollections(lettersCounts.map(\.count), [count])
-    expectEqualCollections(letters.withoutSortedDuplicates(), ["b"])
+    expectEqualCollections(letters.deduplicateSorted(), ["b"])
     expectEqualSequences(lazyLettersCounts.map(\.value), ["b"])
     expectEqualSequences(lazyLettersCounts.map(\.count), [count])
-    expectEqualSequences(letters.lazy.withoutSortedDuplicates(), ["b"])
+    expectEqualSequences(letters.lazy.deduplicateSorted(), ["b"])
   }
 
   /// Test multiple elements.
@@ -72,11 +72,11 @@ final class SortedDuplicatesTests: XCTestCase {
     ]
     expectEqualCollections(sampleCounts.map(\.value), expected.map(\.0))
     expectEqualCollections(sampleCounts.map(\.count), expected.map(\.1))
-    expectEqualCollections(sample.withoutSortedDuplicates(), "Xacdfxz")
+    expectEqualCollections(sample.deduplicateSorted(), "Xacdfxz")
 
     let lazySampleCounts = sample.lazy.countSortedDuplicates()
     expectEqualSequences(lazySampleCounts.map(\.value), expected.map(\.0))
     expectEqualSequences(lazySampleCounts.map(\.count), expected.map(\.1))
-    expectEqualSequences(sample.lazy.withoutSortedDuplicates(), "Xacdfxz")
+    expectEqualSequences(sample.lazy.deduplicateSorted(), "Xacdfxz")
   }
 }