异步链式编程—promise沉思录

一、promise的组成

1、task：promise要完成的任务；

2、result：处理完的数据；

3、status：状态；

4、fulfill、reject（对应catch）

5、ResolveCallback ErrorCallback promise状态的解释函数

6、resolve：

对promise当前的状态作出解释，已完成的状态立即执行回掉，未完成的状态注册回掉函数；

7、then：前一promise的回掉注册，后一promise的前导；

二、promose状态机：

fulfill、reject：状态改变函数、输入；前导；可以由内部和外部函数执行；

表面接口是task；task内部可能经过多次传递；

ResolveCallback ErrorCallback ：状态改变后的输出函数；后续；

三、promise的生命周期（以异步为例）

1、promiseA创建、执行异步task功能；

2、调用then创建中继promise结点（promiseZ），同时将then输入的（promiseX）构造器和promiseZ的（fulfill）打包（promiseA.resolve()）传递给promiseA.resolveCallbacks[]；

3、promiseA task完成，执行promiseA.fulfill，履行promiseA承若；

4、promiseA.fulfill 调用 后继函数向外传递状态；

5、resolveCallback执行，首先生成promiseX，然后将promiseZ的fulfill注册为promiseX的后继功能；

6、promiseX task完成，执行promiseX 的 fulfill，resolveCallback调用promiseZ的fulfill；

7、promiseZ的状态完成、履行承诺；调用后继的promise模块；

四、函数式编程的环境变量—模拟递归函数调用站

promise异步调用链的构建过程相当于递归调用的构建过程；

promise链的执行过程相当于递归调用的反向执行过程；

理清构造和执行的关键在于搞清楚每一个函数或block的环境变量；

尤其是block，它的环境变量可能横跨几个promise模块；

block的环境变量：

1、self函数代表的promise；

2、函数参量的输入；

3、block生成的环境变量

@discardableResult func then<U>(_ next: @escaping ((T) -> Promise<U>) ) -> Promise<U> {

return Promise<U> { fulfill, reject in

self.catch { (err) in

reject(err)

}.resolve { result in

next(result).catch { (err) in

reject(err)

}.then { (finalResult) in

fulfill(finalResult)

}

}

}

}

普通函数调用通过全局函数和函数调用栈保存环境变量；

block通过block对象保存环境变量；

四、异步编程模型

？

五、promoie （task）的功能

promiseA：起始的异步功能函数，异步完成后履行promise，调用后继功能；

promiseX：履行then输入的功能，作为promiseA的后继和promiseZ的前导；

由promise构造器（monand的flatmap中的transform）生成；

promiseZ:   负责将promiseX构造器和自身的fulfill打包，通过promiseA的resolve传递给promiseA；同时中继后面的promise；

promiseZ作为promise.then的环境变量；

六、promise构造函数、then、回掉函数管道化

@discardableResult func then<U>(_ next: @escaping ((T) -> Promise<U>) ) -> Promise<U> {

return Promise<U> { fulfill, reject in

self.catch { (err) in

reject(err)

}.resolve { result in

next(result).catch { (err) in

reject(err)

}.then { (finalResult) in

fulfill(finalResult)

}

}

}

}

七、promise、flatMap

trait Monad[M[_]] {

def unit[A](a: A): M[A]

def flatMap[A, B](fa: M[A])(f: A => M[B]): M[B]

将promise对象的构建看成一个过程，

只有transform: @escaping ((T) -> Promise<U>)执行完成，promiseZ才算构造完成；