rxrs's Introduction

rxrs

Reactive Extensions Library for Rust.

This is a work in progress library. Do not use it for production environments.

Observable

Create

For creating new Observable instances, the library provides a number of creation operators:

of: creates a finite number of observables with a defined value:
```
let observable = of(&[1, 2, 3]);
```
interval: creates an infinite observable that emits sequential numbers every specified interval of time:
```
let observable = interval(1000); // every 1000 ms (1s)
```

rxrs's People

Contributors

Stargazers

Watchers

rxrs's Issues

Subscription on a piped Observable does not work

When using multiple Observable operators (e.g. map, filter), it's not possible to subscribe to the resulted Observable, if this one is used by another operator:

#[test]
fn successive_subscriptions() {
   let data = [1, 2, 3];

    let multiplied = of(&data)
        .map(|item| item * 2);

    assert!(values_sent(&multiplied, &[2, 4, 6]));
    assert!(is_completed(&multiplied));

    let result = multiplied.map(|item| item / 2);
    assert!(values_sent(&result, &data));
    assert!(is_completed(&result));
}

Not possible to use multiple operators to same observable

Since Observable does not implement the copy trait, it's currently not possible to use multiple operators.

Example:

#[test]
fn multiple_operators_same_observable() {
    let observable = of(&[1, 2 ,3]);

    let even = observable.filter(|item| item % 2 == 0);
    let odd = observable.filter(|item| item % 2 == 1);

    assert!(values_sent(&even, &[2]));
    assert!(is_completed(&even));
    assert!(values_sent(&odd, &[1, 3]));
    assert!(is_completed(&odd));
}