Add conditional Equatable (for Swift 4.1+) and Hashable (4.2+) conformance

Closes #25. I initially thought we could also conform to Codable but that seems impossible because there's no way to serialize the comparator function.

Author: ole

Sources/SortedArray.swift

@@ -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),
         ]
     }
 }