Trait linera_witty::ExportFunction

pub trait ExportFunction<Handler, Parameters, Results> {
    // Required method
    fn export(
        &mut self,
        module_name: &str,
        function_name: &str,
        handler: Handler,
    ) -> Result<(), RuntimeError>;
}

A type that accepts registering a host function as an export for a guest Wasm instance.

The Handler represents the closure type required for the host function, and Parameters and Results are the input and output types of the closure, respectively.

Required Methods

fn export( &mut self, module_name: &str, function_name: &str, handler: Handler, ) -> Result<(), RuntimeError>

Registers a host function executed by the handler with the provided module_name and function_name as an export for a guest Wasm instance.

Implementors

impl<Handler, A, B, C, D, E, F, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, L, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, L: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K, L)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, L, M, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, L: WasmTy, M: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K, L, M)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, L, M, N, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, L: WasmTy, M: WasmTy, N: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, L: WasmTy, M: WasmTy, N: WasmTy, O: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, L: WasmTy, M: WasmTy, N: WasmTy, O: WasmTy, P: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, F: WasmTy, G: WasmTy, H: WasmTy, I: WasmTy, J: WasmTy, K: WasmTy, L: WasmTy, M: WasmTy, N: WasmTy, O: WasmTy, P: WasmTy, Q: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, E, FlatResult, Data> ExportFunction<Handler, (A, B, C, D, E), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, E: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D, E)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, D, FlatResult, Data> ExportFunction<Handler, (A, B, C, D), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, D: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C, D)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, C, FlatResult, Data> ExportFunction<Handler, (A, B, C), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, C: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B, C)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, B, FlatResult, Data> ExportFunction<Handler, (A, B), FlatResult> for Linker<Data>

where A: WasmTy, B: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A, B)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, A, FlatResult, Data> ExportFunction<Handler, (A,), FlatResult> for Linker<Data>

where A: WasmTy, FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, (A,)) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, FlatResult, Data> ExportFunction<Handler, (), FlatResult> for Linker<Data>

where FlatResult: MaybeFlatType + WasmRet, Handler: Fn(Caller<'_, Data>, ()) -> Result<FlatResult, RuntimeError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, L, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, L: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K, L)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, L, M, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, L: FromToNativeWasmType, M: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K, L, M)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, L, M, N, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, L: FromToNativeWasmType, M: FromToNativeWasmType, N: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, L: FromToNativeWasmType, M: FromToNativeWasmType, N: FromToNativeWasmType, O: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, L: FromToNativeWasmType, M: FromToNativeWasmType, N: FromToNativeWasmType, O: FromToNativeWasmType, P: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, F: FromToNativeWasmType, G: FromToNativeWasmType, H: FromToNativeWasmType, I: FromToNativeWasmType, J: FromToNativeWasmType, K: FromToNativeWasmType, L: FromToNativeWasmType, M: FromToNativeWasmType, N: FromToNativeWasmType, O: FromToNativeWasmType, P: FromToNativeWasmType, Q: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, E, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D, E), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, E: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D, E)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, D, FlatResult, UserData> ExportFunction<Handler, (A, B, C, D), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, D: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C, D)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, C, FlatResult, UserData> ExportFunction<Handler, (A, B, C), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, C: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B, C)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, B, FlatResult, UserData> ExportFunction<Handler, (A, B), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, B: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A, B)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, A, FlatResult, UserData> ExportFunction<Handler, (A,), FlatResult> for InstanceBuilder<UserData>

where A: FromToNativeWasmType, FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, (A,)) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, HandlerError, FlatResult, UserData> ExportFunction<Handler, (), FlatResult> for InstanceBuilder<UserData>

where FlatResult: MaybeFlatType + WasmTypeList, UserData: 'static, HandlerError: Error + Send + Sync + 'static, Handler: Fn(FunctionEnvMut<'_, Environment<UserData>>, ()) -> Result<FlatResult, HandlerError> + Send + Sync + 'static,

impl<Handler, Parameters, Results, UserData> ExportFunction<Handler, Parameters, Results> for MockInstance<UserData>

where Handler: Fn(MockInstance<UserData>, Parameters) -> Result<Results, RuntimeError> + 'static, Parameters: 'static, Results: 'static,