missing_features.md

Missing features

This document tracks the implementation status of ReactiveX operators and features in rxRust. We welcome contributions!

If you are looking for a Good First Issue, consider implementing one of the missing "Utility" or "Conditional" operators.

Operators By Category

Based on ReactiveX Operators Documentation.

Creating Observables

Operators that originate new Observables.

• Create — create an Observable from scratch by calling observer methods programmatically
  • use new method in rxRust
• Defer — do not create the Observable until the observer subscribes, and create a fresh Observable for each observer
• Empty/Never/Throw — create Observables that have very precise and limited behavior
• From — convert some other object or data structure into an Observable
  • from_iter
  • from_fn
  • from_future
  • from_stream
  • from_callback
• Interval — create an Observable that emits a sequence of integers spaced by a particular time interval
• Just — convert an object or a set of objects into an Observable that emits that or those objects
  • named of, of_result, of_option in rxRust
• Range — create an Observable that emits a range of sequential integers
  • use from_iter with a range
• Repeat — create an Observable that emits a particular item or sequence of items repeatedly
  • repeat is not explicitly implemented but can be achieved with from_iter or recursive scheduling, but a dedicated operator might be missing.
• Start — create an Observable that emits the return value of a function
  • defer or from_fn covers this.
• Timer — create an Observable that emits a single item after a given delay

Transforming Observables

Operators that transform items that are emitted by an Observable.

• Buffer — periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time
  • buffer(closing_notifier)
  • buffer_with_count
  • buffer_with_time
  • buffer_with_count_and_time
• FlatMap — transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable
  • implemented as merge_all (flatten) or map(...).merge_all(...)
• GroupBy — divide an Observable into a set of Observables that each emit a different group of items from the original Observable, organized by key
• Map — transform the items emitted by an Observable by applying a function to each item
• Scan — apply a function to each item emitted by an Observable, sequentially, and emit each successive value
• Window — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time

Filtering Observables

Operators that selectively emit items from a source Observable.

• Debounce — only emit an item from an Observable if a particular timespan has passed without it emitting another item
  • Throttle
  • ThrottleTime
  • Debounce
• Distinct — suppress duplicate items emitted by an Observable
  • DistinctUntilChanged — only emit when the current value is different than the last
• ElementAt — emit only item n emitted by an Observable
  • via take(n+1).last() or specific op. Original list checked it.
• Filter — emit only those items from an Observable that pass a predicate test
• First — emit only the first item, or the first item that meets a condition, from an Observable
  • via take(1)
• IgnoreElements — do not emit any items from an Observable but mirror its termination notification
  • via filter(|_| false) or ignore_elements (impl in finalize or similar?)
• Last — emit only the last item emitted by an Observable
• Sample — emit the most recent item emitted by an Observable within periodic time intervals
• Skip — suppress the first n items emitted by an Observable
• SkipLast — suppress the last n items emitted by an Observable
• SkipWhile — suppress items emitted by an Observable until a specified condition becomes false
• Take — emit only the first n items emitted by an Observable
• TakeLast — emit only the last n items emitted by an Observable
• TakeWhile — emit items emitted by an Observable while a specified condition is true

Combining Observables

Operators that work with multiple source Observables to create a single Observable

• And/Then/When — combine sets of items emitted by two or more Observables by means of Pattern and Plan intermediaries
• CombineLatest — when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this function
• Join — combine items emitted by two Observables whenever an item from one Observable is emitted during a time window defined according to an item emitted by the other Observable
• Merge — combine multiple Observables into one by merging their emissions
• StartWith — emit a specified sequence of items before beginning to emit the items from the source Observable
• Switch — convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently-emitted of those Observables
  • available via switch_map(|x| x) (aka switchAll)
• SwitchMap — map each item into an inner Observable and switch to the latest one
• WithLatestFrom - similar to CombineLatest, but only emits items when the single source Observable emits an item
• Zip — combine the emissions of multiple Observables together via a specified function and emit single items for each combination based on the results of this function

Error Handling Operators

Operators that help to recover from error notifications from an Observable

• Catch — recover from an onError notification by continuing the sequence without error
  • map_err exists, but catch_error (switch to new observable on error) is missing.
