Trait glsp::IntoCallArgs

pub trait IntoCallArgs: Sealed {
    pub fn arg_count(&self) -> usize;
    pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError>
    where
        E: Extend<Slot>;
}

A type which can be converted into the arguments to a function call.

It's not possible to implement this trait for your own types, but it's implemented for tuples, slices, arrays, and references to the same, when their elements all implement IntoVal.

Functions like glsp:call and Obj::call are generic over this trait:

let push_rfn: RFn = glsp::global("push!");
glsp::call(&push_rfn, (my_arr, 100i32))?;

Due to some limitations in Rust's type system, argument lists can be slightly awkward:

• It's not possible to pass in &[] or [] to represent an empty argument list. You should use &() or () instead.
• IntoVal isn't implemented for references to references, so types like &(&f32, &f32), &[&Root<Arr>] and [&i32; 16] won't be accepted. When working with references, prefer to use tuples, like (&f32, &f32).

Required methods

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

Loading content...

Implementations on Foreign Types

impl<'a, A> IntoCallArgs for &'a (A,) where
    &'a A: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a> IntoCallArgs for &'a ()

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, _dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoCallArgs for &'a (A, B, C, D, E, F, G, H, I, J, K) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal,
    &'a J: IntoVal,
    &'a K: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C> IntoCallArgs for &'a mut (A, B, C) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoCallArgs for &'a (A, B, C, D, E, F, G, H, I, J, K, L) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal,
    &'a J: IntoVal,
    &'a K: IntoVal,
    &'a L: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<T, const N: usize> IntoCallArgs for [T; N] where
    &'a T: for<'a> IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'a, A> IntoCallArgs for &'a mut (A,) where
    &'a mut A: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a> IntoCallArgs for &'a mut ()

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, _dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C> IntoCallArgs for &'a (A, B, C) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E> IntoCallArgs for &'a mut (A, B, C, D, E) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F> IntoCallArgs for &'a mut (A, B, C, D, E, F) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H> IntoCallArgs for &'a (A, B, C, D, E, F, G, H) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D> IntoCallArgs for &'a mut (A, B, C, D) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F> IntoCallArgs for &'a (A, B, C, D, E, F) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G> IntoCallArgs for &'a mut (A, B, C, D, E, F, G) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, T, const N: usize> IntoCallArgs for &'a [T; N] where
    &'a T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H> IntoCallArgs for &'a mut (A, B, C, D, E, F, G, H) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E> IntoCallArgs for &'a (A, B, C, D, E) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B> IntoCallArgs for &'a (A, B) where
    &'a A: IntoVal,
    &'a B: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I> IntoCallArgs for &'a mut (A, B, C, D, E, F, G, H, I) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I> IntoCallArgs for &'a (A, B, C, D, E, F, G, H, I) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<A, B> IntoCallArgs for (A, B) where
    B: IntoVal,
    A: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoCallArgs for &'a mut (A, B, C, D, E, F, G, H, I, J, K, L) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal,
    &'a mut J: IntoVal,
    &'a mut K: IntoVal,
    &'a mut L: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, T> IntoCallArgs for &'a mut [T] where
    &'a mut T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<A> IntoCallArgs for (A,) where
    A: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D> IntoCallArgs for &'a (A, B, C, D) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G> IntoCallArgs for &'a (A, B, C, D, E, F, G) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, T> IntoCallArgs for &'a [T] where
    &'a T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

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

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoCallArgs for &'a (A, B, C, D, E, F, G, H, I, J) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal,
    &'a J: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl IntoCallArgs for ()

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, _dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoCallArgs for &'a mut (A, B, C, D, E, F, G, H, I, J) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal,
    &'a mut J: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoCallArgs for &'a mut (A, B, C, D, E, F, G, H, I, J, K) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal,
    &'a mut J: IntoVal,
    &'a mut K: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

impl<'a, T, const N: usize> IntoCallArgs for &'a mut [T; N] where
    &'a mut T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'a, A, B> IntoCallArgs for &'a mut (A, B) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<EE>(self, dst: &mut EE) -> Result<(), GError> where
    EE: Extend<Slot>, 

Loading content...

Implementors

impl<'a, T> IntoCallArgs for Rest<'a, T> where
    T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'r, 'a, T> IntoCallArgs for &'r Rest<'a, T> where
    'a: 'r,
    &'r T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

impl<'r, 'a, T> IntoCallArgs for &'r mut Rest<'a, T> where
    'a: 'r,
    &'r mut T: IntoVal, 

pub fn arg_count(&self) -> usize

pub fn into_call_args<E>(self, dst: &mut E) -> Result<(), GError> where
    E: Extend<Slot>, 

Loading content...