refactor: 💥 type list tools made and implementation detail of the library

src/core/include/mp-units/bits/type_list.h

@@ -33,9 +33,7 @@
 MP_UNITS_DIAGNOSTIC_PUSH
 MP_UNITS_DIAGNOSTIC_IGNORE_EXPR_ALWAYS_TF
 
-namespace mp_units {
+namespace mp_units::detail {
-
-namespace detail {
 
 template<typename T>
 inline constexpr bool is_type_list = false;
@@ -43,31 +41,20 @@ inline constexpr bool is_type_list = false;
 template<template<typename...> typename T, typename... Types>
 inline constexpr bool is_type_list<T<Types...>> = true;
 
-}  // namespace detail
-
 template<typename T>
-concept TypeList = detail::is_type_list<T>;
+concept TypeList = is_type_list<T>;
 
 // size
-
-namespace detail {
-
 template<typename List>
 struct type_list_size_impl;
 
 template<template<typename...> typename List, typename... Types>
 struct type_list_size_impl<List<Types...>> : std::integral_constant<std::size_t, sizeof...(Types)> {};
 
-}  // namespace detail
-
 template<TypeList List>
-inline constexpr std::size_t type_list_size = detail::type_list_size_impl<List>::value;
+inline constexpr std::size_t type_list_size = type_list_size_impl<List>::value;
-
 
 // map
-
-namespace detail {
-
 template<typename T, template<typename...> typename To>
 struct type_list_map_impl;
 
@@ -76,16 +63,11 @@ struct type_list_map_impl<From<Args...>, To> {
   using type = To<Args...>;
 };
 
-}  // namespace detail
-
 template<TypeList From, template<typename...> typename To>
-using type_list_map = MP_UNITS_TYPENAME detail::type_list_map_impl<From, To>::type;
+using type_list_map = MP_UNITS_TYPENAME type_list_map_impl<From, To>::type;
 
 
 // element
-
-namespace detail {
-
 template<std::size_t I, typename T>
 struct type_list_leaf {
   using type = T;
@@ -100,22 +82,16 @@ struct indexed_type_list_impl<std::index_sequence<Is...>, Ts...> : type_list_lea
 template<std::size_t I, typename T>
 std::type_identity<T> type_list_element_func(const type_list_leaf<I, T>&);
 
-}  // namespace detail
-
 template<typename... Ts>
-struct indexed_type_list : detail::indexed_type_list_impl<std::index_sequence_for<Ts...>, Ts...> {};
+struct indexed_type_list : indexed_type_list_impl<std::index_sequence_for<Ts...>, Ts...> {};
 
 template<TypeList List, std::size_t I>
-using type_list_element_indexed = typename decltype(detail::type_list_element_func<I>(std::declval<List>()))::type;
+using type_list_element_indexed = typename decltype(type_list_element_func<I>(std::declval<List>()))::type;
 
 template<TypeList List, std::size_t I>
 using type_list_element = type_list_element_indexed<type_list_map<List, indexed_type_list>, I>;
 
-
 // front
-
-namespace detail {
-
 template<typename List>
 struct type_list_front_impl;
 
@@ -124,22 +100,14 @@ struct type_list_front_impl<List<T, Ts...>> {
   using type = T;
 };
 
-}  // namespace detail
-
 template<TypeList List>
-using type_list_front = MP_UNITS_TYPENAME detail::type_list_front_impl<List>::type;
+using type_list_front = MP_UNITS_TYPENAME type_list_front_impl<List>::type;
-
 
 // back
-
 template<TypeList List>
 using type_list_back = type_list_element<List, type_list_size<List> - 1>;
 
-
 // push_front
-
-namespace detail {
-
 template<typename List, typename... Types>
 struct type_list_push_front_impl;
 
@@ -148,16 +116,10 @@ struct type_list_push_front_impl<List<OldTypes...>, NewTypes...> {
   using type = List<NewTypes..., OldTypes...>;
 };
 
-}  // namespace detail
-
 template<TypeList List, typename... Types>
-using type_list_push_front = MP_UNITS_TYPENAME detail::type_list_push_front_impl<List, Types...>::type;
+using type_list_push_front = MP_UNITS_TYPENAME type_list_push_front_impl<List, Types...>::type;
-
 
 // push_back
-
-namespace detail {
-
 template<typename List, typename... Types>
 struct type_list_push_back_impl;
 
@@ -166,16 +128,10 @@ struct type_list_push_back_impl<List<OldTypes...>, NewTypes...> {
   using type = List<OldTypes..., NewTypes...>;
 };
 
-}  // namespace detail
-
 template<TypeList List, typename... Types>
-using type_list_push_back = MP_UNITS_TYPENAME detail::type_list_push_back_impl<List, Types...>::type;
+using type_list_push_back = MP_UNITS_TYPENAME type_list_push_back_impl<List, Types...>::type;
-
 
 // join
-
-namespace detail {
-
 template<typename List, typename... Rest>
 struct type_list_join_impl {
   using type = List;
@@ -186,16 +142,10 @@ struct type_list_join_impl<List<First...>, List<Second...>, Rest...> {
   using type = MP_UNITS_TYPENAME type_list_join_impl<List<First..., Second...>, Rest...>::type;
 };
 
-}  // namespace detail
-
 template<TypeList... Lists>
-using type_list_join = MP_UNITS_TYPENAME detail::type_list_join_impl<Lists...>::type;
+using type_list_join = MP_UNITS_TYPENAME type_list_join_impl<Lists...>::type;
-
 
 // split
-
-namespace detail {
-
 template<typename List, typename First, typename Second>
 struct type_list_split_impl;
 
@@ -206,28 +156,19 @@ struct type_list_split_impl<List<Args...>, std::index_sequence<First...>, std::i
   using second_list = List<type_list_element_indexed<indexed_list, sizeof...(First) + Second>...>;
 };
 
-}  // namespace detail
-
 template<TypeList List, std::size_t N>
   requires(N <= type_list_size<List>)
 struct type_list_split :
-    detail::type_list_split_impl<List, std::make_index_sequence<N>,
+    type_list_split_impl<List, std::make_index_sequence<N>, std::make_index_sequence<type_list_size<List> - N>> {};
-                                 std::make_index_sequence<type_list_size<List> - N>> {};
-
 
 // split_half
-
 template<TypeList List>
 struct type_list_split_half;
 
 template<template<typename...> typename List, typename... Types>
 struct type_list_split_half<List<Types...>> : type_list_split<List<Types...>, (sizeof...(Types) + 1) / 2> {};
 
-
 // merge_sorted
-
-namespace detail {
-
 template<typename SortedList1, typename SortedList2, template<typename, typename> typename Pred>
 struct type_list_merge_sorted_impl;
 
@@ -261,17 +202,10 @@ struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...
     typename type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>::type, Rhs1>::type;
 };
 
-}  // namespace detail
-
 template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred>
-using type_list_merge_sorted =
+using type_list_merge_sorted = MP_UNITS_TYPENAME type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
-  MP_UNITS_TYPENAME detail::type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
-
 
 // sort
-
-namespace detail {
-
 template<typename List, template<typename, typename> typename Pred>
 struct type_list_sort_impl;
 
@@ -294,11 +228,9 @@ struct type_list_sort_impl<List<Types...>, Pred> {
   using type = MP_UNITS_TYPENAME type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type;
 };
 
-}  // namespace detail
-
 template<TypeList List, template<typename, typename> typename Pred>
-using type_list_sort = MP_UNITS_TYPENAME detail::type_list_sort_impl<List, Pred>::type;
+using type_list_sort = MP_UNITS_TYPENAME type_list_sort_impl<List, Pred>::type;
 
-}  // namespace mp_units
+}  // namespace mp_units::detail
 
 MP_UNITS_DIAGNOSTIC_POP

test/static/type_list_test.cpp

@@ -27,6 +27,7 @@
 namespace {
 
 using namespace mp_units;
+using namespace mp_units::detail;
 
 template<typename... Types>
 struct type_list;