Trait tlua::PushInto

pub trait PushInto<L>
where
    L: AsLua,
{
    type Err;

    // Required method
    fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>;

    // Provided method
    fn push_into_no_err(self, lua: L) -> PushGuard<L>
       where Self: Sized,
             <Self as PushInto<L>>::Err: Into<Void> { ... }
}

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

Required Associated Types

type Err

Required Methods

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

Push the value into lua by value

Provided Methods

fn push_into_no_err(self, lua: L) -> PushGuard<L>

where Self: Sized, <Self as PushInto<L>>::Err: Into<Void>,

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

Implementations on Foreign Types

impl<L> PushInto<L> for bool

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for f32

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for f64

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for i8

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for i16

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for i32

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for i64

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for isize

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for u8

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for u16

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for u32

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for u64

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for ()

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for usize

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for CString

where L: AsLua,

type Err = Void

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

impl<L> PushInto<L> for String

where L: AsLua,

type Err = Void

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

impl<L, K> PushInto<L> for HashSet<K>

where L: AsLua, K: PushOneInto<LuaState> + Eq + Hash + Debug,

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

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

impl<L, K, V> PushInto<L> for HashMap<K, V>

where L: AsLua, K: PushOneInto<LuaState> + Eq + Hash + Debug, V: PushOneInto<LuaState> + Debug,

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

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

impl<L, T> PushInto<L> for Option<T>

where T: PushInto<L>, L: AsLua,

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

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

impl<L, T> PushInto<L> for Vec<T>

where L: AsLua, T: PushInto<LuaState>,

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

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

impl<L, T, const N: usize> PushInto<L> for [T; N]

where L: AsLua, T: PushInto<LuaState>,

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

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

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

where LU: AsLua, A: PushInto<LuaState>, B: PushInto<LuaState>, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, B, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (B, C, D, E, F, G, H, I, J, K, L, M)

where LU: AsLua, B: PushInto<LuaState>, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (C, D, E, F, G, H, I, J, K, L, M)

where LU: AsLua, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (D, E, F, G, H, I, J, K, L, M)

where LU: AsLua, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, E, F, G, H, I, J, K, L, M> PushInto<LU> for (E, F, G, H, I, J, K, L, M)

where LU: AsLua, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, F, G, H, I, J, K, L, M> PushInto<LU> for (F, G, H, I, J, K, L, M)

where LU: AsLua, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, G, H, I, J, K, L, M> PushInto<LU> for (G, H, I, J, K, L, M)

where LU: AsLua, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, H, I, J, K, L, M> PushInto<LU> for (H, I, J, K, L, M)

where LU: AsLua, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, I, J, K, L, M> PushInto<LU> for (I, J, K, L, M)

where LU: AsLua, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, J, K, L, M> PushInto<LU> for (J, K, L, M)

where LU: AsLua, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, K, L, M> PushInto<LU> for (K, L, M)

where LU: AsLua, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, L, M> PushInto<LU> for (L, M)

where LU: AsLua, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

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

impl<LU, M> PushInto<LU> for (M,)

where LU: AsLua, M: PushInto<LU>,

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

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

impl<T, E> PushInto<InsideCallback> for Result<T, Throw<E>>

where T: PushInto<InsideCallback>, E: Display,

type Err = <T as PushInto<InsideCallback>>::Err

fn push_into_lua( self, lua: InsideCallback ) -> Result<PushGuard<InsideCallback>, (T::Err, InsideCallback)>

impl<T, E> PushInto<InsideCallback> for Result<T, E>

where T: PushInto<InsideCallback>, E: Display,

type Err = <T as PushInto<InsideCallback>>::Err

fn push_into_lua( self, lua: InsideCallback ) -> Result<PushGuard<InsideCallback>, (T::Err, InsideCallback)>

impl<T, L> PushInto<L> for &T

where L: AsLua, T: ?Sized + Push<L>,

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

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

Implementors

impl<L> PushInto<L> for AnyLuaString

where L: AsLua,

type Err = Void

impl<L> PushInto<L> for False

where L: AsLua,

type Err = Void

impl<L> PushInto<L> for Nil

where L: AsLua,

type Err = Void

impl<L> PushInto<L> for Null

where L: AsLua,

type Err = Void

impl<L> PushInto<L> for True

where L: AsLua,

type Err = Void

impl<L, I> PushInto<L> for TableFromIter<I>

where L: AsLua, I: Iterator, <I as Iterator>::Item: PushInto<LuaState>,

type Err = PushIterError<<<I as Iterator>::Item as PushInto<*mut lua_State>>::Err>

impl<L, K> PushInto<L> for Object<K>

where L: AsLua, K: AsLua,

type Err = Void

impl<L, R> PushInto<L> for LuaCodeFromReader<R>

where L: AsLua, R: Read,

type Err = LuaError

impl<L, T> PushInto<L> for CData<T>

where L: AsLua, T: AsCData,

type Err = Void

impl<L, Z, R> PushInto<L> for Function<Z, (), R>

where L: AsLua, Z: FnMut() -> R + '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> PushInto<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 + '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> PushInto<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 + '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> PushInto<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 + '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> PushInto<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 + '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> PushInto<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 + '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> PushInto<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 + '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> PushInto<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 + '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> PushInto<L> for Function<Z, (H, I, J, K, M, N), R>

where L: AsLua, Z: FnMut(H, I, J, K, M, N) -> R + '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> PushInto<L> for Function<Z, (I, J, K, M, N), R>

where L: AsLua, Z: FnMut(I, J, K, M, N) -> R + '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> PushInto<L> for Function<Z, (J, K, M, N), R>

where L: AsLua, Z: FnMut(J, K, M, N) -> R + '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> PushInto<L> for Function<Z, (K, M, N), R>

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

type Err = Void

impl<L, Z, R, M: 'static, N: 'static> PushInto<L> for Function<Z, (M, N), R>

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

type Err = Void

impl<L, Z, R, N: 'static> PushInto<L> for Function<Z, (N,), R>

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

type Err = Void

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

type Err = Void

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

type Err = Void

impl<L: AsLua> PushInto<L> for CFunction

type Err = Void

impl<LU, A, B, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(A, B, C, D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, A: PushInto<LuaState>, B: PushInto<LuaState>, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, B, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(B, C, D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, B: PushInto<LuaState>, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(C, D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, E, F, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(E, F, G, H, I, J, K, L, M)>

where LU: AsLua, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, F, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(F, G, H, I, J, K, L, M)>

where LU: AsLua, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, G, H, I, J, K, L, M> PushInto<LU> for AsTable<(G, H, I, J, K, L, M)>

where LU: AsLua, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, H, I, J, K, L, M> PushInto<LU> for AsTable<(H, I, J, K, L, M)>

where LU: AsLua, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, I, J, K, L, M> PushInto<LU> for AsTable<(I, J, K, L, M)>

where LU: AsLua, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, J, K, L, M> PushInto<LU> for AsTable<(J, K, L, M)>

where LU: AsLua, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, K, L, M> PushInto<LU> for AsTable<(K, L, M)>

where LU: AsLua, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, L, M> PushInto<LU> for AsTable<(L, M)>

where LU: AsLua, L: PushInto<LuaState>, M: PushInto<LuaState>,

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

impl<LU, M> PushInto<LU> for AsTable<(M,)>

where LU: AsLua, M: PushInto<LuaState>,

type Err = AsTablePushError<TuplePushError<<M as PushInto<*mut lua_State>>::Err, Void>>