前言

假设你需要构建如下应用：

App要求：

实时验证用户名是否有效
匹配密码
响应用户界面

你会如何实现？实现的过程会应用到哪些概念？

你需要使用 Target/Action 来获取输入框的最新值，使用计时器来实现定期检查，使用 KVO 来控制加载指示器的状态。

你还需要使用 URLSession 来进行网络请求，汇总三个输入框的结果，然后通过 KVC 来控制按钮的可用状态。

涉及到的异步接口：

Target/Action
通知中心
URLSession
KVC
定制的回调

是否觉得，这些步骤略显繁琐？
是否有更好的解决方案呢？

Combine

Combine 提供了统一的、声明式的API，可以随着时间的推移处理多个值

Combine 特性：

泛型
类型安全
组合优先
由请求驱动

核心概念：

Publishers
Subscribers
Operators

Publisher

定义值和错误如何产生
值类型
允许 Subscriber 的注册

protocol Publisher {

    associatedtype Output
    associatedtype Failure: Error
    
    func subscribe<S: Subscriber>(_ subscriber: S)
      where S.Input == Output, S.Failure == Failure
}

为 Publisher 拓展通知中心

extension NotificationCenter {
    struct Publisher: Combine.Publisher {
        typealias Output = Notification
        typealias Failure = Never
        init(center: NotificationCenter, name: Notification.Name, object: Any? = nil)
    }
}

Subscribers

接收值和完成事件
引用类型

protocol Subscriber {

    associatedtype Input
    associatedtype Failure: Error
    
    func receive(subscription: Subscription)
    func receive(_ input: Input) -> Subscribers.Demand
    func receive(completion: Subscribers.Completion<Failure>)
}

extension Subscribers {

    class Assign<Root, Input>: Subscriber, Cancellable {
        typealias Failure = Never
    }
    
    init(object: Root, keyPath: ReferenceWritableKeyPath<Root, Input>)
}

Publisher 和 Subscriber 之间的关系

Subscriber 被绑定到 Publisher 上
Publisher 发送一个订阅
Subscriber 向 Publisher 请求值
Publisher 向 Subscriber 发送值
Publisher 发送完成事件

使用 Publisher 和 Subscriber 的示例代码：

class Wizard {
    var grade: Int
}

let merlin = Wizard(grade: 5)

let graduationPublisher = NotificationCenter.Publisher(center: .default, name: .graduated, object: merlin)
let gradeSubscriber = Subscribers.Assign(object: merlin, keyPath: \.grade)

graduationPublisher.subscribe(gradeSubscriber)

以上代码由于类型不匹配，会遭遇如下错误：

看来，我们需要通过某种方式来实现类型匹配。

Operators

输入 Publisher
形容改变值的行为
订阅 Publisher (向上游)
发送结果给 Subscriber (向下游)
值类型

extension Publishers {
    struct Map<Upstream: Publisher, Output>: Publisher {
        typealias Failure = Upstream.Failure
        
        let upstream: Upstream
        let transform: (Upstream.Output) -> Output
    } 
}

现在，我们可以通过优雅的方式解决之前的问题。

let graduationPublisher = NotificationCenter.Publisher(center: .default, name: .graduated, object: merlin)
let gradeSubscriber = Subscribers.Assign(object: merlin, keyPath: \.grade)

let converter = Publishers.Map(upstream: graduationPublisher) { note in
    return note.userInfo?["NewGrade"] as? Int ?? 0
}

converter.subscribe(gradeSubscriber)

使用 Map Operator，我们完成了订阅操作。

不过，还可以把步骤简化一下：

extension Publisher {
    func map<T>(_ transform: @escaping (Output) -> T) -> Publishers.Map<Self, T> {
        return Publishers.Map(upstream: self, transform: transform)
    }
}

let cancellable = NotificationCenter.default.publisher(for: .graduated, object: merlin)
                    .map { note in
                        return note.userInfo?["NewGrade"] as? Int ?? 0
                    }
                    .assign(to: \.grade, on: merlin)

声明式 Operator API 的优点：