Trait nvim_oxi::lua::Poppable

pub trait Poppable {
    unsafe fn pop(lua_state: *mut lua_State) -> Result<Self, Error>;
}

Trait implemented for types that can be popped off the Lua stack.

Required Methods

unsafe fn pop(lua_state: *mut lua_State) -> Result<Self, Error>

Pops the value at the top of the stack.

Implementations on Foreign Types

impl Poppable for i32

unsafe fn pop(lstate: *mut lua_State) -> Result<i32, Error>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Poppable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,
    J: Poppable,
    K: Poppable,
    L: Poppable,
    M: Poppable,
    N: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Error>

impl<A, B, C, D, E, F> Poppable for (A, B, C, D, E, F)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B, C, D, E, F), Error>

impl<K, V> Poppable for HashMap<K, V, RandomState>where
    K: Poppable + Eq + Hash,
    V: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<HashMap<K, V, RandomState>, Error>

impl Poppable for f64

unsafe fn pop(state: *mut lua_State) -> Result<f64, Error>

impl<A> Poppable for (A,)where
    A: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A,), Error>

impl<A, B, C, D> Poppable for (A, B, C, D)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B, C, D), Error>

impl<A, B, C, D, E, F, G, H, I, J, K, L> Poppable for (A, B, C, D, E, F, G, H, I, J, K, L)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,
    J: Poppable,
    K: Poppable,
    L: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Error>

impl Poppable for String

unsafe fn pop(state: *mut lua_State) -> Result<String, Error>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Poppable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,
    J: Poppable,
    K: Poppable,
    L: Poppable,
    M: Poppable,
    N: Poppable,
    O: Poppable,
    P: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Error>

impl<T> Poppable for Vec<T, Global>where
    T: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<Vec<T, Global>, Error>

impl Poppable for u8

unsafe fn pop(lstate: *mut lua_State) -> Result<u8, Error>

impl Poppable for u64

unsafe fn pop(lstate: *mut lua_State) -> Result<u64, Error>

impl Poppable for u32

unsafe fn pop(lstate: *mut lua_State) -> Result<u32, Error>

impl Poppable for bool

unsafe fn pop(state: *mut lua_State) -> Result<bool, Error>

impl Poppable for i16

unsafe fn pop(lstate: *mut lua_State) -> Result<i16, Error>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Poppable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,
    J: Poppable,
    K: Poppable,
    L: Poppable,
    M: Poppable,
    N: Poppable,
    O: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Error>

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

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Error>

impl Poppable for i8

unsafe fn pop(lstate: *mut lua_State) -> Result<i8, Error>

impl<A, B, C, D, E, F, G> Poppable for (A, B, C, D, E, F, G)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B, C, D, E, F, G), Error>

impl Poppable for i64

unsafe fn pop(lstate: *mut lua_State) -> Result<i64, Error>

impl<A, B, C, D, E, F, G, H, I> Poppable for (A, B, C, D, E, F, G, H, I)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I), Error>

impl Poppable for isize

unsafe fn pop(state: *mut lua_State) -> Result<isize, Error>

impl<A, B, C, D, E, F, G, H, I, J, K> Poppable for (A, B, C, D, E, F, G, H, I, J, K)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,
    J: Poppable,
    K: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Error>

impl<A, B> Poppable for (A, B)where
    A: Poppable,
    B: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B), Error>

impl Poppable for f32

unsafe fn pop(state: *mut lua_State) -> Result<f32, Error>

impl<T> Poppable for Option<T>where
    T: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<Option<T>, Error>

impl Poppable for u16

unsafe fn pop(lstate: *mut lua_State) -> Result<u16, Error>

impl<A, B, C, D, E, F, G, H, I, J> Poppable for (A, B, C, D, E, F, G, H, I, J)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,
    I: Poppable,
    J: Poppable,

unsafe fn pop(
    state: *mut lua_State
) -> Result<(A, B, C, D, E, F, G, H, I, J), Error>

impl<A, B, C, D, E, F, G, H> Poppable for (A, B, C, D, E, F, G, H)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,
    F: Poppable,
    G: Poppable,
    H: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B, C, D, E, F, G, H), Error>

impl<A, B, C, D, E> Poppable for (A, B, C, D, E)where
    A: Poppable,
    B: Poppable,
    C: Poppable,
    D: Poppable,
    E: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B, C, D, E), Error>

impl Poppable for usize

unsafe fn pop(lstate: *mut lua_State) -> Result<usize, Error>

impl<A, B, C> Poppable for (A, B, C)where
    A: Poppable,
    B: Poppable,
    C: Poppable,

unsafe fn pop(state: *mut lua_State) -> Result<(A, B, C), Error>

impl Poppable for ()

unsafe fn pop(state: *mut lua_State) -> Result<(), Error>

Implementors

impl Poppable for Buffer

impl Poppable for TabPage

impl Poppable for Window

impl Poppable for AutocmdCallbackArgs

impl Poppable for CommandArgs

impl Poppable for KVec<KeyValuePair>

impl Poppable for KVec<Object>

impl Poppable for Object

impl Poppable for nvim_oxi::String

impl<A, R> Poppable for Function<A, R>