diff --git a/include/seqan3/argument_parser/detail/format_base.hpp b/include/seqan3/argument_parser/detail/format_base.hpp
index 8479078a34..0583598956 100644
--- a/include/seqan3/argument_parser/detail/format_base.hpp
+++ b/include/seqan3/argument_parser/detail/format_base.hpp
@@ -18,12 +18,11 @@
 #include <sstream>
 #include <string>
 
-#include <meta/meta.hpp>
-
 #include <seqan3/argument_parser/auxiliary.hpp>
 #include <seqan3/argument_parser/exceptions.hpp>
 #include <seqan3/argument_parser/validators.hpp>
 #include <seqan3/core/detail/reflection.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/std/filesystem>
 
 namespace seqan3::detail
@@ -43,20 +42,20 @@ class format_base
     static std::string get_type_name_as_string(value_type const & /**/)
     {
         using type = std::decay_t<value_type>;
-        using types = meta::list<int8_t,
-                                 uint8_t,
-                                 int16_t,
-                                 uint16_t,
-                                 int32_t,
-                                 uint32_t,
-                                 int64_t,
-                                 uint64_t,
-                                 double,
-                                 float,
-                                 bool,
-                                 char,
-                                 std::string,
-                                 std::filesystem::path>;
+        using types = type_list<int8_t,
+                                uint8_t,
+                                int16_t,
+                                uint16_t,
+                                int32_t,
+                                uint32_t,
+                                int64_t,
+                                uint64_t,
+                                double,
+                                float,
+                                bool,
+                                char,
+                                std::string,
+                                std::filesystem::path>;
         std::vector<std::string> names{"signed 8 bit integer",
                                        "unsigned 8 bit integer",
                                        "signed 16 bit integer",
@@ -72,8 +71,8 @@ class format_base
                                        "std::string",
                                        "std::filesystem::path"};
 
-        if constexpr (meta::in<types, type>::value)
-            return names[meta::find_index<types, type>::value];
+        if constexpr (list_traits::contains<type, types>)
+            return names[list_traits::find<type, types>];
         else
             return detail::get_display_name_v<value_type>.str();
     }
diff --git a/include/seqan3/core/algorithm/configuration.hpp b/include/seqan3/core/algorithm/configuration.hpp
index 51ed693df6..2e50a00c0f 100644
--- a/include/seqan3/core/algorithm/configuration.hpp
+++ b/include/seqan3/core/algorithm/configuration.hpp
@@ -19,8 +19,7 @@
 #include <seqan3/core/algorithm/concept.hpp>
 #include <seqan3/core/algorithm/configuration_utility.hpp>
 #include <seqan3/core/algorithm/pipeable_config_element.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/core/tuple_utility.hpp>
 #include <seqan3/core/type_list/type_list.hpp>
 #include <seqan3/std/concepts>
@@ -276,13 +275,13 @@ class configuration : public std::tuple<configs_t...>
     template <typename query_t>
     static constexpr bool exists() noexcept
     {
-        return !meta::empty<meta::find<type_list<configs_t...>, query_t>>::value;
+        return pack_traits::contains<query_t, configs_t...>;
     }
     //!\brief Checks if the given type exists in the tuple.
     template <template <typename ...> typename query_t>
     static constexpr bool exists() noexcept
     {
-        return !meta::empty<meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>>::value;
+        return (pack_traits::find_if<detail::is_same_configuration_f<query_t>::template invoke, configs_t...> > -1);
     }
     //!\}
 
@@ -566,10 +565,9 @@ configuration(pipeable_config_element<derived_t, value_t> const &) -> configurat
 template <template <typename ...> class query_t, typename ...configs_t>
 constexpr auto & get(configuration<configs_t...> & config) noexcept
 {
-    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
-    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");
+    constexpr auto pos = pack_traits::find_if<detail::is_same_configuration_f<query_t>::template invoke, configs_t...>;
+    static_assert(pos > -1, "Access error: The requested type is not contained.");
 
-    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
     return get<pos>(config);
 }
 
@@ -577,10 +575,9 @@ constexpr auto & get(configuration<configs_t...> & config) noexcept
 template <template <typename ...> class query_t, typename ...configs_t>
 constexpr auto const & get(configuration<configs_t...> const & config) noexcept
 {
-    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
-    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");
+    constexpr auto pos = pack_traits::find_if<detail::is_same_configuration_f<query_t>::template invoke, configs_t...>;
+    static_assert(pos > -1, "Access error: The requested type is not contained.");
 
-    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
     return get<pos>(config);
 }
 
@@ -588,10 +585,9 @@ constexpr auto const & get(configuration<configs_t...> const & config) noexcept
 template <template <typename ...> class query_t, typename ...configs_t>
 constexpr auto && get(configuration<configs_t...> && config) noexcept
 {
-    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
-    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");
+    constexpr auto pos = pack_traits::find_if<detail::is_same_configuration_f<query_t>::template invoke, configs_t...>;
+    static_assert(pos > -1, "Access error: The requested type is not contained.");
 
-    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
     return get<pos>(std::move(config));
 }
 
