Documentation idea: label operators as either lossless or potentially lossy

[curiousercreative]

I'm no wiz with RxJS still, but over the years I've struggled to wrap my head around the various operators. We have great tools in the marble diagrams and the operator decision tree, but one dimension that could be more succinctly documented is whether an operator is potentially lossy or not. Take, debounce, throttle, filter are some examples of operators that may output fewer values than taken as input. On the contrary, the various maps, tap, and others will always output the same number of values as they are input (over time).

Anecdotally, I was in need of a lossless operator to comply with an API service's rate limit and it took me awhile to rule out the various operators (they are all lossy) before I rolled my own: https://github.com/curiousercreative/rxjs-rate-limit

If there's interest, I'd recommend discussing further:

• besides lossy and lossless, is it worth enumerating types of operators that merge or split values? These are harder to define, but perhaps worth denoting whether all inputs are present (transformatively lossless) or not (transformatively lossy or just lossy)
• how to present this attribute in docs
• could this be helpful in the operator decision tree questionnaire?

[curiousercreative]

To add some context, I've been using RxJS for building reporting and ETL batch scripts where I need to ensure all data is processed and it'd be nice to quickly rule out operators which are lossy and focus on lossless operators.

[jakovljevic-mladen]

Hi @curiousercreative, thank you for sharing your idea with us.

I am in favor of adding and improving our docs a lot, but we have to do it very carefully. Marking operators as lossy or lossless is much harder for some operators as there are operators that can be both lossy and lossless. For example, switchMap can be both lossy and lossless, depending on the result of the callback function passed to switchMap. It can also can provide much more next emission than the source Observable.

The list of such operators is huge. How would we mark such operators? Also, what about docs? How terms lossy and lossless could be described in docs when someone sees them?

[curiousercreative]

@jakovljevic-mladen thanks for the response, yeah it's really less of a binary than I had originally presented. What's valuable to understand at a glance is the relationship between quantity input and output. Would the following cover all cases:

• outputs exactly the same quantity input
• outputs less than or equal to quantity input
• outputs more than or equal to quantity
• output quantity unrelated to input quantity (may output more or less or equal to input)