feat: make to_*dynamic_value functions usable without nightly Rust

4 files changed, 40 insertions, 101 deletions

diff --git a/src/di_container/asynchronous.rs b/src/di_container/asynchronous.rs
index a338c0a..6cb54f3 100644
--- a/src/di_container/asynchronous.rs
+++ b/src/di_container/asynchronous.rs
@@ -51,15 +51,17 @@
 //! ```
 use std::any::type_name;
 
+use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
 use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder;
 use crate::di_container::binding_storage::DIContainerBindingStorage;
 use crate::di_container::BindingOptions;
 use crate::errors::async_di_container::AsyncDIContainerError;
+use crate::future::BoxFuture;
 use crate::private::cast::arc::CastArc;
 use crate::private::cast::boxed::CastBox;
 use crate::private::cast::error::CastError;
-use crate::provider::r#async::{AsyncProvidable, IAsyncProvider};
-use crate::ptr::SomePtr;
+use crate::provider::r#async::{AsyncProvidable, IAsyncProvider, ProvidableFunctionKind};
+use crate::ptr::{SomePtr, TransientPtr};
 use crate::util::use_double;
 
 use_double!(crate::dependency_history::DependencyHistory);
@@ -347,12 +349,7 @@ impl AsyncDIContainer
                 ))
             }
             #[cfg(feature = "factory")]
