owned-future 0.1.1

Turn borrowed futures into owned futures
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

/// A macro for quickly implementing [`crate::GetFut`] without capturing.
///
/// If you need capturing, you will have to manually capture what you want in a user-defined struct
/// and implement [`crate::GetFut`] for that struct.
#[macro_export]
macro_rules! get {
    (fn($input:ident: &mut $ity:ty) -> $oty:ty { $($v:tt)+ }) => {{
        $crate::get!(fn<'a>($input: &mut $ity) -> $oty {$($v)+})
    }};
    (fn<$a:lifetime>($input:ident: &mut $ity:ty) -> $oty:ty { $($v:tt)+ }) => {{
        #[derive(Clone, Copy)]
        struct Impl;
        impl $crate::GetFut for Impl {
            type Input = $ity;
            type Output = $oty;
            fn get_fut<$a>(self, $input: &$a mut Self::Input) -> impl $a+Future<Output = Self::Output> {
                $($v)+
            }
        }
        Impl
    }};
}

/// A macro for quickly implementing [`crate::TryGetFut`] without capturing.
///
/// If you need capturing, you will have to manually capture what you want in a user-defined struct
/// and implement [`crate::TryGetFut`] for that struct.
#[macro_export]
macro_rules! try_get {
    (fn($input:ident: &mut $ity:ty) -> Result<($oty:ty, $aty:ty), $ety:ty> { $($v:tt)+ }) => {{
        $crate::try_get!(fn<'a>($input: &mut $ity) -> Result<($oty, $aty), $ety> {$($v)+})
    }};
    (fn<$a:lifetime>($input:ident: &mut $ity:ty) -> Result<($oty:ty, $aty:ty), $ety:ty> { $($v:tt)+ }) => {{
        #[derive(Clone, Copy)]
        struct Impl;
        impl $crate::TryGetFut for Impl {
            type Input = $ity;
            type Output = $oty;
            type Aux = $aty;
            type Error = $ety;
            fn try_get_fut<$a>(self, $input: &$a mut Self::Input) -> Result<(impl $a+Future<Output = Self::Output>, Self::Aux), Self::Error> {
                $($v)+
            }
        }
        Impl
    }};
}

/// A macro for quickly implementing [`crate::AsyncTryGetFut`] without capturing.
///
/// If you need capturing, you will have to manually capture what you want in a user-defined struct
/// and implement [`crate::AsyncTryGetFut`] for that struct.
#[cfg(feature = "async")]
#[macro_export]
macro_rules! async_try_get {
    (async fn($input:ident: &mut $ity:ty) -> Result<($oty:ty, $aty:ty), $ety:ty> { $($v:tt)+ }) => {{
        $crate::async_try_get!(async fn<'a, 'b>($input: &mut $ity) -> Result<($oty, $aty), $ety> {$($v)+})
    }};
    (async fn<$a:lifetime, $b:lifetime>($input:ident: &mut $ity:ty) -> Result<($oty:ty, $aty:ty), $ety:ty> { $($v:tt)+ }) => {{
        #[derive(Clone, Copy)]
        struct Impl;
        impl<$a> $crate::AsyncTryGetFut<$a> for Impl {
            type Input = $ity;
            type Output = $oty;
            type Aux = $aty;
            type Error = $ety;
            async fn async_try_get_fut<$b>(self, $input: &$b mut Self::Input) -> Result<(impl $b+Future<Output = Self::Output>, Self::Aux), Self::Error> {

                $($v)+
            }
        }
        Impl
    }};
}
/// A macro for quickly implementing [`crate::AsyncSendTryGetFut`] without capturing.
///
/// If you need capturing, you will have to manually capture what you want in a user-defined struct
/// and implement [`crate::AsyncSendTryGetFut`] for that struct.
///
/// For now this has to use `Pin<Box<dyn Future>>` due a compiler bug
/// ([rust-lang/rust#100013](https://github.com/rust-lang/rust/issues/100013)).This will
/// change in a future release when this bug is fixed.
#[cfg(feature = "async")]
#[macro_export]
macro_rules! async_send_try_get {
    (fn($input:ident: &mut $ity:ty) -> Result<($oty:ty, $aty:ty), $ety:ty> { $($v:tt)+ }) => {{
        $crate::async_send_try_get!(fn<'a, 'b>($input: &mut $ity) -> Result<($oty, $aty), $ety> {$($v)+})
    }};
    (fn<$a:lifetime, $b:lifetime>($input:ident: &mut $ity:ty) -> Result<($oty:ty, $aty:ty), $ety:ty> { $($v:tt)+ }) => {{

        use alloc::boxed::Box;
        use core::pin::Pin;

        #[derive(Clone, Copy)]
        struct Impl;
        impl<$a> $crate::AsyncSendTryGetFut<$a> for Impl {
            type Input = $ity;
            type Output = $oty;
            type Aux = $aty;
            type Error = $ety;
            fn async_send_try_get_fut<$b>(self, $input: &$b mut Self::Input) -> Pin<Box<dyn $b + Send + Future<Output = Result<(Pin<Box<dyn $b + Send + Future<Output = Self::Output>>>, Self::Aux), Self::Error>>>> {
                Box::pin({$($v)+})
            }
        }
        Impl
    }};
}