Swift 协议关联类型和约束的理解

协议 (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 { 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

    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: ListViewModelInputs, ListViewModelOutputs, ListViewModelType {
    
    init(
        loadList: @escaping () -> SignalProducer, 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: 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(loadList: AppEnvironment.current.apiService.loadTaxes)

问题在于 taxViewModel.outputs.itemsLoaded 的类型是 Signal<[(some TestListViewModelOutputs).ItemType], Never>，而不是我们想要的 Signal<[Tax], Never>。

所以我最后不得不把相关的 protocol 去掉，直接定义 class：

class ListViewModel {

    init(
        loadList: @escaping () -> SignalProducer, 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(loadList: AppEnvironment.current.apiService.loadTaxes)

taxViewModel.outputs.itemsLoaded 的类型是 Signal<[(some TestListViewModelOutputs).ItemType], Never>，而不是我们想要的 Signal<[Tax], Never>。

我认为编译器应该把 taxViewModel.outputs.itemsLoaded 推断成 Signal<[Tax], Never> 类型。因为 ListViewModel 已经明确 ItemType 是 Tax 类型，也就意味着 ListViewModelOutputs 协议规定的 var itemsLoaded: Signal<[ItemType], Never> 具体类型是 Signal<[Tax], Never>，所以 taxViewModel.outputs.itemsLoaded 应该是 Signal<[Tax], Never> 类型。

想及时看到我的新文章的，可以关注我。同时也欢迎加入我管理的Swift开发群：536353151。