refactor: rename castable factory to castable function

9 files changed, 75 insertions, 70 deletions

diff --git a/src/castable_factory/mod.rs b/src/castable_function/mod.rs
index 0cb2127..4c2f0db 100644
--- a/src/castable_factory/mod.rs
+++ b/src/castable_function/mod.rs
@@ -6,13 +6,13 @@ use crate::ptr::TransientPtr;
 #[cfg(feature = "async")]
 pub mod threadsafe;
 
-/// Interface for any castable factory.
-pub trait AnyCastableFactory: Any + Debug
+/// Interface for any castable function.
+pub trait AnyCastableFunction: Any + Debug
 {
     fn as_any(&self) -> &dyn Any;
 }
 
-pub struct CastableFactory<ReturnInterface, DIContainerT>
+pub struct CastableFunction<ReturnInterface, DIContainerT>
 where
     ReturnInterface: 'static + ?Sized,
     DIContainerT: 'static,
@@ -20,7 +20,7 @@ where
     func: &'static dyn Fn(&DIContainerT) -> TransientPtr<ReturnInterface>,
 }
 
-impl<ReturnInterface, DIContainerT> CastableFactory<ReturnInterface, DIContainerT>
+impl<ReturnInterface, DIContainerT> CastableFunction<ReturnInterface, DIContainerT>
 where
     ReturnInterface: 'static + ?Sized,
 {
@@ -37,8 +37,8 @@ where
     }
 }
 
-impl<ReturnInterface, DIContainerT> AnyCastableFactory
-    for CastableFactory<ReturnInterface, DIContainerT>
+impl<ReturnInterface, DIContainerT> AnyCastableFunction
+    for CastableFunction<ReturnInterface, DIContainerT>
 where
     ReturnInterface: 'static + ?Sized,
     DIContainerT: 'static,
@@ -50,7 +50,7 @@ where
 }
 
 impl<ReturnInterface, DIContainerT> Debug
-    for CastableFactory<ReturnInterface, DIContainerT>
+    for CastableFunction<ReturnInterface, DIContainerT>
 where
     ReturnInterface: 'static + ?Sized,
 {
@@ -60,7 +60,7 @@ where
         let ret = type_name::<TransientPtr<ReturnInterface>>();
 
         formatter.write_fmt(format_args!(
-            "CastableFactory (&DIContainer) -> {ret} {{ ... }}"
+            "CastableFunction (&DIContainer) -> {ret} {{ ... }}"
         ))
     }
 }
@@ -80,13 +80,13 @@ mod tests
     #[test]
     fn can_call()
     {
-        let castable_factory = CastableFactory::new(&|_: &MockDIContainer| {
+        let castable_func = CastableFunction::new(&|_: &MockDIContainer| {
             TransientPtr::new(Bacon { heal_amount: 27 })
         });
 
         let mock_di_container = MockDIContainer::new();
 
-        let output = castable_factory.call(&mock_di_container);
+        let output = castable_func.call(&mock_di_container);
 
         assert_eq!(output, TransientPtr::new(Bacon { heal_amount: 27 }));
     }
diff --git a/src/castable_factory/threadsafe.rs b/src/castable_function/threadsafe.rs
index 8b1e66d..7543396 100644
--- a/src/castable_factory/threadsafe.rs
+++ b/src/castable_function/threadsafe.rs
@@ -1,13 +1,16 @@
 use std::any::{type_name, Any};
 use std::fmt::Debug;
 
-use crate::castable_factory::AnyCastableFactory;
+use crate::castable_function::AnyCastableFunction;
 use crate::ptr::TransientPtr;
 
-/// Interface for any threadsafe castable factory.
-pub trait AnyThreadsafeCastableFactory: AnyCastableFactory + Send + Sync + Debug {}
+/// Interface for any threadsafe castable function.
+pub trait AnyThreadsafeCastableFunction:
+    AnyCastableFunction + Send + Sync + Debug
+{
+}
 
-pub struct ThreadsafeCastableFactory<ReturnInterface, DIContainerT>
+pub struct ThreadsafeCastableFunction<ReturnInterface, DIContainerT>
 where
     DIContainerT: 'static,
     ReturnInterface: 'static + ?Sized,
@@ -16,7 +19,7 @@ where
 }
 
 impl<ReturnInterface, DIContainerT>
-    ThreadsafeCastableFactory<ReturnInterface, DIContainerT>
+    ThreadsafeCastableFunction<ReturnInterface, DIContainerT>
 where
     DIContainerT: 'static,
     ReturnInterface: 'static + ?Sized,
@@ -36,8 +39,8 @@ where
     }
 }
 
