Swift 泛型和协议扩展的奇怪行为

Question

我在协议扩展和泛型的接口上看到了一些奇怪的行为。我是 Swift 新手，所以我可能会误解，但我不明白这怎么可能是正确的行为。

首先让我们定义一个协议，并使用默认函数实现对其进行扩展：

protocol Foo {
}

extension Foo {
    static func yo() {
        print("Foo.yo")    
    }
}

现在定义几个符合要求的类型：

struct A: Foo {
}

struct B: Foo {
    static func yo() {
        print("B.yo")
    }
}

A.yo()
B.yo()

正如所料，A.yo() 使用yo 的默认实现，而B.yo() 使用B 提供的显式实现：输出为

Foo.yo
B.yo

现在让我们创建一个简单的泛型类型：

struct C<T: Foo> {
    static func what() {
        T.yo()
    }
}

C<A>.what()
C<B>.what()

C<A>.what() 打印 Foo.yo，正如预期的那样。但是C<B>.what() 也会打印出Foo.yo！

C<B> 的含义肯定只是C 的模板，用B 代替了类型参数T？然而B 的yo 版本没有被调用。

我错过了什么？我正在使用 Swift 5.2.2。

现在，事实证明，您可以通过在 Foo 的原始定义中声明 yo 来解决此问题。如果我们这样做：

protocol Foo {
    static func yo()
}

然后C<B>.what() 按我的预期工作，打印B.yo。一开始我无法理解最初的行为，但我更无法理解这将如何改变它。

在我的实际应用程序中，我无法使用此修复程序，因为我正在扩展一个预先存在的协议，其中包含一个我想专注于特定符合类型的函数。

Answer 1

泛型在编译时解析。它们不像类层次结构或协议上的方法调用那样动态调度。这种静态是他们的观点，这就是性能获胜的根源。

据我所知，Foo.yo() 和 B.yo() 是完全不相关的函数。调用Foo.yo() 会静态调度调用Foo，同样，调用B.yo() 会静态调度调用B。

然而，如果您将 B.self 向上转换为 Foo.Type，并在其上调用 yo()，则最终会静态调度调用 Foo：

(B.self as Foo.Type).yo()

要获得动态调度（实现您所追求的那种多态性），您需要将yo 定义为协议的要求。这在B.yo()（现在是协议一致性的一部分）和Foo.yo()（对于不提供自己的类型的默认实现）之间建立了关系。

protocol Foo {
//  static func yo() // uncomment this
}

extension Foo {
    static func yo() {
        print("Foo.yo")    
    }
}

struct A: Foo {
}

struct B: Foo {
    static func yo() {
        print("B.yo")
    }
}

struct C<T: Foo> {
    static func what() {
        T.yo()
    }
}
A.yo()
B.yo()
(B.self as Foo.Type).yo()
C<A>.what()
C<B>.what()

之前的结果：

Foo.yo
B.yo
Foo.yo
Foo.yo
Foo.yo

将yo 设为要求后的结果：

Foo.yo
B.yo
B.yo
Foo.yo
B.yo

Answer 2

如果没有确切情况的更多详细信息，很难针对您的确切情况提出解决方案 - 您无法提供这些吗？可以说这是预期的行为，它与编译器所做的一些优化和假设有关。

您可能想查看这篇关于 Swift 中静态与动态调度的文章：https://medium.com/@PavloShadov/https-medium-com-pavloshadov-swift-protocols-magic-of-dynamic-static-methods-dispatches-dfe0e0c85509