Rx java 递归地将Rx单体组合为可观测

假设我有一个名为s_0的单元素，它可以从类型t发出元素t_0，或者在某些语言中是单元素。即:

s_0: -- t_0          // Success

OR

s_0: -- X            // Failure

类型T的实例有一个下一个方法，该方法返回类型T的可选单值以及单值？在科特林。此行为导致一个能够发出T实例链的单实例链，其中每个单s_i可以发出一个能够返回下一个单s_i+1的元素T_i，该元素将发出一个元素T_i+1，依此类推，直到最后一个元素T_n-1不返回单个或任何单实例失败：

s_0: -- t_0
        ↓
        s_1: -- t_1
                ↓
                s_2: -- t_2

                        ...

                        ↓
                        s_n-1: -- t_n-1
                                  ↓
                                  null

OR

s_0: -- t_0
        ↓
        s_1: -- t_1
                ↓
                s_2: -- t_2

                        ...

                        ↓
                        s_i: -- X

我正在寻找一种优雅的方法，从类型T获得一个可观测的o，能够从s_0开始的链中发射所有元素，当链上没有更多单体时成功完成，或者如果任何单体失败，则失败：

o: -- t_0 -- t_1 -- t_2 -- ... -- t_n-1 --o     // Success

OR

o: -- t_0 -- t_1 -- t_2 -- ... --X              // Failure

所谓优雅，我指的是像Kotlin中这样简单的东西：

这有什么适用性？

---

当使用带有分页的REST API时，可以发现这种情况，其中单个实例可用于检索单个页面，这反过来又可以提供能够发出后续页面的单个实例。

我还没有测试过这一点，但基于我不久前针对类似分页问题编写的解决方案，我将其翻译为Kotlin

fun Single<T>.chain(): Observable<T> =
    toObservable()
    .concatWith {
        it.next()?.chain()
        ?: Observable.empty()
    }

---

获得递归链接的关键是concatWith操作符递归调用chain方法

我还没有测试过这个方法，但是基于一个解决方案，我在不久前编写了一个类似的分页问题的代码，我将其翻译为Kotlin

fun Single<T>.chain(): Observable<T> =
    toObservable()
    .concatWith {
        it.next()?.chain()
        ?: Observable.empty()
    }

获得递归链接的关键是concatWith操作符递归调用chain方法

虽然If是我的util类，但您可以通过If…else

---

虽然If是我的util类，但您可以改为If…else…

酷！concatMap+递归是一种方法。我只想指出，在这个特定的例子中，给定的代码将不起作用，因为发出的项永远不会为null，它应该递归地与返回值连接起来，比如：concatMap{Observable.justit.concatWithit.next？.chainnext？：Observable.empty}。但这只是一个小细节，你的回答为我指明了正确的方向。谢谢我刚刚更新了我的答案以反映这一点。请注意，您的chain方法不接受任何下一个参数；凉的concatMap+递归是一种方法。我只想指出，在这个特定的例子中，给定的代码将不起作用，因为发出的项永远不会为null，它应该递归地与返回值连接起来，比如：concatMap{Observable.justit.concatWithit.next？.chainnext？：Observable.empty}。但这只是一个小细节，你的回答为我指明了正确的方向。谢谢我刚刚更新了我的答案以反映这一点。请注意，您的chain方法不接受任何下一个参数；为什么投反对票？为什么投反对票？

public class Q44535765 {
  public static void main(String[] args) {
    Maybe<Element> first = get();
    first.toObservable()
        .compose(o -> chain(o))
        .doOnError(e -> System.out.println(e))
        .subscribe(
            e -> System.out.println(e),
            e -> System.out.println("fail"),
            () -> System.out.println("complete"));
  }

  static Maybe<Element> get() {
    return Maybe.just(
        () -> If.<Maybe<Element>> that(Math.random() > 0.1)
            .tobe(() -> get())
            .orbe(() -> If.<Maybe<Element>> that(Math.random() > 0.5)
                .tobe(() -> Maybe.empty())
                .orbe(() -> null)
                .result())
            .result());
  }

  static Observable<Element> chain(Observable<Element> s) {
    return s.concatMap(
        e -> Observable.just(e)
            .concatWith(e.next()
                .toObservable()
                .compose(o -> chain(o))));
  }

  interface Element {
    Maybe<Element> next();
  }
}