diff --git a/source/tinystl/iterator/iterator_traits.h b/source/tinystl/iterator/iterator_traits.h
index b56f383..bc1203a 100644
--- a/source/tinystl/iterator/iterator_traits.h
+++ b/source/tinystl/iterator/iterator_traits.h
@@ -69,83 +69,83 @@ concept cpp17_random_access_iterator =
 
 // has nested types
 template <class Iter>
-concept has_iterator_category = requires { typename Iter::iterator_category; };
+concept iter_has_iterator_category = requires { typename Iter::iterator_category; };
 
 template <class Iter>
-concept has_value_type = requires { typename Iter::value_type; };
+concept iter_has_value_type = requires { typename Iter::value_type; };
 
 template <class Iter>
-concept has_difference_type = requires { typename Iter::difference_type; };
+concept iter_has_difference_type = requires { typename Iter::difference_type; };
 
 template <class Iter>
-concept has_pointer = requires { typename Iter::pointer; };
+concept iter_has_pointer = requires { typename Iter::pointer; };
 
 template <class Iter>
-concept has_reference = requires { typename Iter::reference; };
+concept iter_has_reference = requires { typename Iter::reference; };
 
 // get pointer type
 template <class Iter>
-concept has_arrow =
+concept iter_has_arrow =
   requires(Iter &&iter) { static_cast<Iter &&>(iter).operator->(); };
 
 template <class Iter>
