Apple 官方异步编程框架：Swift Combine 简介

发布者定义了 如何描述产生的值和错误
，通过定义关联类型 Output
和 Failure
的实际类型（当发布者不产生错误时，可以使用 Never
）。由于发布者不需要实际产生值和错误，所以我们可以用值类型来定义它，也就是 Swift 里的结构体。发布者提供让订阅者注册的能力，通过实现 receive
方法。
发布者可以适配到现有的很多异步操作接口中。

官方 Cocoa 框架中 NotificationCenter
接口适配发布者的例子（
截止至 beta1 版本的 Xcode， 此 API 尚未开放
beta2 版本已支持）：

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

订阅者（Subscriber）

和发布者配对的，就是订阅者。同样的，在 Combine 框架中是一个协议：

public protocol Subscriber : CustomCombineIdentifierConvertible {

    /// 接受到的值的类型
    associatedtype Input

    /// 可能接受到的错误的类型
    associatedtype Failure : Error

    /// 告诉订阅者，它在发布者上被成功订阅，可以请求值了
    func receive(subscription: Subscription)

    /// 告诉订阅者，发布者产生值了
    func receive(_ input: Self.Input) -> Subscribers.Demand

    /// 告诉订阅者，发布者已经终止产生值了，不管是正常情况还是由于情况
    func receive(completion: Subscribers.Completion<Self.Failure>)
}

订阅者定义了 如何描述接受的值和错误
，类似的，通过定义关联类型 Input
和 Failure
。由于订阅者在接受到值之后，经常会影响和修改某些状态，所以我们使用引用类型来定义它，也就是 Swift 里的类类型。
订阅者有三个核心方法：

• 接收到订阅的消息
• 接收到产生的值的消息
• 接收到产生已经终止的消息

订阅消息(Subsciption):描述如何控制发布者到订阅者的数据流动，用于表达发布者和订阅者之间的连接。

官方的提供 Assign
的订阅者例子（可以在文档中找到更详细的定义）：

extension Subscribers {
    final public class Assign : Subscriber, Cancellable {
      
        public typealias Failure = Never

        public init(object: Root, keyPath: ReferenceWritableKeyPath)
            //...
    }
}

运算符（Operator）

当有了发布者和订阅者后，它们之间是怎么配合起来运作的呢，如下图所示：

subsribe
receive
request
receive
receive

看起来一切都配合的很美好，好像这两个概念已经可以实现我们的功能了。当你开开心心敲下这个例子的时候：

class Foo {
    var name:String
    init(name:String) {
        self.name = name
    }
}

let object = Foo(name:"Test")
let publisher = NotificationCenter.Publisher(center: .default, name: "Send", object: object)
let subsciber = Subscribers.Assign(object: object, keyPath: \.name)

publisher.subscribe(subsciber)

你会发现编译不过，因为 NotificationCenter
发布者产生的值类型是 Notification
，而订阅者需要接受 name 的 String
类型。这时候，操作符就应运而生了。

操作符是一个 桥梁
，定义一些便捷的操作，让发布者和订阅者能搭配使用，而这样就可以让发布者和订阅者的耦合程度降低，通用程度变高。而复用的发布者和订阅者可以通过一到多个操作符进行适配。

操作符定义 如何进行值的转换
。操作符是遵循 Publisher 协议的，从上游的发布者订阅值，生成新的发布者，处理后并发送给下游的订阅者。
官方提供的 Map 操作符的例子：

extension Publishers {
    public struct Map : Publisher where Upstream : Publisher {
        public typealias Failure = Upstream.Failure
        public let upstream: Upstream
        public let transform: (Upstream.Output) -> Output
        public func receive(subscriber: S) where Output == S.Input, S : Subscriber, Upstream.Failure == S.Failure
    }
}

extension Publishers.Map {
    public func map(_ transform: @escaping (Output) -> T) -> Publishers.Map
}

extension Publishers {
    public struct Zip : Publisher where A : Publisher, B : Publisher, A.Failure == B.Failure {
        public typealias Output = (A.Output, B.Output)
        public typealias Failure = A.Failure
        public let a: A
        public let b: B
        public init(_ a: A, _ b: B)
        public func receive(subscriber: S) where S : Subscriber, B.Failure == S.Failure, S.Input == (A.Output, B.Output)
    }
}

extension Publishers {
    public struct CombineLatest : Publisher where A : Publisher, B : Publisher, A.Failure == B.Failure {
        public typealias Failure = A.Failure
        public let a: A
        public let b: B
        public let transform: (A.Output, B.Output) -> Output
        public init(_ a: A, _ b: B, transform: @escaping (A.Output, B.Output) -> Output)
        public func receive(subscriber: S) where Output == S.Input, S : Subscriber, B.Failure == S.Failure
    }
}