another-rxrust 0.0.46

A different implementation than `rxRust` for easier use of `ReactiveX` in `Rust`.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#[cfg(all(test, not(feature = "web")))]
mod test {
  use crate::prelude::*;
  use std::{thread, time};

  #[test]
  fn basic() {
    fn ob() -> Observable<'static, i32> {
      Observable::create(|s| {
        s.next(100);
        s.next(200);
        s.complete();
      })
    }

    observables::from_iter(1..10)
      .observe_on(schedulers::new_thread_scheduler())
      .flat_map(|x| match x {
        1 => observables::empty(),
        2 => observables::just(x),
        3 => ob().map(move |y| (y + x)),
        4 => observables::error(RxError::from_error("some error")),
        _ => observables::never(),
      })
      .map(|x| format!("{}", x))
      .on_error_resume_next(|e| {
        ob().map(move |x| {
          format!(
            "resume {:?} {}",
            e.downcast_ref::<&str>(),
            x
          )
        })
      })
      .subscribe(
        |x| println!("{}", x),
        |e| println!("{:?}", e.downcast_ref::<&str>()),
        || println!("complete"),
      );

    thread::sleep(time::Duration::from_millis(500));
  }

  #[test]
  fn outside_var() {
    #[derive(Clone)]
    struct OutsideVar {
      data: String,
    }
    let x = OutsideVar { data: "abc".to_owned() };

    let xx = x.clone();
    let xxx = x.clone();

    let jx = observables::just(x);

    jx.subscribe(
      |x| println!("{}", x.data),
      print_error!(),
      move || {
        println!("complete {}", xx.data);
      },
    );

    jx.subscribe(
      |x| println!("{}", x.data),
      print_error!(),
      move || {
        println!("complete {}", xxx.data);
      },
    );
  }
}