Swift 作为现代、高效、安全的编程语言，其背后有很多高级特性为之支撑。

『 Swift 最佳实践』系列对常用的语言特性逐个进行介绍，助力写出更简洁、更优雅的 Swift 代码，快速实现从 OC 到 Swift 的转变。

该系列内容主要包括：

Optional
Enum
Closure
Protocol
Generics
Property Wrapper
Error Handling
Advanced Collections
Pattern Matching
Metatypes(.self/.Type/.Protocol)
High Performance

ps. 本系列不是入门级语法教程，需要有一定的 Swift 基础

本文是系列文章的第五篇，介绍 Generics，通过泛型可以写出更灵活、通用性更好的代码。

Write code that works for multiple types and specify requirements for those types. — Swift Docs · Generics

Swift 通过 Type Constraints 赋以 Generics 更强大的能力，可以更加灵活的控制 Generics 具备的能力和使用场景 ?。

于此同时，因为 Generics 需要 Boxing 以及方法调用都是动态派发有一定的性能损耗。

为此，Swift 在编译时会做特化处理 (Specialization) 以优化 Generics 的性能。

Phantom Types 在 Swift 现有类型安全基础之上还可以进一步强化类型。

邂逅 Generics

在 Swift 中，可以定义泛型类型 (Generic class/struce/enum)，也可以定义泛型方法。

下面我们通过一个~~做作的~~典型的例子来逐步介绍 Swift Generics 的特性。

Generic Types

实现一个自定义的 Array (BetterArray)：

public struct BetterArray {
  var storages: [Any] = []    // ??‍?








  mutating func append(_ newEelement: Any) {
    stroages.append(newEelement)
  }

}

看起来还不错？

but，元素类型怎么是 Any❓

很不 “Swift”！

元素类型又不能写死，那该怎么办？?

这时就轮到泛型登场了：

//                       ?
public struct BetterArray<T> {
  var storages: [T] = []




  mutating func append(_ newElement: T) {
    storages.append(newElement)

  }




}

如上，为 BetterArray 添加了泛型 (T)

对泛型名 T 不是很满意，可以给它起个更有意义的名字：

//                          ?
public struct BetterArray<Element> {
  var storages: [Element] = []




  mutating func append(_ newElement: Element) {
    storages.append(newElement)

  }




}

初始化 BetterArray 时需指定泛型的具体类型，如：

//                            ?
var betterArray = BetterArray<Int>()

目前 BetterArray 的功能有点简单，给它添加一个 index(of:) 的能力，即检索某个元素的 index：

func index(of element: Element) -> Int? {
  storages.firstIndex(of: element)
}

很遗憾，编译报错 ?：

Referencing instance method 'firstIndex(of:)' on 'Collection' requires that 'Element' conform to 'Equatable'

简单讲，就是要求 BetterArray 中的元素实现 Equatable 协议。

问题不大，Generics 可以添加类型约束 (Type Constraints)。

Type Constraints

// 也可以用 where clause: 
// public struct BetterArray<Element> where Element: Equatable
//                                    ?
public struct BetterArray<Element: Equatable> {
  var storages: [Element] = []




  mutating func append(_ newElement: Element) {
    storages.append(newElement)
  }

  func index(of element: Element) -> Int? {
    storages.firstIndex(of: element)
  }
}

完美！?

but，可能会接到投诉 ?，「我只是要用 BetterArray 做些存储，并不需要调用 index(of:) 方法，凭啥要实现 Equatable ？！?」

问题大不，Type Constraints 不仅可以加在 Generics 类型定义时，也可以通过「 where clause 」加在具体方法上：

public struct BetterArray<Element> {


  // ...










  //                                                        ?

  func index(of element: Element) -> Int? where Element: Equatable {

    storages.firstIndex(of: element)


  }




}

这时，只要不调用 index(of:) 方法，任何类型都可以用 BetterArray：

struct DemoElement {}


var betterArray = BetterArray<DemoElement>()    // ✅
betterArray.append(DemoElement())               // ✅




// ❌ Instance method 'index(of:)' requires that 'DemoElement' conform to 'Equatable'
betterArray.index(of: DemoElement())

BetterArray 还需要个 remove 功能 ?：

public struct BetterArray<Element> {


  // ...










  //                                                        ?

  func index(of element: Element) -> Int? where Element: Equatable {

    storages.firstIndex(of: element)


  }







  //                                                              ?
  mutating func remove(_ nouseElement: Element) where Element: Equatable {
    storages.removeAll { $0 == nouseElement }
  }
}

如上，index(of)、remove 两个方法都要求 Element 实现 Equatable，此时可以为 BetterArray 增加一个分类，并将 Type Constraints 统一放在分类上：

public struct BetterArray<Element> { /* ... */ }


//                                      ?
extension BetterArray where Element: Equatable {
  func index(of element: Element) -> Int? {
    storages.firstIndex(of: element)


  }







  mutating func remove(_ nouseElement: Element) {
    storages.removeAll { $0 == nouseElement }
  }
}

关于 Generic Type Constraints，有三种情况：

Protocol Constraints：如上所示，要求类型实现某个协议 (where Element: Equatable)；