• Retry — if a source Observable sends an onError notification, resubscribe to it in the hopes that it will complete without error
  • Implemented with generic policies (count, delay, reset_on_success).

Observable Utility Operators

A toolbox of useful Operators for working with Observables

• Delay — shift the emissions from an Observable forward in time by a particular amount
• Do — register an action to take upon a variety of Observable lifecycle events
  • named tap
• Materialize/Dematerialize — represent both the items emitted and the notifications sent as emitted items, or reverse this process
• ObserveOn — specify the scheduler on which an observer will observe this Observable
• Serialize — force an Observable to make serialized calls and to be well-behaved
• Subscribe — operate upon the emissions and notifications from an Observable
• SubscribeOn — specify the scheduler an Observable should use when it is subscribed to
• TimeInterval — convert an Observable that emits items into one that emits indications of the amount of time elapsed between those emissions
• Timeout — mirror the source Observable, but issue an error notification if a particular period of time elapses without any emitted items
• Timestamp — attach a timestamp to each item emitted by an Observable
• Using — create a disposable resource that has the same lifespan as the Observable

Conditional and Boolean Operators

Operators that evaluate one or more Observables or items emitted by Observables

• All — determine whether all items emitted by an Observable meet some criteria
  • every or all
• Amb — given two or more source Observables, emit all of the items from only the first of these Observables to emit an item
• Contains — determine whether an Observable emits a particular item or not
• DefaultIfEmpty — emit items from the source Observable, or a default item if the source Observable emits nothing
• SequenceEqual — determine whether two Observables emit the same sequence of items
• SkipUntil — discard items emitted by an Observable until a second Observable emits an item
• SkipWhile — discard items emitted by an Observable until a specified condition becomes false
• TakeUntil — discard items emitted by an Observable after a second Observable emits an item or terminates
• TakeWhile — discard items emitted by an Observable after a specified condition becomes false

Mathematical and Aggregate Operators

Operators that operate on the entire sequence of items emitted by an Observable

• Average — calculates the average of numbers emitted by an Observable and emits this average
• Concat — emit the emissions from two or more Observables without interleaving them
  • ConcatAll (implemented as merge_all(1))
  • ConcatMap
  • Concat (static version taking iterables/varargs)
    • implemented as concat_observables in factory.rs
• Count — count the number of items emitted by the source Observable and emit only this value
• Max — determine, and emit, the maximum-valued item emitted by an Observable
• Min — determine, and emit, the minimum-valued item emitted by an Observable
• Reduce — apply a function to each item emitted by an Observable, sequentially, and emit the final value
• Sum — calculate the sum of numbers emitted by an Observable and emit this sum

Backpressure Operators

• backpressure operators — strategies for coping with Observables that produce items more rapidly than their observers consume them
  • on_backpressure_buffer, on_backpressure_drop, etc.

Connectable Observable Operators

Specialty Observables that have more precisely-controlled subscription dynamics

• Connect — instruct a connectable Observable to begin emitting items to its subscribers
• Publish — convert an ordinary Observable into a connectable Observable
• RefCount — make a Connectable Observable behave like an ordinary Observable
• Replay — ensure that all observers see the same sequence of emitted items, even if they subscribe after the Observable has begun emitting items

Operators to Convert Observables

• Future - to_future converts an observable to a Future
• Stream - to_stream converts an observable to Stream
• To — convert an Observable into another object or data structure

Subjects

• AsyncSubject — emits the last value (and only the last value) emitted by the source Observable, and only after that source Observable completes
• BehaviorSubject — begins by emitting the item most recently emitted by the source Observable (or a seed/default value if none has yet been emitted) and then continues to emit any other items emitted later by the source Observable(s)
• PublishSubject — emits to an observer only those items that are emitted by the source Observable(s) subsequent to the time of the subscription
  • The standard Subject in rxRust (Local::subject() / Shared::subject()) behaves as a PublishSubject.
• ReplaySubject — emits to any observer all of the items that were emitted by the source Observable(s), regardless of when the observer subscribes

Schedulers

• Async Scheduler and timer for local thread (not thread safe).
• Local thread scheduler.
• Thread pool scheduler.
• Virtual timer (for testing).

Workflows

• CI
  • Unit test coverage report.
  • Benchmark to measure performance for every commit.
  • Real-life representative algorithms implemented to measure performance.