More flexible chained api about wasmi HOT 6 CLOSED

instance
    .export_by_name(func_name)?
    .as_func()?
    .with_externals(&mut NopExternals)
    .with_args(&args)?
    .invoke()
    .ok()?;

impl FuncRef {
    pub fn with_externals<'a, E: Externals>(
        &'a self,
        externals: &'a mut E,
    ) -> BoundExternalsFunc<'a, E> {
        BoundExternalsFunc {
            func_instance: self,
            externals,
        }
    }
}

/// First step in chained function calling pattern.                                                                                  
pub struct BoundExternalsFunc<'a, E: Externals + 'a> {
    func_instance: &'a FuncRef,
    externals: &'a mut E,
}

impl<'a, E: Externals> BoundExternalsFunc<'a, E> {
    pub fn with_args(self, args: &'a [RuntimeValue]) -> Option<BoundFunc<'a, E>> {
        BoundFunc::new(self.func_instance, self.externals, args)
    }
}

/// FuncRef with verified arguments.                                                                                                 
pub struct BoundFunc<'a, E: Externals + 'a> {
    func_instance: &'a FuncRef,
    externals: &'a mut E,
    args: &'a [RuntimeValue],
}

impl<'a, E: Externals> BoundFunc<'a, E> {
    fn new(
        func_instance: &'a FuncRef,
        externals: &'a mut E,
        args: &'a [RuntimeValue],
    ) -> Option<BoundFunc<'a, E>> {
        check_function_args(func_instance.signature(), &args).ok()?;
        Some(BoundFunc {
            func_instance,
            externals,
            args,
        })
    }

    pub fn invoke(&mut self) -> Result<Option<RuntimeValue>, Trap> {
        FuncInstance::invoke(&self.func_instance, self.args, self.externals)
    }
}