Swift：基于协议一致性的可能性重载或路由到通用方法？

Question

在通用处理链中，我有一个处理结果的方法。如果泛型 Type 恰好符合协议，我想进行不同的处理。

我想重载基于协议一致性的方法。这种切换方法可以通过编译器（如果基于协议一致性的切换没有）。

不幸的是，当从处理链中尚未为该协议键入的方法调用编译器时，编译器从不使用更具体的重载。这目前不可能吗？

这是一个例子：

protocol MyProtocol {
    var protocolString: String { get }
}

struct SpecialResult: MyProtocol {
    let protocolString: String = "special MyProtocol"
}

func preProcess<T>(result: T) {
    // Process chain for any kind of T
    print("PreProcess: T conforms to MyProtocol: \(T.self is MyProtocol.Type)") // always prints true
    process(result: result)
}

func process<T>(result: T) where T: MyProtocol { // Doesn't matter if I use process<T: MyProtocol>
    // process specifically for MyProtocol
    print("I'm processing a \(result.protocolString) result!")
}

func process<T>(result: T) {
    // process generically for T
    print("I'm processing a result.")
    print("Process: T conforms to MyProtocol: \(T.self is MyProtocol.Type)") // always prints true
}

let result = SpecialResult()
preProcess(result: result)
process(result: result)

// PreProcess: T conforms to MyProtocol: true
// I'm processing a result.
// Process: T conforms to MyProtocol: true
// I'm processing a special MyProtocol result!

我希望它会打印两次特殊的 MyProtocol 行。

对此有任何解决方案吗？即使没有方法重载，我似乎也无法让路由工作。

我可以跳过重载并使用两个不同的方法名，在 if T.self is MyProtocol.Type 后面调用每个方法名，但编译器仍然抱怨真实情况需要符合 MyProtocol，如果是真实情况，它显然必须遵守！

我可以转换result as? MyProtocol，但随后我失去了它的底层类型，这是我在整个处理链中都需要的。我真的需要一种方法来做类似result as? T: MyProtocol 之类的事情，但我似乎找不到如何...

Answer 1

这里有一些错误。最基本的是这个结构：

T.self is MyProtocol.Type

那是错误的。你的意思是：

result is MyProtocol

或者你可以使用：

T.self is MyProtocol

（但您可能应该使用result 版本）

您使用的东西大致是“T 是 MyProtocol 的类型的子类型”，这意味着“T 是一种元类型”，这真的不是你的意思（事实上，我不太确定这是否意味着任何有用）。

所以这给了你：

func preProcess<T>(result: T) {
    // Process chain for any kind of T
    print("PreProcess: T conforms to MyProtocol: \(result is MyProtocol)") // always prints true
    process(result: result)
}

由于您想要对类型进行运行时考虑，您需要使用运行时检查（即“if”语句，而不是泛型）。我不是 100% 清楚你想从中得到什么，但我希望它是这样的：

func process<T>(result: T) {
    let resultType: String
    if let myProtocol = result as? MyProtocol {
        resultType = myProtocol.protocolString
    } else {
        resultType = ""
    }

    print("I'm processing a \(resultType) result.")
    print("Process: T conforms to MyProtocol: \(result is MyProtocol)")
}

合起来就是：

PreProcess: T conforms to MyProtocol: true
I'm processing a special MyProtocol result.
Process: T conforms to MyProtocol: true
I'm processing a special MyProtocol result.
Process: T conforms to MyProtocol: true

这就是我想你的意思。当然，你可以用一个挤在一起的?? 重写大的if 语句：

let resultType = (result as? MyProtocol)?.protocolString ?? ""

或者您可以在if 中拆分您的处理，而不是使用字符串值，或其他。

你也可以这样写（可能是你的意思）：

func process(result: MyProtocol) {
    print("I'm processing a \(result.protocolString) result!")
}

func process<T>(result: T) {
    // process generically for T
    if let result = result as? MyProtocol {
        process(result: result)
    } else {
        print("I'm processing a result.")
    }
}

我倾向于对使用这样的同名重载有点小心，因为它可能会模棱两可（我可能会命名第一个process(myProtocol:)）。它完全有效，并且非常有用（请参阅 stdlib 中编码器容器中的各种 encode 方法）。但它也可能有点令人困惑，因此应谨慎使用。

但最重要的收获是马特的回答。泛型不是动态调度。它们是在编译时根据编译时信息 100% 确定的。通常，泛型重载只能用于提高性能（支持更好的 BidirectionalCollections 算法，而不仅仅是 Collections）。它们不应该被用来改变行为。这条路很少按照您的预期工作。

Answer 2

您似乎认为这里会发生某种动态调度。它不是。这不是泛型。

泛型在编译时被解析。运行时不会基于对参数的实时检查来覆盖编译器的行为。编译器在preProcess 中所知道的只是这个东西是一个 T，它可以是任何类型。所以它选择了一般的实现。

如果你想在代码中检查这是什么类型的东西，然后沮丧地告诉编译器，好吧，你可以这样做。但运行时不会为你做这些。

Answer 3

当你写的时候：

let result = SpecialResult()
preProcess(result: result)

编译器知道result 的类型，但在func preProcess<T>(result:) T 可能是任何的东西，所以它总是会调用非专业版本process<T>(result:)。

帮助编译器保留类型信息的一种方法是添加Processor 协议：

protocol Processor {
    associatedtype T
    func description(for result: T) -> String
}

extension Processor {
    func preProcess(result: T) {
        // Process chain for any kind of T
        print("PreProcess: T conforms to MyProtocol: \(T.self is MyProtocol.Type)") // always prints true
        process(result: result)
    }

    func process(result: T) {
        // process generically for T
        print("I'm processing a \(description(for: result)).")
        print("Process: T conforms to MyProtocol: \(result is MyProtocol)") // always prints true
    }
}

这个想法是让符合类型的类型担心处理结果，这里只是描述，但实际上可以是任何东西。

现在有两种选择：

• 所有可能结果的通用类：

struct ResultProcessor<T>: Processor {
    let result: T
    
    func description(for result: T) -> String {
        if let myProtocol = result as? MyProtocol {
            return myProtocol.protocolString
        } else {
            return "result"
        }
    }
}

用法：

let result = SpecialResult()
let processor = ResultProcessor(result: result)
processor.preProcess(result: result)
processor.process(result: result)

// PreProcess: T conforms to MyProtocol: true
// I'm processing a special MyProtocol.
// Process: T conforms to MyProtocol: true
// I'm processing a special MyProtocol.
// Process: T conforms to MyProtocol: true

或者为每种已知类型的结果设置一个专门的类：

struct SpecialResultProcessor: Processor {
    let result: SpecialResult
    
    func description(for result: SpecialResult) -> String {
        "special \(result.protocolString) result"
    }
}

用法：

let specialResultProcessor = ResultProcessor(result: result)
specialResultProcessor.preProcess(result: result)
specialResultProcessor.process(result: result)

// PreProcess: T conforms to MyProtocol: true
// I'm processing a special MyProtocol.
// Process: T conforms to MyProtocol: true
// I'm processing a special MyProtocol.
// Process: T conforms to MyProtocol: true