rustility 0.1.1

A collection of utilities I often find myself using 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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use std::{future::Future, pin::Pin};

use async_trait::async_trait;

/// Discard is a trait used to discard the values of results/options.
///
/// This trait provides a single method, `discard`, which is particularly useful if you want to run the result/option code, but don't care about the returned result.
pub trait Discard {
    /// Takes ownership of the Result/Option and discards the value.
    ///
    /// # Example
    /// ```rust
    /// use rustility::Discard;
    /// fn code_that_returns_a_result() -> Result<i32, Box<dyn std::error::Error>> {
    ///     let computation_value = 1;
    ///     assert_eq!(computation_value, 1);
    ///     Ok(computation_value)
    /// }
    /// code_that_returns_a_result().discard();
    ///
    /// ```
    fn discard(self);
}

impl<T, E> Discard for Result<T, E> {
    fn discard(self) {
        let _ = self;
        drop(self);
    }
}

impl<T> Discard for Option<T> {
    fn discard(self) {
        let _ = self;
        drop(self);
    }
}

#[async_trait]
/// AsyncMap is a trait used to map a value under asynchronous contexts.
///
/// It allows you to pass in a boxed + pinned future and perform activites similar to std's map for Options/Results.
pub trait AsyncMap<T, U, F>
where
    F: FnOnce(T) -> Pin<Box<dyn Future<Output = U> + Send>> + Send,
{
    type Output;
    async fn async_map(self, map: F) -> Self::Output;
}

#[async_trait]
impl<T, U, F> AsyncMap<T, U, F> for Option<T>
where
    T: Send,
    U: Send,
    F: 'static + FnOnce(T) -> Pin<Box<dyn Future<Output = U> + Send>> + Send,
{
    type Output = Option<U>;
    async fn async_map(self, map: F) -> Self::Output {
        match self {
            Some(t) => {
                let u = map(t).await;
                Some(u)
            }
            None => None,
        }
    }
}

#[async_trait]
impl<T, E, U, F> AsyncMap<T, U, F> for Result<T, E>
where
    T: Send,
    U: Send,
    E: Send,
    F: 'static + FnOnce(T) -> Pin<Box<dyn Future<Output = U> + Send>> + Send,
{
    type Output = Result<U, E>;
    async fn async_map(self, map: F) -> Self::Output {
        match self {
            Ok(t) => {
                let u = map(t).await;
                Ok(u)
            }
            Err(e) => Err(e),
        }
    }
}