fast_async_trait 0.1.1

Fast async traits for 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
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

#![feature(type_alias_impl_trait)]
use fast_async_trait::*;

#[async_trait_def]
pub trait AsyncTrait {
    type Item;

    async fn owned (self) -> Option<Self::Item>;
    async fn by_ref (&self) -> Option<Self::Item>;
    async fn by_mut (&mut self) -> Option<Self::Item>;
    fn regular_method (&self) -> u8;
    
    #[inline]
    async fn owned_default (self, _n: usize) -> Option<Self::Item> where Self: Sized {
        return self.owned().await
    }

    #[inline]
    async fn by_ref_default (&self, n: usize) -> Option<Self::Item> {
        for _ in 0..n {
            let _ = self.by_ref().await;
        }
        return self.by_ref().await
    }

    #[inline]
    async fn by_mut_default (&mut self, n: usize) -> Option<Self::Item> {
        for _ in 0..n {
            let _ = self.by_mut().await;
        }
        return self.by_mut().await
    }
}

#[async_trait_impl]
impl AsyncTrait for (usize, &[u8]) {
    type Item = u8;

    #[inline]
    async fn owned (self) -> Option<Self::Item> {
        return self.1.get(self.0).copied()
    }

    #[inline]
    async fn by_ref (&self) -> Option<Self::Item> {
        return self.1.get(self.0).copied()
    }

    #[inline]
    async fn by_mut (&mut self) -> Option<Self::Item> {
        return self.1.get(self.0).copied()
    }

    #[inline]
    fn regular_method (&self) -> u8 {
        return 32u8;
    }
}

/*#[async_trait_impl]
impl AsyncIterator for (usize, &[u16]) {
    type Item = u16;

    #[inline]
    async fn owned (self) -> Option<Self::Item> {
        return self.1.get(self.0).copied()
    }

    #[inline]
    async fn by_ref (&self) -> Option<Self::Item> {
        return self.1.get(self.0).copied()
    }

    #[inline]
    async fn by_mut (&mut self) -> Option<Self::Item> {
        return self.1.get(self.0).copied()
    }

    #[inline]
    async fn by_mut_default (&mut self, n: usize) -> Option<Self::Item> {
        return self.by_mut().await;
    }
}*/

/*type AsyncIteratorAdderDefault<'a, This: 'a + ?Sized + AsyncIterator> = impl 'a + ::core::future::Future;

pub trait AsyncIterator {
    type Item;
    type Next<'__self__>: '__self__ + ::core::future::Future<Output = Option<Self::Item>> where Self: '__self__;
    type Nth<'__self__>: 
        '__self__ + ::core::future::Future<Output = <AsyncIteratorAdderDefault<'__self__, Self> as ::core::future::Future>::Output> = AsyncIteratorAdderDefault<'__self__, Self>
        where Self: '__self__;

    fn next<'__self__>(&'__self__ mut self) -> Self::Next<'__self__> where Self: '__self__;

    #[inline]
    fn nth<'__self__>(
        &'__self__ mut self,
        n: usize,
    ) -> AsyncIteratorAdderDefault<'__self__, Self>
    where
        Self: '__self__,
    {
        return async move {
            for _ in 0..n {
                let _ = self.next().await;
            }
            return self.next().await;
        }
    }
}*/

/*impl<I: Iterator> AsyncIterator for I {
    type Item = I::Item;
    type Next<'a> = core::future::Ready<Option<I::Item>> where Self: 'a;

    #[inline]
    fn next<'a> (&'a mut self) -> Self::Next<'a> where Self: 'a {
        return core::future::ready(<Self as Iterator>::next(self))
    }
}

pub struct AsyncMap<I, F> {
    iter: I,
    f: F
}

#[async_trait_impl]
impl<I: AsyncIterator, F: FnMut(I::Item) -> Fut, Fut: Future> AsyncIterator for AsyncMap<I, F> {
    type Item = Fut::Output;

    #[inline]
    async fn next (&mut self) -> Option<Self::Item> {
        let v = self.iter.next().await?;
        return Some((self.f)(v).await)
    }
}

#[cfg(test)]
mod tests {
    fn assert_send<T: Send> (_t: &T) {}

    #[test]
    fn test () {
        let fut = [1, 2, 3];
        assert_send(t);
    }
}*/