refactor!: remove IDependencyHistory

BREAKING CHANGE: IDependencyHistory has been removed as part of an effort to simplify the API. This affects IDIContainer, DIContainer, IAsyncDIContainer, AsyncDIContainer, Injectable, AsyncInjectable, BindingBuilder, AsyncBindingBuilder, BindingScopeConfigurator, BindingWhenConfigurator, AsyncBindingScopeConfigurator, AsyncBindingWhenConfigurator and DependencyHistory

16 files changed, 386 insertions, 579 deletions

diff --git a/src/dependency_history.rs b/src/dependency_history.rs
index 4e36a7b..cd4e77d 100644
--- a/src/dependency_history.rs
+++ b/src/dependency_history.rs
@@ -7,18 +7,6 @@ use std::fmt::{Debug, Display};
 const BOLD_MODE: &str = "\x1b[1m";
 const RESET_BOLD_MODE: &str = "\x1b[22m";
 
-/// Dependency history interface.
-///
-/// **This trait is sealed and cannot be implemented for types outside this crate.**
-pub trait IDependencyHistory: private::Sealed
-{
-    #[doc(hidden)]
-    fn push<Dependency: 'static + ?Sized>(&mut self);
-
-    #[doc(hidden)]
-    fn contains<Dependency: 'static + ?Sized>(&self) -> bool;
-}
-
 /// Dependency history.
 #[derive(Clone, Debug)]
 pub struct DependencyHistory
@@ -35,16 +23,18 @@ impl DependencyHistory
     }
 }
 
-impl IDependencyHistory for DependencyHistory
+#[cfg_attr(test, mockall::automock)]
+impl DependencyHistory
 {
     #[doc(hidden)]
-    fn push<Dependency: 'static + ?Sized>(&mut self)
+    pub fn push<Dependency: 'static + ?Sized>(&mut self)
     {
         self.inner.push(type_name::<Dependency>());
     }
 
     #[doc(hidden)]
-    fn contains<Dependency: 'static + ?Sized>(&self) -> bool
+    #[allow(clippy::must_use_candidate)]
+    pub fn contains<Dependency: 'static + ?Sized>(&self) -> bool
     {
         self.inner.contains(&type_name::<Dependency>())
     }
diff --git a/src/di_container/asynchronous/binding/builder.rs b/src/di_container/asynchronous/binding/builder.rs
index d33b840..45597e8 100644
--- a/src/di_container/asynchronous/binding/builder.rs
+++ b/src/di_container/asynchronous/binding/builder.rs
@@ -5,13 +5,15 @@ use std::any::type_name;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use crate::dependency_history::IDependencyHistory;
 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::asynchronous::IAsyncDIContainer;
 use crate::errors::async_di_container::AsyncBindingBuilderError;
 use crate::interfaces::async_injectable::AsyncInjectable;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 /// Alias for a threadsafe boxed function.
 #[cfg(feature = "factory")]
@@ -22,28 +24,25 @@ pub type BoxFn<Args, Return> = Box<(dyn Fn<Args, Output = Return> + Send + Sync)
 ///
 /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer
 #[must_use = "No binding will be created if you don't use the binding builder"]
-pub struct AsyncBindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+pub struct AsyncBindingBuilder<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized + Send + Sync,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     di_container: Arc<DIContainerType>,
-    dependency_history_factory: fn() -> DependencyHistoryType,
+    dependency_history_factory: fn() -> DependencyHistory,
 
     interface_phantom: PhantomData<Interface>,
 }
 