Class Constraints：要求类型是某个类的子类 (where Element: UIView)，如：

extension BetterArray where Element: UIView {
  func subviews(at index: Int) -> [UIView]? {
    guard index < storages.count else {
      return nil
    }





    return storages[index].subviews
  }
}

Same-type Constraints：要求类型是某个具体的类型值 (where Element == String)，如：

extension BetterArray where Element == String {
  func splice() -> Element {
    storages.reduce("") { partialResult, element in
      partialResult + element
    }

  }

}

Same-type Constraints 一般只出现在 extension 或具体某个方法上，若出现在类型定义上就没有意义了，如：

// ⚠️ Same-type requirement makes generic parameter 'T' non-generic; this is an error in Swift 6
struct BadArray<T> where T == String {}

Protocol associatedtype Constraints 也是上面 3 种情况。

总之，Type Constraints 赋以 Generics 更大的操作空间。

不加 Type Constraints 的泛型除了存储，其他基本上什么也做不了！

连实例化都做不了，因为没有init方法！

Generic Functions

BetterArray 怎么能少了「函数式」的能力呢，加个 map：

public struct BetterArray<Element> {


  //      ?
  func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] {
    try storages.map(transform)
  }
}

如上，不仅可以给类型 (Class、Struct、Enum) 加上 Generics，还可以给方法添加 Generics。

泛型方法的调用不需要显式指定对应的具体类型：

// 通过 Inferring Type，可知具体类型为 String，不需要手动指定
//
let result = betterArray.map { _ in "" }

正如在 Swift 最佳实践之 Protocol 中介绍的，从 Swift 5.7 起，对于有 Protocol Constraints 的泛型方法可以用 some 关键字改写，更简洁：
func someDemo<P: Equatable>(_ other: P) -> Bool {
  // ...


}







// Equivalent to ?




func someDeom(_ other: some Equatable) -> Bool {
  // ...
}

“深入” Generics

编译器是如何处理 Generics 的？?

根据 Swift 最佳实践之 Protocol 中相关经验看，应该不简单?

总的来说，Swift 对 Generics 的处理分 2 种情况：

运行时，对 Generics 做装箱处理 (Boxing)
编译时，对 Generics 做特化处理 (Specialization)

Boxing

所谓 Boxing，与用于处理 Protocol 作为类型 (Existential Type) 时的 Existential Container 非常类似。

简单来说，就是要对 Generics 做一次封装转换，Generics 在使用是真实类型可能千差万别，但 Generics 定义是需要有「固定的对象模型」。

所谓对象模型 (Object Model)，主要有几个职责：

指导对象实例化时属性如何存储

指导对象如何执行 allocate、copy、destroy 等基础内存操作以及获取 size、alignment 等内存信息

指导如何查找实例方法的入口地址

如上节所述，根据 Generic Type Constraints 的不同，可以分为三种情况：

No Constraints，这类泛型能做的事非常少，Boxing 只需关心 allocate、copy、destroy 等基本操作如何执行即可
Class Constraints，有基础类作为约束，除了 allocate、copy、destroy 以外，还需要通过 VWT (Value Witness Table) 存储约束类中定义的方法，以便通过 generic-types 可以调用到它们
Protocol Constraints，除了 allocate、copy、destroy 以外，还需要通过 PWT (Protocol Witness Table) 存储协议中指定的方法，以便通过 generic-types 可以调用它们

这里讨论的 Protocol 是没有 class constraint 的，对于只能由类实现的协议作为泛型约束时，其效果同上面讨论的 Class Constraints。

通过 SIL (Swift Intermediate Language) 可以大致了解 Swift 背后的实现原理。

swiftc demo.swift -O -emit-sil -o demo-sil.s

如上，通过 swiftc 命令可以生成 SIL。

其中的 -O 是对生成的 SIL 代码进行编译优化，使 SIL 更简洁高效。

后面要讲到的泛型特化 (Specialization of Generics) 也只有在 -O 优化下会发生。

总之，Generics 对性能有影响，主要体现在 2 个方面：

Boxing 处理
通过 Generics 调用的方法都是动态派发 (通过 VWT 或 PWT)

Specialization

Generics 带来的性能影响可以通过特化 (Specialization of Generics) 来优化。

所谓特化就是生成泛型的特定版本，将泛型转换为非泛型，如：

@inline(never)
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a
  a = b
  b = temp
}


var a = 1
var b = 2
swapTwoValues(&a, &b)

如上，通过 Int 型参数调用 swapTwoValues 时，编译器就会生成该方法的 Int 版本：

// specialized swapTwoValues<A>(_:_:)
sil shared [noinline] @$s4main13swapTwoValuesyyxz_xztlFSi_Tg5 : $@convention(thin) (@inout Int, @inout Int) -> () {
// %0 "a"                                         // users: %6, %4, %2
// %1 "b"                                         // users: %7, %5, %3
bb0(%0 : $*Int, %1 : $*Int):
  debug_value_addr %0 : $*Int, var, name "a", argno 1 // id: %2
  debug_value_addr %1 : $*Int, var, name "b", argno 2 // id: %3
  %4 = load %0 : $*Int                            // user: %7
  %5 = load %1 : $*Int                            // user: %6
  store %5 to %0 : $*Int                          // id: %6
  store %4 to %1 : $*Int                          // id: %7
  %8 = tuple ()                                   // user: %9
  return %8 : $()                                 // id: %9
} // end sil function '$s4main13swapTwoValuesyyxz_xztlFSi_Tg5'

