Remove collection conformances to Equatable and Hashable (#124)

Author: Tim Vermeulen

Guides/Compacted.md

@@ -31,8 +31,8 @@ extension Collection {
 ```
 
 One is a more general `CompactedSequence` for any `Sequence` base. And the other a more specialized `CompactedCollection` 
-where base is a `Collection` and with conditional conformance to `BidirectionalCollection`, `RandomAccessCollection`, 
-`LazyCollectionProtocol`, `Equatable` and `Hashable` when base collection conforms to them.
+where base is a `Collection` and with conditional conformance to `BidirectionalCollection`, `RandomAccessCollection` and
+`LazyCollectionProtocol` when base collection conforms to them.
 
 ### Naming
 

Sources/Algorithms/Chain.swift

@@ -283,9 +283,6 @@ extension Chain2: BidirectionalCollection
 extension Chain2: RandomAccessCollection
   where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
 
-extension Chain2: Equatable where Base1: Equatable, Base2: Equatable {}
-extension Chain2: Hashable where Base1: Hashable, Base2: Hashable {}
-
 //===----------------------------------------------------------------------===//
 // chain(_:_:)
 //===----------------------------------------------------------------------===//

Sources/Algorithms/Chunked.swift

@@ -512,21 +512,6 @@ extension Collection {
   }
 }
 
-// Conditional conformances.
-extension ChunkedByCount: Equatable where Base: Equatable {}
-
-// Since we have another stored property of type `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` and `chunkCount`. Since the computed
-// index is based on it, it should not make a difference here.
-extension ChunkedByCount: Hashable where Base: Hashable {
-  @inlinable
-  public func hash(into hasher: inout Hasher) {
-    hasher.combine(base)
-    hasher.combine(chunkCount)
-  }
-}
 extension ChunkedByCount.Index: Hashable where Base.Index: Hashable {}
 
 // Lazy conditional conformance.

Sources/Algorithms/Combinations.swift

@@ -181,8 +181,6 @@ extension Combinations: Sequence {
 }
 
 extension Combinations: LazySequenceProtocol where Base: LazySequenceProtocol {}
-extension Combinations: Equatable where Base: Equatable {}
-extension Combinations: Hashable where Base: Hashable {}
 
 //===----------------------------------------------------------------------===//
 // combinations(ofCount:)

Sources/Algorithms/Compacted.swift

@@ -179,48 +179,3 @@ extension CompactedCollection: LazySequenceProtocol
   where Base: LazySequenceProtocol {}
 extension CompactedCollection: LazyCollectionProtocol
   where Base: LazyCollectionProtocol {}
-
-
-// Hashable and Equatable conformance are based on each non-nil
-// element on base collection.
-extension CompactedSequence: Equatable
-  where Base.Element: Equatable {
-
-  @inlinable
-  public static func ==(lhs: CompactedSequence,
-                        rhs: CompactedSequence) -> Bool {
-    lhs.elementsEqual(rhs)
-  }
-}
-
-extension CompactedSequence: Hashable
-  where Element: Hashable {
-
-  @inlinable
-  public func hash(into hasher: inout Hasher) {
-    for element in self {
-      hasher.combine(element)
-    }
-  }
-}
-
-extension CompactedCollection: Equatable
-  where Base.Element: Equatable {
-
-  @inlinable
-  public static func ==(lhs: CompactedCollection,
-                        rhs: CompactedCollection) -> Bool {
-    lhs.elementsEqual(rhs)
-  }
-}
-
-extension CompactedCollection: Hashable
-  where Element: Hashable {
-
-  @inlinable
-  public func hash(into hasher: inout Hasher) {
-    for element in self {
-      hasher.combine(element)
-    }
-  }
-}

Sources/Algorithms/Cycle.swift

@@ -163,9 +163,6 @@ extension FiniteCycle: BidirectionalCollection
 extension FiniteCycle: RandomAccessCollection
   where Base: RandomAccessCollection {}
 
-extension FiniteCycle: Equatable where Base: Equatable {}
-extension FiniteCycle: Hashable where Base: Hashable {}
-
 //===----------------------------------------------------------------------===//
 // cycled()
 //===----------------------------------------------------------------------===//

Sources/Algorithms/Indexed.swift

@@ -72,8 +72,6 @@ extension Indexed: BidirectionalCollection where Base: BidirectionalCollection {
 extension Indexed: RandomAccessCollection where Base: RandomAccessCollection {}
 extension Indexed: LazySequenceProtocol where Base: LazySequenceProtocol {}
 extension Indexed: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
-extension Indexed: Equatable where Base: Equatable {}
-extension Indexed: Hashable where Base: Hashable {}
 
 //===----------------------------------------------------------------------===//
 // indexed()

Sources/Algorithms/Product.swift

@@ -438,8 +438,6 @@ extension Product2: RandomAccessCollection
   where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
 
 extension Product2.Index: Hashable where Base1.Index: Hashable, Base2.Index: Hashable {}
-extension Product2: Equatable where Base1: Equatable, Base2: Equatable {}
-extension Product2: Hashable where Base1: Hashable, Base2: Hashable {}
 
 //===----------------------------------------------------------------------===//
 // product(_:_:)

Sources/Algorithms/Stride.swift

@@ -269,22 +269,4 @@ extension StrideCollection: BidirectionalCollection
 }
 
 extension StrideCollection: RandomAccessCollection where Base: RandomAccessCollection {}
-
-extension StrideCollection: Equatable where Base.Element: Equatable {
-  @inlinable
-  public static func == (lhs: StrideCollection, rhs: StrideCollection) -> Bool {
-    lhs.elementsEqual(rhs, by: ==)
-  }
-}
-
-extension StrideCollection: Hashable where Base.Element: Hashable {
-  @inlinable
-  public func hash(into hasher: inout Hasher) {
-    hasher.combine(stride)
-    for element in self {
-      hasher.combine(element)
-    }
-  }
-}
-
 extension StrideCollection.Index: Hashable where Base.Index: Hashable {}

Sources/Algorithms/Windows.swift

@@ -350,6 +350,4 @@ extension Windows: BidirectionalCollection where Base: BidirectionalCollection {
 extension Windows: LazySequenceProtocol where Base: LazySequenceProtocol {}
 extension Windows: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
 extension Windows: RandomAccessCollection where Base: RandomAccessCollection {}
-extension Windows: Equatable where Base: Equatable {}
-extension Windows: Hashable where Base: Hashable, Base.Index: Hashable {}
 extension Windows.Index: Hashable where Base.Index: Hashable {}