-impl<Interface, DIContainerType, DependencyHistoryType>
-    AsyncBindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> AsyncBindingBuilder<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized + Send + Sync,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+    DIContainerType: IAsyncDIContainer,
 {
     pub(crate) fn new(
         di_container: Arc<DIContainerType>,
-        dependency_history_factory: fn() -> DependencyHistoryType,
+        dependency_history_factory: fn() -> DependencyHistory,
     ) -> Self
     {
         Self {
@@ -99,16 +98,11 @@ where
     pub async fn to<Implementation>(
         self,
     ) -> Result<
-        AsyncBindingScopeConfigurator<
-            Interface,
-            Implementation,
-            DIContainerType,
-            DependencyHistoryType,
-        >,
+        AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>,
         AsyncBindingBuilderError,
     >
     where
-        Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>,
+        Implementation: AsyncInjectable<DIContainerType>,
     {
         if self.di_container.has_binding::<Interface>(None).await {
             return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::<
@@ -182,7 +176,7 @@ where
         self,
         factory_func: &'static FactoryFunc,
     ) -> Result<
-        AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+        AsyncBindingWhenConfigurator<Interface, DIContainerType>,
         AsyncBindingBuilderError,
     >
     where
@@ -277,7 +271,7 @@ where
         self,
         factory_func: &'static FactoryFunc,
     ) -> Result<
-        AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+        AsyncBindingWhenConfigurator<Interface, DIContainerType>,
         AsyncBindingBuilderError,
     >
     where
@@ -370,7 +364,7 @@ where
         self,
         factory_func: &'static FactoryFunc,
     ) -> Result<
-        AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+        AsyncBindingWhenConfigurator<Interface, DIContainerType>,
         AsyncBindingBuilderError,
     >
     where
@@ -465,7 +459,7 @@ where
         self,
         factory_func: &'static FactoryFunc,
     ) -> Result<
-        AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+        AsyncBindingWhenConfigurator<Interface, DIContainerType>,
         AsyncBindingBuilderError,
     >
     where
@@ -510,14 +504,14 @@ mod tests
     use mockall::predicate::eq;
 
     use super::*;
+    use crate::dependency_history::MockDependencyHistory;
     use crate::test_utils::{mocks, subjects_async};
 
     #[tokio::test]
     async fn can_bind_to() -> Result<(), Box<dyn Error>>
     {
-        let mut di_container_mock = mocks::async_di_container::MockAsyncDIContainer::<
-            mocks::MockDependencyHistory,
-        >::new();
+        let mut di_container_mock =
+            mocks::async_di_container::MockAsyncDIContainer::new();
 
         di_container_mock
             .expect_has_binding::<dyn subjects_async::IUserManager>()
@@ -531,14 +525,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = AsyncBindingBuilder::<
-            dyn subjects_async::IUserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            AsyncBindingBuilder::<
+                dyn subjects_async::IUserManager,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_builder.to::<subjects_async::UserManager>().await?;
 
@@ -575,14 +566,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = AsyncBindingBuilder::<
-            IUserManagerFactory,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            AsyncBindingBuilder::<
+                IUserManagerFactory,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_builder
             .to_factory(&|_| {
@@ -624,14 +612,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = AsyncBindingBuilder::<
-            IUserManagerFactory,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            AsyncBindingBuilder::<
+                IUserManagerFactory,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_builder
             .to_async_factory(&|_| {
@@ -673,14 +658,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = AsyncBindingBuilder::<
-            dyn subjects_async::IUserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            AsyncBindingBuilder::<
+                dyn subjects_async::IUserManager,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_builder
             .to_default_factory(&|_| {
@@ -723,14 +705,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = AsyncBindingBuilder::<
-            dyn subjects_async::IUserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            AsyncBindingBuilder::<
+                dyn subjects_async::IUserManager,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_builder
             .to_async_default_factory(&|_| {
diff --git a/src/di_container/asynchronous/binding/scope_configurator.rs b/src/di_container/asynchronous/binding/scope_configurator.rs
index 023bb5e..a4a684b 100644
--- a/src/di_container/asynchronous/binding/scope_configurator.rs
+++ b/src/di_container/asynchronous/binding/scope_configurator.rs
@@ -4,51 +4,42 @@
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator;
 use crate::di_container::asynchronous::IAsyncDIContainer;
 use crate::errors::async_di_container::AsyncBindingScopeConfiguratorError;
 use crate::interfaces::async_injectable::AsyncInjectable;
 use crate::provider::r#async::{AsyncSingletonProvider, AsyncTransientTypeProvider};
 use crate::ptr::ThreadsafeSingletonPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 /// Scope configurator for a binding for type `Interface` inside a [`IAsyncDIContainer`].
 ///
 /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer
-pub struct AsyncBindingScopeConfigurator<
-    Interface,
-    Implementation,
-    DIContainerType,
-    DependencyHistoryType,
-> where
+pub struct AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>
+where
     Interface: 'static + ?Sized + Send + Sync,
-    Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    Implementation: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     di_container: Arc<DIContainerType>,
-    dependency_history_factory: fn() -> DependencyHistoryType,
+    dependency_history_factory: fn() -> DependencyHistory,
 
     interface_phantom: PhantomData<Interface>,
     implementation_phantom: PhantomData<Implementation>,
 }
 
-impl<Interface, Implementation, DIContainerType, DependencyHistoryType>
-    AsyncBindingScopeConfigurator<
-        Interface,
-        Implementation,
-        DIContainerType,
-        DependencyHistoryType,
-    >
+impl<Interface, Implementation, DIContainerType>
+    AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>
 where
     Interface: 'static + ?Sized + Send + Sync,
-    Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+    Implementation: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     pub(crate) fn new(
         di_container: Arc<DIContainerType>,
-        dependency_history_factory: fn() -> DependencyHistoryType,
+        dependency_history_factory: fn() -> DependencyHistory,
     ) -> Self
     {
         Self {
@@ -64,7 +55,7 @@ where
     /// This is the default.
     pub async fn in_transient_scope(
         self,
-    ) -> AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+    ) -> AsyncBindingWhenConfigurator<Interface, DIContainerType>
     {
         self.set_in_transient_scope().await;
 
@@ -78,7 +69,7 @@ where
     pub async fn in_singleton_scope(
         self,
     ) -> Result<
-        AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+        AsyncBindingWhenConfigurator<Interface, DIContainerType>,
         AsyncBindingScopeConfiguratorError,
     >
     {
@@ -107,11 +98,9 @@ where
         self.di_container
             .set_binding::<Interface>(
                 None,
-                Box::new(AsyncTransientTypeProvider::<
-                    Implementation,
-                    DIContainerType,
-                    DependencyHistoryType,
-                >::new()),
+                Box::new(
+                    AsyncTransientTypeProvider::<Implementation, DIContainerType>::new(),
+                ),
             )
             .await;
     }
@@ -121,6 +110,7 @@ where
 mod tests
 {
     use super::*;
+    use crate::dependency_history::MockDependencyHistory;
     use crate::test_utils::{mocks, subjects_async};
 
     #[tokio::test]
@@ -135,15 +125,12 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_scope_configurator = AsyncBindingScopeConfigurator::<
-            dyn subjects_async::IUserManager,
-            subjects_async::UserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_scope_configurator =
+            AsyncBindingScopeConfigurator::<
+                dyn subjects_async::IUserManager,
+                subjects_async::UserManager,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_scope_configurator.in_transient_scope().await;
     }
@@ -160,15 +147,12 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_scope_configurator = AsyncBindingScopeConfigurator::<
-            dyn subjects_async::IUserManager,
-            subjects_async::UserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Arc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_scope_configurator =
+            AsyncBindingScopeConfigurator::<
+                dyn subjects_async::IUserManager,
+                subjects_async::UserManager,
+                mocks::async_di_container::MockAsyncDIContainer,
+            >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
 
         assert!(binding_scope_configurator
             .in_singleton_scope()
diff --git a/src/di_container/asynchronous/binding/when_configurator.rs b/src/di_container/asynchronous/binding/when_configurator.rs
index 39e1807..d08239e 100644
--- a/src/di_container/asynchronous/binding/when_configurator.rs
+++ b/src/di_container/asynchronous/binding/when_configurator.rs
@@ -5,38 +5,32 @@ use std::any::type_name;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::asynchronous::IAsyncDIContainer;
 use crate::errors::async_di_container::AsyncBindingWhenConfiguratorError;
 
 /// When configurator for a binding for type `Interface` inside a [`IAsyncDIContainer`].
 ///
 /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer
-pub struct AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+pub struct AsyncBindingWhenConfigurator<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized + Send + Sync,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     di_container: Arc<DIContainerType>,
 
     interface_phantom: PhantomData<Interface>,
-    dependency_history_phantom: PhantomData<DependencyHistoryType>,
 }
 
-impl<Interface, DIContainerType, DependencyHistoryType>
-    AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> AsyncBindingWhenConfigurator<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized + Send + Sync,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     pub(crate) fn new(di_container: Arc<DIContainerType>) -> Self
     {
         Self {
             di_container,
             interface_phantom: PhantomData,
-            dependency_history_phantom: PhantomData,
         }
     }
 
@@ -99,8 +93,7 @@ mod tests
 
         let binding_when_configurator = AsyncBindingWhenConfigurator::<
             dyn subjects_async::INumber,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
+            mocks::async_di_container::MockAsyncDIContainer,
         >::new(Arc::new(di_container_mock));
 
         assert!(binding_when_configurator
diff --git a/src/di_container/asynchronous/mod.rs b/src/di_container/asynchronous/mod.rs
index b603e88..927f549 100644
--- a/src/di_container/asynchronous/mod.rs
+++ b/src/di_container/asynchronous/mod.rs
@@ -57,7 +57,6 @@ use std::sync::Arc;
 use async_lock::Mutex;
 use async_trait::async_trait;
 
-use crate::dependency_history::{DependencyHistory, IDependencyHistory};
 use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder;
 use crate::di_container::binding_storage::DIContainerBindingStorage;
 use crate::errors::async_di_container::AsyncDIContainerError;
@@ -67,6 +66,9 @@ use crate::private::cast::boxed::CastBox;
 use crate::private::cast::error::CastError;
 use crate::provider::r#async::{AsyncProvidable, IAsyncProvider};
 use crate::ptr::{SomePtr, TransientPtr};
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 pub mod binding;
 pub mod prelude;
@@ -75,15 +77,11 @@ pub mod prelude;
 ///
 /// **This trait is sealed and cannot be implemented for types outside this crate.**
 #[async_trait]
-pub trait IAsyncDIContainer<DependencyHistoryType>:
-    Sized + 'static + Send + Sync + details::DIContainerInternals<DependencyHistoryType>
-where
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+pub trait IAsyncDIContainer:
+    Sized + 'static + Send + Sync + details::DIContainerInternals
 {
     /// Returns a new [`AsyncBindingBuilder`] for the given interface.
-    fn bind<Interface>(
-        self: &mut Arc<Self>,
-    ) -> AsyncBindingBuilder<Interface, Self, DependencyHistoryType>
+    fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self>
     where
         Interface: 'static + ?Sized + Send + Sync;
 
@@ -121,7 +119,7 @@ where
     #[doc(hidden)]
     async fn get_bound<Interface>(
         self: &Arc<Self>,
-        dependency_history: DependencyHistoryType,
+        dependency_history: DependencyHistory,
         name: Option<&'static str>,
     ) -> Result<SomePtr<Interface>, AsyncDIContainerError>
     where
@@ -131,8 +129,7 @@ where
 /// Async dependency injection container.
 pub struct AsyncDIContainer
 {
-    binding_storage:
-        Mutex<DIContainerBindingStorage<dyn IAsyncProvider<Self, DependencyHistory>>>,
+    binding_storage: Mutex<DIContainerBindingStorage<dyn IAsyncProvider<Self>>>,
 }
 
 impl AsyncDIContainer
@@ -148,11 +145,9 @@ impl AsyncDIContainer
 }
 
 #[async_trait]
-impl IAsyncDIContainer<DependencyHistory> for AsyncDIContainer
+impl IAsyncDIContainer for AsyncDIContainer
 {
-    fn bind<Interface>(
-        self: &mut Arc<Self>,
-    ) -> AsyncBindingBuilder<Interface, Self, DependencyHistory>
+    fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self>
     where
         Interface: 'static + ?Sized + Send + Sync,
     {
@@ -205,7 +200,7 @@ impl IAsyncDIContainer<DependencyHistory> for AsyncDIContainer
 }
 
 #[async_trait]
-impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer
+impl details::DIContainerInternals for AsyncDIContainer
 {
     async fn has_binding<Interface>(self: &Arc<Self>, name: Option<&'static str>) -> bool
     where
@@ -217,7 +212,7 @@ impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer
     async fn set_binding<Interface>(
         self: &Arc<Self>,
         name: Option<&'static str>,
-        provider: Box<dyn IAsyncProvider<Self, DependencyHistory>>,
+        provider: Box<dyn IAsyncProvider<Self>>,
     ) where
         Interface: 'static + ?Sized,
     {
@@ -230,7 +225,7 @@ impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer
     async fn remove_binding<Interface>(
         self: &Arc<Self>,
         name: Option<&'static str>,
-    ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistory>>>
+    ) -> Option<Box<dyn IAsyncProvider<Self>>>
     where
         Interface: 'static + ?Sized,
     {
@@ -242,7 +237,7 @@ impl AsyncDIContainer
 {
     async fn handle_binding_providable<Interface>(
         self: &Arc<Self>,
-        binding_providable: AsyncProvidable<Self, DependencyHistory>,
+        binding_providable: AsyncProvidable<Self>,
     ) -> Result<SomePtr<Interface>, AsyncDIContainerError>
     where
         Interface: 'static + ?Sized + Send + Sync,
@@ -369,7 +364,7 @@ impl AsyncDIContainer
         self: &Arc<Self>,
         name: Option<&'static str>,
         dependency_history: DependencyHistory,
-    ) -> Result<AsyncProvidable<Self, DependencyHistory>, AsyncDIContainerError>
+    ) -> Result<AsyncProvidable<Self>, AsyncDIContainerError>
     where
         Interface: 'static + ?Sized + Send + Sync,
     {
@@ -408,13 +403,10 @@ pub(crate) mod details
 
     use async_trait::async_trait;
 
-    use crate::dependency_history::IDependencyHistory;
     use crate::provider::r#async::IAsyncProvider;
 
     #[async_trait]
-    pub trait DIContainerInternals<DependencyHistoryType>
-    where
-        DependencyHistoryType: IDependencyHistory,
+    pub trait DIContainerInternals
     {
         async fn has_binding<Interface>(
             self: &Arc<Self>,
@@ -426,14 +418,14 @@ pub(crate) mod details
         async fn set_binding<Interface>(
             self: &Arc<Self>,
             name: Option<&'static str>,
-            provider: Box<dyn IAsyncProvider<Self, DependencyHistoryType>>,
+            provider: Box<dyn IAsyncProvider<Self>>,
         ) where
             Interface: 'static + ?Sized;
 
         async fn remove_binding<Interface>(
             self: &Arc<Self>,
             name: Option<&'static str>,
-        ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistoryType>>>
+        ) -> Option<Box<dyn IAsyncProvider<Self>>>
         where
             Interface: 'static + ?Sized;
     }
diff --git a/src/di_container/blocking/binding/builder.rs b/src/di_container/blocking/binding/builder.rs
index 27151d7..991961c 100644
--- a/src/di_container/blocking/binding/builder.rs
+++ b/src/di_container/blocking/binding/builder.rs
@@ -5,40 +5,39 @@ use std::any::type_name;
 use std::marker::PhantomData;
 use std::rc::Rc;
 
-use crate::dependency_history::IDependencyHistory;
 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::blocking::IDIContainer;
 use crate::errors::di_container::BindingBuilderError;
 use crate::interfaces::injectable::Injectable;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 /// Binding builder for type `Interface` inside a [`IDIContainer`].
 ///
 /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer
 #[must_use = "No binding will be created if you don't use the binding builder"]
-pub struct BindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+pub struct BindingBuilder<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     di_container: Rc<DIContainerType>,
-    dependency_history_factory: fn() -> DependencyHistoryType,
+    dependency_history_factory: fn() -> DependencyHistory,
 
     interface_phantom: PhantomData<Interface>,
 }
 
-impl<Interface, DIContainerType, DependencyHistoryType>
-    BindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> BindingBuilder<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + 'static,
+    DIContainerType: IDIContainer,
 {
     pub(crate) fn new(
         di_container: Rc<DIContainerType>,
-        dependency_history_factory: fn() -> DependencyHistoryType,
+        dependency_history_factory: fn() -> DependencyHistory,
     ) -> Self
     {
         Self {
@@ -93,16 +92,11 @@ where
     pub fn to<Implementation>(
         self,
     ) -> Result<
-        BindingScopeConfigurator<
-            Interface,
-            Implementation,
-            DIContainerType,
-            DependencyHistoryType,
-        >,
+        BindingScopeConfigurator<Interface, Implementation, DIContainerType>,
         BindingBuilderError,
     >
     where
-        Implementation: Injectable<DIContainerType, DependencyHistoryType>,
+        Implementation: Injectable<DIContainerType>,
     {
         {
             if self.di_container.has_binding::<Interface>(None) {
@@ -194,10 +188,7 @@ where
     pub fn to_factory<Args, Return, Func>(
         self,
         factory_func: &'static Func,
-    ) -> Result<
-        BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
-        BindingBuilderError,
-    >
+    ) -> Result<BindingWhenConfigurator<Interface, DIContainerType>, BindingBuilderError>
     where
         Args: std::marker::Tuple + 'static,
         Return: 'static + ?Sized,
@@ -283,10 +274,7 @@ where
     pub fn to_default_factory<Return, FactoryFunc>(
         self,
         factory_func: &'static FactoryFunc,
-    ) -> Result<
-        BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
-        BindingBuilderError,
-    >
+    ) -> Result<BindingWhenConfigurator<Interface, DIContainerType>, BindingBuilderError>
     where
         Return: 'static + ?Sized,
         FactoryFunc: Fn<
@@ -326,6 +314,7 @@ mod tests
     use mockall::predicate::eq;
 
     use super::*;
+    use crate::dependency_history::MockDependencyHistory;
     use crate::test_utils::{mocks, subjects};
 
     #[test]
@@ -345,14 +334,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = BindingBuilder::<
-            dyn subjects::INumber,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Rc::new(mock_di_container),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            BindingBuilder::<
+                dyn subjects::INumber,
+                mocks::blocking_di_container::MockDIContainer,
+            >::new(Rc::new(mock_di_container), MockDependencyHistory::new);
 
         binding_builder.to::<subjects::Number>()?;
 
@@ -384,14 +370,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = BindingBuilder::<
-            IUserManagerFactory,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Rc::new(mock_di_container),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            BindingBuilder::<
+                IUserManagerFactory,
+                mocks::blocking_di_container::MockDIContainer,
+            >::new(Rc::new(mock_di_container), MockDependencyHistory::new);
 
         binding_builder.to_factory(&|_| {
             Box::new(move |_num, _text| {
@@ -430,14 +413,11 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_builder = BindingBuilder::<
-            dyn subjects::IUserManager,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Rc::new(mock_di_container),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_builder =
+            BindingBuilder::<
+                dyn subjects::IUserManager,
+                mocks::blocking_di_container::MockDIContainer,
+            >::new(Rc::new(mock_di_container), MockDependencyHistory::new);
 
         binding_builder.to_default_factory(&|_| {
             Box::new(move || {
diff --git a/src/di_container/blocking/binding/scope_configurator.rs b/src/di_container/blocking/binding/scope_configurator.rs
index f318dd6..0e2437f 100644
--- a/src/di_container/blocking/binding/scope_configurator.rs
+++ b/src/di_container/blocking/binding/scope_configurator.rs
@@ -4,51 +4,42 @@
 use std::marker::PhantomData;
 use std::rc::Rc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator;
 use crate::di_container::blocking::IDIContainer;
 use crate::errors::di_container::BindingScopeConfiguratorError;
 use crate::interfaces::injectable::Injectable;
 use crate::provider::blocking::{SingletonProvider, TransientTypeProvider};
 use crate::ptr::SingletonPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 /// Scope configurator for a binding for type `Interface` inside a [`IDIContainer`].
 ///
 /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer
-pub struct BindingScopeConfigurator<
-    Interface,
-    Implementation,
-    DIContainerType,
-    DependencyHistoryType,
-> where
+pub struct BindingScopeConfigurator<Interface, Implementation, DIContainerType>
+where
     Interface: 'static + ?Sized,
-    Implementation: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    Implementation: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     di_container: Rc<DIContainerType>,
-    dependency_history_factory: fn() -> DependencyHistoryType,
+    dependency_history_factory: fn() -> DependencyHistory,
 
     interface_phantom: PhantomData<Interface>,
     implementation_phantom: PhantomData<Implementation>,
 }
 
-impl<Interface, Implementation, DIContainerType, DependencyHistoryType>
-    BindingScopeConfigurator<
-        Interface,
-        Implementation,
-        DIContainerType,
-        DependencyHistoryType,
-    >
+impl<Interface, Implementation, DIContainerType>
+    BindingScopeConfigurator<Interface, Implementation, DIContainerType>
 where
     Interface: 'static + ?Sized,
-    Implementation: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + 'static,
+    Implementation: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     pub(crate) fn new(
         di_container: Rc<DIContainerType>,
-        dependency_history_factory: fn() -> DependencyHistoryType,
+        dependency_history_factory: fn() -> DependencyHistory,
     ) -> Self
     {
         Self {
@@ -63,9 +54,8 @@ where
     ///
     /// This is the default.
     #[allow(clippy::must_use_candidate)]
-    pub fn in_transient_scope(
-        self,
-    ) -> BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+    pub fn in_transient_scope(self)
+        -> BindingWhenConfigurator<Interface, DIContainerType>
     {
         self.set_in_transient_scope();
 
@@ -79,7 +69,7 @@ where
     pub fn in_singleton_scope(
         self,
     ) -> Result<
-        BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+        BindingWhenConfigurator<Interface, DIContainerType>,
         BindingScopeConfiguratorError,
     >
     {
@@ -101,11 +91,7 @@ where
     {
         self.di_container.set_binding::<Interface>(
             None,
-            Box::new(TransientTypeProvider::<
-                Implementation,
-                DIContainerType,
-                DependencyHistoryType,
-            >::new()),
+            Box::new(TransientTypeProvider::<Implementation, DIContainerType>::new()),
         );
     }
 }
@@ -114,6 +100,7 @@ where
 mod tests
 {
     use super::*;
+    use crate::dependency_history::MockDependencyHistory;
     use crate::test_utils::{mocks, subjects};
 
     #[test]
@@ -127,15 +114,12 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_scope_configurator = BindingScopeConfigurator::<
-            dyn subjects::IUserManager,
-            subjects::UserManager,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Rc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_scope_configurator =
+            BindingScopeConfigurator::<
+                dyn subjects::IUserManager,
+                subjects::UserManager,
+                mocks::blocking_di_container::MockDIContainer,
+            >::new(Rc::new(di_container_mock), MockDependencyHistory::new);
 
         binding_scope_configurator.in_transient_scope();
     }
@@ -151,15 +135,12 @@ mod tests
             .return_once(|_name, _provider| ())
             .once();
 
-        let binding_scope_configurator = BindingScopeConfigurator::<
-            dyn subjects::IUserManager,
-            subjects::UserManager,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(
-            Rc::new(di_container_mock),
-            mocks::MockDependencyHistory::new,
-        );
+        let binding_scope_configurator =
+            BindingScopeConfigurator::<
+                dyn subjects::IUserManager,
+                subjects::UserManager,
+                mocks::blocking_di_container::MockDIContainer,
+            >::new(Rc::new(di_container_mock), MockDependencyHistory::new);
 
         assert!(binding_scope_configurator.in_singleton_scope().is_ok());
     }
diff --git a/src/di_container/blocking/binding/when_configurator.rs b/src/di_container/blocking/binding/when_configurator.rs
index 31b1b48..fcef377 100644
--- a/src/di_container/blocking/binding/when_configurator.rs
+++ b/src/di_container/blocking/binding/when_configurator.rs
@@ -5,38 +5,32 @@ use std::any::type_name;
 use std::marker::PhantomData;
 use std::rc::Rc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::blocking::IDIContainer;
 use crate::errors::di_container::BindingWhenConfiguratorError;
 
 /// When configurator for a binding for type `Interface` inside a [`IDIContainer`].
 ///
 /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer
-pub struct BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+pub struct BindingWhenConfigurator<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     di_container: Rc<DIContainerType>,
 
     interface_phantom: PhantomData<Interface>,
-    dependency_history_phantom: PhantomData<DependencyHistoryType>,
 }
 
-impl<Interface, DIContainerType, DependencyHistoryType>
-    BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> BindingWhenConfigurator<Interface, DIContainerType>
 where
     Interface: 'static + ?Sized,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     pub(crate) fn new(di_container: Rc<DIContainerType>) -> Self
     {
         Self {
             di_container,
             interface_phantom: PhantomData,
-            dependency_history_phantom: PhantomData,
         }
     }
 
@@ -97,8 +91,7 @@ mod tests
 
         let binding_when_configurator = BindingWhenConfigurator::<
             dyn subjects::INumber,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
+            mocks::blocking_di_container::MockDIContainer,
         >::new(Rc::new(di_container_mock));
 
         assert!(binding_when_configurator.when_named("cool").is_ok());
diff --git a/src/di_container/blocking/mod.rs b/src/di_container/blocking/mod.rs
index cd7065c..5781583 100644
--- a/src/di_container/blocking/mod.rs
+++ b/src/di_container/blocking/mod.rs
@@ -54,7 +54,6 @@ use std::any::type_name;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::dependency_history::{DependencyHistory, IDependencyHistory};
 use crate::di_container::binding_storage::DIContainerBindingStorage;
 use crate::di_container::blocking::binding::builder::BindingBuilder;
 use crate::errors::di_container::DIContainerError;
@@ -62,6 +61,9 @@ use crate::private::cast::boxed::CastBox;
 use crate::private::cast::rc::CastRc;
 use crate::provider::blocking::{IProvider, Providable};
 use crate::ptr::SomePtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 pub mod binding;
 pub mod prelude;
@@ -69,15 +71,10 @@ pub mod prelude;
 /// Blocking dependency injection container interface.
 ///
 /// **This trait is sealed and cannot be implemented for types outside this crate.**
-pub trait IDIContainer<DependencyHistoryType>:
-    Sized + 'static + details::DIContainerInternals<DependencyHistoryType>
-where
-    DependencyHistoryType: IDependencyHistory,
+pub trait IDIContainer: Sized + 'static + details::DIContainerInternals
 {
     /// Returns a new [`BindingBuilder`] for the given interface.
-    fn bind<Interface>(
-        self: &mut Rc<Self>,
-    ) -> BindingBuilder<Interface, Self, DependencyHistoryType>
+    fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self>
     where
         Interface: 'static + ?Sized;
 
@@ -109,7 +106,7 @@ where
     #[doc(hidden)]
     fn get_bound<Interface>(
         self: &Rc<Self>,
-        dependency_history: DependencyHistoryType,
+        dependency_history: DependencyHistory,
         name: Option<&'static str>,
     ) -> Result<SomePtr<Interface>, DIContainerError>
     where
@@ -119,8 +116,7 @@ where
 /// Blocking dependency injection container.
 pub struct DIContainer
 {
-    binding_storage:
-        RefCell<DIContainerBindingStorage<dyn IProvider<Self, DependencyHistory>>>,
+    binding_storage: RefCell<DIContainerBindingStorage<dyn IProvider<Self>>>,
 }
 
 impl DIContainer
@@ -135,11 +131,9 @@ impl DIContainer
     }
 }
 
-impl IDIContainer<DependencyHistory> for DIContainer
+impl IDIContainer for DIContainer
 {
-    fn bind<Interface>(
-        self: &mut Rc<Self>,
-    ) -> BindingBuilder<Interface, Self, DependencyHistory>
+    fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self>
     where
         Interface: 'static + ?Sized,
     {
@@ -183,7 +177,7 @@ impl IDIContainer<DependencyHistory> for DIContainer
     }
 }
 
-impl details::DIContainerInternals<DependencyHistory> for DIContainer
+impl details::DIContainerInternals for DIContainer
 {
     fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool
     where
@@ -195,7 +189,7 @@ impl details::DIContainerInternals<DependencyHistory> for DIContainer
     fn set_binding<Interface>(
         self: &Rc<Self>,
         name: Option<&'static str>,
-        provider: Box<dyn IProvider<Self, DependencyHistory>>,
+        provider: Box<dyn IProvider<Self>>,
     ) where
         Interface: 'static + ?Sized,
     {
@@ -207,7 +201,7 @@ impl details::DIContainerInternals<DependencyHistory> for DIContainer
     fn remove_binding<Interface>(
         self: &Rc<Self>,
         name: Option<&'static str>,
-    ) -> Option<Box<dyn IProvider<Self, DependencyHistory>>>
+    ) -> Option<Box<dyn IProvider<Self>>>
     where
         Interface: 'static + ?Sized,
     {
@@ -219,7 +213,7 @@ impl DIContainer
 {
     fn handle_binding_providable<Interface>(
         #[cfg(feature = "factory")] self: &Rc<Self>,
-        binding_providable: Providable<Self, DependencyHistory>,
+        binding_providable: Providable<Self>,
     ) -> Result<SomePtr<Interface>, DIContainerError>
     where
         Interface: 'static + ?Sized,
@@ -278,7 +272,7 @@ impl DIContainer
         self: &Rc<Self>,
         name: Option<&'static str>,
         dependency_history: DependencyHistory,
-    ) -> Result<Providable<Self, DependencyHistory>, DIContainerError>
+    ) -> Result<Providable<Self>, DIContainerError>
     where
         Interface: 'static + ?Sized,
     {
@@ -306,12 +300,9 @@ pub(crate) mod details
 {
     use std::rc::Rc;
 
-    use crate::dependency_history::IDependencyHistory;
     use crate::provider::blocking::IProvider;
 
-    pub trait DIContainerInternals<DependencyHistoryType>
-    where
-        DependencyHistoryType: IDependencyHistory,
+    pub trait DIContainerInternals
     {
         fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool
         where
@@ -320,14 +311,14 @@ pub(crate) mod details
         fn set_binding<Interface>(
             self: &Rc<Self>,
             name: Option<&'static str>,
-            provider: Box<dyn IProvider<Self, DependencyHistoryType>>,
+            provider: Box<dyn IProvider<Self>>,
         ) where
             Interface: 'static + ?Sized;
 
         fn remove_binding<Interface>(
             self: &Rc<Self>,
             name: Option<&'static str>,
-        ) -> Option<Box<dyn IProvider<Self, DependencyHistoryType>>>
+        ) -> Option<Box<dyn IProvider<Self>>>
         where
             Interface: 'static + ?Sized;
     }
diff --git a/src/interfaces/async_injectable.rs b/src/interfaces/async_injectable.rs
index d8e7dfc..2364ae1 100644
--- a/src/interfaces/async_injectable.rs
+++ b/src/interfaces/async_injectable.rs
@@ -2,18 +2,19 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::asynchronous::IAsyncDIContainer;
 use crate::errors::injectable::InjectableError;
 use crate::future::BoxFuture;
 use crate::private::cast::CastFromArc;
 use crate::ptr::TransientPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 /// Interface for structs that can be injected into or be injected to.
-pub trait AsyncInjectable<DIContainerType, DependencyHistoryType>: CastFromArc
+pub trait AsyncInjectable<DIContainerType>: CastFromArc
 where
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     /// Resolves the dependencies of the injectable.
     ///
@@ -21,18 +22,16 @@ where
     /// Will return `Err` if resolving the dependencies fails.
     fn resolve<'di_container, 'fut>(
         di_container: &'di_container Arc<DIContainerType>,
-        dependency_history: DependencyHistoryType,
+        dependency_history: DependencyHistory,
     ) -> BoxFuture<'fut, Result<TransientPtr<Self>, InjectableError>>
     where
         Self: Sized + 'fut,
         'di_container: 'fut;
 }
 
-impl<DIContainerType, DependencyHistoryType> Debug
-    for dyn AsyncInjectable<DIContainerType, DependencyHistoryType>
+impl<DIContainerType> Debug for dyn AsyncInjectable<DIContainerType>
 where
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
     {
diff --git a/src/interfaces/injectable.rs b/src/interfaces/injectable.rs
index b70e13f..82b773a 100644
--- a/src/interfaces/injectable.rs
+++ b/src/interfaces/injectable.rs
@@ -2,17 +2,18 @@
 use std::fmt::Debug;
 use std::rc::Rc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::blocking::IDIContainer;
 use crate::errors::injectable::InjectableError;
 use crate::private::cast::CastFrom;
 use crate::ptr::TransientPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 /// Interface for structs that can be injected into or be injected to.
-pub trait Injectable<DIContainerType, DependencyHistoryType>: CastFrom
+pub trait Injectable<DIContainerType>: CastFrom
 where
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     /// Resolves the dependencies of the injectable.
     ///
@@ -20,17 +21,15 @@ where
     /// Will return `Err` if resolving the dependencies fails.
     fn resolve(
         di_container: &Rc<DIContainerType>,
-        dependency_history: DependencyHistoryType,
+        dependency_history: DependencyHistory,
     ) -> Result<TransientPtr<Self>, InjectableError>
     where
         Self: Sized;
 }
 
-impl<DIContainerType, DependencyHistoryType> Debug
-    for dyn Injectable<DIContainerType, DependencyHistoryType>
+impl<DIContainerType> Debug for dyn Injectable<DIContainerType>
 where
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
     {
diff --git a/src/lib.rs b/src/lib.rs
index 4807f61..40bf6e6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -112,6 +112,7 @@ pub use syrette_macros::{declare_interface, injectable, named};
 pub mod private;
 
 mod provider;
+mod util;
 
 #[cfg(test)]
 #[cfg(not(tarpaulin_include))]
diff --git a/src/provider/async.rs b/src/provider/async.rs
index da42c7b..38600c9 100644
--- a/src/provider/async.rs
+++ b/src/provider/async.rs
@@ -3,24 +3,21 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::asynchronous::IAsyncDIContainer;
 use crate::errors::injectable::InjectableError;
 use crate::interfaces::async_injectable::AsyncInjectable;
 use crate::ptr::{ThreadsafeSingletonPtr, TransientPtr};
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 #[derive(strum_macros::Display, Debug)]
-pub enum AsyncProvidable<DIContainerType, DependencyHistoryType>
+pub enum AsyncProvidable<DIContainerType>
 where
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
-    Transient(TransientPtr<dyn AsyncInjectable<DIContainerType, DependencyHistoryType>>),
-    Singleton(
-        ThreadsafeSingletonPtr<
-            dyn AsyncInjectable<DIContainerType, DependencyHistoryType>,
-        >,
-    ),
+    Transient(TransientPtr<dyn AsyncInjectable<DIContainerType>>),
+    Singleton(ThreadsafeSingletonPtr<dyn AsyncInjectable<DIContainerType>>),
     #[cfg(feature = "factory")]
     Factory(
         crate::ptr::ThreadsafeFactoryPtr<
@@ -43,26 +40,22 @@ where
 
 #[async_trait]
 #[cfg_attr(test, mockall::automock, allow(dead_code))]
-pub trait IAsyncProvider<DIContainerType, DependencyHistoryType>: Send + Sync
+pub trait IAsyncProvider<DIContainerType>: Send + Sync
 where
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     async fn provide(
         &self,
         di_container: &Arc<DIContainerType>,
-        dependency_history: DependencyHistoryType,
-    ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>;
+        dependency_history: DependencyHistory,
+    ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>;
 
-    fn do_clone(&self)
-        -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>;
+    fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>;
 }
 
-impl<DIContainerType, DependencyHistoryType> Clone
-    for Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+impl<DIContainerType> Clone for Box<dyn IAsyncProvider<DIContainerType>>
 where
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    DIContainerType: IAsyncDIContainer,
 {
     fn clone(&self) -> Self
     {
@@ -70,148 +63,127 @@ where
     }
 }
 
-pub struct AsyncTransientTypeProvider<
-    InjectableType,
-    DIContainerType,
-    DependencyHistoryType,
-> where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+pub struct AsyncTransientTypeProvider<InjectableType, DIContainerType>
+where
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     injectable_phantom: PhantomData<InjectableType>,
     di_container_phantom: PhantomData<DIContainerType>,
-    dependency_history_phantom: PhantomData<DependencyHistoryType>,
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType>
+    AsyncTransientTypeProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     pub fn new() -> Self
     {
         Self {
             injectable_phantom: PhantomData,
             di_container_phantom: PhantomData,
-            dependency_history_phantom: PhantomData,
         }
     }
 }
 
 #[async_trait]
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    IAsyncProvider<DIContainerType, DependencyHistoryType>
-    for AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IAsyncProvider<DIContainerType>
+    for AsyncTransientTypeProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     async fn provide(
         &self,
         di_container: &Arc<DIContainerType>,
-        dependency_history: DependencyHistoryType,
-    ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>
+        dependency_history: DependencyHistory,
+    ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>
     {
         Ok(AsyncProvidable::Transient(
             InjectableType::resolve(di_container, dependency_history).await?,
         ))
     }
 
-    fn do_clone(&self)
-        -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+    fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>
     {
         Box::new(self.clone())
     }
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType> Clone
-    for AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> Clone
+    for AsyncTransientTypeProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     fn clone(&self) -> Self
     {
         Self {
             injectable_phantom: self.injectable_phantom,
             di_container_phantom: PhantomData,
-            dependency_history_phantom: PhantomData,
         }
     }
 }
 
-pub struct AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+pub struct AsyncSingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     singleton: ThreadsafeSingletonPtr<InjectableType>,
 
     di_container_phantom: PhantomData<DIContainerType>,
-    dependency_history_phantom: PhantomData<DependencyHistoryType>,
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType>
+    AsyncSingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     pub fn new(singleton: ThreadsafeSingletonPtr<InjectableType>) -> Self
     {
         Self {
             singleton,
             di_container_phantom: PhantomData,
-            dependency_history_phantom: PhantomData,
         }
     }
 }
 
 #[async_trait]
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    IAsyncProvider<DIContainerType, DependencyHistoryType>
-    for AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IAsyncProvider<DIContainerType>
+    for AsyncSingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     async fn provide(
         &self,
         _di_container: &Arc<DIContainerType>,
-        _dependency_history: DependencyHistoryType,
-    ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>
+        _dependency_history: DependencyHistory,
+    ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>
     {
         Ok(AsyncProvidable::Singleton(self.singleton.clone()))
     }
 
-    fn do_clone(&self)
-        -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+    fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>
     {
         Box::new(self.clone())
     }
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType> Clone
-    for AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> Clone
+    for AsyncSingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync,
+    InjectableType: AsyncInjectable<DIContainerType>,
+    DIContainerType: IAsyncDIContainer,
 {
     fn clone(&self) -> Self
     {
         Self {
             singleton: self.singleton.clone(),
             di_container_phantom: PhantomData,
-            dependency_history_phantom: PhantomData,
         }
     }
 }
@@ -249,17 +221,15 @@ impl AsyncFactoryProvider
 
 #[cfg(feature = "factory")]
 #[async_trait]
-impl<DIContainerType, DependencyHistoryType>
-    IAsyncProvider<DIContainerType, DependencyHistoryType> for AsyncFactoryProvider
+impl<DIContainerType> IAsyncProvider<DIContainerType> for AsyncFactoryProvider
 where
-    DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+    DIContainerType: IAsyncDIContainer,
 {
     async fn provide(
         &self,
         _di_container: &Arc<DIContainerType>,
-        _dependency_history: DependencyHistoryType,
-    ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>
+        _dependency_history: DependencyHistory,
+    ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>
     {
         Ok(match self.variant {
             AsyncFactoryVariant::Normal => AsyncProvidable::Factory(self.factory.clone()),
@@ -272,8 +242,7 @@ where
         })
     }
 
-    fn do_clone(&self)
-        -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+    fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>
     {
         Box::new(self.clone())
     }
@@ -297,7 +266,7 @@ mod tests
     use std::error::Error;
 
     use super::*;
-    use crate::test_utils::mocks::MockDependencyHistory;
+    use crate::dependency_history::MockDependencyHistory;
     use crate::test_utils::{mocks, subjects_async};
 
     #[tokio::test]
@@ -305,8 +274,7 @@ mod tests
     {
         let transient_type_provider = AsyncTransientTypeProvider::<
             subjects_async::UserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
+            mocks::async_di_container::MockAsyncDIContainer,
         >::new();
 
         let di_container = mocks::async_di_container::MockAsyncDIContainer::new();
@@ -329,8 +297,7 @@ mod tests
     {
         let singleton_provider = AsyncSingletonProvider::<
             subjects_async::UserManager,
-            mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
+            mocks::async_di_container::MockAsyncDIContainer,
         >::new(ThreadsafeSingletonPtr::new(
             subjects_async::UserManager {},
         ));
@@ -383,7 +350,7 @@ mod tests
         assert!(
             matches!(
                 factory_provider
-                    .provide(&di_container, mocks::MockDependencyHistory::new())
+                    .provide(&di_container, MockDependencyHistory::new())
                     .await?,
                 AsyncProvidable::Factory(_)
             ),
diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs
index ea506ab..a18e997 100644
--- a/src/provider/blocking.rs
+++ b/src/provider/blocking.rs
@@ -1,20 +1,21 @@
 use std::marker::PhantomData;
 use std::rc::Rc;
 
-use crate::dependency_history::IDependencyHistory;
 use crate::di_container::blocking::IDIContainer;
 use crate::errors::injectable::InjectableError;
 use crate::interfaces::injectable::Injectable;
 use crate::ptr::{SingletonPtr, TransientPtr};
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
 
 #[derive(strum_macros::Display, Debug)]
-pub enum Providable<DIContainerType, DependencyHistoryType>
+pub enum Providable<DIContainerType>
 where
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
-    Transient(TransientPtr<dyn Injectable<DIContainerType, DependencyHistoryType>>),
-    Singleton(SingletonPtr<dyn Injectable<DIContainerType, DependencyHistoryType>>),
+    Transient(TransientPtr<dyn Injectable<DIContainerType>>),
+    Singleton(SingletonPtr<dyn Injectable<DIContainerType>>),
     #[cfg(feature = "factory")]
     Factory(crate::ptr::FactoryPtr<dyn crate::private::any_factory::AnyFactory>),
     #[cfg(feature = "factory")]
@@ -22,35 +23,32 @@ where
 }
 
 #[cfg_attr(test, mockall::automock, allow(dead_code))]
-pub trait IProvider<DIContainerType, DependencyHistoryType>
+pub trait IProvider<DIContainerType>
 where
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     fn provide(
         &self,
         di_container: &Rc<DIContainerType>,
-        dependency_history: DependencyHistoryType,
-    ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>;
+        dependency_history: DependencyHistory,
+    ) -> Result<Providable<DIContainerType>, InjectableError>;
 }
 
-pub struct TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+pub struct TransientTypeProvider<InjectableType, DIContainerType>
 where
-    InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    InjectableType: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     injectable_phantom: PhantomData<InjectableType>,
     di_container_phantom: PhantomData<DIContainerType>,
-    dependency_history_phantom: PhantomData<DependencyHistoryType>,
+    dependency_history_phantom: PhantomData<DependencyHistory>,
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType>
+    TransientTypeProvider<InjectableType, DIContainerType>
 where
-    InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    InjectableType: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     pub fn new() -> Self
     {
@@ -62,19 +60,17 @@ where
     }
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    IProvider<DIContainerType, DependencyHistoryType>
-    for TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IProvider<DIContainerType>
+    for TransientTypeProvider<InjectableType, DIContainerType>
 where
-    InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    InjectableType: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     fn provide(
         &self,
         di_container: &Rc<DIContainerType>,
-        dependency_history: DependencyHistoryType,
-    ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>
+        dependency_history: DependencyHistory,
+    ) -> Result<Providable<DIContainerType>, InjectableError>
     {
         Ok(Providable::Transient(InjectableType::resolve(
             di_container,
@@ -83,24 +79,21 @@ where
     }
 }
 
-pub struct SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+pub struct SingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    InjectableType: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     singleton: SingletonPtr<InjectableType>,
 
     di_container_phantom: PhantomData<DIContainerType>,
-    dependency_history_phantom: PhantomData<DependencyHistoryType>,
+    dependency_history_phantom: PhantomData<DependencyHistory>,
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> SingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    InjectableType: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     pub fn new(singleton: SingletonPtr<InjectableType>) -> Self
     {
@@ -112,19 +105,17 @@ where
     }
 }
 
-impl<InjectableType, DIContainerType, DependencyHistoryType>
-    IProvider<DIContainerType, DependencyHistoryType>
-    for SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IProvider<DIContainerType>
+    for SingletonProvider<InjectableType, DIContainerType>
 where
-    InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    InjectableType: Injectable<DIContainerType>,
+    DIContainerType: IDIContainer,
 {
     fn provide(
         &self,
         _di_container: &Rc<DIContainerType>,
-        _dependency_history: DependencyHistoryType,
-    ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>
+        _dependency_history: DependencyHistory,
+    ) -> Result<Providable<DIContainerType>, InjectableError>
     {
         Ok(Providable::Singleton(self.singleton.clone()))
     }
@@ -153,17 +144,15 @@ impl FactoryProvider
 }
 
 #[cfg(feature = "factory")]
-impl<DIContainerType, DependencyHistoryType>
-    IProvider<DIContainerType, DependencyHistoryType> for FactoryProvider
+impl<DIContainerType> IProvider<DIContainerType> for FactoryProvider
 where
-    DIContainerType: IDIContainer<DependencyHistoryType>,
-    DependencyHistoryType: IDependencyHistory,
+    DIContainerType: IDIContainer,
 {
     fn provide(
         &self,
         _di_container: &Rc<DIContainerType>,
-        _dependency_history: DependencyHistoryType,
-    ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>
+        _dependency_history: DependencyHistory,
+    ) -> Result<Providable<DIContainerType>, InjectableError>
     {
         Ok(if self.is_default_factory {
             Providable::DefaultFactory(self.factory.clone())
@@ -179,6 +168,7 @@ mod tests
     use std::error::Error;
 
     use super::*;
+    use crate::dependency_history::MockDependencyHistory;
     use crate::test_utils::{mocks, subjects};
 
     #[test]
@@ -186,13 +176,12 @@ mod tests
     {
         let transient_type_provider = TransientTypeProvider::<
             subjects::UserManager,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
+            mocks::blocking_di_container::MockDIContainer,
         >::new();
 
         let di_container = mocks::blocking_di_container::MockDIContainer::new();
 
-        let dependency_history_mock = mocks::MockDependencyHistory::new();
+        let dependency_history_mock = MockDependencyHistory::new();
 
         assert!(
             matches!(
@@ -209,22 +198,18 @@ mod tests
     #[test]
     fn singleton_provider_works() -> Result<(), Box<dyn Error>>
     {
-        let singleton_provider = SingletonProvider::<
-            subjects::UserManager,
-            mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
-            mocks::MockDependencyHistory,
-        >::new(SingletonPtr::new(
-            subjects::UserManager {},
-        ));
+        let singleton_provider =
+            SingletonProvider::<
+                subjects::UserManager,
+                mocks::blocking_di_container::MockDIContainer,
+            >::new(SingletonPtr::new(subjects::UserManager {}));
 
         let di_container = mocks::blocking_di_container::MockDIContainer::new();
 
         assert!(
             matches!(
-                singleton_provider.provide(
-                    &Rc::new(di_container),
-                    mocks::MockDependencyHistory::new()
-                )?,
+                singleton_provider
+                    .provide(&Rc::new(di_container), MockDependencyHistory::new())?,
                 Providable::Singleton(_)
             ),
             "The provided type is not a singleton"
@@ -253,8 +238,7 @@ mod tests
 
         assert!(
             matches!(
-                factory_provider
-                    .provide(&di_container, mocks::MockDependencyHistory::new())?,
+                factory_provider.provide(&di_container, MockDependencyHistory::new())?,
                 Providable::Factory(_)
             ),
             "The provided type is not a factory"
@@ -263,7 +247,7 @@ mod tests
         assert!(
             matches!(
                 default_factory_provider
-                    .provide(&di_container, mocks::MockDependencyHistory::new())?,
+                    .provide(&di_container, MockDependencyHistory::new())?,
                 Providable::DefaultFactory(_)
             ),
             "The provided type is not a default factory"
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 78ad63b..2bc1671 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -7,12 +7,13 @@ pub mod subjects
 
     use syrette_macros::declare_interface;
 
-    use crate::dependency_history::IDependencyHistory;
     use crate::di_container::blocking::IDIContainer;
     use crate::interfaces::injectable::Injectable;
     use crate::private::cast::CastFromArc;
     use crate::ptr::TransientPtr;
 
+    use_dependency_history!();
+
     pub trait IUserManager
     {
         fn add_user(&self, user_id: i128);
@@ -44,18 +45,17 @@ pub mod subjects
     }
 
     use crate as syrette;
+    use crate::util::use_dependency_history;
 
     declare_interface!(UserManager -> IUserManager);
 
-    impl<DIContainerType, DependencyHistoryType>
-        Injectable<DIContainerType, DependencyHistoryType> for UserManager
+    impl<DIContainerType> Injectable<DIContainerType> for UserManager
     where
-        DIContainerType: IDIContainer<DependencyHistoryType>,
-        DependencyHistoryType: IDependencyHistory,
+        DIContainerType: IDIContainer,
     {
         fn resolve(
             _di_container: &Rc<DIContainerType>,
-            _dependency_history: DependencyHistoryType,
+            _dependency_history: DependencyHistory,
         ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
         where
             Self: Sized,
@@ -115,15 +115,13 @@ pub mod subjects
 
     declare_interface!(Number -> INumber);
 
-    impl<DIContainerType, DependencyHistoryType>
-        Injectable<DIContainerType, DependencyHistoryType> for Number
+    impl<DIContainerType> Injectable<DIContainerType> for Number
     where
-        DIContainerType: IDIContainer<DependencyHistoryType>,
-        DependencyHistoryType: IDependencyHistory,
+        DIContainerType: IDIContainer,
     {
         fn resolve(
             _di_container: &Rc<DIContainerType>,
-            _dependency_history: DependencyHistoryType,
+            _dependency_history: DependencyHistory,
         ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
         where
             Self: Sized,
@@ -151,11 +149,12 @@ pub mod subjects_async
     use async_trait::async_trait;
     use syrette_macros::declare_interface;
 
-    use crate::dependency_history::IDependencyHistory;
     use crate::di_container::asynchronous::IAsyncDIContainer;
     use crate::interfaces::async_injectable::AsyncInjectable;
     use crate::ptr::TransientPtr;
 
+    use_dependency_history!();
+
     pub trait IUserManager: Send + Sync
     {
         fn add_user(&self, user_id: i128);
@@ -187,19 +186,18 @@ pub mod subjects_async
     }
 
     use crate as syrette;
+    use crate::util::use_dependency_history;
 
     declare_interface!(UserManager -> IUserManager);
 
     #[async_trait]
-    impl<DIContainerType, DependencyHistoryType>
-        AsyncInjectable<DIContainerType, DependencyHistoryType> for UserManager
+    impl<DIContainerType> AsyncInjectable<DIContainerType> for UserManager
     where
-        DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-        DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+        DIContainerType: IAsyncDIContainer,
     {
         async fn resolve(
             _: &Arc<DIContainerType>,
-            _dependency_history: DependencyHistoryType,
+            _dependency_history: DependencyHistory,
         ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
         where
             Self: Sized,
@@ -260,15 +258,13 @@ pub mod subjects_async
     declare_interface!(Number -> INumber, threadsafe_sharable = true);
 
     #[async_trait]
-    impl<DIContainerType, DependencyHistoryType>
-        AsyncInjectable<DIContainerType, DependencyHistoryType> for Number
+    impl<DIContainerType> AsyncInjectable<DIContainerType> for Number
     where
-        DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-        DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+        DIContainerType: IAsyncDIContainer,
     {
         async fn resolve(
             _: &Arc<DIContainerType>,
-            _dependency_history: DependencyHistoryType,
+            _dependency_history: DependencyHistory,
         ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
         where
             Self: Sized,
@@ -290,27 +286,22 @@ pub mod mocks
         use std::rc::Rc;
 
         use super::*;
-        use crate::dependency_history::IDependencyHistory;
         use crate::di_container::blocking::binding::builder::BindingBuilder;
         use crate::di_container::blocking::details::DIContainerInternals;
         use crate::di_container::blocking::IDIContainer;
         use crate::errors::di_container::DIContainerError;
         use crate::provider::blocking::IProvider;
         use crate::ptr::SomePtr;
+        use crate::util::use_dependency_history;
+
+        use_dependency_history!();
 
         mock! {
-            pub DIContainer<DependencyHistoryType>
-            where
-                DependencyHistoryType: IDependencyHistory + 'static
-            {}
+            pub DIContainer {}
 
-            impl<DependencyHistoryType> IDIContainer<DependencyHistoryType> for
-                DIContainer<DependencyHistoryType>
-            where
-                DependencyHistoryType: IDependencyHistory + 'static
+            impl IDIContainer for DIContainer
             {
-                fn bind<Interface>(self: &mut Rc<Self>) ->
-                    BindingBuilder<Interface, Self, DependencyHistoryType>
+                fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self>
                 where
                     Interface: 'static + ?Sized;
 
@@ -328,18 +319,14 @@ pub mod mocks
                 #[doc(hidden)]
                 fn get_bound<Interface>(
                     self: &Rc<Self>,
-                    dependency_history: DependencyHistoryType,
+                    dependency_history: DependencyHistory,
                     name: Option<&'static str>,
                 ) -> Result<SomePtr<Interface>, DIContainerError>
                 where
                     Interface: 'static + ?Sized;
             }
 
-            impl<DependencyHistoryType> DIContainerInternals<
-                DependencyHistoryType
-            > for DIContainer<DependencyHistoryType>
-                where
-                    DependencyHistoryType: IDependencyHistory
+            impl DIContainerInternals for DIContainer
             {
                 fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool
                 where
@@ -349,14 +336,14 @@ pub mod mocks
                 fn set_binding<Interface>(
                     self: &Rc<Self>,
                     name: Option<&'static str>,
-                    provider: Box<dyn IProvider<Self, DependencyHistoryType>>,
+                    provider: Box<dyn IProvider<Self>>,
                 ) where
                     Interface: 'static + ?Sized;
 
                 fn remove_binding<Interface>(
                     self: &Rc<Self>,
                     name: Option<&'static str>,
-                ) -> Option<Box<dyn IProvider<Self, DependencyHistoryType>>>
+                ) -> Option<Box<dyn IProvider<Self>>>
                 where
                     Interface: 'static + ?Sized;
             }
@@ -369,29 +356,24 @@ pub mod mocks
         use std::sync::Arc;
 
         use super::*;
-        use crate::dependency_history::IDependencyHistory;
         use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder;
         use crate::di_container::asynchronous::details::DIContainerInternals;
         use crate::di_container::asynchronous::IAsyncDIContainer;
         use crate::errors::async_di_container::AsyncDIContainerError;
         use crate::provider::r#async::IAsyncProvider;
         use crate::ptr::SomePtr;
+        use crate::util::use_dependency_history;
+
+        use_dependency_history!();
 
         mock! {
-            pub AsyncDIContainer<DependencyHistoryType>
-                where
-                DependencyHistoryType: IDependencyHistory + 'static + Send + Sync
-            {}
+            pub AsyncDIContainer {}
 
             #[async_trait::async_trait]
-            impl<DependencyHistoryType> IAsyncDIContainer<
-                DependencyHistoryType
-            > for AsyncDIContainer<DependencyHistoryType>
-            where
-                DependencyHistoryType: IDependencyHistory + 'static + Send + Sync
+            impl IAsyncDIContainer for AsyncDIContainer
             {
                 fn bind<Interface>(self: &mut Arc<Self>) ->
-                    AsyncBindingBuilder<Interface, Self, DependencyHistoryType>
+                    AsyncBindingBuilder<Interface, Self>
                 where
                     Interface: 'static + ?Sized + Send + Sync;
 
@@ -411,7 +393,7 @@ pub mod mocks
                 #[doc(hidden)]
                 async fn get_bound<Interface>(
                     self: &Arc<Self>,
-                    dependency_history: DependencyHistoryType,
+                    dependency_history: DependencyHistory,
                     name: Option<&'static str>,
                 ) -> Result<SomePtr<Interface>, AsyncDIContainerError>
                 where
@@ -419,11 +401,7 @@ pub mod mocks
             }
 
             #[async_trait::async_trait]
-            impl<DependencyHistoryType> DIContainerInternals<
-                DependencyHistoryType
-            > for AsyncDIContainer<DependencyHistoryType>
-            where
-                DependencyHistoryType: IDependencyHistory + 'static + Send + Sync
+            impl DIContainerInternals for AsyncDIContainer
             {
                 async fn has_binding<Interface>(
                     self: &Arc<Self>,
@@ -435,14 +413,14 @@ pub mod mocks
                 async fn set_binding<Interface>(
                     self: &Arc<Self>,
                     name: Option<&'static str>,
-                    provider: Box<dyn IAsyncProvider<Self, DependencyHistoryType>>,
+                    provider: Box<dyn IAsyncProvider<Self>>,
                 ) where
                     Interface: 'static + ?Sized;
 
                 async fn remove_binding<Interface>(
                     self: &Arc<Self>,
                     name: Option<&'static str>,
-                ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistoryType>>>
+                ) -> Option<Box<dyn IAsyncProvider<Self>>>
                 where
                     Interface: 'static + ?Sized;
             }
@@ -457,34 +435,31 @@ pub mod mocks
         use async_trait::async_trait;
 
         use super::*;
-        use crate::dependency_history::IDependencyHistory;
         use crate::di_container::asynchronous::IAsyncDIContainer;
         use crate::errors::injectable::InjectableError;
         use crate::provider::r#async::{AsyncProvidable, IAsyncProvider};
+        use crate::util::use_dependency_history;
+
+        use_dependency_history!();
 
         mock! {
-            pub AsyncProvider<
-                DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-                DependencyHistoryType: IDependencyHistory + Send + Sync
-            > {}
+            pub AsyncProvider<DIContainerType: IAsyncDIContainer> {}
 
             #[async_trait]
             impl<
-                DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
-                DependencyHistoryType: IDependencyHistory + Send + Sync
-            > IAsyncProvider<DIContainerType, DependencyHistoryType> for AsyncProvider<
+                DIContainerType: IAsyncDIContainer,
+            > IAsyncProvider<DIContainerType> for AsyncProvider<
                 DIContainerType,
-                DependencyHistoryType
             >
             {
                 async fn provide(
                     &self,
                     di_container: &Arc<DIContainerType>,
-                    dependency_history: DependencyHistoryType
-                ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>;
+                    dependency_history: DependencyHistory
+                ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>;
 
                 fn do_clone(&self) ->
-                    Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>;
+                    Box<dyn IAsyncProvider<DIContainerType>>;
             }
         }
     }
@@ -494,47 +469,31 @@ pub mod mocks
         use std::rc::Rc;
 
         use super::*;
-        use crate::dependency_history::IDependencyHistory;
         use crate::di_container::blocking::IDIContainer;
         use crate::errors::injectable::InjectableError;
         use crate::provider::blocking::{IProvider, Providable};
+        use crate::util::use_dependency_history;
+
+        use_dependency_history!();
 
         mock! {
-            pub Provider<DIContainerType, DependencyHistoryType>
+            pub Provider<DIContainerType>
             where
-                DIContainerType: IDIContainer<DependencyHistoryType>,
-                DependencyHistoryType: IDependencyHistory,
+                DIContainerType: IDIContainer
             {}
 
-            impl<DIContainerType, DependencyHistoryType> IProvider<
-                DIContainerType,
-                DependencyHistoryType
-            > for Provider<DIContainerType, DependencyHistoryType>
-                where
-                    DIContainerType: IDIContainer<DependencyHistoryType>,
-                    DependencyHistoryType: IDependencyHistory
+            impl<DIContainerType> IProvider<DIContainerType> for Provider<DIContainerType>
+            where
+                DIContainerType: IDIContainer,
             {
                 fn provide(
                     &self,
                     di_container: &Rc<DIContainerType>,
-                    dependency_history: DependencyHistoryType,
-                ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>;
+                    dependency_history: DependencyHistory,
+                ) -> Result<Providable<DIContainerType>, InjectableError>;
             }
         }
     }
-
-    mock! {
-        pub DependencyHistory {}
-
-        impl crate::dependency_history::IDependencyHistory for DependencyHistory
-        {
-            fn push<Dependency: 'static + ?Sized>(&mut self);
-
-            fn contains<Dependency: 'static + ?Sized>(&self) -> bool;
-        }
-
-        impl crate::dependency_history::private::Sealed for DependencyHistory {}
-    }
 }
 
 #[cfg(feature = "async")]
diff --git a/src/util.rs b/src/util.rs
new file mode 100644
index 0000000..2d2d911
--- /dev/null
+++ b/src/util.rs
@@ -0,0 +1,15 @@
+#[cfg(not(test))]
+macro_rules! use_dependency_history {
+    () => {
+        use $crate::dependency_history::DependencyHistory;
+    };
+}
+
+#[cfg(test)]
+macro_rules! use_dependency_history {
+    () => {
+        use $crate::dependency_history::MockDependencyHistory as DependencyHistory;
+    };
+}
+
+pub(crate) use use_dependency_history;