一个 Swift 协议要求，只能通过使用 final 类来满足

Question

我正在为 Swift 上的所有者/所有者方案建模：

class Owner<T: Ownee> {
     // ...
}

protocol Ownee {
    var owner: Owner<Self> { get }
}

然后我有一对遵循上述建模类型的教授/学生：

class Professor: Owner<Student> {
    // ...
}

class Student: Ownee {
    let professor: Professor
    var owner: Owner<Student> {  // error here (see below)
        return professor
    }

    init(professor: Professor) {
        self.professor = professor
    }
}

但是我在Student 类中对var owner 的定义出现以下错误：

协议 'Ownee' 要求 'owner' 不能满足 非最终类（'Student'），因为它在非参数中使用'Self'， 非结果型职位

我试图了解导致此错误的原因是什么，为什么将 Student 类设为 final 会修复它，以及是否有一些解决方法能够以不同的方式对此进行建模，而不会使此类成为最终类。我已经用谷歌搜索过这个错误，但到目前为止还没有找到太多。

Answer 1

如果您来到这个线程只是想寻找一种方法让子类继承一个引用其自身类型（Self 类型）的方法，一种解决方法是在子类的类型上参数化父类。例如

class Foo<T> {
    func configure(_ block: @escaping (T)->Void) { }
}

class Bar: Foo<Bar> { }

Bar().configure { $0... }

但是...您似乎也可以在协议扩展中添加一个不会被认为符合协议本身的方法。我不完全理解为什么会这样：

protocol Configurable {
    // Cannot include the method in the protocol definition
    //func configure(_ block: @escaping (Self)->Void)
}

public extension Configurable {
    func configure(_ block: @escaping (Self)->Void) { }
}

class Foo: Configurable { }

class Bar: Foo { }

Bar().configure { $0... }

如果您在协议定义本身中取消注释该方法，您将收到 Protocol 'Configurable' requirement 'configure' cannot be satisfied by a non-final class ('Foo') because it uses 'Self' in a non-parameter, non-result type position 编译错误。

Answer 2

以下语法应该支持您所追求的：

protocol Ownee {
    associatedtype Owned = Self where Owned:Ownee
    var owner: Owner<Owned> { get }
}

（使用 Swift 4 - Beta 1 测试）

Answer 3

错误是正确的。你必须让你的类最终，因为没有子类可以符合你的协议Ownee。

考虑这个子类：

class FirstGradeStudent: Student {
   // inherited from parent
   // var owner: Owner<Student> {
   //     return professor
   //  }
}

如您所见，由于他的父母，它必须实现var owner: Owner<Student>，但它应该实现var owner: Owner<FirstGradeStudent>，因为协议包含var owner: Owner<Self> { get }，在这种情况下Self将是FirstGradeStudent .

解决方法

1：给Ownee定义一个超类，Owner应该使用它：

class Owner<T: OwneeSuper> {
    // ...
}

protocol OwneeSuper {}    
protocol Ownee: OwneeSuper {
    associatedtype T: OwneeSuper
    var owner: Owner<T> { get }
}

OwneeSuper 只是克服this problem 的一种解决方法，否则我们只会使用：

protocol Ownee {
    associatedtype T: Ownee
    var owner: Owner<T> { get }
}

2.在符合Ownee的类中，必须通过定义typealias将associatedtype的抽象类型转为具体类：

class Student: Ownee {
    typealias T = Student // <<-- define the property to be Owner<Student>
    let professor: Professor
    var owner: Owner<T> { 
        return professor
    }

    init(professor: Professor) {
        self.professor = professor
    }
}

3. 子类现在可以使用您定义的类型的属性：

class FirstGradeStudent: Student {
    func checkOwnerType() {
        if self.owner is Owner<Student> { //warning: 'is' test is always true
            print("yeah!")
        }
    }
}

Answer 4

如果Student 被子类化会发生什么？所有者属性仍然是 Owner<Student>，但 Student != StudentSubclass。

通过使您的Student 类符合Ownee 协议，您必须满足协议的约定。 Ownee 协议声明 Owner 具有类型约束，因此 Owner 泛型类型是符合 Ownee 的类型（在本例中为 Student）。

如果编译器允许子类化（即允许您不将 Student 设为 final），那么 StudentSubclass 就有可能存在。这样的子类将继承Owner<Student> 类型的Owner 属性，但Student 与StudentSubclass 不同。 Ownee协议的约定已经被破坏，因此不能允许这样的子类存在。