async-iter-ext 0.3.0

Async iterator methods and async methods for option and result.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/// Asynchronous extension methods for `Option<T>`.
///
/// This trait allows using asynchronous functions with `Option` types,
pub trait AsyncOptionTools<T> {
    /// Asynchronously checks if the option is `Some` and satisfies a predicate.
    ///
    /// Returns `false` if the value is `None`. If `Some`, the provided async function is run.
    ///
    /// # Examples
    ///
    /// ```
    /// use async_std::task;
    /// use async_iter_ext::AsyncOptionTools;
    ///
    /// task::block_on(async {
    ///     async fn is_positive(x: i32) -> bool {
    ///         x > 0
    ///     }
    ///
    ///     let some = Some(10);
    ///     let none: Option<i32> = None;
    ///
    ///     assert_eq!(some.is_some_and_async(is_positive).await, true);
    ///     assert_eq!(none.is_some_and_async(is_positive).await, false);
    /// });
    /// ```
    #[allow(clippy::wrong_self_convention)]
    fn is_some_and_async<F, Fut>(self, f: F) -> impl Future<Output = bool>
    where
        F: FnOnce(T) -> Fut,
        Fut: Future<Output = bool>;

    /// Asynchronously checks if the option is `None` or satisfies a predicate.
    ///
    /// - Returns `true` if the value is `None`.
    /// - If `Some`, runs the async predicate and returns its result.
    ///
    /// # Examples
    ///
    /// ```
    /// use async_std::task;
    /// use async_iter_ext::AsyncOptionTools;
    ///
    /// task::block_on(async {
    ///     async fn is_zero(x: u8) -> bool {
    ///         x == 0
    ///     }
    ///
    ///     let some = Some(0);
    ///     let none: Option<u8> = None;
    ///
    ///     assert_eq!(some.is_none_or_async(is_zero).await, true);
    ///     assert_eq!(
    ///         some.is_none_or_async(|x| async move { x > 1 }).await,
    ///         false
    ///     );
    ///     assert_eq!(none.is_none_or_async(is_zero).await, true);
    /// });
    /// ```
    #[allow(clippy::wrong_self_convention)]
    fn is_none_or_async<F, Fut>(self, f: F) -> impl Future<Output = bool>
    where
        F: FnOnce(T) -> Fut,
        Fut: Future<Output = bool>;

    /// Asynchronously maps an `Option<T>` to an `Option<B>` using an async function.
    ///
    /// - If `Some`, the function is awaited and wrapped in `Some`.
    /// - If `None`, returns `None`.
    ///
    /// # Examples
    ///
    /// ```
    /// use async_std::task;
    /// use async_iter_ext::AsyncOptionTools;
    ///
    /// task::block_on(async {
    ///     async fn to_string_async(n: i32) -> String {
    ///         format!("Number: {}", n)
    ///     }
    ///
    ///     let some = Some(42);
    ///     let result = some.map_async(to_string_async).await;
    ///     assert_eq!(result, Some("Number: 42".to_string()));
    ///
    ///     let none: Option<i32> = None;
    ///     let result = none.map_async(to_string_async).await;
    ///     assert_eq!(result, None);
    /// });
    /// ```
    #[allow(clippy::wrong_self_convention)]
    fn map_async<B, F, Fut>(self, f: F) -> impl Future<Output = Option<B>>
    where
        F: FnOnce(T) -> Fut,
        Fut: Future<Output = B>;
}

impl<T> AsyncOptionTools<T> for Option<T> {
    async fn is_some_and_async<F, Fut>(self, f: F) -> bool
    where
        F: FnOnce(T) -> Fut,
        Fut: Future<Output = bool>,
    {
        if let Some(x) = self {
            f(x).await
        } else {
            false
        }
    }

    async fn is_none_or_async<F, Fut>(self, f: F) -> bool
    where
        F: FnOnce(T) -> Fut,
        Fut: Future<Output = bool>,
    {
        if let Some(x) = self { f(x).await } else { true }
    }

    async fn map_async<B, F, Fut>(self, f: F) -> Option<B>
    where
        F: FnOnce(T) -> Fut,
        Fut: Future<Output = B>,
    {
        if let Some(x) = self {
            Some(f(x).await)
        } else {
            None
        }
    }
}