flatZip or call it however you want...

Hi everybody,

Lately I have noticed that from time to time I have the following use case:

• Im zipping many observables by using Observable.zip
• Some values are actually not interesting from my point of view (and I can know that only during the zipping when I have all the values at hand) so I need to have some value that will represent those unwanted result - usually I use null
• Right after Observable.zip I have a Observable.filter where Im filtering out all the null s so only the correct values are propagated further

I think that pretty neat solution would be to have a version of Observable.zip method (it can be called completely diffrent) that is workin like zip but accepts function that returns Observable. Thanks to that in such a case as described above we could simply return Observable.empty() and could skip the filtering step.

What do you think about it ?

[tobilarscheid]

I like the idea - I think this is commonly useful and vote for reopening!

[exi]

I would like to argue for a flatZip as well.

Using an Array only works if all components have the same type.

Using my own static method also seems very clunky since it breaks the fluid style of RxJava call chains.

A very common use-case for us is:

Single<Integer> iSingle = fetchInteger();
Single<Float> fSingle = fetchFloat();
Single<String> sSingle = fetchString();
Single.zip(iSingle, fSingle, sSingle, (i, f, s) -> fetchMoreData(i, f, s));

The problem here is that fetchMoreData also returns a Single which is currently not really easy to handle if i don’t want to end up with a Single<Single<Data>>.

So i’m stuck with:

Single<Integer> iSingle = fetchInteger();
Single<Float> fSingle = fetchFloat();
Single<String> sSingle = fetchString();
Single.zip(iSingle, fSingle, sSingle, MyCustomContainer::create)
  .flatMap(container -> fetchMoreData(container.getI(), container.getF(), container.getS());

Which is also very ugly and required me to have some custom tuple type just to be able to return some async value.