-impl<ReturnInterface, DIContainerT> AnyCastableFactory
-    for ThreadsafeCastableFactory<ReturnInterface, DIContainerT>
+impl<ReturnInterface, DIContainerT> AnyCastableFunction
+    for ThreadsafeCastableFunction<ReturnInterface, DIContainerT>
 where
     DIContainerT: 'static,
     ReturnInterface: 'static + ?Sized,
@@ -48,8 +51,8 @@ where
     }
 }
 
-impl<ReturnInterface, DIContainerT> AnyThreadsafeCastableFactory
-    for ThreadsafeCastableFactory<ReturnInterface, DIContainerT>
+impl<ReturnInterface, DIContainerT> AnyThreadsafeCastableFunction
+    for ThreadsafeCastableFunction<ReturnInterface, DIContainerT>
 where
     DIContainerT: 'static,
     ReturnInterface: 'static + ?Sized,
@@ -57,7 +60,7 @@ where
 }
 
 impl<ReturnInterface, DIContainerT> Debug
-    for ThreadsafeCastableFactory<ReturnInterface, DIContainerT>
+    for ThreadsafeCastableFunction<ReturnInterface, DIContainerT>
 where
     DIContainerT: 'static,
     ReturnInterface: 'static + ?Sized,
@@ -68,7 +71,7 @@ where
         let ret = type_name::<TransientPtr<ReturnInterface>>();
 
         formatter.write_fmt(format_args!(
-            "ThreadsafeCastableFactory (&AsyncDIContainer) -> {ret} {{ ... }}",
+            "ThreadsafeCastableFunction(&AsyncDIContainer) -> {ret} {{ ... }}",
         ))
     }
 }
@@ -88,14 +91,14 @@ mod tests
     #[test]
     fn can_call()
     {
-        let castable_factory =
-            ThreadsafeCastableFactory::new(&|_: &MockAsyncDIContainer| {
+        let castable_function =
+            ThreadsafeCastableFunction::new(&|_: &MockAsyncDIContainer| {
                 TransientPtr::new(Bacon { heal_amount: 27 })
             });
 
         let mock_di_container = MockAsyncDIContainer::new();
 
-        let output = castable_factory.call(&mock_di_container);
+        let output = castable_function.call(&mock_di_container);
 
         assert_eq!(output, TransientPtr::new(Bacon { heal_amount: 27 }));
     }
diff --git a/src/di_container/asynchronous/binding/builder.rs b/src/di_container/asynchronous/binding/builder.rs
index f42e6a1..8465c9a 100644
--- a/src/di_container/asynchronous/binding/builder.rs
+++ b/src/di_container/asynchronous/binding/builder.rs
@@ -173,7 +173,7 @@ where
         Interface: Fn<Args, Output = Return> + Send + Sync,
         FactoryFunc: Fn(&AsyncDIContainer) -> BoxFn<Args, Return> + Send + Sync,
     {
-        use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
         use crate::provider::r#async::AsyncFactoryVariant;
 
         if self
@@ -186,7 +186,7 @@ where
             )));
         }
 
-        let factory_impl = ThreadsafeCastableFactory::new(factory_func);
+        let factory_impl = ThreadsafeCastableFunction::new(factory_func);
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
@@ -270,7 +270,7 @@ where
             + Send
             + Sync,
     {
-        use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
         use crate::provider::r#async::AsyncFactoryVariant;
 
         if self
@@ -283,7 +283,7 @@ where
             )));
         }
 
-        let factory_impl = ThreadsafeCastableFactory::new(factory_func);
+        let factory_impl = ThreadsafeCastableFunction::new(factory_func);
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
@@ -354,7 +354,7 @@ where
             + Send
             + Sync,
     {
-        use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
         use crate::provider::r#async::AsyncFactoryVariant;
 
         if self
@@ -367,7 +367,7 @@ where
             )));
         }
 
-        let factory_impl = ThreadsafeCastableFactory::new(factory_func);
+        let factory_impl = ThreadsafeCastableFunction::new(factory_func);
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
@@ -445,7 +445,7 @@ where
             + Send
             + Sync,
     {
-        use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
         use crate::provider::r#async::AsyncFactoryVariant;
 
         if self
@@ -458,7 +458,7 @@ where
             )));
         }
 
