RxPy - Pourquoi les émissions sont-elles entrelacées avec les opérateurs de fusion?

Question

Alors j'apprends RxPy après avoir fait RxJava et RxKotlin pendant deux ans. Une chose que je remarque est que certains opérateurs provoquent un entrelacement fou qui ne se produit pas dans RxJava.

Par exemple, flat_map() entraînera l'entrelacement des émissions dans le désordre pour une source Observable simple.

items = Observable.from_(("Alpha","Beta","Gamma","Delta","Epsilon")) 

items.flat_map(lambda s: Observable.from_(list(s))).subscribe(print) 

SORTIE:

A 
l 
B 
p 
e 
G 
h 
t 
a 
D 
a 
a 
m 
e 
E 
m 
l 
p 
a 
t 
s 
a 
i 
l 
o 
n 

Cependant, avec RxJava ou RxKotlin, tout reste séquentiel et dans l'ordre.

fun main(args: Array<String>) { 
    Observable.just("Alpha","Beta","Gamma","Delta","Epsilon") 
     .flatMap { 
      Observable.from(it.toCharArray().asIterable()) 
     }.subscribe(::println) 
} 

SORTIE:

A 
l 
p 
h 
a 
B 
e 
t 
a 
G 
a 
m 
m 
a 
D 
e 
l 
t 
a 
E 
p 
s 
i 
l 
o 
n 

Je confirme que tout est en cours d'exécution sur le MainThread et il n'y a pas de planification asynchrone bizarre passe (je pense). Pourquoi RxPy se comporte-t-il de cette manière? Je remarque que cela arrive presque avec n'importe quel opérateur qui traite plusieurs sources Observable fusionnant ensemble. Que fait exactement le programmeur par défaut?

Aussi, pourquoi n'y a-t-il pas concat_map() dans RxPy? J'ai l'impression que cela n'est pas possible avec la façon dont l'ordonnancement fonctionne ...

Answer 1

Comme cela a déjà été noté, flatMap ne garantit pas la commande. RxPy ne met pas en œuvre concat_map comme un opérateur distinct mais vous pouvez obtenir le même effet en utilisant les opérateurs map et concat_all

Observable.from_(("Alpha","Beta","Gamma","Delta","Epsilon"))\ 
      .map(lambda s: Observable.from_(list(s)))\ 
      .concat_all()\ 
      .subscribe(print)