swift函数式编程-解决回调地狱

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)
 }
}