-        let factory_impl = ThreadsafeCastableFactory::new(factory_func);
+        let factory_impl = ThreadsafeCastableFunction::new(factory_func);
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
diff --git a/src/di_container/asynchronous/mod.rs b/src/di_container/asynchronous/mod.rs
index 3e29ef6..c993b8b 100644
--- a/src/di_container/asynchronous/mod.rs
+++ b/src/di_container/asynchronous/mod.rs
@@ -348,11 +348,11 @@ impl AsyncDIContainer
             }
             #[cfg(feature = "factory")]
             AsyncProvidable::Factory(factory_binding) => {
-                use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+                use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
 
                 let factory = factory_binding
                     .as_any()
-                    .downcast_ref::<ThreadsafeCastableFactory<Interface, Self>>()
+                    .downcast_ref::<ThreadsafeCastableFunction<Interface, Self>>()
                     .ok_or_else(|| AsyncDIContainerError::CastFailed {
                         interface: type_name::<Interface>(),
                         binding_kind: "factory",
@@ -362,10 +362,10 @@ impl AsyncDIContainer
             }
             #[cfg(feature = "factory")]
             AsyncProvidable::DefaultFactory(binding) => {
-                use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+                use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
                 use crate::ptr::TransientPtr;
 
-                type DefaultFactoryFn<Interface> = ThreadsafeCastableFactory<
+                type DefaultFactoryFn<Interface> = ThreadsafeCastableFunction<
                     dyn Fn() -> TransientPtr<Interface> + Send + Sync,
                     AsyncDIContainer,
                 >;
@@ -382,11 +382,11 @@ impl AsyncDIContainer
             }
             #[cfg(feature = "factory")]
             AsyncProvidable::AsyncDefaultFactory(binding) => {
-                use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+                use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
                 use crate::future::BoxFuture;
                 use crate::ptr::TransientPtr;
 
-                type AsyncDefaultFactoryFn<Interface> = ThreadsafeCastableFactory<
+                type AsyncDefaultFactoryFn<Interface> = ThreadsafeCastableFunction<
                     dyn Fn<(), Output = BoxFuture<'static, TransientPtr<Interface>>>
                         + Send
                         + Sync,
@@ -652,7 +652,7 @@ mod tests
             }
         }
 
-        use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
 
         type IUserManagerFactory =
             dyn Fn(Vec<i128>) -> TransientPtr<dyn IUserManager> + Send + Sync;
@@ -674,7 +674,7 @@ mod tests
             inner_mock_provider.expect_provide().returning(|_, _| {
                 Ok(AsyncProvidable::Factory(
                     crate::ptr::ThreadsafeFactoryPtr::new(
-                        ThreadsafeCastableFactory::new(factory_func),
+                        ThreadsafeCastableFunction::new(factory_func),
                     ),
                 ))
             });
@@ -734,7 +734,7 @@ mod tests
             }
         }
 
-        use crate::castable_factory::threadsafe::ThreadsafeCastableFactory;
+        use crate::castable_function::threadsafe::ThreadsafeCastableFunction;
 
         type IUserManagerFactory =
             dyn Fn(Vec<i128>) -> TransientPtr<dyn IUserManager> + Send + Sync;
@@ -756,7 +756,7 @@ mod tests
             inner_mock_provider.expect_provide().returning(|_, _| {
                 Ok(AsyncProvidable::Factory(
                     crate::ptr::ThreadsafeFactoryPtr::new(
-                        ThreadsafeCastableFactory::new(factory_func),
+                        ThreadsafeCastableFunction::new(factory_func),
                     ),
                 ))
             });
diff --git a/src/di_container/blocking/binding/builder.rs b/src/di_container/blocking/binding/builder.rs
index 9f7f6f9..ead1a54 100644
--- a/src/di_container/blocking/binding/builder.rs
+++ b/src/di_container/blocking/binding/builder.rs
@@ -181,7 +181,7 @@ where
         Interface: Fn<Args, Output = crate::ptr::TransientPtr<Return>>,
         Func: Fn(&DIContainer) -> Box<Interface>,
     {
-        use crate::castable_factory::CastableFactory;
+        use crate::castable_function::CastableFunction;
 
         if self
             .di_container
@@ -192,7 +192,7 @@ where
             >()));
         }
 
