[−][src]Trait wasm_bindgen::convert::IntoWasmAbi

pub trait IntoWasmAbi: WasmDescribe {
    type Abi: WasmAbi;
    fn into_abi(self, extra: &mut dyn Stack) -> Self::Abi;
}

A trait for anything that can be converted into a type that can cross the wasm ABI directly, eg u32 or f64.

This is the opposite operation as FromWasmAbi and Ref[Mut]FromWasmAbi.

Associated Types

The wasm ABI type that this converts into when crossing the ABI boundary.

Required Methods

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

Implementations on Foreign Types

impl<'a, 'b, R> IntoWasmAbi for &'a (dyn Fn() -> R + 'b) where
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, R> IntoWasmAbi for &'a mut (dyn FnMut() -> R + 'b) where
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, R> IntoWasmAbi for &'a (dyn Fn(A) -> R + 'b) where
    A: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, R> IntoWasmAbi for &'a mut (dyn FnMut(A) -> R + 'b) where
    A: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, R> IntoWasmAbi for &'a (dyn Fn(A, B) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, R> IntoWasmAbi for &'a mut (dyn FnMut(A, B) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, R> IntoWasmAbi for &'a (dyn Fn(A, B, C) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, R> IntoWasmAbi for &'a mut (dyn FnMut(A, B, C) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, R> IntoWasmAbi for &'a (dyn Fn(A, B, C, D) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, R> IntoWasmAbi for &'a mut (dyn FnMut(A, B, C, D) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, E, R> IntoWasmAbi for &'a (dyn Fn(A, B, C, D, E) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    E: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, E, R> IntoWasmAbi for &'a mut (dyn FnMut(A, B, C, D, E) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    E: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, E, F, R> IntoWasmAbi for &'a (dyn Fn(A, B, C, D, E, F) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    E: FromWasmAbi,
    F: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, E, F, R> IntoWasmAbi for &'a mut (dyn FnMut(A, B, C, D, E, F) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    E: FromWasmAbi,
    F: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, E, F, G, R> IntoWasmAbi for &'a (dyn Fn(A, B, C, D, E, F, G) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    E: FromWasmAbi,
    F: FromWasmAbi,
    G: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl<'a, 'b, A, B, C, D, E, F, G, R> IntoWasmAbi for &'a mut (dyn FnMut(A, B, C, D, E, F, G) -> R + 'b) where
    A: FromWasmAbi,
    B: FromWasmAbi,
    C: FromWasmAbi,
    D: FromWasmAbi,
    E: FromWasmAbi,
    F: FromWasmAbi,
    G: FromWasmAbi,
    R: ReturnWasmAbi, 
[src]

impl IntoWasmAbi for i32
[src]

impl IntoWasmAbi for Option<i32>
[src]

impl IntoWasmAbi for isize
[src]

impl IntoWasmAbi for Option<isize>
[src]

impl IntoWasmAbi for u32
[src]

impl IntoWasmAbi for Option<u32>
[src]

impl IntoWasmAbi for usize
[src]

impl IntoWasmAbi for Option<usize>
[src]

impl IntoWasmAbi for f32
[src]

impl IntoWasmAbi for Option<f32>
[src]

impl IntoWasmAbi for f64
[src]

impl IntoWasmAbi for Option<f64>
[src]

impl IntoWasmAbi for i8
[src]

impl IntoWasmAbi for u8
[src]

impl IntoWasmAbi for i16
[src]

impl IntoWasmAbi for u16
[src]

impl IntoWasmAbi for i64
[src]

impl IntoWasmAbi for Option<i64>
[src]

impl IntoWasmAbi for u64
[src]

impl IntoWasmAbi for Option<u64>
[src]

impl IntoWasmAbi for bool
[src]

impl IntoWasmAbi for char
[src]

impl IntoWasmAbi for Option<char>
[src]

impl<T> IntoWasmAbi for *const T
[src]

impl<T> IntoWasmAbi for *mut T
[src]

impl<T: OptionIntoWasmAbi> IntoWasmAbi for Option<T>
[src]

impl IntoWasmAbi for ()
[src]

impl IntoWasmAbi for Box<[u8]>
[src]

impl<'a> IntoWasmAbi for &'a [u8]
[src]

impl<'a> IntoWasmAbi for &'a mut [u8]
[src]

impl IntoWasmAbi for Box<[i8]>
[src]

impl<'a> IntoWasmAbi for &'a [i8]
[src]

impl<'a> IntoWasmAbi for &'a mut [i8]
[src]

impl IntoWasmAbi for Box<[u16]>
[src]

impl<'a> IntoWasmAbi for &'a [u16]
[src]

impl<'a> IntoWasmAbi for &'a mut [u16]
[src]

impl IntoWasmAbi for Box<[i16]>
[src]

impl<'a> IntoWasmAbi for &'a [i16]
[src]

impl<'a> IntoWasmAbi for &'a mut [i16]
[src]

impl IntoWasmAbi for Box<[u32]>
[src]

impl<'a> IntoWasmAbi for &'a [u32]
[src]

impl<'a> IntoWasmAbi for &'a mut [u32]
[src]

impl IntoWasmAbi for Box<[i32]>
[src]

impl<'a> IntoWasmAbi for &'a [i32]
[src]

impl<'a> IntoWasmAbi for &'a mut [i32]
[src]

impl IntoWasmAbi for Box<[u64]>
[src]

impl<'a> IntoWasmAbi for &'a [u64]
[src]

impl<'a> IntoWasmAbi for &'a mut [u64]
[src]

impl IntoWasmAbi for Box<[i64]>
[src]

impl<'a> IntoWasmAbi for &'a [i64]
[src]

impl<'a> IntoWasmAbi for &'a mut [i64]
[src]

impl IntoWasmAbi for Box<[f32]>
[src]

impl<'a> IntoWasmAbi for &'a [f32]
[src]

impl<'a> IntoWasmAbi for &'a mut [f32]
[src]

impl IntoWasmAbi for Box<[f64]>
[src]

impl<'a> IntoWasmAbi for &'a [f64]
[src]

impl<'a> IntoWasmAbi for &'a mut [f64]
[src]

impl<T> IntoWasmAbi for Vec<T> where
    Box<[T]>: IntoWasmAbi<Abi = WasmSlice>, 
[src]

impl IntoWasmAbi for String
[src]

impl<'a> IntoWasmAbi for &'a str
[src]

impl IntoWasmAbi for Box<[JsValue]>
[src]

Implementors

impl IntoWasmAbi for JsValue
[src]

impl<'a> IntoWasmAbi for &'a JsValue
[src]

impl<'a, T: ?Sized> IntoWasmAbi for &'a Closure<T> where
    T: WasmClosure, 
[src]

impl<T: IntoWasmAbi> IntoWasmAbi for Clamped<T>
[src]