使用泛型覆盖 Optionals 的 / 运算符会导致无限循环

Question

让我们看看下面的代码sn-p：

func / <T>(lhs: T?,rhs: T?) throws -> T? {
    switch (lhs,rhs) {
        case let (l?,r?):
            return try l/r
        default:
            return nil
    }
}

let x : Double? = 2
let y : Double? = 2

let z = try! x/y

我创建了一个需要两个可选参数的通用函数。如果我运行此代码，它会导致无限循环，因为 try l/r 使用 func / <T>(lhs: T?,rhs: T?) 来划分值。谁能解释为什么将两个非可选的 double 值相除会导致对我编写的方法的函数调用，而不是 Double 的默认 / 运算符定义？

如果我通过一个需要该类的静态 / 运算符的扩展来扩展 Double，那么一切都会像魅力一样工作：

protocol Dividable {
    static func /(lhs: Self, rhs: Self) -> Self
}

extension Double: Dividable {}

func / <T:Dividable>(lhs: T?,rhs: T?) throws -> T? {
    switch (lhs,rhs) {
        case let (l?,r?):
            return  l/r
        default:
            return nil
    }
}

let x : Double? = 2
let y : Double? = 2

let z = try! x/y

Answer 1

例如二进制算术Double 不是使用具体的Double 类型实现的，而是作为符合FloatingPoint 的类型的默认泛型实现：

• swift/stdlib/public/core/FloatingPoint.swift.gyb

在您的自定义 / 函数块内，编译器不知道类型持有者 T 符合 FloatingPoint，l/r 的重载解析将解析为方法本身（因为 @987654331 @ 实现虽然更具体，但在您的自定义实现中，更通用的非约束类型 T 无法访问）。

您可以通过将FloatingPoint 作为类型约束添加到您自己的自定义方法来解决此问题：

func /<T: FloatingPoint>(lhs: T?, rhs: T?) throws -> T? {
    switch (lhs, rhs) {
        case let (l?, r?):
            return try l/r
        default:
            return nil
    }
}

同样，整数类型的二进制算术被实现为默认泛型实现，受限于符合内部协议 _IntegerArithmetic 的类型，公共协议 IntegerArithmetic 也符合。

• swift/stdlib/public/core/IntegerArithmetic.swift.gyb

您可以使用后一种公共协议为整数类型实现自定义运算符函数的重载。

func /<T: IntegerArithmetic>(lhs: T?, rhs: T?) throws -> T? {
    switch (lhs, rhs) {
        case let (l?, r?):
            return try l/r
        default:
            return nil
    }
}

最后，您可能需要考虑为什么要抛出此函数。还请注意，在处理您想要操作的两个可选值时，有一些方法可以简化您的实现，仅在两者都不同于nil 的情况下。例如：

func /<T: FloatingPoint>(lhs: T?, rhs: T?) -> T? {
    return lhs.flatMap { l in rhs.map{ l / $0 } }
}

func /<T: IntegerArithmetic>(lhs: T?, rhs: T?) -> T? {
    return lhs.flatMap { l in rhs.map{ l / $0 } }
}

当然，如果您更喜欢语义而不是简洁，请将您的 switch 语句包装在单个 if 语句中

func /<T: FloatingPoint>(lhs: T?, rhs: T?) -> T? {
    if case let (l?, r?) = (lhs, rhs) {
        return l/r
    }
    return nil
}

func /<T: IntegerArithmetic>(lhs: T?, rhs: T?) -> T? {
    if case let (l?, r?) = (lhs, rhs) {
        return l/r
    }
    return nil
}

Answer 2

您的函数签名不会让编译器知道lhs 和rhs 的类型，除了它们是同一类型。例如，您可以这样调用您的方法：

let str1 = "Left string"
let str2 = "Right string"
let result = try? str1 / str2

这将导致无限循环，因为编译器知道的唯一方法称为/，它接受两个相同类型的参数（在本例中为String）是您声明的那个； return try l/r 会一遍又一遍地调用你的 func / <T>(lhs: T?,rhs: T?) throws -> T? 方法。

正如您在问题中提到的，您需要一个参数必须符合的协议。不幸的是there is no existing Number or Dividable protocol that would fit your needs，所以你必须自己做。

请注意，当分母为 0 时，除法会崩溃并且不会抛出错误，因此您应该能够从函数中删除 throws 关键字，使其成为：

func / <T:Dividable>(lhs: T?, rhs: T?) -> T?

编辑以进一步澄清

如果您考虑一下编译器当时知道的内容，我认为这更有意义。一旦进入函数，编译器就知道lhs 和rhs 是T 类型并且是可选的。它不知道T 是什么，也不知道它的任何属性或功能，只知道它们都是T 类型。一旦你解开这些值，你仍然只知道它们都是T 类型并且是非可选的。即使你知道T（在这种情况下）是Double，它也可能是String（根据我上面的例子）。这将要求编译器遍历每个可能的类和结构以找到支持您的方法签名的东西（在本例中为 func / (lhs: Double, rhs: Double) -> Double），它根本无法做到（在合理的时间内），并且会导致不可预测的代码.想象一下，如果您添加了这个全局方法，然后每次在现有的东西（例如Float(10) / Float(5)）上使用/，您的方法都会被调用，这会很快变得非常混乱和混乱。