Trait wasmtime::IntoFunc

pub trait IntoFunc<Params, Results> { }

Internal trait implemented for all arguments that can be passed to Func::wrap.

This trait should not be implemented by external users, it’s only intended as an implementation detail of this crate.

Implementors

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    A14: WasmTy,
    A15: WasmTy,
    A16: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    A14: WasmTy,
    A15: WasmTy,
    A16: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    A14: WasmTy,
    A15: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    A14: WasmTy,
    A15: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    A14: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    A14: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    A13: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    A12: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    A11: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    A10: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, A9, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8, A9), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    A9: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7, A8) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, A8, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7, A8), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7, A8) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    A8: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6, A7), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6, A7) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, A7, R> IntoFunc<(A1, A2, A3, A4, A5, A6, A7), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6, A7) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    A7: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5, A6), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5, A6) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, A6, R> IntoFunc<(A1, A2, A3, A4, A5, A6), R> for F where
    F: Fn(A1, A2, A3, A4, A5, A6) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    A6: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4, A5), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4, A5) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, A5, R> IntoFunc<(A1, A2, A3, A4, A5), R> for F where
    F: Fn(A1, A2, A3, A4, A5) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    A5: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, R> IntoFunc<(Caller<'_>, A1, A2, A3, A4), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3, A4) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, A4, R> IntoFunc<(A1, A2, A3, A4), R> for F where
    F: Fn(A1, A2, A3, A4) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    A4: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, R> IntoFunc<(Caller<'_>, A1, A2, A3), R> for F where
    F: Fn(Caller<'_>, A1, A2, A3) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, A3, R> IntoFunc<(A1, A2, A3), R> for F where
    F: Fn(A1, A2, A3) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    A3: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, R> IntoFunc<(Caller<'_>, A1, A2), R> for F where
    F: Fn(Caller<'_>, A1, A2) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    R: WasmRet, 

impl<F, A1, A2, R> IntoFunc<(A1, A2), R> for F where
    F: Fn(A1, A2) -> R + 'static,
    A1: WasmTy,
    A2: WasmTy,
    R: WasmRet, 

impl<F, A1, R> IntoFunc<(Caller<'_>, A1), R> for F where
    F: Fn(Caller<'_>, A1) -> R + 'static,
    A1: WasmTy,
    R: WasmRet, 

impl<F, A1, R> IntoFunc<(A1,), R> for F where
    F: Fn(A1) -> R + 'static,
    A1: WasmTy,
    R: WasmRet, 

impl<F, R> IntoFunc<(Caller<'_>,), R> for F where
    F: Fn(Caller<'_>) -> R + 'static,
    R: WasmRet, 

impl<F, R> IntoFunc<(), R> for F where
    F: Fn() -> R + 'static,
    R: WasmRet,