编译器合成 (synthesize) 是十分重要的功能，它把开发者从简单重复的劳动中解放出来。在Swift 4.0 中，我们知道 Codable 可以合成相关函数，于是 Codable 的实现者在大部分情况下不需要实现相关函数。 到了 Swift 4.1，Equatable 和 Hashable 也支持了合成。触发合成的一个重要的必要非充分条件是：包含的存储属性或相关值全都是 Codable / Equatable / Hashable，编译器才有可能推导出这个类型的相关函数实现。
我们先复习一下相关概念：
如果对象相等，则这两个对象的 hash 值一定相等。
如果两个对象 hash 值相等，这两个对象不一定相等。
Swift 中 Hashable 一定是 Equatable，因为前者继承了后者。
修改
==函数的时候需要考虑是否同步修改hashValue，反之亦然。Dictionary 和 Set 的中的 Key 类型都要求是 Hashable
1. 合成 Equatable
我们以前得手写如下代码。缺点：1. 实现很冗长无聊。2. 增删改一个属性还得记得改这个函数。
struct Person: Equatable {
static func == (lhs: Person, rhs: Person) -> Bool {
return
lhs.firstName == rhs.firstName &&
lhs.lastName == rhs.lastName &&
lhs.birthDate == rhs.birthDate &&
...
}
}
现在舒服了，声明下 : Equatable即可，编译器帮你合成 == 函数的实现。
struct Person: Equatable { ... }
这样是否意味着可以无脑申明 Equatable 了呢？并不是这样。在某些属性不参与相等比较时，必须自己实现，让编译器不要合成。举个例子，假如 Person 有一个属性叫 createdTime，记录了它被创建的时间，如果我们不希望这个属性参与相等比较，就需要自己实现 == 函数。
我们回顾一下 enum 在 Swift 4.1 版本前的情况，以下三种情况哪些可以编译通过呢？
// eg1
enum SSS {
case a
case b
}
SSS.a == SSS.b
// eg2
enum KKK : String {
case a
case b
}
KKK.a == KKK.b
// eg3
enum Token {
case string(String)
case number(Int)
case lparen
case rparen
}
Token.string("123") == Token.string("456")
答案是：例子1、2能编译过，例子 3编译不过。SSS 是最简单的 enum，KKK是带有 rawType 的 enum，这两个在 Swift 4.1 之前就自动是 Equatable 和 Hashable，即便不显式声明。
例子3是带 associated value 的 enum，在 Swift 4.1 之前需要实现 Equatable，不仅要声明 :Equatable，还得自己写 == 方法，你还记得怎么写吗？，不妨不要看下面的答案，练习一下 Pattern Matching。
static func == (lhs: Token, rhs: Token) -> Bool {
switch (lhs, rhs) {
case (.string(let lhsString), .string(let rhsString)):
return lhsString == rhsString
case (.number(let lhsNumber), .number(let rhsNumber)):
return lhsNumber == rhsNumber
case (.lparen, .lparen), (.rparen, .rparen):
return true
default:
return false
}
}
在 Swift 4.1 中，例子 3 我们仅仅需要声明 :Equatable 就能让编译器帮我们合成==方法，太方便了。
2. 合成 Hashable
试想一下，上面那个带 associated value 的 enum，如何实现它的 hashValue方法呢？有可能你已经有了答案，但这里同样可以声明 :Hashable让编译器合成。
接下来我们来回顾下什么是 hash 函数。这个函数目的是：将原来对象的域映射到 Int 的值域。笔者认为 hash 函数设计的难点有两个：
- 如何将一个输入的域（对象的可取值范围），映射到一个一般来说更小的域（Int），同时又尽可能防止不同的对象得到同一个 Int，（这种情况叫“冲突”，冲突不可避免，但大规模冲突会大幅降低对象检索效率，最简单的hash函数实现是
return 1，但却是最糟糕的hash函数） - hash 函数效率非常重要，它可能会被非常频繁地调用。除了 hash 函数算法本身，我们可以设计缓存策略，特别是在不可变情况比较多的 struct 和 enum 的时候。
基于以上两点：编译器合成的 hash 函数能保证高质量，但很有可能不是最优的。因为编译器无法得到一些只有你知道的信息：比如属性的实际值域：var age: Int（不可能是负数；如果是 Person 结构，取值范围在0-200等），又比如属性之间的关系特性，而往往你可以利用这些信息设计出更优的 hash 函数。
合成 Hashable 跟 Equatable 一样，声明 :Hashable 之后，可以自己实现，来压制编译器的合成行为。
Hashable 和 Equatable 还有一些编译器不合成的情况需要特别指出：
- class 不合成，原因是继承情况下比较复杂，合成出来也不一定是你要的。
- extension 声明实现 Hashable 或 Equatable 时也不合成。
其他：标准库 Index 类型支持 Hashable
除了同样是 Swift 4.1 的新特性并且同样跟 Hashable 相关，跟本文主题没太多关系，这里增强的是：标准库将 Index 类型都实现了 Hashable。
我们知道 Swift 有个特性叫强类型的 Key Path。如果 Key Path 中用下标表达式的话，下标类型必须是 Hashable 的，Int 原本就是，而String.Index原来不是，所以下面例子中第二段的代码只在 Swift 4.1 中是合法的。
let numbers = [10, 20, 30, 40, 50]
let firstValue = \[Int].[0]
print(numbers[keyPath: firstValue]) // 10
let string = "Helloooo!"
let firstChar = \String.[string.startIndex] // valid in Swift 4.1 or later
小结
在本文中，我们探讨了：
- 合成 Hashable和 Equatable 的价值。
- 合成的局限性，需要自己书写函数的情况和注意点。
- 编译器不合成的情况。
- 标准库 Index 类型支持 Hashable，增强Key Path表达式能力。
Swift 4.1 新特性系列文章
Swift 4.1 新特性 (1) Conditional Conformance
Swift 4.1 新特性 (2) Sequence.compactMap
Swift 4.1 新特性 (3) 合成 Equatable 和 Hashable
Swift 4.1 新特性 (4) Codable的改进