1、任何异步操作的参数必然是一些基本参数，加上回调函数！请仔细考虑这句话！！！
2、假如说，我们将这么一个异步操作拆分开来：接收一个参数，返回一个回调函数？请仔细思考，是否可以！！！！
一些烧脑的概念：
抽象的是一个计算过程————函数式变成精髓所在。。。@包涵卿
curried function 柯里化，
monad type 单子
functor 函子
Promises/A(http://wiki.commonjs.org/wiki/Promises/A)
what is promises(https://promisesaplus.com/)
promisesJs(https://www.promisejs.org/)
以上烧脑的概念，需要大致的了解一下，至少能够看得懂，如果看懂了，那么下面那段代码，应该就没有问题了。
以下是 swift开发者大会上，傅若愚 解决回调地狱的核心代码中，我稍加整理
主要是闭包的写法让人不是很好理解，加了一些推导过程。
源码路径 https://github.com/lingoer/SwiftyCharms
import UIKit
import Foundation
enum Result<T> {
case Success(T)
case Failure(ErrorType)
}
func == <T: Equatable>(lhs: Result<T>, rhs: Result<T>) -> Bool {
if case (.Success(let l), .Success(let r)) = (lhs, rhs) {
return l == r
}
return false
}
extension Result {
static func unit(x: T) -> Result<T> {
return .Success(x)
}
func map<U>(f: T throws -> U) -> Result<U> {
return flatMap { .unit(try f($0)) }
}
func flatMap<U>(f: T throws -> Result<U>) -> Result<U> {
switch self {
case .Success(let value):
do {
return try f(value)
} catch let e {
return .Failure(e)
}
case .Failure(let e):
return .Failure(e)
}
}
func apply<U>(rf: Result < T throws -> U >) -> Result<U> {
return rf.flatMap(map)
}
}
struct Async<T> {
let trunk: (Result<T> -> Void) -> Void
init(function: (Result<T> -> Void) -> Void) {
trunk = function
}
func execute(callBack: Result<T> -> Void) {
trunk(callBack)
}
}
extension Async {
static func unit(x: T) -> Async<T> {
// return Async{ $0(.Success(x))}
return Async(function: { trunk -> Void in
trunk(.Success(x))
})
}
func map<U>(transform: T throws -> U) -> Async<U> {
// return flatMap { .unit(try transform($0)) }
return flatMap({ tx in
return Async<U>.unit(try transform(tx))
})
}
func flatMap<U>(transform: T throws -> Async<U>) -> Async<U> {
// 然后，就可以大神的代码一样了
return Async<U> { trunk in
self.execute {
switch $0.map(transform) {
case .Success(let async):
async.execute(trunk)
case .Failure(let err):
trunk(.Failure(err))
}
}
}
// 然后在去掉 参数
// return Async<U> { trunk in
// self.execute{ result in
// switch result.map(transform) {
// case .Success(let async):
// async.execute(trunk)
// case .Failure(let err):
// trunk(.Failure(err))
// }
// }
// }
// 里面那一层同样的的道理，可以简化为
// return Async<U> { trunk in
// self.execute({ (result) -> Void in
// switch result.map(transform) {
// case .Success(let async):
// async.execute(trunk)
// case .Failure(let err):
// trunk(.Failure(err))
// }
// })
// }
// 括号只有一个参数，括号可以不写
// return Async<U> { (trunk) in
// self.execute({ (result) -> Void in
// switch result.map(transform) {
// case .Success(let async):
// async.execute(trunk)
// case .Failure(let err):
// trunk(.Failure(err))
// }
// })
// }
// 返回值在末尾，可以不写
// return Async<U> { (trunk) in
// self.execute({ (result) -> Void in
// switch result.map(transform) {
// case .Success(let async):
// async.execute(trunk)
// case .Failure(let err):
// trunk(.Failure(err))
// }
// })
// }
// 最后一个参数，可以写成{}在末尾
// return Async<U> { (trunk) -> Void in
// self.execute({ (result) -> Void in
// switch result.map(transform){
// case .Success(let async):
// async.execute(trunk)
// case .Failure(let err):
// trunk(.Failure(err))
// }
// })
// }
// 最开始的状况
// return Async<U>(function: { trunk -> Void in
// self.execute({ result -> Void in
// switch result.map(transform) {
// case .Success(let async):
// async.execute(trunk)
// case .Failure(let err):
// trunk(.Failure(err))
// }
// })
// })
}
func apply<U>(af: Async < T throws -> U >) -> Async<U> {
// return af.flatMap({ (<#T#>) -> U throws -> Async<U> in
// <#code#>
// })
//看到 T -> U -> Async<U> 没，四核和map是一个样的函数啊，只不过这个是curry版本的。所以，呵呵，直接替换
return af.flatMap(map)
}
}