-struct get_pointer {
+struct iter_get_pointer {
   using type = void;
 };
 
-template <has_pointer Iter>
-struct get_pointer<Iter> {
+template <iter_has_pointer Iter>
+struct iter_get_pointer<Iter> {
   using type = typename Iter::pointer;
 };
 
 template <class Iter>
-  requires(!has_pointer<Iter>) && (has_arrow<Iter>)
-struct get_pointer<Iter> {
+  requires(!iter_has_pointer<Iter>) && (iter_has_arrow<Iter>)
+struct iter_get_pointer<Iter> {
   using type = decltype(std::declval<Iter &>().operator->());
 };
 
 // get reference type
 template <class Iter>
-struct get_reference {
+struct iter_get_reference {
   using type = std::remove_reference_t<Iter>;
 };
 
-template <has_reference Iter>
-struct get_reference<Iter> {
+template <iter_has_reference Iter>
+struct iter_get_reference<Iter> {
   using type = typename Iter::reference;
 };
 
 // get iterator category
 template <class Iter>
-struct get_iterator_category_impl {
+struct iter_get_iterator_category_impl {
   using type = tinystl::input_iterator_tag;
 };
 
 template <cpp17_forward_iterator Iter>
-struct get_iterator_category_impl<Iter> {
+struct iter_get_iterator_category_impl<Iter> {
   using type = tinystl::forward_iterator_tag;
 };
 
 template <cpp17_bidirectional_iterator Iter>
-struct get_iterator_category_impl<Iter> {
+struct iter_get_iterator_category_impl<Iter> {
   using type = tinystl::bidirectional_iterator_tag;
 };
 
 template <cpp17_random_access_iterator Iter>
-struct get_iterator_category_impl<Iter> {
+struct iter_get_iterator_category_impl<Iter> {
   using type = tinystl::random_access_iterator_tag;
 };
 
 template <class Iter>
-struct get_iterator_category : get_iterator_category_impl<Iter> {};
+struct iter_get_iterator_category : iter_get_iterator_category_impl<Iter> {};
 
-template <has_iterator_category Iter>
-struct get_iterator_category<Iter> {
+template <iter_has_iterator_category Iter>
+struct iter_get_iterator_category<Iter> {
   using type = Iter::iterator_category;
 };
 
 template <class Iter>
-struct get_difference_type {
+struct iter_get_difference_type {
   using type = void;
 };
 
@@ -153,17 +153,17 @@ template <class Iter>
   requires requires {
     typename std::incrementable_traits<Iter>::difference_type;
   }
-struct get_difference_type<Iter> {
+struct iter_get_difference_type<Iter> {
   using type = typename std::incrementable_traits<Iter>::difference_type;
 };
 
 template <class Iter>
 concept specifies_members = requires {
-  requires has_value_type<Iter>;
-  requires has_difference_type<Iter>;
-  requires has_reference<Iter>;
-  requires has_iterator_category<Iter>;
-  requires !has_pointer<Iter>;
+  requires iter_has_value_type<Iter>;
+  requires iter_has_difference_type<Iter>;
+  requires iter_has_reference<Iter>;
+  requires iter_has_iterator_category<Iter>;
+  requires !iter_has_pointer<Iter>;
 };
 
 template <class _Tp>
@@ -192,19 +192,19 @@ struct iterator_traits<Iter> {
 
 template <detail::cpp17_input_iterator_missing_members Iter>
 struct iterator_traits<Iter> {
-  using iterator_category = typename detail::get_iterator_category<Iter>::type;
+  using iterator_category = typename detail::iter_get_iterator_category<Iter>::type;
   using value_type = typename std::indirectly_readable_traits<Iter>::value_type;
   using difference_type =
     typename std::incrementable_traits<Iter>::difference_type;
-  using pointer = typename detail::get_pointer<Iter>::type;
-  using reference = typename detail::get_reference<Iter>::type;
+  using pointer = typename detail::iter_get_pointer<Iter>::type;
+  using reference = typename detail::iter_get_reference<Iter>::type;
 };
 
 template <detail::cpp17_iterator_missing_members Iter>
 struct iterator_traits<Iter> {
   using iterator_category = output_iterator_tag;
   using value_type = void;
-  using difference_type = detail::get_difference_type<Iter>::type;
+  using difference_type = detail::iter_get_difference_type<Iter>::type;
   using pointer = void;
   using reference = void;
 };
diff --git a/source/tinystl/memory/allocator_traits.h b/source/tinystl/memory/allocator_traits.h
index b4daa8e..121c7e1 100644
--- a/source/tinystl/memory/allocator_traits.h
+++ b/source/tinystl/memory/allocator_traits.h
@@ -16,89 +16,89 @@
 // https://en.cppreference.com/w/cpp/memory/allocator_traits.html
 
 namespace detail {
-// get_pointer
+// alloc_get_pointer
 template <class Alloc, class = void>
-struct get_pointer {
+struct alloc_get_pointer {
   using type = typename Alloc::value_type *;
 };
 template <class Alloc>
-struct get_pointer<Alloc, tinystl::void_t<typename Alloc::pointer>> {
+struct alloc_get_pointer<Alloc, tinystl::void_t<typename Alloc::pointer>> {
   using type = typename Alloc::pointer;
 };
 
-// get_const_pointer
+// alloc_get_const_pointer
 template <class Alloc, class = void>
-struct get_const_pointer {
-  using pointer_type = typename get_pointer<Alloc>::type;
+struct alloc_get_const_pointer {
+  using pointer_type = typename alloc_get_pointer<Alloc>::type;
   using value_type = typename Alloc::value_type;
   using type = typename tinystl::pointer_traits<pointer_type>::template rebind<
     const value_type>;
 };
 template <class Alloc>
-struct get_const_pointer<
+struct alloc_get_const_pointer<
   Alloc, tinystl::void_t<typename Alloc::const_pointer>> {
   using type = typename Alloc::const_pointer;
 };
 
-// get_void_pointer
+// alloc_get_void_pointer
 template <class Alloc, class = void>
-struct get_void_pointer {
-  using pointer_type = typename get_pointer<Alloc>::type;
+struct alloc_get_void_pointer {
+  using pointer_type = typename alloc_get_pointer<Alloc>::type;
   using type =
     typename tinystl::pointer_traits<pointer_type>::template rebind<void>;
 };
 template <class Alloc>
-struct get_void_pointer<Alloc, tinystl::void_t<typename Alloc::void_pointer>> {
+struct alloc_get_void_pointer<Alloc, tinystl::void_t<typename Alloc::void_pointer>> {
   using type = typename Alloc::void_pointer;
 };
 
-// get_const_void_pointer
+// alloc_get_const_void_pointer
 template <class Alloc, class = void>
-struct get_const_void_pointer {
-  using pointer_type = typename get_pointer<Alloc>::type;
+struct alloc_get_const_void_pointer {
+  using pointer_type = typename alloc_get_pointer<Alloc>::type;
   using type =
     typename tinystl::pointer_traits<pointer_type>::template rebind<const void>;
 };
 
 template <class Alloc>
-struct get_const_void_pointer<
+struct alloc_get_const_void_pointer<
   Alloc, tinystl::void_t<typename Alloc::const_void_pointer>> {
   using type = typename Alloc::const_void_pointer;
 };
 
-// get_difference_type
+// alloc_get_difference_type
 template <class Alloc, class = void>
-struct get_difference_type {
-  using _Ptrty = typename get_pointer<Alloc>::type;
+struct alloc_get_difference_type {
+  using _Ptrty = typename alloc_get_pointer<Alloc>::type;
   using type = typename tinystl::pointer_traits<_Ptrty>::difference_type;
 };
 
 template <class Alloc>
-struct get_difference_type<
+struct alloc_get_difference_type<
   Alloc, tinystl::void_t<typename Alloc::difference_type>> {
   using type = typename Alloc::difference_type;
 };
 
-// get_size_type
+// alloc_get_size_type
 template <class Alloc, class = void>
-struct get_size_type {
+struct alloc_get_size_type {
   using type =
-    tinystl::make_unsigned_t<typename get_difference_type<Alloc>::type>;
+    tinystl::make_unsigned_t<typename alloc_get_difference_type<Alloc>::type>;
 };
 
 template <class Alloc>
-struct get_size_type<Alloc, tinystl::void_t<typename Alloc::size_type>> {
+struct alloc_get_size_type<Alloc, tinystl::void_t<typename Alloc::size_type>> {
   using type = typename Alloc::size_type;
 };
 
 // propagate_on_container_copy_assignment
 template <class Alloc, class = void>
-struct get_propagate_on_container_copy_assignment {
+struct alloc_get_propagate_on_container_copy_assignment {
   using type = tinystl::false_type;
 };
 
 template <class Alloc>
-struct get_propagate_on_container_copy_assignment<
+struct alloc_get_propagate_on_container_copy_assignment<
   Alloc,
   tinystl::void_t<typename Alloc::propagate_on_container_copy_assignment>> {
   using type = typename Alloc::propagate_on_container_copy_assignment;
@@ -106,12 +106,12 @@ struct get_propagate_on_container_copy_assignment<
 
 // propagate_on_container_move_assignment
 template <class Alloc, class = void>
-struct get_propagate_on_container_move_assignment {
+struct alloc_get_propagate_on_container_move_assignment {
   using type = tinystl::false_type;
 };
 
 template <class Alloc>
-struct get_propagate_on_container_move_assignment<
+struct alloc_get_propagate_on_container_move_assignment<
   Alloc,
   tinystl::void_t<typename Alloc::propagate_on_container_move_assignment>> {
   using type = typename Alloc::propagate_on_container_move_assignment;
@@ -119,89 +119,89 @@ struct get_propagate_on_container_move_assignment<
 
 // propagate_on_container_swap
 template <class Alloc, class = void>
-struct get_propagate_on_container_swap {
+struct alloc_get_propagate_on_container_swap {
   using type = tinystl::false_type;
 };
 
 template <class Alloc>
-struct get_propagate_on_container_swap<
+struct alloc_get_propagate_on_container_swap<
   Alloc, tinystl::void_t<typename Alloc::propagate_on_container_swap>> {
   using type = typename Alloc::propagate_on_container_swap;
 };
 
 // is_always_equal
 template <class Alloc, class = void>
-struct get_is_always_equal {
+struct alloc_get_is_always_equal {
   using type = tinystl::is_empty<Alloc>;
 };
 
 template <class Alloc>
-struct get_is_always_equal<
+struct alloc_get_is_always_equal<
   Alloc, tinystl::void_t<typename Alloc::is_always_equal>> {
   using type = typename Alloc::is_always_equal;
 };
 
 // rebind_alloc
 template <class Alloc, class Newfirst>
-struct get_rebind_get_impl;
+struct alloc_get_rebind_alloc_impl;
 
 template <
   template <class, class...> class Alloc, class First, class... Rest,
   class Newfirst>
-struct get_rebind_get_impl<Alloc<First, Rest...>, Newfirst> {
+struct alloc_get_rebind_alloc_impl<Alloc<First, Rest...>, Newfirst> {
   // given Alloc<First, Rest...>, replace First with Newfirst
   using type = Alloc<Newfirst, Rest...>;
 };
 
 template <class Alloc, class NewAlloc, class = void>
-struct get_rebind_alloc {
-  using type = typename get_rebind_get_impl<Alloc, NewAlloc>::type;
+struct alloc_get_rebind_alloc {
+  using type = typename alloc_get_rebind_alloc_impl<Alloc, NewAlloc>::type;
 };
 
 template <class Alloc, class NewAlloc>
-struct get_rebind_alloc<
+struct alloc_get_rebind_alloc<
   Alloc, NewAlloc,
   tinystl::void_t<typename Alloc::template rebind<NewAlloc>::other>> {
   using type = typename Alloc::template rebind<NewAlloc>::other;
 };
 
-// has_construct
+// alloc_has_construct
 template <class, class Alloc, class... Args>
-const bool has_construct_impl = false;
+const bool alloc_has_construct_impl = false;
 
 template <class Alloc, class... Args>
-const bool has_construct_impl<
+const bool alloc_has_construct_impl<
   decltype((void)std::declval<Alloc>().construct(std::declval<Args>()...)),
   Alloc, Args...> = true;
 
 template <class Alloc, class... Args>
-const bool has_construct = has_construct_impl<void, Alloc, Args...>;
+const bool alloc_has_construct = alloc_has_construct_impl<void, Alloc, Args...>;
 
-// has_destroy
+// alloc_has_destroy
 template <class Alloc, class Pointer, class = void>
-const bool has_destroy = false;
+const bool alloc_has_destroy = false;
 
 template <class Alloc, class Pointer>
-const bool has_destroy<
+const bool alloc_has_destroy<
   Alloc, Pointer,
   decltype((void)std::declval<Alloc>().destroy(std::declval<Pointer>()))> =
   true;
 
-// has_max_size
+// alloc_has_max_size
 template <class Alloc, class = void>
-const bool has_max_size = false;
+const bool alloc_has_max_size = false;
 
 template <class Alloc>
 const bool
-  has_max_size<Alloc, decltype((void)std::declval<Alloc &>().max_size())> =
+  alloc_has_max_size<Alloc, decltype((void)std::declval<Alloc &>().max_size())> =
     true;
 
-// has_select_on_container_copy_construction
+// alloc_has_select_on_container_copy_construction
 template <class Alloc, class = void>
-const bool has_select_on_container_copy_construction = false;
+const bool alloc_has_select_on_container_copy_construction = false;
 
 template <class Alloc>
-const bool has_select_on_container_copy_construction<
+const bool alloc_has_select_on_container_copy_construction<
   Alloc, decltype((void)std::declval<Alloc>()
                     .select_on_container_copy_construction())> = true;
 
@@ -215,27 +215,27 @@ struct allocator_traits {
   using allocator_type = Alloc;
   using value_type = typename Alloc::value_type;
 
-  using pointer = typename detail::get_pointer<Alloc>::type;
-  using const_pointer = typename detail::get_const_pointer<Alloc>::type;
-  using void_pointer = typename detail::get_void_pointer<Alloc>::type;
+  using pointer = typename detail::alloc_get_pointer<Alloc>::type;
+  using const_pointer = typename detail::alloc_get_const_pointer<Alloc>::type;
+  using void_pointer = typename detail::alloc_get_void_pointer<Alloc>::type;
   using const_void_pointer =
-    typename detail::get_const_void_pointer<Alloc>::type;
+    typename detail::alloc_get_const_void_pointer<Alloc>::type;
 
-  using size_type = typename detail::get_size_type<Alloc>::type;
-  using difference_type = typename detail::get_difference_type<Alloc>::type;
+  using size_type = typename detail::alloc_get_size_type<Alloc>::type;
+  using difference_type = typename detail::alloc_get_difference_type<Alloc>::type;
 
   using propagate_on_container_copy_assignment =
-    typename detail::get_propagate_on_container_copy_assignment<Alloc>::type;
+    typename detail::alloc_get_propagate_on_container_copy_assignment<Alloc>::type;
   using propagate_on_container_move_assignment =
-    typename detail::get_propagate_on_container_move_assignment<Alloc>::type;
+    typename detail::alloc_get_propagate_on_container_move_assignment<Alloc>::type;
   using propagate_on_container_swap =
-    typename detail::get_propagate_on_container_swap<Alloc>::type;
+    typename detail::alloc_get_propagate_on_container_swap<Alloc>::type;
 
-  using is_always_equal = typename detail::get_is_always_equal<Alloc>::type;
+  using is_always_equal = typename detail::alloc_get_is_always_equal<Alloc>::type;
 
   // Member alias templates
   template <class NewAlloc>
-  using rebind_alloc = typename detail::get_rebind_alloc<Alloc, NewAlloc>::type;
+  using rebind_alloc = typename detail::alloc_get_rebind_alloc<Alloc, NewAlloc>::type;
 
   template <class NewAlloc>
   using rebind_traits = allocator_traits<rebind_alloc<NewAlloc>>;
@@ -253,48 +253,48 @@ struct allocator_traits {
 
   template <
     class T, class... Args,
-    enable_if_t<detail::has_construct<Alloc, T *, Args...>, int> = 0>
+    enable_if_t<detail::alloc_has_construct<Alloc, T *, Args...>, int> = 0>
   static void construct(Alloc &a, T *p, Args &&...args) {
     a.construct(p, std::forward<Args>(args)...);
   }
 
   template <
     class T, class... Args,
-    enable_if_t<!detail::has_construct<Alloc, T *, Args...>, int> = 0>
+    enable_if_t<!detail::alloc_has_construct<Alloc, T *, Args...>, int> = 0>
   static void construct(Alloc &, T *p, Args &&...args) {
     construct_at(p, std::forward<Args>(args)...);
   }
 
-  template <class T, enable_if_t<detail::has_destroy<Alloc, T *>, int> = 0>
+  template <class T, enable_if_t<detail::alloc_has_destroy<Alloc, T *>, int> = 0>
   static void destroy(Alloc &a, T *p) {
     a.destroy(p);
   }
 
-  template <class T, enable_if_t<!detail::has_destroy<Alloc, T *>, int> = 0>
+  template <class T, enable_if_t<!detail::alloc_has_destroy<Alloc, T *>, int> = 0>
   static void destroy(Alloc &, T *p) {
     destroy_at(p);
   }
 
-  template <class U = Alloc, enable_if_t<detail::has_max_size<U>, int> = 0>
+  template <class U = Alloc, enable_if_t<detail::alloc_has_max_size<U>, int> = 0>
   static size_type max_size(const Alloc &a) noexcept {
     return a.max_size();
   }
 
-  template <class U = Alloc, enable_if_t<!detail::has_max_size<U>, int> = 0>
+  template <class U = Alloc, enable_if_t<!detail::alloc_has_max_size<U>, int> = 0>
   static size_type max_size(const Alloc &) noexcept {
     return std::numeric_limits<size_type>::max() / sizeof(value_type);
   }
 
   template <
     class U = Alloc,
-    enable_if_t<detail::has_select_on_container_copy_construction<U>, int> = 0>
+    enable_if_t<detail::alloc_has_select_on_container_copy_construction<U>, int> = 0>
   static Alloc select_on_container_copy_construction(const Alloc &a) {
     return a.select_on_container_copy_construction();
   }
 
   template <
     class U = Alloc,
-    enable_if_t<!detail::has_select_on_container_copy_construction<U>, int> = 0>
+    enable_if_t<!detail::alloc_has_select_on_container_copy_construction<U>, int> = 0>
   static Alloc select_on_container_copy_construction(const Alloc &a) {
     return a;
   }