awaiter_trait/
lib.rs

1#![no_std]
2
3use core::pin::Pin;
4pub mod r#dyn;
5use r#dyn::*;
6#[cfg(feature = "embedded-io")]
7pub mod io;
8pub trait Awaiter: AwaiterMut + UnsafeAwaiter {
9    fn r#await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T;
10}
11
12pub trait AwaiterMut: UnsafeAwaiterMut {
13    fn await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T;
14}
15
16pub trait UnsafeAwaiter: UnsafeAwaiterMut {
17    unsafe fn unsafe_await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T;
18}
19pub trait UnsafeAwaiterMut {
20    unsafe fn unsafe_await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T;
21}
22#[doc(hidden)]
23pub mod __ {
24    pub use core;
25}
26#[macro_export]
27macro_rules! autoimpl {
28    (<$($g:ident $(: $b:path)? ),*> $t:ty as Awaiter) => {
29        const _: () = {
30            impl<$($g $(: $b)? ),*> $crate::AwaiterMut for $t{
31                fn await_mut<T>(&mut self, f: $crate::__::core::pin::Pin<&mut (dyn $crate::__::core::future::Future<Output = T> + '_)>) -> T{
32                    <Self as $crate::Awaiter>::r#await(self,f)
33                }
34            }
35            impl<$($g $(: $b)? ),*> $crate::UnsafeAwaiter for $t{
36                unsafe fn unsafe_await<T>(&self, f: $crate::__::core::pin::Pin<&mut (dyn $crate::__::core::future::Future<Output = T> + '_)>) -> T{
37                    <Self as $crate::Awaiter>::r#await(self,f)
38                }
39            }
40            $crate::autoimpl!(<$($g $(: $b)? ),*> $t as AwaiterMut);
41
42        };
43    };
44    (<$($g:ident $(: $b:path)? ),*> $t:ty as UnsafeAwaiter) => {
45        const _: () = {
46            impl<$($g $(: $b)? ),*> $crate::UnsafeAwaiterMut for $t{
47                unsafe fn unsafe_await_mut<T>(&mut self, f: $crate::__::core::pin::Pin<&mut (dyn $crate::__::core::future::Future<Output = T> + '_)>) -> T{
48                    unsafe{
49                        <Self as $crate::UnsafeAwaiter>::unsafe_await(self,f)
50                    }
51                }
52            }
53        };
54    };
55    (<$($g:ident $(: $b:path)? ),*> $t:ty as AwaiterMut) => {
56        const _: () = {
57            impl<$($g $(: $b)? ),*> $crate::UnsafeAwaiterMut for $t{
58                unsafe fn unsafe_await_mut<T>(&mut self, f: $crate::__::core::pin::Pin<&mut (dyn $crate::__::core::future::Future<Output = T> + '_)>) -> T{
59                   <Self as $crate::AwaiterMut>::await_mut(self,f)
60                }
61            }
62        };
63    };
64    (<$($g:ident $(: $b:path)? ),*> $t:ty as UnsafeCoroutineMut) => {
65        const _: () = {
66            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineMutSelfMut for $t{
67                unsafe fn unsafe_exec_mut_self_mut<T>(
68                    &mut self,
69                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynUnsafeAwaiterMut + '_)) -> T,
70                ) -> impl $crate::__::core::future::Future<Output = T>{
71                    unsafe{
72                        <Self as $crate::UnsafeCoroutineMut>::unsafe_exec_mut(self,move|a|f(a))
73                    }
74                }
75            }
76        };
77    };
78    (<$($g:ident $(: $b:path)? ),*> $t:ty as UnsafeCoroutineSelfMut) => {
79        const _: () = {
80            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineMutSelfMut for $t{
81                unsafe fn unsafe_exec_mut_self_mut<T>(
82                    &mut self,
83                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynUnsafeAwaiterMut + '_)) -> T,
84                ) -> impl $crate::__::core::future::Future<Output = T>{
85                    unsafe{
86                        <Self as $crate::UnsafeCoroutineSelfMut>::unsafe_exec_self_mut(self,move|mut a|f(&mut a))
87                    }
88                }
89            }
90        };
91    };
92    (<$($g:ident $(: $b:path)? ),*> $t:ty as CoroutineMutSelfMut) => {
93        const _: () = {
94            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineMutSelfMut for $t{
95                unsafe fn unsafe_exec_mut_self_mut<T>(
96                    &mut self,
97                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynUnsafeAwaiterMut + '_)) -> T,
98                ) -> impl $crate::__::core::future::Future<Output = T>{
99                    unsafe{
100                        <Self as $crate::CoroutineMutSelfMut>::exec_mut_self_mut(self,move|a|f(a))
101                    }
102                }
103            }
104        };
105    };
106    (<$($g:ident $(: $b:path)? ),*> $t:ty as UnsafeCoroutine) => {
107        const _: () = {
108            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineMut for $t{
109                unsafe fn unsafe_exec_mut<T>(
110                    &self,
111                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynUnsafeAwaiterMut + '_)) -> T,
112                ) -> impl $crate::__::core::future::Future<Output = T>{
113                    unsafe{
114                        <Self as $crate::UnsafeCoroutine>::unsafe_exec(self,move|a|f(a))
115                    }
116                }
117            }
118            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineSelfMut for $t{
119                unsafe fn unsafe_exec_self_mut<T>(
120                    &mut self,
121                    f: impl FnOnce(& (dyn $crate::r#dyn::DynUnsafeAwaiter + '_)) -> T,
122                ) -> impl $crate::__::core::future::Future<Output = T>{
123                    unsafe{
124                        <Self as $crate::UnsafeCoroutine>::unsafe_exec(self,move|a|f(a))
125                    }
126                }
127            }
128            $crate::autoimpl!(<$($g $(: $b)? ),*> $t as UnsafeCoroutineMut);
129        };
130    };
131    (<$($g:ident $(: $b:path)? ),*> $t:ty as CoroutineMut) => {
132        const _: () = {
133            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineMut for $t{
134                unsafe fn unsafe_exec_mut<T>(
135                    &self,
136                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynUnsafeAwaiterMut + '_)) -> T,
137                ) -> impl $crate::__::core::future::Future<Output = T>{
138                    unsafe{
139                        <Self as $crate::CoroutineMut>::exec_mut(self,move|a|f(a))
140                    }
141                }
142            }
143            impl<$($g $(: $b)? ),*> $crate::CoroutineMutSelfMut for $t{
144                fn exec_mut_self_mut<T>(
145                    &mut self,
146                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynAwaiterMut + '_)) -> T,
147                ) -> impl $crate::__::core::future::Future<Output = T>{
148                    // unsafe{
149                        <Self as $crate::CoroutineMut>::exec_mut(self,move|a|f(a))
150                    // }
151                }
152            }
153            $crate::autoimpl!(<$($g $(: $b)? ),*> $t as UnsafeCoroutineMut);
154        };
155    };
156    (<$($g:ident $(: $b:path)? ),*> $t:ty as CoroutineSelfMut) => {
157        const _: () = {
158
159            impl<$($g $(: $b)? ),*> $crate::CoroutineMutSelfMut for $t{
160                fn exec_mut_self_mut<T>(
161                    &mut self,
162                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynAwaiterMut + '_)) -> T,
163                ) -> impl $crate::__::core::future::Future<Output = T>{
164                    // unsafe{
165                        <Self as $crate::CoroutineSelfMut>::exec_self_mut(self,move|a|f(a))
166                    // }
167                }
168            }
169            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineSelfMut for $t{
170                unsafe fn unsafe_exec_self_mut<T>(
171                    &mut self,
172                    f: impl FnOnce(& (dyn $crate::r#dyn::DynUnsafeAwaiter + '_)) -> T,
173                ) -> impl $crate::__::core::future::Future<Output = T>{
174                    unsafe{
175                        <Self as $crate::CoroutineSelfMut>::exec_self_mut(self,move|a|f(a))
176                    }
177                }
178            }
179            $crate::autoimpl!(<$($g $(: $b)? ),*> $t as CoroutineMutSelfMut);
180        };
181    };
182    (<$($g:ident $(: $b:path)? ),*> $t:ty as Coroutine) => {
183        const _: () = {
184            impl<$($g $(: $b)? ),*> $crate::CoroutineMut for $t{
185                fn exec_mut<T>(
186                    &self,
187                    f: impl FnOnce(&mut (dyn $crate::r#dyn::DynAwaiterMut + '_)) -> T,
188                ) -> impl $crate::__::core::future::Future<Output = T>{
189                    unsafe{
190                        <Self as $crate::Coroutine>::exec(self,move|mut a|f(&mut a))
191                    }
192                }
193            }
194            impl<$($g $(: $b)? ),*> $crate::CoroutineSelfMut for $t{
195                fn exec_self_mut<T>(
196                    &mut self,
197                    f: impl FnOnce(& (dyn $crate::r#dyn::DynAwaiter + '_)) -> T,
198                ) -> impl $crate::__::core::future::Future<Output = T>{
199                    // unsafe{
200                        <Self as $crate::Coroutine>::exec(self,move|a|f(a))
201                    // }
202                }
203            }
204            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutine for $t{
205                unsafe fn unsafe_exec<T>(
206                    &self,
207                    f: impl FnOnce(& (dyn $crate::r#dyn::DynUnsafeAwaiter + '_)) -> T,
208                ) -> impl $crate::__::core::future::Future<Output = T>{
209                    unsafe{
210                        <Self as $crate::Coroutine>::exec(self,move|a|f(a))
211                    }
212                }
213            }
214            impl<$($g $(: $b)? ),*> $crate::UnsafeCoroutineSelfMut for $t{
215                unsafe fn unsafe_exec_self_mut<T>(
216                    &mut self,
217                    f: impl FnOnce(& (dyn $crate::r#dyn::DynUnsafeAwaiter + '_)) -> T,
218                ) -> impl $crate::__::core::future::Future<Output = T>{
219                    unsafe{
220                        <Self as $crate::UnsafeCoroutine>::unsafe_exec(self,move|a|f(a))
221                    }
222                }
223            }
224            $crate::autoimpl!(<$($g $(: $b)? ),*> $t as CoroutineMut);
225            // $crate::autoimpl!(<$($g $(: $b)? ),*> $t as UnsafeCoroutineSelfMut);
226        };
227    };
228}
229impl<'a, T2: Awaiter + ?Sized> Awaiter for &'a T2 {
230    fn r#await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
231        (&**self).r#await(f)
232    }
233}
234impl<'a, T2: Awaiter + ?Sized> Awaiter for &'a mut T2 {
235    fn r#await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
236        (&**self).r#await(f)
237    }
238}
239impl<'a, T2: Awaiter + ?Sized> AwaiterMut for &'a T2 {
240    fn await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
241        (&**self).r#await(f)
242    }
243}
244impl<'a, T2: AwaiterMut + ?Sized> AwaiterMut for &'a mut T2 {
245    fn await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
246        (&mut **self).await_mut(f)
247    }
248}
249impl<'a, T2: UnsafeAwaiter + ?Sized> UnsafeAwaiter for &'a T2 {
250    unsafe fn unsafe_await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
251        unsafe { (&**self).unsafe_await(f) }
252    }
253}
254impl<'a, T2: UnsafeAwaiter + ?Sized> UnsafeAwaiter for &'a mut T2 {
255    unsafe fn unsafe_await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
256        unsafe { (&**self).unsafe_await(f) }
257    }
258}
259impl<'a, T2: UnsafeAwaiter + ?Sized> UnsafeAwaiterMut for &'a T2 {
260    unsafe fn unsafe_await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
261        unsafe { (&**self).unsafe_await(f) }
262    }
263}
264impl<'a, T2: UnsafeAwaiterMut + ?Sized> UnsafeAwaiterMut for &'a mut T2 {
265    unsafe fn unsafe_await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
266        unsafe { (&mut **self).unsafe_await_mut(f) }
267    }
268}
269impl<T2: UnsafeAwaiter + ?Sized> UnsafeAwaiter for *const T2 {
270    unsafe fn unsafe_await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
271        unsafe { (&**self).unsafe_await(f) }
272    }
273}
274impl<T2: UnsafeAwaiter + ?Sized> UnsafeAwaiter for *mut T2 {
275    unsafe fn unsafe_await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
276        unsafe { (&**self).unsafe_await(f) }
277    }
278}
279impl<T2: UnsafeAwaiter + ?Sized> UnsafeAwaiterMut for *const T2 {
280    unsafe fn unsafe_await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
281        unsafe { (&**self).unsafe_await(f) }
282    }
283}
284impl<T2: UnsafeAwaiterMut + ?Sized> UnsafeAwaiterMut for *mut T2 {
285    unsafe fn unsafe_await_mut<T>(&mut self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
286        unsafe { (&mut **self).unsafe_await_mut(f) }
287    }
288}
289pub trait UnsafeCoroutineMut: UnsafeCoroutineMutSelfMut {
290    unsafe fn unsafe_exec_mut<T>(
291        &self,
292        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
293    ) -> impl Future<Output = T>;
294}
295pub trait CoroutineMut: UnsafeCoroutineMut + CoroutineMutSelfMut {
296    fn exec_mut<T>(
297        &self,
298        f: impl FnOnce(&mut (dyn DynAwaiterMut + '_)) -> T,
299    ) -> impl Future<Output = T>;
300}
301pub trait UnsafeCoroutine: UnsafeCoroutineMut + UnsafeCoroutineSelfMut {
302    unsafe fn unsafe_exec<T>(
303        &self,
304        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
305    ) -> impl Future<Output = T>;
306}
307pub trait Coroutine: UnsafeCoroutine + CoroutineMut + CoroutineSelfMut {
308    fn exec<T>(&self, f: impl FnOnce(&(dyn DynAwaiter + '_)) -> T) -> impl Future<Output = T>;
309}
310pub trait UnsafeCoroutineMutSelfMut {
311    unsafe fn unsafe_exec_mut_self_mut<T>(
312        &mut self,
313        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
314    ) -> impl Future<Output = T>;
315}
316pub trait CoroutineMutSelfMut: UnsafeCoroutineMutSelfMut {
317    fn exec_mut_self_mut<T>(
318        &mut self,
319        f: impl FnOnce(&mut (dyn DynAwaiterMut + '_)) -> T,
320    ) -> impl Future<Output = T>;
321}
322pub trait UnsafeCoroutineSelfMut: UnsafeCoroutineMutSelfMut {
323    unsafe fn unsafe_exec_self_mut<T>(
324        &mut self,
325        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
326    ) -> impl Future<Output = T>;
327}
328pub trait CoroutineSelfMut: UnsafeCoroutineSelfMut + CoroutineMutSelfMut {
329    fn exec_self_mut<T>(
330        &mut self,
331        f: impl FnOnce(&(dyn DynAwaiter + '_)) -> T,
332    ) -> impl Future<Output = T>;
333}
334impl<'a, T2: UnsafeCoroutineMut + ?Sized> UnsafeCoroutineMut for &'a T2 {
335    unsafe fn unsafe_exec_mut<T>(
336        &self,
337        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
338    ) -> impl Future<Output = T> {
339        (&**self).unsafe_exec_mut(f)
340    }
341}
342impl<'a, T2: UnsafeCoroutineMut + ?Sized> UnsafeCoroutineMut for &'a mut T2 {
343    unsafe fn unsafe_exec_mut<T>(
344        &self,
345        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
346    ) -> impl Future<Output = T> {
347        (&**self).unsafe_exec_mut(f)
348    }
349}
350impl<'a, T2: UnsafeCoroutineMut + ?Sized> UnsafeCoroutineMutSelfMut for &'a T2 {
351    unsafe fn unsafe_exec_mut_self_mut<T>(
352        &mut self,
353        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
354    ) -> impl Future<Output = T> {
355        (&**self).unsafe_exec_mut(f)
356    }
357}
358impl<'a, T2: UnsafeCoroutineMutSelfMut + ?Sized> UnsafeCoroutineMutSelfMut for &'a mut T2 {
359    unsafe fn unsafe_exec_mut_self_mut<T>(
360        &mut self,
361        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
362    ) -> impl Future<Output = T> {
363        (&mut **self).unsafe_exec_mut_self_mut(f)
364    }
365}
366impl<'a, T2: UnsafeCoroutine + ?Sized> UnsafeCoroutine for &'a T2 {
367    unsafe fn unsafe_exec<T>(
368        &self,
369        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
370    ) -> impl Future<Output = T> {
371        (&**self).unsafe_exec(f)
372    }
373}
374impl<'a, T2: UnsafeCoroutine + ?Sized> UnsafeCoroutine for &'a mut T2 {
375    unsafe fn unsafe_exec<T>(
376        &self,
377        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
378    ) -> impl Future<Output = T> {
379        (&**self).unsafe_exec(f)
380    }
381}
382impl<'a, T2: UnsafeCoroutine + ?Sized> UnsafeCoroutineSelfMut for &'a T2 {
383    unsafe fn unsafe_exec_self_mut<T>(
384        &mut self,
385        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
386    ) -> impl Future<Output = T> {
387        (&**self).unsafe_exec(f)
388    }
389}
390impl<'a, T2: UnsafeCoroutineSelfMut + ?Sized> UnsafeCoroutineSelfMut for &'a mut T2 {
391    unsafe fn unsafe_exec_self_mut<T>(
392        &mut self,
393        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
394    ) -> impl Future<Output = T> {
395        (&mut **self).unsafe_exec_self_mut(f)
396    }
397}
398
399impl<'a, T2: CoroutineMut + ?Sized> CoroutineMut for &'a T2 {
400    fn exec_mut<T>(
401        &self,
402        f: impl FnOnce(&mut (dyn DynAwaiterMut + '_)) -> T,
403    ) -> impl Future<Output = T> {
404        (&**self).exec_mut(f)
405    }
406}
407impl<'a, T2: CoroutineMut + ?Sized> CoroutineMut for &'a mut T2 {
408    fn exec_mut<T>(
409        &self,
410        f: impl FnOnce(&mut (dyn DynAwaiterMut + '_)) -> T,
411    ) -> impl Future<Output = T> {
412        (&**self).exec_mut(f)
413    }
414}
415impl<'a, T2: CoroutineMut + ?Sized> CoroutineMutSelfMut for &'a T2 {
416    fn exec_mut_self_mut<T>(
417        &mut self,
418        f: impl FnOnce(&mut (dyn DynAwaiterMut + '_)) -> T,
419    ) -> impl Future<Output = T> {
420        (&**self).exec_mut(f)
421    }
422}
423impl<'a, T2: CoroutineMutSelfMut + ?Sized> CoroutineMutSelfMut for &'a mut T2 {
424    fn exec_mut_self_mut<T>(
425        &mut self,
426        f: impl FnOnce(&mut (dyn DynAwaiterMut + '_)) -> T,
427    ) -> impl Future<Output = T> {
428        (&mut **self).exec_mut_self_mut(f)
429    }
430}
431impl<'a, T2: Coroutine + ?Sized> Coroutine for &'a T2 {
432    fn exec<T>(&self, f: impl FnOnce(&(dyn DynAwaiter + '_)) -> T) -> impl Future<Output = T> {
433        (&**self).exec(f)
434    }
435}
436impl<'a, T2: Coroutine + ?Sized> Coroutine for &'a mut T2 {
437    fn exec<T>(&self, f: impl FnOnce(&(dyn DynAwaiter + '_)) -> T) -> impl Future<Output = T> {
438        (&**self).exec(f)
439    }
440}
441impl<'a, T2: Coroutine + ?Sized> CoroutineSelfMut for &'a T2 {
442    fn exec_self_mut<T>(
443        &mut self,
444        f: impl FnOnce(&(dyn DynAwaiter + '_)) -> T,
445    ) -> impl Future<Output = T> {
446        (&**self).exec(f)
447    }
448}
449impl<'a, T2: CoroutineSelfMut + ?Sized> CoroutineSelfMut for &'a mut T2 {
450    fn exec_self_mut<T>(
451        &mut self,
452        f: impl FnOnce(&(dyn DynAwaiter + '_)) -> T,
453    ) -> impl Future<Output = T> {
454        (&mut **self).exec_self_mut(f)
455    }
456}
457
458impl<T2: UnsafeCoroutineMut + ?Sized> UnsafeCoroutineMut for *const T2 {
459    unsafe fn unsafe_exec_mut<T>(
460        &self,
461        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
462    ) -> impl Future<Output = T> {
463        (&**self).unsafe_exec_mut(f)
464    }
465}
466impl<T2: UnsafeCoroutineMut + ?Sized> UnsafeCoroutineMut for *mut T2 {
467    unsafe fn unsafe_exec_mut<T>(
468        &self,
469        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
470    ) -> impl Future<Output = T> {
471        (&**self).unsafe_exec_mut(f)
472    }
473}
474impl<T2: UnsafeCoroutineMut + ?Sized> UnsafeCoroutineMutSelfMut for *const T2 {
475    unsafe fn unsafe_exec_mut_self_mut<T>(
476        &mut self,
477        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
478    ) -> impl Future<Output = T> {
479        (&**self).unsafe_exec_mut(f)
480    }
481}
482impl<T2: UnsafeCoroutineMutSelfMut + ?Sized> UnsafeCoroutineMutSelfMut for *mut T2 {
483    unsafe fn unsafe_exec_mut_self_mut<T>(
484        &mut self,
485        f: impl FnOnce(&mut (dyn DynUnsafeAwaiterMut + '_)) -> T,
486    ) -> impl Future<Output = T> {
487        (&mut **self).unsafe_exec_mut_self_mut(f)
488    }
489}
490impl<T2: UnsafeCoroutine + ?Sized> UnsafeCoroutine for *const T2 {
491    unsafe fn unsafe_exec<T>(
492        &self,
493        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
494    ) -> impl Future<Output = T> {
495        (&**self).unsafe_exec(f)
496    }
497}
498impl<T2: UnsafeCoroutine + ?Sized> UnsafeCoroutine for *mut T2 {
499    unsafe fn unsafe_exec<T>(
500        &self,
501        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
502    ) -> impl Future<Output = T> {
503        (&**self).unsafe_exec(f)
504    }
505}
506impl<T2: UnsafeCoroutine + ?Sized> UnsafeCoroutineSelfMut for *const T2 {
507    unsafe fn unsafe_exec_self_mut<T>(
508        &mut self,
509        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
510    ) -> impl Future<Output = T> {
511        (&**self).unsafe_exec(f)
512    }
513}
514impl<T2: UnsafeCoroutineSelfMut + ?Sized> UnsafeCoroutineSelfMut for *mut T2 {
515    unsafe fn unsafe_exec_self_mut<T>(
516        &mut self,
517        f: impl FnOnce(&(dyn DynUnsafeAwaiter + '_)) -> T,
518    ) -> impl Future<Output = T> {
519        (&mut **self).unsafe_exec_self_mut(f)
520    }
521}
awaiter_trait/lib.rs

awaiter_trait/
lib.rs
