[CodeReview] Adjusment suggested on review

Author: LucianoPAlmeida

Sources/Algorithms/Compacted.swift

@@ -60,13 +60,11 @@ public struct CompactedCollection<Base: Collection, Element>: Collection
   @usableFromInline
   let base: Base
 
-  @usableFromInline
-  let _startIdx: Base.Index
-  
   @inlinable
   init(base: Base) {
     self.base = base
-    self._startIdx = base.firstIndex(where: { $0 != nil }) ?? base.endIndex
+    let idx = base.firstIndex(where: { $0 != nil }) ?? base.endIndex
+    self.startIndex = Index(base: idx)
   }
 
   public struct Index {
@@ -79,9 +77,7 @@ public struct CompactedCollection<Base: Collection, Element>: Collection
     }
   }
 
-  /// Complexity: O(1)
-  @inlinable
-  public var startIndex: Index { Index(base: _startIdx) }
+  public var startIndex: Index
 
   @inlinable
   public var endIndex: Index { Index(base: base.endIndex) }
@@ -93,19 +89,13 @@ public struct CompactedCollection<Base: Collection, Element>: Collection
 
   @inlinable
   public func index(after i: Index) -> Index {
-    guard i.base != base.endIndex else {
-      return Index(base: base.endIndex)
+    guard i != endIndex else {
+      fatalError("Index out of bounds")
     }
-    
-    var idx = base.index(after: i.base)
-    while idx != base.endIndex {
-      guard base[idx] != nil else {
-        base.formIndex(after: &idx)
-        continue
-      }
-      return Index(base: idx)
-    }
-    return Index(base: base.endIndex)
+    let baseIdx = base.index(after: i.base)
+    guard let idx = base[baseIdx...].firstIndex(where: { $0 != nil })
+      else { return endIndex }
+    return Index(base: idx)
   }
 }
 
@@ -114,19 +104,14 @@ extension CompactedCollection: BidirectionalCollection
 
   @inlinable
   public func index(before i: Index) -> Index {
-    guard i.base != base.startIndex else {
-      return Index(base: base.startIndex)
-    }
-
-    var idx = base.index(before: i.base)
-    while idx > base.startIndex {
-      guard base[idx] != nil else {
-        base.formIndex(before: &idx)
-        continue
-      }
-      return Index(base: idx)
+    guard i != startIndex else {
+      fatalError("Index out of bounds")
     }
-    return Index(base: base.startIndex)
+    
+    let baseIdx = base.index(before: i.base)
+    guard let idx = base[...baseIdx].lastIndex(where: { $0 != nil })
+      else { return Index(base: base.startIndex) }
+    return Index(base: idx)
   }
 }
 
@@ -138,6 +123,9 @@ extension CompactedCollection.Index: Comparable {
   }
 }
 
+extension CompactedCollection.Index: Hashable
+  where Base.Index: Hashable {}
+
 extension Collection {
   /// Complexity: O(*n*) where *n*  is the number of elements in the
   /// base collection.
@@ -150,25 +138,58 @@ extension Collection {
 
 extension CompactedSequence: LazySequenceProtocol
   where Base: LazySequenceProtocol {}
-extension CompactedSequence: Equatable where Base: Equatable {}
-extension CompactedSequence: Hashable where Base: Hashable {}
 
 extension CompactedCollection: RandomAccessCollection
   where Base: RandomAccessCollection {}
 extension CompactedCollection: LazySequenceProtocol
   where Base: LazySequenceProtocol {}
 extension CompactedCollection: LazyCollectionProtocol
   where Base: LazyCollectionProtocol {}
-extension CompactedCollection: Equatable where Base: Equatable {}
-
-// Since we have another stored property of type `Base.Index` on the
-// collection, synthesis of `Hashble` conformace would require
-// a `Base.Index: Hashable` constraint, so we implement the hasher
-// only in terms of `base`. Since the computed index is based on it,
-// it should not make a difference here.
-extension CompactedCollection: Hashable where Base: Hashable {
+
+
+// Hashable and Equatable conformance is based on each non-nil
+// element on base collection.
+extension CompactedSequence: Equatable
+  where Base: Equatable, Base.Element: Equatable {
+
+  @inlinable
+  public static func ==(lhs: CompactedSequence,
+                        rhs: CompactedSequence) -> Bool {
+    lhs.compactMap({ $0 })
+      .elementsEqual(rhs.compactMap({ $0 }))
+  }
+}
+
+extension CompactedSequence: Hashable
+  where Base: Hashable, Base.Element: Hashable {
+  @inlinable
+  public func hash(into hasher: inout Hasher) {
+    for element in base {
+      guard let unwrapped = element else { continue }
+      hasher.combine(unwrapped)
+    }
+  }
+}
+
+extension CompactedCollection: Equatable
+  where Base: Equatable, Base.Element: Equatable {
+
+  @inlinable
+  public static func ==(lhs: CompactedCollection,
+                        rhs: CompactedCollection) -> Bool {
+    lhs.compactMap({ $0 })
+      .elementsEqual(rhs.compactMap({ $0 }))
+  }
+}
+
+extension CompactedCollection: Hashable
+  where Base: Hashable, Base.Element: Hashable {
+
   @inlinable
   public func hash(into hasher: inout Hasher) {
-    hasher.combine(base)
+    for element in base {
+      guard let unwrapped = element else { continue }
+      hasher.combine(unwrapped)
+    }
   }
 }