RxSwift如何避免回调地狱

首先看如何制造回调地狱：

func fetchData(_ f: (String) -> Void) -> Void {
    f("1")
}

fetchData { (result) in
    print(result)
}

那么可以总结出回调地狱的规则为：

(T -> ()) -> ()

如何避免回调地狱：单子的模型（简）

struct Monad<T> {
    var value: T
    func flatMap<U>(_ f: (T) -> Monad<U>) -> Monad<U> {
        return f(value)
    }
}

let monad = Monad(value: 10)
let result = monad
    .flatMap ({
        return Monad(value: String($0)) // "10"
    })
    .flatMap({
        return Monad(value: Float($0)! + 5) // 10.0 + 5
    })

result.value // 15

所以单子模型的关键函数flatMap可以抽象成：

(T -> F(U)) -> F(U)

最后用RxSwift实现

func fetchData() -> Observable<String> {
    return Observable<String>.create { observer in
        DispatchQueue.global().async {
            sleep(1)
            DispatchQueue.main.async {
                observer.onNext("1")
            }
        }
        return Disposables.create()
    }
}
    
func convertToInt(source: String) -> Observable<Int> {
    return Observable<Int>.create { observer in
        let result = Int(source) ?? 0
        observer.onNext(result)
        return Disposables.create()
    }
}
    
func convertToBool(source: Int) -> Observable<Bool> {
    return Observable<Bool>.create { observer in
        let result = source > 0 ? true : false
        observer.onNext(result)
        return Disposables.create()
    }
}

要实现单子就返回Observable即可。

产生回调地狱的调用方式（简化）：

fetchData().subscribe(onNext: {
    self.convertToInt(source: $0).subscribe(onNext: {
        self.convertToBool(source: $0).subscribe(onNext: {
            print("final result: \($0)")
        })
    })
})

不产生回调地狱（单子）的方式（简化）：

self.fetchData()
    .flatMap({
        return self.convertToInt(source: $0)
    })
    .flatMap({
        return self.convertToBool(source: $0)
    })
    .subscribe(onNext: {
        print("final result:\($0)")
    })