Swift 决策树的可观测性

我需要一个函数，它将复杂的IAP购买树封装到一个简单的attemptPurchase函数中，该函数返回一个布尔可观察值（true->success，false->cancelled，error->any error）

但我对如何创建该函数感到困惑，主要是因为决策的开始是异步的

决策树和下面的代码

//失败->缺少返回函数
//但是我不能返回信用检查，因为根据结果，执行是不同的
func attemptPurchase（金额：Int）->可观察{
let creditCheck=creditCheck（金额）
creditCheck.filter{$0}.subscribeNext{uuIn
返回可观察。仅（真）
}
creditCheck.filter{$0}.subscribeNext{uuIn
返回confirmIAP（）.processIAP（）
}
}
func creditCheck（金额：Int）->可观察{
返回API.creditCheck.map{$0>amount}
}
func confirmIAP（）->可观察{
//确认IAP的用户界面
}
func processIAP（）->可观察{
//用于在我的服务器上上载IAP的UI
}

这是您可以做到的：

func attemptPurchase(amount: Int) -> Observable<Bool> {
    return creditCheck(amount)
        .flatMapLatest { (enoughCredit: Bool) -> Observable<Bool> in
            if enoughCredit {
                return Observable.just(true)
            } else {
                return confirmIAP()
                    .flatMapLatest { (isConfirmed: Bool) -> Observable<Bool> in
                        if isConfirmed {
                            return processIAP()
                        } else {
                            return Observable.just(false)
                        }
                    }
            }
        }
}

func尝试购买（金额：Int）->可观察{
退货信用支票（金额）
.flatMapLatest{（enoughCredit:Bool）->在
如果没有足够的信用{
返回可观察。仅（真）
}否则{
返回confirmIAP（）
.flatMapLatest{（已确认：Bool）->在
如果被证实{
返回进程iap（）
}否则{
返回可观察。仅（假）
}
}
}
}
}

来自RxSwift slack组中的答案：

func attemptPurchase(amount: Int) -> Observable<Bool>{
    return creditCheck(amount)
        .flatMap { enough in
            return (enough ? .just(true) : confirmIAP())
        }
        .flatMap { ready in
            guard ready else { /* failure */ }
            return processIAP()
        }
}

func尝试购买（金额：Int）->可观察{
退货信用支票（金额）
.flatMap{足够了
return（足够了？.just（true）：confirmIAP（））
}
.flatMap{准备就绪
保护就绪，否则{/*失败*/}
返回进程iap（）
}
}

谢谢您的回答，非常感谢！还有另一个答案，我发现更多。刚刚加上去的。你觉得呢？他们的行为不同，但我不确定你需要哪一个。为什么他们不同？两者都达到了问题的目的例如，在我的代码中，如果

enoughCredit

是

true

，那么最终的

可观察的
只发出
true
，这就是它所做的。但是，在您的中，如果
足够
为
真
，那么它也将运行
processIAP（）
。因此，流量是不同的。另外，<代码>平面图 VS <代码> PrimaPaulest，这意味着，如果你正在处理一个事件，而另一个事件通过，<代码>平面地图< /代码>将使它们同时发生，而<>代码> PrimaPaulest< <代码>将取消/处理第一个事件。
func attemptPurchase(amount: Int) -> Observable<Bool>{
    return creditCheck(amount)
        .flatMap { enough in
            return (enough ? .just(true) : confirmIAP())
        }
        .flatMap { ready in
            guard ready else { /* failure */ }
            return processIAP()
        }
}