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
}

ABC 都实现了 Identifiable 协议,其中 Cid 类型是自定义的遵循 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 可以是一个字符串 AppleMacType 的 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] = []
}

如果把 IphoneMacWatch 的其中一个 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 协议规定了 inputsoutputs 两个变量,并且类型都是协议类型,所以使用时就能直接调用协议规定的方法或者变量,例如:

viewModel.inputs.applicationDidBecomeActive()
viewModel.outputs.pushTokenSuccessfullyGenerated
    .observeForUI()
    .observeValues { token in
        print("📲 [Push Registration] Push token successfully generated (\(token)) ✨")
    }

inputsoutputs 两个协议类型的变量带来的好处是区分 ViewModel 数据输入和输出,让代码的意图更清晰。

现在问题来了:如果 inputsoutputs 的协议类型带有关联类型,该怎么办?

有关联类型协议的变量

自从阅读了 Kickstarter 的源码,我已经在项目上用上了这种结构模式,其中就遇到了需要把 inputsoutputs 定义为带有关联类型协议的变量的情况。

我的情况如下:有很多个页面都是从服务器加载一个数组,然后用 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 }
}

ListViewModelTypeoutputs 使用了关联按类型, 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 }
}

这里的 inputsoutputs 主要是要为了 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> 已经明确 ItemTypeTax 类型,也就意味着 ListViewModelOutputs 协议规定的 var itemsLoaded: Signal<[ItemType], Never> 具体类型是 Signal<[Tax], Never>,所以 taxViewModel.outputs.itemsLoaded 应该是 Signal<[Tax], Never> 类型。

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