Use any-fn crate (#2031)

native/Cargo.toml

@@ -9,9 +9,10 @@ readme.workspace = true
 repository.workspace = true
 
 [features]
-alloc = []
+alloc = ["dep:any-fn"]
 
 [dependencies]
+any-fn = { version = "0.4.1", optional = true }
 heapless = { version = "0.8.0", default-features = false }
 stak-vm = { version = "0.7.21", path = "../vm" }
 

native/src/dynamic.rs

@@ -1,13 +1,10 @@
 //! Native functions dynamically defined.
 
 mod error;
-mod function;
 
-pub use self::{
-    error::DynamicError,
-    function::{DynamicFunction, IntoDynamicFunction},
-};
+pub use self::error::DynamicError;
 use alloc::boxed::Box;
+use any_fn::AnyFn;
 use core::{any::Any, cell::RefCell};
 use heapless::Vec;
 use stak_vm::{Error, Memory, Number, PrimitiveSet, Type};
@@ -16,13 +13,13 @@ const MAXIMUM_ARGUMENT_COUNT: usize = 16;
 
 /// A dynamic primitive set equipped with native functions in Rust.
 pub struct DynamicPrimitiveSet<'a, const N: usize> {
-    functions: &'a mut [DynamicFunction<'a>],
+    functions: &'a mut [AnyFn<'a>],
     objects: [Option<RefCell<Box<dyn Any>>>; N],
 }
 
 impl<'a, const N: usize> DynamicPrimitiveSet<'a, N> {
     /// Creates a primitive set.
-    pub fn new(functions: &'a mut [DynamicFunction<'a>]) -> Self {
+    pub fn new(functions: &'a mut [AnyFn<'a>]) -> Self {
         Self {
             functions,
             // TODO Garbage-collect foreign objects.

native/src/dynamic/error.rs

@@ -1,31 +1,38 @@
+use any_fn::AnyFnError;
 use core::{
-    error,
+    error::Error,
     fmt::{self, Display, Formatter},
 };
 
 /// An error.
 #[derive(Debug)]
 pub enum DynamicError {
-    /// A object downcast error.
-    Downcast,
+    /// An `AnyFn` error.
+    AnyFn(AnyFnError),
     /// A object index error.
     ObjectIndex,
     /// A virtual machine error.
     Vm(stak_vm::Error),
 }
 
+impl From<AnyFnError> for DynamicError {
+    fn from(error: AnyFnError) -> Self {
+        Self::AnyFn(error)
+    }
+}
+
 impl From<stak_vm::Error> for DynamicError {
     fn from(error: stak_vm::Error) -> Self {
         Self::Vm(error)
     }
 }
 
-impl error::Error for DynamicError {}
+impl Error for DynamicError {}
 
 impl Display for DynamicError {
     fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
         match self {
-            Self::Downcast => write!(formatter, "cannot downcast object"),
+            Self::AnyFn(error) => write!(formatter, "{error}"),
             Self::ObjectIndex => write!(formatter, "invalid object index"),
             Self::Vm(error) => write!(formatter, "{error}"),
         }