@@ -599,10 +595,9 @@ constexpr auto && get(configuration<configs_t...> && config) noexcept
 template <template <typename ...> class query_t, typename ...configs_t>
 constexpr auto const && get(configuration<configs_t...> const && config) noexcept
 {
-    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
-    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");
+    constexpr auto pos = pack_traits::find_if<detail::is_same_configuration_f<query_t>::template invoke, configs_t...>;
+    static_assert(pos > -1, "Access error: The requested type is not contained.");
 
-    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
     // TODO: change after GCC-7 bug with const && version of get in std::tuple is fixed.
     // return get<pos>(std::move(config));
     return std::move(get<pos>(config));
diff --git a/include/seqan3/core/pod_tuple.hpp b/include/seqan3/core/pod_tuple.hpp
index e997d5d16a..8977082392 100644
--- a/include/seqan3/core/pod_tuple.hpp
+++ b/include/seqan3/core/pod_tuple.hpp
@@ -15,9 +15,8 @@
 #include <tuple>
 #include <type_traits>
 
-#include <meta/meta.hpp>
-
 #include <seqan3/core/platform.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 
 namespace seqan3
 {
@@ -245,12 +244,10 @@ constexpr auto const && get(seqan3::pod_tuple<types...> const && t) noexcept
 template <typename type, typename ...arg_types>
 constexpr auto & get(seqan3::pod_tuple<arg_types...> & t) noexcept
 //!\cond
-    requires meta::in<meta::list<arg_types...>, type>::value &&
-             (meta::find_index<meta::list<arg_types...>, type>::value ==
-              meta::reverse_find_index<meta::list<arg_types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
 //!\endcond
 {
-    return seqan3::get<meta::find_index<meta::list<arg_types...>, type>::value>(t);
+    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(t);
 }
 
 //!\brief The same as [std::get](https://en.cppreference.com/w/cpp/utility/tuple/get) on an std::tuple.
@@ -258,12 +255,10 @@ constexpr auto & get(seqan3::pod_tuple<arg_types...> & t) noexcept
 template <typename type, typename ...arg_types>
 constexpr auto const & get(seqan3::pod_tuple<arg_types...> const & t) noexcept
 //!\cond
-    requires meta::in<meta::list<arg_types...>, type>::value &&
-             (meta::find_index<meta::list<arg_types...>, type>::value ==
-              meta::reverse_find_index<meta::list<arg_types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
 //!\endcond
 {
-    return seqan3::get<meta::find_index<meta::list<arg_types...>, type>::value>(t);
+    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(t);
 }
 
 //!\brief The same as [std::get](https://en.cppreference.com/w/cpp/utility/tuple/get) on an std::tuple.
@@ -271,12 +266,10 @@ constexpr auto const & get(seqan3::pod_tuple<arg_types...> const & t) noexcept
 template <typename type, typename ...arg_types>
 constexpr auto && get(seqan3::pod_tuple<arg_types...> && t) noexcept
 //!\cond
-    requires meta::in<meta::list<arg_types...>, type>::value &&
-             (meta::find_index<meta::list<arg_types...>, type>::value ==
-              meta::reverse_find_index<meta::list<arg_types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
 //!\endcond
 {
-    return seqan3::get<meta::find_index<meta::list<arg_types...>, type>::value>(std::move(t));
+    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(std::move(t));
 }
 
 //!\brief The same as [std::get](https://en.cppreference.com/w/cpp/utility/tuple/get) on an std::tuple.
@@ -284,12 +277,10 @@ constexpr auto && get(seqan3::pod_tuple<arg_types...> && t) noexcept
 template <typename type, typename ...arg_types>
 constexpr auto const && get(seqan3::pod_tuple<arg_types...> const && t) noexcept
 //!\cond
-    requires meta::in<meta::list<arg_types...>, type>::value &&
-             (meta::find_index<meta::list<arg_types...>, type>::value ==
-              meta::reverse_find_index<meta::list<arg_types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
 //!\endcond
 {
-    return seqan3::get<meta::find_index<meta::list<arg_types...>, type>::value>(std::move(t));
+    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(std::move(t));
 }
 //!\}
 
@@ -329,36 +320,28 @@ constexpr auto const && get(seqan3::pod_tuple<types...> const && t) noexcept
 
 template <typename type, typename ...types>
 constexpr auto & get(seqan3::pod_tuple<types...> & t) noexcept
-    requires meta::in<meta::list<types...>, type>::value &&
-             (meta::find_index<meta::list<types...>, type>::value ==
-              meta::reverse_find_index<meta::list<types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, types...> == 1)
 {
     return seqan3::get<type>(t);
 }
 
 template <typename type, typename ...types>
 constexpr auto const & get(seqan3::pod_tuple<types...> const & t) noexcept
-    requires meta::in<meta::list<types...>, type>::value &&
-             (meta::find_index<meta::list<types...>, type>::value ==
-              meta::reverse_find_index<meta::list<types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, types...> == 1)
 {
     return seqan3::get<type>(t);
 }
 
 template <typename type, typename ...types>
 constexpr auto && get(seqan3::pod_tuple<types...> && t) noexcept
-    requires meta::in<meta::list<types...>, type>::value &&
-             (meta::find_index<meta::list<types...>, type>::value ==
-              meta::reverse_find_index<meta::list<types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, types...> == 1)
 {
     return seqan3::get<type>(std::move(t));
 }
 
 template <typename type, typename ...types>
 constexpr auto const && get(seqan3::pod_tuple<types...> const && t) noexcept
-    requires meta::in<meta::list<types...>, type>::value &&
-             (meta::find_index<meta::list<types...>, type>::value ==
-              meta::reverse_find_index<meta::list<types...>, type>::value)
+    requires (seqan3::pack_traits::count<type, types...> == 1)
 {
     return seqan3::get<type>(std::move(t));
 }
@@ -374,7 +357,7 @@ template <std::size_t i, template <typename ...> typename t, typename ...types>
             std::is_base_of_v<seqan3::pod_tuple<types...>, t<types...>>
 struct tuple_element<i, t<types...>>
 {
-    using type = meta::at_c<meta::list<types...>, i>;
+    using type = seqan3::pack_traits::at<i, types...>;
 };
 
 /*!\brief Provides access to the number of elements in a tuple as a compile-time constant expression.
diff --git a/include/seqan3/core/tuple_utility.hpp b/include/seqan3/core/tuple_utility.hpp
index a5057ad2c6..195623bdb8 100644
--- a/include/seqan3/core/tuple_utility.hpp
+++ b/include/seqan3/core/tuple_utility.hpp
@@ -12,15 +12,11 @@
 
 #pragma once
 
-#include <meta/meta.hpp>
-
 #include <utility>
 
 #include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/core/pod_tuple.hpp>
-#include <seqan3/core/type_list/type_list.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 
 namespace seqan3::detail
 {
@@ -152,7 +148,7 @@ constexpr auto tuple_split(tuple_t<ts...> && t)
 template <typename pivot_t, tuple_like tuple_t>
 constexpr auto tuple_split(tuple_t && t)
 {
-    constexpr size_t pivot_c = meta::find_index<detail::tuple_type_list_t<remove_cvref_t<tuple_t>>, pivot_t>::value;
+    constexpr size_t pivot_c = list_traits::find<pivot_t, detail::tuple_type_list_t<remove_cvref_t<tuple_t>>>;
 
     static_assert(pivot_c <= std::tuple_size_v<remove_cvref_t<tuple_t>>);
 
diff --git a/include/seqan3/core/type_list/traits.hpp b/include/seqan3/core/type_list/traits.hpp
index a8489ce7e6..e45e4e019c 100644
--- a/include/seqan3/core/type_list/traits.hpp
+++ b/include/seqan3/core/type_list/traits.hpp
@@ -467,7 +467,8 @@ inline constexpr ptrdiff_t find = -1;
  * \include test/snippet/core/type_list/list_traits_find.cpp
  */
 template <typename query_t, typename ...pack_t>
-inline constexpr ptrdiff_t find<query_t,type_list<pack_t...>> = seqan3::pack_traits::detail::find<query_t, pack_t...>();
+inline constexpr ptrdiff_t find<query_t, type_list<pack_t...>> =
+    seqan3::pack_traits::detail::find<query_t, pack_t...>();
 
 //!\cond
 template <template <typename> typename pred_t, seqan3::detail::type_list_specialisation list_t>
diff --git a/include/seqan3/core/type_traits/transformation_trait_or.hpp b/include/seqan3/core/type_traits/transformation_trait_or.hpp
index b7d0252f4f..0dc49a1a43 100644
--- a/include/seqan3/core/type_traits/transformation_trait_or.hpp
+++ b/include/seqan3/core/type_traits/transformation_trait_or.hpp
@@ -17,6 +17,7 @@
 #include <meta/meta.hpp>
 
 #include <seqan3/core/platform.hpp>
+#include <seqan3/core/type_traits/concept.hpp>
 #include <seqan3/std/type_traits>
 
 namespace seqan3::detail
@@ -42,7 +43,7 @@ namespace seqan3::detail
  *   seqan3::detail::transformation_trait_or_t as a shorthand for *seqan3::detail::transformation_trait_or::type*
  */
 template <typename type_t, typename default_t>
-using transformation_trait_or = std::conditional_t<meta::is_trait<type_t>::value,   // check if type_t::type exists
+using transformation_trait_or = std::conditional_t<transformation_trait<type_t>,    // check if type_t::type exists
                                                    type_t,                          // if yes, return type_t
                                                    std::type_identity<default_t>>;  // else return default_t as trait
 
diff --git a/include/seqan3/io/alignment_file/input.hpp b/include/seqan3/io/alignment_file/input.hpp
index 764c302e4e..cf57b45702 100644
--- a/include/seqan3/io/alignment_file/input.hpp
+++ b/include/seqan3/io/alignment_file/input.hpp
@@ -25,7 +25,7 @@
 #include <seqan3/alphabet/quality/phred42.hpp>
 #include <seqan3/alphabet/quality/qualified.hpp>
 #include <seqan3/core/concept/tuple.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/io/alignment_file/input_format_concept.hpp>
 #include <seqan3/io/alignment_file/format_bam.hpp>
@@ -856,7 +856,7 @@ class alignment_file_input
     template <typename format_type>
     void init(format_type const &)
     {
-        static_assert(meta::in<valid_formats, format_type>::value,
+        static_assert(list_traits::contains<format_type, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
 
         format = detail::alignment_file_input_format_REMOVEME<format_type>{};
diff --git a/include/seqan3/io/alignment_file/output.hpp b/include/seqan3/io/alignment_file/output.hpp
index 7d0f8d7194..be00ebe984 100644
--- a/include/seqan3/io/alignment_file/output.hpp
+++ b/include/seqan3/io/alignment_file/output.hpp
@@ -20,8 +20,7 @@
 #include <vector>
 
 #include <seqan3/core/concept/tuple.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/io/alignment_file/format_bam.hpp>
 #include <seqan3/io/alignment_file/format_sam.hpp>
 #include <seqan3/io/alignment_file/header.hpp>
@@ -340,7 +339,7 @@ class alignment_file_output
         secondary_stream{&stream, stream_deleter_noop},
         format{detail::alignment_file_output_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
     }
 
@@ -353,7 +352,7 @@ class alignment_file_output
         secondary_stream{&*primary_stream, stream_deleter_noop},
         format{detail::alignment_file_output_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
     }
 
diff --git a/include/seqan3/io/detail/misc.hpp b/include/seqan3/io/detail/misc.hpp
index 6f46b9e17e..91f65610e0 100644
--- a/include/seqan3/io/detail/misc.hpp
+++ b/include/seqan3/io/detail/misc.hpp
@@ -16,7 +16,7 @@
 
 #include <seqan3/core/detail/pack_algorithm.hpp>
 #include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/core/type_list/type_list.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/io/sequence_file/input_format_concept.hpp>
 #include <seqan3/std/algorithm>
@@ -33,8 +33,8 @@ struct variant_from_tags;
 
 //!\brief Transfers a list of format tags (`...ts`) onto a std::variant by specialising output_t with each.
 //!\ingroup io
-template <template <typename ...> typename output_t, typename ...ts>
-struct variant_from_tags<meta::list<ts...>, output_t>
+template <template <typename...> typename output_t, typename ...ts>
+struct variant_from_tags<type_list<ts...>, output_t>
 {
     //!\brief The type of std::variant.
     using type = std::variant<output_t<ts>...>;
@@ -76,9 +76,9 @@ void set_format(format_variant_type & format,
     if (extension.size() > 1)
     {
         extension = extension.substr(1); // drop leading "."
-        meta::for_each(valid_formats{}, [&] (auto && fmt)
+        detail::for_each<valid_formats>([&] (auto fmt)
         {
-            using fmt_type = remove_cvref_t<decltype(fmt)>;
+            using fmt_type = remove_cvref_t<typename decltype(fmt)::type>;
             using fmt_tag  = typename fmt_type::format_tag;
 
             for (auto const & ext : fmt_tag::file_extensions)
diff --git a/include/seqan3/io/detail/record.hpp b/include/seqan3/io/detail/record.hpp
index bde04cdab2..767b4d9c8f 100644
--- a/include/seqan3/io/detail/record.hpp
+++ b/include/seqan3/io/detail/record.hpp
@@ -14,7 +14,7 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/io/record.hpp>
 #include <seqan3/range/views/repeat.hpp>
 #include <seqan3/std/ranges>
@@ -100,8 +100,8 @@ struct select_types_with_ids<field_types, field_types_as_ids, selected_field_ids
                                          selected_field_ids,
                                          field_no + 1,
                                          return_types ...,
-                                         meta::at_c<field_types,
-                                                    field_types_as_ids::index_of(selected_field_ids::as_array[field_no])>>;
+                                         list_traits::at<field_types_as_ids::index_of(
+                                             selected_field_ids::as_array[field_no]), field_types>>;
 
 };
 //!\endcond
diff --git a/include/seqan3/io/sequence_file/input.hpp b/include/seqan3/io/sequence_file/input.hpp
index 2b90da84eb..42d7c47f15 100644
--- a/include/seqan3/io/sequence_file/input.hpp
+++ b/include/seqan3/io/sequence_file/input.hpp
@@ -28,7 +28,7 @@
 #include <seqan3/alphabet/quality/phred42.hpp>
 #include <seqan3/alphabet/quality/qualified.hpp>
 #include <seqan3/core/detail/pack_algorithm.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/io/stream/concept.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/std/filesystem>
@@ -551,7 +551,7 @@ class sequence_file_input
         primary_stream{&stream, stream_deleter_noop},
         format{detail::sequence_file_input_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
 
         // possibly add intermediate compression stream
@@ -567,7 +567,7 @@ class sequence_file_input
         primary_stream{new stream_t{std::move(stream)}, stream_deleter_default},
         format{detail::sequence_file_input_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
 
         // possibly add intermediate compression stream
diff --git a/include/seqan3/io/sequence_file/output.hpp b/include/seqan3/io/sequence_file/output.hpp
index 4f7222b8d9..633594bb5a 100644
--- a/include/seqan3/io/sequence_file/output.hpp
+++ b/include/seqan3/io/sequence_file/output.hpp
@@ -23,8 +23,7 @@
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
 #include <seqan3/core/detail/pack_algorithm.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/io/stream/concept.hpp>
 #include <seqan3/io/exception.hpp>
@@ -299,7 +298,7 @@ class sequence_file_output
         secondary_stream{&stream, stream_deleter_noop},
         format{detail::sequence_file_output_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
     }
 
@@ -313,7 +312,7 @@ class sequence_file_output
         secondary_stream{&*primary_stream, stream_deleter_noop},
         format{detail::sequence_file_output_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
     }
     //!\}
diff --git a/include/seqan3/io/structure_file/input.hpp b/include/seqan3/io/structure_file/input.hpp
index cde31d2e6d..7a738cdd22 100644
--- a/include/seqan3/io/structure_file/input.hpp
+++ b/include/seqan3/io/structure_file/input.hpp
@@ -31,7 +31,7 @@
 #include <seqan3/alphabet/nucleotide/rna15.hpp>
 #include <seqan3/alphabet/nucleotide/rna5.hpp>
 #include <seqan3/alphabet/structure/all.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/io/stream/concept.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/std/filesystem>
@@ -803,7 +803,7 @@ class structure_file_input
         primary_stream{&stream, stream_deleter_noop},
         format{detail::structure_file_input_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
 
         // possibly add intermediate decompression stream
@@ -818,7 +818,7 @@ class structure_file_input
         primary_stream{new stream_t{std::move(stream)}, stream_deleter_default},
         format{detail::structure_file_input_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
 
         // possibly add intermediate compression stream
diff --git a/include/seqan3/io/structure_file/output.hpp b/include/seqan3/io/structure_file/output.hpp
index 472eb55c3d..bd929115fc 100644
--- a/include/seqan3/io/structure_file/output.hpp
+++ b/include/seqan3/io/structure_file/output.hpp
@@ -25,8 +25,7 @@
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
 #include <seqan3/alphabet/structure/all.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/type_list/traits.hpp>
 #include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/io/stream/concept.hpp>
 #include <seqan3/io/exception.hpp>
@@ -304,7 +303,7 @@ class structure_file_output
         secondary_stream{&stream, stream_deleter_noop},
         format{detail::structure_file_output_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
     }
 
@@ -317,7 +316,7 @@ class structure_file_output
         secondary_stream{&*primary_stream, stream_deleter_noop},
         format{detail::structure_file_output_format_REMOVEME<file_format>{}}
     {
-        static_assert(meta::in<valid_formats, file_format>::value,
+        static_assert(list_traits::contains<file_format, valid_formats>,
                       "You selected a format that is not in the valid_formats of this file.");
     }
     //!\}
diff --git a/test/unit/alignment/scoring_scheme_test.cpp b/test/unit/alignment/scoring_scheme_test.cpp
index 11cd9863f0..a67666c928 100644
--- a/test/unit/alignment/scoring_scheme_test.cpp
+++ b/test/unit/alignment/scoring_scheme_test.cpp
@@ -17,6 +17,7 @@
 #include <seqan3/alphabet/aminoacid/all.hpp>
 #include <seqan3/alphabet/nucleotide/all.hpp>
 #include <seqan3/alphabet/quality/all.hpp>
+#include <seqan3/core/detail/pack_algorithm.hpp>
 #include <seqan3/core/type_list/type_list.hpp>
 #include <seqan3/test/cereal.hpp>
 
@@ -250,9 +251,9 @@ TYPED_TEST(generic, convertability)
     if constexpr (detail::is_type_specialisation_of_v<TypeParam, aminoacid_scoring_scheme>)
     {
         using aa_types = type_list<aa27, aa20>;
-        meta::for_each(aa_types{}, [&] (auto && aa) constexpr
+        detail::for_each<aa_types>([&] (auto aa) constexpr
         {
-            using nucl_t = std::decay_t<decltype(aa)>;
+            using nucl_t = std::decay_t<typename decltype(aa)::type>;
 
             EXPECT_EQ(scheme.score('C'_aa27,                  'G'_aa27),
                       scheme.score(nucl_t{}.assign_char('C'), nucl_t{}.assign_char('G')));
@@ -263,9 +264,9 @@ TYPED_TEST(generic, convertability)
     {
 
         using nucl_types = type_list<dna4, dna5, dna15, rna4, rna5, rna15>;
-        meta::for_each(nucl_types{}, [&] (auto && nucl) constexpr
+        detail::for_each<nucl_types>([&] (auto nucl) constexpr
         {
-            using nucl_t = std::decay_t<decltype(nucl)>;
+            using nucl_t = std::decay_t<typename decltype(nucl)::type>;
 
             EXPECT_EQ(scheme.score('C'_dna15,                 'G'_dna15),
                       scheme.score(nucl_t{}.assign_char('C'), nucl_t{}.assign_char('G')));
diff --git a/test/unit/alphabet/aminoacid/aminoacid_conversion_integration_test.cpp b/test/unit/alphabet/aminoacid/aminoacid_conversion_integration_test.cpp
index 30c7273184..ba7320896b 100644
--- a/test/unit/alphabet/aminoacid/aminoacid_conversion_integration_test.cpp
+++ b/test/unit/alphabet/aminoacid/aminoacid_conversion_integration_test.cpp
@@ -10,6 +10,7 @@
 #include <meta/meta.hpp>
 
 #include <seqan3/alphabet/aminoacid/all.hpp>
+#include <seqan3/core/detail/pack_algorithm.hpp>
 #include <seqan3/core/type_list/type_list.hpp>
 
 using namespace seqan3;
@@ -25,9 +26,9 @@ TYPED_TEST_CASE(aminoacid_conversion, aminoacid_gtest_types);
 // conversion to any other amino acid type
 TYPED_TEST(aminoacid_conversion, explicit_conversion)
 {
-    meta::for_each(aminoacid_types{}, [&] (auto && aa) constexpr
+    detail::for_each<aminoacid_types>([&] (auto aa) constexpr
     {
-        using out_type = std::decay_t<decltype(aa)>;
+        using out_type = std::decay_t<typename decltype(aa)::type>;
         EXPECT_EQ(static_cast<out_type>(TypeParam{}.assign_char('A')), out_type{}.assign_char('A'));
         EXPECT_EQ(static_cast<out_type>(TypeParam{}.assign_char('C')), out_type{}.assign_char('C'));
         EXPECT_EQ(static_cast<out_type>(TypeParam{}.assign_char('F')), out_type{}.assign_char('F'));
diff --git a/test/unit/alphabet/nucleotide/nucleotide_conversion_integration_test.cpp b/test/unit/alphabet/nucleotide/nucleotide_conversion_integration_test.cpp
index 3c8d6fd911..db80352f94 100644
--- a/test/unit/alphabet/nucleotide/nucleotide_conversion_integration_test.cpp
+++ b/test/unit/alphabet/nucleotide/nucleotide_conversion_integration_test.cpp
@@ -10,6 +10,7 @@
 #include <meta/meta.hpp>
 
 #include <seqan3/alphabet/nucleotide/all.hpp>
+#include <seqan3/core/detail/pack_algorithm.hpp>
 #include <seqan3/core/type_list/type_list.hpp>
 
 using namespace seqan3;
@@ -26,9 +27,9 @@ TYPED_TEST_CASE(nucleotide_conversion, nucleotide_gtest_types);
 // conversion to any other nucleotide type
 TYPED_TEST(nucleotide_conversion, explicit_conversion)
 {
-    meta::for_each(nucleotide_types{}, [&] (auto && nucl) constexpr
+    detail::for_each<nucleotide_types>([&] (auto nucl) constexpr
     {
-        using out_type = std::decay_t<decltype(nucl)>;
+        using out_type = std::decay_t<typename decltype(nucl)::type>;
         EXPECT_EQ(static_cast<out_type>(TypeParam{}.assign_char('A')), out_type{}.assign_char('A'));
         EXPECT_EQ(static_cast<out_type>(TypeParam{}.assign_char('C')), out_type{}.assign_char('C'));
         EXPECT_EQ(static_cast<out_type>(TypeParam{}.assign_char('G')), out_type{}.assign_char('G'));
diff --git a/test/unit/alphabet/quality/quality_conversion_integration_test.cpp b/test/unit/alphabet/quality/quality_conversion_integration_test.cpp
index a5d30d25c8..f5ebaab813 100644
--- a/test/unit/alphabet/quality/quality_conversion_integration_test.cpp
+++ b/test/unit/alphabet/quality/quality_conversion_integration_test.cpp
@@ -12,6 +12,7 @@
 
 #include <gtest/gtest.h>
 
+#include <seqan3/core/detail/pack_algorithm.hpp>
 #include <seqan3/alphabet/quality/all.hpp>
 
 using namespace seqan3;
@@ -27,9 +28,9 @@ TYPED_TEST_CASE(quality_conversion, quality_conversion_gtest_types);
 
 TYPED_TEST(quality_conversion, explicit_conversion)
 {
-    meta::for_each(quality_conversion_types{}, [&] (auto && qual) constexpr
+    detail::for_each<quality_conversion_types>([&] (auto qual) constexpr
     {
-        using out_type = std::decay_t<decltype(qual)>;
+        using out_type = std::decay_t<typename decltype(qual)::type>;
         EXPECT_EQ(static_cast<out_type>(TypeParam{ 0}), out_type{ 0});
         EXPECT_EQ(static_cast<out_type>(TypeParam{ 5}), out_type{ 5});
         EXPECT_EQ(static_cast<out_type>(TypeParam{15}), out_type{15});
diff --git a/test/unit/core/type_list_test.cpp b/test/unit/core/type_list_test.cpp
index abf2e80512..05f55db68b 100644
--- a/test/unit/core/type_list_test.cpp
+++ b/test/unit/core/type_list_test.cpp
@@ -12,8 +12,7 @@
 #include <gtest/gtest.h>
 
 #include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_list/type_list.hpp>
-#include <seqan3/core/type_list/traits.hpp>
+#include <seqan3/core/type_list/all.hpp>
 
 using namespace seqan3;
 
@@ -21,7 +20,7 @@ TEST(type_list, basic)
 {
     using t = type_list<int, char, double>;
 
-    EXPECT_TRUE((std::is_same_v<meta::at_c<t, 1>, char>));
+    EXPECT_TRUE((std::is_same_v<list_traits::at<1, t>, char>));
 }
 
 // ----------------------------------------------------------------------------
diff --git a/test/unit/core/type_traits/range_iterator_test.cpp b/test/unit/core/type_traits/range_iterator_test.cpp
index 3aee2d3ef4..983137005e 100644
--- a/test/unit/core/type_traits/range_iterator_test.cpp
+++ b/test/unit/core/type_traits/range_iterator_test.cpp
@@ -13,6 +13,7 @@
 #include <meta/meta.hpp>
 
 
+#include <seqan3/core/type_list/all.hpp>
 #include <seqan3/core/type_traits/all.hpp>
 #include <seqan3/core/detail/reflection.hpp>
 #include <seqan3/range/shortcuts.hpp>
@@ -55,11 +56,11 @@ TEST(range_and_iterator, sentinel_)
 template <typename list1, typename list2, size_t pos = 0>
 void expect_same_types()
 {
-    constexpr bool val = std::is_same_v<meta::at_c<list1, pos>, meta::at_c<list2, pos>>;
+    constexpr bool val = std::is_same_v<list_traits::at<pos, list1>, list_traits::at<pos, list2>>;
     if constexpr (!val)
     {
-        std::cerr << "pos: " << pos << " \'" << detail::get_display_name_v<meta::at_c<list1, pos>>
-                  << "\' not equal to \'" << detail::get_display_name_v<meta::at_c<list2, pos>> << "\' \n";
+        std::cerr << "pos: " << pos << " \'" << detail::get_display_name_v<list_traits::at<pos, list1>>
+                  << "\' not equal to \'" << detail::get_display_name_v<list_traits::at<pos, list2>> << "\' \n";
     }
     EXPECT_TRUE(val);
 
@@ -71,93 +72,93 @@ TEST(range_and_iterator, value_type_)
 {
     using foreign_iterator = detail::random_access_iterator<std::vector<int>>;
     auto v = std::views::iota(1);
-    using type_list = meta::list<value_type_t<std::vector<int>>,                    // short
-                                 typename value_type<std::vector<int>>::type,       // long
-                                 typename std::vector<int>::value_type,             // member type
-                                 value_type_t<std::vector<int> const>,              // const container
-                                 value_type_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
-                                 value_type_t<foreign_iterator>,                    // iterator2
-                                 value_type_t<decltype(v)>>;                        // range, no member
-    using comp_list = meta::list<int,
-                                 int,
-                                 int,
-                                 int,
-                                 int,
-                                 int,
-                                 int>;
-
-    expect_same_types<type_list, comp_list>();
+    using type_list_example = type_list<value_type_t<std::vector<int>>,                          // short
+                                        typename value_type<std::vector<int>>::type,             // long
+                                        typename std::vector<int>::value_type,                   // member type
+                                        value_type_t<std::vector<int> const>,                    // const container
+                                        value_type_t<std::ranges::iterator_t<std::vector<int>>>, // iterator
+                                        value_type_t<foreign_iterator>,                          // iterator2
+                                        value_type_t<decltype(v)>>;                              // range, no member
+    using comp_list = type_list<int,
+                                int,
+                                int,
+                                int,
+                                int,
+                                int,
+                                int>;
+
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, reference_)
 {
     using foreign_iterator = detail::random_access_iterator<std::vector<int>>;
     auto v = std::views::iota(1);
-    using type_list = meta::list<reference_t<std::vector<int>>,                    // short
-                                 typename reference<std::vector<int>>::type,       // long
-                                 typename std::vector<int>::reference,             // member type
-                                 reference_t<std::vector<int> const>,              // const container
-                                 reference_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
-                                 reference_t<foreign_iterator>,                    // iterator2
-                                 reference_t<decltype(v)>>;                        // range, no member
-
-    using comp_list = meta::list<int &,
-                                 int &,
-                                 int &,
-                                 int const &,   // container is const
-                                 int &,
-                                 int &,
-                                 int>;          // view creates values
-
-    expect_same_types<type_list, comp_list>();
+    using type_list_example = type_list<reference_t<std::vector<int>>,                          // short
+                                        typename reference<std::vector<int>>::type,             // long
+                                        typename std::vector<int>::reference,                   // member type
+                                        reference_t<std::vector<int> const>,                    // const container
+                                        reference_t<std::ranges::iterator_t<std::vector<int>>>, // iterator
+                                        reference_t<foreign_iterator>,                          // iterator2
+                                        reference_t<decltype(v)>>;                              // range, no member
+
+    using comp_list = type_list<int &,
+                                int &,
+                                int &,
+                                int const &,   // container is const
+                                int &,
+                                int &,
+                                int>;          // view creates values
+
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, rvalue_reference_)
 {
     using foreign_iterator = detail::random_access_iterator<std::vector<int>>;
     auto v = std::views::iota(1);
-    using type_list = meta::list<rvalue_reference_t<std::vector<int>>,                    // short
-                                 typename rvalue_reference<std::vector<int>>::type,       // long
+    using type_list_example = type_list<rvalue_reference_t<std::vector<int>>,                          // short
+                                        typename rvalue_reference<std::vector<int>>::type,             // long
 // No types have member,yet:
-//                                  typename std::vector<int>::rvalue_reference,             // member type
-                                 rvalue_reference_t<std::vector<int> const>,              // const container
-                                 rvalue_reference_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
-                                 rvalue_reference_t<foreign_iterator>,                    // iterator2
-                                 rvalue_reference_t<decltype(v)>>;                        // range, no member
-
-    using comp_list = meta::list<int &&,
-                                 int &&,
-//                                  int &&,
-                                 int const &&,  // container is const
-                                 int &&,
-                                 int &&,
-                                 int>;          // view creates values
-
-    expect_same_types<type_list, comp_list>();
+//                                      typename std::vector<int>::rvalue_reference,                   // member type
+                                        rvalue_reference_t<std::vector<int> const>,                    // const container
+                                        rvalue_reference_t<std::ranges::iterator_t<std::vector<int>>>, // iterator
+                                        rvalue_reference_t<foreign_iterator>,                          // iterator2
+                                        rvalue_reference_t<decltype(v)>>;                              // range, no member
+
+    using comp_list = type_list<int &&,
+                                int &&,
+//                              int &&,
+                                int const &&,  // container is const
+                                int &&,
+                                int &&,
+                                int>;          // view creates values
+
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, const_reference_)
 {
 //     using foreign_iterator = detail::random_access_iterator<std::vector<int>>;
     auto v = std::views::iota(1);
-    using type_list = meta::list<const_reference_t<std::vector<int>>,                    // short
-                                 typename const_reference<std::vector<int>>::type,       // long
-                                 typename std::vector<int>::const_reference,             // member type
-                                 const_reference_t<std::vector<int> const>,              // const container
+    using type_list_example = type_list<const_reference_t<std::vector<int>>,                          // short
+                                        typename const_reference<std::vector<int>>::type,             // long
+                                        typename std::vector<int>::const_reference,                   // member type
+                                        const_reference_t<std::vector<int> const>,                    // const container
 // not defined on iterators
-//                                  const_reference_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
-//                                  const_reference_t<foreign_iterator>,                    // iterator2
-                                 const_reference_t<decltype(v)>>;                        // range, no member
-
-    using comp_list = meta::list<int const &,
-                                 int const &,
-                                 int const &,
-                                 int const &,  // container is const
-//                                  int const &,
-//                                  int const &,
-                                 int>;          // view creates values
-
-    expect_same_types<type_list, comp_list>();
+//                                      const_reference_t<std::ranges::iterator_t<std::vector<int>>>, // iterator
+//                                      const_reference_t<foreign_iterator>,                          // iterator2
+                                        const_reference_t<decltype(v)>>;                              // range, no member
+
+    using comp_list = type_list<int const &,
+                                int const &,
+                                int const &,
+                                int const &,  // container is const
+//                              int const &,
+//                              int const &,
+                                int>;          // view creates values
+
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, difference_type_)
@@ -165,13 +166,13 @@ TEST(range_and_iterator, difference_type_)
     //TODO(h-2): add something that actually has a different difference_type
     using foreign_iterator = detail::random_access_iterator<std::vector<int>>;
     auto v = std::views::iota(1);
-    using type_list = meta::list<difference_type_t<std::vector<int>>,                    // short
-                                 typename difference_type<std::vector<int>>::type,       // long
-                                 typename std::vector<int>::difference_type,             // member type
-                                 difference_type_t<std::vector<int> const>,              // const container
-                                 difference_type_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
-                                 difference_type_t<foreign_iterator>,                    // iterator2
-                                 difference_type_t<decltype(v)>>;                        // range, no member
+    using type_list_example = type_list<difference_type_t<std::vector<int>>,                          // short
+                                        typename difference_type<std::vector<int>>::type,             // long
+                                        typename std::vector<int>::difference_type,                   // member type
+                                        difference_type_t<std::vector<int> const>,                    // const container
+                                        difference_type_t<std::ranges::iterator_t<std::vector<int>>>, // iterator
+                                        difference_type_t<foreign_iterator>,                          // iterator2
+                                        difference_type_t<decltype(v)>>;                              // range, no member
 
     // views::ints' difference_type is not std::ptrdiff_t, but depends on the size.
     // For infinite views, like in our case, it's std::int_fast64_t (or std::int_fast32_t on 32bit).
@@ -183,15 +184,15 @@ TEST(range_and_iterator, difference_type_)
                                                std::int_fast64_t,
                                                std::int_fast32_t>;
 
-    using comp_list = meta::list<std::ptrdiff_t,
-                                 std::ptrdiff_t,
-                                 std::ptrdiff_t,
-                                 std::ptrdiff_t,
-                                 std::ptrdiff_t,
-                                 std::ptrdiff_t,
-                                 view_int_diff_t>;
+    using comp_list = type_list<std::ptrdiff_t,
+                                std::ptrdiff_t,
+                                std::ptrdiff_t,
+                                std::ptrdiff_t,
+                                std::ptrdiff_t,
+                                std::ptrdiff_t,
+                                view_int_diff_t>;
 
-    expect_same_types<type_list, comp_list>();
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, size_type_)
@@ -200,40 +201,40 @@ TEST(range_and_iterator, size_type_)
     using foreign_iterator = detail::random_access_iterator<std::vector<int>>;
 // iota is not a sized range, but take_exactly is
     auto v = std::views::iota(0) | views::take_exactly(2);
-    using type_list = meta::list<size_type_t<std::vector<int>>,                    // short
-                                 typename size_type<std::vector<int>>::type,       // long
-                                 typename std::vector<int>::size_type,             // member type
-                                 size_type_t<std::vector<int> const>,              // const container
-                                 size_type_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
-                                 size_type_t<foreign_iterator>,                    // iterator2
-                                 size_type_t<decltype(v)>>;                        // range, no member
-
-    using comp_list = meta::list<size_t,
-                                 size_t,
-                                 size_t,
-                                 size_t,
-                                 size_t,
-                                 size_t,
-                                 size_t>;
-
-    expect_same_types<type_list, comp_list>();
+    using type_list_example = type_list<size_type_t<std::vector<int>>,                          // short
+                                        typename size_type<std::vector<int>>::type,             // long
+                                        typename std::vector<int>::size_type,                   // member type
+                                        size_type_t<std::vector<int> const>,                    // const container
+                                        size_type_t<std::ranges::iterator_t<std::vector<int>>>, // iterator
+                                        size_type_t<foreign_iterator>,                          // iterator2
+                                        size_type_t<decltype(v)>>;                              // range, no member
+
+    using comp_list = type_list<size_t,
+                                size_t,
+                                size_t,
+                                size_t,
+                                size_t,
+                                size_t,
+                                size_t>;
+
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, innermost_value_type_)
 {
-    using type_list = meta::list<typename innermost_value_type<std::vector<int>>::type,         // long
-                                 innermost_value_type_t<std::vector<int>>,                      // short
-                                 innermost_value_type_t<std::vector<std::vector<int>>>,         // two-level
-                                 innermost_value_type_t<std::ranges::iterator_t<std::vector<int>>>,          // iterator
-                                 innermost_value_type_t<std::ranges::iterator_t<std::vector<int> const>>>;   // const_iterator
-
-    using comp_list = meta::list<int,
-                                 int,
-                                 int,
-                                 int,
-                                 int>;
-
-    expect_same_types<type_list, comp_list>();
+    using type_list_example = type_list<typename innermost_value_type<std::vector<int>>::type,                    // long
+                                        innermost_value_type_t<std::vector<int>>,                                 // short
+                                        innermost_value_type_t<std::vector<std::vector<int>>>,                    // two-level
+                                        innermost_value_type_t<std::ranges::iterator_t<std::vector<int>>>,        // iterator
+                                        innermost_value_type_t<std::ranges::iterator_t<std::vector<int> const>>>; // const_iterator
+
+    using comp_list = type_list<int,
+                                int,
+                                int,
+                                int,
+                                int>;
+
+    expect_same_types<type_list_example, comp_list>();
 }
 
 TEST(range_and_iterator, dimension)