From 7e41f86515de6b0cc6609c830b8d6ed24358441a Mon Sep 17 00:00:00 2001
From: wjr <1966336874@qq.com>
Date: Wed, 9 Oct 2024 22:34:56 +0800
Subject: [PATCH] update tp

---
 include/wjr/algorithm.hpp                     |   4 +-
 .../preview/memory/aligned_alloc_macos.hpp    |   2 +-
 include/wjr/biginteger/biginteger.hpp         |   3 +-
 include/wjr/capture_leaf.hpp                  |   2 +-
 include/wjr/compressed_pair.hpp               |   2 +-
 include/wjr/concurrency/lkf_forward_list.hpp  |   2 +-
 .../{constexpr_map.hpp => constant_map.hpp}   |   6 +-
 include/wjr/container/constant_radix_tree.hpp |   7 +
 include/wjr/format/charconv-impl.hpp          |   3 +-
 include/wjr/format/charconv.hpp               |   3 +-
 include/wjr/format/fastfloat.hpp              |  10 +-
 .../iterator/contiguous_iterator_adpater.hpp  |   2 +
 include/wjr/json/document.hpp                 |   5 +-
 include/wjr/math/integral_constant.hpp        |  34 +-
 include/wjr/math/uint128_t.hpp                |   2 +-
 include/wjr/memory/detail.hpp                 |  10 +
 include/wjr/tp/algorithm.hpp                  | 439 +++++++++++++++
 include/wjr/tp/compiler.hpp                   |   8 -
 include/wjr/tp/{list.hpp => detail.hpp}       | 503 ++----------------
 include/wjr/tuple.hpp                         |   5 +-
 include/wjr/type_traits.hpp                   |   2 +
 21 files changed, 526 insertions(+), 528 deletions(-)
 rename include/wjr/container/{constexpr_map.hpp => constant_map.hpp} (75%)
 create mode 100644 include/wjr/container/constant_radix_tree.hpp
 create mode 100644 include/wjr/tp/algorithm.hpp
 delete mode 100644 include/wjr/tp/compiler.hpp
 rename include/wjr/tp/{list.hpp => detail.hpp} (53%)

