[CodeReview] Making the corrections

Author: LucianoPAlmeida

Sources/Algorithms/Compacted.swift

@@ -107,7 +107,7 @@ public struct CompactedCollection<Base: Collection, Element>: Collection
 
   @inlinable
   public func index(after i: Index) -> Index {
-    precondition(i < endIndex, "Index out of bounds")
+    precondition(i != endIndex, "Index out of bounds")
 
     let baseIdx = base.index(after: i.base)
     guard let idx = base[baseIdx...].firstIndex(where: { $0 != nil })
@@ -121,7 +121,7 @@ extension CompactedCollection: BidirectionalCollection
 
   @inlinable
   public func index(before i: Index) -> Index {
-    precondition(i > startIndex, "Index out of bounds")
+    precondition(i != startIndex, "Index out of bounds")
 
     guard let idx =
             base[startIndex.base..<i.base]
@@ -175,8 +175,6 @@ extension Collection {
 extension CompactedSequence: LazySequenceProtocol
   where Base: LazySequenceProtocol {}
 
-extension CompactedCollection: RandomAccessCollection
-  where Base: RandomAccessCollection {}
 extension CompactedCollection: LazySequenceProtocol
   where Base: LazySequenceProtocol {}
 extension CompactedCollection: LazyCollectionProtocol

Tests/SwiftAlgorithmsTests/CompactedTests.swift

@@ -38,7 +38,7 @@ final class CompactedTests: XCTestCase {
 
   func testCollectionTraversals() {
     for array in self.tests {
-      validateIndexTraversals(array)
+      validateIndexTraversals(array.compacted())
     }
   }
 
@@ -55,14 +55,27 @@ final class CompactedTests: XCTestCase {
   }
 
   func testCollectionHashableConformances() {
-    for array in self.tests {
-      let seq = array.eraseToAnyHashableSequence()
-      XCTAssertEqualHashValue(
-        seq.compacted(), seq.compactMap({ $0 }).compacted()
-      )
-      XCTAssertEqualHashValue(
-        array.compacted(), array.compactMap({ $0 }).compacted()
-      )
+    for array1 in self.tests {
+      for array2 in self.tests {
+        // For non-equal Collections and Sequences that produce the same
+        // compacted, the compacted wrapper should produce the same hash.
+        // e.g. [1, 2, 3, nil, nil, 4].compacted() should produce the
+        // same hash as [1, nil, 2, nil, 3, 4].compacted()
+        guard !array1.elementsEqual(array2) &&
+               array1.compacted() == array2.compacted() else {
+          continue
+        }
+        
+        let seq = array1.eraseToAnyHashableSequence()
+        let seq2 = array2.eraseToAnyHashableSequence()
+        
+        XCTAssertEqualHashValue(
+          seq.compacted(), seq2.compacted()
+        )
+        XCTAssertEqualHashValue(
+          array1.compacted(), array2.compacted()
+        )
+      }
     }
   }
 }

Tests/SwiftAlgorithmsTests/TestUtilities.swift

@@ -190,7 +190,7 @@ func hash<T: Hashable>(_ value: T) -> Int {
   return hasher.finalize()
 }
 
-/// Asserts two hashable value produce the same hash value.
+/// Asserts that two hashable instances produce the same hash value.
 func XCTAssertEqualHashValue<T: Hashable, U: Hashable>(
   _ expression1: @autoclosure () throws -> T,
   _ expression2: @autoclosure () throws -> U,