1、任何異步操作的參數(shù)必然是一些基本參數(shù)脆侮，加上回調(diào)函數(shù)锌畸！請仔細考慮這句話！＞副堋潭枣！
2、假如說幻捏，我們將這么一個異步操作拆分開來：接收一個參數(shù)盆犁，返回一個回調(diào)函數(shù)？請仔細思考篡九，是否可以ｒ伎埂！Ｎ拖隆翰铡！
一些燒腦的概念：
抽象的是一個計算過程————函數(shù)式變成精髓所在。讽坏。锭魔。@包涵卿
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/)
以上燒腦的概念路呜，需要大致的了解一下迷捧，至少能夠看得懂织咧，如果看懂了，那么下面那段代碼漠秋，應(yīng)該就沒有問題了笙蒙。
以下是 swift開發(fā)者大會上，傅若愚 解決回調(diào)地獄的核心代碼中庆锦，我稍加整理
主要是閉包的寫法讓人不是很好理解捅位，加了一些推導過程。
源碼路徑 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))
}
}
}
// 然后在去掉 參數(shù)
// 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))
// }
// })
// }
// 括號只有一個參數(shù)，括號可以不寫
// 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))
// }
// })
// }
// 最后一個參數(shù)焰雕，可以寫成{}在末尾
// 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是一個樣的函數(shù)啊芳杏，只不過這個是curry版本的矩屁。所以，呵呵爵赵，直接替換
return af.flatMap(map)
}
}