diff --git a/include/wjr/algorithm.hpp b/include/wjr/algorithm.hpp
index 4d981de2..a8cd546b 100644
--- a/include/wjr/algorithm.hpp
+++ b/include/wjr/algorithm.hpp
@@ -190,8 +190,8 @@ constant_length_strncasecmp(const char *a, const char *b,
     } else if constexpr (Length >= 5 && Length <= 6) {
         constexpr auto RestLength = Length - 4;
         return constant_length_strncasecmp(a, b, 4_u) &
-               constant_length_strncasecmp(a + 4, b + 4,
-                                           integral_constant<unsigned int, RestLength>());
+               constant_length_strncasecmp(
+                   a + 4, b + 4, integral_constant<unsigned int, RestLength>());
     } else {
         static_assert(Length == 7);
         return constant_length_strncasecmp(a, b, 4_u) &
diff --git a/include/wjr/arch/preview/memory/aligned_alloc_macos.hpp b/include/wjr/arch/preview/memory/aligned_alloc_macos.hpp
index 1e2bf5e4..63abe43e 100644
--- a/include/wjr/arch/preview/memory/aligned_alloc_macos.hpp
+++ b/include/wjr/arch/preview/memory/aligned_alloc_macos.hpp
@@ -9,7 +9,7 @@ namespace wjr {
 
 WJR_MALLOC inline void *aligned_alloc(size_t size, size_t alignment) noexcept {
     WJR_ASSERT(has_single_bit(alignment));
-    
+
     if (size == 0) {
         return 0;
     }
diff --git a/include/wjr/biginteger/biginteger.hpp b/include/wjr/biginteger/biginteger.hpp
index becb098c..48809e0c 100644
--- a/include/wjr/biginteger/biginteger.hpp
+++ b/include/wjr/biginteger/biginteger.hpp
@@ -3487,8 +3487,7 @@ template <typename S>
 from_chars_result<const char *>
 from_chars_characters_unchecked(const char *first, const char *last,
                                 basic_biginteger<S> &dst, unsigned int base) noexcept {
-    return biginteger_detail::__from_chars_impl<false>(first, last, &dst,
-                                                                     base);
+    return biginteger_detail::__from_chars_impl<false>(first, last, &dst, base);
 }
 
 template <typename S>
diff --git a/include/wjr/capture_leaf.hpp b/include/wjr/capture_leaf.hpp
index caac0f8e..8094754d 100644
--- a/include/wjr/capture_leaf.hpp
+++ b/include/wjr/capture_leaf.hpp
@@ -4,7 +4,7 @@
 #include <tuple>
 
 #include <wjr/crtp/class_base.hpp>
-#include <wjr/tp/list.hpp>
+#include <wjr/tp/algorithm.hpp>
 #include <wjr/type_traits.hpp>
 
 namespace wjr {
diff --git a/include/wjr/compressed_pair.hpp b/include/wjr/compressed_pair.hpp
index 65050cd4..588d2e7d 100644
--- a/include/wjr/compressed_pair.hpp
+++ b/include/wjr/compressed_pair.hpp
@@ -13,7 +13,7 @@ class compressed_pair;
 namespace std {
 
 template <typename T, typename U>
-struct tuple_size<wjr::compressed_pair<T, U>> : std::integral_constant<size_t, 2> {};
+struct tuple_size<wjr::compressed_pair<T, U>> : integral_constant<size_t, 2> {};
 
 template <size_t I, typename T, typename U>
 struct tuple_element<I, wjr::compressed_pair<T, U>> {
diff --git a/include/wjr/concurrency/lkf_forward_list.hpp b/include/wjr/concurrency/lkf_forward_list.hpp
index ac7b4d12..3807826d 100644
--- a/include/wjr/concurrency/lkf_forward_list.hpp
+++ b/include/wjr/concurrency/lkf_forward_list.hpp
@@ -7,7 +7,7 @@
 namespace wjr::intrusive {
 
 struct lkf_forward_list_node {
-    lkf_forward_list_node()  noexcept : next(nullptr) {}
+    lkf_forward_list_node() noexcept : next(nullptr) {}
     lkf_forward_list_node(const lkf_forward_list_node &) = delete;
     lkf_forward_list_node &operator=(const lkf_forward_list_node &) = delete;
     ~lkf_forward_list_node() = default;
diff --git a/include/wjr/container/constexpr_map.hpp b/include/wjr/container/constant_map.hpp
similarity index 75%
rename from include/wjr/container/constexpr_map.hpp
rename to include/wjr/container/constant_map.hpp
index 30e3a973..f0751cf4 100644
--- a/include/wjr/container/constexpr_map.hpp
+++ b/include/wjr/container/constant_map.hpp
@@ -1,5 +1,5 @@
-#ifndef WJR_CONTAINER_CONSTEXPR_MAP_HPP__
-#define WJR_CONTAINER_CONSTEXPR_MAP_HPP__
+#ifndef WJR_CONTAINER_CONSTANT_MAP_HPP__
+#define WJR_CONTAINER_CONSTANT_MAP_HPP__
 
 #include <array>
 #include <string_view>
@@ -25,4 +25,4 @@ class string_map {
 
 } // namespace wjr
 
-#endif // WJR_CONTAINER_CONSTEXPR_MAP_HPP__
\ No newline at end of file
+#endif // WJR_CONTAINER_CONSTANT_MAP_HPP__
\ No newline at end of file
diff --git a/include/wjr/container/constant_radix_tree.hpp b/include/wjr/container/constant_radix_tree.hpp
new file mode 100644
index 00000000..6e07ee69
--- /dev/null
+++ b/include/wjr/container/constant_radix_tree.hpp
@@ -0,0 +1,7 @@
+#ifndef WJR_CONSTANT_RADIX_TREE_HPP__
+#define WJR_CONSTANT_RADIX_TREE_HPP__
+
+namespace wjr {
+}
+
+#endif // WJR_CONSTANT_RADIX_TREE_HPP__
\ No newline at end of file
diff --git a/include/wjr/format/charconv-impl.hpp b/include/wjr/format/charconv-impl.hpp
index 5fb969a9..f0a0465a 100644
--- a/include/wjr/format/charconv-impl.hpp
+++ b/include/wjr/format/charconv-impl.hpp
@@ -127,7 +127,8 @@ WJR_PURE WJR_INTRINSIC_INLINE bool is_made_of_eight_digits_fast(const char *src)
 WJR_PURE WJR_INTRINSIC_INLINE uint32_t
 parse_eight_digits_unrolled(const char *src) noexcept;
 
-WJR_PURE WJR_INTRINSIC_INLINE const char *skip_whitespace(const char *first, const char * last) noexcept;
+WJR_PURE WJR_INTRINSIC_INLINE const char *skip_whitespace(const char *first,
+                                                          const char *last) noexcept;
 
 } // namespace wjr
 
diff --git a/include/wjr/format/charconv.hpp b/include/wjr/format/charconv.hpp
index 86929dd1..f7f969a2 100644
--- a/include/wjr/format/charconv.hpp
+++ b/include/wjr/format/charconv.hpp
@@ -2211,7 +2211,8 @@ template <typename Value, unsigned int IBase = 10, typename Converter = char_con
           WJR_REQUIRES(charconv_detail::__is_valid_converter_v<Value, Converter>)>
 WJR_INTRINSIC_INLINE from_chars_result<const char *>
 from_chars(const char *first, const char *last, Value &val,
-           integral_constant<unsigned int, IBase> ic = {}, Converter conv = {}) noexcept {
+           integral_constant<unsigned int, IBase> ic = {},
+           Converter conv = {}) noexcept {
     return __from_chars_impl(first, last, val, ic, conv);
 }
 
diff --git a/include/wjr/format/fastfloat.hpp b/include/wjr/format/fastfloat.hpp
index 223bdfb2..97ca1469 100644
--- a/include/wjr/format/fastfloat.hpp
+++ b/include/wjr/format/fastfloat.hpp
@@ -78,14 +78,16 @@ __from_chars_impl<default_writer<double>, chars_format>(const char *first,
  * `fast_float::chars_format::general` which allows both `fixed` and `scientific`.
  */
 template <chars_format Fmt = chars_format::general>
-from_chars_result<> from_chars(const char *first, const char *last, float &value,
-                               integral_constant<chars_format, Fmt> fmt = {}) noexcept {
+from_chars_result<>
+from_chars(const char *first, const char *last, float &value,
+           integral_constant<chars_format, Fmt> fmt = {}) noexcept {
     return __from_chars_impl(first, last, default_writer<float>(value), fmt);
 }
 
 template <chars_format Fmt = chars_format::general>
-from_chars_result<> from_chars(const char *first, const char *last, double &value,
-                               integral_constant<chars_format, Fmt> fmt = {}) noexcept {
+from_chars_result<>
+from_chars(const char *first, const char *last, double &value,
+           integral_constant<chars_format, Fmt> fmt = {}) noexcept {
     return __from_chars_impl(first, last, default_writer<double>(value), fmt);
 }
 
diff --git a/include/wjr/iterator/contiguous_iterator_adpater.hpp b/include/wjr/iterator/contiguous_iterator_adpater.hpp
index 303a8504..a7d5b88d 100644
--- a/include/wjr/iterator/contiguous_iterator_adpater.hpp
+++ b/include/wjr/iterator/contiguous_iterator_adpater.hpp
@@ -340,6 +340,7 @@ struct pointer_traits<wjr::contiguous_const_iterator_adapter<Container, Traits>>
                           "can't convert invalid vector iterator to pointer");
         }
 #endif
+
         return wjr::to_address(ptr.m_ptr);
     }
 };
@@ -361,6 +362,7 @@ struct pointer_traits<wjr::contiguous_iterator_adapter<Container, Traits>> {
                           "can't convert invalid vector iterator to pointer");
         }
 #endif
+
         return wjr::to_address(ptr.m_ptr);
     }
 };
diff --git a/include/wjr/json/document.hpp b/include/wjr/json/document.hpp
index 1ed79fa9..e690b0c4 100644
--- a/include/wjr/json/document.hpp
+++ b/include/wjr/json/document.hpp
@@ -505,9 +505,8 @@ void format(Formatter fmt, const basic_document<Traits> &doc) noexcept {
 /**
  * @details At present, it's a simple but flexible implementation solution. This is not as
  * good as a only iteration in terms of performance. \n
- * Performance (use std::map and wjr::vector as container on my local x64 2.50 GHz machine) : \n
- * twitter.document : 700~720 MB/s \n
- * canada.document : 660~680 MB/s
+ * Performance (use std::map and wjr::vector as container on my local x64 2.50 GHz
+ * machine) : \n twitter.document : 700~720 MB/s \n canada.document : 660~680 MB/s
  * @todo 1. For most strings, only need to check first character to compare.
  * 2. Maybe use hash like std::unordered_map, but for long strings, compare even faster
  * than hash.
diff --git a/include/wjr/math/integral_constant.hpp b/include/wjr/math/integral_constant.hpp
index 9fee8a86..26fcf678 100644
--- a/include/wjr/math/integral_constant.hpp
+++ b/include/wjr/math/integral_constant.hpp
@@ -5,37 +5,6 @@
 
 namespace wjr {
 
-template <typename T, T val>
-struct integral_constant {
-    static constexpr T value = val;
-
-    using value_type = T;
-    using type = integral_constant;
-
-    WJR_ENABLE_DEFAULT_SPECIAL_MEMBERS(integral_constant);
-
-    constexpr integral_constant(std::integral_constant<T, val>) noexcept {}
-
-    constexpr operator value_type() const noexcept { return value; }
-    WJR_NODISCARD constexpr value_type operator()() const noexcept { return value; }
-
-    WJR_NODISCARD constexpr operator std::integral_constant<T, val>() const noexcept {
-        return {};
-    }
-
-    template <typename U, U u>
-    constexpr auto operator+(integral_constant<U, u>) const noexcept {
-        constexpr auto result = value + u;
-        return integral_constant<decltype(result), result>{};
-    }
-
-    template <typename U, U u>
-    constexpr auto operator-(integral_constant<U, u>) const noexcept {
-        constexpr auto result = value - u;
-        return integral_constant<decltype(result), result>{};
-    }
-};
-
 namespace digits_literal_detail {
 
 template <uint64_t Base>
@@ -123,7 +92,8 @@ WJR_CONST constexpr T parse() noexcept {
 #define WJR_REGISTER_INTEGRAL_LITERALS(NAME, TYPE)                                       \
     template <char... Chars>                                                             \
     WJR_CONST WJR_INTRINSIC_CONSTEXPR auto operator"" _##NAME() noexcept                 \
-        -> integral_constant<TYPE, digits_literal_detail::parse<TYPE, Chars...>()> {     \
+        -> integral_constant<TYPE,                                                  \
+                                  digits_literal_detail::parse<TYPE, Chars...>()> {      \
         return {};                                                                       \
     }
 
diff --git a/include/wjr/math/uint128_t.hpp b/include/wjr/math/uint128_t.hpp
index 14439ae4..3f83b311 100644
--- a/include/wjr/math/uint128_t.hpp
+++ b/include/wjr/math/uint128_t.hpp
@@ -202,7 +202,7 @@ WJR_INTRINSIC_CONSTEXPR20 uint128_t mul64x64to128(uint64_t a, uint64_t b) noexce
 namespace std {
 
 template <>
-struct tuple_size<wjr::uint128_t> : std::integral_constant<size_t, 2> {};
+struct tuple_size<wjr::uint128_t> : integral_constant<size_t, 2> {};
 
 template <size_t I>
 struct tuple_element<I, wjr::uint128_t> {
diff --git a/include/wjr/memory/detail.hpp b/include/wjr/memory/detail.hpp
index e7de37d2..054e24ed 100644
--- a/include/wjr/memory/detail.hpp
+++ b/include/wjr/memory/detail.hpp
@@ -14,6 +14,15 @@ WJR_REGISTER_HAS_TYPE(pointer_traits_to_address,
 
 WJR_REGISTER_HAS_TYPE(pointer_access, std::declval<const Ptr &>().operator->(), Ptr);
 
+#if defined(WJR_CXX_20)
+
+template <typename Ptr>
+constexpr auto to_address(const Ptr &p) noexcept {
+    return std::to_address(p);
+}
+
+#else
+
 template <typename T>
 constexpr T *to_address(T *p) noexcept {
     static_assert(!std::is_function_v<T>, "T cannot be a function.");
@@ -33,6 +42,7 @@ constexpr auto to_address(const Ptr &p) noexcept {
         return wjr::to_address(p.operator->());
     }
 }
+#endif
 
 /**
  * @return to_address(p.base()).
diff --git a/include/wjr/tp/algorithm.hpp b/include/wjr/tp/algorithm.hpp
new file mode 100644
index 00000000..1b074628
--- /dev/null
+++ b/include/wjr/tp/algorithm.hpp
@@ -0,0 +1,439 @@
+#ifndef WJR_TP_ALGORITHM_HPP__
+#define WJR_TP_ALGORITHM_HPP__
+
+#include <wjr/tp/detail.hpp>
+
+namespace wjr {
+
+template <typename T, typename U>
+struct tp_equal_to : std::is_same<T, U> {};
+
+template <typename T, typename U>
+struct tp_not_equal_to : std::negation<tp_equal_to<T, U>> {};
+
+template <typename T, typename U>
+struct tp_less : std::bool_constant<(T::value < U::value)> {};
+
+template <typename T, typename U>
+struct tp_greater : tp_less<U, T> {};
+
+template <typename T, typename U>
+struct tp_less_equal : std::negation<tp_greater<T, U>> {};
+
+template <typename T, typename U>
+struct tp_greater_equal : std::negation<tp_less<T, U>> {};
+
+template <typename T, template <typename...> typename F>
+struct tp_transform;
+
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename F>
+struct tp_transform<C<Args...>, F> {
+    using type = C<F<Args>...>;
+};
+
+/**
+ * @brief f(L<Args...>, Fn) -> L<Fn(Args)...>
+ * @details use with apply, bind, bind_front, bind_back...  \
+ * For example: \
+ * tp_transform_f<tp_bind_front<tp_apply_f, tp_bind_front<std::is_same>>,   \
+ * tp_list<tp_list<int, float>, tp_list<float, float>, tp_list<int, double>>>   \
+ * -> tp_list<std::is_same<int, float>, std::is_same<float, float>, std::is_same<int,   \
+ * double>>
+ *
+ */
+template <typename T, template <typename...> typename F>
+using tp_transform_t = typename tp_transform<T, F>::type;
+
+template <typename T, typename F>
+using tp_transform_f = typename tp_transform<T, F::template fn>::type;
+
+template <typename T, template <typename...> typename P, typename U>
+struct tp_replace_if;
+
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename P, typename U>
+struct tp_replace_if<C<Args...>, P, U> {
+    using type = C<tp_conditional_t<P<Args>, U, Args>...>;
+};
+
+/// @brief f(L<Args...>, P, U) -> L<if P(Args)::value then U else Args...>
+template <typename T, template <typename...> typename P, typename U>
+using tp_replace_if_t = typename tp_replace_if<T, P, U>::type;
+
+template <typename T, typename P, typename U>
+using tp_replace_if_f = tp_replace_if_t<T, P::template fn, U>;
+
+template <typename T, typename O, typename N>
+struct tp_replace {
+    using type = tp_replace_if_f<T, tp_bind_front<tp_equal_to, O>, N>;
+};
+
+template <typename T, typename O, typename N>
+using tp_replace_t = typename tp_replace<T, O, N>::type;
+
+template <typename T, typename U>
+struct tp_fill {
+    using type = tp_repeat_t<U, tp_size_v<T>>;
+};
+
+/// @brief f(L<Args...>, U) -> L<U, U, ..., U>
+template <typename T, typename U>
+using tp_fill_t = typename tp_fill<T, U>::type;
+
+template <typename T, template <typename...> typename P>
+struct tp_count_if;
+
+template <template <typename...> typename C, template <typename...> typename P>
+struct tp_count_if<C<>, P> {
+    static constexpr size_t value = 0;
+};
+
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename P>
+struct tp_count_if<C<Args...>, P> {
+    static constexpr size_t value = (P<Args>::value + ...);
+};
+
+/// @brief f(L<Args...>, P) -> count(P(Args)::value)
+template <typename T, template <typename...> typename P>
+constexpr size_t tp_count_if_v = tp_count_if<T, P>::value;
+
+template <typename T, typename P>
+constexpr size_t tp_count_if_f_v = tp_count_if_v<T, P::template fn>;
+
+template <typename T, typename V>
+struct tp_count {
+    static constexpr size_t value = tp_count_if_f_v<T, tp_bind_front<tp_equal_to, V>>;
+};
+
+template <typename T, typename V>
+constexpr size_t tp_count_v = tp_count<T, V>::value;
+
+template <typename T, typename V>
+struct tp_contains {
+    static constexpr bool value = tp_count_v<T, V> != 0;
+};
+
+template <typename T, typename V>
+constexpr bool tp_contains_v = tp_contains<T, V>::value;
+
+template <typename T, template <typename...> typename P>
+struct tp_remove_if;
+
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename P>
+struct tp_remove_if<C<Args...>, P> {
+    using type = tp_concat_t<C<>, tp_conditional_t<P<Args>, C<>, C<Args>>...>;
+};
+
+/// @brief f(L<Args...>, P) -> L<if P(Args)::value then L<> else L<Args>...>
+template <typename T, template <typename...> typename P>
+using tp_remove_if_t = typename tp_remove_if<T, P>::type;
+
+template <typename T, typename P>
+using tp_remove_if_f = tp_remove_if_t<T, P::template fn>;
+
+template <typename T, typename V>
+struct tp_remove {
+    using type = tp_remove_if_f<T, tp_bind_front<tp_equal_to, V>>;
+};
+
+template <typename T, typename V>
+using tp_remove_t = typename tp_remove<T, V>::type;
+
+template <typename T, template <typename...> typename P>
+struct tp_filter {
+    using type = tp_remove_if_f<T, tp_not_fn<P>>;
+};
+
+template <typename T, template <typename...> typename P>
+using tp_filter_t = typename tp_filter<T, P>::type;
+
+template <typename T, typename P>
+using tp_filter_f = tp_filter_t<T, P::template fn>;
+
+template <template <typename...> typename C, typename... Args>
+struct tp_product;
+
+/// @private
+template <typename _Enable, template <typename...> typename C, typename... Args>
+struct __tp_product_helper {
+    using type = tp_list<>;
+};
+
+/// @private
+template <typename _Enable, template <typename...> typename C, typename T>
+struct __tp_product_helper<_Enable, C, T> {
+    using type = tp_list<tp_rename_t<T, C>>;
+};
+
+/// @private
+template <template <typename...> typename C, typename T,
+          template <typename...> typename C1, typename... Args1, typename... Args>
+struct __tp_product_helper<std::enable_if_t<sizeof...(Args1) != 0, void>, C, T,
+                           C1<Args1...>, Args...> {
+    using type =
+        tp_concat_t<typename __tp_product_helper<void, C, tp_push_back_t<T, Args1>,
+                                                 Args...>::type...>;
+};
+
+template <template <typename...> typename C, typename... Args>
+struct tp_product {
+    using type = typename __tp_product_helper<void, C, tp_list<>, Args...>::type;
+};
+
+/// @brief f(C, L<A1, A2>, L<B1, B2, B3>) -> \
+/// L<C<A1, B1>, C<A1, B2>, C<A1, B3>, C<A2, B1>, C<A2, B2>, C<A2, B3>>
+template <template <typename...> typename C, typename... Args>
+using tp_product_t = typename tp_product<C, Args...>::type;
+
+template <typename C>
+struct tp_reverse;
+
+template <template <typename...> typename C>
+struct tp_reverse<C<>> {
+    using type = C<>;
+};
+
+template <template <typename...> typename C, typename T, typename... Args>
+struct tp_reverse<C<T, Args...>> {
+    using type = tp_push_back_t<typename tp_reverse<C<Args...>>::type, T>;
+};
+
+template <typename C>
+using tp_reverse_t = typename tp_reverse<C>::type;
+
+/// @private
+template <typename _Enable, size_t idx, typename C, template <typename...> typename P>
+struct __tp_find_if_helper;
+
+/// @private
+template <typename _Enable, size_t idx, template <typename...> typename C, typename T,
+          typename... Args, template <typename...> typename P>
+struct __tp_find_if_helper<_Enable, idx, C<T, Args...>, P> {
+    constexpr static size_t value =
+        __tp_find_if_helper<void, idx + 1, C<Args...>, P>::value;
+};
+
+/// @private
+template <typename _Enable, size_t idx, template <typename...> typename C,
+          template <typename...> typename P>
+struct __tp_find_if_helper<_Enable, idx, C<>, P> {
+    constexpr static size_t value = -1;
+};
+
+/// @private
+template <size_t idx, template <typename...> typename C, typename T, typename... Args,
+          template <typename...> typename P>
+struct __tp_find_if_helper<std::enable_if_t<P<T>::value, void>, idx, C<T, Args...>, P> {
+    constexpr static size_t value = idx;
+};
+
+template <typename C, template <typename...> typename P>
+struct tp_find_if {
+    constexpr static size_t value = __tp_find_if_helper<void, 0, C, P>::value;
+};
+
+template <typename C, template <typename...> typename P>
+inline constexpr size_t tp_find_if_v = tp_find_if<C, P>::value;
+
+template <typename C, typename P>
+inline constexpr size_t tp_find_if_f = tp_find_if<C, P::template fn>::value;
+
+template <typename C, typename V>
+struct tp_find {
+    constexpr static size_t value = tp_find_if_f<C, tp_bind_front<tp_equal_to, V>>;
+};
+
+template <typename C, typename V>
+inline constexpr size_t tp_find_v = tp_find<C, V>::value;
+
+template <typename C, template <typename...> typename P>
+struct tp_unique_if {
+    using type = tp_left_fold_f<C, tp_clear_t<C>,
+                                tp_bind<tp_conditional_t, tp_bind_front<P>, tp_arg<0>,
+                                        tp_bind_front<tp_push_back_t>>>;
+};
+
+// using NOW_LIST = tp_prefix_t<C, I + 1>;
+// using PRE_LIST = tp_prefix_t<C, I>;
+// using PRE_UNIQUE_IF_LIST = tp_unique_if_t<PRE_LIST>;
+// then :
+// tp_unique_if_t<NOW_LIST, P>
+// = tp_conditonal_t<
+// P<PRE_UNIQUE_IF_LIST, tp_at_t<C, I>>,
+// PRE_UNIQUE_IF_LIST,
+// tp_push_back_t<PRE_UNIQUE_IF_LIST, tp_at_t<C, I>>>
+//
+// It is equivalent to calling P every time on the results
+// of the previous processing and the new value.
+// If P is false, the new value is added
+template <typename C, template <typename...> typename P>
+using tp_unique_if_t = typename tp_unique_if<C, P>::type;
+
+template <typename C, typename P>
+using tp_unique_if_f = typename tp_unique_if<C, P::template fn>::type;
+
+template <typename C>
+struct tp_unique {
+    using type = tp_unique_if_t<C, tp_contains>;
+};
+
+/// @private
+template <typename _Enable, typename C, typename C1, typename C2,
+          template <typename...> typename P>
+struct __tp_merge_helper;
+
+/// @private
+template <typename _Enable, template <typename...> typename C, typename... Args,
+          template <typename...> typename C1, template <typename...> typename C2,
+          typename... Args2, template <typename...> typename P>
+struct __tp_merge_helper<_Enable, C<Args...>, C1<>, C2<Args2...>, P> {
+    using type = tp_list<Args..., Args2...>;
+};
+
+/// @private
+template <typename _Enable, template <typename...> typename C, typename... Args,
+          template <typename...> typename C1, typename... Args1,
+          template <typename...> typename C2, template <typename...> typename P>
+struct __tp_merge_helper<_Enable, C<Args...>, C1<Args1...>, C2<>, P> {
+    using type = tp_list<Args..., Args1...>;
+};
+
+/// @private
+template <typename _Enable, template <typename...> typename C, typename... Args,
+          template <typename...> typename C1, template <typename...> typename C2,
+          template <typename...> typename P>
+struct __tp_merge_helper<_Enable, C<Args...>, C1<>, C2<>, P> {
+    using type = tp_list<Args...>;
+};
+
+/// @private
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename C1, typename T1, typename... Args1,
+          template <typename...> typename C2, typename T2, typename... Args2,
+          template <typename...> typename P>
+struct __tp_merge_helper<std::enable_if_t<P<T1, T2>::value, void>, C<Args...>,
+                         C1<T1, Args1...>, C2<T2, Args2...>, P> {
+    using type = typename __tp_merge_helper<void, C<Args..., T1>, C1<Args1...>,
+                                            C2<T2, Args2...>, P>::type;
+};
+
+/// @private
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename C1, typename T1, typename... Args1,
+          template <typename...> typename C2, typename T2, typename... Args2,
+          template <typename...> typename P>
+struct __tp_merge_helper<std::enable_if_t<!P<T1, T2>::value, void>, C<Args...>,
+                         C1<T1, Args1...>, C2<T2, Args2...>, P> {
+    using type = typename __tp_merge_helper<void, C<Args..., T2>, C1<T1, Args1...>,
+                                            C2<Args2...>, P>::type;
+};
+
+template <typename C1, typename C2, template <typename...> typename P>
+struct tp_merge {
+    using type = typename __tp_merge_helper<void, tp_list<>, C1, C2, P>::type;
+};
+
+// like std::merge
+// merge two list with P
+template <typename C1, typename C2, template <typename...> typename P = tp_less>
+using tp_merge_t = typename tp_merge<C1, C2, P>::type;
+
+template <typename C1, typename C2, typename P = tp_make_fn<tp_less>>
+using tp_merge_f = typename tp_merge<C1, C2, P::template fn>::type;
+
+template <typename C, template <typename...> typename P>
+struct tp_sort;
+
+/// @private
+template <typename C, template <typename...> typename P>
+struct __tp_sort_helper;
+
+/// @private
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename P>
+struct __tp_sort_helper<C<Args...>, P> {
+    using _Container = C<Args...>;
+    constexpr static size_t size = tp_size_v<_Container>;
+    constexpr static size_t mid = size / 2;
+    using type1 = typename __tp_sort_helper<tp_prefix_t<_Container, mid>, P>::type;
+    using type2 = typename __tp_sort_helper<tp_suffix_t<_Container, size - mid>, P>::type;
+    using type = tp_merge_t<type1, type2, P>;
+};
+
+/// @private
+template <template <typename...> typename C, typename T,
+          template <typename...> typename P>
+struct __tp_sort_helper<C<T>, P> {
+    using type = C<T>;
+};
+
+/// @private
+template <template <typename...> typename C, template <typename...> typename P>
+struct __tp_sort_helper<C<>, P> {
+    using type = C<>;
+};
+
+template <template <typename...> typename C, typename... Args,
+          template <typename...> typename P>
+struct tp_sort<C<Args...>, P> {
+    using type = tp_rename_t<typename __tp_sort_helper<C<Args...>, P>::type, C>;
+};
+
+// list std::sort
+template <typename C, template <typename...> typename P = tp_less>
+using tp_sort_t = typename tp_sort<C, P>::type;
+
+template <typename C, typename P = tp_make_fn<tp_less>>
+using tp_sort_f = typename tp_sort<C, P::template fn>::type;
+
+template <typename C0, typename C1, typename P>
+struct __tp_lexicographical_compare__helper;
+
+template <template <typename...> typename C0, template <typename...> typename C1,
+          typename P, typename T, typename... Args0, typename U, typename... Args1>
+struct __tp_lexicographical_compare__helper<C0<T, Args0...>, C1<U, Args1...>, P> {
+    using Less = std::bool_constant<P::template fn<T, U>::value>;
+    using Next = typename __tp_lexicographical_compare__helper<C0<Args0...>, C1<Args1...>,
+                                                               P>::type;
+    using type =
+        std::conditional_t<Less::value, Less,
+                           typename tp_defer_t<__tp_lexicographical_compare__helper,
+                                               C0<Args0...>, C1<Args1...>, P>::type>;
+};
+
+template <template <typename...> typename C0, template <typename...> typename C1,
+          typename P, typename... Args0>
+struct __tp_lexicographical_compare__helper<C0<Args0...>, C1<>, P> {
+    using type = std::false_type;
+};
+
+template <template <typename...> typename C0, template <typename...> typename C1,
+          typename P, typename... Args1>
+struct __tp_lexicographical_compare__helper<C0<>, C1<Args1...>, P> {
+    using type = std::true_type;
+};
+
+template <template <typename...> typename C0, template <typename...> typename C1,
+          typename P>
+struct __tp_lexicographical_compare__helper<C0<>, C1<>, P> {
+    using type = std::false_type;
+};
+
+template <typename C0, typename C1, template <typename...> typename P>
+struct tp_lexicographical_compare {
+    using type = typename __tp_lexicographical_compare__helper<C0, C1, tp_make_fn<P>>::type;
+};
+
+template <typename C0, typename C1, template <typename...> typename P = tp_less>
+using tp_lexicographical_compare_t = typename tp_lexicographical_compare<C0, C1, P>::type;
+
+template <typename C0, typename C1, typename P = tp_make_fn<tp_less>>
+using tp_lexicographical_compare_f =
+    typename tp_lexicographical_compare<C0, C1, P::template fn>::type;
+
+} // namespace wjr
+
+#endif // WJR_TP_ALGORITHM_HPP__
\ No newline at end of file
diff --git a/include/wjr/tp/compiler.hpp b/include/wjr/tp/compiler.hpp
deleted file mode 100644
index 8c9d48f7..00000000
--- a/include/wjr/tp/compiler.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef WJR_TP_COMPILER_HPP__
-#define WJR_TP_COMPILER_HPP__
-
-#include <wjr/tp/list.hpp>
-
-namespace wjr {} // namespace wjr
-
-#endif           // WJR_TP_COMPILER_HPP__
\ No newline at end of file
diff --git a/include/wjr/tp/list.hpp b/include/wjr/tp/detail.hpp
similarity index 53%
rename from include/wjr/tp/list.hpp
rename to include/wjr/tp/detail.hpp
index bbef813c..c62857c6 100644
--- a/include/wjr/tp/list.hpp
+++ b/include/wjr/tp/detail.hpp
@@ -1,5 +1,5 @@
-#ifndef WJR_TP_LIST_HPP__
-#define WJR_TP_LIST_HPP__
+#ifndef WJR_TP_DETAIL_HPP__
+#define WJR_TP_DETAIL_HPP__
 
 #include <wjr/type_traits.hpp>
 
@@ -8,16 +8,6 @@ namespace wjr {
 template <typename... Args>
 struct tp_list {};
 
-template <typename T>
-struct tp_is_list : std::false_type {};
-
-template <typename... Args>
-struct tp_is_list<tp_list<Args...>> : std::true_type {};
-
-// check if is tp_list
-template <typename T>
-inline constexpr bool tp_is_list_v = tp_is_list<T>::value;
-
 template <typename T>
 struct tp_is_container : std::false_type {};
 
@@ -31,9 +21,9 @@ template <typename T>
 struct tp_size;
 
 template <template <typename...> typename C, typename... Args>
-struct tp_size<C<Args...>> : std::integral_constant<size_t, sizeof...(Args)> {};
+struct tp_size<C<Args...>> : integral_constant<size_t, sizeof...(Args)> {};
 
-// get size of C<Args...>
+/// @brief get size of C<Args...>
 template <typename T>
 inline constexpr size_t tp_size_v = tp_size<T>::value;
 
@@ -72,7 +62,7 @@ struct tp_defer {
                                   typename __tp_defer_helper<F, Args...>::type>;
 };
 
-// use std::enable_if_t to defer the instantiation of F<Args...>
+/// @brief use std::enable_if_t to defer the instantiation of F<Args...>
 template <template <typename...> typename F, typename... Args>
 using tp_defer_t = typename tp_defer<F, Args...>::type;
 
@@ -84,25 +74,25 @@ struct tp_type_identity {
     using type = T;
 };
 
-// tp_type_identity_t<T> is T
+/// @brief tp_type_identity_t<T> is T
 template <typename T>
 using tp_type_identity_t = typename tp_type_identity<T>::type;
 
-// F1<F2<Args...>>
+/// @brief F1<F2<Args...>>
 template <template <typename...> typename F1, template <typename...> typename F2>
 struct tp_bind_fn {
     template <typename... Args>
     using fn = tp_defer_t<F1, tp_defer_t<F2, Args...>>;
 };
 
-// make F can be used as fn
+/// @brief make F can be used as fn
 template <template <typename...> typename F>
 struct tp_make_fn {
     template <typename... Args>
     using fn = tp_defer_t<F, Args...>;
 };
 
-// std::negation<F<Args...>>
+/// @brief std::negation<F<Args...>>
 template <template <typename...> typename F>
 struct tp_not_fn {
     template <typename... Args>
@@ -130,7 +120,7 @@ struct tp_assign<T1<Args1...>, T2<Args2...>> {
     using type = T1<Args2...>;
 };
 
-// f(L1<Args1...>, L2<Args2...>) -> L1<Args2...>
+/// @brief f(L1<Args1...>, L2<Args2...>) -> L1<Args2...>
 template <typename T, typename U>
 using tp_assign_t = typename tp_assign<T, U>::type;
 
@@ -142,7 +132,7 @@ struct tp_clear<T<Args...>> {
     using type = T<>;
 };
 
-// f(L<Args...>) -> L<>
+/// @brief f(L<Args...>) -> L<>
 template <typename T>
 using tp_clear_t = typename tp_clear<T>::type;
 
@@ -154,7 +144,7 @@ struct tp_push_front<C<Args1...>, Args2...> {
     using type = C<Args2..., Args1...>;
 };
 
-// f(L<Args1...>, Args2...) -> L<Args1..., Args2...)
+/// @brief f(L<Args1...>, Args2...) -> L<Args1..., Args2...)
 template <typename T, typename... Args>
 using tp_push_front_t = typename tp_push_front<T, Args...>::type;
 
@@ -166,7 +156,7 @@ struct tp_push_back<C<Args1...>, Args2...> {
     using type = C<Args1..., Args2...>;
 };
 
-// f(L<Args1...>, Args2...) -> L<Args2..., Args1...)
+/// @brief f(L<Args1...>, Args2...) -> L<Args2..., Args1...)
 template <typename T, typename... Args>
 using tp_push_back_t = typename tp_push_back<T, Args...>::type;
 
@@ -229,7 +219,7 @@ struct tp_rename<C<Args...>, U> {
     using type = U<Args...>;
 };
 
-// f(L1<Args1...>, L2) -> L2<Args1...>
+/// @brief f(L1<Args1...>, L2) -> L2<Args1...>
 template <typename T, template <typename...> typename U>
 using tp_rename_t = typename tp_rename<T, U>::type;
 
@@ -243,21 +233,21 @@ struct tp_cut<C<Args...>, I, N> {
     using type = tp_rename_t<typename __tp_cut_helper<void, I, N, Args...>::type, C>;
 };
 
-// f(L<Args...>, I, N) -> L<Args[I ~ I + N - 1]>
+/// @brief f(L<Args...>, I, N) -> L<Args[I ~ I + N - 1]>
 template <typename T, size_t I, size_t N>
 using tp_cut_t = typename tp_cut<T, I, N>::type;
 
 template <typename T>
 struct tp_pop_front : tp_cut<T, 1, tp_size_v<T> - 1> {};
 
-// f(L<T, Args...>) -> L<Args...>
+/// @brief f(L<T, Args...>) -> L<Args...>
 template <typename T>
 using tp_pop_front_t = typename tp_pop_front<T>::type;
 
 template <typename T>
 struct tp_pop_back : tp_cut<T, 0, tp_size_v<T> - 1> {};
 
-// f(L<Args..., T>) -> L<Args...>
+/// @brief f(L<Args..., T>) -> L<Args...>
 template <typename T>
 using tp_pop_back_t = typename tp_pop_back<T>::type;
 
@@ -287,7 +277,7 @@ struct tp_at<C<Args...>, index> {
     using type = typename __tp_at_helper<index, Args...>::type;
 };
 
-// f(L<Args...>, index) - > Args(index)
+/// @brief f(L<Args...>, index) - > Args(index)
 template <typename T, size_t index>
 using tp_at_t = typename tp_at<T, index>::type;
 
@@ -296,7 +286,7 @@ struct tp_front {
     using type = tp_at_t<T, 0>;
 };
 
-// tp_at_t(T, 0)
+/// @brief tp_at_t(T, 0)
 template <typename T>
 using tp_front_t = typename tp_front<T>::type;
 
@@ -305,7 +295,7 @@ struct tp_back {
     using type = tp_at_t<T, tp_size_v<T> - 1>;
 };
 
-// tp_at_t(T, tp_size_v<T> - 1)
+/// @brief tp_at_t(T, tp_size_v<T> - 1)
 template <typename T>
 using tp_back_t = typename tp_back<T>::type;
 
@@ -314,7 +304,7 @@ struct tp_prefix {
     using type = tp_cut_t<T, 0, idx>;
 };
 
-// f(L<Args...>, idx) -> L<Args[0 ~ idx - 1]>
+/// @brief f(L<Args...>, idx) -> L<Args[0 ~ idx - 1]>
 template <typename T, size_t idx>
 using tp_prefix_t = typename tp_prefix<T, idx>::type;
 
@@ -323,7 +313,7 @@ struct tp_suffix {
     using type = tp_cut_t<T, tp_size_v<T> - idx, idx>;
 };
 
-// f(L<Args...>, idx) -> L<Args[tp_size_v<T> - idx ~ tp_size_v<T> - 1]>
+/// @brief f(L<Args...>, idx) -> L<Args[tp_size_v<T> - idx ~ tp_size_v<T> - 1]>
 template <typename T, size_t idx>
 using tp_suffix_t = typename tp_suffix<T, idx>::type;
 
@@ -362,7 +352,8 @@ struct tp_concat<T, U, Args3...> {
     using type = typename tp_concat<typename tp_concat<T, U>::type, Args3...>::type;
 };
 
-// f(L1<Args...>, L2<Args2...>, ... Ln<Argsn...>) -> L1<Args..., Args2..., Argsn...>
+/// @brief f(L1<Args...>, L2<Args2...>, ... Ln<Argsn...>) -> L1<Args..., Args2...,
+/// Argsn...>
 template <typename... Args>
 using tp_concat_t = typename tp_concat<Args...>::type;
 
@@ -377,7 +368,8 @@ struct tp_replace_at<T, 0, U> {
     using type = tp_push_front_t<tp_pop_front_t<T>, U>;
 };
 
-// f(L<Args...>, idx, U) -> L<Args[0 ~ idx - 1], U, Args[idx + 1 ~ tp_size_v<T> - 1]>
+/// @brief f(L<Args...>, idx, U) -> L<Args[0 ~ idx - 1], U, Args[idx + 1 ~ tp_size_v<T> -
+/// 1]>
 template <typename T, size_t idx, typename U>
 using tp_replace_at_t = typename tp_replace_at<T, idx, U>::type;
 
@@ -407,8 +399,7 @@ struct tp_conditional<V, T1, T2> {
     using type = std::conditional_t<V::value, T1, T2>;
 };
 
-// f(V, T, U) -> std::conditional_t<V::value, T, U>
-// f(V, T, Args...) -> std::conditional_t<V::value, T, f(Args...)>
+/// @brief f(V, T, Args...) -> std::conditional_t<V::value, T, f(Args...)>
 template <typename V, typename T, typename... Args>
 using tp_conditional_t = typename tp_conditional<V, T, Args...>::type;
 
@@ -447,8 +438,9 @@ struct tp_apply {
     using type = tp_rename_t<T, F>;
 };
 
-// f(F, L<Args...>) -> F<Args...>
-// same as tp_rename_t(L<Args...>, F)
+/**
+ * @brief f(F, L<Args...>) -> F<Args...>. same as tp_rename_t(L<Args...>, F)
+ */
 template <template <typename...> typename F, typename T>
 using tp_apply_t = typename tp_apply<F, T>::type;
 
@@ -494,28 +486,6 @@ struct tp_bind_back {
 template <typename F, typename... Args>
 using tp_bind_back_f = tp_bind_back<F::template fn, Args...>;
 
-template <typename T, template <typename...> typename F>
-struct tp_transform;
-
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename F>
-struct tp_transform<C<Args...>, F> {
-    using type = C<F<Args>...>;
-};
-
-// f(L<Args...>, Fn) -> L<Fn(Args)...>
-// use with apply, bind, bind_front, bind_back...
-// for example:
-// tp_transform_f<tp_bind_front<tp_apply_f, tp_bind_front<std::is_same>>,
-// tp_list<tp_list<int, float>, tp_list<float, float>, tp_list<int, double>>>
-// -> tp_list<std::is_same<int, float>, std::is_same<float, float>, std::is_same<int,
-// double>>
-template <typename T, template <typename...> typename F>
-using tp_transform_t = typename tp_transform<T, F>::type;
-
-template <typename T, typename F>
-using tp_transform_f = typename tp_transform<T, F::template fn>::type;
-
 template <template <typename...> typename C, typename... Args>
 struct tp_zip;
 
@@ -553,8 +523,8 @@ struct tp_zip<C, T, Args...> {
         C, std::make_index_sequence<tp_size_v<T>>>::template type<T, Args...>;
 };
 
-// f(C, L<A1, A2, ... An>, L<B1, B2, ..., Bn> ...)
-// -> L<C<A1, B1, ...>, C<A2, B2, ...>, ..., C<An, Bn, ...>>
+/// @brief f(C, L<A1, A2, ... An>, L<B1, B2, ..., Bn> ...) \
+/// -> L<C<A1, B1, ...>, C<A2, B2, ...>, ..., C<An, Bn, ...>>
 template <template <typename...> typename C, typename... Args>
 using tp_zip_t = typename tp_zip<C, Args...>::type;
 
@@ -580,7 +550,7 @@ struct tp_max_size {
     constexpr static size_t value = __tp_max_size_helper<T, Args...>::value;
 };
 
-// tp_max_size_v<T, Args...> -> size_t
+/// @brief tp_max_size_v<T, Args...> -> size_t
 template <typename T, typename... Args>
 inline constexpr size_t tp_max_size_v = tp_max_size<T, Args...>::value;
 
@@ -594,151 +564,10 @@ struct tp_unwrap<C<T>> {
     using type = T;
 };
 
-// f(C<T>) -> T
+/// @brief f(C<T>) -> T
 template <typename T>
 using tp_unwrap_t = typename tp_unwrap<T>::type;
 
-template <typename T, template <typename...> typename P, typename U>
-struct tp_replace_if;
-
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename P, typename U>
-struct tp_replace_if<C<Args...>, P, U> {
-    using type = C<tp_conditional_t<P<Args>, U, Args>...>;
-};
-
-// f(L<Args...>, P, U) -> L<if P(Args)::value then U else Args...>
-template <typename T, template <typename...> typename P, typename U>
-using tp_replace_if_t = typename tp_replace_if<T, P, U>::type;
-
-template <typename T, typename P, typename U>
-using tp_replace_if_f = tp_replace_if_t<T, P::template fn, U>;
-
-template <typename T, typename U>
-struct tp_replace_if_true {
-    using type = tp_replace_if_t<T, tp_type_identity_t, U>;
-};
-
-template <typename T, typename U>
-using tp_replace_if_true_t = typename tp_replace_if_true<T, U>::type;
-
-template <typename T, typename U>
-struct tp_replace_if_false {
-    using type = tp_replace_if_f<T, tp_not_fn<tp_type_identity_t>, U>;
-};
-
-template <typename T, typename U>
-using tp_replace_if_false_t = typename tp_replace_if_false<T, U>::type;
-
-template <typename T, typename O, typename N>
-struct tp_replace {
-    using type = tp_replace_if_f<T, tp_bind_front<std::is_same, O>, N>;
-};
-
-template <typename T, typename O, typename N>
-using tp_replace_t = typename tp_replace<T, O, N>::type;
-
-template <typename T, typename U>
-struct tp_fill {
-    using type = tp_replace_if_t<T, tp_true_type, U>;
-};
-
-// f(L<Args...>, U) -> L<U, U, ..., U>
-template <typename T, typename U>
-using tp_fill_t = typename tp_fill<T, U>::type;
-
-template <typename T, template <typename...> typename P>
-struct tp_count_if;
-
-template <template <typename...> typename C, template <typename...> typename P>
-struct tp_count_if<C<>, P> {
-    static constexpr size_t value = 0;
-};
-
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename P>
-struct tp_count_if<C<Args...>, P> {
-    static constexpr size_t value = (P<Args>::value + ...);
-};
-
-// f(L<Args...>, P) -> count(P(Args)::value)
-template <typename T, template <typename...> typename P>
-constexpr size_t tp_count_if_v = tp_count_if<T, P>::value;
-
-template <typename T, typename P>
-constexpr size_t tp_count_if_f_v = tp_count_if_v<T, P::template fn>;
-
-template <typename T, typename V>
-struct tp_count {
-    static constexpr size_t value = tp_count_if_f_v<T, tp_bind_front<std::is_same, V>>;
-};
-
-template <typename T, typename V>
-constexpr size_t tp_count_v = tp_count<T, V>::value;
-
-template <typename T, typename V>
-struct tp_contains {
-    static constexpr bool value = tp_count_v<T, V> != 0;
-};
-
-template <typename T, typename V>
-constexpr bool tp_contains_v = tp_contains<T, V>::value;
-
-template <typename T, template <typename...> typename P>
-struct tp_remove_if;
-
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename P>
-struct tp_remove_if<C<Args...>, P> {
-    using type = tp_concat_t<C<>, tp_conditional_t<P<Args>, C<>, C<Args>>...>;
-};
-
-// f(L<Args...>, P) -> L<if P(Args)::value then L<> else L<Args>...>
-template <typename T, template <typename...> typename P>
-using tp_remove_if_t = typename tp_remove_if<T, P>::type;
-
-template <typename T, typename P>
-using tp_remove_if_f = tp_remove_if_t<T, P::template fn>;
-
-template <typename T, typename V>
-struct tp_remove {
-    using type = tp_remove_if_f<T, tp_bind_front<std::is_same, V>>;
-};
-
-template <typename T, typename V>
-using tp_remove_t = typename tp_remove<T, V>::type;
-
-template <typename T, template <typename...> typename P>
-struct tp_filter {
-    using type = tp_remove_if_f<T, tp_not_fn<P>>;
-};
-
-template <typename T, template <typename...> typename P>
-using tp_filter_t = typename tp_filter<T, P>::type;
-
-template <typename T, typename P>
-using tp_filter_f = tp_filter_t<T, P::template fn>;
-
-template <typename T, typename U>
-struct tp_equal;
-
-/// @private
-template <typename _Enable, typename T, typename U>
-struct __tp_equal_helper : std::false_type {};
-
-/// @private
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename D, typename... Args2>
-struct __tp_equal_helper<std::enable_if_t<sizeof...(Args) == sizeof...(Args2), void>,
-                         C<Args...>, D<Args2...>>
-    : std::conjunction<std::is_same<Args, Args2>...> {};
-
-template <typename T, typename U>
-struct tp_equal : __tp_equal_helper<void, T, U> {};
-
-template <typename T, typename U>
-inline constexpr bool tp_equal_v = tp_equal<T, U>::value;
-
 template <typename T, size_t N>
 struct tp_repeat {
     using type = tp_concat_t<T, typename tp_repeat<T, N - 1>::type>;
@@ -772,42 +601,6 @@ struct tp_resize {
 template <typename C, size_t N, typename V>
 using tp_resize_t = typename tp_resize<C, N, V>::type;
 
-template <template <typename...> typename C, typename... Args>
-struct tp_product;
-
-/// @private
-template <typename _Enable, template <typename...> typename C, typename... Args>
-struct __tp_product_helper {
-    using type = tp_list<>;
-};
-
-/// @private
-template <typename _Enable, template <typename...> typename C, typename T>
-struct __tp_product_helper<_Enable, C, T> {
-    using type = tp_list<tp_rename_t<T, C>>;
-};
-
-/// @private
-template <template <typename...> typename C, typename T,
-          template <typename...> typename C1, typename... Args1, typename... Args>
-struct __tp_product_helper<std::enable_if_t<sizeof...(Args1) != 0, void>, C, T,
-                           C1<Args1...>, Args...> {
-    using type =
-        tp_concat_t<typename __tp_product_helper<void, C, tp_push_back_t<T, Args1>,
-                                                 Args...>::type...>;
-};
-
-template <template <typename...> typename C, typename... Args>
-struct tp_product {
-    using type = typename __tp_product_helper<void, C, tp_list<>, Args...>::type;
-};
-
-// for example
-// f(C, L<A1, A2>, L<B1, B2, B3>) -> L<C<A1, B1>, C<A1, B2>, C<A1, B3>, C<A2, B1>, C<A2,
-// B2>, C<A2, B3>>
-template <template <typename...> typename C, typename... Args>
-using tp_product_t = typename tp_product<C, Args...>::type;
-
 template <typename C, size_t I, typename... Args>
 struct tp_insert {
     static_assert(I <= tp_size_v<C>, "tp insert index out of range");
@@ -828,78 +621,6 @@ struct tp_erase {
 template <typename C, size_t I, size_t N>
 using tp_erase_t = typename tp_erase<C, I, N>::type;
 
-template <typename C>
-struct tp_reverse;
-
-template <template <typename...> typename C>
-struct tp_reverse<C<>> {
-    using type = C<>;
-};
-
-template <template <typename...> typename C, typename T, typename... Args>
-struct tp_reverse<C<T, Args...>> {
-    using type = tp_push_back_t<typename tp_reverse<C<Args...>>::type, T>;
-};
-
-template <typename C>
-using tp_reverse_t = typename tp_reverse<C>::type;
-
-/// @private
-template <typename _Enable, size_t idx, typename C, template <typename...> typename P>
-struct __tp_find_if_helper;
-
-/// @private
-template <typename _Enable, size_t idx, template <typename...> typename C, typename T,
-          typename... Args, template <typename...> typename P>
-struct __tp_find_if_helper<_Enable, idx, C<T, Args...>, P> {
-    constexpr static size_t value =
-        __tp_find_if_helper<void, idx + 1, C<Args...>, P>::value;
-};
-
-/// @private
-template <typename _Enable, size_t idx, template <typename...> typename C,
-          template <typename...> typename P>
-struct __tp_find_if_helper<_Enable, idx, C<>, P> {
-    constexpr static size_t value = -1;
-};
-
-/// @private
-template <size_t idx, template <typename...> typename C, typename T, typename... Args,
-          template <typename...> typename P>
-struct __tp_find_if_helper<std::enable_if_t<P<T>::value, void>, idx, C<T, Args...>, P> {
-    constexpr static size_t value = idx;
-};
-
-template <typename C, template <typename...> typename P>
-struct tp_find_if {
-    constexpr static size_t value = __tp_find_if_helper<void, 0, C, P>::value;
-};
-
-template <typename C, template <typename...> typename P>
-inline constexpr size_t tp_find_if_v = tp_find_if<C, P>::value;
-
-template <typename C, typename P>
-inline constexpr size_t tp_find_if_f = tp_find_if<C, P::template fn>::value;
-
-template <typename C, template <typename...> typename P>
-struct tp_find_if_not {
-    constexpr static size_t value = tp_find_if_f<C, tp_not_fn<P>>;
-};
-
-template <typename C, template <typename...> typename P>
-inline constexpr size_t tp_find_if_not_v = tp_find_if_not<C, P>::value;
-
-template <typename C, typename P>
-inline constexpr size_t tp_find_if_not_f = tp_find_if_not<C, P::template fn>::value;
-
-template <typename C, typename V>
-struct tp_find {
-    constexpr static size_t value = tp_find_if_f<C, tp_bind_front<std::is_same, V>>;
-};
-
-template <typename C, typename V>
-inline constexpr size_t tp_find_v = tp_find<C, V>::value;
-
 template <typename C, typename E, template <typename...> typename F>
 struct tp_left_fold;
 
@@ -915,7 +636,7 @@ struct tp_left_fold<C<T, Args...>, E, F> {
     using type = typename tp_left_fold<C<Args...>, F<E, T>, F>::type;
 };
 
-// f(L<A1, A2, ... An>, E, F) -> F<F<F...<F<E, A1>, A2>, ...>, An>
+/// @brief f(L<A1, A2, ... An>, E, F) -> F<F<F...<F<E, A1>, A2>, ...>, An>
 template <typename C, typename E, template <typename...> typename F>
 using tp_left_fold_t = typename tp_left_fold<C, E, F>::type;
 
@@ -938,158 +659,13 @@ struct tp_right_fold<C<T, Args...>, E, F> {
     using type = F<T, next_type>;
 };
 
-// f(L<A1, A2, ... An>, E, F) -> F<A1, F<A2, ... F<An, E>...>>
+/// @brief f(L<A1, A2, ... An>, E, F) -> F<A1, F<A2, ... F<An, E>...>>
 template <typename C, typename E, template <typename...> typename F>
 using tp_right_fold_t = typename tp_right_fold<C, E, F>::type;
 
 template <typename C, typename E, typename F>
 using tp_right_fold_f = typename tp_right_fold<C, E, F::template fn>::type;
 
-template <typename C, template <typename...> typename P>
-struct tp_unique_if {
-    using type = tp_left_fold_f<C, tp_clear_t<C>,
-                                tp_bind<tp_conditional_t, tp_bind_front<P>, tp_arg<0>,
-                                        tp_bind_front<tp_push_back_t>>>;
-};
-
-// using NOW_LIST = tp_prefix_t<C, I + 1>;
-// using PRE_LIST = tp_prefix_t<C, I>;
-// using PRE_UNIQUE_IF_LIST = tp_unique_if_t<PRE_LIST>;
-// then :
-// tp_unique_if_t<NOW_LIST, P>
-// = tp_conditonal_t<
-// P<PRE_UNIQUE_IF_LIST, tp_at_t<C, I>>,
-// PRE_UNIQUE_IF_LIST,
-// tp_push_back_t<PRE_UNIQUE_IF_LIST, tp_at_t<C, I>>>
-//
-// It is equivalent to calling P every time on the results
-// of the previous processing and the new value.
-// If P is false, the new value is added
-template <typename C, template <typename...> typename P>
-using tp_unique_if_t = typename tp_unique_if<C, P>::type;
-
-template <typename C, typename P>
-using tp_unique_if_f = typename tp_unique_if<C, P::template fn>::type;
-
-template <typename C>
-struct tp_unique {
-    using type = tp_unique_if_t<C, tp_contains>;
-};
-
-// same as tp_unique_if_t<C, tp_contains>
-// remove the same type
-template <typename C>
-using tp_unique_t = typename tp_unique<C>::type;
-
-/// @private
-template <typename _Enable, typename C, typename C1, typename C2,
-          template <typename...> typename P>
-struct __tp_merge_helper;
-
-/// @private
-template <typename _Enable, template <typename...> typename C, typename... Args,
-          template <typename...> typename C1, template <typename...> typename C2,
-          typename... Args2, template <typename...> typename P>
-struct __tp_merge_helper<_Enable, C<Args...>, C1<>, C2<Args2...>, P> {
-    using type = tp_list<Args..., Args2...>;
-};
-
-/// @private
-template <typename _Enable, template <typename...> typename C, typename... Args,
-          template <typename...> typename C1, typename... Args1,
-          template <typename...> typename C2, template <typename...> typename P>
-struct __tp_merge_helper<_Enable, C<Args...>, C1<Args1...>, C2<>, P> {
-    using type = tp_list<Args..., Args1...>;
-};
-
-/// @private
-template <typename _Enable, template <typename...> typename C, typename... Args,
-          template <typename...> typename C1, template <typename...> typename C2,
-          template <typename...> typename P>
-struct __tp_merge_helper<_Enable, C<Args...>, C1<>, C2<>, P> {
-    using type = tp_list<Args...>;
-};
-
-/// @private
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename C1, typename T1, typename... Args1,
-          template <typename...> typename C2, typename T2, typename... Args2,
-          template <typename...> typename P>
-struct __tp_merge_helper<std::enable_if_t<P<T1, T2>::value, void>, C<Args...>,
-                         C1<T1, Args1...>, C2<T2, Args2...>, P> {
-    using type = typename __tp_merge_helper<void, C<Args..., T1>, C1<Args1...>,
-                                            C2<T2, Args2...>, P>::type;
-};
-
-/// @private
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename C1, typename T1, typename... Args1,
-          template <typename...> typename C2, typename T2, typename... Args2,
-          template <typename...> typename P>
-struct __tp_merge_helper<std::enable_if_t<!P<T1, T2>::value, void>, C<Args...>,
-                         C1<T1, Args1...>, C2<T2, Args2...>, P> {
-    using type = typename __tp_merge_helper<void, C<Args..., T2>, C1<T1, Args1...>,
-                                            C2<Args2...>, P>::type;
-};
-
-template <typename C1, typename C2, template <typename...> typename P>
-struct tp_merge {
-    using type = typename __tp_merge_helper<void, tp_list<>, C1, C2, P>::type;
-};
-
-// like std::merge
-// merge two list with P
-template <typename C1, typename C2, template <typename...> typename P>
-using tp_merge_t = typename tp_merge<C1, C2, P>::type;
-
-template <typename C1, typename C2, typename P>
-using tp_merge_f = typename tp_merge<C1, C2, P::template fn>::type;
-
-template <typename C, template <typename...> typename P>
-struct tp_sort;
-
-/// @private
-template <typename C, template <typename...> typename P>
-struct __tp_sort_helper;
-
-/// @private
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename P>
-struct __tp_sort_helper<C<Args...>, P> {
-    using _Container = C<Args...>;
-    constexpr static size_t size = tp_size_v<_Container>;
-    constexpr static size_t mid = size / 2;
-    using type1 = typename __tp_sort_helper<tp_prefix_t<_Container, mid>, P>::type;
-    using type2 = typename __tp_sort_helper<tp_suffix_t<_Container, size - mid>, P>::type;
-    using type = tp_merge_t<type1, type2, P>;
-};
-
-/// @private
-template <template <typename...> typename C, typename T,
-          template <typename...> typename P>
-struct __tp_sort_helper<C<T>, P> {
-    using type = C<T>;
-};
-
-/// @private
-template <template <typename...> typename C, template <typename...> typename P>
-struct __tp_sort_helper<C<>, P> {
-    using type = C<>;
-};
-
-template <template <typename...> typename C, typename... Args,
-          template <typename...> typename P>
-struct tp_sort<C<Args...>, P> {
-    using type = tp_rename_t<typename __tp_sort_helper<C<Args...>, P>::type, C>;
-};
-
-// list std::sort
-template <typename C, template <typename...> typename P>
-using tp_sort_t = typename tp_sort<C, P>::type;
-
-template <typename C, typename P>
-using tp_sort_f = typename tp_sort<C, P::template fn>::type;
-
 /// @private
 template <typename T, typename S>
 struct __tp_make_integer_sequence_helper;
@@ -1097,7 +673,7 @@ struct __tp_make_integer_sequence_helper;
 /// @private
 template <typename T, T... Idxs>
 struct __tp_make_integer_sequence_helper<T, std::integer_sequence<T, Idxs...>> {
-    using type = tp_list<std::integral_constant<T, Idxs>...>;
+    using type = tp_list<integral_constant<T, Idxs>...>;
 };
 
 template <typename T, T N>
@@ -1116,8 +692,7 @@ struct __tp_make_std_integer_sequence_helper;
 
 /// @private
 template <typename T, T... Idxs>
-struct __tp_make_std_integer_sequence_helper<
-    T, tp_list<std::integral_constant<T, Idxs>...>> {
+struct __tp_make_std_integer_sequence_helper<T, tp_list<integral_constant<T, Idxs>...>> {
     using type = std::integer_sequence<T, Idxs...>;
 };
 
@@ -1127,4 +702,4 @@ using tp_make_std_index_sequence =
 
 } // namespace wjr
 
-#endif // WJR_TP_LIST_HPP__
\ No newline at end of file
+#endif // WJR_TP_DETAIL_HPP__
\ No newline at end of file
diff --git a/include/wjr/tuple.hpp b/include/wjr/tuple.hpp
index 9c291677..ba4b61a6 100644
--- a/include/wjr/tuple.hpp
+++ b/include/wjr/tuple.hpp
@@ -16,8 +16,7 @@ class tuple;
 namespace std {
 
 template <typename... Args>
-struct tuple_size<wjr::tuple<Args...>> : std::integral_constant<size_t, sizeof...(Args)> {
-};
+struct tuple_size<wjr::tuple<Args...>> : integral_constant<size_t, sizeof...(Args)> {};
 
 template <size_t I, typename... Args>
 struct tuple_element<I, wjr::tuple<Args...>> {
@@ -351,7 +350,7 @@ constexpr decltype(auto) apply(Func &&fn, Tuple &&tp) noexcept(noexcept(
 template <size_t I, typename Tuple>
 struct __tuple_cat_single_helper {
     static constexpr size_t Size = std::tuple_size_v<Tuple>;
-    using type0 = tp_repeat_t<tp_list<std::integral_constant<size_t, I>>, Size>;
+    using type0 = tp_repeat_t<tp_list<integral_constant<size_t, I>>, Size>;
     using type1 = tp_make_index_sequence<Size>;
 };
 
diff --git a/include/wjr/type_traits.hpp b/include/wjr/type_traits.hpp
index ba97affc..cb9096ef 100644
--- a/include/wjr/type_traits.hpp
+++ b/include/wjr/type_traits.hpp
@@ -31,6 +31,8 @@ struct in_place_min_t {
 
 inline constexpr in_place_min_t in_place_min = {};
 
+using std::integral_constant;
+
 template <typename... Args>
 struct multi_conditional;