async_closure 0.1.2

This crate utilizes the nightly-only feature async_fn_in_trait to imitate async_closures.
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

//! Traits that can be written in trait bounds on the callers of
//! async closures **carrying temporary lifetimes**.

/// The type implemented with this trait can be only used once
/// with its states obtained **by value**.
#[doc = include_str!("./doc/trait/lifetimes_fnonce.md")]
pub trait AsyncFnOnce<'env, Args> {
    type Output;
    async fn call_once(self, args: Args) -> Self::Output;
}

/// The type implemented with this trait can be used multiple
/// times with its states obtained by **exclusive** references.
#[doc = include_str!("./doc/trait/lifetimes_fnmut.md")]
pub trait AsyncFnMut<'env, Args>: AsyncFnOnce<'env, Args> {
    async fn call_mut(&mut self, args: Args) -> Self::Output;
}

/// The type implemented with this trait can be used multiple
/// times with its states obtained by **shared** references.
#[doc = include_str!("./doc/trait/lifetimes_fn.md")]
pub trait AsyncFn<'env, Args>: AsyncFnMut<'env, Args> {
    async fn call(&self, args: Args) -> Self::Output;
}

/// Generate a value that is of unnamed closure type implemented with
/// [`AsyncFnOnce`].
#[doc = include_str!("./doc/macro_syntax.md")]
#[doc = include_str!("./doc/macro/lifetimes_details.md")]
#[doc = include_str!("./doc/macro/lifetimes_examples_once.md")]
#[macro_export]
macro_rules! async_closure_once {
    (
        { $( $field:ident : $t:ty  = $init:expr ),* $(,)? };
        async | $( $args:ident  : $a:ty ),* $(,)? | -> $out:ty
        $e:block
    ) => {{
        struct __AsyncClosure<'a> {
            $( pub $field: $t , )*
            _ph: ::std::marker::PhantomData<&'a ()>,
        }
        impl<'a> $crate::capture_lifetimes::AsyncFnOnce<'a, ( $($a,)* )> for __AsyncClosure<'a> {
            type Output = $out;
            async fn call_once(self, __args: ( $($a,)* )) -> $out {
                let Self { $( $field , )* .. } = self;
                #[allow(unused_parens)]
                let ( $( $args ,)*  ) = __args;
                $e
            }
        }
        #[allow(clippy::redundant_field_names)]
        __AsyncClosure { $($field: $init , )* _ph: ::std::marker::PhantomData }
    }};
}

/// Generate a value that is of unnamed closure type implemented with
/// [`AsyncFnMut`].
#[doc = include_str!("./doc/macro_syntax.md")]
#[doc = include_str!("./doc/macro/lifetimes_details.md")]
#[doc = include_str!("./doc/macro/lifetimes_examples_mut.md")]
#[macro_export]
macro_rules! async_closure_mut {
    (
        { $( $field:ident : $t:ty  = $init:expr ),* $(,)? };
        async | $( $args:ident  : $a:ty ),* $(,)? | -> $out:ty
        $e:block
    ) => {{
        struct __AsyncClosure<'a> {
            $( pub $field: $t , )*
            _ph: ::std::marker::PhantomData<&'a ()>,
        }
        impl<'a> $crate::capture_lifetimes::AsyncFnOnce<'a, ( $($a,)* )> for __AsyncClosure<'a> {
            type Output = $out;
            async fn call_once(mut self, __args: ( $($a,)* )) -> $out {
                <Self as $crate::capture_lifetimes::AsyncFnMut<'a, ( $($a,)* )>>::call_mut(&mut self, __args).await
            }
        }
        impl<'a> $crate::capture_lifetimes::AsyncFnMut<'a, ( $($a,)* )> for __AsyncClosure<'a> {
            async fn call_mut(&mut self, __args: ( $($a,)* )) -> $out {
                let Self { $( $field , )* .. } = self;
                #[allow(unused_parens)]
                let ( $( $args ,)*  ) = __args;
                $e
            }
        }
        #[allow(clippy::redundant_field_names)]
        __AsyncClosure { $($field: $init , )* _ph: ::std::marker::PhantomData }
    }};
}

/// Generate a value that is of unnamed closure type implemented with
/// [`AsyncFn`].
#[doc = include_str!("./doc/macro_syntax.md")]
#[doc = include_str!("./doc/macro/lifetimes_details.md")]
#[doc = include_str!("./doc/macro/lifetimes_examples_fn.md")]
#[macro_export]
macro_rules! async_closure {
    (
        { $( $field:ident : $t:ty  = $init:expr ),* $(,)? };
        async | $( $args:ident  : $a:ty ),* $(,)? | -> $out:ty
        $e:block
    ) => {{
        struct __AsyncClosure<'a> {
            $( pub $field: $t , )*
            _ph: ::std::marker::PhantomData<&'a ()>,
        }
        impl<'a> $crate::capture_lifetimes::AsyncFnOnce<'a, ( $($a,)* )> for __AsyncClosure<'a> {
            type Output = $out;
            async fn call_once(self, __args: ( $($a,)* )) -> $out {
                <Self as $crate::capture_lifetimes::AsyncFn<'a, ( $($a,)* )>>::call(&self, __args).await
            }
        }
        impl<'a> $crate::capture_lifetimes::AsyncFnMut<'a, ( $($a,)* )> for __AsyncClosure<'a> {
            async fn call_mut(&mut self, __args: ( $($a,)* )) -> $out {
                <Self as $crate::capture_lifetimes::AsyncFn<'a, ( $($a,)* )>>::call(&*self, __args).await
            }
        }
        impl<'a> $crate::capture_lifetimes::AsyncFn<'a, ( $($a,)* )> for __AsyncClosure<'a> {
            async fn call(&self, __args: ( $($a,)* )) -> $out {
                let Self { $( $field , )* .. } = self;
                #[allow(unused_parens)]
                let ( $( $args ,)* ) = __args;
                $e
            }
        }
        #[allow(clippy::redundant_field_names)]
        __AsyncClosure { $($field: $init , )* _ph: ::std::marker::PhantomData }
    }};
}