如何让关联类型为可选协议类型的Enum遵循Hashable协议？

背景 #

我定义了一个Enum，其中某个Case的关联类型是可选协议类型。添加这个新的关联类型后，出现了以下编译错误：

编译错误 #1： 类型'MyEnum'不符合协议'Equatable'
编译错误 #2： 类型'MyEnum'不符合协议'Hashable'

代码 #

protocol Component { ... }

enum MyEnum: Hashable, Identifiable {
    var id: Int { hashValue }

    case myCase1
    case myCase2(value: Int? = nil)
    case myCase3(component: (any Component)? = nil) // 添加该Case后代码报错
}

问题 #

如何解决上述编译错误，让枚举Case支持以可选协议类型作为关联类型？

原因分析 #

Swift无法自动为包含**存在类型（any Protocol）**的枚举生成Equatable和Hashable实现——因为Component协议本身未遵守Equatable/Hashable，编译器无法判断两个any Component实例是否相等，也无法生成对应的哈希值。

解决方案 #

根据Component协议的实际使用场景，可选择以下两种方案：

方案1：让Component协议继承Equatable和Hashable

如果所有Component的实现类型都能遵守Equatable和Hashable，直接修改协议定义即可：

protocol Component: Equatable, Hashable { ... }

enum MyEnum: Hashable, Identifiable {
    var id: Int { hashValue }

    case myCase1
    case myCase2(value: Int? = nil)
    case myCase3(component: (any Component)? = nil)
}

此时编译器会自动为MyEnum合成Equatable和Hashable的实现，因为any Component现在具备了相等判断和哈希计算的能力。

注意：如果Component包含带关联类型的方法，这种方式可能触发"Protocol can only be used as a generic constraint because it has Self or associated type requirements"错误，此时需使用方案2。

方案2：手动实现Equatable和Hashable

若无法让Component继承Equatable/Hashable（比如协议需要被不支持相等判断的类型实现），可手动为MyEnum实现这两个协议：

首先，为Component协议添加自定义的相等判断和哈希方法（如果是类协议，可利用引用相等简化实现）：

// 非类协议的情况
protocol Component {
    func isEqual(to other: any Component) -> Bool
    func hash(into hasher: inout Hasher)
}

// 类协议的情况（可默认实现）
protocol Component: AnyObject {
    // 原有协议方法...
}
extension Component {
    func isEqual(to other: any Component) -> Bool {
        self === other
    }
    func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(self))
    }
}

接着手动实现MyEnum的Equatable和Hashable方法：

enum MyEnum: Hashable, Identifiable {
    var id: Int { hashValue }

    case myCase1
    case myCase2(value: Int? = nil)
    case myCase3(component: (any Component)? = nil)

    // 实现Equatable
    static func == (lhs: MyEnum, rhs: MyEnum) -> Bool {
        switch (lhs, rhs) {
        case (.myCase1, .myCase1):
            return true
        case let (.myCase2(lVal), .myCase2(rVal)):
            return lVal == rVal
        case let (.myCase3(lComp), .myCase3(rComp)):
            switch (lComp, rComp) {
            case (nil, nil):
                return true
            case let (l?, r?):
                return l.isEqual(to: r)
            default:
                return false
            }
        default:
            return false
        }
    }

    // 实现Hashable
    func hash(into hasher: inout Hasher) {
        switch self {
        case .myCase1:
            hasher.combine(0) // 用唯一整数区分不同枚举case
        case let .myCase2(value):
            hasher.combine(1)
            hasher.combine(value)
        case let .myCase3(component):
            hasher.combine(2)
            if let component = component {
                component.hash(into: &hasher)
            } else {
                hasher.combine(nil as Any?)
            }
        }
    }
}

这种方式完全由开发者控制相等判断和哈希逻辑，适配各种复杂场景。

内容的提问来源于stack exchange，提问作者christophriepe