[CodeReview] More adjustments requested.

Author: LucianoPAlmeida

Sources/Algorithms/Compacted.swift

@@ -89,9 +89,8 @@ public struct CompactedCollection<Base: Collection, Element>: Collection
 
   @inlinable
   public func index(after i: Index) -> Index {
-    guard i != endIndex else {
-      fatalError("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 })
       else { return endIndex }
@@ -104,13 +103,12 @@ extension CompactedCollection: BidirectionalCollection
 
   @inlinable
   public func index(before i: Index) -> Index {
-    guard i != startIndex else {
-      fatalError("Index out of bounds")
-    }
+    precondition(i > startIndex, "Index out of bounds")
 
-    let baseIdx = base.index(before: i.base)
-    guard let idx = base[...baseIdx].lastIndex(where: { $0 != nil })
-      else { return Index(base: base.startIndex) }
+    guard let idx =
+            base[startIndex.base..<i.base]
+                .lastIndex(where: { $0 != nil })
+      else { fatalError("Index out of bounds") }
     return Index(base: idx)
   }
 }
@@ -150,46 +148,42 @@ extension CompactedCollection: LazyCollectionProtocol
 // Hashable and Equatable conformance are based on each non-nil
 // element on base collection.
 extension CompactedSequence: Equatable
-  where Base: Equatable, Base.Element: Equatable {
+  where Base.Element: Equatable {
 
   @inlinable
   public static func ==(lhs: CompactedSequence,
                         rhs: CompactedSequence) -> Bool {
-    lhs.compactMap({ $0 })
-      .elementsEqual(rhs.compactMap({ $0 }))
+    lhs.elementsEqual(rhs)
   }
 }
 
 extension CompactedSequence: Hashable
-  where Base: Hashable, Base.Element: Hashable {
+  where Element: Hashable {
   @inlinable
   public func hash(into hasher: inout Hasher) {
-    for element in base {
-      guard let unwrapped = element else { continue }
-      hasher.combine(unwrapped)
+    for element in self {
+      hasher.combine(element)
     }
   }
 }
 
 extension CompactedCollection: Equatable
-  where Base: Equatable, Base.Element: Equatable {
+  where Base.Element: Equatable {
 
   @inlinable
   public static func ==(lhs: CompactedCollection,
                         rhs: CompactedCollection) -> Bool {
-    lhs.compactMap({ $0 })
-      .elementsEqual(rhs.compactMap({ $0 }))
+    lhs.elementsEqual(rhs)
   }
 }
 
 extension CompactedCollection: Hashable
-  where Base: Hashable, Base.Element: Hashable {
+  where Element: Hashable {
 
   @inlinable
   public func hash(into hasher: inout Hasher) {
-    for element in base {
-      guard let unwrapped = element else { continue }
-      hasher.combine(unwrapped)
+    for element in self {
+      hasher.combine(element)
     }
   }
 }

Tests/SwiftAlgorithmsTests/CompactedTests.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift Algorithms open source project
 //
-// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information

Tests/SwiftAlgorithmsTests/TestUtilities.swift

@@ -46,6 +46,7 @@ struct SplitMix64: RandomNumberGenerator {
   }
 }
 
+// An eraser helper to any hashable sequence.
 struct AnyHashableSequence<Base>
   where Base: Sequence, Base: Hashable {
   var base: Base