Trait LuaNativeAsyncFn

pub trait LuaNativeAsyncFn<A: FromLuaMulti> {
    type Output: IntoLuaMulti;

    // Required method
    fn call(
        &self,
        args: A,
    ) -> impl Future<Output = Self::Output> + MaybeSend + 'static;
}

Available on crate feature async only.

A trait for types that returns a future and can be used as Lua functions.

Required Associated Types

type Output: IntoLuaMulti

Required Methods

fn call( &self, args: A, ) -> impl Future<Output = Self::Output> + MaybeSend + 'static

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<FN, A, B, C, D, E, F, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F)> for FN

where FN: Fn(A, B, C, D, E, F) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G)> for FN

where FN: Fn(A, B, C, D, E, F, G) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H)> for FN

where FN: Fn(A, B, C, D, E, F, G, H) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, K, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J, K)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J, K) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, K, L, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J, K, L)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, K, L, M, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M, N): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for FN

where FN: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Fut + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, E, Fut, R> LuaNativeAsyncFn<(A, B, C, D, E)> for FN

where FN: Fn(A, B, C, D, E) -> Fut + MaybeSend + 'static, (A, B, C, D, E): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, D, Fut, R> LuaNativeAsyncFn<(A, B, C, D)> for FN

where FN: Fn(A, B, C, D) -> Fut + MaybeSend + 'static, (A, B, C, D): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, C, Fut, R> LuaNativeAsyncFn<(A, B, C)> for FN

where FN: Fn(A, B, C) -> Fut + MaybeSend + 'static, (A, B, C): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, B, Fut, R> LuaNativeAsyncFn<(A, B)> for FN

where FN: Fn(A, B) -> Fut + MaybeSend + 'static, (A, B): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, A, Fut, R> LuaNativeAsyncFn<(A,)> for FN

where FN: Fn(A) -> Fut + MaybeSend + 'static, (A,): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R

impl<FN, Fut, R> LuaNativeAsyncFn<()> for FN

where FN: Fn() -> Fut + MaybeSend + 'static, (): FromLuaMulti, Fut: Future<Output = R> + MaybeSend + 'static, R: IntoLuaMulti,

type Output = R