Ich habe ein ziemlich standardmäßiges API-Paginierungsproblem, das Sie mit einer einfachen Rekursion lösen können. Hier ist ein Beispiel:

public Observable<List<Result>> scan() {
    return scanPage(Optional.empty(), ImmutableList.of());
}

private Observable<?> scanPage(Optional<KEY> startKey, List<Result> results) {
    return this.scanner.scan(startKey, LIMIT)
            .flatMap(page -> {
                if (!page.getLastKey().isPresent()) {
                    return Observable.just(results);
                }
                return scanPage(page.getLastKey(), ImmutableList.<Result>builder()
                        .addAll(results)
                        .addAll(page.getResults())
                        .build()
                );
            });
}

Aber dies kann offensichtlich einen massiven Callstack erzeugen. Wie kann ich dies unbedingt tun, aber den Observable-Stream beibehalten?

Hier ist ein zwingendes Blockierungsbeispiel:

public List<Result> scan() {
    Optional<String> startKey = Optional.empty();
    final ImmutableList.Builder<Result> results = ImmutableList.builder();

    do {
        final Page page = this.scanner.scan(startKey);
        startKey = page.getLastKey();
        results.addAll(page.getResults());
    } while (startKey.isPresent());

    return results.build();
}