diff --git a/source/tinystl/allocator/.gitkeep b/source/tinystl/allocator/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/source/tinystl/container/array.h b/source/tinystl/container/array.h
index 821f4c7..6b176ac 100644
--- a/source/tinystl/container/array.h
+++ b/source/tinystl/container/array.h
@@ -4,10 +4,9 @@
 
 #include <compare>
 #include <cstddef>
+#include <iterator>
 #include <stdexcept>
 
-#include "tinystl/iterator/reverse_iterator.h"
-
 namespace tinystl {
 template <class T, std::size_t N>
 struct array {
@@ -21,8 +20,8 @@ struct array {
   using const_pointer = const value_type *;
   using iterator = pointer;
   using const_iterator = const_pointer;
-  using reverse_iterator = tinystl::reverse_iterator<iterator>;
-  using const_reverse_iterator = tinystl::reverse_iterator<const_iterator>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
   // Member functions
 
diff --git a/source/tinystl/experimental/type_traits.h b/source/tinystl/experimental/type_traits.h
deleted file mode 100644
index 3c0c119..0000000
--- a/source/tinystl/experimental/type_traits.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/void_t.h"
-#include "tinystl/type_traits/is_same.h"
-#include "tinystl/type_traits/is_convertible.h"
-
-namespace detail {
-template <
-  class Default, class AlwaysVoid, template <class...> class Op, class... Args>
-struct detector {
-  using value_t = tinystl::false_type;
-  using type = Default;
-};
-
-template <class Default, template <class...> class Op, class... Args>
-struct detector<Default, tinystl::void_t<Op<Args...>>, Op, Args...> {
-  using value_t = tinystl::true_type;
-  using type = Op<Args...>;
-};
-} // namespace detail
-
-namespace tinystl {
-
-struct nonesuch {
-  ~nonesuch() = delete;
-  nonesuch(nonesuch const &) = delete;
-  void operator=(nonesuch const &) = delete;
-};
-
-template <template <class...> class Op, class... Args>
-using is_detected =
-  typename detail::detector<nonesuch, void, Op, Args...>::value_t;
-
-template <template <class...> class Op, class... Args>
-using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;
-
-template <class Default, template <class...> class Op, class... Args>
-using detected_or = detail::detector<Default, void, Op, Args...>;
-
-template< template<class...> class Op, class... Args >
-constexpr inline bool is_detected_v = is_detected<Op, Args...>::value;
-
-template< class Default, template<class...> class Op, class... Args >
-using detected_or_t = typename detected_or<Default, Op, Args...>::type;
-
-template< class Expected, template<class...> class Op, class... Args >
-using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>;
-
-template< class Expected, template<class...> class Op, class... Args >
-constexpr inline bool is_detected_exact_v =
-    is_detected_exact<Expected, Op, Args...>::value;
-
-template< class To, template<class...> class Op, class... Args >
-using is_detected_convertible =
-    is_convertible<detected_t<Op, Args...>, To>;
-
-template< class To, template<class...> class Op, class... Args >
-constexpr inline bool is_detected_convertible_v =
-    is_detected_convertible<To, Op, Args...>::value;
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/iterator/.gitkeep b/source/tinystl/iterator/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/source/tinystl/iterator/back_insert_iterator.h b/source/tinystl/iterator/back_insert_iterator.h
deleted file mode 100644
index e6f5a4d..0000000
--- a/source/tinystl/iterator/back_insert_iterator.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include <utility>
-
-#include "tinystl/iterator/iterator_tag.h"
-
-namespace tinystl {
-
-// https://en.cppreference.com/w/cpp/iterator/back_insert_iterator.html
-template <class Container>
-class back_insert_iterator {
-public:
-  // Member types
-  using iterator_category = output_iterator_tag;
-  using value_type = void;
-  using difference_type = ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-
-  // Member functions
-  explicit back_insert_iterator(Container &c) : container(&c) {}
-
-  back_insert_iterator &operator=(const typename Container::value_type &value) {
-    container->push_back(value);
-    return *this;
-  }
-
-  back_insert_iterator &operator=(typename Container::value_type &&value) {
-    container->push_back(std::move(value));
-    return *this;
-  }
-
-  back_insert_iterator &operator*() { return *this; }
-
-  back_insert_iterator &operator++() { return *this; }
-
-  back_insert_iterator operator++(int) { return *this; }
-
-protected:
-  // Member objects
-  Container *container;
-};
-
-// https://en.cppreference.com/w/cpp/iterator/back_inserter.html
-template <class Container>
-back_insert_iterator<Container> back_inserter(Container &c) {
-  return back_insert_iterator<Container>(c);
-}
-
-} // namespace tinystl
diff --git a/source/tinystl/iterator/front_insert_iterator.h b/source/tinystl/iterator/front_insert_iterator.h
deleted file mode 100644
index 5e6ae8b..0000000
--- a/source/tinystl/iterator/front_insert_iterator.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include <utility>
-
-#include "tinystl/iterator/iterator_tag.h"
-
-namespace tinystl {
-
-// https://en.cppreference.com/w/cpp/iterator/front_insert_iterator.html
-template <class Container>
-class front_insert_iterator {
-public:
-  // Member types
-  using iterator_category = output_iterator_tag;
-  using value_type = void;
-  using difference_type = ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-
-  // Member functions
-  explicit front_insert_iterator(Container &c) : container(&c) {}
-
-  front_insert_iterator &
-  operator=(const typename Container::value_type &value) {
-    container->push_front(value);
-    return *this;
-  }
-
-  front_insert_iterator &operator=(typename Container::value_type &&value) {
-    container->push_front(std::move(value));
-    return *this;
-  }
-
-  front_insert_iterator &operator*() { return *this; }
-
-  front_insert_iterator &operator++() { return *this; }
-
-  front_insert_iterator operator++(int) { return *this; }
-
-protected:
-  // Member objects
-  Container *container;
-};
-
-// https://en.cppreference.com/w/cpp/iterator/front_inserter.html
-template <class Container>
-front_insert_iterator<Container> front_inserter(Container &c) {
-  return front_insert_iterator<Container>(c);
-}
-} // namespace tinystl
diff --git a/source/tinystl/iterator/insert_iterator.h b/source/tinystl/iterator/insert_iterator.h
deleted file mode 100644
index b5ed92b..0000000
--- a/source/tinystl/iterator/insert_iterator.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include <utility>
-
-#include "tinystl/iterator/iterator_tag.h"
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/iterator/insert_iterator.html
-template <class Container>
-class insert_iterator {
-public:
-  // Member types
-  using iterator_category = output_iterator_tag;
-  using value_type = void;
-  using difference_type = ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-
-  // Member functions
-  insert_iterator(Container &c, typename Container::iterator it)
-    : container(&c), iter(it) {}
-
-  insert_iterator &operator=(const typename Container::value_type &value) {
-    iter = container->insert(iter, value);
-    ++iter;
-    return *this;
-  }
-
-  insert_iterator &operator=(typename Container::value_type &&value) {
-    iter = container->insert(iter, std::move(value));
-    ++iter;
-    return *this;
-  }
-
-  insert_iterator &operator*() { return *this; }
-
-  insert_iterator &operator++() { return *this; }
-
-  insert_iterator operator++(int) { return *this; }
-
-protected:
-  Container *container;
-  typename Container::iterator iter;
-};
-
-template <class Container>
-insert_iterator<Container>
-inserter(Container &c, typename Container::iterator it) {
-  return insert_iterator<Container>(c, it);
-}
-
-} // namespace tinystl
diff --git a/source/tinystl/iterator/iterator.h b/source/tinystl/iterator/iterator.h
deleted file mode 100644
index 155646d..0000000
--- a/source/tinystl/iterator/iterator.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-// https://en.cppreference.com/w/cpp/iterator/iterator.html
-namespace tinystl {
-
-template <
-  typename Category, typename T, typename Distance = std::ptrdiff_t,
-  typename Pointer = T *, typename Reference = T &>
-struct [[deprecated("deprecated")]] iterator {
-  using iterator_category = Category;
-  using value_type = T;
-  using difference_type = Distance;
-  using pointer = Pointer;
-  using reference = Reference;
-};
-} // namespace tinystl
diff --git a/source/tinystl/iterator/iterator_tag.h b/source/tinystl/iterator/iterator_tag.h
deleted file mode 100644
index af712a0..0000000
--- a/source/tinystl/iterator/iterator_tag.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-// https://en.cppreference.com/w/cpp/iterator/iterator_tags.html
-// https://en.cppreference.com/w/cpp/iterator/iterator_traits.html
-
-namespace tinystl {
-// iteratror category tags
-struct input_iterator_tag {};
-
-struct output_iterator_tag {};
-
-struct forward_iterator_tag : public input_iterator_tag {};
-
-struct bidirectional_iterator_tag : public forward_iterator_tag {};
-
-struct random_access_iterator_tag : public bidirectional_iterator_tag {};
-
-struct contiguous_iterator_tag : public random_access_iterator_tag {};
-
-
-} // namespace tinystl
diff --git a/source/tinystl/iterator/iterator_traits.h b/source/tinystl/iterator/iterator_traits.h
deleted file mode 100644
index bc1203a..0000000
--- a/source/tinystl/iterator/iterator_traits.h
+++ /dev/null
@@ -1,232 +0,0 @@
-#pragma once
-
-#include <concepts>
-#include <cstddef>
-#include <iterator>
-
-#include "tinystl/iterator/iterator_tag.h"
-#include "tinystl/type_traits/is_object.h"
-#include "tinystl/type_traits/is_renferenceable.h"
-
-// https://en.cppreference.com/w/cpp/iterator/iterator_tags.html
-// https://en.cppreference.com/w/cpp/iterator/iterator_traits.html
-namespace detail {
-template <class I>
-concept cpp17_iterator = requires(I i) {
-  { *i } -> tinystl::referenceable;
-  { ++i } -> std::same_as<I &>;
-  { *i++ } -> tinystl::referenceable;
-} && std::copyable<I>;
-
-template <class I>
-concept cpp17_input_iterator =
-  cpp17_iterator<I> && std::equality_comparable<I> && requires(I i) {
-    typename std::incrementable_traits<I>::difference_type;
-    typename std::indirectly_readable_traits<I>::value_type;
-    typename std::common_reference_t<
-      std::iter_reference_t<I> &&,
-      typename std::indirectly_readable_traits<I>::value_type &>;
-    *i++;
-    typename std::common_reference_t<
-      decltype(*i++) &&,
-      typename std::indirectly_readable_traits<I>::value_type &>;
-    requires std::signed_integral<
-      typename std::incrementable_traits<I>::difference_type>;
-  };
-
-template <class It>
-concept cpp17_forward_iterator =
-  cpp17_input_iterator<It> && std::constructible_from<It> &&
-  std::is_reference_v<std::iter_reference_t<It>> &&
-  std::same_as<
-    std::remove_cvref_t<std::iter_reference_t<It>>,
-    typename std::indirectly_readable_traits<It>::value_type> &&
-  requires(It it) {
-    { it++ } -> std::convertible_to<const It &>;
-    { *it++ } -> std::same_as<std::iter_reference_t<It>>;
-  };
-
-template <class I>
-concept cpp17_bidirectional_iterator =
-  cpp17_forward_iterator<I> && requires(I i) {
-    { --i } -> std::same_as<I &>;
-    { i-- } -> std::convertible_to<const I &>;
-    { *i-- } -> std::same_as<std::iter_reference_t<I>>;
-  };
-
-template <class I>
-concept cpp17_random_access_iterator =
-  cpp17_bidirectional_iterator<I> && std::totally_ordered<I> &&
-  requires(I i, typename std::incrementable_traits<I>::difference_type n) {
-    { i += n } -> std::same_as<I &>;
-    { i -= n } -> std::same_as<I &>;
-    { i + n } -> std::same_as<I>;
-    { n + i } -> std::same_as<I>;
-    { i - n } -> std::same_as<I>;
-    { i - i } -> std::same_as<decltype(n)>;
-    { i[n] } -> std::convertible_to<std::iter_reference_t<I>>;
-  };
-
-// has nested types
-template <class Iter>
-concept iter_has_iterator_category = requires { typename Iter::iterator_category; };
-
-template <class Iter>
-concept iter_has_value_type = requires { typename Iter::value_type; };
-
-template <class Iter>
-concept iter_has_difference_type = requires { typename Iter::difference_type; };
-
-template <class Iter>
-concept iter_has_pointer = requires { typename Iter::pointer; };
-
-template <class Iter>
-concept iter_has_reference = requires { typename Iter::reference; };
-
-// get pointer type
-template <class Iter>
-concept iter_has_arrow =
-  requires(Iter &&iter) { static_cast<Iter &&>(iter).operator->(); };
-
-template <class Iter>
-struct iter_get_pointer {
-  using type = void;
-};
-
-template <iter_has_pointer Iter>
-struct iter_get_pointer<Iter> {
-  using type = typename Iter::pointer;
-};
-
-template <class 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 iter_get_reference {
-  using type = std::remove_reference_t<Iter>;
-};
-
-template <iter_has_reference Iter>
-struct iter_get_reference<Iter> {
-  using type = typename Iter::reference;
-};
-
-// get iterator category
-template <class Iter>
-struct iter_get_iterator_category_impl {
-  using type = tinystl::input_iterator_tag;
-};
-
-template <cpp17_forward_iterator Iter>
-struct iter_get_iterator_category_impl<Iter> {
-  using type = tinystl::forward_iterator_tag;
-};
-
-template <cpp17_bidirectional_iterator Iter>
-struct iter_get_iterator_category_impl<Iter> {
-  using type = tinystl::bidirectional_iterator_tag;
-};
-
-template <cpp17_random_access_iterator Iter>
-struct iter_get_iterator_category_impl<Iter> {
-  using type = tinystl::random_access_iterator_tag;
-};
-
-template <class Iter>
-struct iter_get_iterator_category : iter_get_iterator_category_impl<Iter> {};
-
-template <iter_has_iterator_category Iter>
-struct iter_get_iterator_category<Iter> {
-  using type = Iter::iterator_category;
-};
-
-template <class Iter>
-struct iter_get_difference_type {
-  using type = void;
-};
-
-template <class Iter>
-  requires requires {
-    typename std::incrementable_traits<Iter>::difference_type;
-  }
-struct iter_get_difference_type<Iter> {
-  using type = typename std::incrementable_traits<Iter>::difference_type;
-};
-
-template <class Iter>
-concept specifies_members = requires {
-  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>
-concept cpp17_iterator_missing_members =
-  !specifies_members<_Tp> && cpp17_iterator<_Tp>;
-
-template <class _Tp>
-concept cpp17_input_iterator_missing_members =
-  cpp17_iterator_missing_members<_Tp> && cpp17_input_iterator<_Tp>;
-
-} // namespace detail
-
-namespace tinystl {
-
-template <class Iter>
-struct iterator_traits {};
-
-template <detail::specifies_members Iter>
-struct iterator_traits<Iter> {
-  using iterator_category = typename Iter::iterator_category;
-  using value_type = typename Iter::value_type;
-  using difference_type = typename Iter::difference_type;
-  using pointer = void;
-  using reference = typename Iter::reference;
-};
-
-template <detail::cpp17_input_iterator_missing_members Iter>
-struct iterator_traits<Iter> {
-  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::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::iter_get_difference_type<Iter>::type;
-  using pointer = void;
-  using reference = void;
-};
-
-template <class T>
-  requires is_object_v<T>
-struct iterator_traits<T *> {
-  using iterator_category = random_access_iterator_tag;
-  using value_type = remove_cv_t<T>;
-  using difference_type = std::ptrdiff_t;
-  using pointer = T *;
-  using reference = T &;
-  using iterator_concept = contiguous_iterator_tag;
-};
-
-template <class T>
-struct [[deprecated("deprecated")]] iterator_traits<const T *> {
-  using iterator_category = random_access_iterator_tag;
-  using value_type = T;
-  using difference_type = ptrdiff_t;
-  using pointer = const T *;
-  using reference = const T &;
-};
-
-} // namespace tinystl
diff --git a/source/tinystl/iterator/reverse_iterator.h b/source/tinystl/iterator/reverse_iterator.h
deleted file mode 100644
index 4dee013..0000000
--- a/source/tinystl/iterator/reverse_iterator.h
+++ /dev/null
@@ -1,162 +0,0 @@
-#pragma once
-
-#include "tinystl/iterator/iterator_traits.h"
-
-#include <compare>
-
-namespace tinystl {
-
-// https://en.cppreference.com/w/cpp/iterator/reverse_iterator.html
-template <class Iter>
-class reverse_iterator {
-public:
-  // Member types
-  using iterator_type = Iter;
-  using iterator_category = typename iterator_traits<Iter>::iterator_category;
-  using value_type = typename iterator_traits<Iter>::value_type;
-  using difference_type = typename iterator_traits<Iter>::difference_type;
-  using pointer = typename iterator_traits<Iter>::pointer;
-  using reference = typename iterator_traits<Iter>::reference;
-
-  // Member functions
-  reverse_iterator() = default;
-
-  explicit reverse_iterator(Iter itr) : current(itr) {}
-
-  template <class U>
-  reverse_iterator(const reverse_iterator<U> &other) : current(other.current) {}
-
-  template <class U>
-  reverse_iterator &operator=(const reverse_iterator<U> &other) {
-    current = other.current;
-    return *this;
-  }
-
-  iterator_type base() const { return current; }
-
-  reference operator*() const {
-    Iter tmp = current;
-    return *--tmp;
-  }
-
-  pointer operator->() const { return std::addressof(operator*()); }
-
-  reference operator[](difference_type n) const { return *(*this + n); }
-
-  reverse_iterator &operator++() {
-    --current;
-    return *this;
-  }
-
-  reverse_iterator &operator--() {
-    ++current;
-    return *this;
-  }
-
-  reverse_iterator operator++(int) {
-    reverse_iterator tmp = *this;
-    --current;
-    return tmp;
-  }
-
-  reverse_iterator operator--(int) {
-    reverse_iterator tmp = *this;
-    ++current;
-    return tmp;
-  }
-
-  reverse_iterator operator+(difference_type n) const {
-    return reverse_iterator(current - n);
-  }
-
-  reverse_iterator operator-(difference_type n) const {
-    return reverse_iterator(current + n);
-  }
-
-  reverse_iterator &operator+=(difference_type n) {
-    current -= n;
-    return *this;
-  }
-
-  reverse_iterator &operator-=(difference_type n) {
-    current += n;
-    return *this;
-  }
-
-  // TODO
-protected:
-  Iter current = Iter();
-};
-
-// Non-member functions
-template <class Iter1, class Iter2>
-bool operator==(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return lhs.base() == rhs.base();
-}
-
-template <class Iter1, class Iter2>
-bool operator!=(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return lhs.base() != rhs.base();
-}
-
-template <class Iter1, class Iter2>
-bool operator<(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return lhs.base() > rhs.base();
-}
-
-template <class Iter1, class Iter2>
-bool operator<=(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return lhs.base() >= rhs.base();
-}
-
-template <class Iter1, class Iter2>
-bool operator>(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return lhs.base() < rhs.base();
-}
-
-template <class Iter1, class Iter2>
-bool operator>=(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return lhs.base() <= rhs.base();
-}
-
-template <class Iter1, class Iter2>
-constexpr std::compare_three_way_result_t<Iter1, Iter2> operator<=>(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) {
-  return rhs.base() <=> lhs.base();
-}
-
-template <class Iter>
-reverse_iterator<Iter> operator+(
-  typename reverse_iterator<Iter>::difference_type n,
-  const reverse_iterator<Iter> &it
-) {
-  return it + n;
-}
-
-template <class Iter1, class Iter2>
-auto operator-(
-  const reverse_iterator<Iter1> &lhs, const reverse_iterator<Iter2> &rhs
-) -> decltype(rhs.base() - lhs.base()) {
-  return rhs.base() - lhs.base();
-}
-
-// https://en.cppreference.com/w/cpp/iterator/make_reverse_iterator.html
-template <class Iter>
-reverse_iterator<Iter> make_reverse_iterator(Iter i) {
-  return reverse_iterator<Iter>(i);
-}
-
-} // namespace tinystl
diff --git a/source/tinystl/memory.h b/source/tinystl/memory.h
deleted file mode 100644
index 778d4ee..0000000
--- a/source/tinystl/memory.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include <tinystl/memory/addressof.h>
-#include <tinystl/memory/allocator.h>
-#include <tinystl/memory/allocator_traits.h>
-#include <tinystl/memory/construct.h>
-#include <tinystl/memory/destroy.h>
-#include <tinystl/memory/pointer_traits.h>
-
diff --git a/source/tinystl/memory/addressof.h b/source/tinystl/memory/addressof.h
deleted file mode 100644
index f94ec8e..0000000
--- a/source/tinystl/memory/addressof.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/is_object.h"
-#include "tinystl/type_traits/enable_if.h"
-
-namespace tinystl {
-
-template <class T>
-typename enable_if<is_object<T>::value, T *>::type addressof(T &arg) noexcept {
-  return reinterpret_cast<T *>(
-    &const_cast<char &>(reinterpret_cast<const volatile char &>(arg))
-  );
-}
-
-template <class T>
-typename enable_if<!is_object<T>::value, T *>::type addressof(T &arg) noexcept {
-  return &arg;
-}
-} // namespace tinystl
diff --git a/source/tinystl/memory/allocate_at_least.h b/source/tinystl/memory/allocate_at_least.h
deleted file mode 100644
index 113e146..0000000
--- a/source/tinystl/memory/allocate_at_least.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "tinystl/memory/allocator_traits.h"
-
-namespace tinystl {
-
-template <class Pointer>
-struct allocation_result {
-  Pointer ptr;
-  size_t count;
-};
-
-template <class Alloc>
-constexpr allocation_result<typename allocator_traits<Alloc>::pointer>
-allocate_at_least(Alloc &alloc, size_t n) {
-  return {alloc.allocate(n), n};
-}
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/memory/allocator.h b/source/tinystl/memory/allocator.h
deleted file mode 100644
index b505bd6..0000000
--- a/source/tinystl/memory/allocator.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <limits>
-#include <new>
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/memory/allocator.html
-template <class T>
-struct allocator {
-  // Member types
-  using value_type = T;
-  using pointer [[deprecated("deprecated")]] = T *;               // util c++20
-  using const_pointer [[deprecated("deprecated")]] = const T *;   // util c++20
-  using reference [[deprecated("deprecated")]] = T &;             // util c++20
-  using const_reference [[deprecated("deprecated")]] = const T &; // util c++20
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-  using propagate_on_container_move_assignment = true_type;
-  template <class U>
-  struct [[deprecated("deprecated")]] rebind {
-    typedef allocator<U> other;
-  }; // util c++20
-  using is_always_equal [[deprecated("deprecated")]] = true_type; // util c++26
-
-  // Member functions
-  allocator() noexcept {}
-
-  allocator(const allocator &other) noexcept {}
-
-  template <class U>
-  allocator(const allocator<U> &) noexcept {}
-
-  ~allocator() noexcept {}
-
-  [[deprecated("deprecated")]]
-  pointer address(reference x) const noexcept {
-    return &x;
-  } // util c++20
-
-  [[deprecated("deprecated")]]
-  const_pointer address(const_reference x) const noexcept {
-    return &x;
-  } // util c++20
-
-  [[deprecated("deprecated")]]
-  T *allocate(size_type n, const void *) {
-    allocate(n);
-  } // util c++20
-
-  T *allocate(size_type n) {
-    if (std::numeric_limits<std::size_t>::max() / sizeof(T) < n)
-      throw std::bad_array_new_length();
-    return static_cast<T *>(::operator new(n * sizeof(T)));
-  }
-
-  void deallocate(T *p, std::size_t n) {
-    ::operator delete(p);
-  }
-
-  [[deprecated("deprecated")]]
-  size_type max_size() const noexcept {
-    return std::numeric_limits<std::size_t>::max() / sizeof(T);
-  } // util c++20
-
-  template <class U, class... Args>
-  [[deprecated("deprecated")]]
-  void construct(U *p, Args &&...args) {
-    ::new ((void *)p) U(std::forward<Args>(args)...);
-  } // util c++20
-
-  template <class U>
-  [[deprecated("deprecated")]]
-  void destroy(U *p) {
-    p->~U();
-  } // util c++20
-};
-
-// Non-member functions
-template <class T, class U>
-bool operator==(const allocator<T> &, const allocator<U> &) noexcept {
-  return true;
-} // constexpr since c++20
-
-template <class T, class U>
-[[deprecated("deprecated")]]
-bool operator!=(const allocator<T> &, const allocator<U> &) noexcept {
-  return false;
-} // util c++20
-
-} // namespace tinystl
diff --git a/source/tinystl/memory/allocator_traits.h b/source/tinystl/memory/allocator_traits.h
deleted file mode 100644
index 121c7e1..0000000
--- a/source/tinystl/memory/allocator_traits.h
+++ /dev/null
@@ -1,303 +0,0 @@
-#pragma once
-
-#include <limits>
-#include <utility>
-
-
-#include "tinystl/memory/construct.h"
-#include "tinystl/memory/destroy.h"
-#include "tinystl/memory/pointer_traits.h"
-#include "tinystl/type_traits/enable_if.h"
-#include "tinystl/type_traits/is_empty.h"
-#include "tinystl/type_traits/make_unsigned.h"
-#include "tinystl/type_traits/void_t.h"
-
-
-// https://en.cppreference.com/w/cpp/memory/allocator_traits.html
-
-namespace detail {
-// alloc_get_pointer
-template <class Alloc, class = void>
-struct alloc_get_pointer {
-  using type = typename Alloc::value_type *;
-};
-template <class Alloc>
-struct alloc_get_pointer<Alloc, tinystl::void_t<typename Alloc::pointer>> {
-  using type = typename Alloc::pointer;
-};
-
-// alloc_get_const_pointer
-template <class Alloc, class = void>
-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 alloc_get_const_pointer<
-  Alloc, tinystl::void_t<typename Alloc::const_pointer>> {
-  using type = typename Alloc::const_pointer;
-};
-
-// alloc_get_void_pointer
-template <class Alloc, class = void>
-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 alloc_get_void_pointer<Alloc, tinystl::void_t<typename Alloc::void_pointer>> {
-  using type = typename Alloc::void_pointer;
-};
-
-// alloc_get_const_void_pointer
-template <class Alloc, class = void>
-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 alloc_get_const_void_pointer<
-  Alloc, tinystl::void_t<typename Alloc::const_void_pointer>> {
-  using type = typename Alloc::const_void_pointer;
-};
-
-// alloc_get_difference_type
-template <class Alloc, class = void>
-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 alloc_get_difference_type<
-  Alloc, tinystl::void_t<typename Alloc::difference_type>> {
-  using type = typename Alloc::difference_type;
-};
-
-// alloc_get_size_type
-template <class Alloc, class = void>
-struct alloc_get_size_type {
-  using type =
-    tinystl::make_unsigned_t<typename alloc_get_difference_type<Alloc>::type>;
-};
-
-template <class Alloc>
-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 alloc_get_propagate_on_container_copy_assignment {
-  using type = tinystl::false_type;
-};
-
-template <class Alloc>
-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;
-};
-
-// propagate_on_container_move_assignment
-template <class Alloc, class = void>
-struct alloc_get_propagate_on_container_move_assignment {
-  using type = tinystl::false_type;
-};
-
-template <class Alloc>
-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;
-};
-
-// propagate_on_container_swap
-template <class Alloc, class = void>
-struct alloc_get_propagate_on_container_swap {
-  using type = tinystl::false_type;
-};
-
-template <class Alloc>
-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 alloc_get_is_always_equal {
-  using type = tinystl::is_empty<Alloc>;
-};
-
-template <class Alloc>
-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 alloc_get_rebind_alloc_impl;
-
-template <
-  template <class, class...> class Alloc, class First, class... Rest,
-  class 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 alloc_get_rebind_alloc {
-  using type = typename alloc_get_rebind_alloc_impl<Alloc, NewAlloc>::type;
-};
-
-template <class Alloc, class NewAlloc>
-struct alloc_get_rebind_alloc<
-  Alloc, NewAlloc,
-  tinystl::void_t<typename Alloc::template rebind<NewAlloc>::other>> {
-  using type = typename Alloc::template rebind<NewAlloc>::other;
-};
-
-// alloc_has_construct
-template <class, class Alloc, class... Args>
-const bool alloc_has_construct_impl = false;
-
-template <class Alloc, class... Args>
-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 alloc_has_construct = alloc_has_construct_impl<void, Alloc, Args...>;
-
-// alloc_has_destroy
-template <class Alloc, class Pointer, class = void>
-const bool alloc_has_destroy = false;
-
-template <class Alloc, class Pointer>
-const bool alloc_has_destroy<
-  Alloc, Pointer,
-  decltype((void)std::declval<Alloc>().destroy(std::declval<Pointer>()))> =
-  true;
-
-// alloc_has_max_size
-template <class Alloc, class = void>
-const bool alloc_has_max_size = false;
-
-template <class Alloc>
-const bool
-  alloc_has_max_size<Alloc, decltype((void)std::declval<Alloc &>().max_size())> =
-    true;
-
-// alloc_has_select_on_container_copy_construction
-template <class Alloc, class = void>
-const bool alloc_has_select_on_container_copy_construction = false;
-
-template <class Alloc>
-const bool alloc_has_select_on_container_copy_construction<
-  Alloc, decltype((void)std::declval<Alloc>()
-                    .select_on_container_copy_construction())> = true;
-
-} // namespace detail
-
-namespace tinystl {
-
-template <class Alloc>
-struct allocator_traits {
-  // Member types
-  using allocator_type = Alloc;
-  using value_type = typename Alloc::value_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::alloc_get_const_void_pointer<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::alloc_get_propagate_on_container_copy_assignment<Alloc>::type;
-  using propagate_on_container_move_assignment =
-    typename detail::alloc_get_propagate_on_container_move_assignment<Alloc>::type;
-  using propagate_on_container_swap =
-    typename detail::alloc_get_propagate_on_container_swap<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::alloc_get_rebind_alloc<Alloc, NewAlloc>::type;
-
-  template <class NewAlloc>
-  using rebind_traits = allocator_traits<rebind_alloc<NewAlloc>>;
-
-  // Member functions
-  static pointer allocate(Alloc &a, size_type n) { return a.allocate(n); }
-
-  static pointer allocate(Alloc &a, size_type n, const_void_pointer hint) {
-    return a.allocate(n, hint);
-  }
-
-  static void deallocate(Alloc &a, pointer p, size_type n) {
-    a.deallocate(p, n);
-  }
-
-  template <
-    class T, class... Args,
-    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::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::alloc_has_destroy<Alloc, T *>, int> = 0>
-  static void destroy(Alloc &a, T *p) {
-    a.destroy(p);
-  }
-
-  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::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::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::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::alloc_has_select_on_container_copy_construction<U>, int> = 0>
-  static Alloc select_on_container_copy_construction(const Alloc &a) {
-    return a;
-  }
-};
-
-} // namespace tinystl
diff --git a/source/tinystl/memory/construct.h b/source/tinystl/memory/construct.h
deleted file mode 100644
index 103b59c..0000000
--- a/source/tinystl/memory/construct.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <utility>
-
-namespace tinystl {
-template <
-  class T, class... Args,
-  class = decltype(::new (std::declval<void *>()) T(std::declval<Args>()...))>
-constexpr T *construct_at(T *location, Args &&...args) {
-  return ::new (static_cast<void *>(location)) T(std::forward<Args>(args)...);
-}
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/memory/destroy.h b/source/tinystl/memory/destroy.h
deleted file mode 100644
index 5ec5916..0000000
--- a/source/tinystl/memory/destroy.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "tinystl/memory/addressof.h"
-#include "tinystl/type_traits/enable_if.h"
-#include "tinystl/type_traits/is_array.h"
-
-namespace tinystl {
-template <class T, enable_if_t<!is_array_v<T>, int> = 0>
-void destroy_at(T *p) {
-  p->~T();
-}
-
-template <class T, enable_if_t<is_array_v<T>, int> = 0>
-void destroy_at(T *p) {
-  for (auto &elem : *p) {
-    (destroy_at)(addressof(elem));
-  }
-}
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/memory/pointer_traits.h b/source/tinystl/memory/pointer_traits.h
deleted file mode 100644
index da309bd..0000000
--- a/source/tinystl/memory/pointer_traits.h
+++ /dev/null
@@ -1,113 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#include "tinystl/memory/addressof.h"
-#include "tinystl/type_traits/conditional.h"
-#include "tinystl/type_traits/void_t.h"
-#include "tinystl/type_traits/is_void.h"
-
-namespace detail {
-
-// pointer traits element type
-template <class Ptr>
-struct pointer_traits_element_type_impl {};
-
-template <template <class, class...> class Sp, class Tp, class... Args>
-struct pointer_traits_element_type_impl<Sp<Tp, Args...>> {
-  using type = Tp;
-};
-
-template <class Ptr, class = void>
-struct pointer_traits_element_type : pointer_traits_element_type_impl<Ptr> {};
-
-template <class Ptr>
-struct pointer_traits_element_type<
-  Ptr, tinystl::void_t<typename Ptr::element_type>> {
-  using type = typename Ptr::element_type;
-};
-
-// pointer traits difference type
-template <class Ty, class = void>
-struct pointer_traits_difference_type {
-  using type = ptrdiff_t;
-};
-
-template <class Ty>
-struct pointer_traits_difference_type<
-  Ty, tinystl::void_t<typename Ty::difference_type>> {
-  using type = typename Ty::difference_type;
-};
-
-// pointer traits rebind
-template <class Tp, class Up>
-struct pointer_traits_rebind_impl {
-  static_assert(
-    false, "Cannot rebind pointer; did you forget to add a rebind "
-           "member to your pointer?"
-  );
-};
-
-template <
-  template <class, class...> class Sp, class Tp, class... Args, class Up>
-struct pointer_traits_rebind_impl<Sp<Tp, Args...>, Up> {
-  using type = Sp<Up, Args...>;
-};
-
-template <class Tp, class Up, class = void>
-struct pointer_traits_rebind : pointer_traits_rebind_impl<Tp, Up> {};
-
-template <class Tp, class Up>
-struct pointer_traits_rebind<
-  Tp, Up, tinystl::void_t<typename Tp::template rebind<Up>>> {
-  using type = typename Tp::template rebind<Up>;
-};
-
-// pointer traits impl
-template <class Ptr, class = void>
-struct pointer_traits_impl {};
-
-template <class Ptr>
-struct pointer_traits_impl<
-  Ptr, tinystl::void_t<typename pointer_traits_element_type<Ptr>::type>> {
-  using pointer = Ptr;
-  using element_type = typename pointer_traits_element_type<Ptr>::type;
-  using difference_type = typename pointer_traits_difference_type<Ptr>::type;
-  template <class Up>
-  using rebind = typename pointer_traits_rebind<pointer, Up>::type;
-
-  static pointer pointer_to(
-    tinystl::conditional_t<tinystl::is_void_v<element_type>, char, element_type>
-      &r
-  ) {
-    return Ptr::pointer_to(r);
-  }
-};
-} // namespace detail
-
-namespace tinystl {
-
-// https://en.cppreference.com/w/cpp/memory/pointer_traits.html
-template <class Ptr>
-struct pointer_traits : detail::pointer_traits_impl<Ptr> {};
-
-template <class T>
-struct pointer_traits<T *> {
-  // Member types
-  using pointer = T *;
-  using element_type = T;
-  using difference_type = std::ptrdiff_t;
-
-  // Member alias templates
-  template <class U>
-  using rebind = U *;
-
-  // Member functions
-  static pointer pointer_to(
-    tinystl::conditional_t<tinystl::is_void_v<element_type>, char, element_type>
-      &r
-  ) noexcept {
-    return addressof(r);
-  } // constexpr since c++20
-};
-} // namespace tinystl
diff --git a/source/tinystl/memory/temp_value.h b/source/tinystl/memory/temp_value.h
deleted file mode 100644
index 3957d16..0000000
--- a/source/tinystl/memory/temp_value.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include "tinystl/memory/addressof.h"
-#include "tinystl/memory/allocator_traits.h"
-
-namespace tinystl {
-template <class T, class Alloc>
-class temp_value {
-public:
-  template <class... Args>
-  temp_value(Alloc &alloc, Args &&...args) : m_alloc(alloc) {
-    tinystl::allocator_traits<Alloc>::construct(
-      m_alloc, addr(), std::forward<Args>(args)...
-    );
-  }
-
-  ~temp_value() { tinystl::allocator_traits<Alloc>::destroy(m_alloc, addr()); }
-
-  T &get() noexcept { return *addr(); }
-
-private:
-  T *addr() { return addressof(m_value); }
-
-private:
-  union {
-    T m_value;
-  };
-
-  Alloc m_alloc;
-};
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/memory/to_address.h b/source/tinystl/memory/to_address.h
deleted file mode 100644
index 600216c..0000000
--- a/source/tinystl/memory/to_address.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "tinystl/memory/pointer_traits.h"
-#include "tinystl/type_traits/is_function.h"
-
-namespace tinystl {
-template <class T>
-constexpr T *to_address(T *p) noexcept {
-  static_assert(!is_function_v<T>);
-  return p;
-}
-
-template <class T>
-constexpr auto to_address(const T &p) noexcept {
-  if constexpr (requires { pointer_traits<T>::to_address(p); })
-    return pointer_traits<T>::to_address(p);
-  else
-    return to_address(p.operator->());
-}
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/type_traits.h b/source/tinystl/type_traits.h
deleted file mode 100644
index 3aa11b8..0000000
--- a/source/tinystl/type_traits.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-// https://en.cppreference.com/w/cpp/header/type_traits.html
-// https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
-// https://clang.llvm.org/docs/LanguageExtensions.html#type-trait-primitives
-// https://learn.microsoft.com/en-us/cpp/extensions/compiler-support-for-type-traits-cpp-component-extensions?view=msvc-170
-
-// composite_type_categories
-#include <tinystl/type_traits/is_arithmetic.h>
-#include <tinystl/type_traits/is_member_pointer.h>
-#include <tinystl/type_traits/is_object.h>
-#include <tinystl/type_traits/is_reference.h>
-#include <tinystl/type_traits/is_scalar.h>
-
-
-// const_volatility_specifiers
-#include <tinystl/type_traits/remove_cv.h>
-
-// miscellaneous_transformations
-#include <tinystl/type_traits/conditional.h>
-#include <tinystl/type_traits/enable_if.h>
-#include <tinystl/type_traits/void_t.h>
-
-// primary_type_categories
-#include <tinystl/type_traits/is_array.h>
-#include <tinystl/type_traits/is_class.h>
-#include <tinystl/type_traits/is_enum.h>
-#include <tinystl/type_traits/is_floating_point.h>
-#include <tinystl/type_traits/is_integral.h>
-#include <tinystl/type_traits/is_lvalue_reference.h>
-#include <tinystl/type_traits/is_null_pointer.h>
-#include <tinystl/type_traits/is_pointer.h>
-#include <tinystl/type_traits/is_rvalue_reference.h>
-#include <tinystl/type_traits/is_union.h>
-#include <tinystl/type_traits/is_void.h>
-
-// type_properties
-#include <tinystl/type_traits/is_empty.h>
-
-// type_relationships
-#include <tinystl/type_traits/is_same.h>
diff --git a/source/tinystl/type_traits/add_reference.h b/source/tinystl/type_traits/add_reference.h
deleted file mode 100644
index bafba02..0000000
--- a/source/tinystl/type_traits/add_reference.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/void_t.h"
-
-namespace tinystl {
-
-template <class _Ty, class = void>
-struct _Add_reference { // add reference (non-referenceable type)
-    using _Lvalue = _Ty;
-    using _Rvalue = _Ty;
-};
-
-template <class _Ty>
-struct _Add_reference<_Ty, void_t<_Ty&>> { // (referenceable type)
-    using _Lvalue = _Ty&;
-    using _Rvalue = _Ty&&;
-};
-
-template <class _Ty>
-struct add_lvalue_reference {
-    using type = typename _Add_reference<_Ty>::_Lvalue;
-};
-
-template <class _Ty>
-using add_lvalue_reference_t = typename _Add_reference<_Ty>::_Lvalue;
-
-template <class _Ty>
-struct add_rvalue_reference {
-    using type = typename _Add_reference<_Ty>::_Rvalue;
-};
-
-template <class _Ty>
-using add_rvalue_reference_t = typename _Add_reference<_Ty>::_Rvalue;
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/type_traits/conditional.h b/source/tinystl/type_traits/conditional.h
deleted file mode 100644
index 8f87105..0000000
--- a/source/tinystl/type_traits/conditional.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-namespace tinystl {
-template <bool B, class T, class F>
-struct conditional {
-  using type = T;
-};
-
-template <class T, class F>
-struct conditional<false, T, F> {
-  using type = F;
-};
-
-template <bool B, class T, class F>
-using conditional_t = typename conditional<B, T, F>::type;
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/enable_if.h b/source/tinystl/type_traits/enable_if.h
deleted file mode 100644
index f4f6793..0000000
--- a/source/tinystl/type_traits/enable_if.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/types/enable_if.html
-template <bool B, class T = void>
-struct enable_if {};
-
-template <class T>
-struct enable_if<true, T> {
-  typedef T type;
-};
-
-template <bool B, class T = void>
-using enable_if_t = typename enable_if<B, T>::type;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/integral_constant.h b/source/tinystl/type_traits/integral_constant.h
deleted file mode 100644
index db97bec..0000000
--- a/source/tinystl/type_traits/integral_constant.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-namespace tinystl {
-
-// https://en.cppreference.com/w/cpp/types/integral_constant.html
-template <class T, T v>
-struct integral_constant {
-  // Member constants
-  static constexpr T value = v;
-
-  // Member types
-  using value_type = T;
-  using type = integral_constant; // using injected-class-name
-
-  // Memeber functions
-  constexpr operator value_type() const noexcept { return value; }
-  constexpr value_type operator()() const noexcept {
-    return value;
-  } // since c++14
-};
-
-// Helper alias templates
-template <bool B>
-using bool_constant = integral_constant<bool, B>;
-
-// Specialization
-using true_type = integral_constant<bool, true>;
-using false_type = integral_constant<bool, false>;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_arithmetic.h b/source/tinystl/type_traits/is_arithmetic.h
deleted file mode 100644
index e774342..0000000
--- a/source/tinystl/type_traits/is_arithmetic.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/is_floating_point.h"
-#include "tinystl/type_traits/is_integral.h"
-
-namespace tinystl {
-template <class T>
-struct is_arithmetic
-  : bool_constant<is_integral_v<T> || is_floating_point_v<T>> {};
-
-template <class T>
-inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_array.h b/source/tinystl/type_traits/is_array.h
deleted file mode 100644
index d3a7956..0000000
--- a/source/tinystl/type_traits/is_array.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-
-template <class T>
-struct is_array : false_type {};
-
-template <class T>
-struct is_array<T[]> : true_type {};
-
-template <class T, std::size_t N>
-struct is_array<T[N]> : true_type {};
-
-template <class T>
-inline constexpr bool is_array_v = is_array<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_class.h b/source/tinystl/type_traits/is_class.h
deleted file mode 100644
index 3d51dbd..0000000
--- a/source/tinystl/type_traits/is_class.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/is_union.h"
-
-namespace detail {
-template <class T>
-tinystl::bool_constant<!tinystl::is_union_v<T>> test(int T::*);
-
-template <class>
-tinystl::false_type test(...);
-} // namespace detail
-
-namespace tinystl {
-
-// template <class T>
-// struct is_class : bool_constant<__is_class(T)> {};
-
-template <class T>
-struct is_class : decltype(detail::test<T>(nullptr)) {};
-
-template <class T>
-inline constexpr bool is_class_v = is_class<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_const.h b/source/tinystl/type_traits/is_const.h
deleted file mode 100644
index 7207a1f..0000000
--- a/source/tinystl/type_traits/is_const.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-
-template <class T>
-struct is_const : false_type {};
-
-template <class T>
-struct is_const<const T> : true_type {};
-
-template <class T>
-inline constexpr bool is_const_v = is_const<T>::value;
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/type_traits/is_constructible.h b/source/tinystl/type_traits/is_constructible.h
deleted file mode 100644
index 245b167..0000000
--- a/source/tinystl/type_traits/is_constructible.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/add_reference.h"
-#include "tinystl/type_traits/integral_constant.h"
-
-
-namespace tinystl {
-
-template <class _Tp, class... _Args>
-struct is_constructible : bool_constant<__is_constructible(_Tp, _Args...)> {};
-
-template <class _Tp, class... _Args>
-inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
-
-template <class _Tp>
-struct is_copy_constructible
-  : bool_constant<__is_constructible(_Tp, add_lvalue_reference_t<const _Tp>)> {
-};
-
-template <class _Tp>
-inline constexpr bool is_copy_constructible_v =
-  is_copy_constructible<_Tp>::value;
-
-template <class _Tp>
-struct is_move_constructible
-  : bool_constant<__is_constructible(_Tp, add_rvalue_reference_t<_Tp>)> {};
-
-template <class _Tp>
-inline constexpr bool is_move_constructible_v =
-  is_move_constructible<_Tp>::value;
-
-template <class _Tp>
-struct is_default_constructible : bool_constant<__is_constructible(_Tp)> {};
-
-template <class _Tp>
-inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/type_traits/is_convertible.h b/source/tinystl/type_traits/is_convertible.h
deleted file mode 100644
index 8ffaa02..0000000
--- a/source/tinystl/type_traits/is_convertible.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-
-template <class _T1, class _T2>
-struct is_convertible : bool_constant<__is_convertible(_T1, _T2)> {};
-
-template <class _From, class _To>
-inline constexpr bool is_convertible_v = __is_convertible(_From, _To);
-
-template <class _Tp, class _Up>
-struct is_nothrow_convertible
-  : bool_constant<__is_nothrow_convertible(_Tp, _Up)> {};
-
-template <class _Tp, class _Up>
-inline constexpr bool is_nothrow_convertible_v =
-  __is_nothrow_convertible(_Tp, _Up);
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/type_traits/is_empty.h b/source/tinystl/type_traits/is_empty.h
deleted file mode 100644
index 2e37a72..0000000
--- a/source/tinystl/type_traits/is_empty.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-template <class T>
-struct is_empty : bool_constant<__is_empty(T)> {};
-
-template <class T>
-inline constexpr bool is_empty_v = __is_empty(T);
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_enum.h b/source/tinystl/type_traits/is_enum.h
deleted file mode 100644
index 0e0f442..0000000
--- a/source/tinystl/type_traits/is_enum.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-
-template <class T>
-struct is_enum : tinystl::bool_constant<__is_enum(T)> {};
-
-template <class T>
-inline constexpr bool is_enum_v = __is_enum(T);
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_floating_point.h b/source/tinystl/type_traits/is_floating_point.h
deleted file mode 100644
index 5019dfd..0000000
--- a/source/tinystl/type_traits/is_floating_point.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/is_same.h"
-#include "tinystl/type_traits/remove_cv.h"
-
-namespace tinystl {
-template <class T>
-struct is_floating_point
-  : bool_constant<
-      // Note: standard floating-point types
-      is_same_v<float, remove_cv_t<T>> ||
-      is_same_v<double, remove_cv_t<T>> ||
-      is_same_v<long double, remove_cv_t<T>>> {};
-
-template <class T>
-inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_function.h b/source/tinystl/type_traits/is_function.h
deleted file mode 100644
index 68ed486..0000000
--- a/source/tinystl/type_traits/is_function.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/is_const.h"
-#include "tinystl/type_traits/is_reference.h"
-
-namespace tinystl {
-
-// primary template
-// template <class T>
-// struct is_function : bool_constant<__is_function(T)> {};
-
-template <class T>
-struct is_function
-  : bool_constant<!is_const_v<const T> && !is_reference_v<T>> {};
-
-template <class T>
-inline constexpr bool is_function_v = is_function<T>::value;
-} // namespace tinystl
\ No newline at end of file
diff --git a/source/tinystl/type_traits/is_integral.h b/source/tinystl/type_traits/is_integral.h
deleted file mode 100644
index 9efcc54..0000000
--- a/source/tinystl/type_traits/is_integral.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-// Note: this implementation uses C++20 facilities
-template <class T>
-  struct is_integral
-  : bool_constant <
-    requires(T t, T *p, void (*f)(T)) // T* parameter excludes reference types
-{
-  reinterpret_cast<T>(t); // Exclude class types
-  f(0);                   // Exclude enumeration types
-  p + t; // Exclude everything not yet excluded but integral types
-}>{};
-
-template <class T>
-inline constexpr bool is_integral_v = is_integral<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_lvalue_reference.h b/source/tinystl/type_traits/is_lvalue_reference.h
deleted file mode 100644
index 0d9c762..0000000
--- a/source/tinystl/type_traits/is_lvalue_reference.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-template<class T>
-struct is_lvalue_reference : false_type {};
-template<class T>
-struct is_lvalue_reference<T&> : true_type {};
-
-template<class T>
-inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
-}
diff --git a/source/tinystl/type_traits/is_member_pointer.h b/source/tinystl/type_traits/is_member_pointer.h
deleted file mode 100644
index 2ea1ae3..0000000
--- a/source/tinystl/type_traits/is_member_pointer.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/remove_cv.h"
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-template <class T>
-struct is_member_pointer_helper : false_type {};
-
-template <class T, class U>
-struct is_member_pointer_helper<T U::*> : true_type {};
-
-template <class T>
-struct is_member_pointer
-  : is_member_pointer_helper<remove_cv_t<T>> {};
-
-template <class T>
-inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_null_pointer.h b/source/tinystl/type_traits/is_null_pointer.h
deleted file mode 100644
index b864676..0000000
--- a/source/tinystl/type_traits/is_null_pointer.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#include "tinystl/type_traits/remove_cv.h"
-#include "tinystl/type_traits/is_same.h"
-
-namespace tinystl {
-template <class T>
-struct is_null_pointer : is_same<std::nullptr_t, remove_cv_t<T>> {
-};
-
-template <class T>
-inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
-}; // namespace tinystl
diff --git a/source/tinystl/type_traits/is_object.h b/source/tinystl/type_traits/is_object.h
deleted file mode 100644
index 2d93fe1..0000000
--- a/source/tinystl/type_traits/is_object.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/is_array.h"
-#include "tinystl/type_traits/is_class.h"
-#include "tinystl/type_traits/is_scalar.h"
-#include "tinystl/type_traits/is_union.h"
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/types/is_object.html
-template <class T>
-struct is_object
-  : bool_constant<
-      is_scalar_v<T> || is_array_v<T> || is_union_v<T> || is_class_v<T>> {};
-
-template <class T>
-inline constexpr bool is_object_v = is_object<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_pointer.h b/source/tinystl/type_traits/is_pointer.h
deleted file mode 100644
index 0e29ee3..0000000
--- a/source/tinystl/type_traits/is_pointer.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-template <class T>
-struct is_pointer : false_type {};
-
-template <class T>
-struct is_pointer<T *> : true_type {};
-
-template <class T>
-struct is_pointer<T *const> : true_type {};
-
-template <class T>
-struct is_pointer<T *volatile> : true_type {};
-
-template <class T>
-struct is_pointer<T *const volatile> : true_type {};
-
-template <class T>
-inline constexpr bool is_pointer_v = is_pointer<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_reference.h b/source/tinystl/type_traits/is_reference.h
deleted file mode 100644
index f6546e1..0000000
--- a/source/tinystl/type_traits/is_reference.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/is_lvalue_reference.h"
-#include "tinystl/type_traits/is_rvalue_reference.h"
-
-namespace tinystl {
-template<class T>
-struct is_reference : bool_constant<is_lvalue_reference_v<T> || is_rvalue_reference_v<T>> {};
-
-template <class T>
-inline constexpr bool is_reference_v = is_reference<T>::value;
-}
diff --git a/source/tinystl/type_traits/is_renferenceable.h b/source/tinystl/type_traits/is_renferenceable.h
deleted file mode 100644
index 992f40c..0000000
--- a/source/tinystl/type_traits/is_renferenceable.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/void_t.h"
-
-namespace tinystl {
-template <class T, class = void>
-struct is_referenceable : false_type {};
-
-template <class T>
-struct is_referenceable<T, void_t<T &>> : true_type {};
-
-template <class T>
-inline constexpr bool is_referenceable_v = is_referenceable<T>::value;
-
-// template <class T, class = void>
-// inline const bool is_referenceable_v = false;
-
-// template <class T>
-// inline const bool is_referenceable_v<T, void_t<T &>> = true;
-
-template <class T>
-concept referenceable = is_referenceable_v<T>;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_rvalue_reference.h b/source/tinystl/type_traits/is_rvalue_reference.h
deleted file mode 100644
index 53dd663..0000000
--- a/source/tinystl/type_traits/is_rvalue_reference.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-template<class T>
-struct is_rvalue_reference : false_type {};
-template<class T>
-struct is_rvalue_reference<T&&> : true_type {};
-
-template <class T>
-inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
-}
diff --git a/source/tinystl/type_traits/is_same.h b/source/tinystl/type_traits/is_same.h
deleted file mode 100644
index 42f4e74..0000000
--- a/source/tinystl/type_traits/is_same.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/types/is_same.html
-
-template <class T, class U>
-struct is_same : false_type {};
-
-template <class T>
-struct is_same<T, T> : true_type {};
-
-template <class T, class U>
-constexpr bool is_same_v = is_same<T, U>::value;
-
-}; // namespace tinystl
diff --git a/source/tinystl/type_traits/is_scalar.h b/source/tinystl/type_traits/is_scalar.h
deleted file mode 100644
index cf6b838..0000000
--- a/source/tinystl/type_traits/is_scalar.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-#include "tinystl/type_traits/is_arithmetic.h"
-#include "tinystl/type_traits/is_enum.h"
-#include "tinystl/type_traits/is_member_pointer.h"
-#include "tinystl/type_traits/is_null_pointer.h"
-#include "tinystl/type_traits/is_pointer.h"
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/types/is_scalar
-template <class T>
-struct is_scalar : bool_constant<
-                     is_arithmetic_v<T> || is_enum_v<T> || is_pointer_v<T> ||
-                     is_member_pointer_v<T> || is_null_pointer_v<T>> {};
-
-template <class T>
-inline constexpr bool is_scalar_v = is_scalar<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_union.h b/source/tinystl/type_traits/is_union.h
deleted file mode 100644
index 8ec0469..0000000
--- a/source/tinystl/type_traits/is_union.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/integral_constant.h"
-
-namespace tinystl {
-
-template <class T>
-struct is_union : bool_constant<__is_union(T)> {};
-
-template <class T>
-inline constexpr bool is_union_v = is_union<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/is_void.h b/source/tinystl/type_traits/is_void.h
deleted file mode 100644
index e7ca9b3..0000000
--- a/source/tinystl/type_traits/is_void.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "tinystl/type_traits/remove_cv.h"
-#include "tinystl/type_traits/is_same.h"
-
-namespace tinystl {
-
-// https://en.cppreference.com/w/cpp/types/is_void.html
-template <class T>
-struct is_void : is_same<void, remove_cv_t<T>> {};
-
-template <class T>
-inline constexpr bool is_void_v = is_void<T>::value;
-
-} // namespace tinystl
diff --git a/source/tinystl/type_traits/make_unsigned.h b/source/tinystl/type_traits/make_unsigned.h
deleted file mode 100644
index d1832f8..0000000
--- a/source/tinystl/type_traits/make_unsigned.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-namespace tinystl {
-template <class T>
-struct make_unsigned 
-{
-  // TODO: use own implementation
-  using type = std::make_unsigned_t<T>;
-};
-
-template< class T >
-using make_unsigned_t = typename make_unsigned<T>::type;
-}
diff --git a/source/tinystl/type_traits/remove_cv.h b/source/tinystl/type_traits/remove_cv.h
deleted file mode 100644
index 700b943..0000000
--- a/source/tinystl/type_traits/remove_cv.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-namespace tinystl {
-// https://en.cppreference.com/w/cpp/types/remove_cv.html
-
-template <class T>
-struct remove_cv {
-  typedef T type;
-};
-template <class T>
-struct remove_cv<const T> {
-  typedef T type;
-};
-template <class T>
-struct remove_cv<volatile T> {
-  typedef T type;
-};
-template <class T>
-struct remove_cv<const volatile T> {
-  typedef T type;
-};
-
-template <class T>
-struct remove_const {
-  typedef T type;
-};
-template <class T>
-struct remove_const<const T> {
-  typedef T type;
-};
-
-template <class T>
-struct remove_volatile {
-  typedef T type;
-};
-template <class T>
-struct remove_volatile<volatile T> {
-  typedef T type;
-};
-
-template <class T>
-using remove_cv_t = typename remove_cv<T>::type; // since C++14
-template <class T>
-using remove_const_t = typename remove_const<T>::type; // since C++14
-template <class T>
-using remove_volatile_t = typename remove_volatile<T>::type; // since C++14
-
-}; // namespace tinystl
diff --git a/source/tinystl/type_traits/void_t.h b/source/tinystl/type_traits/void_t.h
deleted file mode 100644
index 4b6d42c..0000000
--- a/source/tinystl/type_traits/void_t.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-namespace tinystl {
-template <class...>
-using void_t = void;
-}
diff --git a/source/tinystl/utility/exception_guard.h b/source/tinystl/utility/exception_guard.h
deleted file mode 100644
index c77ebbf..0000000
--- a/source/tinystl/utility/exception_guard.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <utility>
-
-namespace tinystl {
-
-template <class Roolback>
-class exception_guard_exceptions {
-public:
-  exception_guard_exceptions() = delete;
-
-  explicit exception_guard_exceptions(Roolback roolbaclk)
-    : m_roolback(std::move(roolbaclk)), m_complete(false) {}
-
-  exception_guard_exceptions(exception_guard_exceptions &&other) noexcept
-    : m_roolback(std::move(other.m_roolback)), m_complete(other.m_complete) {
-    other.m_complete = true;
-  }
-  exception_guard_exceptions(const exception_guard_exceptions &) = delete;
-  exception_guard_exceptions &
-  operator=(const exception_guard_exceptions &) = delete;
-  exception_guard_exceptions &
-  operator=(exception_guard_exceptions &&other) = delete;
-
-  ~exception_guard_exceptions() noexcept(false) {
-    if (!m_complete) {
-      m_roolback();
-    }
-  }
-
-  void complete() noexcept { m_complete = true; }
-
-private:
-  Roolback m_roolback;
-  bool m_complete;
-};
-
-template <class Roolback>
-class exception_guard_nonexceptions {
-public:
-exception_guard_nonexceptions() = delete;
-
-  explicit exception_guard_nonexceptions(Roolback)
-    : m_complete(false) {}
-
-  exception_guard_nonexceptions(exception_guard_nonexceptions &&other) noexcept
-    : m_complete(other.m_complete) {
-    other.m_complete = true;
-  }
-
-  exception_guard_nonexceptions(const exception_guard_nonexceptions &) = delete;
-  exception_guard_nonexceptions &
-  operator=(const exception_guard_nonexceptions &) = delete;
-  exception_guard_nonexceptions &
-  operator=(exception_guard_nonexceptions &&other) = delete;
-
-  ~exception_guard_nonexceptions() noexcept {
-    assert(!m_complete && "exception_guard not complete with exceptions disabled");
-  }
-
-  void complete() noexcept { m_complete = true; }
-
-private:
-  bool m_complete;
-};
-
-template <class Roolback>
-using exception_guard = exception_guard_exceptions<Roolback>;
-
-template <class Roolback>
-exception_guard<Roolback> make_exception_guard(Roolback roolback) {
-  return exception_guard<Roolback>(std::move(roolback));
-}
-
-} // namespace tinystl
\ No newline at end of file
diff --git a/test/memory/allocator.cpp b/test/memory/allocator.cpp
deleted file mode 100644
index df7b6af..0000000
--- a/test/memory/allocator.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <memory>
-#include <string>
-
-#include <tinystl/memory.h>
-#include <tinystl/type_traits.h>
-
-TEST_CASE("tinystl::allocator basic int usage", "[allocator][int]") {
-
-  // construct
-  std::allocator<int> std_alloc;
-  int* std_p = std_alloc.allocate(1);
-  std::allocator_traits<std::allocator<int>>::construct(std_alloc, std_p, 7);
-  REQUIRE(*std_p == 7);
-  std::allocator_traits<std::allocator<int>>::destroy(std_alloc, std_p);
-  std_alloc.deallocate(std_p, 1);
-
-  tinystl::allocator<int> alloc1;
-  static_assert(tinystl::is_same_v<int, decltype(alloc1)::value_type>);
-  int *p1 = alloc1.allocate(1);
-  alloc1.deallocate(p1, 1);
-
-  using traits_t1 = std::allocator_traits<decltype(alloc1)>;
-  p1 = traits_t1::allocate(alloc1, 1);
-  traits_t1::construct(alloc1, p1, 7);
-  REQUIRE(*p1 == 7);
-  traits_t1::deallocate(alloc1, p1, 1);
-}
-
-TEST_CASE("tinystl::allocator with std::string", "[allocator][string]") {
-  tinystl::allocator<std::string> alloc2;
-  using traits_t2 = tinystl::allocator_traits<decltype(alloc2)>;
-  traits_t2::rebind_alloc<std::string> alloc_ = alloc2;
-  std::string *p2 = traits_t2::allocate(alloc2, 2);
-  traits_t2::construct(alloc2, p2, "foo");
-  traits_t2::construct(alloc2, p2 + 1, "bar");
-  REQUIRE(p2[0] == "foo");
-  REQUIRE(p2[1] == "bar");
-  traits_t2::destroy(alloc2, p2 + 1);
-  traits_t2::destroy(alloc2, p2);
-  traits_t2::deallocate(alloc2, p2, 2);
-}
diff --git a/test/type_traits/integral_constant.cpp b/test/type_traits/integral_constant.cpp
deleted file mode 100644
index 0a4247e..0000000
--- a/test/type_traits/integral_constant.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <tinystl/type_traits.h>
-
-TEST_CASE("integral_constant checks", "[type_traits][integral_constant]") {
-  SECTION("type and value checks") {
-    using two_t = tinystl::integral_constant<int, 2>;
-    using four_t = tinystl::integral_constant<int, 4>;
-    REQUIRE_FALSE(tinystl::is_same_v<two_t, four_t>);
-    REQUIRE(two_t::value * 2 == four_t::value);
-    REQUIRE((two_t() << 1) == (four_t() >> 0));
-  }
-
-  SECTION("enum type checks") {
-    enum class E { e1, e2 };
-    using c1 = tinystl::integral_constant<E, E::e1>;
-    using c2 = tinystl::integral_constant<E, E::e2>;
-    REQUIRE(c1::value != E::e2);
-    REQUIRE(c1() == E::e1);
-    REQUIRE(tinystl::is_same_v<c2, c2>);
-  }
-}
diff --git a/test/type_traits/is_same.cpp b/test/type_traits/is_same.cpp
deleted file mode 100644
index b726cac..0000000
--- a/test/type_traits/is_same.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <tinystl/type_traits.h>
-
-TEST_CASE("is_same basic checks", "[type_traits][is_same]") {
-  SECTION("int and int32_t") {
-    // usually true if 'int' is 32 bit
-    REQUIRE(tinystl::is_same<int, std::int32_t>::value == (sizeof(int) == 4));
-    // possibly true if ILP64 data model is used
-    REQUIRE(tinystl::is_same<int, std::int64_t>::value == (sizeof(int) == 8));
-  }
-
-  SECTION("is_same_v syntax") {
-    REQUIRE(tinystl::is_same_v<int, std::int32_t> == (sizeof(int) == 4));
-    REQUIRE(tinystl::is_same_v<int, std::int64_t> == (sizeof(int) == 8));
-  }
-
-  SECTION("decltype comparison") {
-    long double num1 = 1.0;
-    long double num2 = 2.0;
-    REQUIRE(tinystl::is_same_v<decltype(num1), decltype(num2)>);
-  }
-
-  SECTION("float and int32_t are not same") {
-    REQUIRE_FALSE(tinystl::is_same<float, std::int32_t>::value);
-  }
-
-  SECTION("int signedness") {
-    REQUIRE(tinystl::is_same_v<int, int>);
-    REQUIRE_FALSE(tinystl::is_same_v<int, unsigned int>);
-    REQUIRE(tinystl::is_same_v<int, signed int>);
-  }
-
-  SECTION("char signedness") {
-    REQUIRE(tinystl::is_same_v<char, char>);
-    REQUIRE_FALSE(tinystl::is_same_v<char, unsigned char>);
-    REQUIRE_FALSE(tinystl::is_same_v<char, signed char>);
-  }
-
-  SECTION("const-qualified type") {
-    REQUIRE_FALSE(tinystl::is_same<const int, int>());
-  }
-}
diff --git a/test/type_traits/is_void.cpp b/test/type_traits/is_void.cpp
deleted file mode 100644
index f262eca..0000000
--- a/test/type_traits/is_void.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <tinystl/type_traits.h>
-
-void foo();
-
-TEST_CASE("is_void trait", "[type_traits][is_void]") {
-  SECTION("basic void types") {
-    REQUIRE(tinystl::is_void_v<void>);
-    REQUIRE(tinystl::is_void_v<const void>);
-    REQUIRE(tinystl::is_void_v<volatile void>);
-    REQUIRE(tinystl::is_void_v<const volatile void>);
-    REQUIRE(tinystl::is_void_v<tinystl::void_t<>>);
-  }
-  SECTION("non-void types") {
-    REQUIRE_FALSE(tinystl::is_void_v<void *>);
-    REQUIRE_FALSE(tinystl::is_void_v<int>);
-    REQUIRE_FALSE(tinystl::is_void_v<decltype(foo)>);
-    REQUIRE_FALSE(tinystl::is_void_v<tinystl::is_void<void>>);
-  }
-}
diff --git a/test/type_traits/remove_cv.cpp b/test/type_traits/remove_cv.cpp
deleted file mode 100644
index 306e741..0000000
--- a/test/type_traits/remove_cv.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <tinystl/type_traits.h>
-
-template <typename U, typename V>
-constexpr bool same = tinystl::is_same_v<U, V>;
-
-TEST_CASE("remove_cv_t type trait", "[type_traits][remove_cv]") {
-  SECTION("basic cv removal") {
-    REQUIRE(same<tinystl::remove_cv_t<int>, int>);
-    REQUIRE(same<tinystl::remove_cv_t<const int>, int>);
-    REQUIRE(same<tinystl::remove_cv_t<volatile int>, int>);
-    REQUIRE(same<tinystl::remove_cv_t<const volatile int>, int>);
-  }
-
-  SECTION("pointer cv removal") {
-    // remove_cv only works on types, not on pointers
-    REQUIRE_FALSE(same<tinystl::remove_cv_t<const volatile int *>, int *>);
-    REQUIRE(
-      same<tinystl::remove_cv_t<const volatile int *>, const volatile int *>
-    );
-    REQUIRE(same<tinystl::remove_cv_t<const int *volatile>, const int *>);
-    REQUIRE(same<tinystl::remove_cv_t<int *const volatile>, int *>);
-  }
-}