diff --git a/libs/pika/algorithms/include/pika/algorithms/traits/projected.hpp b/libs/pika/algorithms/include/pika/algorithms/traits/projected.hpp
index d3636a545..179219083 100644
--- a/libs/pika/algorithms/include/pika/algorithms/traits/projected.hpp
+++ b/libs/pika/algorithms/include/pika/algorithms/traits/projected.hpp
@@ -186,12 +186,13 @@ namespace pika { namespace parallel { namespace traits {
         };
 
         template <typename ExPolicy, typename F, typename... Projected>
-        struct is_indirect_callable<ExPolicy, F, pika::util::pack<Projected...>,
-            typename std::enable_if<pika::util::all_of<is_projected_indirect<
-                                        Projected>...>::value &&
+        struct is_indirect_callable<ExPolicy, F,
+            pika::util::detail::pack<Projected...>,
+            std::enable_if_t<pika::util::detail::all_of_v<
+                                 is_projected_indirect<Projected>...> &&
                 (!pika::is_vectorpack_execution_policy<ExPolicy>::value ||
-                    !pika::util::all_of<
-                        is_projected_zip_iterator<Projected>...>::value)>::type>
+                    !pika::util::detail::all_of_v<
+                        is_projected_zip_iterator<Projected>...>)>>
           : is_indirect_callable_impl<F,
                 typename projected_result_of_indirect<Projected>::type...>
         {
@@ -202,12 +203,13 @@ namespace pika { namespace parallel { namespace traits {
         // special handling because zip_iterator<>::reference is not a real
         // reference type.
         template <typename ExPolicy, typename F, typename... Projected>
-        struct is_indirect_callable<ExPolicy, F, pika::util::pack<Projected...>,
-            typename std::enable_if<pika::util::all_of<is_projected_indirect<
-                                        Projected>...>::value &&
+        struct is_indirect_callable<ExPolicy, F,
+            pika::util::detail::pack<Projected...>,
+            std::enable_if_t<pika::util::detail::all_of_v<
+                                 is_projected_indirect<Projected>...> &&
                 pika::is_vectorpack_execution_policy<ExPolicy>::value &&
-                pika::util::all_of<
-                    is_projected_zip_iterator<Projected>...>::value>::type>
+                pika::util::detail::all_of_v<
+                    is_projected_zip_iterator<Projected>...>>>
           : is_indirect_callable_impl<F,
                 typename projected_result_of_vector_pack<Projected>::type...>
         {
@@ -218,7 +220,7 @@ namespace pika { namespace parallel { namespace traits {
     template <typename ExPolicy, typename F, typename... Projected>
     struct is_indirect_callable
       : detail::is_indirect_callable<std::decay_t<ExPolicy>, std::decay_t<F>,
-            pika::util::pack<std::decay_t<Projected>...>>
+            pika::util::detail::pack<std::decay_t<Projected>...>>
     {
     };
 
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/fill.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/fill.hpp
index 3b3139e8a..a1c3ec297 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/fill.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/fill.hpp
@@ -258,7 +258,7 @@ namespace pika {
                 typename pika::parallel::util::detail::algorithm_result<
                     ExPolicy>::type;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::fill<FwdIter>().call(
                        PIKA_FORWARD(ExPolicy, policy), first, last, value);
         }
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/for_loop.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/for_loop.hpp
index 57dd6876d..3e1d19043 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/for_loop.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/for_loop.hpp
@@ -767,7 +767,7 @@ namespace pika {
             ///////////////////////////////////////////////////////////////////////
             template <typename... Ts, std::size_t... Is>
             PIKA_HOST_DEVICE PIKA_FORCEINLINE constexpr void init_iteration(
-                std::tuple<Ts...>& args, pika::util::index_pack<Is...>,
+                std::tuple<Ts...>& args, pika::util::detail::index_pack<Is...>,
                 std::size_t part_index) noexcept
             {
                 int const _sequencer[] = {
@@ -777,8 +777,8 @@ namespace pika {
 
             template <typename... Ts, std::size_t... Is, typename F, typename B>
             PIKA_HOST_DEVICE PIKA_FORCEINLINE constexpr void invoke_iteration(
-                std::tuple<Ts...>& args, pika::util::index_pack<Is...>, F&& f,
-                B part_begin)
+                std::tuple<Ts...>& args, pika::util::detail::index_pack<Is...>,
+                F&& f, B part_begin)
             {
                 PIKA_INVOKE(PIKA_FORWARD(F, f), part_begin,
                     std::get<Is>(args).iteration_value()...);
@@ -786,7 +786,8 @@ namespace pika {
 
             template <typename... Ts, std::size_t... Is>
             PIKA_HOST_DEVICE PIKA_FORCEINLINE constexpr void next_iteration(
-                std::tuple<Ts...>& args, pika::util::index_pack<Is...>) noexcept
+                std::tuple<Ts...>& args,
+                pika::util::detail::index_pack<Is...>) noexcept
             {
                 int const _sequencer[] = {
                     0, (std::get<Is>(args).next_iteration(), 0)...};
@@ -795,7 +796,7 @@ namespace pika {
 
             template <typename... Ts, std::size_t... Is>
             PIKA_HOST_DEVICE PIKA_FORCEINLINE constexpr void exit_iteration(
-                std::tuple<Ts...>& args, pika::util::index_pack<Is...>,
+                std::tuple<Ts...>& args, pika::util::detail::index_pack<Is...>,
                 std::size_t size) noexcept
             {
                 int const _sequencer[] = {
@@ -830,8 +831,9 @@ namespace pika {
                     B part_begin, std::size_t part_steps,
                     std::size_t part_index)
                 {
-                    auto pack = typename pika::util::make_index_pack<sizeof...(
-                        Ts)>::type();
+                    auto pack =
+                        typename pika::util::detail::make_index_pack<sizeof...(
+                            Ts)>::type();
                     detail::init_iteration(args_, pack, part_index);
 
                     if (stride_ == 1)
@@ -982,9 +984,10 @@ namespace pika {
 
                 template <typename ExPolicy, typename InIter, typename S,
                     typename F>
-                PIKA_HOST_DEVICE static constexpr pika::util::unused_type
-                sequential(ExPolicy&&, InIter first, std::size_t count,
-                    S stride, F&& f)
+                PIKA_HOST_DEVICE static constexpr pika::util::detail::
+                    unused_type
+                    sequential(ExPolicy&&, InIter first, std::size_t count,
+                        S stride, F&& f)
                 {
                     if (stride == 1)
                     {
@@ -1022,14 +1025,15 @@ namespace pika {
                         }
                     }
 
-                    return pika::util::unused_type();
+                    return pika::util::detail::unused_type();
                 }
 
                 template <typename ExPolicy, typename InIter, typename Size,
                     typename S, typename F, typename Arg, typename... Args>
-                PIKA_HOST_DEVICE static constexpr pika::util::unused_type
-                sequential(ExPolicy&&, InIter first, Size size, S stride, F&& f,
-                    Arg&& arg, Args&&... args)
+                PIKA_HOST_DEVICE static constexpr pika::util::detail::
+                    unused_type
+                    sequential(ExPolicy&&, InIter first, Size size, S stride,
+                        F&& f, Arg&& arg, Args&&... args)
                 {
                     int const init_sequencer[] = {(arg.init_iteration(0), 0),
                         (args.init_iteration(0), 0)...};
@@ -1080,7 +1084,7 @@ namespace pika {
                         (args.exit_iteration(size), 0)...};
                     (void) exit_sequencer;
 
-                    return pika::util::unused_type();
+                    return pika::util::detail::unused_type();
                 }
 
                 template <typename ExPolicy, typename B, typename Size,
@@ -1102,14 +1106,14 @@ namespace pika {
                                 PIKA_FORWARD(ExPolicy, policy), first, size,
                                 part_iterations<ExPolicy, F, S>{
                                     PIKA_FORWARD(F, f)},
-                                pika::util::empty_function{});
+                                pika::util::detail::empty_function{});
                         }
 
                         return util::partitioner<ExPolicy>::call_with_index(
                             PIKA_FORWARD(ExPolicy, policy), first, size, stride,
                             part_iterations<ExPolicy, F, S>{
                                 PIKA_FORWARD(F, f), stride},
-                            pika::util::empty_function{});
+                            pika::util::detail::empty_function{});
                     }
                     else
                     {
@@ -1126,9 +1130,8 @@ namespace pika {
                                 PIKA_FORWARD(F, f), stride, args},
                             [=](std::vector<pika::future<void>>&&) mutable
                             -> void {
-                                auto pack =
-                                    typename pika::util::make_index_pack<
-                                        sizeof...(Ts)>::type();
+                                auto pack = typename pika::util::detail::
+                                    make_index_pack<sizeof...(Ts)>::type();
                                 // make sure live-out variables are properly set on
                                 // return
                                 detail::exit_iteration(args, pack, size);
@@ -1142,7 +1145,7 @@ namespace pika {
                 std::size_t... Is, typename... Args>
             typename util::detail::algorithm_result<ExPolicy>::type for_loop(
                 ExPolicy&& policy, B first, E last, S stride,
-                pika::util::index_pack<Is...>, Args&&... args)
+                pika::util::detail::index_pack<Is...>, Args&&... args)
             {
                 // stride shall not be zero
                 PIKA_ASSERT(stride != 0);
@@ -1173,7 +1176,7 @@ namespace pika {
                 std::size_t... Is, typename... Args>
             typename util::detail::algorithm_result<ExPolicy>::type for_loop_n(
                 ExPolicy&& policy, B first, Size size, S stride,
-                pika::util::index_pack<Is...>, Args&&... args)
+                pika::util::detail::index_pack<Is...>, Args&&... args)
             {
                 // stride shall not be zero
                 PIKA_ASSERT(stride != 0);
@@ -1221,7 +1224,7 @@ namespace pika {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(
                 PIKA_FORWARD(ExPolicy, policy), first, last, 1,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -1241,7 +1244,7 @@ namespace pika {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(pika::execution::seq, first,
                 last, 1, typename make_index_pack<sizeof...(Args) - 1>::type(),
                 PIKA_FORWARD(Args, args)...);
@@ -1270,7 +1273,7 @@ namespace pika {
                 "for_loop_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(
                 PIKA_FORWARD(ExPolicy, policy), first, last, stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -1292,7 +1295,7 @@ namespace pika {
                 "for_loop_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(pika::execution::seq, first,
                 last, stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -1322,7 +1325,7 @@ namespace pika {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop_n must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop_n(
                 PIKA_FORWARD(ExPolicy, policy), first, size, 1,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -1343,7 +1346,7 @@ namespace pika {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop_n must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop_n(pika::execution::seq, first,
                 size, 1, typename make_index_pack<sizeof...(Args) - 1>::type(),
                 PIKA_FORWARD(Args, args)...);
@@ -1374,7 +1377,7 @@ namespace pika {
                 "for_loop_n_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop_n(
                 PIKA_FORWARD(ExPolicy, policy), first, size, stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -1397,7 +1400,7 @@ namespace pika {
                 "for_loop_n_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop_n(pika::execution::seq, first,
                 size, stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/nth_element.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/nth_element.hpp
index c92c219e5..d9bcc2cd7 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/nth_element.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/nth_element.hpp
@@ -392,7 +392,7 @@ namespace pika {
             using result_type =
                 pika::parallel::util::detail::algorithm_result_t<ExPolicy>;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::nth_element<RandomIt>().call(
                        PIKA_FORWARD(ExPolicy, policy), first, nth, last,
                        PIKA_FORWARD(Pred, pred),
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/sort.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/sort.hpp
index b48d07eaa..3da7a0255 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/sort.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/sort.hpp
@@ -539,7 +539,7 @@ namespace pika {
                 typename pika::parallel::util::detail::algorithm_result<
                     ExPolicy>::type;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::sort<RandomIt>().call(
                        PIKA_FORWARD(ExPolicy, policy), first, last,
                        PIKA_FORWARD(Comp, comp), PIKA_FORWARD(Proj, proj));
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/stable_sort.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/stable_sort.hpp
index cfbe97b27..b98756ff0 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/stable_sort.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/stable_sort.hpp
@@ -401,7 +401,7 @@ namespace pika {
                 typename pika::parallel::util::detail::algorithm_result<
                     ExPolicy>::type;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::stable_sort<RandomIt>().call(
                        PIKA_FORWARD(ExPolicy, policy), first, last,
                        PIKA_FORWARD(Comp, comp), PIKA_FORWARD(Proj, proj));
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_default_construct.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_default_construct.hpp
index eeee76b1a..96093d0cb 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_default_construct.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_default_construct.hpp
@@ -421,7 +421,7 @@ namespace pika {
                 typename pika::parallel::util::detail::algorithm_result<
                     ExPolicy>::type;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::uninitialized_default_construct<
                        FwdIter>()
                        .call(PIKA_FORWARD(ExPolicy, policy), first, last);
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_fill.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_fill.hpp
index 9dc2f92b5..d23c9377d 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_fill.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_fill.hpp
@@ -424,7 +424,7 @@ namespace pika {
                 typename pika::parallel::util::detail::algorithm_result<
                     ExPolicy>::type;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::uninitialized_fill<FwdIter>()
                        .call(
                            PIKA_FORWARD(ExPolicy, policy), first, last, value);
diff --git a/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_value_construct.hpp b/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_value_construct.hpp
index 60a94ca89..f6689eea9 100644
--- a/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_value_construct.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/algorithms/uninitialized_value_construct.hpp
@@ -423,7 +423,7 @@ namespace pika {
                 typename pika::parallel::util::detail::algorithm_result<
                     ExPolicy>::type;
 
-            return pika::util::void_guard<result_type>(),
+            return pika::util::detail::void_guard<result_type>(),
                    pika::parallel::v1::detail::uninitialized_value_construct<
                        FwdIter>()
                        .call(PIKA_FORWARD(ExPolicy, policy), first, last);
diff --git a/libs/pika/algorithms/include/pika/parallel/container_algorithms/for_loop.hpp b/libs/pika/algorithms/include/pika/parallel/container_algorithms/for_loop.hpp
index eb5f4f6d1..3ea0fc50d 100644
--- a/libs/pika/algorithms/include/pika/parallel/container_algorithms/for_loop.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/container_algorithms/for_loop.hpp
@@ -752,7 +752,7 @@ namespace pika { namespace ranges {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(
                 PIKA_FORWARD(ExPolicy, policy), first, last, 1,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -772,7 +772,7 @@ namespace pika { namespace ranges {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(pika::execution::seq, first,
                 last, 1, typename make_index_pack<sizeof...(Args) - 1>::type(),
                 PIKA_FORWARD(Args, args)...);
@@ -792,7 +792,7 @@ namespace pika { namespace ranges {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(
                 PIKA_FORWARD(ExPolicy, policy), pika::util::begin(rng),
                 pika::util::end(rng), 1,
@@ -812,7 +812,7 @@ namespace pika { namespace ranges {
             static_assert(sizeof...(Args) >= 1,
                 "for_loop must be called with at least a function object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(pika::execution::seq,
                 pika::util::begin(rng), pika::util::end(rng), 1,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -842,7 +842,7 @@ namespace pika { namespace ranges {
                 "for_loop_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(
                 PIKA_FORWARD(ExPolicy, policy), first, last, stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -864,7 +864,7 @@ namespace pika { namespace ranges {
                 "for_loop_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(pika::execution::seq, first,
                 last, stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
@@ -887,7 +887,7 @@ namespace pika { namespace ranges {
                 "for_loop_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(
                 PIKA_FORWARD(ExPolicy, policy), pika::util::begin(rng),
                 pika::util::end(rng), stride,
@@ -909,7 +909,7 @@ namespace pika { namespace ranges {
                 "for_loop_strided must be called with at least a function "
                 "object");
 
-            using pika::util::make_index_pack;
+            using pika::util::detail::make_index_pack;
             return parallel::v2::detail::for_loop(pika::execution::seq,
                 pika::util::begin(rng), pika::util::end(rng), stride,
                 typename make_index_pack<sizeof...(Args) - 1>::type(),
diff --git a/libs/pika/algorithms/include/pika/parallel/datapar/zip_iterator.hpp b/libs/pika/algorithms/include/pika/parallel/datapar/zip_iterator.hpp
index 1264143c7..819433c92 100644
--- a/libs/pika/algorithms/include/pika/parallel/datapar/zip_iterator.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/datapar/zip_iterator.hpp
@@ -36,7 +36,7 @@ namespace pika { namespace parallel { namespace util { namespace detail {
         template <std::size_t... Is>
         static PIKA_FORCEINLINE bool call(
             pika::util::zip_iterator<Iter...> const& it,
-            pika::util::index_pack<Is...>)
+            pika::util::detail::index_pack<Is...>)
         {
             auto const& t = it.get_iterator_tuple();
             bool const sequencer[] = {
@@ -48,15 +48,15 @@ namespace pika { namespace parallel { namespace util { namespace detail {
         static PIKA_FORCEINLINE bool call(
             pika::util::zip_iterator<Iter...> const& it)
         {
-            return call(it,
-                typename pika::util::make_index_pack<sizeof...(Iter)>::type());
+            return call(
+                it, pika::util::detail::make_index_pack_t<sizeof...(Iter)>());
         }
     };
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename... Iter>
     struct iterator_datapar_compatible_impl<pika::util::zip_iterator<Iter...>>
-      : pika::util::all_of<std::is_arithmetic<
+      : pika::util::detail::all_of<std::is_arithmetic<
             typename std::iterator_traits<Iter>::value_type>...>
     {
     };
@@ -68,7 +68,7 @@ namespace pika { namespace parallel { namespace traits {
     namespace detail {
         template <typename Tuple, typename... Iter, std::size_t... Is>
         Tuple aligned_pack(pika::util::zip_iterator<Iter...> const& iter,
-            pika::util::index_pack<Is...>)
+            pika::util::detail::index_pack<Is...>)
         {
             auto const& t = iter.get_iterator_tuple();
             return std::make_tuple(
@@ -79,7 +79,7 @@ namespace pika { namespace parallel { namespace traits {
 
         template <typename Tuple, typename... Iter, std::size_t... Is>
         Tuple unaligned_pack(pika::util::zip_iterator<Iter...> const& iter,
-            pika::util::index_pack<Is...>)
+            pika::util::detail::index_pack<Is...>)
         {
             auto const& t = iter.get_iterator_tuple();
             return std::make_tuple(
@@ -97,16 +97,16 @@ namespace pika { namespace parallel { namespace traits {
         template <typename... Iter>
         static value_type aligned(pika::util::zip_iterator<Iter...> const& iter)
         {
-            return traits::detail::aligned_pack<value_type>(iter,
-                typename pika::util::make_index_pack<sizeof...(Iter)>::type());
+            return traits::detail::aligned_pack<value_type>(
+                iter, pika::util::detail::make_index_pack_t<sizeof...(Iter)>());
         }
 
         template <typename... Iter>
         static value_type unaligned(
             pika::util::zip_iterator<Iter...> const& iter)
         {
-            return traits::detail::unaligned_pack<value_type>(iter,
-                typename pika::util::make_index_pack<sizeof...(Iter)>::type());
+            return traits::detail::unaligned_pack<value_type>(
+                iter, pika::util::detail::make_index_pack<sizeof...(Iter)>());
         }
     };
 
@@ -115,7 +115,7 @@ namespace pika { namespace parallel { namespace traits {
         template <typename Tuple, typename... Iter, std::size_t... Is>
         void aligned_pack(Tuple& value,
             pika::util::zip_iterator<Iter...> const& iter,
-            pika::util::index_pack<Is...>)
+            pika::util::detail::index_pack<Is...>)
         {
             auto const& t = iter.get_iterator_tuple();
             int const sequencer[] = {0,
@@ -129,7 +129,7 @@ namespace pika { namespace parallel { namespace traits {
         template <typename Tuple, typename... Iter, std::size_t... Is>
         void unaligned_pack(Tuple& value,
             pika::util::zip_iterator<Iter...> const& iter,
-            pika::util::index_pack<Is...>)
+            pika::util::detail::index_pack<Is...>)
         {
             auto const& t = iter.get_iterator_tuple();
             int const sequencer[] = {0,
@@ -149,7 +149,7 @@ namespace pika { namespace parallel { namespace traits {
             V& value, pika::util::zip_iterator<Iter...> const& iter)
         {
             traits::detail::aligned_pack(value, iter,
-                typename pika::util::make_index_pack<sizeof...(Iter)>::type());
+                pika::util::detail::make_index_pack_t<sizeof...(Iter)>());
         }
 
         template <typename V, typename... Iter>
@@ -157,7 +157,7 @@ namespace pika { namespace parallel { namespace traits {
             V& value, pika::util::zip_iterator<Iter...> const& iter)
         {
             traits::detail::unaligned_pack(value, iter,
-                typename pika::util::make_index_pack<sizeof...(Iter)>::type());
+                pika::util::detail::make_index_pack<sizeof...(Iter)>());
         }
     };
 }}}    // namespace pika::parallel::traits
diff --git a/libs/pika/algorithms/include/pika/parallel/spmd_block.hpp b/libs/pika/algorithms/include/pika/parallel/spmd_block.hpp
index e533a70c5..e2ca3d791 100644
--- a/libs/pika/algorithms/include/pika/parallel/spmd_block.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/spmd_block.hpp
@@ -125,7 +125,7 @@ namespace pika { namespace lcos { namespace local {
 
         template <typename... I>
         typename std::enable_if<
-            util::all_of<typename std::is_integral<I>::type...>::value>::type
+            util::detail::all_of_v<typename std::is_integral<I>::type...>>::type
         sync_images(I... i) const
         {
             std::set<std::size_t> images = {(std::size_t) i...};
diff --git a/libs/pika/algorithms/include/pika/parallel/util/detail/algorithm_result.hpp b/libs/pika/algorithms/include/pika/parallel/util/detail/algorithm_result.hpp
index 8fcf0be5b..a596f071a 100644
--- a/libs/pika/algorithms/include/pika/parallel/util/detail/algorithm_result.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/util/detail/algorithm_result.hpp
@@ -52,7 +52,7 @@ namespace pika { namespace parallel { namespace util { namespace detail {
         // Obtain initiating function's return type.
         static constexpr void get() noexcept {}
 
-        static constexpr void get(pika::util::unused_type) noexcept {}
+        static constexpr void get(pika::util::detail::unused_type) noexcept {}
 
         static void get(pika::future<void>&& t)
         {
@@ -96,7 +96,7 @@ namespace pika { namespace parallel { namespace util { namespace detail {
             return pika::make_ready_future();
         }
 
-        static type get(pika::util::unused_type)
+        static type get(pika::util::detail::unused_type)
         {
             return pika::make_ready_future();
         }
@@ -143,7 +143,7 @@ namespace pika { namespace parallel { namespace util { namespace detail {
             return pika::make_ready_future();
         }
 
-        static type get(pika::util::unused_type)
+        static type get(pika::util::detail::unused_type)
         {
             return pika::make_ready_future();
         }
diff --git a/libs/pika/algorithms/include/pika/parallel/util/partitioner.hpp b/libs/pika/algorithms/include/pika/parallel/util/partitioner.hpp
index e12da06eb..afba1555b 100644
--- a/libs/pika/algorithms/include/pika/parallel/util/partitioner.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/util/partitioner.hpp
@@ -280,7 +280,7 @@ namespace pika { namespace parallel { namespace util {
 
             static R reduce(std::vector<pika::future<Result>>&& workitems,
                 std::list<std::exception_ptr>&& errors,
-                pika::util::empty_function)
+                pika::util::detail::empty_function)
             {
                 // wait for all tasks to finish
                 pika::wait_all_nothrow(workitems);
diff --git a/libs/pika/algorithms/include/pika/parallel/util/prefetching.hpp b/libs/pika/algorithms/include/pika/parallel/util/prefetching.hpp
index 9ee0590c9..a2e17f6ca 100644
--- a/libs/pika/algorithms/include/pika/parallel/util/prefetching.hpp
+++ b/libs/pika/algorithms/include/pika/parallel/util/prefetching.hpp
@@ -262,14 +262,14 @@ namespace pika { namespace parallel { namespace util {
 
         template <typename... Ts, std::size_t... Is>
         PIKA_FORCEINLINE void prefetch_containers(std::tuple<Ts...> const& t,
-            pika::util::index_pack<Is...>, std::size_t idx)
+            pika::util::detail::index_pack<Is...>, std::size_t idx)
         {
             prefetch_addresses((std::get<Is>(t).get())[idx]...);
         }
 #else
         template <typename... Ts, std::size_t... Is>
         PIKA_FORCEINLINE void prefetch_containers(std::tuple<Ts...> const& t,
-            pika::util::index_pack<Is...>, std::size_t idx)
+            pika::util::detail::index_pack<Is...>, std::size_t idx)
         {
             int const sequencer[] = {(std::get<Is>(t).get()[idx], 0)..., 0};
             (void) sequencer;
@@ -285,7 +285,8 @@ namespace pika { namespace parallel { namespace util {
                 Pred)
             {
                 using index_pack_type =
-                    typename pika::util::make_index_pack<sizeof...(Ts)>::type;
+                    typename pika::util::detail::make_index_pack<sizeof...(
+                        Ts)>::type;
 
                 for (/**/; count != 0; (void) --count, ++it)
                 {
@@ -318,7 +319,8 @@ namespace pika { namespace parallel { namespace util {
                 CancelToken& tok, F&& f, Pred)
             {
                 using index_pack_type =
-                    typename pika::util::make_index_pack<sizeof...(Ts)>::type;
+                    typename pika::util::detail::make_index_pack<sizeof...(
+                        Ts)>::type;
 
                 for (/**/; count != 0; (void) --count, ++it)
                 {
@@ -368,7 +370,8 @@ namespace pika { namespace parallel { namespace util {
                 Pred)
             {
                 using index_pack_type =
-                    typename pika::util::make_index_pack<sizeof...(Ts)>::type;
+                    typename pika::util::detail::make_index_pack<sizeof...(
+                        Ts)>::type;
 
                 for (/**/; count != 0; (void) --count, ++it)
                 {
@@ -401,7 +404,8 @@ namespace pika { namespace parallel { namespace util {
                 CancelToken& tok, F&& f, Pred)
             {
                 using index_pack_type =
-                    typename pika::util::make_index_pack<sizeof...(Ts)>::type;
+                    typename pika::util::detail::make_index_pack<sizeof...(
+                        Ts)>::type;
 
                 for (/**/; count != 0; (void) --count, ++it)
                 {
@@ -451,7 +455,8 @@ namespace pika { namespace parallel { namespace util {
     {
         static_assert(pika::traits::is_random_access_iterator<Itr>::value,
             "Iterators have to be of random access iterator category");
-        static_assert(pika::util::all_of<pika::traits::is_range<Ts>...>::value,
+        static_assert(
+            pika::util::detail::all_of_v<pika::traits::is_range<Ts>...>,
             "All variadic parameters have to represent ranges");
 
         using ranges_type = std::tuple<std::reference_wrapper<Ts const>...>;
@@ -469,7 +474,8 @@ namespace pika { namespace parallel { namespace util {
             using iterator_type = prefetching::prefetching_iterator<Itr, Ts...>;
             using type = typename iterator_type::base_iterator;
             using index_pack_type =
-                typename pika::util::make_index_pack<sizeof...(Ts)>::type;
+                typename pika::util::detail::make_index_pack<sizeof...(
+                    Ts)>::type;
 
             template <typename End, typename F>
             static iterator_type call(iterator_type it, End end, F&& f)
@@ -529,7 +535,8 @@ namespace pika { namespace parallel { namespace util {
             using iterator_type = prefetching::prefetching_iterator<Itr, Ts...>;
             using type = typename iterator_type::base_iterator;
             using index_pack_type =
-                typename pika::util::make_index_pack<sizeof...(Ts)>::type;
+                typename pika::util::detail::make_index_pack<sizeof...(
+                    Ts)>::type;
 
             template <typename End, typename F>
             static iterator_type call(iterator_type it, End end, F&& f)
diff --git a/libs/pika/algorithms/src/task_group.cpp b/libs/pika/algorithms/src/task_group.cpp
index 59fc7f5fe..f5c3c2f52 100644
--- a/libs/pika/algorithms/src/task_group.cpp
+++ b/libs/pika/algorithms/src/task_group.cpp
@@ -76,7 +76,7 @@ namespace pika::execution::experimental {
             auto state = PIKA_MOVE(state_);
             if (state)
             {
-                state->set_value(pika::util::unused);
+                state->set_value(pika::util::detail::unused);
             }
         }
     }
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/split_future.hpp b/libs/pika/async_combinators/include/pika/async_combinators/split_future.hpp
index c8448dc7d..b6cd0186d 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/split_future.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/split_future.hpp
@@ -176,7 +176,8 @@ namespace pika {
         ///////////////////////////////////////////////////////////////////////
         template <typename... Ts, std::size_t... Is>
         PIKA_FORCEINLINE std::tuple<pika::future<Ts>...> split_future_helper(
-            pika::future<std::tuple<Ts...>>&& f, pika::util::index_pack<Is...>)
+            pika::future<std::tuple<Ts...>>&& f,
+            pika::util::detail::index_pack<Is...>)
         {
             return std::make_tuple(extract_nth_future<Is>(f)...);
         }
@@ -184,7 +185,7 @@ namespace pika {
         template <typename... Ts, std::size_t... Is>
         PIKA_FORCEINLINE std::tuple<pika::future<Ts>...> split_future_helper(
             pika::shared_future<std::tuple<Ts...>>&& f,
-            pika::util::index_pack<Is...>)
+            pika::util::detail::index_pack<Is...>)
         {
             return std::make_tuple(extract_nth_future<Is>(f)...);
         }
@@ -302,7 +303,8 @@ namespace pika {
         pika::future<std::tuple<Ts...>>&& f)
     {
         return detail::split_future_helper(PIKA_MOVE(f),
-            typename pika::util::make_index_pack<sizeof...(Ts)>::type());
+            typename pika::util::detail::make_index_pack<sizeof...(
+                Ts)>::type());
     }
 
     PIKA_FORCEINLINE std::tuple<pika::future<void>> split_future(
@@ -316,7 +318,8 @@ namespace pika {
         pika::shared_future<std::tuple<Ts...>>&& f)
     {
         return detail::split_future_helper(PIKA_MOVE(f),
-            typename pika::util::make_index_pack<sizeof...(Ts)>::type());
+            typename pika::util::detail::make_index_pack<sizeof...(
+                Ts)>::type());
     }
 
     PIKA_FORCEINLINE std::tuple<pika::future<void>> split_future(
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/wait_all.hpp b/libs/pika/async_combinators/include/pika/async_combinators/wait_all.hpp
index faa268dc9..5906837e6 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/wait_all.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/wait_all.hpp
@@ -134,7 +134,7 @@ namespace pika {
 #include <pika/iterator_support/traits/is_iterator.hpp>
 #include <pika/memory/intrusive_ptr.hpp>
 #include <pika/type_support/decay.hpp>
-#include <pika/type_support/unwrap_ref.hpp>
+#include <pika/type_support/unwrap_reference.hpp>
 
 #include <algorithm>
 #include <array>
@@ -304,9 +304,10 @@ namespace pika {
             template <std::size_t I>
             PIKA_FORCEINLINE void await_range()
             {
-                await_range<I>(
-                    pika::util::begin(pika::util::unwrap_ref(std::get<I>(t_))),
-                    pika::util::end(pika::util::unwrap_ref(std::get<I>(t_))));
+                await_range<I>(pika::util::begin(pika::detail::unwrap_reference(
+                                   std::get<I>(t_))),
+                    pika::util::end(
+                        pika::detail::unwrap_reference(std::get<I>(t_))));
             }
 
             // Current element is a simple future
@@ -346,11 +347,11 @@ namespace pika {
                 if constexpr (is_end_v<I>)
                 {
                     // simply make ourself ready
-                    this->set_value(util::unused);
+                    this->set_value(util::detail::unused);
                 }
                 else
                 {
-                    using future_type = pika::util::decay_unwrap_t<
+                    using future_type = pika::util::detail::decay_unwrap_t<
                         typename std::tuple_element<I, Tuple>::type>;
 
                     if constexpr (is_future_or_shared_state_v<future_type>)
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/wait_each.hpp b/libs/pika/async_combinators/include/pika/async_combinators/wait_each.hpp
index a4c97d3a6..1df35a760 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/wait_each.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/wait_each.hpp
@@ -209,7 +209,7 @@ namespace pika {
     template <typename F, typename... Ts,
         typename Enable =
             std::enable_if_t<!traits::is_future_v<std::decay_t<F>> &&
-                util::all_of_v<traits::is_future<Ts>...>>>
+                util::detail::all_of_v<traits::is_future<Ts>...>>>
     void wait_each_nothrow(F&& f, Ts&&... ts)
     {
         pika::when_each(PIKA_FORWARD(F, f), PIKA_FORWARD(Ts, ts)...).wait();
@@ -218,7 +218,7 @@ namespace pika {
     template <typename F, typename... Ts,
         typename Enable =
             std::enable_if_t<!traits::is_future_v<std::decay_t<F>> &&
-                util::all_of_v<traits::is_future<Ts>...>>>
+                util::detail::all_of_v<traits::is_future<Ts>...>>>
     void wait_each(F&& f, Ts&&... ts)
     {
         auto result =
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/wait_some.hpp b/libs/pika/async_combinators/include/pika/async_combinators/wait_some.hpp
index 202dd7d3e..f0b1c9ce9 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/wait_some.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/wait_some.hpp
@@ -221,7 +221,7 @@ namespace pika {
 
             template <typename Tuple, std::size_t... Is>
             PIKA_FORCEINLINE void apply(
-                Tuple const& tuple, pika::util::index_pack<Is...>) const
+                Tuple const& tuple, pika::util::detail::index_pack<Is...>) const
             {
                 int const _sequencer[] = {
                     0, (((*this)(std::get<Is>(tuple))), 0)...};
@@ -231,7 +231,8 @@ namespace pika {
             template <typename... Ts>
             PIKA_FORCEINLINE void apply(std::tuple<Ts...> const& sequence) const
             {
-                apply(sequence, pika::util::make_index_pack_t<sizeof...(Ts)>());
+                apply(sequence,
+                    pika::util::detail::make_index_pack_t<sizeof...(Ts)>());
             }
 
             template <typename Sequence_>
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/when_any.hpp b/libs/pika/async_combinators/include/pika/async_combinators/when_any.hpp
index 32c92382f..30e3a54f8 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/when_any.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/when_any.hpp
@@ -276,7 +276,7 @@ namespace pika {
 
             template <typename Tuple, std::size_t... Is>
             PIKA_FORCEINLINE void apply(
-                Tuple& tuple, pika::util::index_pack<Is...>) const
+                Tuple& tuple, pika::util::detail::index_pack<Is...>) const
             {
                 int const _sequencer[] = {
                     (((*this)(std::get<Is>(tuple))), 0)...};
@@ -286,7 +286,8 @@ namespace pika {
             template <typename... Ts>
             PIKA_FORCEINLINE void apply(std::tuple<Ts...>& sequence) const
             {
-                apply(sequence, pika::util::make_index_pack_t<sizeof...(Ts)>());
+                apply(sequence,
+                    pika::util::detail::make_index_pack_t<sizeof...(Ts)>());
             }
 
             template <typename Sequence_>
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/when_each.hpp b/libs/pika/async_combinators/include/pika/async_combinators/when_each.hpp
index 0507fcd34..14bde35f3 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/when_each.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/when_each.hpp
@@ -137,7 +137,7 @@ namespace pika {
 #include <pika/iterator_support/range.hpp>
 #include <pika/memory/intrusive_ptr.hpp>
 #include <pika/type_support/decay.hpp>
-#include <pika/type_support/unwrap_ref.hpp>
+#include <pika/type_support/unwrap_reference.hpp>
 
 #include <algorithm>
 #include <cstddef>
@@ -189,11 +189,11 @@ namespace pika {
             {
                 if constexpr (is_end_v<I>)
                 {
-                    this->set_value(util::unused);
+                    this->set_value(util::detail::unused);
                 }
                 else
                 {
-                    using future_type = pika::util::decay_unwrap_t<
+                    using future_type = pika::util::detail::decay_unwrap_t<
                         typename std::tuple_element<I, Tuple>::type>;
 
                     if constexpr (pika::traits::is_future_v<future_type> ||
@@ -209,7 +209,8 @@ namespace pika {
                                     future_type>,
                             "element must be future or range of futures");
 
-                        auto&& curr = pika::util::unwrap_ref(std::get<I>(t_));
+                        auto&& curr =
+                            pika::detail::unwrap_reference(std::get<I>(t_));
                         await_range<I>(
                             pika::util::begin(curr), pika::util::end(curr));
                     }
@@ -269,7 +270,7 @@ namespace pika {
 
                     if (++count_ == needed_count_)
                     {
-                        this->set_value(util::unused);
+                        this->set_value(util::detail::unused);
 
                         // explicitly destruct iterators as those might
                         // become dangling after we make ourselves ready
@@ -286,7 +287,7 @@ namespace pika {
             template <std::size_t I>
             PIKA_FORCEINLINE void await_future()
             {
-                using future_type = pika::util::decay_unwrap_t<
+                using future_type = pika::util::detail::decay_unwrap_t<
                     typename std::tuple_element<I, Tuple>::type>;
 
                 pika::intrusive_ptr<when_each_frame> this_(this);
@@ -325,7 +326,7 @@ namespace pika {
 
                 if (++count_ == needed_count_)
                 {
-                    this->set_value(util::unused);
+                    this->set_value(util::detail::unused);
                     return;
                 }
 
@@ -429,7 +430,7 @@ namespace pika {
     ///////////////////////////////////////////////////////////////////////////
     template <typename F, typename... Ts>
     std::enable_if_t<!pika::traits::is_future_v<std::decay_t<F>> &&
-            pika::util::all_of_v<pika::traits::is_future<Ts>...>,
+            pika::util::detail::all_of_v<pika::traits::is_future<Ts>...>,
         pika::future<void>>
     when_each(F&& f, Ts&&... ts)
     {
diff --git a/libs/pika/async_combinators/include/pika/async_combinators/when_some.hpp b/libs/pika/async_combinators/include/pika/async_combinators/when_some.hpp
index 36970860b..c9fd3204b 100644
--- a/libs/pika/async_combinators/include/pika/async_combinators/when_some.hpp
+++ b/libs/pika/async_combinators/include/pika/async_combinators/when_some.hpp
@@ -301,7 +301,7 @@ namespace pika {
 
             template <typename Tuple, std::size_t... Is>
             PIKA_FORCEINLINE void apply(
-                Tuple& tuple, util::index_pack<Is...>) const
+                Tuple& tuple, util::detail::index_pack<Is...>) const
             {
                 int const _sequencer[] = {
                     (((*this)(std::get<Is>(tuple))), 0)...};
@@ -311,7 +311,8 @@ namespace pika {
             template <typename... Ts>
             PIKA_FORCEINLINE void apply(std::tuple<Ts...>& sequence) const
             {
-                apply(sequence, util::make_index_pack_t<sizeof...(Ts)>());
+                apply(
+                    sequence, util::detail::make_index_pack_t<sizeof...(Ts)>());
             }
 
             template <typename Sequence_>
diff --git a/libs/pika/async_cuda/include/pika/async_cuda/then_with_stream.hpp b/libs/pika/async_cuda/include/pika/async_cuda/then_with_stream.hpp
index d98b8a95d..01c2e9e1c 100644
--- a/libs/pika/async_cuda/include/pika/async_cuda/then_with_stream.hpp
+++ b/libs/pika/async_cuda/include/pika/async_cuda/then_with_stream.hpp
@@ -499,18 +499,18 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                         pika::execution::experimental::value_types_of_t<
                             then_with_cuda_stream_sender_type,
                             pika::execution::experimental::detail::empty_env,
-                            pika::util::pack, pika::util::pack>,
+                            pika::util::detail::pack, pika::util::detail::pack>,
                         result_types_helper>,
                     pika::detail::monostate>>>;
 #else
-            using result_type =
-                pika::util::detail::change_pack_t<pika::detail::variant,
-                    pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                        pika::util::detail::transform_t<
-                            then_with_cuda_stream_sender_type::value_types<
-                                pika::util::pack, pika::util::pack>,
-                            result_types_helper>,
-                        pika::detail::monostate>>>;
+            using result_type = pika::util::detail::change_pack_t<
+                pika::detail::variant,
+                pika::util::detail::unique_t<pika::util::detail::prepend_t<
+                    pika::util::detail::transform_t<
+                        then_with_cuda_stream_sender_type::value_types<
+                            pika::util::detail::pack, pika::util::detail::pack>,
+                        result_types_helper>,
+                    pika::detail::monostate>>>;
 #endif
             result_type result;
 
diff --git a/libs/pika/async_mpi/include/pika/async_mpi/transform_mpi.hpp b/libs/pika/async_mpi/include/pika/async_mpi/transform_mpi.hpp
index f47247eb3..774f61179 100644
--- a/libs/pika/async_mpi/include/pika/async_mpi/transform_mpi.hpp
+++ b/libs/pika/async_mpi/include/pika/async_mpi/transform_mpi.hpp
@@ -323,7 +323,8 @@ namespace pika::mpi::experimental {
                                 transform_mpi_sender_type,
                                 pika::execution::experimental::detail::
                                     empty_env,
-                                pika::util::pack, pika::util::pack>,
+                                pika::util::detail::pack,
+                                pika::util::detail::pack>,
                             result_types_helper>,
                         pika::detail::monostate>>>;
 #else
@@ -332,7 +333,8 @@ namespace pika::mpi::experimental {
                     pika::util::detail::unique_t<pika::util::detail::prepend_t<
                         pika::util::detail::transform_t<
                             transform_mpi_sender_type::value_types<
-                                pika::util::pack, pika::util::pack>,
+                                pika::util::detail::pack,
+                                pika::util::detail::pack>,
                             result_types_helper>,
                         pika::detail::monostate>>>;
 #endif
diff --git a/libs/pika/datastructures/include/pika/datastructures/member_pack.hpp b/libs/pika/datastructures/include/pika/datastructures/member_pack.hpp
index 0fa184798..205eca4fd 100644
--- a/libs/pika/datastructures/include/pika/datastructures/member_pack.hpp
+++ b/libs/pika/datastructures/include/pika/datastructures/member_pack.hpp
@@ -102,7 +102,7 @@ namespace pika::util::detail {
     struct PIKA_EMPTY_BASES member_pack;
 
     template <std::size_t... Is, typename... Ts>
-    struct PIKA_EMPTY_BASES member_pack<util::index_pack<Is...>, Ts...>
+    struct PIKA_EMPTY_BASES member_pack<util::detail::index_pack<Is...>, Ts...>
       : member_leaf<Is, Ts>...
     {
         member_pack() = default;
@@ -140,6 +140,6 @@ namespace pika::util::detail {
 
     template <typename... Ts>
     using member_pack_for =
-        member_pack<typename util::make_index_pack<sizeof...(Ts)>::type, Ts...>;
+        member_pack<util::detail::make_index_pack_t<sizeof...(Ts)>, Ts...>;
 
 }    // namespace pika::util::detail
diff --git a/libs/pika/execution/include/pika/execution/algorithms/detail/partial_algorithm.hpp b/libs/pika/execution/include/pika/execution/algorithms/detail/partial_algorithm.hpp
index 409f34d72..1385a6058 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/detail/partial_algorithm.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/detail/partial_algorithm.hpp
@@ -20,7 +20,8 @@ namespace pika {
     struct partial_algorithm_base;
 
     template <typename Tag, std::size_t... Is, typename... Ts>
-    struct partial_algorithm_base<Tag, pika::util::index_pack<Is...>, Ts...>
+    struct partial_algorithm_base<Tag, pika::util::detail::index_pack<Is...>,
+        Ts...>
     {
     private:
         pika::util::detail::member_pack_for<Ts...> ts;
@@ -49,5 +50,6 @@ namespace pika {
 
     template <typename Tag, typename... Ts>
     using partial_algorithm = partial_algorithm_base<Tag,
-        typename pika::util::make_index_pack<sizeof...(Ts)>::type, Ts...>;
+        typename pika::util::detail::make_index_pack<sizeof...(Ts)>::type,
+        Ts...>;
 }}}}    // namespace pika::execution::experimental::detail
diff --git a/libs/pika/execution/include/pika/execution/algorithms/detail/predicates.hpp b/libs/pika/execution/include/pika/execution/algorithms/detail/predicates.hpp
index 73cd3ac15..cea23c209 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/detail/predicates.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/detail/predicates.hpp
@@ -274,8 +274,8 @@ namespace pika { namespace parallel { inline namespace v1 { namespace detail {
     struct equal_to
     {
         template <typename T1, typename T2,
-            typename Enable = typename std::enable_if<
-                pika::traits::is_equality_comparable_with<T1, T2>::value>::type>
+            typename Enable = std::enable_if_t<
+                pika::traits::detail::is_equality_comparable_with_v<T1, T2>>>
         PIKA_HOST_DEVICE PIKA_FORCEINLINE constexpr auto operator()(
             T1&& t1, T2&& t2) const
         {
@@ -286,8 +286,8 @@ namespace pika { namespace parallel { inline namespace v1 { namespace detail {
     struct not_equal_to
     {
         template <typename T1, typename T2,
-            typename Enable = typename std::enable_if<
-                pika::traits::is_equality_comparable_with<T1, T2>::value>::type>
+            typename Enable = std::enable_if_t<
+                pika::traits::detail::is_equality_comparable_with_v<T1, T2>>>
         PIKA_HOST_DEVICE PIKA_FORCEINLINE constexpr auto operator()(
             T1&& t1, T2&& t2) const
         {
diff --git a/libs/pika/execution/include/pika/execution/algorithms/detail/single_result.hpp b/libs/pika/execution/include/pika/execution/algorithms/detail/single_result.hpp
index b63169d1d..2a72f1eeb 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/detail/single_result.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/detail/single_result.hpp
@@ -25,19 +25,20 @@ namespace pika {
     };
 
     template <>
-    struct single_result<pika::util::pack<pika::util::pack<>>>
+    struct single_result<pika::util::detail::pack<pika::util::detail::pack<>>>
     {
         using type = void;
     };
 
     template <typename T>
-    struct single_result<pika::util::pack<pika::util::pack<T>>>
+    struct single_result<pika::util::detail::pack<pika::util::detail::pack<T>>>
     {
         using type = T;
     };
 
     template <typename T, typename U, typename... Ts>
-    struct single_result<pika::util::pack<pika::util::pack<T, U, Ts...>>>
+    struct single_result<
+        pika::util::detail::pack<pika::util::detail::pack<T, U, Ts...>>>
     {
         static_assert(sizeof(T) == 0,
             "expected a single variant with a single type in "
@@ -46,7 +47,7 @@ namespace pika {
     };
 
     template <typename T, typename U, typename... Ts>
-    struct single_result<pika::util::pack<T, U, Ts...>>
+    struct single_result<pika::util::detail::pack<T, U, Ts...>>
     {
         static_assert(sizeof(T) == 0,
             "expected a single variant with a single type in "
@@ -76,7 +77,7 @@ namespace pika {
     };
 
     template <typename T>
-    struct single_variant<pika::util::pack<T>>
+    struct single_variant<pika::util::detail::pack<T>>
     {
         using type = T;
     };
diff --git a/libs/pika/execution/include/pika/execution/algorithms/just.hpp b/libs/pika/execution/include/pika/execution/algorithms/just.hpp
index b3a8f5a1d..3b135bead 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/just.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/just.hpp
@@ -28,7 +28,7 @@ namespace pika { namespace execution { namespace experimental {
         struct just_sender_impl;
 
         template <typename std::size_t... Is, typename... Ts>
-        struct just_sender_impl<pika::util::index_pack<Is...>, Ts...>
+        struct just_sender_impl<pika::util::detail::index_pack<Is...>, Ts...>
         {
             struct just_sender_type
             {
@@ -131,7 +131,8 @@ namespace pika { namespace execution { namespace experimental {
         constexpr PIKA_FORCEINLINE auto operator()(Ts&&... ts) const
         {
             return just_detail::just_sender<
-                typename pika::util::make_index_pack<sizeof...(Ts)>::type,
+                typename pika::util::detail::make_index_pack<sizeof...(
+                    Ts)>::type,
                 Ts...>{PIKA_FORWARD(Ts, ts)...};
         }
     } just{};
diff --git a/libs/pika/execution/include/pika/execution/algorithms/let_error.hpp b/libs/pika/execution/include/pika/execution/algorithms/let_error.hpp
index dc407d02a..412f1c580 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/let_error.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/let_error.hpp
@@ -64,8 +64,8 @@ namespace pika { namespace execution { namespace experimental {
                     PredecessorSender>::template error_types<Variant>,
                 std::decay>;
             static_assert(
-                !std::is_same<predecessor_error_types<pika::util::pack>,
-                    pika::util::pack<>>::value,
+                !std::is_same<predecessor_error_types<pika::util::detail::pack>,
+                    pika::util::detail::pack<>>::value,
                 "let_error used with a predecessor that has an empty "
                 "error_types. Is let_error misplaced?");
 
diff --git a/libs/pika/execution/include/pika/execution/algorithms/let_value.hpp b/libs/pika/execution/include/pika/execution/algorithms/let_value.hpp
index 9963978f1..f977601f9 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/let_value.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/let_value.hpp
@@ -97,7 +97,7 @@ namespace pika { namespace execution { namespace experimental {
                             >>>;
 #endif
 
-            // pika::util::pack acts as a concrete type in place of Tuple. It is
+            // pika::util::detail::pack acts as a concrete type in place of Tuple. It is
             // required for computing successor_sender_types, but disappears
             // from the final error_types.
             template <template <typename...> class Variant>
@@ -105,7 +105,8 @@ namespace pika { namespace execution { namespace experimental {
                 pika::util::detail::unique_t<pika::util::detail::prepend_t<
                     pika::util::detail::concat_pack_of_packs_t<
                         pika::util::detail::transform_t<
-                            successor_sender_types<pika::util::pack, Variant>,
+                            successor_sender_types<pika::util::detail::pack,
+                                Variant>,
                             detail::error_types<Variant>::template apply>>,
                     std::exception_ptr>>;
 
diff --git a/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp b/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
index 001d256cc..fe8cac640 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
@@ -143,7 +143,9 @@ namespace pika { namespace execution { namespace experimental {
                 make_future_receiver r_local = PIKA_MOVE(r);
 
                 pika::detail::try_catch_exception_ptr(
-                    [&]() { r_local.data->set_value(pika::util::unused); },
+                    [&]() {
+                        r_local.data->set_value(pika::util::detail::unused);
+                    },
                     [&](std::exception_ptr ep) {
                         r_local.data->set_exception(PIKA_MOVE(ep));
                     });
@@ -207,11 +209,11 @@ namespace pika { namespace execution { namespace experimental {
                 typename pika::execution::experimental::value_types_of_t<
                     std::decay_t<Sender>,
                     pika::execution::experimental::detail::empty_env,
-                    pika::util::pack, pika::util::pack>;
+                    pika::util::detail::pack, pika::util::detail::pack>;
 #else
             using value_types = typename pika::execution::experimental::
                 sender_traits<std::decay_t<Sender>>::template value_types<
-                    pika::util::pack, pika::util::pack>;
+                    pika::util::detail::pack, pika::util::detail::pack>;
 #endif
             using result_type =
                 std::decay_t<detail::single_result_t<value_types>>;
diff --git a/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp b/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
index c4cdbb198..b4a8e9db1 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
@@ -77,7 +77,7 @@ namespace pika::this_thread::experimental {
             // fail to compile.
             using result_type = std::decay_t<pika::execution::experimental::
                     detail::single_result_t<predecessor_value_types<
-                        pika::util::pack, pika::util::pack>>>;
+                        pika::util::detail::pack, pika::util::detail::pack>>>;
 
             // Constant to indicate if the type of the result from the
             // predecessor sender is void or not
@@ -119,7 +119,7 @@ namespace pika::this_thread::experimental {
             // fail to compile.
             using result_type = std::decay_t<pika::execution::experimental::
                     detail::single_result_t<predecessor_value_types<
-                        pika::util::pack, pika::util::pack>>>;
+                        pika::util::detail::pack, pika::util::detail::pack>>>;
 
             // Constant to indicate if the type of the result from the
             // predecessor sender is void or not
diff --git a/libs/pika/execution/include/pika/execution/algorithms/when_all.hpp b/libs/pika/execution/include/pika/execution/algorithms/when_all.hpp
index 05a34b42f..97ab1fdd8 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/when_all.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/when_all.hpp
@@ -85,7 +85,8 @@ namespace pika { namespace execution { namespace experimental {
             };
 
             template <typename... Ts, std::size_t... Is>
-            auto set_value_helper(pika::util::index_pack<Is...>, Ts&&... ts)
+            auto set_value_helper(
+                pika::util::detail::index_pack<Is...>, Ts&&... ts)
                 -> decltype((std::declval<typename OperationState::
                                      value_types_storage_type>()
                                     .template get<
@@ -103,8 +104,9 @@ namespace pika { namespace execution { namespace experimental {
                     ...);
             }
 
-            using index_pack_type = typename pika::util::make_index_pack<
-                OperationState::sender_pack_size>::type;
+            using index_pack_type =
+                typename pika::util::detail::make_index_pack<
+                    OperationState::sender_pack_size>::type;
 
             template <typename... Ts>
             auto set_value(Ts&&... ts) noexcept
@@ -182,8 +184,8 @@ namespace pika { namespace execution { namespace experimental {
             {
                 using value_types =
                     typename pika::execution::experimental::sender_traits<
-                        Sender>::template value_types<pika::util::pack,
-                        pika::util::pack>;
+                        Sender>::template value_types<pika::util::detail::pack,
+                        pika::util::detail::pack>;
                 using type = detail::single_result_non_void_t<value_types>;
             };
 
@@ -214,10 +216,10 @@ namespace pika { namespace execution { namespace experimental {
 
             template <std::size_t I>
             static constexpr std::size_t sender_pack_size_at_index =
-                detail::single_variant_t<
-                    typename sender_traits<pika::util::at_index_t<I,
-                        Senders...>>::template value_types<pika::util::pack,
-                        pika::util::pack>>::size;
+                detail::single_variant_t<typename sender_traits<
+                    pika::util::detail::at_index_t<I, Senders...>>::
+                        template value_types<pika::util::detail::pack,
+                            pika::util::detail::pack>>::size;
 
             template <typename Receiver, typename SendersPack,
                 std::size_t I = num_predecessors - 1>
@@ -240,10 +242,10 @@ namespace pika { namespace execution { namespace experimental {
                 // here and complains about incmplete types. Lifting the helper
                 // explicitly in here works.
                 static constexpr std::size_t sender_pack_size =
-                    detail::single_variant_t<
-                        typename sender_traits<pika::util::at_index_t<i,
-                            Senders...>>::template value_types<pika::util::pack,
-                            pika::util::pack>>::size;
+                    detail::single_variant_t<typename sender_traits<
+                        pika::util::detail::at_index_t<i, Senders...>>::
+                            template value_types<pika::util::detail::pack,
+                                pika::util::detail::pack>>::size;
 #endif
 
                 // Number of predecessor senders that have not yet called any of
@@ -261,8 +263,8 @@ namespace pika { namespace execution { namespace experimental {
                         pika::util::detail::member_pack_for,
                         pika::util::detail::transform_t<
                             pika::util::detail::concat_pack_of_packs_t<
-                                value_types<pika::util::pack,
-                                    pika::util::pack>>,
+                                value_types<pika::util::detail::pack,
+                                    pika::util::detail::pack>>,
                             add_optional>>;
                 // Values sent by all predecessor senders are stored here in the
                 // base-case operation state. They are stored in a
@@ -307,7 +309,7 @@ namespace pika { namespace execution { namespace experimental {
 
                 template <std::size_t... Is, typename... Ts>
                 void set_value_helper(pika::util::detail::member_pack<
-                    pika::util::index_pack<Is...>, Ts...>& ts)
+                    pika::util::detail::index_pack<Is...>, Ts...>& ts)
                 {
                     pika::execution::experimental::set_value(
                         PIKA_MOVE(receiver),
@@ -424,7 +426,7 @@ namespace pika { namespace execution { namespace experimental {
         // clang-format off
         template <typename... Senders,
             PIKA_CONCEPT_REQUIRES_(
-                pika::util::all_of_v<is_sender<Senders>...>
+                pika::util::detail::all_of_v<is_sender<Senders>...>
             )>
         // clang-format on
         friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
diff --git a/libs/pika/execution/include/pika/execution/algorithms/when_all_vector.hpp b/libs/pika/execution/include/pika/execution/algorithms/when_all_vector.hpp
index c595bb845..c56091e0b 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/when_all_vector.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/when_all_vector.hpp
@@ -66,9 +66,9 @@ namespace pika::execution::experimental {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
             // We expect a single value type or nothing from the predecessor
             // sender type
-            using element_value_type = detail::single_result_t<
-                pika::execution::experimental::value_types_of_t<Sender,
-                    detail::empty_env, pika::util::pack, pika::util::pack>>;
+            using element_value_type = detail::single_result_t<pika::execution::
+                    experimental::value_types_of_t<Sender, detail::empty_env,
+                        pika::util::detail::pack, pika::util::detail::pack>>;
 
             static constexpr bool is_void_value_type =
                 std::is_void_v<element_value_type>;
@@ -106,8 +106,9 @@ namespace pika::execution::experimental {
             // We expect a single value type or nothing from the predecessor
             // sender type
             using element_value_type = detail::single_result_t<
-                typename pika::execution::experimental::sender_traits<Sender>::
-                    template value_types<pika::util::pack, pika::util::pack>>;
+                typename pika::execution::experimental::sender_traits<
+                    Sender>::template value_types<pika::util::detail::pack,
+                    pika::util::detail::pack>>;
 
             static constexpr bool is_void_value_type =
                 std::is_void_v<element_value_type>;
diff --git a/libs/pika/execution/include/pika/execution/executors/execution_parameters.hpp b/libs/pika/execution/include/pika/execution/executors/execution_parameters.hpp
index 21e6613ac..684b77b0c 100644
--- a/libs/pika/execution/include/pika/execution/executors/execution_parameters.hpp
+++ b/libs/pika/execution/include/pika/execution/executors/execution_parameters.hpp
@@ -696,7 +696,8 @@ namespace pika { namespace parallel { namespace execution {
     static_assert(                                                             \
         parameters_type_counter<                                               \
             PIKA_PP_CAT(pika::parallel::execution::detail::has_, func) <       \
-            pika::util::decay_unwrap_t<Params>>::value... > ::value <= 1,      \
+            pika::util::detail::decay_unwrap_t<Params>>::value... > ::value <= \
+            1,                                                                 \
         "Passing more than one executor parameters type "                      \
         "exposing " PIKA_PP_STRINGIZE(func) " is not possible") /**/
 
@@ -704,8 +705,8 @@ namespace pika { namespace parallel { namespace execution {
         struct executor_parameters : public unwrapper<Params>...
         {
             static_assert(
-                pika::util::all_of<pika::traits::is_executor_parameters<
-                    std::decay_t<Params>>...>::value,
+                pika::util::detail::all_of_v<pika::traits::
+                        is_executor_parameters<std::decay_t<Params>>...>,
                 "All passed parameters must be a proper executor parameters "
                 "objects");
             static_assert(sizeof...(Params) >= 2,
@@ -724,7 +725,8 @@ namespace pika { namespace parallel { namespace execution {
 
             template <typename Dependent = void,
                 typename Enable = std::enable_if_t<
-                    pika::util::all_of<std::is_constructible<Params>...>::value,
+                    pika::util::detail::all_of<
+                        std::is_constructible<Params>...>::value,
                     Dependent>>
             constexpr executor_parameters()
               : unwrapper<Params>()...
@@ -732,9 +734,9 @@ namespace pika { namespace parallel { namespace execution {
             }
 
             template <typename... Params_,
-                typename Enable =
-                    std::enable_if_t<pika::util::pack<Params...>::size ==
-                        pika::util::pack<Params_...>::size>>
+                typename Enable = std::enable_if_t<
+                    pika::util::detail::pack<Params...>::size ==
+                    pika::util::detail::pack<Params_...>::size>>
             constexpr executor_parameters(Params_&&... params)
               : unwrapper<Params>(PIKA_FORWARD(Params_, params))...
             {
@@ -750,7 +752,8 @@ namespace pika { namespace parallel { namespace execution {
     // specialize trait for the type-combiner
     template <typename... Parameters>
     struct is_executor_parameters<detail::executor_parameters<Parameters...>>
-      : pika::util::all_of<pika::traits::is_executor_parameters<Parameters>...>
+      : pika::util::detail::all_of<
+            pika::traits::is_executor_parameters<Parameters>...>
     {
     };
 
diff --git a/libs/pika/execution/include/pika/execution/executors/execution_parameters_fwd.hpp b/libs/pika/execution/include/pika/execution/executors/execution_parameters_fwd.hpp
index 801d53e60..3e793cc56 100644
--- a/libs/pika/execution/include/pika/execution/executors/execution_parameters_fwd.hpp
+++ b/libs/pika/execution/include/pika/execution/executors/execution_parameters_fwd.hpp
@@ -94,7 +94,7 @@ namespace pika { namespace parallel { namespace execution {
             std::size_t cores, std::size_t num_tasks)
         {
             return detail::get_chunk_size_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec), PIKA_FORWARD(F, f), cores,
                 num_tasks);
@@ -130,7 +130,7 @@ namespace pika { namespace parallel { namespace execution {
             std::size_t cores, std::size_t num_tasks)
         {
             return detail::maximal_number_of_chunks_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec), cores, num_tasks);
         }
@@ -161,7 +161,7 @@ namespace pika { namespace parallel { namespace execution {
             reset_thread_distribution_t, Parameters&& params, Executor&& exec)
         {
             return detail::reset_thread_distribution_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec));
         }
@@ -192,7 +192,7 @@ namespace pika { namespace parallel { namespace execution {
             processing_units_count_t, Parameters&& params, Executor&& exec)
         {
             return detail::processing_units_count_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec));
         }
@@ -221,7 +221,7 @@ namespace pika { namespace parallel { namespace execution {
             mark_begin_execution_t, Parameters&& params, Executor&& exec)
         {
             return detail::mark_begin_execution_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec));
         }
@@ -250,7 +250,7 @@ namespace pika { namespace parallel { namespace execution {
             mark_end_of_scheduling_t, Parameters&& params, Executor&& exec)
         {
             return detail::mark_end_of_scheduling_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec));
         }
@@ -279,7 +279,7 @@ namespace pika { namespace parallel { namespace execution {
             mark_end_execution_t, Parameters&& params, Executor&& exec)
         {
             return detail::mark_end_execution_fn_helper<
-                pika::util::decay_unwrap_t<Parameters>,
+                pika::util::detail::decay_unwrap_t<Parameters>,
                 std::decay_t<Executor>>::call(PIKA_FORWARD(Parameters, params),
                 PIKA_FORWARD(Executor, exec));
         }
diff --git a/libs/pika/execution/include/pika/execution/executors/fused_bulk_execute.hpp b/libs/pika/execution/include/pika/execution/executors/fused_bulk_execute.hpp
index 8b25d01ff..884c1bae8 100644
--- a/libs/pika/execution/include/pika/execution/executors/fused_bulk_execute.hpp
+++ b/libs/pika/execution/include/pika/execution/executors/fused_bulk_execute.hpp
@@ -70,8 +70,8 @@ namespace pika { namespace parallel { namespace execution { namespace detail {
     template <typename Executor, typename F, typename Shape, typename Future,
         std::size_t... Is, typename... Ts>
     PIKA_FORCEINLINE auto fused_bulk_sync_execute(Executor&& exec, F&& f,
-        Shape const& shape, Future&& predecessor, pika::util::index_pack<Is...>,
-        std::tuple<Ts...> const& args)
+        Shape const& shape, Future&& predecessor,
+        pika::util::detail::index_pack<Is...>, std::tuple<Ts...> const& args)
         -> decltype(execution::bulk_sync_execute(PIKA_FORWARD(Executor, exec),
             PIKA_FORWARD(F, f), shape, PIKA_FORWARD(Future, predecessor),
             std::get<Is>(args)...))
@@ -100,7 +100,8 @@ namespace pika { namespace parallel { namespace execution { namespace detail {
         {
             return fused_bulk_sync_execute(exec_, f_, shape_,
                 PIKA_FORWARD(Future, predecessor),
-                typename pika::util::make_index_pack<sizeof...(Ts)>::type(),
+                typename pika::util::detail::make_index_pack<sizeof...(
+                    Ts)>::type(),
                 args_);
         }
     };
@@ -122,8 +123,8 @@ namespace pika { namespace parallel { namespace execution { namespace detail {
     template <typename Executor, typename F, typename Shape, typename Future,
         std::size_t... Is, typename... Ts>
     PIKA_FORCEINLINE auto fused_bulk_async_execute(Executor&& exec, F&& f,
-        Shape const& shape, Future&& predecessor, pika::util::index_pack<Is...>,
-        std::tuple<Ts...> const& args)
+        Shape const& shape, Future&& predecessor,
+        pika::util::detail::index_pack<Is...>, std::tuple<Ts...> const& args)
         -> decltype(execution::bulk_async_execute(PIKA_FORWARD(Executor, exec),
             PIKA_FORWARD(F, f), shape, PIKA_FORWARD(Future, predecessor),
             std::get<Is>(args)...))
@@ -152,7 +153,8 @@ namespace pika { namespace parallel { namespace execution { namespace detail {
         {
             return fused_bulk_async_execute(exec_, f_, shape_,
                 PIKA_FORWARD(Future, predecessor),
-                typename pika::util::make_index_pack<sizeof...(Ts)>::type(),
+                typename pika::util::detail::make_index_pack<sizeof...(
+                    Ts)>::type(),
                 args_);
         }
     };
diff --git a/libs/pika/execution/include/pika/execution/traits/executor_traits.hpp b/libs/pika/execution/include/pika/execution/traits/executor_traits.hpp
index a0c39c748..e4f0acf96 100644
--- a/libs/pika/execution/include/pika/execution/traits/executor_traits.hpp
+++ b/libs/pika/execution/include/pika/execution/traits/executor_traits.hpp
@@ -105,7 +105,7 @@ namespace pika { namespace parallel { namespace execution {
         using execution_category = typename T::execution_category;
 
     public:
-        using type = pika::util::detected_or_t<
+        using type = pika::util::detail::detected_or_t<
             pika::execution::unsequenced_execution_tag, execution_category,
             Executor>;
     };
@@ -119,8 +119,8 @@ namespace pika { namespace parallel { namespace execution {
         using shape_type = typename T::shape_type;
 
     public:
-        using type =
-            pika::util::detected_or_t<std::size_t, shape_type, Executor>;
+        using type = pika::util::detail::detected_or_t<std::size_t, shape_type,
+            Executor>;
     };
 
     ///////////////////////////////////////////////////////////////////////////
@@ -133,9 +133,8 @@ namespace pika { namespace parallel { namespace execution {
         using index_type = typename T::index_type;
 
     public:
-        using type =
-            pika::util::detected_or_t<typename executor_shape<Executor>::type,
-                index_type, Executor>;
+        using type = pika::util::detail::detected_or_t<
+            typename executor_shape<Executor>::type, index_type, Executor>;
     };
 
     ///////////////////////////////////////////////////////////////////////////
@@ -147,9 +146,8 @@ namespace pika { namespace parallel { namespace execution {
         using parameters_type = typename T::parameters_type;
 
     public:
-        using type =
-            pika::util::detected_or_t<pika::execution::static_chunk_size,
-                parameters_type, Executor>;
+        using type = pika::util::detail::detected_or_t<
+            pika::execution::static_chunk_size, parameters_type, Executor>;
     };
 
     ///////////////////////////////////////////////////////////////////////////
@@ -171,7 +169,7 @@ namespace pika { namespace parallel { namespace execution {
         };
 
         template <typename Executor, typename T, typename... Ts>
-        struct executor_future<Executor, T, pika::util::pack<Ts...>,
+        struct executor_future<Executor, T, pika::util::detail::pack<Ts...>,
             std::enable_if_t<pika::traits::is_two_way_executor_v<Executor> &&
                 exposes_future_type<Executor, T>::value>>
         {
@@ -179,7 +177,7 @@ namespace pika { namespace parallel { namespace execution {
         };
 
         template <typename Executor, typename T, typename... Ts>
-        struct executor_future<Executor, T, pika::util::pack<Ts...>,
+        struct executor_future<Executor, T, pika::util::detail::pack<Ts...>,
             std::enable_if_t<pika::traits::is_two_way_executor_v<Executor> &&
                 !exposes_future_type<Executor, T>::value>>
         {
@@ -198,7 +196,7 @@ namespace pika { namespace parallel { namespace execution {
     template <typename Executor, typename T, typename... Ts>
     struct executor_future
       : detail::executor_future<std::decay_t<Executor>, T,
-            pika::util::pack<std::decay_t<Ts>...>>
+            pika::util::detail::pack<std::decay_t<Ts>...>>
     {
     };
 
diff --git a/libs/pika/execution/include/pika/execution/traits/future_then_result_exec.hpp b/libs/pika/execution/include/pika/execution/traits/future_then_result_exec.hpp
index 1ab2ef1e2..c1d05cbc8 100644
--- a/libs/pika/execution/include/pika/execution/traits/future_then_result_exec.hpp
+++ b/libs/pika/execution/include/pika/execution/traits/future_then_result_exec.hpp
@@ -14,8 +14,8 @@
 #include <pika/futures/traits/future_then_result.hpp>
 #include <pika/futures/traits/future_traits.hpp>
 #include <pika/futures/traits/is_future.hpp>
-#include <pika/type_support/identity.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
+#include <pika/type_support/type_identity.hpp>
 
 #include <type_traits>
 #include <utility>
@@ -42,10 +42,10 @@ namespace pika { namespace traits {
                 traits::executor_future_t<Executor, func_result_type, Future>;
 
             // perform unwrapping of future<future<R>>
-            using result_type = util::lazy_conditional_t<
+            using result_type = util::detail::lazy_conditional_t<
                 pika::traits::detail::is_unique_future_v<cont_result>,
                 pika::traits::future_traits<cont_result>,
-                pika::util::identity<cont_result>>;
+                pika::detail::type_identity<cont_result>>;
 
             using type = pika::future<result_type>;
         };
diff --git a/libs/pika/execution/include/pika/execution/traits/vector_pack_alignment_size.hpp b/libs/pika/execution/include/pika/execution/traits/vector_pack_alignment_size.hpp
index 08e5e895a..486887d25 100644
--- a/libs/pika/execution/include/pika/execution/traits/vector_pack_alignment_size.hpp
+++ b/libs/pika/execution/include/pika/execution/traits/vector_pack_alignment_size.hpp
@@ -42,11 +42,11 @@ namespace pika { namespace parallel { namespace traits {
 
     template <typename... Vector>
     struct vector_pack_alignment<std::tuple<Vector...>,
-        typename std::enable_if<
-            pika::util::all_of<is_vector_pack<Vector>...>::value>::type>
+        std::enable_if_t<
+            pika::util::detail::all_of_v<is_vector_pack<Vector>...>>>
     {
-        typedef typename std::tuple_element<0, std::tuple<Vector...>>::type
-            pack_type;
+        using pack_type =
+            typename std::tuple_element<0, std::tuple<Vector...>>::type;
 
         static std::size_t const value =
             vector_pack_alignment<pack_type>::value;
@@ -58,8 +58,8 @@ namespace pika { namespace parallel { namespace traits {
 
     template <typename... Vector>
     struct vector_pack_size<std::tuple<Vector...>,
-        typename std::enable_if<
-            pika::util::all_of<is_vector_pack<Vector>...>::value>::type>
+        std::enable_if_t<
+            pika::util::detail::all_of_v<is_vector_pack<Vector>...>>>
     {
         typedef typename std::tuple_element<0, std::tuple<Vector...>>::type
             pack_type;
diff --git a/libs/pika/execution/tests/unit/executor_parameters.cpp b/libs/pika/execution/tests/unit/executor_parameters.cpp
index 6def9834e..0c6d99e99 100644
--- a/libs/pika/execution/tests/unit/executor_parameters.cpp
+++ b/libs/pika/execution/tests/unit/executor_parameters.cpp
@@ -26,9 +26,8 @@
 template <typename... Parameters>
 void parameters_test_impl(Parameters&&... params)
 {
-    static_assert(
-        pika::util::all_of<
-            pika::traits::is_executor_parameters<Parameters>...>::value,
+    static_assert(pika::util::detail::all_of_v<
+                      pika::traits::is_executor_parameters<Parameters>...>,
         "pika::traits::is_executor_parameters<Parameters>::value");
 
     using iterator_tag = std::random_access_iterator_tag;
diff --git a/libs/pika/execution_base/include/pika/execution_base/any_sender.hpp b/libs/pika/execution_base/include/pika/execution_base/any_sender.hpp
index c2348dd80..780773f12 100644
--- a/libs/pika/execution_base/include/pika/execution_base/any_sender.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/any_sender.hpp
@@ -886,11 +886,11 @@ namespace pika::execution::experimental {
             using value_types_pack =
                 pika::execution::experimental::value_types_of_t<Sender,
                     pika::execution::experimental::detail::empty_env,
-                    pika::util::pack, pika::util::pack>;
+                    pika::util::detail::pack, pika::util::detail::pack>;
 #else
             using value_types_pack = typename pika::execution::experimental::
                 sender_traits<std::decay_t<Sender>>::template value_types<
-                    pika::util::pack, pika::util::pack>;
+                    pika::util::detail::pack, pika::util::detail::pack>;
 #endif
             static_assert(value_types_pack::size == 1,
                 "any_sender and unique_any_sender require the predecessor "
diff --git a/libs/pika/execution_base/include/pika/execution_base/sender.hpp b/libs/pika/execution_base/include/pika/execution_base/sender.hpp
index a332a6889..167961787 100644
--- a/libs/pika/execution_base/include/pika/execution_base/sender.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/sender.hpp
@@ -193,7 +193,7 @@ namespace pika { namespace execution { namespace experimental {
                 std::is_destructible<std::decay_t<F>>::value &&
                 std::is_move_constructible<std::decay_t<F>>::value &&
                 std::is_copy_constructible<Executor>::value &&
-                pika::traits::is_equality_comparable<Executor>::value>>
+                pika::traits::detail::is_equality_comparable_v<Executor>>>
           : std::true_type
         {
         };
@@ -468,7 +468,7 @@ namespace pika { namespace execution { namespace experimental {
         std::enable_if_t<
             pika::detail::is_invocable<schedule_t, Scheduler>::value &&
             std::is_copy_constructible<Scheduler>::value &&
-            pika::traits::is_equality_comparable<Scheduler>::value>>
+            pika::traits::detail::is_equality_comparable_v<Scheduler>>>
       : std::true_type
     {
     };
diff --git a/libs/pika/execution_base/include/pika/execution_base/traits/is_executor.hpp b/libs/pika/execution_base/include/pika/execution_base/traits/is_executor.hpp
index 277d6b4b9..902cd9854 100644
--- a/libs/pika/execution_base/include/pika/execution_base/traits/is_executor.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/traits/is_executor.hpp
@@ -133,7 +133,7 @@ namespace pika { namespace traits {
     // trait testing for any of the above
     template <typename T, typename Enable = void>
     struct is_executor_any
-      : util::any_of<is_one_way_executor<T>,
+      : util::detail::any_of<is_one_way_executor<T>,
             is_never_blocking_one_way_executor<T>, is_bulk_one_way_executor<T>,
             is_two_way_executor<T>, is_bulk_two_way_executor<T>>
     {
diff --git a/libs/pika/executors/include/pika/executors/dataflow.hpp b/libs/pika/executors/include/pika/executors/dataflow.hpp
index f9967a293..0bf65e7b2 100644
--- a/libs/pika/executors/include/pika/executors/dataflow.hpp
+++ b/libs/pika/executors/include/pika/executors/dataflow.hpp
@@ -234,7 +234,7 @@ namespace pika::detail {
                     util::detail::invoke_fused(
                         PIKA_MOVE(func_), PIKA_FORWARD(Futures_, futures));
 
-                    this->set_data(util::unused_type());
+                    this->set_data(util::detail::unused_type());
                 },
                 [&](std::exception_ptr ep) {
                     this->set_exception(PIKA_MOVE(ep));
diff --git a/libs/pika/executors/include/pika/executors/fork_join_executor.hpp b/libs/pika/executors/include/pika/executors/fork_join_executor.hpp
index b7d7a799f..9dabc9b18 100644
--- a/libs/pika/executors/include/pika/executors/fork_join_executor.hpp
+++ b/libs/pika/executors/include/pika/executors/fork_join_executor.hpp
@@ -371,7 +371,8 @@ namespace pika { namespace execution { namespace experimental {
                 template <std::size_t... Is_, typename F_, typename A_,
                     typename Tuple_>
                 static constexpr void invoke_helper(
-                    pika::util::index_pack<Is_...>, F_&& f, A_&& a, Tuple_&& t)
+                    pika::util::detail::index_pack<Is_...>, F_&& f, A_&& a,
+                    Tuple_&& t)
                 {
                     PIKA_INVOKE(PIKA_FORWARD(F_, f), PIKA_FORWARD(A_, a),
                         std::get<Is_>(PIKA_FORWARD(Tuple_, t))...);
diff --git a/libs/pika/functional/include/pika/functional/bind.hpp b/libs/pika/functional/include/pika/functional/bind.hpp
index 5c17e40f8..a8841f572 100644
--- a/libs/pika/functional/include/pika/functional/bind.hpp
+++ b/libs/pika/functional/include/pika/functional/bind.hpp
@@ -75,7 +75,7 @@ namespace pika::util::detail {
     struct invoke_bound_result;
 
     template <typename F, typename... Ts, typename... Us>
-    struct invoke_bound_result<F, util::pack<Ts...>, Us...>
+    struct invoke_bound_result<F, util::detail::pack<Ts...>, Us...>
       : util::detail::invoke_result<F,
             decltype(bind_eval<Ts, sizeof...(Us)>::call(
                 std::declval<Ts>(), std::declval<Us>()...))...>
@@ -126,7 +126,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE
-            invoke_bound_result_t<F&, util::pack<Ts&...>, Us&&...>
+            invoke_bound_result_t<F&, util::detail::pack<Ts&...>, Us&&...>
             operator()(Us&&... vs) &
         {
             return PIKA_INVOKE(_f,
@@ -136,9 +136,9 @@ namespace pika::util::detail {
 
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
-        constexpr PIKA_HOST_DEVICE
-            invoke_bound_result_t<F const&, util::pack<Ts const&...>, Us&&...>
-            operator()(Us&&... vs) const&
+        constexpr PIKA_HOST_DEVICE invoke_bound_result_t<F const&,
+            util::detail::pack<Ts const&...>, Us&&...>
+        operator()(Us&&... vs) const&
         {
             return PIKA_INVOKE(_f,
                 detail::bind_eval<Ts const&, sizeof...(Us)>::call(
@@ -148,7 +148,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE
-            invoke_bound_result_t<F&&, util::pack<Ts&&...>, Us&&...>
+            invoke_bound_result_t<F&&, util::detail::pack<Ts&&...>, Us&&...>
             operator()(Us&&... vs) &&
         {
             return PIKA_INVOKE(PIKA_MOVE(_f),
@@ -159,9 +159,9 @@ namespace pika::util::detail {
 
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
-        constexpr PIKA_HOST_DEVICE
-            invoke_bound_result_t<F const&&, util::pack<Ts const&&...>, Us&&...>
-            operator()(Us&&... vs) const&&
+        constexpr PIKA_HOST_DEVICE invoke_bound_result_t<F const&&,
+            util::detail::pack<Ts const&&...>, Us&&...>
+        operator()(Us&&... vs) const&&
         {
             return PIKA_INVOKE(PIKA_MOVE(_f),
                 detail::bind_eval<Ts const, sizeof...(Us)>::call(
@@ -202,13 +202,14 @@ namespace pika::util::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename F, typename... Ts>
-    constexpr bound<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>,
-        util::decay_unwrap_t<Ts>...>
+    constexpr bound<std::decay_t<F>,
+        util::detail::make_index_pack_t<sizeof...(Ts)>,
+        util::detail::decay_unwrap_t<Ts>...>
     bind(F&& f, Ts&&... vs)
     {
-        using result_type =
-            bound<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>,
-                util::decay_unwrap_t<Ts>...>;
+        using result_type = bound<std::decay_t<F>,
+            util::detail::make_index_pack_t<sizeof...(Ts)>,
+            util::detail::decay_unwrap_t<Ts>...>;
 
         return result_type(PIKA_FORWARD(F, f), PIKA_FORWARD(Ts, vs)...);
     }
diff --git a/libs/pika/functional/include/pika/functional/bind_back.hpp b/libs/pika/functional/include/pika/functional/bind_back.hpp
index 98545898e..6758e1f28 100644
--- a/libs/pika/functional/include/pika/functional/bind_back.hpp
+++ b/libs/pika/functional/include/pika/functional/bind_back.hpp
@@ -26,7 +26,7 @@ namespace pika::util::detail {
     struct invoke_bound_back_result;
 
     template <typename F, typename... Ts, typename... Us>
-    struct invoke_bound_back_result<F, util::pack<Ts...>, Us...>
+    struct invoke_bound_back_result<F, util::detail::pack<Ts...>, Us...>
       : util::detail::invoke_result<F, Us..., Ts...>
     {
     };
@@ -71,7 +71,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_back_result<F&,
-            util::pack<Ts&...>, Us&&...>::type
+            util::detail::pack<Ts&...>, Us&&...>::type
         operator()(Us&&... vs) &
         {
             return PIKA_INVOKE(
@@ -81,7 +81,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_back_result<F const&,
-            util::pack<Ts const&...>, Us&&...>::type
+            util::detail::pack<Ts const&...>, Us&&...>::type
         operator()(Us&&... vs) const&
         {
             return PIKA_INVOKE(
@@ -91,7 +91,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_back_result<F&&,
-            util::pack<Ts&&...>, Us&&...>::type
+            util::detail::pack<Ts&&...>, Us&&...>::type
         operator()(Us&&... vs) &&
         {
             return PIKA_INVOKE(PIKA_MOVE(_f), PIKA_FORWARD(Us, vs)...,
@@ -101,7 +101,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_back_result<F const&&,
-            util::pack<Ts const&&...>, Us&&...>::type
+            util::detail::pack<Ts const&&...>, Us&&...>::type
         operator()(Us&&... vs) const&&
         {
             return PIKA_INVOKE(PIKA_MOVE(_f), PIKA_FORWARD(Us, vs)...,
@@ -141,12 +141,13 @@ namespace pika::util::detail {
 
     template <typename F, typename... Ts>
     constexpr bound_back<std::decay_t<F>,
-        util::make_index_pack_t<sizeof...(Ts)>, util::decay_unwrap_t<Ts>...>
+        util::detail::make_index_pack_t<sizeof...(Ts)>,
+        util::detail::decay_unwrap_t<Ts>...>
     bind_back(F&& f, Ts&&... vs)
     {
-        using result_type =
-            bound_back<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>,
-                util::decay_unwrap_t<Ts>...>;
+        using result_type = bound_back<std::decay_t<F>,
+            util::detail::make_index_pack_t<sizeof...(Ts)>,
+            util::detail::decay_unwrap_t<Ts>...>;
 
         return result_type(PIKA_FORWARD(F, f), PIKA_FORWARD(Ts, vs)...);
     }
diff --git a/libs/pika/functional/include/pika/functional/bind_front.hpp b/libs/pika/functional/include/pika/functional/bind_front.hpp
index 48d84c4ce..d9d142a88 100644
--- a/libs/pika/functional/include/pika/functional/bind_front.hpp
+++ b/libs/pika/functional/include/pika/functional/bind_front.hpp
@@ -26,7 +26,7 @@ namespace pika::util::detail {
     struct invoke_bound_front_result;
 
     template <typename F, typename... Ts, typename... Us>
-    struct invoke_bound_front_result<F, util::pack<Ts...>, Us...>
+    struct invoke_bound_front_result<F, util::detail::pack<Ts...>, Us...>
       : util::detail::invoke_result<F, Ts..., Us...>
     {
     };
@@ -72,7 +72,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_front_result<F&,
-            util::pack<Ts&...>, Us&&...>::type
+            util::detail::pack<Ts&...>, Us&&...>::type
         operator()(Us&&... vs) &
         {
             return PIKA_INVOKE(
@@ -82,7 +82,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_front_result<F const&,
-            util::pack<Ts const&...>, Us&&...>::type
+            util::detail::pack<Ts const&...>, Us&&...>::type
         operator()(Us&&... vs) const&
         {
             return PIKA_INVOKE(
@@ -92,7 +92,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_front_result<F&&,
-            util::pack<Ts&&...>, Us&&...>::type
+            util::detail::pack<Ts&&...>, Us&&...>::type
         operator()(Us&&... vs) &&
         {
             return PIKA_INVOKE(PIKA_MOVE(_f),
@@ -103,7 +103,7 @@ namespace pika::util::detail {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
         constexpr PIKA_HOST_DEVICE typename invoke_bound_front_result<F const&&,
-            util::pack<Ts const&&...>, Us&&...>::type
+            util::detail::pack<Ts const&&...>, Us&&...>::type
         operator()(Us&&... vs) const&&
         {
             return PIKA_INVOKE(PIKA_MOVE(_f),
@@ -144,12 +144,12 @@ namespace pika::util::detail {
 
     template <typename F, typename... Ts>
     constexpr bound_front<std::decay_t<F>,
-        typename util::make_index_pack<sizeof...(Ts)>::type,
+        typename util::detail::make_index_pack<sizeof...(Ts)>::type,
         std::decay_t<Ts>...>
     bind_front(F&& f, Ts&&... vs)
     {
         using result_type = bound_front<std::decay_t<F>,
-            typename util::make_index_pack<sizeof...(Ts)>::type,
+            typename util::detail::make_index_pack<sizeof...(Ts)>::type,
             std::decay_t<Ts>...>;
 
         return result_type(PIKA_FORWARD(F, f), PIKA_FORWARD(Ts, vs)...);
diff --git a/libs/pika/functional/include/pika/functional/deferred_call.hpp b/libs/pika/functional/include/pika/functional/deferred_call.hpp
index 44459a632..6e7419509 100644
--- a/libs/pika/functional/include/pika/functional/deferred_call.hpp
+++ b/libs/pika/functional/include/pika/functional/deferred_call.hpp
@@ -23,8 +23,8 @@
 namespace pika::detail {
     template <typename F, typename... Ts>
     struct is_deferred_invocable
-      : pika::detail::is_invocable<util::decay_unwrap_t<F>,
-            util::decay_unwrap_t<Ts>...>
+      : pika::detail::is_invocable<util::detail::decay_unwrap_t<F>,
+            util::detail::decay_unwrap_t<Ts>...>
     {
     };
 
@@ -36,8 +36,8 @@ namespace pika::detail {
 namespace pika::util::detail {
     template <typename F, typename... Ts>
     struct invoke_deferred_result
-      : util::detail::invoke_result<util::decay_unwrap_t<F>,
-            util::decay_unwrap_t<Ts>...>
+      : util::detail::invoke_result<util::detail::decay_unwrap_t<F>,
+            util::detail::decay_unwrap_t<Ts>...>
     {
     };
 
@@ -115,16 +115,16 @@ namespace pika::util::detail {
     };
 
     template <typename F, typename... Ts>
-    deferred<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>,
-        util::decay_unwrap_t<Ts>...>
+    deferred<std::decay_t<F>, util::detail::make_index_pack_t<sizeof...(Ts)>,
+        util::detail::decay_unwrap_t<Ts>...>
     deferred_call(F&& f, Ts&&... vs)
     {
         static_assert(pika::detail::is_deferred_invocable_v<F, Ts...>,
             "F shall be Callable with decay_t<Ts> arguments");
 
-        using result_type =
-            deferred<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>,
-                util::decay_unwrap_t<Ts>...>;
+        using result_type = deferred<std::decay_t<F>,
+            util::detail::make_index_pack_t<sizeof...(Ts)>,
+            util::detail::decay_unwrap_t<Ts>...>;
 
         return result_type(PIKA_FORWARD(F, f), PIKA_FORWARD(Ts, vs)...);
     }
diff --git a/libs/pika/functional/include/pika/functional/detail/empty_function.hpp b/libs/pika/functional/include/pika/functional/detail/empty_function.hpp
index 4992593e9..bb1aff817 100644
--- a/libs/pika/functional/include/pika/functional/detail/empty_function.hpp
+++ b/libs/pika/functional/include/pika/functional/detail/empty_function.hpp
@@ -13,7 +13,7 @@
 
 namespace pika::util::detail {
     ///////////////////////////////////////////////////////////////////////////
-    struct empty_function
+    struct trivial_empty_function
     {
     };    // must be trivial and empty
 
@@ -39,14 +39,15 @@ namespace pika::util::detail {
     constexpr function_vtable<Sig, true> const*
     get_empty_function_vtable() noexcept
     {
-        return &vtables<function_vtable<Sig, true>, empty_function>::instance;
+        return &vtables<function_vtable<Sig, true>,
+            trivial_empty_function>::instance;
     }
 #else
     template <typename Sig>
     function_vtable<Sig, true> const* get_empty_function_vtable() noexcept
     {
         static function_vtable<Sig, true> const empty_vtable =
-            detail::construct_vtable<empty_function>();
+            detail::construct_vtable<trivial_empty_function>();
         return &empty_vtable;
     }
 #endif
diff --git a/libs/pika/functional/include/pika/functional/detail/vtable/callable_vtable.hpp b/libs/pika/functional/include/pika/functional/detail/vtable/callable_vtable.hpp
index baaf552dd..3b6a3cbbd 100644
--- a/libs/pika/functional/include/pika/functional/detail/vtable/callable_vtable.hpp
+++ b/libs/pika/functional/include/pika/functional/detail/vtable/callable_vtable.hpp
@@ -20,7 +20,7 @@
 #include <utility>
 
 namespace pika::util::detail {
-    struct empty_function;
+    struct trivial_empty_function;
 
     ///////////////////////////////////////////////////////////////////////////
     struct callable_info_vtable
@@ -70,7 +70,7 @@ namespace pika::util::detail {
         }
 
         constexpr callable_info_vtable(
-            construct_vtable<empty_function>) noexcept
+            construct_vtable<trivial_empty_function>) noexcept
 #if defined(PIKA_HAVE_THREAD_DESCRIPTION)
           : get_function_address(nullptr)
           , get_function_annotation(nullptr)
@@ -107,7 +107,8 @@ namespace pika::util::detail {
             return throw_bad_function_call<R>();
         }
 
-        constexpr callable_vtable(construct_vtable<empty_function>) noexcept
+        constexpr callable_vtable(
+            construct_vtable<trivial_empty_function>) noexcept
           : invoke(&callable_vtable::_empty_invoke)
         {
         }
diff --git a/libs/pika/functional/include/pika/functional/invoke.hpp b/libs/pika/functional/include/pika/functional/invoke.hpp
index be2bc9853..5af441a79 100644
--- a/libs/pika/functional/include/pika/functional/invoke.hpp
+++ b/libs/pika/functional/include/pika/functional/invoke.hpp
@@ -15,7 +15,7 @@
 
 namespace pika::util::detail {
 #define PIKA_INVOKE_R(R, F, ...)                                               \
-    (::pika::util::void_guard<R>(), PIKA_INVOKE(F, __VA_ARGS__))
+    (::pika::util::detail::void_guard<R>(), PIKA_INVOKE(F, __VA_ARGS__))
 
     /// Invokes the given callable object f with the content of
     /// the argument pack vs
diff --git a/libs/pika/functional/include/pika/functional/invoke_fused.hpp b/libs/pika/functional/include/pika/functional/invoke_fused.hpp
index 321d4b60a..9aa9c376d 100644
--- a/libs/pika/functional/include/pika/functional/invoke_fused.hpp
+++ b/libs/pika/functional/include/pika/functional/invoke_fused.hpp
@@ -93,7 +93,7 @@ namespace pika::util::detail {
         F&& f, Tuple&& t)
     {
         using index_pack = typename detail::fused_index_pack<Tuple>::type;
-        return util::void_guard<R>(),
+        return util::detail::void_guard<R>(),
                detail::invoke_fused_impl(
                    index_pack{}, PIKA_FORWARD(F, f), PIKA_FORWARD(Tuple, t));
     }
diff --git a/libs/pika/futures/include/pika/futures/detail/future_data.hpp b/libs/pika/futures/include/pika/futures/detail/future_data.hpp
index 450fb6f3b..df65b6c69 100644
--- a/libs/pika/futures/include/pika/futures/detail/future_data.hpp
+++ b/libs/pika/futures/include/pika/futures/detail/future_data.hpp
@@ -166,10 +166,10 @@ namespace pika { namespace lcos { namespace detail {
     template <>
     struct future_data_result<void>
     {
-        using type = util::unused_type;
+        using type = util::detail::unused_type;
 
-        PIKA_FORCEINLINE static constexpr util::unused_type set(
-            util::unused_type u) noexcept
+        PIKA_FORCEINLINE static constexpr util::detail::unused_type set(
+            util::detail::unused_type u) noexcept
         {
             return u;
         }
@@ -226,7 +226,7 @@ namespace pika { namespace lcos { namespace detail {
 
         using future_data_refcnt_base::completed_callback_type;
         using future_data_refcnt_base::completed_callback_vector_type;
-        using result_type = util::unused_type;
+        using result_type = util::detail::unused_type;
         using init_no_addref = future_data_refcnt_base::init_no_addref;
 
         virtual ~future_data_base();
@@ -427,7 +427,8 @@ namespace pika { namespace lcos { namespace detail {
             return nullptr;
         }
 
-        util::unused_type* get_result_void(error_code& ec = throws) override
+        util::detail::unused_type* get_result_void(
+            error_code& ec = throws) override
         {
             return base_type::get_result_void(&storage_, ec);
         }
diff --git a/libs/pika/futures/include/pika/futures/future.hpp b/libs/pika/futures/include/pika/futures/future.hpp
index 69dfd6c90..c0508536b 100644
--- a/libs/pika/futures/include/pika/futures/future.hpp
+++ b/libs/pika/futures/include/pika/futures/future.hpp
@@ -102,7 +102,7 @@ namespace pika { namespace lcos { namespace detail {
     template <>
     struct future_value<void> : future_data_result<void>
     {
-        PIKA_FORCEINLINE static void get(pika::util::unused_type) {}
+        PIKA_FORCEINLINE static void get(pika::util::detail::unused_type) {}
 
         static void get_default() {}
     };
@@ -120,10 +120,10 @@ namespace pika { namespace lcos { namespace detail {
     };
 
     template <>
-    struct future_get_result<util::unused_type>
+    struct future_get_result<util::detail::unused_type>
     {
         template <typename SharedState>
-        PIKA_FORCEINLINE static util::unused_type* call(
+        PIKA_FORCEINLINE static util::detail::unused_type* call(
             SharedState const& state, error_code& ec = throws)
         {
             return state->get_result_void(ec);
@@ -902,7 +902,7 @@ namespace pika {
         else
         {
             return f.then(pika::launch::sync, [](pika::future<U>&& f) -> R {
-                return util::void_guard<R>(), f.get();
+                return util::detail::void_guard<R>(), f.get();
             });
         }
     }
@@ -1199,7 +1199,7 @@ namespace pika {
         {
             return f.then(
                 pika::launch::sync, [](pika::shared_future<U>&& f) -> R {
-                    return util::void_guard<R>(), f.get();
+                    return util::detail::void_guard<R>(), f.get();
                 });
         }
         // This silences a bogus warning from nvcc about no return from a
@@ -1311,19 +1311,20 @@ namespace pika {
     ///////////////////////////////////////////////////////////////////////////
     // extension: create a pre-initialized future object, with allocator
     template <int DeductionGuard = 0, typename Allocator, typename T>
-    future<pika::util::decay_unwrap_t<T>> make_ready_future_alloc(
+    future<pika::util::detail::decay_unwrap_t<T>> make_ready_future_alloc(
         Allocator const& a, T&& init)
     {
-        return pika::make_ready_future_alloc<pika::util::decay_unwrap_t<T>>(
-            a, PIKA_FORWARD(T, init));
+        return pika::make_ready_future_alloc<
+            pika::util::detail::decay_unwrap_t<T>>(a, PIKA_FORWARD(T, init));
     }
 
     // extension: create a pre-initialized future object
     template <int DeductionGuard = 0, typename T>
-    PIKA_FORCEINLINE future<pika::util::decay_unwrap_t<T>> make_ready_future(
-        T&& init)
+    PIKA_FORCEINLINE future<pika::util::detail::decay_unwrap_t<T>>
+    make_ready_future(T&& init)
     {
-        return pika::make_ready_future_alloc<pika::util::decay_unwrap_t<T>>(
+        return pika::make_ready_future_alloc<
+            pika::util::detail::decay_unwrap_t<T>>(
             pika::detail::internal_allocator<>{}, PIKA_FORWARD(T, init));
     }
 
@@ -1361,10 +1362,10 @@ namespace pika {
     // extension: create a pre-initialized future object which gets ready at
     // a given point in time
     template <int DeductionGuard = 0, typename T>
-    future<pika::util::decay_unwrap_t<T>> make_ready_future_at(
+    future<pika::util::detail::decay_unwrap_t<T>> make_ready_future_at(
         pika::chrono::steady_time_point const& abs_time, T&& init)
     {
-        using result_type = pika::util::decay_unwrap_t<T>;
+        using result_type = pika::util::detail::decay_unwrap_t<T>;
         using shared_state = lcos::detail::timed_future_data<result_type>;
 
         pika::intrusive_ptr<shared_state> p(
@@ -1375,7 +1376,7 @@ namespace pika {
     }
 
     template <int DeductionGuard = 0, typename T>
-    future<pika::util::decay_unwrap_t<T>> make_ready_future_after(
+    future<pika::util::detail::decay_unwrap_t<T>> make_ready_future_after(
         pika::chrono::steady_duration const& rel_time, T&& init)
     {
         return pika::make_ready_future_at(
@@ -1387,14 +1388,14 @@ namespace pika {
     template <typename Allocator>
     inline future<void> make_ready_future_alloc(Allocator const& a)
     {
-        return pika::make_ready_future_alloc<void>(a, util::unused);
+        return pika::make_ready_future_alloc<void>(a, util::detail::unused);
     }
 
     // extension: create a pre-initialized future object
     PIKA_FORCEINLINE future<void> make_ready_future()
     {
         return make_ready_future_alloc<void>(
-            pika::detail::internal_allocator<>{}, util::unused);
+            pika::detail::internal_allocator<>{}, util::detail::unused);
     }
 
     // Extension (see wg21.link/P0319)
@@ -1413,7 +1414,7 @@ namespace pika {
         using shared_state = lcos::detail::timed_future_data<void>;
 
         return pika::traits::future_access<future<void>>::create(
-            new shared_state(abs_time.value(), pika::util::unused));
+            new shared_state(abs_time.value(), pika::util::detail::unused));
     }
 
     template <typename T>
diff --git a/libs/pika/futures/include/pika/futures/packaged_continuation.hpp b/libs/pika/futures/include/pika/futures/packaged_continuation.hpp
index a85c7ad68..4ed506ead 100644
--- a/libs/pika/futures/include/pika/futures/packaged_continuation.hpp
+++ b/libs/pika/futures/include/pika/futures/packaged_continuation.hpp
@@ -65,7 +65,7 @@ namespace pika { namespace lcos { namespace detail {
         pika::detail::try_catch_exception_ptr(
             [&]() {
                 func(PIKA_FORWARD(Future, future));
-                cont.set_value(util::unused);
+                cont.set_value(util::detail::unused);
             },
             [&](std::exception_ptr ep) { cont.set_exception(PIKA_MOVE(ep)); });
     }
diff --git a/libs/pika/futures/include/pika/futures/promise.hpp b/libs/pika/futures/include/pika/futures/promise.hpp
index 3ca48a5ad..9a675cae0 100644
--- a/libs/pika/futures/include/pika/futures/promise.hpp
+++ b/libs/pika/futures/include/pika/futures/promise.hpp
@@ -525,7 +525,7 @@ namespace pika { namespace lcos { namespace local {
         //   - no_state if *this has no shared state.
         void set_value()
         {
-            base_type::set_value(pika::util::unused);
+            base_type::set_value(pika::util::detail::unused);
         }
 
         // Effects: atomically stores the exception pointer p in the shared
diff --git a/libs/pika/futures/include/pika/futures/traits/future_access.hpp b/libs/pika/futures/include/pika/futures/traits/future_access.hpp
index 9c7e80e2e..40980565c 100644
--- a/libs/pika/futures/include/pika/futures/traits/future_access.hpp
+++ b/libs/pika/futures/include/pika/futures/traits/future_access.hpp
@@ -200,7 +200,7 @@ namespace pika { namespace traits {
             pika::future<R>&& src, Destination& dest, std::true_type)
         {
             src.get();
-            dest.set_value(util::unused);
+            dest.set_value(util::detail::unused);
         }
 
     public:
@@ -278,7 +278,7 @@ namespace pika { namespace traits {
             pika::shared_future<R>&& src, Destination& dest, std::true_type)
         {
             src.get();
-            dest.set_value(util::unused);
+            dest.set_value(util::detail::unused);
         }
 
     public:
diff --git a/libs/pika/futures/include/pika/futures/traits/future_then_result.hpp b/libs/pika/futures/include/pika/futures/traits/future_then_result.hpp
index ed896169c..8926c34bd 100644
--- a/libs/pika/futures/include/pika/futures/traits/future_then_result.hpp
+++ b/libs/pika/futures/include/pika/futures/traits/future_then_result.hpp
@@ -11,8 +11,8 @@
 #include <pika/functional/invoke_result.hpp>
 #include <pika/futures/traits/future_traits.hpp>
 #include <pika/futures/traits/is_future.hpp>
-#include <pika/type_support/identity.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
+#include <pika/type_support/type_identity.hpp>
 
 #include <type_traits>
 #include <utility>
@@ -53,10 +53,10 @@ namespace pika { namespace traits {
             using cont_result = pika::util::detail::invoke_result_t<F&, Future>;
 
             // perform unwrapping of future<future<R>>
-            using result_type = util::lazy_conditional_t<
+            using result_type = util::detail::lazy_conditional_t<
                 pika::traits::detail::is_unique_future<cont_result>::value,
                 pika::traits::future_traits<cont_result>,
-                pika::util::identity<cont_result>>;
+                pika::detail::type_identity<cont_result>>;
 
             using type = pika::future<result_type>;
         };
diff --git a/libs/pika/futures/include/pika/futures/traits/is_future_tuple.hpp b/libs/pika/futures/include/pika/futures/traits/is_future_tuple.hpp
index a1edba3e0..9a16c77c8 100644
--- a/libs/pika/futures/include/pika/futures/traits/is_future_tuple.hpp
+++ b/libs/pika/futures/include/pika/futures/traits/is_future_tuple.hpp
@@ -19,7 +19,8 @@ namespace pika { namespace traits {
     };
 
     template <typename... Ts>
-    struct is_future_tuple<std::tuple<Ts...>> : util::all_of<is_future<Ts>...>
+    struct is_future_tuple<std::tuple<Ts...>>
+      : util::detail::all_of<is_future<Ts>...>
     {
     };
 }}    // namespace pika::traits
diff --git a/libs/pika/futures/include/pika/futures/traits/promise_local_result.hpp b/libs/pika/futures/include/pika/futures/traits/promise_local_result.hpp
index 89a1368d9..e962b500c 100644
--- a/libs/pika/futures/include/pika/futures/traits/promise_local_result.hpp
+++ b/libs/pika/futures/include/pika/futures/traits/promise_local_result.hpp
@@ -18,7 +18,7 @@ namespace pika { namespace traits {
     };
 
     template <>
-    struct promise_local_result<util::unused_type>
+    struct promise_local_result<util::detail::unused_type>
     {
         using type = void;
     };
diff --git a/libs/pika/futures/include/pika/futures/traits/promise_remote_result.hpp b/libs/pika/futures/include/pika/futures/traits/promise_remote_result.hpp
index 6482f5159..4abac52b1 100644
--- a/libs/pika/futures/include/pika/futures/traits/promise_remote_result.hpp
+++ b/libs/pika/futures/include/pika/futures/traits/promise_remote_result.hpp
@@ -18,7 +18,7 @@ namespace pika { namespace traits {
     template <>
     struct promise_remote_result<void>
     {
-        using type = pika::util::unused_type;
+        using type = pika::util::detail::unused_type;
     };
 
     template <typename Result>
diff --git a/libs/pika/futures/src/future_data.cpp b/libs/pika/futures/src/future_data.cpp
index 09d4b34fb..53e381a0c 100644
--- a/libs/pika/futures/src/future_data.cpp
+++ b/libs/pika/futures/src/future_data.cpp
@@ -90,9 +90,9 @@ namespace pika { namespace lcos { namespace detail {
     future_data_base<traits::detail::future_data_void>::~future_data_base() =
         default;
 
-    static util::unused_type unused_;
+    static util::detail::unused_type unused_;
 
-    util::unused_type*
+    util::detail::unused_type*
     future_data_base<traits::detail::future_data_void>::get_result_void(
         void const* storage, error_code& ec)
     {
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/boost_iterator_categories.hpp b/libs/pika/iterator_support/include/pika/iterator_support/boost_iterator_categories.hpp
index a270c1939..190740b97 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/boost_iterator_categories.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/boost_iterator_categories.hpp
@@ -12,8 +12,8 @@
 
 #if !defined(PIKA_HAVE_BOOST_ITERATOR_TRAVERSAL_TAG_COMPATIBILITY)
 
-#include <pika/type_support/identity.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
+#include <pika/type_support/type_identity.hpp>
 
 #include <iterator>
 #include <type_traits>
@@ -53,28 +53,30 @@ namespace pika { namespace iterators {
         // for new-style types.
         template <typename Cat>
         struct std_category_to_traversal
-          : pika::util::lazy_conditional<
+          : pika::util::detail::lazy_conditional<
                 std::is_convertible<Cat,
                     std::random_access_iterator_tag>::value,
-                pika::util::identity<random_access_traversal_tag>,
-                pika::util::lazy_conditional<
+                ::pika::detail::type_identity<random_access_traversal_tag>,
+                pika::util::detail::lazy_conditional<
                     std::is_convertible<Cat,
                         std::bidirectional_iterator_tag>::value,
-                    pika::util::identity<bidirectional_traversal_tag>,
-                    pika::util::lazy_conditional<
+                    ::pika::detail::type_identity<bidirectional_traversal_tag>,
+                    pika::util::detail::lazy_conditional<
                         std::is_convertible<Cat,
                             std::forward_iterator_tag>::value,
-                        pika::util::identity<forward_traversal_tag>,
-                        pika::util::lazy_conditional<
+                        ::pika::detail::type_identity<forward_traversal_tag>,
+                        pika::util::detail::lazy_conditional<
                             std::is_convertible<Cat,
                                 std::input_iterator_tag>::value,
-                            pika::util::identity<single_pass_traversal_tag>,
-                            pika::util::lazy_conditional<
+                            ::pika::detail::type_identity<
+                                single_pass_traversal_tag>,
+                            pika::util::detail::lazy_conditional<
                                 std::is_convertible<Cat,
                                     std::output_iterator_tag>::value,
-                                pika::util::identity<
+                                ::pika::detail::type_identity<
                                     incrementable_traversal_tag>,
-                                pika::util::identity<no_traversal_tag>>>>>>
+                                ::pika::detail::type_identity<
+                                    no_traversal_tag>>>>>>
         {
         };
     }    // namespace detail
@@ -82,9 +84,10 @@ namespace pika { namespace iterators {
     // Convert an iterator category into a traversal tag
     template <typename Cat>
     struct iterator_category_to_traversal
-      : pika::util::lazy_conditional<
+      : pika::util::detail::lazy_conditional<
             std::is_convertible<Cat, incrementable_traversal_tag>::value,
-            pika::util::identity<Cat>, detail::std_category_to_traversal<Cat>>
+            ::pika::detail::type_identity<Cat>,
+            detail::std_category_to_traversal<Cat>>
     {
     };
 
@@ -99,25 +102,28 @@ namespace pika { namespace iterators {
     // Convert an iterator traversal to one of the traversal tags.
     template <typename Traversal>
     struct pure_traversal_tag
-      : pika::util::lazy_conditional<
+      : pika::util::detail::lazy_conditional<
             std::is_convertible<Traversal, random_access_traversal_tag>::value,
-            pika::util::identity<random_access_traversal_tag>,
-            pika::util::lazy_conditional<
+            ::pika::detail::type_identity<random_access_traversal_tag>,
+            pika::util::detail::lazy_conditional<
                 std::is_convertible<Traversal,
                     bidirectional_traversal_tag>::value,
-                pika::util::identity<bidirectional_traversal_tag>,
-                pika::util::lazy_conditional<std::is_convertible<Traversal,
-                                                 forward_traversal_tag>::value,
-                    pika::util::identity<forward_traversal_tag>,
-                    pika::util::lazy_conditional<
+                ::pika::detail::type_identity<bidirectional_traversal_tag>,
+                pika::util::detail::lazy_conditional<
+                    std::is_convertible<Traversal,
+                        forward_traversal_tag>::value,
+                    ::pika::detail::type_identity<forward_traversal_tag>,
+                    pika::util::detail::lazy_conditional<
                         std::is_convertible<Traversal,
                             single_pass_traversal_tag>::value,
-                        pika::util::identity<single_pass_traversal_tag>,
-                        pika::util::lazy_conditional<
+                        ::pika::detail::type_identity<
+                            single_pass_traversal_tag>,
+                        pika::util::detail::lazy_conditional<
                             std::is_convertible<Traversal,
                                 incrementable_traversal_tag>::value,
-                            pika::util::identity<incrementable_traversal_tag>,
-                            pika::util::identity<no_traversal_tag>>>>>>
+                            ::pika::detail::type_identity<
+                                incrementable_traversal_tag>,
+                            ::pika::detail::type_identity<no_traversal_tag>>>>>>
     {
     };
 
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/counting_iterator.hpp b/libs/pika/iterator_support/include/pika/iterator_support/counting_iterator.hpp
index e463d8744..fd63bda66 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/counting_iterator.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/counting_iterator.hpp
@@ -14,8 +14,8 @@
 #include <pika/iterator_support/iterator_range.hpp>
 #include <pika/iterator_support/range.hpp>
 #include <pika/iterator_support/traits/is_range.hpp>
-#include <pika/type_support/identity.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
+#include <pika/type_support/type_identity.hpp>
 
 #include <cstddef>
 #include <iterator>
@@ -41,14 +41,14 @@ namespace pika { namespace util {
                     typename std::iterator_traits<Iterator>::iterator_category;
             };
 
-            using base_traversal =
-                util::lazy_conditional<std::is_integral<Incrementable>::value,
-                    util::identity<std::random_access_iterator_tag>,
-                    iterator_category<Incrementable>>;
+            using base_traversal = util::detail::lazy_conditional<
+                std::is_integral<Incrementable>::value,
+                ::pika::detail::type_identity<std::random_access_iterator_tag>,
+                iterator_category<Incrementable>>;
 
-            using traversal = typename util::lazy_conditional<
+            using traversal = util::detail::lazy_conditional_t<
                 std::is_void<CategoryOrTraversal>::value, base_traversal,
-                util::identity<CategoryOrTraversal>>::type;
+                ::pika::detail::type_identity<CategoryOrTraversal>>;
 
             // calculate difference_type of the resulting iterator
             template <typename Integer>
@@ -71,14 +71,14 @@ namespace pika { namespace util {
                     typename std::iterator_traits<Iterator>::difference_type;
             };
 
-            using base_difference =
-                util::lazy_conditional<std::is_integral<Incrementable>::value,
-                    integer_difference_type<Incrementable>,
-                    iterator_difference_type<Incrementable>>;
+            using base_difference = util::detail::lazy_conditional<
+                std::is_integral<Incrementable>::value,
+                integer_difference_type<Incrementable>,
+                iterator_difference_type<Incrementable>>;
 
-            using difference =
-                typename util::lazy_conditional<std::is_void<Difference>::value,
-                    base_difference, util::identity<Difference>>::type;
+            using difference = util::detail::lazy_conditional_t<
+                std::is_void<Difference>::value, base_difference,
+                ::pika::detail::type_identity<Difference>>;
 
             using type = iterator_adaptor<counting_iterator<Incrementable,
                                               CategoryOrTraversal, Difference>,
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/iterator_adaptor.hpp b/libs/pika/iterator_support/include/pika/iterator_support/iterator_adaptor.hpp
index 8b9dadfb0..1432b0354 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/iterator_adaptor.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/iterator_adaptor.hpp
@@ -14,8 +14,8 @@
 #include <pika/config.hpp>
 #include <pika/iterator_support/iterator_facade.hpp>
 #include <pika/iterator_support/traits/is_iterator.hpp>
-#include <pika/type_support/identity.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
+#include <pika/type_support/type_identity.hpp>
 
 #include <algorithm>
 #include <iterator>
@@ -62,29 +62,31 @@ namespace pika { namespace util {
         {
             // the following type calculations use lazy_conditional to avoid
             // premature instantiations
-            using value_type = typename std::conditional<
-                std::is_void<Value>::value,
-                typename util::lazy_conditional<std::is_void<Reference>::value,
-                    value_type_iterator_traits_helper<Base>,
-                    std::remove_reference<Reference>>::type,
-                Value>::type;
+            using value_type =
+                typename std::conditional<std::is_void<Value>::value,
+                    typename util::detail::lazy_conditional<
+                        std::is_void<Reference>::value,
+                        value_type_iterator_traits_helper<Base>,
+                        std::remove_reference<Reference>>::type,
+                    Value>::type;
 
             using reference_type =
                 typename std::conditional<std::is_void<Reference>::value,
-                    typename util::lazy_conditional<std::is_void<Value>::value,
+                    typename util::detail::lazy_conditional<
+                        std::is_void<Value>::value,
                         reference_iterator_traits_helper<Base>,
                         std::add_lvalue_reference<Value>>::type,
                     Reference>::type;
 
             using iterator_category =
-                typename util::lazy_conditional<std::is_void<Category>::value,
+                util::detail::lazy_conditional_t<std::is_void<Category>::value,
                     category_iterator_traits_helper<Base>,
-                    util::identity<Category>>::type;
+                    ::pika::detail::type_identity<Category>>;
 
-            using difference_type =
-                typename util::lazy_conditional<std::is_void<Difference>::value,
-                    difference_type_iterator_traits_helper<Base>,
-                    util::identity<Difference>>::type;
+            using difference_type = util::detail::lazy_conditional_t<
+                std::is_void<Difference>::value,
+                difference_type_iterator_traits_helper<Base>,
+                ::pika::detail::type_identity<Difference>>;
 
             using type = iterator_facade<Derived, value_type, iterator_category,
                 reference_type, difference_type, Pointer>;
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/traits/is_iterator.hpp b/libs/pika/iterator_support/include/pika/iterator_support/traits/is_iterator.hpp
index 0df1871b7..6af33afce 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/traits/is_iterator.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/traits/is_iterator.hpp
@@ -175,17 +175,16 @@ namespace pika { namespace traits {
         template <typename Iter>
         struct bidirectional_concept<Iter,
             std::void_t<typename dereference_result<Iter>::type,
-                typename equality_result<Iter, Iter>::type,
-                typename inequality_result<Iter, Iter>::type,
+                equality_result_t<Iter, Iter>, inequality_result_t<Iter, Iter>,
                 typename predecrement_result<Iter>::type,
                 typename preincrement_result<Iter>::type,
                 typename postdecrement_result<Iter>::type,
                 typename postincrement_result<Iter>::type>>
           : std::integral_constant<bool,
                 std::is_convertible<bool,
-                    typename equality_result<Iter, Iter>::type>::value &&
+                    equality_result_t<Iter, Iter>>::value &&
                     std::is_convertible<bool,
-                        typename inequality_result<Iter, Iter>::type>::value &&
+                        inequality_result_t<Iter, Iter>>::value &&
                     std::is_same<typename std::add_lvalue_reference<Iter>::type,
                         typename predecrement_result<Iter>::type>::value &&
                     std::is_same<typename std::add_lvalue_reference<Iter>::type,
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/traits/is_sentinel_for.hpp b/libs/pika/iterator_support/include/pika/iterator_support/traits/is_sentinel_for.hpp
index 7412dd85a..a78ac1a4b 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/traits/is_sentinel_for.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/traits/is_sentinel_for.hpp
@@ -26,7 +26,7 @@ namespace pika { namespace traits {
     template <typename Sent, typename Iter>
     struct is_sentinel_for<Sent, Iter,
         typename std::enable_if_t<is_iterator_v<Iter> &&
-            is_weakly_equality_comparable_with<Iter, Sent>::value>>
+            detail::is_weakly_equality_comparable_with_v<Iter, Sent>>>
       : std::true_type
     {
     };
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/transform_iterator.hpp b/libs/pika/iterator_support/include/pika/iterator_support/transform_iterator.hpp
index 667afa186..f99f70a0a 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/transform_iterator.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/transform_iterator.hpp
@@ -9,8 +9,8 @@
 #include <pika/config.hpp>
 #include <pika/functional/invoke_result.hpp>
 #include <pika/iterator_support/iterator_adaptor.hpp>
-#include <pika/type_support/identity.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
+#include <pika/type_support/type_identity.hpp>
 
 #include <iterator>
 #include <type_traits>
@@ -31,25 +31,25 @@ namespace pika { namespace util {
         {
             // the following type calculations use lazy_conditional to avoid
             // premature instantiations
-            using reference_type =
-                typename util::lazy_conditional<std::is_void<Reference>::value,
-                    util::detail::invoke_result<Transformer, Iterator>,
-                    util::identity<Reference>>::type;
-
-            using value_type =
-                typename util::lazy_conditional<std::is_void<Value>::value,
-                    std::remove_reference<reference_type>,
-                    util::identity<Value>>::type;
-
-            using iterator_category =
-                typename util::lazy_conditional<std::is_void<Category>::value,
-                    category_iterator_traits_helper<Iterator>,
-                    util::identity<Category>>::type;
-
-            using difference_type =
-                typename util::lazy_conditional<std::is_void<Difference>::value,
-                    difference_type_iterator_traits_helper<Iterator>,
-                    util::identity<Difference>>::type;
+            using reference_type = typename util::detail::lazy_conditional<
+                std::is_void<Reference>::value,
+                util::detail::invoke_result<Transformer, Iterator>,
+                ::pika::detail::type_identity<Reference>>::type;
+
+            using value_type = typename util::detail::lazy_conditional<
+                std::is_void<Value>::value,
+                std::remove_reference<reference_type>,
+                ::pika::detail::type_identity<Value>>::type;
+
+            using iterator_category = typename util::detail::lazy_conditional<
+                std::is_void<Category>::value,
+                category_iterator_traits_helper<Iterator>,
+                ::pika::detail::type_identity<Category>>::type;
+
+            using difference_type = typename util::detail::lazy_conditional<
+                std::is_void<Difference>::value,
+                difference_type_iterator_traits_helper<Iterator>,
+                ::pika::detail::type_identity<Difference>>::type;
 
             using type = pika::util::iterator_adaptor<
                 transform_iterator<Iterator, Transformer, Reference, Value,
diff --git a/libs/pika/iterator_support/include/pika/iterator_support/zip_iterator.hpp b/libs/pika/iterator_support/include/pika/iterator_support/zip_iterator.hpp
index 95f1a9cd5..62f5270a5 100644
--- a/libs/pika/iterator_support/include/pika/iterator_support/zip_iterator.hpp
+++ b/libs/pika/iterator_support/include/pika/iterator_support/zip_iterator.hpp
@@ -213,8 +213,8 @@ namespace pika { namespace util {
             template <std::size_t... Is>
             PIKA_HOST_DEVICE static
                 typename zip_iterator_reference<std::tuple<Ts...>>::type
-                call(
-                    util::index_pack<Is...>, std::tuple<Ts...> const& iterators)
+                call(util::detail::index_pack<Is...>,
+                    std::tuple<Ts...> const& iterators)
             {
                 return std::forward_as_tuple(*std::get<Is>(iterators)...);
             }
@@ -300,8 +300,8 @@ namespace pika { namespace util {
             PIKA_HOST_DEVICE typename base_type::reference dereference() const
             {
                 return dereference_iterator<IteratorTuple>::call(
-                    typename util::make_index_pack<
-                        std::tuple_size<IteratorTuple>::value>::type(),
+                    util::detail::make_index_pack_t<
+                        std::tuple_size<IteratorTuple>::value>(),
                     iterators_);
             }
 
@@ -328,7 +328,7 @@ namespace pika { namespace util {
 
         private:
             template <typename F, std::size_t... Is>
-            PIKA_HOST_DEVICE void apply(F&& f, util::index_pack<Is...>)
+            PIKA_HOST_DEVICE void apply(F&& f, util::detail::index_pack<Is...>)
             {
                 int const _sequencer[] = {
                     ((f(std::get<Is>(iterators_))), 0)...};
@@ -339,7 +339,7 @@ namespace pika { namespace util {
             PIKA_HOST_DEVICE void apply(F&& f)
             {
                 return apply(PIKA_FORWARD(F, f),
-                    util::make_index_pack<
+                    util::detail::make_index_pack<
                         std::tuple_size<IteratorTuple>::value>());
             }
 
@@ -530,7 +530,7 @@ namespace pika { namespace traits {
 
             template <std::size_t... Is, typename... Ts_>
             static result_type call(
-                util::index_pack<Is...>, std::tuple<Ts_...> const& t)
+                util::detail::index_pack<Is...>, std::tuple<Ts_...> const& t)
             {
                 return std::make_tuple(
                     typename F::template apply<Ts>()(std::get<Is>(t))...);
@@ -539,7 +539,7 @@ namespace pika { namespace traits {
             template <typename... Ts_>
             static result_type call(util::zip_iterator<Ts_...> const& iter)
             {
-                using pika::util::make_index_pack;
+                using pika::util::detail::make_index_pack;
                 return call(typename make_index_pack<sizeof...(Ts)>::type(),
                     iter.get_iterator_tuple());
             }
diff --git a/libs/pika/iterator_support/tests/unit/is_iterator.cpp b/libs/pika/iterator_support/tests/unit/is_iterator.cpp
index 8f3037aba..1c5feeea2 100644
--- a/libs/pika/iterator_support/tests/unit/is_iterator.cpp
+++ b/libs/pika/iterator_support/tests/unit/is_iterator.cpp
@@ -285,6 +285,7 @@ void dereference_result()
 void equality_result()
 {
     using pika::traits::detail::equality_result;
+    using pika::traits::detail::equality_result_t;
 
     struct A
     {
@@ -301,9 +302,7 @@ void equality_result()
         }
     };
 
-    PIKA_TEST_MSG(
-        (std::is_same<B, typename equality_result<C, A>::type>::value),
-        "deduced type");
+    PIKA_TEST_MSG((std::is_same_v<B, equality_result_t<C, A>>), "deduced type");
 
     PIKA_TEST_MSG(
         (!has_nested_type<equality_result<B, A>>::value), "invalid operation");
@@ -312,6 +311,7 @@ void equality_result()
 void inequality_result()
 {
     using pika::traits::detail::inequality_result;
+    using pika::traits::detail::inequality_result_t;
 
     struct A
     {
@@ -329,8 +329,7 @@ void inequality_result()
     };
 
     PIKA_TEST_MSG(
-        (std::is_same<B, typename inequality_result<C, A>::type>::value),
-        "deduced type");
+        (std::is_same_v<B, inequality_result_t<C, A>>), "deduced type");
 
     PIKA_TEST_MSG((!has_nested_type<inequality_result<B, A>>::value),
         "invalid operation");
diff --git a/libs/pika/lcos/include/pika/lcos/channel.hpp b/libs/pika/lcos/include/pika/lcos/channel.hpp
index 1f738fae4..756c618a8 100644
--- a/libs/pika/lcos/include/pika/lcos/channel.hpp
+++ b/libs/pika/lcos/include/pika/lcos/channel.hpp
@@ -919,10 +919,10 @@ namespace pika { namespace lcos { namespace local {
     template <>
     class channel_iterator<void>
       : public pika::util::iterator_facade<channel_iterator<void>,
-            util::unused_type const, std::input_iterator_tag>
+            util::detail::unused_type const, std::input_iterator_tag>
     {
         using base_type = pika::util::iterator_facade<channel_iterator<void>,
-            util::unused_type const, std::input_iterator_tag>;
+            util::detail::unused_type const, std::input_iterator_tag>;
 
     public:
         channel_iterator()
@@ -937,7 +937,7 @@ namespace pika { namespace lcos { namespace local {
     private:
         bool get_checked()
         {
-            pika::future<util::unused_type> f;
+            pika::future<util::detail::unused_type> f;
             if (channel_->try_get(std::size_t(-1), &f))
             {
                 f.get();
@@ -964,11 +964,12 @@ namespace pika { namespace lcos { namespace local {
         base_type::reference dereference() const
         {
             PIKA_ASSERT(data_);
-            return util::unused;
+            return util::detail::unused;
         }
 
     private:
-        pika::intrusive_ptr<detail::channel_impl_base<util::unused_type>>
+        pika::intrusive_ptr<
+            detail::channel_impl_base<util::detail::unused_type>>
             channel_;
         bool data_;
     };
@@ -981,7 +982,7 @@ namespace pika { namespace lcos { namespace local {
         {
         public:
             explicit channel_base(
-                detail::channel_impl_base<util::unused_type>* impl)
+                detail::channel_impl_base<util::detail::unused_type>* impl)
               : channel_(impl)
             {
             }
@@ -1012,17 +1013,20 @@ namespace pika { namespace lcos { namespace local {
             ///////////////////////////////////////////////////////////////////////
             void set(std::size_t generation = std::size_t(-1))
             {
-                channel_->set(generation, pika::util::unused_type()).get();
+                channel_->set(generation, pika::util::detail::unused_type())
+                    .get();
             }
             void set(
                 launch::sync_policy, std::size_t generation = std::size_t(-1))
             {
-                channel_->set(generation, pika::util::unused_type()).get();
+                channel_->set(generation, pika::util::detail::unused_type())
+                    .get();
             }
             pika::future<void> set(
                 launch::async_policy, std::size_t generation = std::size_t(-1))
             {
-                return channel_->set(generation, pika::util::unused_type());
+                return channel_->set(
+                    generation, pika::util::detail::unused_type());
             }
 
             std::size_t close(bool force_delete_entries = false)
@@ -1054,14 +1058,15 @@ namespace pika { namespace lcos { namespace local {
             }
 
             ///////////////////////////////////////////////////////////////////
-            constexpr channel_impl_base<util::unused_type>* get_channel_impl()
-                const noexcept
+            constexpr channel_impl_base<util::detail::unused_type>*
+            get_channel_impl() const noexcept
             {
                 return channel_.get();
             }
 
         protected:
-            pika::intrusive_ptr<channel_impl_base<util::unused_type>> channel_;
+            pika::intrusive_ptr<channel_impl_base<util::detail::unused_type>>
+                channel_;
         };
     }    // namespace detail
 
@@ -1080,7 +1085,8 @@ namespace pika { namespace lcos { namespace local {
         using value_type = void;
 
         channel()
-          : base_type(new detail::unlimited_channel<util::unused_type>())
+          : base_type(
+                new detail::unlimited_channel<util::detail::unused_type>())
         {
         }
 
@@ -1106,7 +1112,8 @@ namespace pika { namespace lcos { namespace local {
         using value_type = void;
 
         one_element_channel()
-          : base_type(new detail::one_element_channel<util::unused_type>())
+          : base_type(
+                new detail::one_element_channel<util::detail::unused_type>())
         {
         }
 
diff --git a/libs/pika/lcos/tests/unit/dataflow_external_future.cpp b/libs/pika/lcos/tests/unit/dataflow_external_future.cpp
index 4f2a6876d..0017fd0b1 100644
--- a/libs/pika/lcos/tests/unit/dataflow_external_future.cpp
+++ b/libs/pika/lcos/tests/unit/dataflow_external_future.cpp
@@ -81,7 +81,7 @@ struct external_future_executor
                     frame_p(frame);
                 pika::apply([frame_p = std::move(frame_p)]() {
                     pika::util::yield_while([]() { return !done; });
-                    frame_p->set_data(pika::util::unused_type{});
+                    frame_p->set_data(pika::util::detail::unused_type{});
                 });
             },
             [&](std::exception_ptr ep) {
@@ -180,7 +180,7 @@ struct external_future_additional_argument_executor
                     frame_p(frame);
                 pika::apply([frame_p = std::move(frame_p)]() {
                     pika::util::yield_while([]() { return !done; });
-                    frame_p->set_data(pika::util::unused_type{});
+                    frame_p->set_data(pika::util::detail::unused_type{});
                 });
             },
             [&](std::exception_ptr ep) {
diff --git a/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_async_impl.hpp b/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_async_impl.hpp
index d4b1117fa..bbbccb573 100644
--- a/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_async_impl.hpp
+++ b/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_async_impl.hpp
@@ -487,8 +487,8 @@ namespace pika {
             template <typename Current>
             void async_traverse_one(Current&& current)
             {
-                using ElementType =
-                    typename pika::util::decay_unwrap<decltype(*current)>::type;
+                using ElementType = typename pika::util::detail::decay_unwrap<
+                    decltype(*current)>::type;
                 return async_traverse_one_impl(
                     container_category_of_t<ElementType>{},
                     PIKA_FORWARD(Current, current));
diff --git a/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_impl.hpp b/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_impl.hpp
index 3b26e1d0f..601724917 100644
--- a/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_impl.hpp
+++ b/libs/pika/pack_traversal/include/pika/pack_traversal/detail/pack_traversal_impl.hpp
@@ -218,7 +218,7 @@ namespace pika { namespace util { namespace detail {
         /// Deduces to a true_type if any of the given types marks
         /// the underlying type to be spread into the current context.
         template <typename... T>
-        using is_any_spread_t = util::any_of<is_spread<T>...>;
+        using is_any_spread_t = util::detail::any_of<is_spread<T>...>;
 
         template <typename C, typename... T>
         constexpr auto map_spread(C&& callable, T&&... args)
@@ -847,7 +847,7 @@ namespace pika { namespace util { namespace detail {
         auto traverse(Strategy, T&& element)
             -> decltype(std::declval<mapping_helper>().match(
                 std::declval<container_category_of_t<
-                    typename pika::util::decay_unwrap<T>::type>>(),
+                    typename pika::util::detail::decay_unwrap<T>::type>>(),
                 std::declval<T>()));
 
         /// \copybrief traverse
@@ -855,14 +855,15 @@ namespace pika { namespace util { namespace detail {
         auto try_traverse(Strategy, T&& element)
             -> decltype(std::declval<mapping_helper>().try_match(
                 std::declval<container_category_of_t<
-                    typename pika::util::decay_unwrap<T>::type>>(),
+                    typename pika::util::detail::decay_unwrap<T>::type>>(),
                 std::declval<T>()))
         {
             // We use tag dispatching here, to categorize the type T whether
             // it satisfies the container or tuple like requirements.
             // Then we can choose the underlying implementation accordingly.
-            return try_match(container_category_of_t<
-                                 typename pika::util::decay_unwrap<T>::type>{},
+            return try_match(
+                container_category_of_t<
+                    typename pika::util::detail::decay_unwrap<T>::type>{},
                 PIKA_FORWARD(T, element));
         }
 
diff --git a/libs/pika/resource_partitioner/tests/unit/async_customization.cpp b/libs/pika/resource_partitioner/tests/unit/async_customization.cpp
index cdedd9bf8..a3409cd57 100644
--- a/libs/pika/resource_partitioner/tests/unit/async_customization.cpp
+++ b/libs/pika/resource_partitioner/tests/unit/async_customization.cpp
@@ -42,8 +42,8 @@ struct test_async_executor
 
     template <typename... Futures>
     struct is_tuple_of_futures<std::tuple<Futures...>>
-      : util::all_of<
-            traits::is_future<typename std::remove_reference<Futures>::type>...>
+      : util::detail::all_of<
+            traits::is_future<std::remove_reference_t<Futures>>...>
     {
     };
 
diff --git a/libs/pika/threading_base/include/pika/threading_base/annotated_function.hpp b/libs/pika/threading_base/include/pika/threading_base/annotated_function.hpp
index 3a498b759..60dc87d27 100644
--- a/libs/pika/threading_base/include/pika/threading_base/annotated_function.hpp
+++ b/libs/pika/threading_base/include/pika/threading_base/annotated_function.hpp
@@ -37,7 +37,7 @@ namespace pika {
         template <typename F>
         struct annotated_function
         {
-            using fun_type = util::decay_unwrap_t<F>;
+            using fun_type = util::detail::decay_unwrap_t<F>;
 
             annotated_function() noexcept
               : name_(nullptr)
diff --git a/libs/pika/type_support/CMakeLists.txt b/libs/pika/type_support/CMakeLists.txt
index 1521aec92..d212f3ccb 100644
--- a/libs/pika/type_support/CMakeLists.txt
+++ b/libs/pika/type_support/CMakeLists.txt
@@ -11,11 +11,10 @@ set(type_support_headers
     pika/type_support/detected.hpp
     pika/type_support/empty_function.hpp
     pika/type_support/equality.hpp
-    pika/type_support/identity.hpp
     pika/type_support/lazy_conditional.hpp
-    pika/type_support/lazy_enable_if.hpp
     pika/type_support/pack.hpp
-    pika/type_support/unwrap_ref.hpp
+    pika/type_support/type_identity.hpp
+    pika/type_support/unwrap_reference.hpp
     pika/type_support/unused.hpp
     pika/type_support/void_guard.hpp
 )
diff --git a/libs/pika/type_support/include/pika/type_support/decay.hpp b/libs/pika/type_support/include/pika/type_support/decay.hpp
index f21c17585..b847a92f2 100644
--- a/libs/pika/type_support/include/pika/type_support/decay.hpp
+++ b/libs/pika/type_support/include/pika/type_support/decay.hpp
@@ -13,21 +13,19 @@
 #include <type_traits>
 #include <utility>
 
-namespace pika { namespace util {
+namespace pika::util::detail {
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail {
-        template <typename TD>
-        struct decay_unwrap_impl
-        {
-            using type = TD;
-        };
+    template <typename TD>
+    struct decay_unwrap_impl
+    {
+        using type = TD;
+    };
 
-        template <typename X>
-        struct decay_unwrap_impl<::std::reference_wrapper<X>>
-        {
-            using type = X&;
-        };
-    }    // namespace detail
+    template <typename X>
+    struct decay_unwrap_impl<::std::reference_wrapper<X>>
+    {
+        using type = X&;
+    };
 
     template <typename T>
     struct decay_unwrap : detail::decay_unwrap_impl<std::decay_t<T>>
@@ -36,4 +34,4 @@ namespace pika { namespace util {
 
     template <typename T>
     using decay_unwrap_t = typename decay_unwrap<T>::type;
-}}    // namespace pika::util
+}    // namespace pika::util::detail
diff --git a/libs/pika/type_support/include/pika/type_support/detail/with_result_of.hpp b/libs/pika/type_support/include/pika/type_support/detail/with_result_of.hpp
index 3cd917cbe..69512664f 100644
--- a/libs/pika/type_support/include/pika/type_support/detail/with_result_of.hpp
+++ b/libs/pika/type_support/include/pika/type_support/detail/with_result_of.hpp
@@ -8,7 +8,7 @@
 
 #include <utility>
 
-namespace pika { namespace util { namespace detail {
+namespace pika::util::detail {
     // Based on
     // https://quuxplusone.github.io/blog/2018/05/17/super-elider-round-2/ and
     // https://akrzemi1.wordpress.com/2018/05/16/rvalues-redefined/.
@@ -42,4 +42,4 @@ namespace pika { namespace util { namespace detail {
     {
         return with_result_of_t<F>(PIKA_FORWARD(F, f));
     }
-}}}    // namespace pika::util::detail
+}    // namespace pika::util::detail
diff --git a/libs/pika/type_support/include/pika/type_support/detail/wrap_int.hpp b/libs/pika/type_support/include/pika/type_support/detail/wrap_int.hpp
index d9cfd9909..5a5ab04fe 100644
--- a/libs/pika/type_support/include/pika/type_support/detail/wrap_int.hpp
+++ b/libs/pika/type_support/include/pika/type_support/detail/wrap_int.hpp
@@ -8,10 +8,10 @@
 
 #include <pika/config.hpp>
 
-namespace pika { namespace traits { namespace detail {
+namespace pika::traits::detail {
     // wraps int so that int argument is favored over wrap_int
     struct wrap_int
     {
         constexpr wrap_int(int) {}
     };
-}}}    // namespace pika::traits::detail
+}    // namespace pika::traits::detail
diff --git a/libs/pika/type_support/include/pika/type_support/detected.hpp b/libs/pika/type_support/include/pika/type_support/detected.hpp
index d71de7541..030a558d9 100644
--- a/libs/pika/type_support/include/pika/type_support/detected.hpp
+++ b/libs/pika/type_support/include/pika/type_support/detected.hpp
@@ -11,9 +11,9 @@
 #include <type_traits>
 #include <utility>
 
-namespace pika { namespace util {
-    // pika::util::nonesuch is a class type used by pika::util::detected_t to
-    // indicate detection failure.
+namespace pika::util::detail {
+    // pika::util::detail::nonesuch is a class type used by
+    // pika::util::detail::detected_t to indicate detection failure.
     struct nonesuch
     {
         nonesuch() = delete;
@@ -22,38 +22,33 @@ namespace pika { namespace util {
         void operator=(nonesuch const&) = delete;
     };
 
-    ///////////////////////////////////////////////////////////////////////////
-    namespace detail {
-        template <typename Default, typename AlwaysVoid,
-            template <typename...> class Op, typename... Args>
-        struct detector
-        {
-            using value_t = std::false_type;
-            using type = Default;
-        };
+    template <typename Default, typename AlwaysVoid,
+        template <typename...> class Op, typename... Args>
+    struct detector
+    {
+        using value_t = std::false_type;
+        using type = Default;
+    };
 
-        template <typename Default, template <typename...> class Op,
-            typename... Args>
-        struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
-        {
-            using value_t = std::true_type;
-            using type = Op<Args...>;
-        };
-    }    // namespace detail
+    template <typename Default, template <typename...> class Op,
+        typename... Args>
+    struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
+    {
+        using value_t = std::true_type;
+        using type = Op<Args...>;
+    };
 
     // The alias template is_detected is an alias for std::true_type if the
     // template-id Op<Args...> is valid; otherwise it is an alias for
     // std::false_type.
     template <template <typename...> class Op, typename... Args>
-    using is_detected =
-        typename detail::detector<nonesuch, void, Op, Args...>::value_t;
+    using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
 
     // The alias template detected_t is an alias for Op<Args...> if that
     // template-id is valid; otherwise it is an alias for the class
-    // pika::util::nonesuch.
+    // pika::util::detail::nonesuch.
     template <template <typename...> class Op, typename... Args>
-    using detected_t =
-        typename detail::detector<nonesuch, void, Op, Args...>::type;
+    using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
 
     // The alias template detected_or is an alias for an unspecified class type
     // with two public member typedefs value_t and type, which are defined as
@@ -65,7 +60,7 @@ namespace pika { namespace util {
     //   alias for Default.
     template <typename Default, template <typename...> class Op,
         typename... Args>
-    using detected_or = detail::detector<Default, void, Op, Args...>;
+    using detected_or = detector<Default, void, Op, Args...>;
 
     template <typename Default, template <typename...> class Op,
         typename... Args>
@@ -82,4 +77,4 @@ namespace pika { namespace util {
     template <typename To, template <typename...> class Op, typename... Args>
     using is_detected_convertible =
         std::is_convertible<detected_t<Op, Args...>, To>;
-}}    // namespace pika::util
+}    // namespace pika::util::detail
diff --git a/libs/pika/type_support/include/pika/type_support/empty_function.hpp b/libs/pika/type_support/include/pika/type_support/empty_function.hpp
index 1411844e9..b218c9581 100644
--- a/libs/pika/type_support/include/pika/type_support/empty_function.hpp
+++ b/libs/pika/type_support/include/pika/type_support/empty_function.hpp
@@ -6,7 +6,7 @@
 
 #pragma once
 
-namespace pika { namespace util {
+namespace pika::util::detail {
 
     struct empty_function
     {
@@ -15,4 +15,4 @@ namespace pika { namespace util {
         {
         }
     };
-}}    // namespace pika::util
+}    // namespace pika::util::detail
diff --git a/libs/pika/type_support/include/pika/type_support/equality.hpp b/libs/pika/type_support/include/pika/type_support/equality.hpp
index f4f2074d1..5d7b6678e 100644
--- a/libs/pika/type_support/include/pika/type_support/equality.hpp
+++ b/libs/pika/type_support/include/pika/type_support/equality.hpp
@@ -12,76 +12,89 @@
 #include <type_traits>
 #include <utility>
 
-namespace pika { namespace traits {
-    namespace detail {
-
-        ///////////////////////////////////////////////////////////////////////
-        template <typename T, typename U, typename Enable = void>
-        struct equality_result
-        {
-        };
-
-        template <typename T, typename U>
-        struct equality_result<T, U,
-            std::void_t<decltype(std::declval<const T&>() ==
-                std::declval<const U&>())>>
-        {
-            using type =
-                decltype(std::declval<const T&>() == std::declval<const U&>());
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        template <typename T, typename U, typename Enable = void>
-        struct inequality_result
-        {
-        };
-
-        template <typename T, typename U>
-        struct inequality_result<T, U,
-            std::void_t<decltype(std::declval<const T&>() !=
-                std::declval<const U&>())>>
-        {
-            using type =
-                decltype(std::declval<const T&>() != std::declval<const U&>());
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        template <typename T, typename U, typename Enable = void>
-        struct is_weakly_equality_comparable_with : std::false_type
-        {
-        };
-
-        template <typename T, typename U>
-        struct is_weakly_equality_comparable_with<T, U,
-            std::void_t<typename detail::equality_result<T, U>::type,
-                typename detail::equality_result<U, T>::type,
-                typename detail::inequality_result<T, U>::type,
-                typename detail::inequality_result<U, T>::type>>
-          : std::true_type
-        {
-        };
-
-    }    // namespace detail
+namespace pika::traits::detail {
+
+    ///////////////////////////////////////////////////////////////////////
+    template <typename T, typename U, typename Enable = void>
+    struct equality_result
+    {
+    };
+
+    template <typename T, typename U>
+    struct equality_result<T, U,
+        std::void_t<decltype(std::declval<const T&>() ==
+            std::declval<const U&>())>>
+    {
+        using type =
+            decltype(std::declval<const T&>() == std::declval<const U&>());
+    };
+
+    template <typename T, typename U>
+    using equality_result_t = typename equality_result<T, U>::type;
+
+    ///////////////////////////////////////////////////////////////////////
+    template <typename T, typename U, typename Enable = void>
+    struct inequality_result
+    {
+    };
+
+    template <typename T, typename U>
+    struct inequality_result<T, U,
+        std::void_t<decltype(std::declval<const T&>() !=
+            std::declval<const U&>())>>
+    {
+        using type =
+            decltype(std::declval<const T&>() != std::declval<const U&>());
+    };
+
+    template <typename T, typename U>
+    using inequality_result_t = typename inequality_result<T, U>::type;
+
+    ///////////////////////////////////////////////////////////////////////
+    template <typename T, typename U, typename Enable = void>
+    struct is_weakly_equality_comparable_with_impl : std::false_type
+    {
+    };
+
+    template <typename T, typename U>
+    struct is_weakly_equality_comparable_with_impl<T, U,
+        std::void_t<equality_result_t<T, U>, equality_result_t<U, T>,
+            inequality_result_t<T, U>, inequality_result_t<U, T>>>
+      : std::true_type
+    {
+    };
 
     template <typename T, typename U>
     struct is_weakly_equality_comparable_with
-      : detail::is_weakly_equality_comparable_with<std::decay_t<T>,
+      : is_weakly_equality_comparable_with_impl<std::decay_t<T>,
             std::decay_t<U>>
     {
     };
 
+    template <typename T, typename U>
+    inline constexpr bool is_weakly_equality_comparable_with_v =
+        is_weakly_equality_comparable_with<T, U>::value;
+
     // for now is_equality_comparable is equivalent to its weak version
     template <typename T, typename U>
     struct is_equality_comparable_with
-      : detail::is_weakly_equality_comparable_with<std::decay_t<T>,
+      : is_weakly_equality_comparable_with_impl<std::decay_t<T>,
             std::decay_t<U>>
     {
     };
 
+    template <typename T, typename U>
+    inline constexpr bool is_equality_comparable_with_v =
+        is_equality_comparable_with<T, U>::value;
+
     template <typename T>
     struct is_equality_comparable
-      : detail::is_weakly_equality_comparable_with<std::decay_t<T>,
+      : is_weakly_equality_comparable_with_impl<std::decay_t<T>,
             std::decay_t<T>>
     {
     };
-}}    // namespace pika::traits
+
+    template <typename T>
+    inline constexpr bool is_equality_comparable_v =
+        is_equality_comparable<T>::value;
+}    // namespace pika::traits::detail
diff --git a/libs/pika/type_support/include/pika/type_support/lazy_conditional.hpp b/libs/pika/type_support/include/pika/type_support/lazy_conditional.hpp
index 778bee111..81a812e39 100644
--- a/libs/pika/type_support/include/pika/type_support/lazy_conditional.hpp
+++ b/libs/pika/type_support/include/pika/type_support/lazy_conditional.hpp
@@ -8,7 +8,7 @@
 
 #include <type_traits>
 
-namespace pika { namespace util {
+namespace pika::util::detail {
     template <bool Enable, typename C1, typename C2>
     struct lazy_conditional : std::conditional<Enable, C1, C2>::type
     {
@@ -16,4 +16,4 @@ namespace pika { namespace util {
 
     template <bool Enable, typename C1, typename C2>
     using lazy_conditional_t = typename lazy_conditional<Enable, C1, C2>::type;
-}}    // namespace pika::util
+}    // namespace pika::util::detail
diff --git a/libs/pika/type_support/include/pika/type_support/lazy_enable_if.hpp b/libs/pika/type_support/include/pika/type_support/lazy_enable_if.hpp
deleted file mode 100644
index ed8f9133c..000000000
--- a/libs/pika/type_support/include/pika/type_support/lazy_enable_if.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//  Copyright (c) 2016 Thomas Heller
-//
-//  SPDX-License-Identifier: BSL-1.0
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-namespace pika { namespace util {
-    template <bool Enable, typename T>
-    struct lazy_enable_if
-    {
-    };
-
-    template <typename T>
-    struct lazy_enable_if<true, T>
-    {
-        using type = typename T::type;
-    };
-}}    // namespace pika::util
diff --git a/libs/pika/type_support/include/pika/type_support/pack.hpp b/libs/pika/type_support/include/pika/type_support/pack.hpp
index 583598ce0..f4f416056 100644
--- a/libs/pika/type_support/include/pika/type_support/pack.hpp
+++ b/libs/pika/type_support/include/pika/type_support/pack.hpp
@@ -11,7 +11,7 @@
 #include <cstddef>
 #include <type_traits>
 
-namespace pika { namespace util {
+namespace pika::util::detail {
 
     template <typename... Ts>
     struct pack
@@ -30,17 +30,14 @@ namespace pika { namespace util {
     template <std::size_t... Is>
     using index_pack = pack_c<std::size_t, Is...>;
 
-    ///////////////////////////////////////////////////////////////////////////
-    namespace detail {
-        template <typename Left, typename Right>
-        struct make_index_pack_join;
+    template <typename Left, typename Right>
+    struct make_index_pack_join;
 
-        template <std::size_t... Left, std::size_t... Right>
-        struct make_index_pack_join<index_pack<Left...>, index_pack<Right...>>
-          : index_pack<Left..., (sizeof...(Left) + Right)...>
-        {
-        };
-    }    // namespace detail
+    template <std::size_t... Left, std::size_t... Right>
+    struct make_index_pack_join<index_pack<Left...>, index_pack<Right...>>
+      : index_pack<Left..., (sizeof...(Left) + Right)...>
+    {
+    };
 
     template <std::size_t N>
     struct make_index_pack
@@ -52,7 +49,7 @@ namespace pika { namespace util {
         defined(PIKA_COMPUTE_DEVICE_CODE))
       : __make_integer_seq<pack_c, std::size_t, N>
 #else
-      : detail::make_index_pack_join<typename make_index_pack<N / 2>::type,
+      : make_index_pack_join<typename make_index_pack<N / 2>::type,
             typename make_index_pack<N - N / 2>::type>
 #endif
     {
@@ -73,40 +70,42 @@ namespace pika { namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     // Workaround for clang bug [https://bugs.llvm.org/show_bug.cgi?id=35077]
-    namespace detail {
-        template <typename T>
-        struct is_true : std::integral_constant<bool, (bool) T::value>
-        {
-        };
-
-        template <typename T>
-        struct is_false : std::integral_constant<bool, !(bool) T::value>
-        {
-        };
-    }    // namespace detail
+    template <typename T>
+    struct is_true : std::integral_constant<bool, (bool) T::value>
+    {
+    };
+
+    template <typename T>
+    inline constexpr bool is_true_v = is_true<T>::value;
+
+    template <typename T>
+    struct is_false : std::integral_constant<bool, !(bool) T::value>
+    {
+    };
+
+    template <typename T>
+    inline constexpr bool is_false_v = is_false<T>::value;
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail {
-        template <typename... Ts>
-        struct always_true : std::true_type
-        {
-        };
+    template <typename... Ts>
+    struct always_true : std::true_type
+    {
+    };
 
-        template <typename... Ts>
-        struct always_false : std::false_type
-        {
-        };
+    template <typename... Ts>
+    struct always_false : std::false_type
+    {
+    };
 
-        template <typename... Ts>
-        static std::false_type all_of(...);
+    template <typename... Ts>
+    static std::false_type all_of_impl(...);
 
-        template <typename... Ts>
-        static auto all_of(int) -> always_true<
-            typename std::enable_if<is_true<Ts>::value>::type...>;
-    }    // namespace detail
+    template <typename... Ts>
+    static auto all_of_impl(int)
+        -> always_true<typename std::enable_if_t<is_true_v<Ts>>...>;
 
     template <typename... Ts>
-    struct all_of : decltype(detail::all_of<Ts...>(0))
+    struct all_of : decltype(all_of_impl<Ts...>(0))
     {
     };
 
@@ -119,17 +118,15 @@ namespace pika { namespace util {
     template <typename... Ts>
     inline constexpr bool all_of_v = all_of<Ts...>::value;
 
-    namespace detail {
-        template <typename... Ts>
-        static std::true_type any_of(...);
+    template <typename... Ts>
+    static std::true_type any_of_impl(...);
 
-        template <typename... Ts>
-        static auto any_of(int) -> always_false<
-            typename std::enable_if<is_false<Ts>::value>::type...>;
-    }    // namespace detail
+    template <typename... Ts>
+    static auto any_of_impl(int)
+        -> always_false<std::enable_if_t<is_false_v<Ts>>...>;
 
     template <typename... Ts>
-    struct any_of : decltype(detail::any_of<Ts...>(0))
+    struct any_of : decltype(any_of_impl<Ts...>(0))
     {
     };
 
@@ -143,7 +140,7 @@ namespace pika { namespace util {
     inline constexpr bool any_of_v = any_of<Ts...>::value;
 
     template <typename... Ts>
-    struct none_of : std::integral_constant<bool, !any_of<Ts...>::value>
+    struct none_of : std::integral_constant<bool, !any_of_v<Ts...>>
     {
     };
 
@@ -155,203 +152,196 @@ namespace pika { namespace util {
     {
     };
 
-    ///////////////////////////////////////////////////////////////////////////
-    namespace detail {
-        struct empty
-        {
-        };
+    struct empty
+    {
+    };
 
 #if (defined(PIKA_HAVE_BUILTIN_TYPE_PACK_ELEMENT) &&                           \
     !defined(PIKA_COMPUTE_DEVICE_CODE)) ||                                     \
     (defined(PIKA_HAVE_BUILTIN_TYPE_PACK_ELEMENT_CUDA) &&                      \
         defined(PIKA_COMPUTE_DEVICE_CODE))
-        template <std::size_t I, typename Ts, bool InBounds = (I < Ts::size)>
-        struct at_index_impl : empty
-        {
-        };
-
-        template <std::size_t I, typename... Ts>
-        struct at_index_impl<I, pack<Ts...>, /*InBounds*/ true>
-        {
-            using type = __type_pack_element<I, Ts...>;
-        };
+    template <std::size_t I, typename Ts, bool InBounds = (I < Ts::size)>
+    struct at_index_impl : empty
+    {
+    };
+
+    template <std::size_t I, typename... Ts>
+    struct at_index_impl<I, pack<Ts...>, /*InBounds*/ true>
+    {
+        using type = __type_pack_element<I, Ts...>;
+    };
 #else
-        template <std::size_t I, typename T>
-        struct indexed
-        {
-            using type = T;
-        };
-
-        template <typename Ts, typename Is>
-        struct indexer;
-
-        template <typename... Ts, std::size_t... Is>
-        struct indexer<pack<Ts...>, pack_c<std::size_t, Is...>>
-          : indexed<Is, Ts>...
-        {
-        };
-
-        template <std::size_t J>
-        static empty at_index_check(...);
-
-        template <std::size_t J, typename T>
-        static indexed<J, T> at_index_check(indexed<J, T> const&);
-
-        template <std::size_t I, typename Ts>
-        struct at_index_impl
-          : decltype(detail::at_index_check<I>(
-                indexer<Ts, typename make_index_pack<Ts::size>::type>()))
-        {
-        };
+    template <std::size_t I, typename T>
+    struct indexed
+    {
+        using type = T;
+    };
+
+    template <typename Ts, typename Is>
+    struct indexer;
+
+    template <typename... Ts, std::size_t... Is>
+    struct indexer<pack<Ts...>, pack_c<std::size_t, Is...>> : indexed<Is, Ts>...
+    {
+    };
+
+    template <std::size_t J>
+    static empty at_index_check(...);
+
+    template <std::size_t J, typename T>
+    static indexed<J, T> at_index_check(indexed<J, T> const&);
+
+    template <std::size_t I, typename Ts>
+    struct at_index_impl
+      : decltype(at_index_check<I>(
+            indexer<Ts, typename make_index_pack<Ts::size>::type>()))
+    {
+    };
 #endif
-    }    // namespace detail
 
     template <std::size_t I, typename... Ts>
-    struct at_index : detail::at_index_impl<I, pack<Ts...>>
+    struct at_index : at_index_impl<I, pack<Ts...>>
     {
     };
 
     template <std::size_t I, typename... Ts>
     using at_index_t = typename at_index<I, Ts...>::type;
 
-    namespace detail {
-        template <typename Pack, template <typename> class Transformer>
-        struct transform;
-
-        template <template <typename> class Transformer,
-            template <typename...> class Pack, typename... Ts>
-        struct transform<Pack<Ts...>, Transformer>
-        {
-            using type = Pack<typename Transformer<Ts>::type...>;
-        };
-
-        /// Apply a meta-function to each element in a pack.
-        template <typename Pack, template <typename> class Transformer>
-        using transform_t = typename transform<Pack, Transformer>::type;
-
-        template <typename PackUnique, typename PackRest>
-        struct unique_helper;
-
-        template <template <typename...> class Pack, typename... Ts>
-        struct unique_helper<Pack<Ts...>, Pack<>>
-        {
-            using type = Pack<Ts...>;
-        };
-
-        template <template <typename...> class Pack, typename... Ts, typename U,
-            typename... Us>
-        struct unique_helper<Pack<Ts...>, Pack<U, Us...>>
-          : std::conditional<contains<U, Ts...>::value,
-                unique_helper<Pack<Ts...>, Pack<Us...>>,
-                unique_helper<Pack<Ts..., U>, Pack<Us...>>>::type
-        {
-        };
-
-        template <typename Pack>
-        struct unique;
-
-        template <template <typename...> class Pack, typename... Ts>
-        struct unique<Pack<Ts...>> : unique_helper<Pack<>, Pack<Ts...>>
-        {
-        };
-
-        /// Remove duplicate types in the given pack.
-        template <typename Pack>
-        using unique_t = typename unique<Pack>::type;
-
-        template <typename... Packs>
-        struct concat;
-
-        template <template <typename...> class Pack, typename... Ts>
-        struct concat<Pack<Ts...>>
-        {
-            using type = Pack<Ts...>;
-        };
-
-        template <template <typename...> class Pack, typename... Ts,
-            typename... Us, typename... Rest>
-        struct concat<Pack<Ts...>, Pack<Us...>, Rest...>
-          : concat<Pack<Ts..., Us...>, Rest...>
-        {
-        };
-
-        /// Concatenate the elements in the given packs into a single pack. The
-        /// packs must be of the same type.
-        template <typename... Packs>
-        using concat_t = typename concat<Packs...>::type;
-
-        /// Concatenate the elements in the given packs into a single pack and then
-        /// remove duplicates.
-        template <typename... Packs>
-        using unique_concat_t = unique_t<concat_t<Packs...>>;
-
-        template <typename Pack>
-        struct concat_pack_of_packs;
-
-        template <template <typename...> class Pack, typename... Ts>
-        struct concat_pack_of_packs<Pack<Ts...>>
-        {
-            using type = typename concat<Ts...>::type;
-        };
-
-        /// Concatenate the packs in the given pack into a single pack. The
-        /// outer pack is discarded.
-        template <typename Pack>
-        using concat_pack_of_packs_t =
-            typename concat_pack_of_packs<Pack>::type;
-
-        template <typename Pack>
-        struct concat_inner_packs;
-
-        template <template <typename...> class Pack, typename... Ts>
-        struct concat_inner_packs<Pack<Ts...>>
-        {
-            using type = Pack<typename concat<Ts...>::type>;
-        };
-
-        /// Concatenate the packs in the given pack into a single pack. The
-        /// outer pack is kept.
-        template <typename Pack>
-        using concat_inner_packs_t = typename concat_inner_packs<Pack>::type;
-
-        template <typename Pack, typename T>
-        struct prepend;
-
-        template <typename T, template <typename...> class Pack, typename... Ts>
-        struct prepend<Pack<Ts...>, T>
-        {
-            using type = Pack<T, Ts...>;
-        };
-
-        /// Prepend a given type to the given pack.
-        template <typename Pack, typename T>
-        using prepend_t = typename prepend<Pack, T>::type;
-
-        template <typename Pack, typename T>
-        struct append;
-
-        template <typename T, template <typename...> class Pack, typename... Ts>
-        struct append<Pack<Ts...>, T>
-        {
-            using type = Pack<Ts..., T>;
-        };
-
-        /// Append a given type to the given pack.
-        template <typename Pack, typename T>
-        using append_t = typename prepend<Pack, T>::type;
-
-        template <template <typename...> class NewPack, typename OldPack>
-        struct change_pack;
-
-        template <template <typename...> class NewPack,
-            template <typename...> class OldPack, typename... Ts>
-        struct change_pack<NewPack, OldPack<Ts...>>
-        {
-            using type = NewPack<Ts...>;
-        };
-
-        /// Change a OldPack<Ts...> to NewPack<Ts...>
-        template <template <typename...> class NewPack, typename OldPack>
-        using change_pack_t = typename change_pack<NewPack, OldPack>::type;
-    }    // namespace detail
-}}       // namespace pika::util
+    template <typename Pack, template <typename> class Transformer>
+    struct transform;
+
+    template <template <typename> class Transformer,
+        template <typename...> class Pack, typename... Ts>
+    struct transform<Pack<Ts...>, Transformer>
+    {
+        using type = Pack<typename Transformer<Ts>::type...>;
+    };
+
+    /// Apply a meta-function to each element in a pack.
+    template <typename Pack, template <typename> class Transformer>
+    using transform_t = typename transform<Pack, Transformer>::type;
+
+    template <typename PackUnique, typename PackRest>
+    struct unique_helper;
+
+    template <template <typename...> class Pack, typename... Ts>
+    struct unique_helper<Pack<Ts...>, Pack<>>
+    {
+        using type = Pack<Ts...>;
+    };
+
+    template <template <typename...> class Pack, typename... Ts, typename U,
+        typename... Us>
+    struct unique_helper<Pack<Ts...>, Pack<U, Us...>>
+      : std::conditional<contains<U, Ts...>::value,
+            unique_helper<Pack<Ts...>, Pack<Us...>>,
+            unique_helper<Pack<Ts..., U>, Pack<Us...>>>::type
+    {
+    };
+
+    template <typename Pack>
+    struct unique;
+
+    template <template <typename...> class Pack, typename... Ts>
+    struct unique<Pack<Ts...>> : unique_helper<Pack<>, Pack<Ts...>>
+    {
+    };
+
+    /// Remove duplicate types in the given pack.
+    template <typename Pack>
+    using unique_t = typename unique<Pack>::type;
+
+    template <typename... Packs>
+    struct concat;
+
+    template <template <typename...> class Pack, typename... Ts>
+    struct concat<Pack<Ts...>>
+    {
+        using type = Pack<Ts...>;
+    };
+
+    template <template <typename...> class Pack, typename... Ts, typename... Us,
+        typename... Rest>
+    struct concat<Pack<Ts...>, Pack<Us...>, Rest...>
+      : concat<Pack<Ts..., Us...>, Rest...>
+    {
+    };
+
+    /// Concatenate the elements in the given packs into a single pack. The
+    /// packs must be of the same type.
+    template <typename... Packs>
+    using concat_t = typename concat<Packs...>::type;
+
+    /// Concatenate the elements in the given packs into a single pack and then
+    /// remove duplicates.
+    template <typename... Packs>
+    using unique_concat_t = unique_t<concat_t<Packs...>>;
+
+    template <typename Pack>
+    struct concat_pack_of_packs;
+
+    template <template <typename...> class Pack, typename... Ts>
+    struct concat_pack_of_packs<Pack<Ts...>>
+    {
+        using type = typename concat<Ts...>::type;
+    };
+
+    /// Concatenate the packs in the given pack into a single pack. The
+    /// outer pack is discarded.
+    template <typename Pack>
+    using concat_pack_of_packs_t = typename concat_pack_of_packs<Pack>::type;
+
+    template <typename Pack>
+    struct concat_inner_packs;
+
+    template <template <typename...> class Pack, typename... Ts>
+    struct concat_inner_packs<Pack<Ts...>>
+    {
+        using type = Pack<typename concat<Ts...>::type>;
+    };
+
+    /// Concatenate the packs in the given pack into a single pack. The
+    /// outer pack is kept.
+    template <typename Pack>
+    using concat_inner_packs_t = typename concat_inner_packs<Pack>::type;
+
+    template <typename Pack, typename T>
+    struct prepend;
+
+    template <typename T, template <typename...> class Pack, typename... Ts>
+    struct prepend<Pack<Ts...>, T>
+    {
+        using type = Pack<T, Ts...>;
+    };
+
+    /// Prepend a given type to the given pack.
+    template <typename Pack, typename T>
+    using prepend_t = typename prepend<Pack, T>::type;
+
+    template <typename Pack, typename T>
+    struct append;
+
+    template <typename T, template <typename...> class Pack, typename... Ts>
+    struct append<Pack<Ts...>, T>
+    {
+        using type = Pack<Ts..., T>;
+    };
+
+    /// Append a given type to the given pack.
+    template <typename Pack, typename T>
+    using append_t = typename prepend<Pack, T>::type;
+
+    template <template <typename...> class NewPack, typename OldPack>
+    struct change_pack;
+
+    template <template <typename...> class NewPack,
+        template <typename...> class OldPack, typename... Ts>
+    struct change_pack<NewPack, OldPack<Ts...>>
+    {
+        using type = NewPack<Ts...>;
+    };
+
+    /// Change a OldPack<Ts...> to NewPack<Ts...>
+    template <template <typename...> class NewPack, typename OldPack>
+    using change_pack_t = typename change_pack<NewPack, OldPack>::type;
+}    // namespace pika::util::detail
diff --git a/libs/pika/type_support/include/pika/type_support/identity.hpp b/libs/pika/type_support/include/pika/type_support/type_identity.hpp
similarity index 78%
rename from libs/pika/type_support/include/pika/type_support/identity.hpp
rename to libs/pika/type_support/include/pika/type_support/type_identity.hpp
index 0f32711b6..a28db69e4 100644
--- a/libs/pika/type_support/include/pika/type_support/identity.hpp
+++ b/libs/pika/type_support/include/pika/type_support/type_identity.hpp
@@ -6,10 +6,10 @@
 
 #pragma once
 
-namespace pika { namespace util {
+namespace pika::detail {
     template <typename T>
-    struct identity
+    struct type_identity
     {
         using type = T;
     };
-}}    // namespace pika::util
+}    // namespace pika::detail
diff --git a/libs/pika/type_support/include/pika/type_support/unused.hpp b/libs/pika/type_support/include/pika/type_support/unused.hpp
index d63c633f8..3ba19955f 100644
--- a/libs/pika/type_support/include/pika/type_support/unused.hpp
+++ b/libs/pika/type_support/include/pika/type_support/unused.hpp
@@ -16,7 +16,7 @@
 #endif
 // clang-format on
 
-namespace pika { namespace util {
+namespace pika::util::detail {
     ///////////////////////////////////////////////////////////////////////////
     // We do not import fusion::unused_type anymore to avoid boost::fusion
     // being turned into an associate namespace, as this interferes with ADL
@@ -82,14 +82,14 @@ namespace pika { namespace util {
     PIKA_CONSTANT
 #endif
     constexpr unused_type unused = unused_type();
-}}    // namespace pika::util
+}    // namespace pika::util::detail
 
 //////////////////////////////////////////////////////////////////////////////
 // use this to silence compiler warnings related to unused function arguments.
 #if defined(__CUDA_ARCH__)
 #define PIKA_UNUSED(x) (void) x
 #else
-#define PIKA_UNUSED(x) ::pika::util::unused = (x)
+#define PIKA_UNUSED(x) ::pika::util::detail::unused = (x)
 #endif
 
 /////////////////////////////////////////////////////////////
diff --git a/libs/pika/type_support/include/pika/type_support/unwrap_ref.hpp b/libs/pika/type_support/include/pika/type_support/unwrap_reference.hpp
similarity index 63%
rename from libs/pika/type_support/include/pika/type_support/unwrap_ref.hpp
rename to libs/pika/type_support/include/pika/type_support/unwrap_reference.hpp
index a2d8f2387..d7c643bbf 100644
--- a/libs/pika/type_support/include/pika/type_support/unwrap_ref.hpp
+++ b/libs/pika/type_support/include/pika/type_support/unwrap_reference.hpp
@@ -10,28 +10,29 @@
 
 #include <functional>
 
-namespace pika { namespace util {
+namespace pika::detail {
     template <typename T>
-    struct unwrap_reference
+    struct unwrap_reference_impl
     {
         using type = T;
     };
 
     template <typename T>
-    struct unwrap_reference<std::reference_wrapper<T>>
+    struct unwrap_reference_impl<std::reference_wrapper<T>>
     {
         using type = T;
     };
 
     template <typename T>
-    struct unwrap_reference<std::reference_wrapper<T> const>
+    struct unwrap_reference_impl<std::reference_wrapper<T> const>
     {
         using type = T;
     };
 
     template <typename T>
-    PIKA_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref(T& t)
+    PIKA_FORCEINLINE typename unwrap_reference_impl<T>::type& unwrap_reference(
+        T& t)
     {
         return t;
     }
-}}    // namespace pika::util
+}    // namespace pika::detail
diff --git a/libs/pika/type_support/include/pika/type_support/void_guard.hpp b/libs/pika/type_support/include/pika/type_support/void_guard.hpp
index 6b80ca49a..9e251b032 100644
--- a/libs/pika/type_support/include/pika/type_support/void_guard.hpp
+++ b/libs/pika/type_support/include/pika/type_support/void_guard.hpp
@@ -8,7 +8,7 @@
 
 #include <pika/config.hpp>
 
-namespace pika { namespace util {
+namespace pika::util::detail {
     ///////////////////////////////////////////////////////////////////////////
     // This utility simplifies templates returning compatible types
     //
@@ -29,4 +29,4 @@ namespace pika { namespace util {
         {
         }
     };
-}}    // namespace pika::util
+}    // namespace pika::util::detail
diff --git a/tools/inspect/deprecated_name_check.cpp b/tools/inspect/deprecated_name_check.cpp
index ad9f6316c..532b2bbfa 100644
--- a/tools/inspect/deprecated_name_check.cpp
+++ b/tools/inspect/deprecated_name_check.cpp
@@ -35,13 +35,6 @@ namespace boost { namespace inspect {
         {"(\\bboost\\s*::\\s*disable_if\\b)", "std::enable_if"},
         {"(\\bboost\\s*::\\s*enable_if_c\\b)", "std::enable_if"},
         {"(\\bboost\\s*::\\s*disable_if_c\\b)", "std::enable_if"},
-        {"(\\bboost\\s*::\\s*lazy_enable_if\\b)", "pika::util::lazy_enable_if"},
-        {"(\\bboost\\s*::\\s*lazy_disable_if\\b)",
-            "pika::util::lazy_enable_if"},
-        {"(\\bboost\\s*::\\s*lazy_enable_if_c\\b)",
-            "pika::util::lazy_enable_if"},
-        {"(\\bboost\\s*::\\s*lazy_disable_if_c\\b)",
-            "pika::util::lazy_enable_if"},
         {"(\\bboost\\s*::\\s*mpl\\b)", "no specific replacement"},
         {"(\\bboost\\s*::\\s*(is_[^\\s]*?\\b))", "std::\\2"},
         {"(\\bboost\\s*::\\s*(add_[^\\s]*?\\b))", "std::\\2"},