rxrust 0.7.2

A Rust implementation of Reactive Extensions.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use crate::prelude::*;

/// Creates an observable that emitts no items, just terminates with an error.
///
/// # Arguments
///
/// * `e` - An error to emitt and terminate with
///
pub fn throw<O, U, Item, Err>(
  e: Err,
) -> Observable<impl FnOnce(Subscriber<O, U>) + Clone, Item, Err>
where
  O: Observer<Item, Err>,
  U: SubscriptionLike,
  Err: Clone,
  Item: Clone,
{
  Observable::new(move |mut subscriber| {
    subscriber.error(e);
  })
}

/// Creates an observable that produces no values.
///
/// Completes immediatelly. Never emits an error.
///
/// # Examples
/// ```
/// use rxrust::prelude::*;
///
/// observable::empty()
///   .subscribe(|v: &i32| {println!("{},", v)});
///
/// // Result: no thing printed
/// ```
///
pub fn empty<O, U, Item>()
-> Observable<impl FnOnce(Subscriber<O, U>) + Clone, Item, ()>
where
  O: Observer<Item, ()>,
  U: SubscriptionLike,
{
  Observable::new(move |mut subscriber: Subscriber<O, U>| {
    subscriber.complete();
  })
}

/// Creates an observable that never emitts anything.
///
/// Neither emitts a value, nor completes, nor emitts an error.
///
pub fn never<O, U, Item>()
-> Observable<impl FnOnce(Subscriber<O, U>) + Clone, Item, ()>
where
  O: Observer<Item, ()>,
  U: SubscriptionLike,
{
  Observable::new(move |_subscriber: Subscriber<O, U>| {
    loop {
      // will not complete
      std::thread::sleep(std::time::Duration::from_secs(1));
    }
  })
}

#[cfg(test)]
mod test {
  use crate::prelude::*;

  #[test]
  fn throw() {
    let mut value_emitted = false;
    let mut completed = false;
    let mut error_emitted = String::new();
    observable::throw(String::from("error")).subscribe_all(
      // helping with type inference
      |_: i32| value_emitted = true,
      |e: String| error_emitted = e,
      || completed = true,
    );
    assert!(!value_emitted);
    assert!(!completed);
    assert_eq!(error_emitted, "error");
  }

  #[test]
  fn empty() {
    let mut hits = 0;
    let mut completed = false;
    observable::empty()
      .subscribe_complete(|_: &()| hits += 1, || completed = true);

    assert_eq!(hits, 0);
    assert_eq!(completed, true);
  }
}