Trait LuaNativeFnMut 

pub trait LuaNativeFnMut<A: FromLuaMulti> {
    type Output;

    // Required method
    fn call(&mut self, args: A) -> Self::Output;
}

A trait for types with mutable state that can be used as Lua functions.

Required Associated Types

type Output

Required Methods

fn call(&mut self, args: A) -> Self::Output

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M, N): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J, K, L, M) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L, M): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J, K, L) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K, L): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J, K) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J, K): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I, J) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I, J): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H, I) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H, I): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G, H) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G, H): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F, G) -> R + MaybeSend + 'static, (A, B, C, D, E, F, G): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E, F) -> R + MaybeSend + 'static, (A, B, C, D, E, F): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D, E) -> R + MaybeSend + 'static, (A, B, C, D, E): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C, D) -> R + MaybeSend + 'static, (A, B, C, D): FromLuaMulti,

type Output = R

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

where FN: FnMut(A, B, C) -> R + MaybeSend + 'static, (A, B, C): FromLuaMulti,

type Output = R

impl<FN, A, B, R> LuaNativeFnMut<(A, B)> for FN

where FN: FnMut(A, B) -> R + MaybeSend + 'static, (A, B): FromLuaMulti,

type Output = R

impl<FN, A, R> LuaNativeFnMut<(A,)> for FN

where FN: FnMut(A) -> R + MaybeSend + 'static, (A,): FromLuaMulti,

type Output = R

impl<FN, R> LuaNativeFnMut<()> for FN

where FN: FnMut() -> R + MaybeSend + 'static, (): FromLuaMulti,

type Output = R