Why doesn't array conform to Equatable, when its items are Equatable in Swift?

user_1448202 0
Viewed 8216

UPDATE:

As of Xcode 9.3, which includes Swift 4.1, the array equality works as expected, and the code in the original question compiles without errors.

However, please see the accepted answer, because it provides a better, more modern solution.

The original question is below:

When I try to declare an instance of a generic enum with type [Post], I get an error saying

Type '[Post]' does not conform to protocol 'Equatable'

which is nonsense, because Post conforms to Equatable and I can actually compare two [Post] instances with no compilation errors?

In the following example, I extend Post and Result<T> types with Equatable and then I do a few tests:

  1. Test that I can compare two Post types: OK
  2. Test that I can compare two [Post] types: OK
  3. Test that I can compare two Result<Post> types: OK
  4. Test that I can compare two Result<[Post]> types: ERROR
import Foundation

struct Post {
    let text: String
}
extension Post: Equatable {}
func ==(lhs: Post, rhs: Post) -> Bool {
    return lhs.text == rhs.text
}


enum Result<T: Equatable> {
    case success(result: T)
    case error
}
extension Result: Equatable {
    static func ==(lhs: Result<T>, rhs: Result<T>) -> Bool {
        switch (lhs, rhs) {
        case let (.success(lhsVal), .success(rhsVal)):
            return lhsVal == rhsVal
        case (.error, .error):
            return true
        default:
            return false
    }
}

func test() {

    // Test 1: Check Post type for equality: OK
    let post1: Post = Post(text: "post 1")
    let post2: Post = Post(text: "post 2")

    if post1 == post2 {
        print("equal posts")
    }

    // Test 2: Check [Post] type for equality: OK
    let arrayOfPosts1: [Post] = [ post1, post2 ]
    let arrayOfPosts2: [Post] = [ post1, post2 ]

    if arrayOfPosts1 == arrayOfPosts2 {
        print("equal arrays of post")
    }

    // Test 3: Check Result<Post> type for equality: OK
    let result1: Result<Post> = Result<Post>.success(result: post1)
    let result2: Result<Post> = Result<Post>.success(result: post2)

    if result1 == result2 {
        print("equal results of post")
    }

    // Test 4: Check Result<[Post]> type for equality: ERROR
    // Compiler error: "Type '[Post]' does not conform to protocol 'Equatable'"
    let arrayResult1: Result<[Post]> = Result<[Post]>.success(result: arrayOfPosts1)
    let arrayResult2: Result<[Post]> = Result<[Post]>.success(result: arrayOfPosts2)

    if arrayResult1 == arrayResult2 {
        print("equal results of array of posts")
    }
}
swift3 swift enums arrays generics
2 Answers

This issue totally sucks and still isn't fixed in Swift 4.

I worked around the issue by having a different type ArrayResult specifically for arrays of results, in addition to Result

public enum ArrayResult<T:Equatable> {

    case success(result: [T])
    case failure(error: Error)
}

extension ArrayResult: Equatable {

    public static func ==(lhs: ArrayResult<T>, rhs: ArrayResult<T>) -> Bool {
        switch (lhs) {
        case .success(let lhsResult):
            if case .success(let rhsResult) = rhs, lhsResult == rhsResult { return true }
        case .failure(let lhsError):
            // We cast associated Error to a NSError so we get Equatable behaviour
            // (Apple guarantee that Error can always be bridged to an NSError)
            if case .failure(let rhsError) = rhs, lhsError as NSError == rhsError as NSError { return true }
        }
        return false
    }
}

func test() {

    // Test 4: Check Result<[Post]> type for equality: NOW OK
    let arrayResult1: ArrayResult<Post> = ArrayResult<Post>.success(result: arrayOfPosts1)
    let arrayResult2: ArrayResult<Post> = ArrayResult<Post>.success(result: arrayOfPosts2)

    if arrayResult1 == arrayResult2 {
        print("equal results of array of posts")
    }
}
user_3343950
Related