如何在 Swift 中比较两个协议数组是否相等？

Question

我运行遇到过一种情况，我确信这种情况并不少见。我有两个符合协议的对象数组，我想检查它们是否相等。

我真正想做的是：

protocol Pattern: Equatable
{
    func isEqualTo(other: Pattern) -> Bool
}

func ==(rhs:Pattern, lhs:Pattern) -> Bool
{
    return rhs.isEqualTo(lhs)
}

extension Equatable where Self : Pattern
{
    func isEqualTo(other: Pattern) -> Bool
    {
        guard let o = other as? Self else { return false }
        return self == o
    }
}

然而，这会导致编译错误：

Error:(10, 30) protocol 'Pattern' can only be used as a generic constraint because it has Self or associated type requirements

基于 this post，我意识到我需要在我的协议中丢失 Equatable 继承并将其下推到具体的 'Pattern' 声明中。虽然我真的不明白为什么。如果我根据协议通过重载 == 定义两个对象如何相等，那么据我所知确实没有问题。我什至不需要知道实际类型或它们是类还是结构。

无论如何，这一切都很好，我现在可以比较 concretePattern.isEqualTo(otherConcretePattern) 但问题仍然是我无法再比较这些对象的数组，就像我可以将具体类型的数组与数组相等性进行比较一样依赖于重载 == 运算符。

到目前为止，我所做的最好的事情是通过扩展将 isEqualTo 方法应用到 CollectionType 上。这至少允许我比较数组。但坦率地说，这段代码很臭。

extension CollectionType where Generator.Element == Pattern
{
    func isEqualTo(patterns:[Pattern]) -> Bool {
        return self.count as? Int == patterns.count && !zip(self, patterns).contains { ![=12=].isEqualTo() }
    }
}

真的没有其他方法吗？请告诉我我遗漏了一些明显的东西。

Answer 1

Swift回答：

protocol _Pattern
{
    func _isEqualTo(_other: Any) -> Bool?
}

extension _Pattern where Self: Pattern
{
    func _isEqualTo(_other: Any) -> Bool?
    {
        return (_other as? Self).map({ self.isEqualTo([=10=]) })
    }
}

protocol Pattern: _Pattern, Equatable
{
    func isEqualTo(other: Self) -> Bool
}

extension Pattern
{
    func isEqualTo(other: _Pattern) -> Bool
    {
        return _isEqualTo(other) ?? false
    }
}

func == <T: Pattern>(rhs: T, lhs: T) -> Bool
{
    return rhs.isEqualTo(lhs)
}

这是我自己开发的模式（双关语），它非常适合此类情况。 _Pattern 是新协议扩展功能的自动实现协议，代表 Pattern.

的类型擦除版本

Answer 2

I have two arrays of objects that conform to a protocol and I want to check if they are the equal.

所以如果两个数组中的所有元素都相等并且元素都符合模式，那么你想说这两个数组是相等的。即

如果a,b,c,d都是符合Pattern的东西，你要

a == c 
a != b
a != d
b != d

let array1: [Pattern] = [a, b, c]
let array2: [Pattern] = [a, b, a]
let array3: [Pattern] = [a, d, c]

array1 == array2  // true
array1 == array3  // false

最简单的方法实际上是为两个模式数组定义相等运算符，即

protocol Pattern
{
    func isEqualTo(other: Pattern) -> Bool
}

func ==(rhs: Pattern, lhs: Pattern) -> Bool
{
    return rhs.isEqualTo(lhs)
}

func ==(lhs: [Pattern], rhs: [Pattern]) -> Bool
{
    guard lhs.count == rhs.count else { return false }
    var i1 = lhs.generate()
    var i2 = rhs.generate()
    var isEqual = true
    while let e1 = i1.next(), e2 = i2.next() where isEqual
    {
        isEqual = e1 == e2
    }
    return isEqual
}

我定义了两种符合 Pattern 的类型并尝试了各种相等比较并且都有效

struct Foo: Pattern
{
    let data: String
    init(data: String)
    {
        self.data = data
    }
    func isEqualTo(other: Pattern) -> Bool
    {
        guard let other = other as? Foo else { return false }
        return self.data == other.data
    }
}

struct Bar: Pattern
{
    let data: String
    init(data: String)
    {
        self.data = data
    }
    func isEqualTo(other: Pattern) -> Bool
    {
        guard let other = other as? Bar else { return false }
        return self.data == other.data
    }
}

let a = Foo(data: "jeremyp")
let b = Bar(data: "jeremyp")
let c = Foo(data: "jeremyp")
let d = Foo(data: "jeremy")

let comp1 = a == c // true
let comp2 = a == b // false
let comp3 = a == d // false

let array1: [Pattern] = [a, b, c]
let array2: [Pattern] = [a, b, a]
let array3: [Pattern] = [a, d, c]

let comp4 = array1 == array2 // true
let comp5 = array1 == array3 // false

如何在 Swift 中比较两个协议数组是否相等？

How to compare two arrays of protocols for equality in Swift?

arrays

protocols

heterogeneous

swift

swift2