Trait AsyncFunc 

pub trait AsyncFunc<Args, Ret> {
    // Required method
    fn call<'a, 'async_trait>(
        &'a self,
        args: Args,
    ) -> Pin<Box<dyn Future<Output = Ret> + Send + 'async_trait>>
       where Args: 'a,
             Ret: 'a,
             Self: 'async_trait,
             'a: 'async_trait;
}

Required Methods

fn call<'a, 'async_trait>( &'a self, args: Args, ) -> Pin<Box<dyn Future<Output = Ret> + Send + 'async_trait>>

where Args: 'a, Ret: 'a, Self: 'async_trait, 'a: 'async_trait,

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<Function, A, B, C, D, E, F, G, H, I, J, K, L, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I, J, K, L), Ret> for Function

where Function: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send, G: Send, H: Send, I: Send, J: Send, K: Send, L: Send,

impl<Function, A, B, C, D, E, F, G, H, I, J, K, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I, J, K), Ret> for Function

where Function: Fn(A, B, C, D, E, F, G, H, I, J, K) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send, G: Send, H: Send, I: Send, J: Send, K: Send,

impl<Function, A, B, C, D, E, F, G, H, I, J, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I, J), Ret> for Function

where Function: Fn(A, B, C, D, E, F, G, H, I, J) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send, G: Send, H: Send, I: Send, J: Send,

impl<Function, A, B, C, D, E, F, G, H, I, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I), Ret> for Function

where Function: Fn(A, B, C, D, E, F, G, H, I) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send, G: Send, H: Send, I: Send,

impl<Function, A, B, C, D, E, F, G, H, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H), Ret> for Function

where Function: Fn(A, B, C, D, E, F, G, H) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send, G: Send, H: Send,

impl<Function, A, B, C, D, E, F, G, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G), Ret> for Function

where Function: Fn(A, B, C, D, E, F, G) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send, G: Send,

impl<Function, A, B, C, D, E, F, Ret, Fut> AsyncFunc<(A, B, C, D, E, F), Ret> for Function

where Function: Fn(A, B, C, D, E, F) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send, F: Send,

impl<Function, A, B, C, D, E, Ret, Fut> AsyncFunc<(A, B, C, D, E), Ret> for Function

where Function: Fn(A, B, C, D, E) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send, E: Send,

impl<Function, A, B, C, D, Ret, Fut> AsyncFunc<(A, B, C, D), Ret> for Function

where Function: Fn(A, B, C, D) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send, D: Send,

impl<Function, A, B, C, Ret, Fut> AsyncFunc<(A, B, C), Ret> for Function

where Function: Fn(A, B, C) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send, C: Send,

impl<Function, A, B, Ret, Fut> AsyncFunc<(A, B), Ret> for Function

where Function: Fn(A, B) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send, B: Send,

impl<Function, A, Ret, Fut> AsyncFunc<(A,), Ret> for Function

where Function: Fn(A) -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static, A: Send,

impl<Function, Ret, Fut> AsyncFunc<(), Ret> for Function

where Function: Fn() -> Fut + Sync + 'static, Fut: Future<Output = Ret> + Send + 'static,