An observable to emit tuple of latest values of N other observables? - reactive-programming

Question

Is there any operation like zip, but which not waits for entire tuple gather, but emits tuple on each change.
For example if it just emitter 1A and B came on second observable, it immediately emits 1B, which is "latest" tuple.
At the beginning, this operation should wait until all N elements gather.

Answer 1

What you're looking for is usually called zipLatest.
Here's an example implementation in Python:
from typing import *
import rx
import rx.operators as ops
def zip_latest(*xss: rx.Observable) -> rx.Observable:
helper = ZipLatestHelper(len(xss))
return mux(*xss).pipe(
ops.map(helper.process),
ops.filter(lambda x: x is not None),
)
def mux(*xss: rx.Observable) -> rx.Observable:
def pair_index(i: int) -> Callable[[Any], Tuple[int, Any]]:
def inner(x: Any) -> Tuple[int, Any]:
return i, x
return inner
paired = [xs.pipe(ops.map(pair_index(i))) for i, xs in enumerate(xss)]
return rx.from_iterable(paired).pipe(ops.merge_all())
class ZipLatestHelper:
def __init__(self, num_streams):
self.latest = [None for _ in range(num_streams)]
self.ready = set()
def process(self, pair: Tuple[int, Any]) -> Optional[Tuple[Any, ...]]:
i, x = pair
self.latest[i] = x
self.ready.add(i)
return (
tuple(self.latest) if len(self.ready) == len(self.latest) else None
)
And usage:
from time import sleep
zipped = zip_latest(
rx.interval(0.5).pipe(ops.map(lambda i: f"A{i}")),
rx.interval(0.3).pipe(ops.map(lambda i: f"B{i}")),
)
zipped.subscribe(print)
sleep(10)
With output:
('A0', 'B0')
('A0', 'B1')
('A0', 'B2')
('A1', 'B2')
('A1', 'B3')
('A2', 'B3')
('A2', 'B4')
('A2', 'B5')
Caveats:
May not be thread-safe.
What should one do if a stream receives OnCompleted? Should the zipped stream continue emitting items, or should it issue an OnCompleted?
What should one do if a stream receives OnError?