[−][src]Struct pm_rlua::functions::Function
Opaque type containing a Rust function or closure.
Trait Implementations
impl<Z, R> FunctionExt<()> for Function<Z, (), R> where
Z: FnMut() -> R,
[src]
Z: FnMut() -> R,
impl<Z, R, A, B, C, D, E, F, G, H, I, J> FunctionExt<(A, B, C, D, E, F, G, H, I, J)> for Function<Z, (A, B, C, D, E, F, G, H, I, J), R> where
Z: FnMut(A, B, C, D, E, F, G, H, I, J) -> R,
[src]
Z: FnMut(A, B, C, D, E, F, G, H, I, J) -> R,
impl<Z, R, A, B, C, D, E, F, G, H, I> FunctionExt<(A, B, C, D, E, F, G, H, I)> for Function<Z, (A, B, C, D, E, F, G, H, I), R> where
Z: FnMut(A, B, C, D, E, F, G, H, I) -> R,
[src]
Z: FnMut(A, B, C, D, E, F, G, H, I) -> R,
impl<Z, R, A, B, C, D, E, F, G, H> FunctionExt<(A, B, C, D, E, F, G, H)> for Function<Z, (A, B, C, D, E, F, G, H), R> where
Z: FnMut(A, B, C, D, E, F, G, H) -> R,
[src]
Z: FnMut(A, B, C, D, E, F, G, H) -> R,
impl<Z, R, A, B, C, D, E, F, G> FunctionExt<(A, B, C, D, E, F, G)> for Function<Z, (A, B, C, D, E, F, G), R> where
Z: FnMut(A, B, C, D, E, F, G) -> R,
[src]
Z: FnMut(A, B, C, D, E, F, G) -> R,
impl<Z, R, A, B, C, D, E, F> FunctionExt<(A, B, C, D, E, F)> for Function<Z, (A, B, C, D, E, F), R> where
Z: FnMut(A, B, C, D, E, F) -> R,
[src]
Z: FnMut(A, B, C, D, E, F) -> R,
impl<Z, R, A, B, C, D, E> FunctionExt<(A, B, C, D, E)> for Function<Z, (A, B, C, D, E), R> where
Z: FnMut(A, B, C, D, E) -> R,
[src]
Z: FnMut(A, B, C, D, E) -> R,
impl<Z, R, A, B, C, D> FunctionExt<(A, B, C, D)> for Function<Z, (A, B, C, D), R> where
Z: FnMut(A, B, C, D) -> R,
[src]
Z: FnMut(A, B, C, D) -> R,
impl<Z, R, A, B, C> FunctionExt<(A, B, C)> for Function<Z, (A, B, C), R> where
Z: FnMut(A, B, C) -> R,
[src]
Z: FnMut(A, B, C) -> R,
impl<Z, R, A, B> FunctionExt<(A, B)> for Function<Z, (A, B), R> where
Z: FnMut(A, B) -> R,
[src]
Z: FnMut(A, B) -> R,
impl<Z, R, A> FunctionExt<(A,)> for Function<Z, (A,), R> where
Z: FnMut(A) -> R,
[src]
Z: FnMut(A) -> R,
impl<Z, R> LuaPush for Function<Z, (), R> where
Z: FnMut() -> R,
R: LuaPush + 'static,
[src]
Z: FnMut() -> R,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static> LuaPush for Function<Z, (A,), R> where
Z: FnMut(A) -> R,
(A,): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A) -> R,
(A,): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> LuaPush for Function<Z, (A, B, C, D, E, F, G, H, I, J), R> where
Z: FnMut(A, B, C, D, E, F, G, H, I, J) -> R,
(A, B, C, D, E, F, G, H, I, J): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D, E, F, G, H, I, J) -> R,
(A, B, C, D, E, F, G, H, I, J): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static> LuaPush for Function<Z, (A, B), R> where
Z: FnMut(A, B) -> R,
(A, B): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B) -> R,
(A, B): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static> LuaPush for Function<Z, (A, B, C), R> where
Z: FnMut(A, B, C) -> R,
(A, B, C): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C) -> R,
(A, B, C): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static> LuaPush for Function<Z, (A, B, C, D), R> where
Z: FnMut(A, B, C, D) -> R,
(A, B, C, D): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D) -> R,
(A, B, C, D): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> LuaPush for Function<Z, (A, B, C, D, E), R> where
Z: FnMut(A, B, C, D, E) -> R,
(A, B, C, D, E): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D, E) -> R,
(A, B, C, D, E): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> LuaPush for Function<Z, (A, B, C, D, E, F), R> where
Z: FnMut(A, B, C, D, E, F) -> R,
(A, B, C, D, E, F): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D, E, F) -> R,
(A, B, C, D, E, F): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> LuaPush for Function<Z, (A, B, C, D, E, F, G), R> where
Z: FnMut(A, B, C, D, E, F, G) -> R,
(A, B, C, D, E, F, G): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D, E, F, G) -> R,
(A, B, C, D, E, F, G): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> LuaPush for Function<Z, (A, B, C, D, E, F, G, H), R> where
Z: FnMut(A, B, C, D, E, F, G, H) -> R,
(A, B, C, D, E, F, G, H): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D, E, F, G, H) -> R,
(A, B, C, D, E, F, G, H): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
impl<Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> LuaPush for Function<Z, (A, B, C, D, E, F, G, H, I), R> where
Z: FnMut(A, B, C, D, E, F, G, H, I) -> R,
(A, B, C, D, E, F, G, H, I): LuaRead,
R: LuaPush + 'static,
[src]
Z: FnMut(A, B, C, D, E, F, G, H, I) -> R,
(A, B, C, D, E, F, G, H, I): LuaRead,
R: LuaPush + 'static,
fn push_to_lua(self, lua: *mut lua_State) -> i32
[src]
Auto Trait Implementations
impl<F, P, R> RefUnwindSafe for Function<F, P, R> where
F: RefUnwindSafe,
P: RefUnwindSafe,
R: RefUnwindSafe,
F: RefUnwindSafe,
P: RefUnwindSafe,
R: RefUnwindSafe,
impl<F, P, R> Send for Function<F, P, R> where
F: Send,
P: Send,
R: Send,
F: Send,
P: Send,
R: Send,
impl<F, P, R> Sync for Function<F, P, R> where
F: Sync,
P: Sync,
R: Sync,
F: Sync,
P: Sync,
R: Sync,
impl<F, P, R> Unpin for Function<F, P, R> where
F: Unpin,
P: Unpin,
R: Unpin,
F: Unpin,
P: Unpin,
R: Unpin,
impl<F, P, R> UnwindSafe for Function<F, P, R> where
F: UnwindSafe,
P: UnwindSafe,
R: UnwindSafe,
F: UnwindSafe,
P: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,