协议 (Protocol) 是 Swift 语言中非常强大而灵活的一个特性。而其中的关联类型就是 Swift 协议灵活的一个表现。
关联类型
@available(OSX 10.15, iOS 13, tvOS 13, watchOS 6, *)
public protocol Identifiable {
associatedtype ID: Hashable
var id: Self.ID { get }
}
我们首先来看 iOS 13 新增的 Identifiable，它声明了一个遵循 Hashable 的关联类型 ID，并且把变量 id 声明为 ID 类型。这么做的好处是实现 Identifiable 协议的类型，它的 id 变量可以是任何遵循 Hashable 协议的类型。例如：
struct MyIdType: Hashable {
let id: String
}
struct A: Identifiable {
let id: String
}
struct B: Identifiable {
let id: Int
}
struct C: Identifiable {
let id: MyIdType
}
A 、 B 和 C 都实现了 Identifiable 协议，其中 C 的 id 类型是自定义的遵循 Hashable 协议的类型。
其实，上面的代码是一个简写的形式，如果把代码写全，应该明确指定 ID 的类型：
struct A: Identifiable {
typealias ID = String
let id: String
}
struct B: Identifiable {
typealias ID = Int
let id: Int
}
struct C: Identifiable {
typealias ID = MyIdType
let id: MyIdType
}
这就是 Swift 协议的关联类型，我们也可以把有关联类型的协议看做是泛型协议。因为我们传什么类型给关联类型，他就是什么类型，与泛型一致。
约束
关联类型非常灵活，但有时候不想让它这么灵活，这时可以使用约束来限制它。
假设有一个 Apple Store，里面售卖 iPhone、Mac 和 Apple Watch。我们要求里面的产品具有相同的 logo。
接下来，我们用代码一步一步演示。
首先定义一个 AppleProduct，描述 Apple 产品，代码如下：
protocol AppleProduct {
associatedtype LogoType
var logo: LogoType { get }
}
要求每个产品有一个 logo 属性。
接下来，定义 AppleStore，描述 Apple Store，先把它写成：
protocol AppleStore {
associatedtype IphoneType: AppleProduct
associatedtype MacType: AppleProduct
associatedtype WatchType: AppleProduct
var iphones: [IphoneType] { get }
var macs: [MacType] { get }
var watches: [WatchType] { get }
}
从上面的代码上看，所有的产品都是 AppleProduct 类型，这个没错，但是每一类产品的 logo 可以是不同的。例如 IphoneType 的 logo 可以是一个字符串 Apple，MacType 的 logo 可以是一个被咬了一口的苹果图像。
那如何保证所有产品的 logo 是相同的？这时我们就必须用到约束，使用 where 关键字。把代码改造如下：
protocol AppleStore {
associatedtype IphoneType: AppleProduct
// 限制 MacType 的 LogoType 等于 IphoneType 的 LogoType
associatedtype MacType: AppleProduct where MacType.LogoType == IphoneType.LogoType
// 限制 WatchType 的 LogoType 等于 IphoneType 的 LogoType
associatedtype WatchType: AppleProduct where WatchType.LogoType == IphoneType.LogoType
var iphones: [IphoneType] { get }
var macs: [MacType] { get }
var watches: [WatchType] { get }
}
通过这两个限制，AppleStore 的三种产品的 logo 都是相同的了。
下面是 AppleStore 的具体实现：
struct Iphone: AppleProduct {
let logo: String
}
struct Mac: AppleProduct {
let logo: String
}
struct Watch: AppleProduct {
let logo: String
}
struct Store: AppleStore {
var iphones: [Iphone] = []
var macs: [Mac] = []
var watches: [Watch] = []
}
如果把 Iphone 、 Mac 和 Watch 的其中一个 logo 类型改为其他类型，Store 就无法遵循 AppleStore 协议。
声明协议类型的变量
无关联类型协议的变量
如果看过 Kickstarter 的源码，你应该会熟悉其中的 ViewModel 的写法。它的模板结构如下：
protocol AppDelegateViewModelInputs {
func applicationDidBecomeActive()
func applicationWillEnterForeground()
}
protocol AppDelegateViewModelOutputs {
var pushTokenSuccessfullyGenerated: Signal<String, Never> { get }
}
protocol AppDelegateViewModelType {
var inputs: AppDelegateViewModelInputs { get }
var outputs: AppDelegateViewModelOutputs { get }
}
final class AppDelegateViewModel: AppDelegateViewModelType, AppDelegateViewModelInputs, AppDelegateViewModelOutputs {
init() {}
private let applicationDidBecomeActiveProperty = MutableProperty(())
func applicationDidBecomeActive() {
applicationDidBecomeActiveProperty.value = ()
}
private let applicationWillEnterForegroundProperty = MutableProperty(())
func applicationWillEnterForeground() {
applicationWillEnterForegroundProperty.value = ()
}
let pushTokenSuccessfullyGenerated: Signal<String, Never>
var inputs: AppDelegateViewModelInputs { return self }
var outputs: AppDelegateViewModelOutputs { return self }
}
这里以 AppDelegate 的 ViewModel 为例，AppDelegateViewModelType 协议规定了 inputs 和 outputs 两个变量，并且类型都是协议类型，所以使用时就能直接调用协议规定的方法或者变量，例如：
viewModel.inputs.applicationDidBecomeActive()
viewModel.outputs.pushTokenSuccessfullyGenerated
.observeForUI()
.observeValues { token in
print("📲 [Push Registration] Push token successfully generated (\(token)) ✨")
}
inputs 和 outputs 两个协议类型的变量带来的好处是区分 ViewModel 数据输入和输出，让代码的意图更清晰。
现在问题来了：如果 inputs 和 outputs 的协议类型带有关联类型，该怎么办？
有关联类型协议的变量
自从阅读了 Kickstarter 的源码，我已经在项目上用上了这种结构模式，其中就遇到了需要把 inputs 和 outputs 定义为带有关联类型协议的变量的情况。
我的情况如下：有很多个页面都是从服务器加载一个数组，然后用 UITableView 显示出来，每个页面都对应一个 ViewModel。写着写着你会发现，这些 ViewModel 都非常类似，除了数组元素的类型不一样，其他都一样，所以我们可以把这些 ViewModels 抽象出一个泛型的 ViewModel，这样就可以一个 ViewModel 用在所有显示数组的界面上。
我首先尝试把 ViewModel 的代码如下：
protocol ListViewModelInputs {
func viewDidLoad()
}
protocol ListViewModelOutputs {
associatedtype ItemType
// 报错：Protocol 'ListViewModelOutputs' can only be used as a generic constraint because it has Self or associated type requirements
var itemsLoaded: Signal<[ItemType], Never> { get }
}
protocol ListViewModelType {
var inputs: ListViewModelInputs { get }
var outputs: ListViewModelOutputs { get }
}
class ListViewModel<ItemType: ListItemType>: ListViewModelInputs, ListViewModelOutputs, ListViewModelType {
init(
loadList: @escaping () -> SignalProducer<ModelsDataWrapper<ItemType>, ErrorEnvelope>
) {
let loadItems = viewDidLoadProperty.signal
.switchMap { _ in
loadList().materialize()
}
itemsLoaded = loadItems.values().map { $0.models }
}
let viewDidLoadProperty = MutableProperty(())
func viewDidLoad() {
viewDidLoadProperty.value = ()
}
var itemsLoaded: Signal<[ItemType], Never>
var inputs: ListViewModelInputs { return self }
// 报错 'ListViewModelOutputs' can only be used as a generic constraint because it has Self or associated type requirements
var outputs: ListViewModelOutputs { return self }
}
当代码写完后发现，报错了，错误的意思是说 ListViewModelOutputs 只能用作泛型约束，因为它具有 Self 或关联的类型要求。
难道无法定义有关联类型协议的变量了吗？不，还是可以定义的，在 iOS 13 以上，可以把 ListViewModelOutputs 改为：
protocol ListViewModelType {
associatedtype OutputType: ListViewModelOutputs
var inputs: ListViewModelInputs { get }
var outputs: OutputType { get }
}
class ListViewModel<ItemType: ListItemType>: ListViewModelInputs, ListViewModelOutputs, ListViewModelType {
var outputs: some ListViewModelOutputs { return self }
}
ListViewModelType 的 outputs 使用了关联按类型， ListViewModel 的 outputs 使用了 some 关键字，改成这样就不会报错了。
some 是 Swift 5.1 新增的特性，想要具体了解 some，可以查看之前写的文章 Swift 5.1 新特性
，搜索 模糊的结果类型 (Opaque Result Types)。
虽然报错的问题解决了，但是 Kickstarter 的这种 ViewModel 结构模式就无法使用了。例如有一个 ViewModel：
let taxViewModel = ListViewModel<Tax>(loadList: AppEnvironment.current.apiService.loadTaxes)
问题在于 taxViewModel.outputs.itemsLoaded 的类型是 Signal<[(some TestListViewModelOutputs).ItemType], Never>，而不是我们想要的 Signal<[Tax], Never>。
所以我最后不得不把相关的 protocol 去掉，直接定义 class：
class ListViewModel<ItemType: ListItemType> {
init(
loadList: @escaping () -> SignalProducer<ModelsDataWrapper<ItemType>, ErrorEnvelope>
) {
let loadItems = viewDidLoadProperty.signal
.switchMap { _ in
loadList().materialize()
}
itemsLoaded = loadItems.values().map { $0.models }
}
let viewDidLoadProperty = MutableProperty(())
func viewDidLoad() {
viewDidLoadProperty.value = ()
}
var itemsLoaded: Signal<[ItemType], Never>
var inputs: ListViewModel { return self }
var outputs: ListViewModel { return self }
}
这里的 inputs 和 outputs 主要是要为了 ViewModel 的风格保持一致，并不能严格区分输入和输出。
思考
对于上面 taxViewModel 的例子：
let taxViewModel = ListViewModel<Tax>(loadList: AppEnvironment.current.apiService.loadTaxes)
taxViewModel.outputs.itemsLoaded 的类型是 Signal<[(some TestListViewModelOutputs).ItemType], Never>，而不是我们想要的 Signal<[Tax], Never>。
我认为编译器应该把 taxViewModel.outputs.itemsLoaded 推断成 Signal<[Tax], Never> 类型。因为 ListViewModel<Tax> 已经明确 ItemType 是 Tax 类型，也就意味着 ListViewModelOutputs 协议规定的 var itemsLoaded: Signal<[ItemType], Never> 具体类型是 Signal<[Tax], Never>，所以 taxViewModel.outputs.itemsLoaded 应该是 Signal<[Tax], Never> 类型。
想及时看到我的新文章的，可以关注我。同时也欢迎加入我管理的Swift开发群：536353151。
