创建一个可复制的协议默认初始化器

Question

我有这个功能：

public protocol ContentType {
    associatedtype T

    static var allTypes: [T] { get }
    static func getContentType(contentTypeId: String) -> T

    var contentTypeId: String? { get }
}

public protocol Copyable: class {
    associatedtype T

    static func copy(old: T, new: T)
}

public protocol CopyableContentType: class {
    associatedtype T
    init(existingContentType: T, newContentTypeId: String?)
}

我想为一个类提供一个默认初始化器：

• 符合ContentType
• 符合Copyable

使用上面的代码，我总是在所需的 init 中做同样的事情：调用实现类的复制函数。有没有办法在保留这个初始化程序的同时省略跨类的重复代码？我想把它添加到协议扩展中：

public extension CopyableContentType where Self: ContentType & Copyable {
    typealias T = Self // So wrong but I have no idea what to put here
                       // T should be the same T as the T usud in ContentType and Copyable
    init(existingContentType: T, newContentTypeId: String?) {
        Self.copy(old: existingContentType, new: self)
    }
}

但这会导致一些错误。我不知道在 typealias 中输入什么，我不能使用相关类型。有什么方法可以提供调用复制函数的默认初始化程序？

Answer 1

我想为一个类提供一个默认初始化器：

• 符合ContentType
• 符合Copyable

我将尝试回答这个问题，假设您的意思是：

• 您想提供init(existingContentType: T, newContentTypeId: String?) 初始化器的默认实现，如ContentType 中的蓝图，if 符合ContentType 的类型也符合@ 987654326@.

让我们先看看你的Copyable 协议。这可能是由于您的问题中遗漏了细节/用例，但我在这里看不到关联类型 T 的需要，因为协议基本上是蓝图/承诺 “class 类型符合Copyable，比如TheClassType，将提供static copy(from: TheClassType, to: TheClassType) 函数的实现" — 其中符合类型(TheClassType) 只是Self。即：

protocol Copyable: class {
    static func copy(from: Self, to: Self)
}

同样适用于ContentType：这里是否需要associatedType，或者给定具体类型的ContentType 仅仅是类型本身；即Self?在继续之前，让我们去掉与您的问题无关的部分：

protocol ContentType {
    var contentTypeId: String? { get }
}

现在，在任何初始化程序之前复制（不是分配 - 我们正在处理引用类型）任何到self（例如self的值类型成员），self必须有已初始化（或分配给）。因此，为了允许为 ContentType 的 init(existingContentType: Self, newContentTypeId: String?) 初始化程序提供默认实现（在符合 Copyable 的情况下；Self 是 class 类型）——该实现旨在利用蓝图 @ copyable 的 987654350@ — 符合 ContentType 的类型必须知道在复制步骤之前初始化自身的方法。即，ContentType 需要在调用 copy(from:to) 方法之前在“复制初始化程序”中绘制一些可用于初始化 self 的初始化程序。让我们简单地蓝图init()：

protocol ContentType {
    var contentTypeId: String? { get set }
    init()
}

现在，由于ContentType 蓝图是一个contentTypeId 成员，并且复制初始化程序包含一个newContentTypeId 参数，因此提供一个默认实现的初始化程序并将contentTypeId 作为其唯一参数可能是明智的；即init(contentTypeId: String?):

extension ContentType {
    init(contentTypeId: String?) {
        self.init()
        self.contentTypeId = contentTypeId
    }
}

有了这个，我们可以提供默认实现的init(existingContentType: Self, newContentTypeId: String?)初始化器作为ContentType的受限扩展，基于Self与Copyable的一致性：

extension ContentType where Self: Copyable {
    init(existingContentType: Self, newContentTypeId: String?) {
        self.init(contentTypeId: newContentTypeId)
        Self.copy(from: existingContentType, to: self)
    }
}

示例

综合以上内容：

protocol Copyable: class {
    static func copy(from: Self, to: Self)
}

protocol ContentType {
    var contentTypeId: String? { get set }
    init()
}

extension ContentType {
    init(contentTypeId: String?) {
        self.init()
        self.contentTypeId = contentTypeId
    }
}

extension ContentType where Self: Copyable {
    init(existingContentType: Self, newContentTypeId: String?) {
        self.init(contentTypeId: newContentTypeId)
        Self.copy(from: existingContentType, to: self)
    }
}

例子：

// Copyable content type
final class Foo: ContentType, Copyable {
    // Note that since all stored properties have initial values,
    // the compiler provides a synthesized initializer for init().
    var contentTypeId: String?
    var data = 0

    static func copy(from: Foo, to: Foo) {
        to.data = from.data
    }
}

let foo1 = Foo(contentTypeId: "foo1")
foo1.data = 42
let foo2 = Foo(existingContentType: foo1, newContentTypeId: "foo2")

print(foo1.contentTypeId ?? "None", foo1.data) // foo1 42
print(foo2.contentTypeId ?? "None", foo2.data) // foo2 42


// Non-copyable content type
final class Bar: ContentType {
    var contentTypeId: String?
} // Bar has no access to
  // init(existingContentType: Self, newContentTypeId: String?)