Trait tlua::Push

pub trait Push<L: AsLua> {
    type Err;

    fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>;

    fn push_no_err(&self, lua: L) -> PushGuard<L>
    where
        <Self as Push<L>>::Err: Into<Void>,
    { ... }
}

Types implementing this trait can be pushed onto the Lua stack by reference.

Required Associated Types

type Err

Error that can happen when pushing a value.

Required Methods

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

Pushes the value on the top of the stack.

Must return a guard representing the elements that have been pushed.

You can implement this for any type you want by redirecting to call to another implementation (for example 5.push_to_lua) or by calling userdata::push_userdata.

Provided Methods

fn push_no_err(&self, lua: L) -> PushGuard<L>where
    <Self as Push<L>>::Err: Into<Void>,

Same as push_to_lua but can only succeed and is only available if Err implements Into<Void>.

Implementations on Foreign Types

impl<L, T> Push<L> for Vec<T>where
    L: AsLua,
    T: Push<LuaState>,

Vec

type Err = PushIterError<<T as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, T> Push<L> for [T]where
    L: AsLua,
    T: Push<LuaState>,

[T]

type Err = PushIterError<<T as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, T, const N: usize> Push<L> for [T; N]where
    L: AsLua,
    T: Push<LuaState>,

[T; N]

type Err = PushIterError<<T as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, K, V> Push<L> for HashMap<K, V>where
    L: AsLua,
    K: PushOne<LuaState> + Eq + Hash + Debug,
    V: PushOne<LuaState> + Debug,

type Err = TuplePushError<<K as Push<*mut lua_State>>::Err, <V as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, K> Push<L> for HashSet<K>where
    L: AsLua,
    K: PushOne<LuaState> + Eq + Hash + Debug,

type Err = <K as Push<*mut lua_State>>::Err

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (K::Err, L)>