那么，什么时候会进行泛型特化呢？

总的原则是在编译泛型方法时知道有哪些调用方，同时调用方的类型是可推演的。

最简单的情况就是泛型方法与调用方在同一个源文件里，一起进行编译。

另外，在编译时若开启了 Whole-Module Optimization，同一模块内部的泛型调用也可以被特化。

Phantom Types

Phantom Types 并非 Swift 特有的，属于一种通用编码技巧。

Phantom Types 没有严格的定义，一般表述是：出现在泛型参数中，但没有被真正使用。

如下代码中的 Role (例子来自 How to use phantom types in Swift)，它只出现在泛型参数中，在 Employee 实现中并未使用：

struct Employee<Role>: Equatable {
    var name: String
}

Phantom Types 有何用？

用于对类型做进一步的强化。

Employee 可能有不同的角色，如：Sales、Programmer 等，我们将其定义为空 enum：

enum Sales { }
enum Programmer { }

由于 Employee 实现了 Equatable，可以在两个实例间进行判等操作。

但判等操作明显只有在同一种角色间进行才有意义：

let john = Employee<Sales>.init(name: "John")
let sea = Employee<Programmer>.init(name: "Sea")








john == sea

正是由于 Phantom Types 在起作用，上述代码中的判等操作编译无法通过：

Cannot convert value of type 'Employee' to expected argument type 'Employee'

将 Phantom Types 定义成空 enum，使其无法被实例化，从而真正满足 Phantom Types 语义。

小问题

下面这段代码在 ~Swift 5.7 上报错，Type 'any FooProtocol' cannot conform to 'FooProtocol'：

protocol FooProtocol {}



struct Foo: FooProtocol {}











func fooFunc<T: FooProtocol>(_ x: T?) {}






func test() {


  let foo: any FooProtocol = Foo()
  fooFunc(foo)  // ❌ Type 'any FooProtocol' cannot conform to 'FooProtocol'
}

而下面 2 个版本没问题：

将 any FooProtocol –> some FooProtocol

protocol FooProtocol {}



struct Foo: FooProtocol {}











func fooFunc<T: FooProtocol>(_ x: T?) {}






func test() {


  //        ?
  let foo: some FooProtocol = Foo()
  fooFunc(foo)  // ✅

}

将泛型参数从 optional –> non-optional

protocol FooProtocol {}



struct Foo: FooProtocol {}











//                               ?
func fooFunc<T: FooProtocol>(_ x: T) {}




func test() {
  let foo: any FooProtocol = Foo()
  fooFunc(foo)  // ✅

}

why ??❓

我们先来?一个好理解的版本：

protocol FooProtocol {}



struct Foo: FooProtocol {}











func fooFunc<T: FooProtocol>(_ x: T?) {}






func test() {


  //                       ?
  let foo: (any FooProtocol)? = Foo() // ❌ Type 'any FooProtocol' cannot conform to 'FooProtocol'
  fooFunc(foo)
}

上面这段代码编译报错，原因类似于：

fooFunc(nil)  // ❌ Generic parameter 'T' could not be inferred

参数是 nil 时，泛型类型没法确定！

因此，也不能以 Optional 类型去调用泛型方法，这个要求合情合理。

泛型方法若只有一个参数，不应将其定义为 Optional，如：
func fooFunc<T: FooProtocol>(_ x: T?) {}
原因在于，永远不可能以 nil 或 Optional 变量去调用 fooFunc

在有多个参数时，可以，如：
func fooFunc2<T: FooProtocol>(_ x: T?, _ y: T) {}
fooFunc2(nil, Foo())
总之，在调用泛型方法时，相关泛型类型需要是明确的！

关键是，上面是以 non-Optional 类型 (let foo: any FooProtocol) 调用的泛型方法 (fooFunc)，为何也不行❓

如上，Swift-Evolution · 0352-implicit-open-existentials

简单讲，理论上可以，没问题，但 Apple 爸爸选择不可以！

理由是，看起来很奇怪?

好消息是，在 Swift 5.8 (Xcode 14.3) 上可以正确编译了 Swift-Evolution · 0375-opening-existential-optional

在 ~Swift 5.7 上可以通过类型擦除 (Type Erasure) 的方式解决：

protocol FooProtocol {
  func bar()
}







struct Foo: FooProtocol {
  func bar() {}
}





//       ?
struct AnyFoo: FooProtocol {
  let anyInstance: any FooProtocol

  func bar() {
    anyInstance.bar()
  }
}

func fooFunc<T: FooProtocol>(_ x: T?) {}

func test() {
  let foo: any FooProtocol = Foo()

  //        ?
  fooFunc(AnyFoo(anyInstance: foo))
}