Implementing hashable conditional conformance because synthetization is not possible

Author: LucianoPAlmeida

Sources/Algorithms/Chunked.swift

@@ -248,18 +248,18 @@ extension Collection {
 }
 
 //===----------------------------------------------------------------------===//
-// chunks(of:)
+// chunks(ofCount:)
 //===----------------------------------------------------------------------===//
 
 /// A collection that presents the elements of its base collection
-/// in `SubSequence` chunks of any given size.
+/// in `SubSequence` chunks of any given count.
 ///
 /// A `ChunkedByCount` is a lazy view on the base Collection, but it does not implicitly confer
 /// laziness on algorithms applied to its result.  In other words, for ordinary collections `c`:
 ///
-/// * `c.chunks(of: 3)` does not create new storage
-/// * `c.chunks(of: 3).map(f)` maps eagerly and returns a new array
-/// * `c.lazy.chunks(of: 3).map(f)` maps lazily and returns a `LazyMapCollection`
+/// * `c.chunks(ofCount: 3)` does not create new storage
+/// * `c.chunks(ofCount: 3).map(f)` maps eagerly and returns a new array
+/// * `c.lazy.chunks(ofCount: 3).map(f)` maps lazily and returns a `LazyMapCollection`
 public struct ChunkedByCount<Base: Collection> {
 
   public typealias Element = Base.SubSequence
@@ -274,7 +274,7 @@ public struct ChunkedByCount<Base: Collection> {
   internal var computedStartIndex: Index
 
   ///  Creates a view instance that presents the elements of `base`
-  ///  in `SubSequence` chunks of the given size.
+  ///  in `SubSequence` chunks of the given count.
   ///
   /// - Complexity: O(n)
   @inlinable
@@ -305,11 +305,13 @@ extension ChunkedByCount: Collection {
     }
   }
 
+  /// - Complexity: O(n)
   public var startIndex: Index { computedStartIndex }
   public var endIndex: Index {
     Index(_baseRange: base.endIndex..<base.endIndex)
   }
 
+  /// - Complexity: O(n)
   public subscript(i: Index) -> Element {
     base[i.baseRange]
   }
@@ -376,9 +378,9 @@ where Base: RandomAccessCollection {
 
 extension Collection {
   /// Returns a `ChunkedCollection<Self>` view presenting the elements
-  /// in chunks with count of the given size parameter.
+  /// in chunks with count of the given count parameter.
   ///
-  /// - Parameter size: The size of the chunks. If the size parameter
+  /// - Parameter size: The size of the chunks. If the count parameter
   ///   is evenly divided by the count of the base `Collection` all the
   ///   chunks will have the count equals to size.
   ///   Otherwise, the last chunk will contain the remaining elements.
@@ -400,9 +402,21 @@ extension Collection {
 
 // Conditional conformances.
 extension ChunkedByCount: Equatable where Base: Equatable {}
-extension ChunkedByCount: Hashable where Base: Hashable, Base.Index: Hashable {}
+
+// Since we have another stored property of type `Index` on the
+// collection, synthetization 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 make a difference here.
+extension ChunkedByCount: Hashable where Base: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(base)
+  }
+}
 extension ChunkedByCount.Index: Hashable where Base.Index: Hashable {}
 
 // Lazy conditional conformance.
-extension ChunkedByCount: LazySequenceProtocol where Base: LazySequenceProtocol {}
-extension ChunkedByCount: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
+extension ChunkedByCount: LazySequenceProtocol
+  where Base: LazySequenceProtocol {}
+extension ChunkedByCount: LazyCollectionProtocol
+  where Base: LazyCollectionProtocol {}