有没有办法将 `Self` 限制为泛型类型？

Question

https://www.raywenderlich.com/148448/introducing-protocol-oriented-programming

protocol Bird {
    var name: String { get }
    var canFly: Bool { get }
    func doSomething()
}

protocol Flyable {
    var airspeedVelocity: Double { get }
}

extension Bird {
    // Flyable birds can fly!
    var canFly: Bool { return self is Flyable }
    func doSomething() {
        print("default Bird: \(name)")
    }
}

class FlappyBird: Bird, Flyable {
    let name: String
    let canFly = true
    var airspeedVelocity: Double = 5.0

    init(name: String) {
        self.name = name
    }
}

class Penguin: Bird {
    let name: String
    let canFly = false

    init(name: String) {
        self.name = name
    }
}

class Owl<T> : Bird {
    let name: String
    let power: T

    init(name: String, power: T) {
        self.name = name
        self.power = power
    }
}

extension Bird where Self: FlappyBird {
    func doSomething() {
        print("FlappyBird: \(name)")
    }
}

extension Bird where Self: Owl<String> {
    func doSomething() {
        print("Owl<String>: \(name)")
    }
}

    let fb = FlappyBird(name:"PAK")
    let penguin = Penguin(name:"Mr. Pickle")
    let nightOwl = Owl<String>(name:"Night Owl", power:"Who")
    let dayOwl = Owl<Int>(name:"Day Owl", power: 50)

    let birds: [Bird] = [fb, penguin, nightOwl, dayOwl]

    birdloop: for bird in birds {
        bird.doSomething()
    }

我得到的输出是：

FlappyBird: PAK
default Bird: Mr. Pickle
default Bird: Night Owl
default Bird: Day Owl

第一个结果按预期工作，因为

extension Bird where Self: FlappyBird {
    func doSomething() {
        print("FlappyBird: \(name)")
    }
}

第二个结果按预期工作，因为它调用了默认协议扩展：

extension Bird {
        // Flyable birds can fly!
        var canFly: Bool { return self is Flyable }
        func doSomething() {
            print("default Bird: \(name)")
        }
    }

我希望打印的第三个结果

Owl<String>: Night Owl

因为nightOwl 是Owl<String> 类型。但它调用了默认的协议扩展：

default Bird: Night Owl

有什么原因吗

extension Bird where Self: FlappyBird {
  func doSomething() {
    print("default Bird: \(name)")
  }
}

被 FlappyBird 类型调用，但是

extension Bird where Self: Owl<String> {
  func doSomething() {
    print("Owl<String>: \(name)")
  }
}

Owl<String> 类型是否不调用？

Answer 1

对于泛型类型Owl<T>，您可以拥有约束where Self: Owl<String>，但它仅适用于具体类型信息可用的上下文。

为了弄清楚发生了什么，请考虑一下：

let nightOwl = Owl<String>(name: "Night Owl", power: "Who")
nightOwl.doSomething() // prints "Owl<String>: Night Owl"

与此相反：

let nightOwl: Bird = Owl<String>(name: "Night Owl", power: "Who")
nightOwl.doSomething() // prints "default Bird: Night Owl"

当 Swift 为 Owl<T> 和 FlappyBird 类型创建协议见证表时，它必须为每个类型采取不同的行为，因为 Owl 是通用的。如果它没有具体的类型信息，即调用站点的Owl<String>，它必须使用Owl<T> 的默认实现。当您将猫头鹰插入[Bird] 类型的数组时，就会发生这种类型信息的“丢失”。

在FlappyBird 的情况下，由于只有一种可能的实现（因为它不是通用的），因此编译器会生成一个带有“预期”方法引用的见证表，即print("FlappyBird: \(name)")。由于FlappyBird 不是通用的，它的见证表不需要对doSomething() 的无约束默认实现的任何引用，因此即使在缺少具体类型信息的情况下也可以正确调用受限实现。

为了明确编译器“需要”具有泛型类型的回退行为，您可以从 Owl<T> 中删除 Bird 一致性并尝试仅依赖受约束的默认实现。这将导致编译错误，该错误与 Swift 一样具有高度误导性。

“猫头鹰”类型的值没有成员“doSomething”

基本上，似乎无法构建见证表，因为它需要存在适用于 Owl 上的所有类型 T 的实现。

参考文献

1. https://forums.swift.org/t/swifts-method-dispatch/7228
2. https://developer.apple.com/videos/play/wwdc2016/416/

Answer 2

@AllenHumphreys answer here 是对原因部分的一个很好的解释。

至于修复部分，将doSomething() 实现为通用Owl 为：

class Owl<T> : Bird {
    //...
    func doSomething() {
        print("Owl<\(type(of: power))>: \(name)")
    }
}

现在你在extension Bird where Self: Owl<String> 中不再需要doSomething()