update tp

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) &

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;
     }

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>

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 {

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>> {

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;

include/wjr/container/constexpr_map.hpp → 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__
+#endif // WJR_CONTAINER_CONSTANT_MAP_HPP__

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__

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
 

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);
 }
 

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);
 }
 

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);
     }
 };

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.

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 {};                                                                       \
     }
 

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> {

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()).