RxSwift のSingleが好きになってきた

DispatchGroup()から解放される

今までだと、

func hogeA(huga: String, success: () -> Void, failure: () -> Void) {
    if Bool {
      success()
    } else {
      failure()
    }
}

func hogeB(huga: String, success: () -> Void, failure: () -> Void) {
    if Bool {
      success()
    } else {
      failure()
    }
}

↑にDispatchGroup()を使って

func hogehoge(huga: Stirng, success: () -> Void, failure: () -> Void) {
    let dispatchGroup = DispatchGroup()
    let dispatchQueue = DispatchQueue(label: "", attributes: .concurrent)

    // mapとか色々な理由でhogeAが終わってからhogeBしたい時
    dispatchGroup.enter()
    dispatchQueue.async(group: dispatchGroup) {
        self.hogeA(huga: "", 
            success: {
                dispatchGroup.leave()
            }, 
            failure: {
                dispatchGroup.leave()
            }
        )
     }

     dispatchGroup.notify(queue: .main) {
         // 例えば0.1秒遅らせたい場合
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
             self.hogeB(huga: "",
                 success: {
                     success()
                 },
                 failure: {
                     failure()
                 }
             )
         }
      }
}

な感じで使っていたと思う。
もしくは無限ネストとか、、
原始的かつバグを生みやすい。

それをSingle&flatMapで解決

import RxSwift

func hogeA(huga: String) -> Single<String?>{
    Single.create { single in
        if Bool {
           single(.just(""))
        } else {
           single(.just(nil))
        }
        return Disposables.create()
    }
}

// `return huga.asSingle()`な感じで`Single.create`書かないパターンも出来るのでよしなに
func hogeB(huga: String) -> Single<Void> {
    Single.create { single in
        if Bool {
           single(.just())
        } else {
           single(.error(Error))// Error型は作るなり、好きに
        }
        return Disposables.create()
    }
}

func hogehoge(huga: Stirng) -> Single<Void?> {
   hogeA(huga: String)
       .flatMap { str -> Single<Void> in
           // hogeAの結果strがnilだったらhogeBは叩かない（.never()で抜ける）
           guard let str = str else { return .never()}
           return hogeB(str)
           //型を変えたいなら return hogeB(str).map { "" }でSingle<String>を返せる
       }
       .subscribe(
           onSuccess: { _ in
           // '_'にはflatMapの`Void`が来る
             return .just(())
           },
           onFailure: { _ in
             return .just(nil)
           }
       )
}

な感じで無限に.flatMapで繋げられる。最高。
暇だったら続き書く