在 Swift 中在泛型结构上实现 Equatable 的奇怪行为

Question

import Foundation

struct NotEquable {}

struct Box<T> {
    let id: Int
    let value: T
}

extension Box: Equatable {
    static func ==<T>(lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.id == rhs.id
    }

    static func ==<T: Equatable>(lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.id == rhs.id && lhs.value == rhs.value
    }
}

infix operator ====: AdditionPrecedence
public protocol OperatorEqual {
    static func ====(lhs: Self, rhs: Self) -> Bool
}

extension Box: OperatorEqual {
    static func ====<T>(lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.id == rhs.id
    }

    static func ====<T: Equatable>(lhs: Box<T>, rhs: Box<T>) -> Bool  {
        return lhs.id == rhs.id && lhs.value == rhs.value
    }
}

public protocol MethodStyleEquatable {
    static func equal(lhs: Self, rhs: Self) -> Bool
}

extension Box: MethodStyleEquatable {
    static func equal<T>(lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.id == rhs.id
    }

    static func equal<T: Equatable>(lhs: Box<T>, rhs: Box<T>) -> Bool  {
        return lhs.id == rhs.id && lhs.value == rhs.value
    }
}

func freeEqual<T>(lhs: Box<T>, rhs: Box<T>) -> Bool {
    return lhs.id == rhs.id
}

func freeEqual<T: Equatable>(lhs: Box<T>, rhs: Box<T>) -> Bool  {
    return lhs.id == rhs.id && lhs.value == rhs.value
}

let a = Box(id: 1, value: 1)
let b = Box(id: 1, value: 2)
a == b
a ==== b
freeEqual(lhs: a, rhs: b)
Box<Int>.equal(lhs: a, rhs: b)

let c = Box(id: 1, value: NotEquable())
let d = Box(id: 1, value: NotEquable())
c == d
c ==== d
freeEqual(lhs: c, rhs: d)
Box<NotEquable>.equal(lhs: c, rhs: d)

在上面的代码片段中，有 4 种实现Equatable：默认实现、自定义操作符样式、方法样式和自由函数样式。我发现在默认或自定义情况下使用运算符样式总是调用 equal 函数的通用版本。另一方面，使用方法或自由函数风格会根据是否T符合来调用正确的版本Equatable。这是一个错误，或者我如何使通用结构Equatable正确符合。

Answer 1

您将类的泛型参数与等式函数的泛型参数混淆了。如所写，您的代码等效于：

struct Box<T1> {
    let id: Int
    let value: T1
}

extension Box: Equatable {
    static func ==<T2>(lhs: Box<T2>, rhs: Box<T2>) -> Bool {
        return lhs.id == rhs.id
    }

    static func ==<T3: Equatable>(lhs: Box<T3>, rhs: Box<T3>) -> Bool {
        return lhs.id == rhs.id && lhs.value == rhs.value
    }
}

将您的定义更改为：

extension Box : Equatable {
    static func ==(lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.id == rhs.id
    }
}

extension Box where T: Equatable {
    static func ==(lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.id == rhs.id && lhs.value == rhs.value
    }
}

它按预期工作。