impl<LU, A, B, C, D, E, F, G, H, I, J, K, L, M> Push<LU> for (A, B, C, D, E, F, G, H, I, J, K, L, M)where
    LU: AsLua,
    A: Push<LuaState>,
    B: Push<LuaState>,
    C: Push<LuaState>,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<A as Push<*mut lua_State>>::Err, <(B, C, D, E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, B, C, D, E, F, G, H, I, J, K, L, M> Push<LU> for (B, C, D, E, F, G, H, I, J, K, L, M)where
    LU: AsLua,
    B: Push<LuaState>,
    C: Push<LuaState>,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<B as Push<*mut lua_State>>::Err, <(C, D, E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, C, D, E, F, G, H, I, J, K, L, M> Push<LU> for (C, D, E, F, G, H, I, J, K, L, M)where
    LU: AsLua,
    C: Push<LuaState>,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<C as Push<*mut lua_State>>::Err, <(D, E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, D, E, F, G, H, I, J, K, L, M> Push<LU> for (D, E, F, G, H, I, J, K, L, M)where
    LU: AsLua,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<D as Push<*mut lua_State>>::Err, <(E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, E, F, G, H, I, J, K, L, M> Push<LU> for (E, F, G, H, I, J, K, L, M)where
    LU: AsLua,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<E as Push<*mut lua_State>>::Err, <(F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, F, G, H, I, J, K, L, M> Push<LU> for (F, G, H, I, J, K, L, M)where
    LU: AsLua,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<F as Push<*mut lua_State>>::Err, <(G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, G, H, I, J, K, L, M> Push<LU> for (G, H, I, J, K, L, M)where
    LU: AsLua,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<G as Push<*mut lua_State>>::Err, <(H, I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, H, I, J, K, L, M> Push<LU> for (H, I, J, K, L, M)where
    LU: AsLua,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<H as Push<*mut lua_State>>::Err, <(I, J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, I, J, K, L, M> Push<LU> for (I, J, K, L, M)where
    LU: AsLua,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<I as Push<*mut lua_State>>::Err, <(J, K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, J, K, L, M> Push<LU> for (J, K, L, M)where
    LU: AsLua,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<J as Push<*mut lua_State>>::Err, <(K, L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, K, L, M> Push<LU> for (K, L, M)where
    LU: AsLua,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<K as Push<*mut lua_State>>::Err, <(L, M) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, L, M> Push<LU> for (L, M)where
    LU: AsLua,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = TuplePushError<<L as Push<*mut lua_State>>::Err, <(M,) as Push<*mut lua_State>>::Err>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, M> Push<LU> for (M,)where
    LU: AsLua,
    M: Push<LU>,

type Err = TuplePushError<<M as Push<LU>>::Err, Void>

fn push_to_lua(&self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<L> Push<L> for isizewhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for i64where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for i32where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for i16where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for i8where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for usizewhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for u64where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for u32where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for u16where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for u8where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for f64where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for f32where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for Stringwhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for CStringwhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for strwhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for CStrwhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for boolwhere
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> Push<L> for ()where
    L: AsLua,

type Err = Void

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L, T> Push<L> for Option<T>where
    T: Push<L>,
    L: AsLua,

type Err = <T as Push<L>>::Err

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<T, L> Push<L> for &Twhere
    L: AsLua,
    T: ?Sized + Push<L>,

type Err = <T as Push<L>>::Err

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

Implementors

impl<'c, L> Push<L> for LuaCode<'c>where
    L: AsLua,

type Err = LuaError

impl<L> Push<L> for AnyLuaStringwhere
    L: AsLua,

type Err = Void

impl<L> Push<L> for Falsewhere
    L: AsLua,

type Err = Void

impl<L> Push<L> for Nilwhere
    L: AsLua,

type Err = Void

impl<L> Push<L> for Nullwhere
    L: AsLua,

type Err = Void

impl<L> Push<L> for Truewhere
    L: AsLua,

type Err = Void

impl<L, K> Push<L> for Object<K>where
    L: AsLua,

type Err = Void

impl<L, O> Push<L> for CDataOnStack<'_, O>where
    L: AsLua,

type Err = Void

impl<L, T> Push<L> for Callable<T>where
    L: AsLua,

type Err = Void

impl<L, T> Push<L> for Indexable<T>where
    L: AsLua,

type Err = Void

impl<L, T> Push<L> for IndexableRW<T>where
    L: AsLua,

type Err = Void

impl<L, T> Push<L> for LuaFunction<T>where
    L: AsLua,

type Err = Void

impl<L, T> Push<L> for LuaTable<T>where
    L: AsLua,

type Err = Void

impl<L, Z, R> Push<L> for Function<Z, (), R>where
    L: AsLua,
    Z: FnMut() -> R,
    Self: Copy + 'static,
    (): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (A, B, C, D, E, F, G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(A, B, C, D, E, F, G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (A, B, C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (B, C, D, E, F, G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(B, C, D, E, F, G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (B, C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (C, D, E, F, G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(C, D, E, F, G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (D, E, F, G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(D, E, F, G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (E, F, G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(E, F, G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (F, G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(F, G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (G, H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(G, H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (H, I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(H, I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (I, J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(I, J, K, M, N) -> R,
    Self: Copy + 'static,
    (I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, J: 'static, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (J, K, M, N), R>where
    L: AsLua,
    Z: FnMut(J, K, M, N) -> R,
    Self: Copy + 'static,
    (J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, K: 'static, M: 'static, N: 'static> Push<L> for Function<Z, (K, M, N), R>where
    L: AsLua,
    Z: FnMut(K, M, N) -> R,
    Self: Copy + 'static,
    (K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, M: 'static, N: 'static> Push<L> for Function<Z, (M, N), R>where
    L: AsLua,
    Z: FnMut(M, N) -> R,
    Self: Copy + 'static,
    (M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L, Z, R, N: 'static> Push<L> for Function<Z, (N,), R>where
    L: AsLua,
    Z: FnMut(N) -> R,
    Self: Copy + 'static,
    (N,): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static,

type Err = Void

impl<L: AsLua> Push<L> for AnyHashableLuaValue

type Err = Void

impl<L: AsLua> Push<L> for AnyLuaValue

type Err = Void

impl<LU, A, B, C, D, E, F, G, H, I, J, K, L, M> Push<LU> for AsTable<(A, B, C, D, E, F, G, H, I, J, K, L, M)>where
    LU: AsLua,
    A: Push<LuaState>,
    B: Push<LuaState>,
    C: Push<LuaState>,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<A as Push<*mut lua_State>>::Err, <(B, C, D, E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, B, C, D, E, F, G, H, I, J, K, L, M> Push<LU> for AsTable<(B, C, D, E, F, G, H, I, J, K, L, M)>where
    LU: AsLua,
    B: Push<LuaState>,
    C: Push<LuaState>,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<B as Push<*mut lua_State>>::Err, <(C, D, E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, C, D, E, F, G, H, I, J, K, L, M> Push<LU> for AsTable<(C, D, E, F, G, H, I, J, K, L, M)>where
    LU: AsLua,
    C: Push<LuaState>,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<C as Push<*mut lua_State>>::Err, <(D, E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, D, E, F, G, H, I, J, K, L, M> Push<LU> for AsTable<(D, E, F, G, H, I, J, K, L, M)>where
    LU: AsLua,
    D: Push<LuaState>,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<D as Push<*mut lua_State>>::Err, <(E, F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, E, F, G, H, I, J, K, L, M> Push<LU> for AsTable<(E, F, G, H, I, J, K, L, M)>where
    LU: AsLua,
    E: Push<LuaState>,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<E as Push<*mut lua_State>>::Err, <(F, G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, F, G, H, I, J, K, L, M> Push<LU> for AsTable<(F, G, H, I, J, K, L, M)>where
    LU: AsLua,
    F: Push<LuaState>,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<F as Push<*mut lua_State>>::Err, <(G, H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, G, H, I, J, K, L, M> Push<LU> for AsTable<(G, H, I, J, K, L, M)>where
    LU: AsLua,
    G: Push<LuaState>,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<G as Push<*mut lua_State>>::Err, <(H, I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, H, I, J, K, L, M> Push<LU> for AsTable<(H, I, J, K, L, M)>where
    LU: AsLua,
    H: Push<LuaState>,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<H as Push<*mut lua_State>>::Err, <(I, J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, I, J, K, L, M> Push<LU> for AsTable<(I, J, K, L, M)>where
    LU: AsLua,
    I: Push<LuaState>,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<I as Push<*mut lua_State>>::Err, <(J, K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, J, K, L, M> Push<LU> for AsTable<(J, K, L, M)>where
    LU: AsLua,
    J: Push<LuaState>,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<J as Push<*mut lua_State>>::Err, <(K, L, M) as Push<*mut lua_State>>::Err>>

impl<LU, K, L, M> Push<LU> for AsTable<(K, L, M)>where
    LU: AsLua,
    K: Push<LuaState>,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<K as Push<*mut lua_State>>::Err, <(L, M) as Push<*mut lua_State>>::Err>>

impl<LU, L, M> Push<LU> for AsTable<(L, M)>where
    LU: AsLua,
    L: Push<LuaState>,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<L as Push<*mut lua_State>>::Err, <(M,) as Push<*mut lua_State>>::Err>>

impl<LU, M> Push<LU> for AsTable<(M,)>where
    LU: AsLua,
    M: Push<LuaState>,

type Err = PushIterError<TuplePushError<<M as Push<*mut lua_State>>::Err, Void>>