-            AsyncProvidable::Function(
-                func_bound,
-                crate::provider::r#async::ProvidableFunctionKind::UserCalled,
-            ) => {
-                use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
-
+            AsyncProvidable::Function(func_bound, ProvidableFunctionKind::UserCalled) => {
                 let factory = func_bound
                     .as_any()
                     .downcast_ref::<ThreadsafeCastableFunction<Interface, Self>>()
@@ -363,14 +360,7 @@ impl AsyncDIContainer
 
                 Ok(SomePtr::ThreadsafeFactory(factory.call(self).into()))
             }
-            #[cfg(feature = "factory")]
-            AsyncProvidable::Function(
-                func_bound,
-                crate::provider::r#async::ProvidableFunctionKind::Instant,
-            ) => {
-                use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
-                use crate::ptr::TransientPtr;
-
+            AsyncProvidable::Function(func_bound, ProvidableFunctionKind::Instant) => {
                 type Func<Interface> = ThreadsafeCastableFunction<
                     dyn Fn() -> TransientPtr<Interface> + Send + Sync,
                     AsyncDIContainer,
@@ -386,19 +376,12 @@ impl AsyncDIContainer
 
                 Ok(SomePtr::Transient(dynamic_val_func.call(self)()))
             }
-            #[cfg(feature = "factory")]
             AsyncProvidable::Function(
                 func_bound,
-                crate::provider::r#async::ProvidableFunctionKind::AsyncInstant,
+                ProvidableFunctionKind::AsyncInstant,
             ) => {
-                use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
-                use crate::future::BoxFuture;
-                use crate::ptr::TransientPtr;
-
                 type Func<Interface> = ThreadsafeCastableFunction<
-                    dyn Fn<(), Output = BoxFuture<'static, TransientPtr<Interface>>>
-                        + Send
-                        + Sync,
+                    dyn Fn() -> BoxFuture<'static, TransientPtr<Interface>> + Send + Sync,
                     AsyncDIContainer,
                 >;
 
diff --git a/src/di_container/asynchronous/binding/builder.rs b/src/di_container/asynchronous/binding/builder.rs
index 6f1281d..db1b576 100644
--- a/src/di_container/asynchronous/binding/builder.rs
+++ b/src/di_container/asynchronous/binding/builder.rs
@@ -1,13 +1,17 @@
 //! Binding builder for types inside of a [`AsyncDIContainer`].
 use std::any::type_name;
 use std::marker::PhantomData;
+use std::sync::Arc;
 
+use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
 use crate::di_container::asynchronous::binding::scope_configurator::AsyncBindingScopeConfigurator;
-#[cfg(feature = "factory")]
 use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator;
 use crate::di_container::BindingOptions;
 use crate::errors::async_di_container::AsyncBindingBuilderError;
+use crate::future::BoxFuture;
 use crate::interfaces::async_injectable::AsyncInjectable;
+use crate::provider::r#async::{AsyncFunctionProvider, ProvidableFunctionKind};
+use crate::ptr::TransientPtr;
 use crate::util::use_double;
 
 use_double!(crate::dependency_history::DependencyHistory);
@@ -272,11 +276,6 @@ where
             + Send
             + Sync,
     {
-        use std::sync::Arc;
-
-        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
-        use crate::provider::r#async::ProvidableFunctionKind;
-
         if self
             .di_container
             .has_binding::<Interface>(BindingOptions::new())
@@ -291,7 +290,7 @@ where
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
-            Box::new(crate::provider::r#async::AsyncFunctionProvider::new(
+            Box::new(AsyncFunctionProvider::new(
                 Arc::new(factory_impl),
                 ProvidableFunctionKind::UserCalled,
             )),
@@ -343,9 +342,7 @@ where
     /// # Ok(())
     /// # }
     /// ```
-    #[cfg(feature = "factory")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))]
-    pub fn to_dynamic_value<Return, Func>(
+    pub fn to_dynamic_value<Func>(
         self,
         func: &'static Func,
     ) -> Result<
@@ -353,16 +350,12 @@ where
         AsyncBindingBuilderError,
     >
     where
-        Return: 'static + ?Sized,
-        Func: Fn(&AsyncDIContainer) -> BoxFn<(), crate::ptr::TransientPtr<Return>>
+        Func: Fn(
+                &AsyncDIContainer,
+            ) -> Box<dyn Fn() -> TransientPtr<Interface> + Send + Sync>
             + Send
             + Sync,
     {
-        use std::sync::Arc;
-
-        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
-        use crate::provider::r#async::ProvidableFunctionKind;
-
         if self
             .di_container
             .has_binding::<Interface>(BindingOptions::new())
@@ -377,7 +370,7 @@ where
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
-            Box::new(crate::provider::r#async::AsyncFunctionProvider::new(
+            Box::new(AsyncFunctionProvider::new(
                 Arc::new(castable_func),
                 ProvidableFunctionKind::Instant,
             )),
@@ -436,9 +429,7 @@ where
     /// # Ok(())
     /// # }
     /// ```
-    #[cfg(feature = "factory")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))]
-    pub fn to_async_dynamic_value<Return, Func>(
+    pub fn to_async_dynamic_value<Func>(
         self,
         func: &'static Func,
     ) -> Result<
@@ -446,16 +437,13 @@ where
         AsyncBindingBuilderError,
     >
     where
-        Return: 'static + ?Sized,
-        Func: Fn(&AsyncDIContainer) -> BoxFn<(), crate::future::BoxFuture<'static, Return>>
-            + Send
+        Func: Fn(
+                &AsyncDIContainer,
+            ) -> Box<
+                dyn Fn() -> BoxFuture<'static, TransientPtr<Interface>> + Send + Sync,
+            > + Send
             + Sync,
     {
-        use std::sync::Arc;
-
-        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
-        use crate::provider::r#async::ProvidableFunctionKind;
-
         if self
             .di_container
             .has_binding::<Interface>(BindingOptions::new())
@@ -470,7 +458,7 @@ where
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
-            Box::new(crate::provider::r#async::AsyncFunctionProvider::new(
+            Box::new(AsyncFunctionProvider::new(
                 Arc::new(castable_func),
                 ProvidableFunctionKind::AsyncInstant,
             )),
@@ -607,7 +595,6 @@ mod tests
     }
 
     #[tokio::test]
-    #[cfg(feature = "factory")]
     async fn can_bind_to_dynamic_value()
     {
         use crate::ptr::TransientPtr;
@@ -645,7 +632,6 @@ mod tests
     }
 
     #[tokio::test]
-    #[cfg(feature = "factory")]
     async fn can_bind_to_async_dynamic_value()
     {
         use crate::ptr::TransientPtr;
diff --git a/src/di_container/blocking.rs b/src/di_container/blocking.rs
index 3d79ae7..0c464df 100644
--- a/src/di_container/blocking.rs
+++ b/src/di_container/blocking.rs
@@ -51,14 +51,15 @@
 //! ```
 use std::any::type_name;
 
+use crate::castable_function::CastableFunction;
 use crate::di_container::binding_storage::DIContainerBindingStorage;
 use crate::di_container::blocking::binding::builder::BindingBuilder;
 use crate::di_container::BindingOptions;
 use crate::errors::di_container::DIContainerError;
 use crate::private::cast::boxed::CastBox;
 use crate::private::cast::rc::CastRc;
-use crate::provider::blocking::{IProvider, Providable};
-use crate::ptr::SomePtr;
+use crate::provider::blocking::{IProvider, Providable, ProvidableFunctionKind};
+use crate::ptr::{SomePtr, TransientPtr};
 use crate::util::use_double;
 
 use_double!(crate::dependency_history::DependencyHistory);
@@ -284,12 +285,7 @@ impl DIContainer
                 })?,
             )),
             #[cfg(feature = "factory")]
-            Providable::Function(
-                func_bound,
-                crate::provider::blocking::ProvidableFunctionKind::UserCalled,
-            ) => {
-                use crate::castable_function::CastableFunction;
-
+            Providable::Function(func_bound, ProvidableFunctionKind::UserCalled) => {
                 let factory = func_bound
                     .as_any()
                     .downcast_ref::<CastableFunction<Interface, Self>>()
@@ -300,14 +296,7 @@ impl DIContainer
 
                 Ok(SomePtr::Factory(factory.call(self).into()))
             }
-            #[cfg(feature = "factory")]
-            Providable::Function(
-                func_bound,
-                crate::provider::blocking::ProvidableFunctionKind::Instant,
-            ) => {
-                use crate::castable_function::CastableFunction;
-                use crate::ptr::TransientPtr;
-
+            Providable::Function(func_bound, ProvidableFunctionKind::Instant) => {
                 type Func<Interface> =
                     CastableFunction<dyn Fn() -> TransientPtr<Interface>, DIContainer>;
 
diff --git a/src/di_container/blocking/binding/builder.rs b/src/di_container/blocking/binding/builder.rs
index 558db6e..596a2aa 100644
--- a/src/di_container/blocking/binding/builder.rs
+++ b/src/di_container/blocking/binding/builder.rs
@@ -1,13 +1,16 @@
 //! Binding builder for types inside of a [`DIContainer`].
 use std::any::type_name;
 use std::marker::PhantomData;
+use std::rc::Rc;
 
+use crate::castable_function::CastableFunction;
 use crate::di_container::blocking::binding::scope_configurator::BindingScopeConfigurator;
-#[cfg(feature = "factory")]
 use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator;
 use crate::di_container::BindingOptions;
 use crate::errors::di_container::BindingBuilderError;
 use crate::interfaces::injectable::Injectable;
+use crate::provider::blocking::{FunctionProvider, ProvidableFunctionKind};
+use crate::ptr::TransientPtr;
 use crate::util::use_double;
 
 use_double!(crate::dependency_history::DependencyHistory);
@@ -181,11 +184,6 @@ where
         Interface: Fn<Args, Output = crate::ptr::TransientPtr<Return>>,
         Func: Fn(&DIContainer) -> Box<Interface>,
     {
-        use std::rc::Rc;
-
-        use crate::castable_function::CastableFunction;
-        use crate::provider::blocking::ProvidableFunctionKind;
-
         if self
             .di_container
             .has_binding::<Interface>(BindingOptions::new())
@@ -199,7 +197,7 @@ where
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
-            Box::new(crate::provider::blocking::FunctionProvider::new(
+            Box::new(FunctionProvider::new(
                 Rc::new(factory_impl),
                 ProvidableFunctionKind::UserCalled,
             )),
@@ -248,35 +246,19 @@ where
     /// # let mut di_container = DIContainer::new();
     /// #
     /// di_container.bind::<dyn IBuffer>().to_dynamic_value(&|_| {
-    ///     Box::new(|| {
-    ///         let buffer = TransientPtr::new(Buffer::<BUFFER_SIZE>::new());
-    ///
-    ///         buffer as TransientPtr<dyn IBuffer>
-    ///     })
+    ///     Box::new(|| TransientPtr::new(Buffer::<BUFFER_SIZE>::new()))
     /// });
     /// #
     /// # Ok(())
     /// # }
     /// ```
-    #[cfg(feature = "factory")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))]
-    pub fn to_dynamic_value<Return, Func>(
+    pub fn to_dynamic_value<Func>(
         self,
         func: &'static Func,
     ) -> Result<BindingWhenConfigurator<'di_container, Interface>, BindingBuilderError>
     where
-        Return: 'static + ?Sized,
-        Func: Fn(
-            &DIContainer,
-        ) -> crate::ptr::TransientPtr<
-            dyn Fn<(), Output = crate::ptr::TransientPtr<Return>>,
-        >,
+        Func: Fn(&DIContainer) -> TransientPtr<dyn Fn() -> TransientPtr<Interface>>,
     {
-        use std::rc::Rc;
-
-        use crate::castable_function::CastableFunction;
-        use crate::provider::blocking::ProvidableFunctionKind;
-
         if self
             .di_container
             .has_binding::<Interface>(BindingOptions::new())
@@ -290,7 +272,7 @@ where
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
-            Box::new(crate::provider::blocking::FunctionProvider::new(
+            Box::new(FunctionProvider::new(
                 Rc::new(castable_func),
                 ProvidableFunctionKind::Instant,
             )),
@@ -376,7 +358,6 @@ mod tests
     }
 
     #[test]
-    #[cfg(feature = "factory")]
     fn can_bind_to_dynamic_value()
     {
         use crate::ptr::TransientPtr;