sugars_async_task 0.5.4

Async task utilities and abstractions for the cyrup-sugars ecosystem
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

//! Future extension traits for async future processing

use crate::task::{AsyncTask, NotResult};
use tokio::sync::oneshot;

//────────────────────────────────────────────────────────────────────────────
// FutureExt – Fluent ops for AsyncTask<T>
//────────────────────────────────────────────────────────────────────────────

/// Extension trait for futures that provides additional combinators for async operations.
pub trait FutureExt<T>: Sized {
    /// Maps the success value of the future to a new type using the provided function.
    fn map<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult;

    /// Executes a function when the future completes successfully.
    fn on_ok<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult;

    /// Executes a function when the future encounters an error.
    fn on_error<U>(
        self,
        f: impl FnOnce(oneshot::error::RecvError) -> U + Send + 'static,
    ) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult,
        T: Into<U>;

    /// Handles both success and error cases with a result handler.
    fn on_result<U>(
        self,
        f: impl FnOnce(Result<T, oneshot::error::RecvError>) -> U + Send + 'static,
    ) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult;

    /// Maps the success value while preserving error state.
    fn map_ok<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult;

    /// Applies a function to the success value without consuming it.
    fn tap_ok(self, f: impl FnOnce(&T) + Send + 'static) -> AsyncTask<T>
    where
        T: NotResult;

    /// Applies a function to the error value without consuming it.
    fn tap_err(self, f: impl FnOnce(&oneshot::error::RecvError) + Send + 'static) -> AsyncTask<T>
    where
        T: NotResult;
}

// Implementation for AsyncTask
impl<T: Send + 'static + NotResult> FutureExt<T> for AsyncTask<T> {
    fn map<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult,
    {
        self.on_ok(f)
    }

    fn on_ok<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult,
    {
        AsyncTask::from_future(async move {
            let value = self.await;
            f(value)
        })
    }

    fn on_error<U>(
        self,
        f: impl FnOnce(oneshot::error::RecvError) -> U + Send + 'static,
    ) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult,
        T: Into<U>,
    {
        self.on_result(move |result| match result {
            Ok(value) => value.into(),
            Err(e) => f(e),
        })
    }

    fn on_result<U>(
        self,
        f: impl FnOnce(Result<T, oneshot::error::RecvError>) -> U + Send + 'static,
    ) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult,
    {
        AsyncTask::from_future(async move {
            let result = self.receiver.await;
            f(result)
        })
    }

    fn map_ok<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>
    where
        U: Send + 'static + NotResult,
    {
        self.on_ok(f)
    }

    fn tap_ok(self, f: impl FnOnce(&T) + Send + 'static) -> AsyncTask<T> {
        AsyncTask::from_future(async move {
            let value = self.await;
            f(&value);
            value
        })
    }

    fn tap_err(self, f: impl FnOnce(&oneshot::error::RecvError) + Send + 'static) -> AsyncTask<T> {
        AsyncTask::from_future(async move {
            match self.receiver.await {
                Ok(value) => value,
                Err(e) => {
                    f(&e);
                    panic!("AsyncTask channel error: {e:?}");
                }
            }
        })
    }
}