diff --git a/include/rexy/list.hpp b/include/rexy/list.hpp
index c96d2dc..e26cd49 100644
--- a/include/rexy/list.hpp
+++ b/include/rexy/list.hpp
@@ -33,9 +33,9 @@ namespace rexy{
 	class list;
 
 	namespace detail{
-		struct node_base{
-			node_base* next = nullptr;
-			node_base* prev = nullptr;
+		struct list_node_base{
+			list_node_base* next = nullptr;
+			list_node_base* prev = nullptr;
 		};
 
 		template<class T>
@@ -43,14 +43,14 @@ namespace rexy{
 		template<class T>
 		struct const_list_iterator;
 		template<class T>
-		struct node;
+		struct list_node;
 	}
 
 	template<class T, class Alloc = rexy::allocator<T>>
-	class list : protected detail::hasallocator<typename std::allocator_traits<Alloc>::template rebind_alloc<detail::node<T>>>
+	class list : protected detail::hasallocator<typename std::allocator_traits<Alloc>::template rebind_alloc<detail::list_node<T>>>
 	{
 	private:
-		using node_allocator_type = detail::hasallocator<typename std::allocator_traits<Alloc>::template rebind_alloc<detail::node<T>>>;
+		using node_allocator_type = detail::hasallocator<typename std::allocator_traits<Alloc>::template rebind_alloc<detail::list_node<T>>>;
 
 	public:
 		using value_type = T;
@@ -67,10 +67,10 @@ namespace rexy{
 		using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
 	public:
-		using node = detail::node<T>;
+		using node = detail::list_node<T>;
 
 	private:
-		detail::node_base m_sentinel = {&m_sentinel, &m_sentinel};
+		detail::list_node_base m_sentinel = {&m_sentinel, &m_sentinel};
 		size_type m_size = 0;
 
 	public:
@@ -202,9 +202,9 @@ namespace rexy{
 		static iterator mergesort(iterator first, size_type firstlen, Comp comp);
 		static std::pair<iterator,size_type> ms_split(iterator it, size_type len);
 
-		static void insert_node_(detail::node_base* prev, detail::node_base* n);
-		static void remove_node_(detail::node_base* rm);
-		static detail::node_base* get_next_then_move_node_(detail::node_base* dest, detail::node_base* n);
+		static void insert_node_(detail::list_node_base* prev, detail::list_node_base* n);
+		static void remove_node_(detail::list_node_base* rm);
+		static detail::list_node_base* get_next_then_move_node_(detail::list_node_base* dest, detail::list_node_base* n);
 	};
 
 }
diff --git a/include/rexy/list.tpp b/include/rexy/list.tpp
index 2141d64..26405d5 100644
--- a/include/rexy/list.tpp
+++ b/include/rexy/list.tpp
@@ -30,28 +30,28 @@ namespace rexy{
 
 	namespace detail{
 		template<class T>
-		struct node : public node_base{
+		struct list_node : public list_node_base{
 			T data;
 
-			constexpr node(node_base* next, node_base* prev, const T& d):
-				node_base{next, prev},
+			constexpr list_node(list_node_base* next, list_node_base* prev, const T& d):
+				list_node_base{next, prev},
 				data(d){}
-			constexpr node(node_base* next, node_base* prev, T&& d):
-				node_base{next, prev},
+			constexpr list_node(list_node_base* next, list_node_base* prev, T&& d):
+				list_node_base{next, prev},
 				data(std::move(d)){}
 			template<class... Args>
-			constexpr node(node_base* next, node_base* prev, Args&&... args):
-				node_base{next, prev},
+			constexpr list_node(list_node_base* next, list_node_base* prev, Args&&... args):
+				list_node_base{next, prev},
 				data(std::forward<Args>(args)...){}
-			constexpr node(const node& n):
-				node_base(n),
+			constexpr list_node(const list_node& n):
+				list_node_base(n),
 				data(n.data){}
-			constexpr node(node&& n):
-				node_base(std::move(n)),
+			constexpr list_node(list_node&& n):
+				list_node_base(std::move(n)),
 				data(std::move(n.data)){}
 
-			constexpr node* next(void)const{return static_cast<node*>(node_base::next);}
-			constexpr node* prev(void)const{return static_cast<node*>(node_base::prev);}
+			constexpr list_node* next(void)const{return static_cast<list_node*>(list_node_base::next);}
+			constexpr list_node* prev(void)const{return static_cast<list_node*>(list_node_base::prev);}
 		};
 
 		template<class T>
@@ -63,9 +63,9 @@ namespace rexy{
 			using pointer = value_type*;
 			using const_pointer = const value_type*;
 
-			using node_t = node<T>;
+			using node_t = list_node<T>;
 
-			node_base* current = nullptr;
+			list_node_base* current = nullptr;
 
 			constexpr bool operator==(const list_iterator& other)const noexcept{return current == other.current;}
 			constexpr bool operator!=(const list_iterator& other)const noexcept{return current != other.current;}
@@ -106,8 +106,8 @@ namespace rexy{
 				return list_iterator{current->prev};
 			}
 
-			node_base* nod(void){return current;}
-			node_base* nod(void)const{return current;}
+			list_node_base* nod(void){return current;}
+			list_node_base* nod(void)const{return current;}
 		};
 		template<class T>
 		struct const_list_iterator{
@@ -120,9 +120,9 @@ namespace rexy{
 			using pointer = value_type*;
 			using const_pointer = const value_type*;
 
-			using node_t = node<T>;
+			using node_t = list_node<T>;
 
-			const node_base* current = nullptr;
+			const list_node_base* current = nullptr;
 
 			constexpr bool operator==(const const_list_iterator& other)const noexcept{return current == other.current;}
 			constexpr bool operator!=(const const_list_iterator& other)const noexcept{return current != other.current;}
@@ -159,11 +159,11 @@ namespace rexy{
 				return const_list_iterator{current->prev};
 			}
 
-			const node_base* nod(void)const{return current;}
+			const list_node_base* nod(void)const{return current;}
 
 		protected:
 			list_iterator<T> unconst(void){
-				return list_iterator<T>{const_cast<node_base*>(current)};
+				return list_iterator<T>{const_cast<list_node_base*>(current)};
 			}
 		};
 
@@ -661,19 +661,19 @@ namespace rexy{
 	}
 
 	template<class T, class Alloc>
-	void list<T,Alloc>::insert_node_(detail::node_base* prev, detail::node_base* n){
+	void list<T,Alloc>::insert_node_(detail::list_node_base* prev, detail::list_node_base* n){
 		n->next = prev->next;
 		n->prev = prev;
 		prev->next->prev = n;
 		prev->next = n;
 	}
 	template<class T, class Alloc>
-	void list<T,Alloc>::remove_node_(detail::node_base* rm){
+	void list<T,Alloc>::remove_node_(detail::list_node_base* rm){
 		rm->prev->next = rm->next;
 		rm->next->prev = rm->prev;
 	}
 	template<class T, class Alloc>
-	detail::node_base* list<T,Alloc>::get_next_then_move_node_(detail::node_base* dest, detail::node_base* n){
+	detail::list_node_base* list<T,Alloc>::get_next_then_move_node_(detail::list_node_base* dest, detail::list_node_base* n){
 		auto* next = n->next;
 		remove_node_(n);
 		insert_node_(dest, n);