是否可以在 Swift 中创建异构集合？

Question

考虑这个例子：

protocol Observable: Hashable {
    // ...
}

struct People: Observable {
    var name: String
    var age: Double

    var hashValue: Int {
        // ...
    }

    static func ==(lhs: People, rhs: People) -> Bool {
        // ,,,
    }
}

struct Color: Observable {
    var red: Double, green: Double, blue: Double

    var hashValue: Int {
        // ...
    }

    static func ==(lhs: Color, rhs: Color) -> Bool {
        // ...
    }
}

var observers: Set<Observable> = [] // Not allowed by the compiler

People 和 Color 都符合Observable 协议，它也继承自Hashable 协议。我想将这些存储在observers 集合中。

using 'Observable' as a concrete type conforming to protocol 
'Hashable' is not supported

是否可以在 Swift 中做异构 Set？

Answer 1

有办法让它成为可能。（受 Apple 实施的启发）

在开始之前，这是我们想要构建的。

protocol Observer: Hashable {
    associatedtype Sender: Observable

    func valueDidChangeInSender(_ sender: Sender, keypath: String, newValue: Any)
}

这个问题的根源是使用Self 强制数组是同构的。你可以在这里看到它：

最重要的变化是它阻止协议作为一种类型使用。

这让我们做不到：

var observers: [Observer] = [] // Observer is not usable as a type.

因此，我们需要另一种方法来使其工作。

我们不这样做

var observers: [AnyHashable] = []

因为AnyHashable 不会约束对象符合Observer 协议。相反，我们可以像这样将Observer 对象包装在AnyObserver 包装器中：

var observers: [AnyObserver] = []
observers.append(AnyObserver(yourObject))

这将确保AnyObserver struct 的值符合Observer 协议。

根据 WWDC 2015: Protocol-Oriented Programming in Swift，我们可以使用 isEqual(_:) 方法建立一个桥梁，以便我们可以比较两个 Any。这样对象就不必遵守Equatable 协议。

protocol AnyObserverBox {
    var hashValue: Int { get }
    var base: Any { get }

    func unbox<T: Hashable>() -> T

    func isEqual(to other: AnyObserverBox) -> Bool
}

之后，我们制作符合AnyObserverBox的框。

struct HashableBox<Base: Hashable>: AnyObserverBox {
    let _base: Base

    init(_ base: Base) {
        _base = base
    }

    var base: Any {
        return _base
    }

    var hashValue: Int {
        return _base.hashValue
    }

    func unbox<T: Hashable>() -> T {
        return (self as AnyObserverBox as! HashableBox<T>)._base
    }

    func isEqual(to other: AnyObserverBox) -> Bool {
        return _base == other.unbox()
    }
}

此框包含我们稍后将创建的AnyObserver 的实际值。

最后我们制作了 AnyObserver。

struct AnyObserver {
    private var box: AnyObserverBox

    public var base: Any {
        return box.base
    }

    public init<T>(_ base: T) where T: Observer {
        box = HashableBox<T>(base)
    }
}

extension AnyObserver: Hashable {
    static func ==(lhs: AnyObserver, rhs: AnyObserver) -> Bool {
        // Hey! We can do a comparison without Equatable protocol.
        return lhs.box.isEqual(to: rhs.box)
    }

    var hashValue: Int {
        return box.hashValue
    }
}

有了所有这些，我们可以做到：

var observers: [AnyObserver] = []
observers.append(AnyObserver(yourObject))

Answer 2

实际上，您不能声明 Observable 类型的 Set（甚至是数组），这是因为 Observable 在某种程度上代表了一个通用协议：

Observable -> Hashable -> Equatable：

其中包含：

public static func ==(lhs: Self, rhs: Self) -> Bool

这就是无法以异构方式使用它的原因。此外，您不能声明 existential 类型：

var object: Observable?
// error: protocol 'Observable' can only be used as a generic constraint
// because it has Self or associated type requirements

如果您想知道这个约束的原因是什么，我认为比较两个People 或两个Color 是合乎逻辑的，但不比较People 和Color。

那么，我们能做些什么呢？

作为一种解决方法，您可以让您的集合成为一组AnyHashable 结构（正如评论中提到的@Leo）：

AnyHashable 类型转发相等比较和散列 对底层可哈希值的操作，隐藏其特定的 底层类型。

如下：

let people = People(name: "name", age: 101)
let color = Color(red: 101, green: 101, blue: 101)

var observers: Set<AnyHashable> = []

observers.insert(people)
observers.insert(color)

for (index, element) in observers.enumerated() {
    if element is People {
        print("\(index): people")
    }
}

这是合法的。