在 《Swift 泛型协议》 中，我们探讨了如何基于类型擦除技术解决 Swift 泛型协议的存储问题，通过定义一个类型擦除包装器 AnyPrinter 解决了泛型协议 Printer 的存储问题。但是，AnyPrinter 并没有显式地引用 base 实例，因为当我们定义一个泛型类型的属性时，编译器会报错。
如果我们在 AnyPrinter 中定义一个 base 属性用于显式引用实例。当我们将 base 声明为 Printer，编译器会报错：Cannot specialize non-generic type 'Printer'；当我们将 base 声明为 Printer<T>，编译器会报错：Protocol 'Printer' can only be used as a generic constraint because it has Self or associated type requirements。如下所示。
struct AnyPrinter<U>: Printer {
typealias T = U
var base: Printer<T>
// Error: Protocol 'Printer' can only be used as a generic constraint because it has Self or associated type requirements
var base: Printer
// Error: Cannot specialize non-generic type 'Printer'
init<Base: Printer>(base : Base) where Base.T == U {
self.base = base
}
func print(val: T) {
base.print(val)
}
}
最终我们基于方法指针隐式地引用了 base 实例。如下所示。
struct AnyPrinter<U>: Printer {
typealias T = U
private let _print: (U) -> ()
init<Base: Printer>(base : Base) where Base.T == U {
_print = base.print
}
func print(val: T) {
_print(val)
}
}
本文，我们就来探讨一下，在泛型协议中，如何显式地引用 base 实例。
protocol Printer {
associatedtype T
func print(val: T)
}
中间类型
上述实现中，在 AnyPrinter 中定义了一个 base 属性，在声明其类型时，无论是声明为 Printer<T> 还是 Printer，编译器都会报错。为了解决这个问题，我们还是以那句经典名言为指导思想，实现一个包装类型作为 base 属性的类型。
这里我们需要另外定义两个类型，两者是基类和子类的关系，并且都遵循泛型协议 Printer。至于为什么定义两个类型，我们后面再解释。在 Swift 标准库实现中，经常使用 box 命名中间类型，或者说是盒子类型、包装类型，这里我们同样以 box 进行命名。
Box 基类
如下所示为 box 基类的实现，由于泛型类型 _AnyPrinterBoxBase 遵循了 Printer 泛型协议，类型参数会自动绑定至关联类型。在真正使用时，_AnyPrinterBoxBase 并不会保持抽象，它最终会被绑定到某个特定类型。
class _AnyPrinterBoxBase<E>: Printer {
typealias T = E
func print(val: E) {
fatalError()
}
}
Box 子类
如下所示为 box 子类的实现，其内部封装了一个实例 var base: Base，并且将方法传递给了实例。这个 base 实例才是 Printer 协议真正的实现者。在 _PrinterBox 类型声明的第一行中，其自动将 Base.T （Printer 协议的关联类型）绑定为 _AnyPrinterBoxBase.T （_AnyPrinterBoxBase 的类型参数） 。此时，我们也无需再在 _PrinterBox 内部通过 typealias T == xxx 的方式手动进行类型绑定。
class _PrinterBox<Base: Printer>: _AnyPrinterBoxBase<Base.T> {
var base: Base
init(_ base: Base) {
self.base = base
}
override func print(val: Base.T) {
base.print(val: val)
}
}
类型擦除
在实现了中间类型后，我们再来修改类型擦除包装器 AnyPrinter 的内部实现。具体如下所示，由于我们使用中间类型 box 对 base 进行了封装，所以这里我们需要将 AnyPrinter 中的 base 的命名修改为 _box。当我们调用 print 方法时，其内部会将 print 方法转发至 _box，而 _box 内部又会将 print 转发至 base 这个真正的实现者。
struct AnyPrinter<T>: Printer {
var _box: _AnyPrinterBoxBase<T>
init<Base: Printer>(_ base: Base) where Base.T == T {
_box = _PrinterBox(base)
}
func print(val: T) {
_box.print(val: val)
}
}
现在，我们再来看前文留下的问题：为什么中间层需要定义基类和子类两个类型。事实上一开始，我尝试只定义一个 box 类型 _PrinterBox，如下所示，但是编译器会报错：
class _PrinterBox<Base>: Printer {
typalias T = Base
var base: Base
init<Base: Printer>(_ base: Base) where Base.T == T {
self.base = base
// Error: Cannot assign value of type 'Base' to type 'Base'
}
func print(val: Base) {
}
}
这个报错看上去有点奇怪，我猜测其原因：虽然构造器通过 where Base.T == T 对 Base 类型进行了约束，但是却并没有将 Printer.T 绑定至 Base 类型。不过奇怪的是，我加了 typealias T = Base 也不管用。如果有人知道原因，可以留言告诉我。最终的解决方案是，实现了两个基类和子类两个类型，通过子类的声明对 Printer.T 进行类型绑定。
最后，我们再来简单对比一下类型擦除的两种方案。如下所示，分别是隐式引用 base 和显式引用 base。其中，Logger 才是 Printer 协议真正的实现者。
具体应用
Codable 源码大量使用了面向协议编程，为了解决泛型协议的存储，其也采用了与上述类似的类型擦除方案。如下所示分别是 Codable 中编解码的核心设计实现，里面涉及到非常多的类，本质上还是在解决泛型擦除。其中，_KeyedEncodingContainerBox 和 _KeyedDecodingContainerBox 中对于 base 的命名有所不同，这里命名成了 concrete。另外，__JSONKeyedEncodingContainer 和 __JSONKeyedDecodingContainer 虽然分别是 KeyedEncodingContainerProcotol 和 KeyedDecodingContainerProtocol 的真正实现者，但是它们内部各自将具体的编码和解码细节转交给了 __JSONEncoder 和 __JSONDecoder。
总结
事实上，曾经我也尝试阅读过 Codable 源码，当时对 Swift 类型擦除并不太了解，从而导致我根本读不懂 Codable 的源码在干什么，为什么要有这么多的类进行方法转发。如今，在了解了 Swift 类型擦除之后，Codable 的设计架构一下子就清晰了，后续有时间我们再来探讨一下 Codable 的源码实现。
总而言之，只有深入了解了 Swift 类型擦除后，我们才能领会面向协议编程的精髓以及相关设计理念。
