deluge 0.2.1

A highly concurrent stream library driving the underlying futures either concurrently or in parallel to process streaming operations as quickly as possible.
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

use crate::deluge::Deluge;
use std::future::Future;

pub struct Map<Del, F> {
    deluge: Del,
    f: F,
}

impl<Del, F> Map<Del, F> {
    pub(crate) fn new(deluge: Del, f: F) -> Self {
        Self { deluge, f }
    }
}

impl<InputDel, Fut, F> Deluge for Map<InputDel, F>
where
    InputDel: Deluge,
    F: Fn(InputDel::Item) -> Fut + Send,
    Fut: Future + Send,
    <Fut as Future>::Output: Send,
{
    type Item = Fut::Output;
    type Output<'a> = impl Future<Output = Option<Self::Item>> + 'a where Self: 'a;

    fn next(&self) -> Option<Self::Output<'_>> {
        self.deluge.next().map(|item| async {
            let item = item.await;
            if let Some(item) = item {
                Some((self.f)(item).await)
            } else {
                None
            }
        })
    }
}