combine-latest 1.1.2

Combines two streams into a new stream which yields tuples with the latest values from each input stream
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

# combine-latest

Combines two streams into a new stream which yields tuples with the latest values from each input
stream. Inspired by Rx's combineLatest.

```rust
use async_stream::stream;
use combine_latest::combine_latest;

fn combine_weather_data_streams(
    temperature: impl Stream<i32>,
    weather_notes: impl Stream<String>,
) -> Stream<String> {
    stream! {
        for await (t, n) in combine_latest(temperature, weather_notes) {
            yield format!("Temperature {t}°, note: {n}");
        }
    }
}
```

`combine_latest` won't yield its first tuple until both input streams have yielded a value. If you
need to get items as soon as the first is available, there is a `combine_latest_opt` function that
yields `(Option<T1>, Option<T2>)` tuples.

As values come in over time on the `temperature` and `weather_notes` streams, `combine_latest` and
`combine_latest_opt` will yield values like so:

|time| temperature  | weather_notes  | combine_latest         | combine_latest_opt                 |
|----|--------------|----------------|------------------------|------------------------------------|
| 0  | 25           |                |                        | (Some(25), None)                   |
| 1  | 26           |                |                        | (Some(26), None)                   |
| 2  |              | Low visibility | (26, "Low visibility") | (Some(26), Some("Low visibility")) |
| 3  |              | Foggy          | (26, "Foggy")          | (Some(26), Some("Foggy"))          |
| 4  | 25           |                | (25, "Foggy")          | (Some(25), Some("Foggy"))          |


Since the same input value might be returned several times in the output stream, the items that the
input streams yield *must implement Clone.*

For types that don't implement Clone, it's possible to use the function `map_latest`:

```rust
fn combine_weather_data_streams(
    temperature: impl Stream<NonCloneTemperature>,
    weather_notes: impl Stream<String>,
) -> Stream<String> {
    stream! {
        for await output in map_latest(
            temperature,
            weather_notes,
            |t, n| format!("Temperature {t}°, note: {n}"),
        ) {
            yield output;
        }
    }
}

```

To add to you project: `cargo add combine-latest`