标准库中的类型抹消
不知道大家有没有听说过Swift中的类型抹消，所谓类型抹消就是不将某实例的真实类型暴露出去，对外只暴露一个必要的类型。举个：当我们编写一个class或者struct并实现了一个协议，当我们对外提供该实例时，只想让外界知道这个东西实现了该协议，可是又不想让外界知道实现了这个协议的class或者struct是哪一个类型的，这时我们就需要用到类型抹消，其实在Swift的标准库就有这样的东西。
struct FibsIterator: IteratorProtocol {
var status = (0, 1)
mutating func next() -> Int? {
guard status.0 < 100 else { return nil }
let num = status.0
self.status = (status.1, status.0 + status.1)
return num
}
}
struct SquareIterator: IteratorProtocol {
var status = 1
mutating func next() -> Int? {
guard status < 100 else { return nil }
defer {
status = status * 2
}
return status
}
}
// fibsIterator的type: AnyIterator<Int>
let fibsIterator = AnyIterator(FibsIterator())
// squareIterator的type: AnyIterator<Int>
let squareIterator = AnyIterator(SquareIterator())
// anyIteratorArray的type: [AnyIterator<Int>]
let anyIteratorArray = [fibsIterator, squareIterator]
// fibsSequence的type: AnySequence<Int>
let fibsSequence = AnySequence { return FibsIterator() }
// 这里因为实现一个Collection协议比较麻烦就直接用数组好了
// c的type: AnyCollection<Int>
let c = AnyCollection(Array<Int>())
关于
IteratorProtocol、Sequence、Collection这里不做介绍......
在我们实现了一个斐波拉契的迭代器后，我们想让外界使用该迭代器来产生斐波拉契序列，可是我们又不想让外界知道我这个东西是是用FibsIterator这个struct来实现的。于是我们就用AnyIterator、AnySequence、AnyCollection来包装它，外界使用者只知道迭代这个东西时是产生一个Int类型的迭代器、序列或集合。这样我们就将FibsIterator的类型给隐藏了。
尝试造轮子
既然我们知道类型抹消这个小技巧，那我们就来学造轮子。首先我们就模仿标准库来实现一个抹消类型的迭代器，首先我们先按照上面的套路定义一个协议和实现两个迭代器：
protocol MyIteratorProtocol {
associatedtype Element
mutating func next() -> Self.Element?
}
struct FibsIterator: MyIteratorProtocol {
var status = (0, 1)
mutating func next() -> Int? {
guard status.0 < 100 else { return nil }
let num = status.0
self.status = (status.1, status.0 + status.1)
return num
}
}
struct SquareIterator: MyIteratorProtocol {
var status = 1
mutating func next() -> Int? {
guard status < 100 else { return nil }
defer {
status = status * 2
}
return status
}
}
然后我们来实现迭代器包装的盒子，对外只暴露迭代器next()方法放回的类型（这里以Int类型为例），而不暴露实现的迭代器类型，一开始我们可能会写出这样的代码：
class IteratorBox<I: MyIteratorProtocol> {
var iterator: I
init(_ iterator: I) {
self.iterator = iterator
}
func next() -> I.Element? {
return iterator.next()
}
}
// fibsIteratorBox的type: IteratorBox<FibsIterator>
let fibsIteratorBox = IteratorBox(FibsIterator())
// squareIteratorBox的type: IteratorBox<SquareIterator>
let squareIteratorBox = IteratorBox(SquareIterator())
// 报错！类型不同，所以Boxs需要转成[Any]
let Boxs = [fibsIteratorBox, squareIteratorBox]❌
在这里出现了两个问题：
第一个问题是我们定义的泛型I直接就暴露出去了，这样就违背了我们的初衷，我们只想要外界看到的是I.Element的类型，而不是暴露I的类型。
第二个问题是，用数组存放这些IteratorBox时，由于泛型不相同而报错。
方法一：通过属性保存迭代器方法的实现
首先我们明确知道为了防止实现MyIteratorProtocol的类型被暴露，IteratorBox的泛型应为MyIteratorProtocol的Element类型，而不是MyIteratorProtocol的类型。其次我们也必须要IteratorBox实现MyIteratorProtocol协议，确保IteratorBox包含完整的功能。
struct IteratorBox<A>: MyIteratorProtocol {
private var nextIMP: () -> A?
init<I: MyIteratorProtocol>(_ iterator: I) where I.Element == A {
var iteratorCopy = iterator // Swift中参数被隐式声明为let
self.nextIMP = { iteratorCopy.next() }
}
func next() -> A? {
return nextIMP()
}
}
// fibsIteratorBox的type: IteratorBox<Int>
let fibsIteratorBox = IteratorBox(FibsIterator())
// squareIteratorBox的type: IteratorBox<Int>
let squareIteratorBox = IteratorBox(SquareIterator())
// Boxs的type: [IteratorBox<Int>]
let Boxs = [fibsIteratorBox, squareIteratorBox]
这样的方法实现起来是非常简单方便的，也实现了标准库中同样的效果。但这样只适合方法较少的类型，因为MyIteratorProtocol每多一个方法就要多一个属性来保存，而且在init方法中也需要编写额外的代码。
当MyIteratorProtocol方法数量多时我们只能像上面那样保存实现MyIteratorProtocol的迭代器，通过迭代器来调用。但是上面造轮子处不是尝试过了吗？而且还问题多多呢...所以我们来看看接下来的方法。
方法二：利用面向对象中的继承和多态特性
首先我们还是要明确刚才提及的需求。我们实现的IteratorBox的泛型应为MyIteratorProtocol的Element类型，而为了保存实现MyIteratorProtocol的迭代器我们又要将泛型约束为实现MyIteratorProtocol的类型，这样就会造成冲突。既然一个类不能同时满足这两个类型，那我们就用两个类来实现好了。
class IteratorBox<A>: MyIteratorProtocol {
func next() -> A? {
fatalError("This method is abstract, you need to implement it!")
}
}
首先我们让IteratorBox实现MyIteratorProtocol中的所有方法，而在方法的实现里我们仅仅让它崩溃。接下来我们实现一个IteratorBoxHelper来保存迭代器，并实现协议里的方法：
class IteratorBoxHelper<I: MyIteratorProtocol> {
var iterator: I
init(_ iterator: I) {
self.iterator = iterator
}
func next() -> I.Element? {
return iterator.next()
}
}
最后我们让IteratorBoxHelper继承自IteratorBox
class IteratorBoxHelper<I: MyIteratorProtocol>: IteratorBox<I.Element> {
var iterator: I
init(_ iterator: I) {
self.iterator = iterator
}
override func next() -> I.Element? {
return iterator.next()
}
}
继承IteratorBox时我们将泛型A的类型约束为IteratorBoxHelper中I的Element的类型。
我们通过IteratorBoxHelper来包装迭代器后，将该类型声明为IteratorBox，也就所谓的向上转型（将子类类型声明为父类类型）,然后我们来调用这些迭代器，调用方法时会根据多态性的特点调用真实类型的方法。
// fibsIteratorBox的type: IteratorBox<Int>
let fibsIteratorBox: IteratorBox = IteratorBoxHelper(FibsIterator())
// squareIteratorBox的type: IteratorBox<Int>
let squareIteratorBox: IteratorBox = IteratorBoxHelper(SquareIterator())
// Boxs的type: [IteratorBox<Int>]
let Boxs = [fibsIteratorBox, squareIteratorBox]
print("调用fibsIteratorBox的next方法")
while let num = fibsIteratorBox.next() {
print(num)
}
print("调用squareIteratorBox的next方法")
while let num = squareIteratorBox.next() {
print(num)
}
包装后不再具有值语义
在这里提一点是，我们的FibsIterator和SquareIterator都是struct，具有值语义，而当我们将它赋值给另一个变量后再迭代就会进行写时复制：
var fib1 = FibsIterator()
print(fib1.next()!) // 0
print(fib1.next()!) // 1
print(fib1.next()!) // 1
var fib2 = fib1
print(fib1.next()!) // 2
print(fib1.next()!) // 3
print(fib2.next()!) // 2
print(fib2.next()!) // 3
对于方法一，虽然IteratorBox的类型和标准库中的AnyIterator同为struct，当它们两个都并不具备写时复制的特性，IteratorBox的闭包属性捕获了iteratorCopy，即使赋值给另一个变量，闭包属性也还是引用用一个iteratorCopy。
对于方法二，由于IteratorBox和IteratorBoxHelper都是class类型，那么就会变成了引用语义，给另一变量赋值时只是指针拷贝：
let fibsIteratorBox: IteratorBox = IteratorBoxHelper(FibsIterator())
print(fibsIteratorBox.next()!) // 0
print(fibsIteratorBox.next()!) // 1
print(fibsIteratorBox.next()!) // 1
let fibsBox2 = fibsIteratorBox
print(fibsIteratorBox.next()!) // 2
print(fibsIteratorBox.next()!) // 3
print(fibsBox2.next()!) // 5
print(fibsBox2.next()!) // 8
至此我们就成功模仿了Swift标准库中
AnyIterator的实现。如有错漏，请多指教。
