Merge branch 'master' into plugins

src/fn_native.rs

@@ -1,14 +1,15 @@
 //! Module containing interfaces with native-Rust functions.
 use crate::any::Dynamic;
 use crate::engine::Engine;
-use crate::module::Module;
+use crate::module::{FuncReturn, Module};
 use crate::parser::ScriptFnDef;
 use crate::plugin::PluginFunction;
 use crate::result::EvalAltResult;
 use crate::token::{is_valid_identifier, Position};
-use crate::utils::ImmutableString;
+use crate::utils::{ImmutableString, StaticVec};
+use crate::Scope;
 
-use crate::stdlib::{boxed::Box, convert::TryFrom, fmt, rc::Rc, string::String, sync::Arc};
+use crate::stdlib::{boxed::Box, convert::TryFrom, fmt, mem, rc::Rc, string::String, sync::Arc};
 
 /// Trait that maps to `Send + Sync` only under the `sync` feature.
 #[cfg(feature = "sync")]
@@ -50,14 +51,15 @@ pub fn shared_take<T: Clone>(value: Shared<T>) -> T {
 
 pub type FnCallArgs<'a> = [&'a mut Dynamic];
 
-/// A general function pointer.
-#[derive(Debug, Clone, Eq, PartialEq, Hash, Default)]
-pub struct FnPtr(ImmutableString);
+/// A general function pointer, which may carry additional (i.e. curried) argument values
+/// to be passed onto a function during a call.
+#[derive(Debug, Clone, Default)]
+pub struct FnPtr(ImmutableString, Vec<Dynamic>);
 
 impl FnPtr {
     /// Create a new function pointer.
-    pub(crate) fn new_unchecked<S: Into<ImmutableString>>(name: S) -> Self {
-        Self(name.into())
+    pub(crate) fn new_unchecked<S: Into<ImmutableString>>(name: S, curry: Vec<Dynamic>) -> Self {
+        Self(name.into(), curry)
     }
     /// Get the name of the function.
     pub fn fn_name(&self) -> &str {
@@ -67,9 +69,38 @@ impl FnPtr {
     pub(crate) fn get_fn_name(&self) -> &ImmutableString {
         &self.0
     }
-    /// Get the name of the function.
-    pub(crate) fn take_fn_name(self) -> ImmutableString {
-        self.0
+    /// Get the underlying data of the function pointer.
+    pub(crate) fn take_data(self) -> (ImmutableString, Vec<Dynamic>) {
+        (self.0, self.1)
+    }
+    /// Get the curried arguments.
+    pub fn curry(&self) -> &[Dynamic] {
+        &self.1
+    }
+
+    /// Call the function pointer with curried arguments (if any).
+    ///
+    /// ## WARNING
+    ///
+    /// All the arguments are _consumed_, meaning that they're replaced by `()`.
+    /// This is to avoid unnecessarily cloning the arguments.
+    /// Do not use the arguments after this call. If they are needed afterwards,
+    /// clone them _before_ calling this function.
+    pub fn call_dynamic(
+        &self,
+        engine: &Engine,
+        lib: impl AsRef<Module>,
+        this_ptr: Option<&mut Dynamic>,
+        mut arg_values: impl AsMut<[Dynamic]>,
+    ) -> FuncReturn<Dynamic> {
+        let args = self
+            .1
+            .iter()
+            .cloned()
+            .chain(arg_values.as_mut().iter_mut().map(|v| mem::take(v)))
+            .collect::<StaticVec<_>>();
+
+        engine.call_fn_dynamic(&mut Scope::new(), lib, self.0.as_str(), this_ptr, args)
     }
 }
 
@@ -84,7 +115,7 @@ impl TryFrom<ImmutableString> for FnPtr {
 
     fn try_from(value: ImmutableString) -> Result<Self, Self::Error> {
         if is_valid_identifier(value.chars()) {
-            Ok(Self(value))
+            Ok(Self(value, Default::default()))
         } else {
             Err(Box::new(EvalAltResult::ErrorFunctionNotFound(
                 value.into(),