Merge pull request #27 from ole/conditional-conformance

Conditional conformance for Equatable (Swift 4.1+) and Hashable (Swift 4.2+)

Author: ole

Sources/SortedArray.swift

@@ -19,7 +19,7 @@ public struct SortedArray<Element> {
     }
 
     /// Initializes the array with a sequence of unsorted elements and a comparison predicate.
-    public init<S: Sequence>(unsorted: S, areInIncreasingOrder: @escaping Comparator<Element>) where S.Iterator.Element == Element {
+    public init<S: Sequence>(unsorted: S, areInIncreasingOrder: @escaping Comparator<Element>) where S.Element == Element {
         let sorted = unsorted.sorted(by: areInIncreasingOrder)
         self._elements = sorted
         self.areInIncreasingOrder = areInIncreasingOrder
@@ -30,7 +30,7 @@ public struct SortedArray<Element> {
     /// This is faster than `init(unsorted:areInIncreasingOrder:)` because the elements don't have to sorted again.
     ///
     /// - Precondition: `sorted` is sorted according to the given comparison predicate. If you violate this condition, the behavior is undefined.
-    public init<S: Sequence>(sorted: S, areInIncreasingOrder: @escaping Comparator<Element>) where S.Iterator.Element == Element {
+    public init<S: Sequence>(sorted: S, areInIncreasingOrder: @escaping Comparator<Element>) where S.Element == Element {
         self._elements = Array(sorted)
         self.areInIncreasingOrder = areInIncreasingOrder
     }
@@ -55,7 +55,7 @@ public struct SortedArray<Element> {
     /// we only need to re-sort once.
     ///
     /// - Complexity: O(_n * log(n)_) where _n_ is the size of the resulting array.
-    public mutating func insert<S: Sequence>(contentsOf newElements: S) where S.Iterator.Element == Element {
+    public mutating func insert<S: Sequence>(contentsOf newElements: S) where S.Element == Element {
         _elements.append(contentsOf: newElements)
         _elements.sort(by: areInIncreasingOrder)
     }
@@ -68,7 +68,7 @@ extension SortedArray where Element: Comparable {
     }
 
     /// Initializes the array with a sequence of unsorted elements. Uses `<` as the comparison predicate.
-    public init<S: Sequence>(unsorted: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(unsorted: S) where S.Element == Element {
         self.init(unsorted: unsorted, areInIncreasingOrder: <)
     }
 
@@ -77,7 +77,7 @@ extension SortedArray where Element: Comparable {
     /// This is faster than `init(unsorted:)` because the elements don't have to sorted again.
     ///
     /// - Precondition: `sorted` is sorted according to the `<` predicate. If you violate this condition, the behavior is undefined.
-    public init<S: Sequence>(sorted: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(sorted: S) where S.Element == Element {
         self.init(sorted: sorted, areInIncreasingOrder: <)
     }
 }
@@ -164,25 +164,25 @@ extension SortedArray {
     // swift(4.1.50): Swift 4.2 compiler in Swift 4 mode
     // swift(4.2): Swift 4.2 compiler
     #if !swift(>=4.1.50)
-    /// Removes the elements in the specified subrange from the array.
-    ///
-    /// - Parameter bounds: The range of the array to be removed. The
-    ///   bounds of the range must be valid indices of the array.
-    ///
-    /// - Complexity: O(_n_), where _n_ is the length of the array.
-    public mutating func removeSubrange(_ bounds: CountableRange<Int>) {
-        _elements.removeSubrange(bounds)
-    }
+        /// Removes the elements in the specified subrange from the array.
+        ///
+        /// - Parameter bounds: The range of the array to be removed. The
+        ///   bounds of the range must be valid indices of the array.
+        ///
+        /// - Complexity: O(_n_), where _n_ is the length of the array.
+        public mutating func removeSubrange(_ bounds: CountableRange<Int>) {
+            _elements.removeSubrange(bounds)
+        }
 
-    /// Removes the elements in the specified subrange from the array.
-    ///
-    /// - Parameter bounds: The range of the array to be removed. The
-    ///   bounds of the range must be valid indices of the array.
-    ///
-    /// - Complexity: O(_n_), where _n_ is the length of the array.
-    public mutating func removeSubrange(_ bounds: CountableClosedRange<Int>) {
-        _elements.removeSubrange(bounds)
-    }
+        /// Removes the elements in the specified subrange from the array.
+        ///
+        /// - Parameter bounds: The range of the array to be removed. The
+        ///   bounds of the range must be valid indices of the array.
+        ///
+        /// - Complexity: O(_n_), where _n_ is the length of the array.
+        public mutating func removeSubrange(_ bounds: CountableClosedRange<Int>) {
+            _elements.removeSubrange(bounds)
+        }
     #endif
 
     /// Removes the specified number of elements from the beginning of the
@@ -416,10 +416,27 @@ extension SortedArray {
     }
 }
 
-public func ==<Element: Equatable> (lhs: SortedArray<Element>, rhs: SortedArray<Element>) -> Bool {
-    return lhs._elements == rhs._elements
-}
+#if swift(>=4.1)
+    extension SortedArray: Equatable where Element: Equatable {
+        public static func == (lhs: SortedArray<Element>, rhs: SortedArray<Element>) -> Bool {
+            // Ignore the comparator function for Equatable
+            return lhs._elements == rhs._elements
+        }
+    }
+#else
+    public func ==<Element: Equatable> (lhs: SortedArray<Element>, rhs: SortedArray<Element>) -> Bool {
+        return lhs._elements == rhs._elements
+    }
 
-public func !=<Element: Equatable> (lhs: SortedArray<Element>, rhs: SortedArray<Element>) -> Bool {
-    return lhs._elements != rhs._elements
-}
+    public func !=<Element: Equatable> (lhs: SortedArray<Element>, rhs: SortedArray<Element>) -> Bool {
+        return lhs._elements != rhs._elements
+    }
+#endif
+
+#if swift(>=4.1.50)
+    extension SortedArray: Hashable where Element: Hashable {
+        public func hash(into hasher: inout Hasher) {
+            hasher.combine(_elements)
+        }
+    }
+#endif

Tests/UnitTests/SortedArrayTests.swift

@@ -332,6 +332,24 @@ class SortedArrayTests: XCTestCase {
         assertElementsEqual(sut, [1,2])
     }
 
+    func testIsEquatableInSwift4_1AndHigher() {
+        #if swift(>=4.1)
+            let array1 = SortedArray(unsorted: [3,2,1])
+            let array2 = SortedArray(unsorted: 1...3)
+            XCTAssertEqual(array1, array2)
+        #endif
+    }
+
+    func testComparatorFunctionIsNotRelevantForEquatable() {
+        #if swift(>=4.1)
+            let array1 = SortedArray(unsorted: [1,1,1], areInIncreasingOrder: <)
+            let array2 = SortedArray(unsorted: [1,1,1], areInIncreasingOrder: >)
+            let array3 = SortedArray(unsorted: [3,2,1,4])
+            XCTAssertEqual(array1, array2)
+            XCTAssertNotEqual(array1, array3)
+        #endif
+    }
+
     func testImplementsEqual() {
         let sut = SortedArray(unsorted: [3,2,1])
         XCTAssertTrue(sut == SortedArray(unsorted: 1...3))
@@ -341,6 +359,16 @@ class SortedArrayTests: XCTestCase {
         let sut = SortedArray(unsorted: 1...3)
         XCTAssertTrue(sut != SortedArray(unsorted: 1...4))
     }
+
+    func testIsHashableInSwift4_2AndHigher() {
+        #if swift(>=4.1.50)
+            let array1 = SortedArray(unsorted: [3,2,1])
+            let array2 = SortedArray(unsorted: 1...3)
+            let array3 = SortedArray(unsorted: [3,2,1,4])
+            XCTAssertEqual(array1.hashValue, array2.hashValue)
+            XCTAssertNotEqual(array1.hashValue, array3.hashValue)
+        #endif
+    }
 }
 
 extension SortedArrayTests {
@@ -398,8 +426,11 @@ extension SortedArrayTests {
             ("testRemoveElementAtBeginningPreservesSortOrder", testRemoveElementAtBeginningPreservesSortOrder),
             ("testRemoveElementInMiddlePreservesSortOrder", testRemoveElementInMiddlePreservesSortOrder),
             ("testRemoveElementAtEndPreservesSortOrder", testRemoveElementAtEndPreservesSortOrder),
+            ("testIsEquatableInSwift4_1AndHigher", testIsEquatableInSwift4_1AndHigher),
+            ("testComparatorFunctionIsNotRelevantForEquatable", testComparatorFunctionIsNotRelevantForEquatable),
             ("testImplementsEqual", testImplementsEqual),
             ("testImplementsNotEqual", testImplementsNotEqual),
+            ("testIsHashableInSwift4_2AndHigher", testIsHashableInSwift4_2AndHigher),
         ]
     }
 }

Tests/UnitTests/TestHelpers.swift

@@ -1,8 +1,9 @@
 import XCTest
 
+// FIXME: Can be replaced with XCTAssertEqual when we drop Swift 4.0 compatibility
 func assertElementsEqual<S1, S2>(_ expression1: @autoclosure () throws -> S1, _ expression2: @autoclosure () throws -> S2, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line)
-    where S1: Sequence, S2: Sequence, S1.Iterator.Element == S2.Iterator.Element, S1.Iterator.Element: Equatable {
-
+    where S1: Sequence, S2: Sequence, S1.Element == S2.Element, S1.Element: Equatable
+{
     // This should give a better error message than using XCTAssert(try expression1().elementsEqual(expression2()), ...)
-    XCTAssertEqual(Array(try expression1()), Array(try expression2()), message, file: file, line: line)
+    try XCTAssertEqual(Array(expression1()), Array(expression2()), message, file: file, line: line)
 }