-        let factory_impl = CastableFactory::new(factory_func);
+        let factory_impl = CastableFunction::new(factory_func);
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
@@ -269,7 +269,7 @@ where
             dyn Fn<(), Output = crate::ptr::TransientPtr<Return>>,
         >,
     {
-        use crate::castable_factory::CastableFactory;
+        use crate::castable_function::CastableFunction;
 
         if self
             .di_container
@@ -280,7 +280,7 @@ where
             >()));
         }
 
-        let factory_impl = CastableFactory::new(factory_func);
+        let factory_impl = CastableFunction::new(factory_func);
 
         self.di_container.set_binding::<Interface>(
             BindingOptions::new(),
diff --git a/src/di_container/blocking/mod.rs b/src/di_container/blocking/mod.rs
index d9efe94..d8b0d59 100644
--- a/src/di_container/blocking/mod.rs
+++ b/src/di_container/blocking/mod.rs
@@ -285,11 +285,11 @@ impl DIContainer
             )),
             #[cfg(feature = "factory")]
             Providable::Factory(factory_binding) => {
-                use crate::castable_factory::CastableFactory;
+                use crate::castable_function::CastableFunction;
 
                 let factory = factory_binding
                     .as_any()
-                    .downcast_ref::<CastableFactory<Interface, Self>>()
+                    .downcast_ref::<CastableFunction<Interface, Self>>()
                     .ok_or_else(|| DIContainerError::CastFailed {
                         interface: type_name::<Interface>(),
                         binding_kind: "factory",
@@ -299,11 +299,11 @@ impl DIContainer
             }
             #[cfg(feature = "factory")]
             Providable::DefaultFactory(factory_binding) => {
-                use crate::castable_factory::CastableFactory;
+                use crate::castable_function::CastableFunction;
                 use crate::ptr::TransientPtr;
 
                 type DefaultFactoryFn<Interface> =
-                    CastableFactory<dyn Fn() -> TransientPtr<Interface>, DIContainer>;
+                    CastableFunction<dyn Fn() -> TransientPtr<Interface>, DIContainer>;
 
                 let default_factory = factory_binding
                     .as_any()
@@ -517,7 +517,7 @@ mod tests
     #[cfg(feature = "factory")]
     fn can_get_factory()
     {
-        use crate::castable_factory::CastableFactory;
+        use crate::castable_function::CastableFunction;
         use crate::ptr::FactoryPtr;
 
         trait IUserManager
@@ -572,7 +572,7 @@ mod tests
         let mut mock_provider = MockIProvider::new();
 
         mock_provider.expect_provide().returning_st(|_, _| {
-            Ok(Providable::Factory(FactoryPtr::new(CastableFactory::new(
+            Ok(Providable::Factory(FactoryPtr::new(CastableFunction::new(
                 factory_func,
             ))))
         });
@@ -592,7 +592,7 @@ mod tests
     #[cfg(feature = "factory")]
     fn can_get_factory_named()
     {
-        use crate::castable_factory::CastableFactory;
+        use crate::castable_function::CastableFunction;
         use crate::ptr::FactoryPtr;
 
         trait IUserManager
@@ -647,7 +647,7 @@ mod tests
         let mut mock_provider = MockIProvider::new();
 
         mock_provider.expect_provide().returning_st(|_, _| {
-            Ok(Providable::Factory(FactoryPtr::new(CastableFactory::new(
+            Ok(Providable::Factory(FactoryPtr::new(CastableFunction::new(
                 factory_func,
             ))))
         });
diff --git a/src/lib.rs b/src/lib.rs
index 5544faa..d061be6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -111,7 +111,7 @@ mod provider;
 mod util;
 
 #[cfg(feature = "factory")]
-mod castable_factory;
+mod castable_function;
 
 #[cfg(test)]
 #[cfg(not(tarpaulin_include))]
diff --git a/src/provider/async.rs b/src/provider/async.rs
index 6ccb082..68eed87 100644
--- a/src/provider/async.rs
+++ b/src/provider/async.rs
@@ -17,19 +17,19 @@ pub enum AsyncProvidable<DIContainerT>
     #[cfg(feature = "factory")]
     Factory(
         crate::ptr::ThreadsafeFactoryPtr<
-            dyn crate::castable_factory::threadsafe::AnyThreadsafeCastableFactory,
+            dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
         >,
     ),
     #[cfg(feature = "factory")]
     DefaultFactory(
         crate::ptr::ThreadsafeFactoryPtr<
-            dyn crate::castable_factory::threadsafe::AnyThreadsafeCastableFactory,
+            dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
         >,
     ),
     #[cfg(feature = "factory")]
     AsyncDefaultFactory(
         crate::ptr::ThreadsafeFactoryPtr<
-            dyn crate::castable_factory::threadsafe::AnyThreadsafeCastableFactory,
+            dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
         >,
     ),
 }
@@ -189,7 +189,7 @@ pub enum AsyncFactoryVariant
 pub struct AsyncFactoryProvider
 {
     factory: crate::ptr::ThreadsafeFactoryPtr<
-        dyn crate::castable_factory::threadsafe::AnyThreadsafeCastableFactory,
+        dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
     >,
     variant: AsyncFactoryVariant,
 }
@@ -199,7 +199,7 @@ impl AsyncFactoryProvider
 {
     pub fn new(
         factory: crate::ptr::ThreadsafeFactoryPtr<
-            dyn crate::castable_factory::threadsafe::AnyThreadsafeCastableFactory,
+            dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
         >,
         variant: AsyncFactoryVariant,
     ) -> Self
@@ -309,14 +309,14 @@ mod tests
     {
         use std::any::Any;
 
-        use crate::castable_factory::threadsafe::AnyThreadsafeCastableFactory;
-        use crate::castable_factory::AnyCastableFactory;
+        use crate::castable_function::threadsafe::AnyThreadsafeCastableFunction;
+        use crate::castable_function::AnyCastableFunction;
         use crate::ptr::ThreadsafeFactoryPtr;
 
         #[derive(Debug)]
         struct FooFactory;
 
-        impl AnyCastableFactory for FooFactory
+        impl AnyCastableFunction for FooFactory
         {
             fn as_any(&self) -> &dyn Any
             {
@@ -324,7 +324,7 @@ mod tests
             }
         }
 
-        impl AnyThreadsafeCastableFactory for FooFactory {}
+        impl AnyThreadsafeCastableFunction for FooFactory {}
 
         let factory_provider = AsyncFactoryProvider::new(
             ThreadsafeFactoryPtr::new(FooFactory),
diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs
index 65e315d..6475dc7 100644
--- a/src/provider/blocking.rs
+++ b/src/provider/blocking.rs
@@ -13,10 +13,10 @@ pub enum Providable<DIContainerType>
     Transient(TransientPtr<dyn Injectable<DIContainerType>>),
     Singleton(SingletonPtr<dyn Injectable<DIContainerType>>),
     #[cfg(feature = "factory")]
-    Factory(crate::ptr::FactoryPtr<dyn crate::castable_factory::AnyCastableFactory>),
+    Factory(crate::ptr::FactoryPtr<dyn crate::castable_function::AnyCastableFunction>),
     #[cfg(feature = "factory")]
     DefaultFactory(
-        crate::ptr::FactoryPtr<dyn crate::castable_factory::AnyCastableFactory>,
+        crate::ptr::FactoryPtr<dyn crate::castable_function::AnyCastableFunction>,
     ),
 }
 
@@ -110,7 +110,7 @@ where
 #[cfg(feature = "factory")]
 pub struct FactoryProvider
 {
-    factory: crate::ptr::FactoryPtr<dyn crate::castable_factory::AnyCastableFactory>,
+    factory: crate::ptr::FactoryPtr<dyn crate::castable_function::AnyCastableFunction>,
     is_default_factory: bool,
 }
 
@@ -118,7 +118,9 @@ pub struct FactoryProvider
 impl FactoryProvider
 {
     pub fn new(
-        factory: crate::ptr::FactoryPtr<dyn crate::castable_factory::AnyCastableFactory>,
+        factory: crate::ptr::FactoryPtr<
+            dyn crate::castable_function::AnyCastableFunction,
+        >,
         is_default_factory: bool,
     ) -> Self
     {
@@ -200,13 +202,13 @@ mod tests
     {
         use std::any::Any;
 
-        use crate::castable_factory::AnyCastableFactory;
+        use crate::castable_function::AnyCastableFunction;
         use crate::ptr::FactoryPtr;
 
         #[derive(Debug)]
         struct FooFactory;
 
-        impl AnyCastableFactory for FooFactory
+        impl AnyCastableFunction for FooFactory
         {
             fn as_any(&self) -> &dyn Any
             {