Trait Poppable

pub trait Poppable: Sized {
    // Required method
    unsafe fn pop(lua_state: *mut State) -> Result<Self, Error>;
}

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

Required Methods

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

Pops the value at the top of the stack.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Poppable for bool

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

impl Poppable for f32

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

impl Poppable for f64

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

impl Poppable for i8

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

impl Poppable for i16

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

impl Poppable for i32

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

impl Poppable for i64

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

impl Poppable for isize

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

impl Poppable for u8

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

impl Poppable for u16

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

impl Poppable for u32

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

impl Poppable for u64

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

impl Poppable for ()

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

impl Poppable for usize

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

impl Poppable for String

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

impl<A> Poppable for (A,)

where A: Poppable,

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

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

where A: Poppable, B: Poppable,

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

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

where A: Poppable, B: Poppable, C: Poppable,

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

impl<K, V> Poppable for HashMap<K, V>

where K: Poppable + Eq + Hash, V: Poppable,

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

impl<T> Poppable for Option<T>

where T: Poppable,

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

impl<T> Poppable for Vec<T>

where T: Poppable,

unsafe fn pop(state: *mut State) -> Result<Vec<T>, 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 Array

impl Poppable for Dictionary

impl Poppable for Object

impl Poppable for nvim_oxi::String

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