diff --git a/.inshpect.toml b/.inshpect.toml
index 6b8fc272d..7f92e11cc 100644
--- a/.inshpect.toml
+++ b/.inshpect.toml
@@ -230,7 +230,10 @@ patterns = [
     { pattern = '\bstd::nullptr_t\b', include = 'cstddef' },
     { pattern = '\bstd::(true|false)_type\b', include = 'type_traits' },
     { pattern = '\bstd::(bool|integral)_constant\b', include = 'type_traits' },
+    { pattern = '\bstd::invoke_result\b', include = 'type_traits' },
+    { pattern = '\bstd::invoke_result_t\b', include = 'type_traits' },
     { pattern = '\bstd::is_void\b', include = 'type_traits' },
+    { pattern = '\bstd::is_void_t\b', include = 'type_traits' },
     { pattern = '\bstd::is_null_pointer\b', include = 'type_traits' },
     { pattern = '\bstd::is_integral\b', include = 'type_traits' },
     { pattern = '\bstd::is_floating_point\b', include = 'type_traits' },
diff --git a/libs/pika/async_cuda/include/pika/async_cuda/then_on_host.hpp b/libs/pika/async_cuda/include/pika/async_cuda/then_on_host.hpp
index f61b8b879..a623366f7 100644
--- a/libs/pika/async_cuda/include/pika/async_cuda/then_on_host.hpp
+++ b/libs/pika/async_cuda/include/pika/async_cuda/then_on_host.hpp
@@ -81,8 +81,8 @@ namespace pika::cuda::experimental {
             {
                 pika::detail::try_catch_exception_ptr(
                     [&]() {
-                        if constexpr (std::is_void_v<pika::util::detail::
-                                              invoke_result_t<F, Ts...>>)
+                        if constexpr (std::is_void_v<
+                                          std::invoke_result_t<F, Ts...>>)
                         {
                         // Certain versions of GCC with optimizations fail on
                         // the move with an internal compiler error.
@@ -165,7 +165,7 @@ namespace pika::cuda::experimental {
                 pika::execution::experimental::completion_signatures<
                     pika::execution::experimental::detail::
                         result_type_signature_helper_t<
-                            pika::util::detail::invoke_result_t<F, Ts...>>>;
+                            std::invoke_result_t<F, Ts...>>>;
 
             using completion_signatures =
                 pika::execution::experimental::make_completion_signatures<
@@ -181,8 +181,7 @@ namespace pika::cuda::experimental {
             template <template <typename...> class Tuple, typename... Ts>
             struct invoke_result_helper<Tuple<Ts...>>
             {
-                using result_type =
-                    typename pika::util::detail::invoke_result<F, Ts...>::type;
+                using result_type = std::invoke_result_t<F, Ts...>;
                 using type =
                     typename std::conditional<std::is_void<result_type>::value,
                         Tuple<>, Tuple<result_type>>::type;
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 65036c39b..208cdd189 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
@@ -179,8 +179,7 @@ namespace pika::cuda::experimental::then_with_stream_detail {
             pika::execution::experimental::completion_signatures<
                 pika::execution::experimental::detail::
                     result_type_signature_helper_t<
-                        pika::util::detail::invoke_result_t<F,
-                            cuda_stream const&,
+                        std::invoke_result_t<F, cuda_stream const&,
                             std::add_lvalue_reference_t<std::decay_t<Ts>>...>>>;
 
         using completion_signatures =
@@ -198,9 +197,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         template <template <typename...> class Tuple, typename... Ts>
         struct invoke_result_helper<Tuple<Ts...>>
         {
-            using result_type =
-                pika::util::detail::invoke_result_t<F, cuda_stream const&,
-                    std::add_lvalue_reference_t<std::decay_t<Ts>>...>;
+            using result_type = std::invoke_result_t<F, cuda_stream const&,
+                std::add_lvalue_reference_t<std::decay_t<Ts>>...>;
             using type = std::conditional_t<std::is_void_v<result_type>,
                 Tuple<>, Tuple<result_type>>;
         };
@@ -328,11 +326,10 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                                 }
                             }
 
-                            using invoke_result_type =
-                                std::decay_t<pika::util::detail::
-                                        invoke_result_t<F, cuda_stream const&,
-                                            std::add_lvalue_reference_t<
-                                                std::decay_t<Ts>>...>>;
+                            using invoke_result_type = std::decay_t<
+                                std::invoke_result_t<F, cuda_stream const&,
+                                    std::add_lvalue_reference_t<
+                                        std::decay_t<Ts>>...>>;
                             constexpr bool is_void_result =
                                 std::is_void_v<invoke_result_type>;
                             if constexpr (is_void_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 18b1bb8a7..13aaab520 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
@@ -83,10 +83,8 @@ namespace pika::mpi::experimental {
                 std::add_lvalue_reference_t<std::decay_t<Ts>>..., MPI_Request*>;
 
         template <typename F, typename... Ts>
-        using mpi_request_invoke_result_t =
-            std::decay_t<pika::util::detail::invoke_result_t<F,
-                std::add_lvalue_reference_t<std::decay_t<Ts>>...,
-                MPI_Request*>>;
+        using mpi_request_invoke_result_t = std::decay_t<std::invoke_result_t<F,
+            std::add_lvalue_reference_t<std::decay_t<Ts>>..., MPI_Request*>>;
 
         template <typename Sender, typename F>
         struct transform_mpi_sender_impl
diff --git a/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp b/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
index de21ee746..394d944fe 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
@@ -21,7 +21,6 @@
 #include <pika/execution_base/receiver.hpp>
 #include <pika/execution_base/sender.hpp>
 #include <pika/functional/detail/tag_priority_invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/iterator_support/counting_shape.hpp>
 #include <pika/type_support/pack.hpp>
 
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 5064f3868..5b6f07071 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/let_error.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/let_error.hpp
@@ -20,7 +20,6 @@
 #include <pika/execution_base/sender.hpp>
 #include <pika/functional/detail/tag_fallback_invoke.hpp>
 #include <pika/functional/invoke_fused.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/type_support/detail/with_result_of.hpp>
 #include <pika/type_support/pack.hpp>
 
@@ -68,8 +67,8 @@ namespace pika::let_error_detail {
         template <typename Error>
         struct successor_sender_types_helper
         {
-            using type = pika::util::detail::invoke_result_t<F,
-                std::add_lvalue_reference_t<Error>>;
+            using type =
+                std::invoke_result_t<F, std::add_lvalue_reference_t<Error>>;
             static_assert(pika::execution::experimental::is_sender<
                               std::decay_t<type>>::value,
                 "let_error expects the invocable sender factory to return "
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 626586f0e..3f393ce0c 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/let_value.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/let_value.hpp
@@ -20,7 +20,6 @@
 #include <pika/execution_base/sender.hpp>
 #include <pika/functional/detail/tag_fallback_invoke.hpp>
 #include <pika/functional/invoke_fused.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/type_support/detail/with_result_of.hpp>
 #include <pika/type_support/pack.hpp>
 
@@ -67,8 +66,8 @@ namespace pika::let_value_detail {
         template <template <typename...> class Tuple, typename... Ts>
         struct successor_sender_types_helper<Tuple<Ts...>>
         {
-            using type = pika::util::detail::invoke_result_t<F,
-                std::add_lvalue_reference_t<Ts>...>;
+            using type =
+                std::invoke_result_t<F, std::add_lvalue_reference_t<Ts>...>;
             static_assert(pika::execution::experimental::is_sender<
                               std::decay_t<type>>::value,
                 "let_value expects the invocable sender factory to return "
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 3c4e5f673..5037074f9 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
@@ -20,7 +20,6 @@
 #include <pika/execution/algorithms/detail/partial_algorithm.hpp>
 #include <pika/execution_base/operation_state.hpp>
 #include <pika/execution_base/sender.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/detail/future_data.hpp>
 #include <pika/futures/promise.hpp>
 #include <pika/memory/intrusive_ptr.hpp>
@@ -31,6 +30,7 @@
 #include <exception>
 #include <memory>
 #include <optional>
+#include <type_traits>
 #include <utility>
 
 namespace pika::make_future_detail {
@@ -214,9 +214,9 @@ namespace pika::make_future_detail {
         using result_type =
             std::decay_t<pika::execution::experimental::detail::single_result_t<
                 value_types>>;
-        using operation_state_type = pika::util::detail::invoke_result_t<
-            pika::execution::experimental::connect_t, Sender,
-            make_future_receiver<result_type, allocator_type>>;
+        using operation_state_type =
+            std::invoke_result_t<pika::execution::experimental::connect_t,
+                Sender, make_future_receiver<result_type, allocator_type>>;
 
         using shared_state =
             future_data<result_type, allocator_type, operation_state_type>;
diff --git a/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp b/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
index a4eec9ec6..852c1234a 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
@@ -60,8 +60,8 @@ namespace pika::schedule_from_detail {
                 Sender>::template error_types<Variant>;
 
         using scheduler_sender_type =
-            typename pika::util::detail::invoke_result<
-                pika::execution::experimental::schedule_t, Scheduler>::type;
+            std::invoke_result_t<pika::execution::experimental::schedule_t,
+                Scheduler>;
         template <template <typename...> class Variant>
         using scheduler_sender_error_types =
             typename pika::execution::experimental::sender_traits<
@@ -139,9 +139,8 @@ namespace pika::schedule_from_detail {
 
             using scheduler_operation_state_type =
                 pika::execution::experimental::connect_result_t<
-                    typename pika::util::detail::invoke_result<
-                        pika::execution::experimental::schedule_t,
-                        Scheduler>::type,
+                    std::invoke_result_t<
+                        pika::execution::experimental::schedule_t, Scheduler>,
                     scheduler_sender_receiver>;
             std::optional<scheduler_operation_state_type> scheduler_op_state;
 
diff --git a/libs/pika/execution/include/pika/execution/algorithms/start_detached.hpp b/libs/pika/execution/include/pika/execution/algorithms/start_detached.hpp
index a25174b2e..3db9b056b 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/start_detached.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/start_detached.hpp
@@ -19,7 +19,6 @@
 #include <pika/execution_base/operation_state.hpp>
 #include <pika/execution_base/sender.hpp>
 #include <pika/functional/detail/tag_fallback_invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/memory/intrusive_ptr.hpp>
 #include <pika/thread_support/atomic_count.hpp>
 #include <pika/type_support/unused.hpp>
diff --git a/libs/pika/execution/include/pika/execution/algorithms/then.hpp b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
index 408f3540a..cb283f461 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/then.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
@@ -17,6 +17,7 @@
 #include <pika/execution_base/completion_scheduler.hpp>
 #include <pika/execution_base/receiver.hpp>
 #include <pika/execution_base/sender.hpp>
+#include <pika/functional/detail/invoke.hpp>
 #include <pika/functional/detail/tag_fallback_invoke.hpp>
 #include <pika/type_support/pack.hpp>
 
@@ -61,8 +62,8 @@ namespace pika::then_detail {
         {
             pika::detail::try_catch_exception_ptr(
                 [&]() {
-                    if constexpr (std::is_void_v<pika::util::detail::
-                                          invoke_result_t<F, Ts...>>)
+                    if constexpr (std::is_void_v<
+                                      std::invoke_result_t<F, Ts...>>)
                     {
                     // Certain versions of GCC with optimizations fail on
                     // the move with an internal compiler error.
@@ -126,7 +127,7 @@ namespace pika::then_detail {
         template <template <typename...> class Tuple, typename... Ts>
         struct invoke_result_helper<Tuple<Ts...>>
         {
-            using result_type = pika::util::detail::invoke_result_t<F, Ts...>;
+            using result_type = std::invoke_result_t<F, Ts...>;
             using type = std::conditional_t<std::is_void<result_type>::value,
                 Tuple<>, Tuple<result_type>>;
         };
diff --git a/libs/pika/execution/include/pika/execution/detail/future_exec.hpp b/libs/pika/execution/include/pika/execution/detail/future_exec.hpp
index e7ca668d6..63f81e7b9 100644
--- a/libs/pika/execution/include/pika/execution/detail/future_exec.hpp
+++ b/libs/pika/execution/include/pika/execution/detail/future_exec.hpp
@@ -17,7 +17,6 @@
 #include <pika/execution/traits/future_then_result_exec.hpp>
 #include <pika/execution_base/traits/is_executor.hpp>
 #include <pika/functional/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/detail/future_data.hpp>
 #include <pika/futures/future.hpp>
 #include <pika/futures/packaged_continuation.hpp>
@@ -57,8 +56,7 @@ namespace pika::lcos::detail {
             using result_type =
                 typename pika::traits::future_then_result<Future,
                     F>::result_type;
-            using continuation_result_type =
-                pika::util::detail::invoke_result_t<F, Future>;
+            using continuation_result_type = std::invoke_result_t<F, Future>;
 
             pika::traits::detail::shared_state_ptr_t<result_type> p =
                 detail::make_continuation_alloc<continuation_result_type>(
@@ -77,8 +75,7 @@ namespace pika::lcos::detail {
             using result_type =
                 typename pika::traits::future_then_result<Future,
                     F>::result_type;
-            using continuation_result_type =
-                pika::util::detail::invoke_result_t<F, Future>;
+            using continuation_result_type = std::invoke_result_t<F, Future>;
 
             pika::traits::detail::shared_state_ptr_t<result_type> p =
                 detail::make_continuation_alloc<continuation_result_type>(alloc,
diff --git a/libs/pika/execution/include/pika/execution/executors/execution.hpp b/libs/pika/execution/include/pika/execution/executors/execution.hpp
index 1d3bebbbc..a3dc6d366 100644
--- a/libs/pika/execution/include/pika/execution/executors/execution.hpp
+++ b/libs/pika/execution/include/pika/execution/executors/execution.hpp
@@ -22,7 +22,6 @@
 #include <pika/functional/bind_back.hpp>
 #include <pika/functional/deferred_call.hpp>
 #include <pika/functional/detail/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/future.hpp>
 #include <pika/futures/traits/future_access.hpp>
 #include <pika/futures/traits/future_traits.hpp>
@@ -282,7 +281,7 @@ namespace pika::parallel::execution::detail {
         // fall-back: emulate sync_execute using async_execute
         template <typename TwoWayExecutor, typename F, typename... Ts>
         static auto call_impl(std::false_type, TwoWayExecutor&& exec, F&& f,
-            Ts&&... ts) -> pika::util::detail::invoke_result_t<F, Ts...>
+            Ts&&... ts) -> std::invoke_result_t<F, Ts...>
         {
             try
             {
@@ -321,7 +320,7 @@ namespace pika::parallel::execution::detail {
         template <typename TwoWayExecutor, typename F, typename... Ts>
         PIKA_FORCEINLINE static auto call_impl(
             pika::detail::wrap_int, TwoWayExecutor&& exec, F&& f, Ts&&... ts)
-            -> pika::util::detail::invoke_result_t<F, Ts...>
+            -> std::invoke_result_t<F, Ts...>
         {
             using is_void = typename std::is_void<
                 pika::util::detail::invoke_deferred_result_t<F, Ts...>>::type;
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 a36593cc2..ed7cb99b8 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
@@ -10,7 +10,6 @@
 #include <pika/config.hpp>
 #include <pika/execution/traits/executor_traits.hpp>
 #include <pika/execution_base/traits/is_executor.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/traits/future_then_result.hpp>
 #include <pika/futures/traits/future_traits.hpp>
 #include <pika/futures/traits/is_future.hpp>
@@ -33,10 +32,9 @@ namespace pika::traits {
 
         template <typename Executor, typename Future, typename F>
         struct future_then_executor_result<Executor, Future, F,
-            std::void_t<pika::util::detail::invoke_result_t<F&, Future>>>
+            std::void_t<std::invoke_result_t<F&, Future>>>
         {
-            using func_result_type =
-                pika::util::detail::invoke_result_t<F&, Future>;
+            using func_result_type = std::invoke_result_t<F&, Future>;
 
             using cont_result =
                 traits::executor_future_t<Executor, func_result_type, Future>;
diff --git a/libs/pika/execution/tests/regressions/future_then_async_executor.cpp b/libs/pika/execution/tests/regressions/future_then_async_executor.cpp
index dd7136711..60df83b19 100644
--- a/libs/pika/execution/tests/regressions/future_then_async_executor.cpp
+++ b/libs/pika/execution/tests/regressions/future_then_async_executor.cpp
@@ -17,8 +17,7 @@ struct test_async_executor
     using execution_category = pika::execution::parallel_execution_tag;
 
     template <typename F, typename... Ts>
-    static pika::future<
-        typename pika::util::detail::invoke_result<F, Ts...>::type>
+    static pika::future<std::invoke_result_t<F, Ts...>>
     async_execute(F&& f, Ts&&... ts)
     {
         return pika::dataflow(
diff --git a/libs/pika/execution/tests/unit/minimal_async_executor.cpp b/libs/pika/execution/tests/unit/minimal_async_executor.cpp
index 22cc4dd98..e0a526041 100644
--- a/libs/pika/execution/tests/unit/minimal_async_executor.cpp
+++ b/libs/pika/execution/tests/unit/minimal_async_executor.cpp
@@ -150,8 +150,7 @@ struct test_async_executor1
     using execution_category = pika::execution::parallel_execution_tag;
 
     template <typename F, typename... Ts>
-    static pika::future<
-        typename pika::util::detail::invoke_result<F, Ts...>::type>
+    static pika::future<std::invoke_result_t<F, Ts...>>
     async_execute(F&& f, Ts&&... ts)
     {
         ++count_async;
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 8d1c0a4f2..14e6122be 100644
--- a/libs/pika/execution_base/include/pika/execution_base/sender.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/sender.hpp
@@ -42,7 +42,6 @@ namespace pika::execution::experimental {
 #include <pika/config/constexpr.hpp>
 #include <pika/execution_base/operation_state.hpp>
 #include <pika/execution_base/receiver.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/tag_invoke.hpp>
 #include <pika/type_support/equality.hpp>
 
@@ -236,7 +235,7 @@ namespace pika::execution::experimental {
         template <typename S, typename R>
         struct connect_result_helper<S, R,
             std::enable_if_t<std::is_invocable<connect_t, S, R>::value>>
-          : pika::util::detail::invoke_result<connect_t, S, R>
+          : std::invoke_result<connect_t, S, R>
         {
         };
     }    // namespace detail
@@ -465,8 +464,7 @@ namespace pika::execution::experimental {
     inline constexpr bool is_scheduler_v = is_scheduler<Scheduler>::value;
 
     template <typename S, typename R>
-    using connect_result_t =
-        typename pika::util::detail::invoke_result<connect_t, S, R>::type;
+    using connect_result_t = std::invoke_result_t<connect_t, S, R>;
 }    // namespace pika::execution::experimental
 #endif
 
diff --git a/libs/pika/executors/tests/unit/shared_parallel_executor.cpp b/libs/pika/executors/tests/unit/shared_parallel_executor.cpp
index dec378fe9..75b2bac5f 100644
--- a/libs/pika/executors/tests/unit/shared_parallel_executor.cpp
+++ b/libs/pika/executors/tests/unit/shared_parallel_executor.cpp
@@ -22,8 +22,7 @@
 struct shared_parallel_executor
 {
     template <typename F, typename... Ts>
-    pika::shared_future<
-        typename pika::util::detail::invoke_result<F, Ts...>::type>
+    pika::shared_future<std::invoke_result_t<F, Ts...>>
     async_execute(F&& f, Ts&&... ts)
     {
         return pika::async(std::forward<F>(f), std::forward<Ts>(ts)...);
diff --git a/libs/pika/functional/include/pika/functional/bind.hpp b/libs/pika/functional/include/pika/functional/bind.hpp
index 7e261cbcb..028cfc7c3 100644
--- a/libs/pika/functional/include/pika/functional/bind.hpp
+++ b/libs/pika/functional/include/pika/functional/bind.hpp
@@ -11,7 +11,6 @@
 #include <pika/assert.hpp>
 #include <pika/datastructures/member_pack.hpp>
 #include <pika/functional/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/one_shot.hpp>
 #include <pika/functional/traits/get_function_address.hpp>
 #include <pika/functional/traits/get_function_annotation.hpp>
@@ -62,9 +61,8 @@ namespace pika::util::detail {
     {
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         template <typename... Us>
-        static constexpr PIKA_HOST_DEVICE
-            util::detail::invoke_result_t<T, Us...>
-            call(T&& t, Us&&... vs)
+        static constexpr PIKA_HOST_DEVICE std::invoke_result_t<T, Us...>
+        call(T&& t, Us&&... vs)
         {
             return PIKA_INVOKE(PIKA_FORWARD(T, t), PIKA_FORWARD(Us, vs)...);
         }
@@ -76,7 +74,7 @@ namespace pika::util::detail {
 
     template <typename F, typename... Ts, typename... Us>
     struct invoke_bound_result<F, util::detail::pack<Ts...>, Us...>
-      : util::detail::invoke_result<F,
+      : std::invoke_result<F,
             decltype(bind_eval<Ts, sizeof...(Us)>::call(
                 std::declval<Ts>(), std::declval<Us>()...))...>
     {
diff --git a/libs/pika/functional/include/pika/functional/bind_back.hpp b/libs/pika/functional/include/pika/functional/bind_back.hpp
index 92ff9d05e..9d84722ef 100644
--- a/libs/pika/functional/include/pika/functional/bind_back.hpp
+++ b/libs/pika/functional/include/pika/functional/bind_back.hpp
@@ -10,7 +10,6 @@
 #include <pika/config.hpp>
 #include <pika/datastructures/member_pack.hpp>
 #include <pika/functional/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/one_shot.hpp>
 #include <pika/functional/traits/get_function_address.hpp>
 #include <pika/functional/traits/get_function_annotation.hpp>
@@ -27,7 +26,7 @@ namespace pika::util::detail {
 
     template <typename F, typename... Ts, typename... Us>
     struct invoke_bound_back_result<F, util::detail::pack<Ts...>, Us...>
-      : util::detail::invoke_result<F, Us..., Ts...>
+      : std::invoke_result<F, Us..., Ts...>
     {
     };
 
diff --git a/libs/pika/functional/include/pika/functional/bind_front.hpp b/libs/pika/functional/include/pika/functional/bind_front.hpp
index d9d142a88..2527c161a 100644
--- a/libs/pika/functional/include/pika/functional/bind_front.hpp
+++ b/libs/pika/functional/include/pika/functional/bind_front.hpp
@@ -10,7 +10,6 @@
 #include <pika/config.hpp>
 #include <pika/datastructures/member_pack.hpp>
 #include <pika/functional/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/one_shot.hpp>
 #include <pika/functional/traits/get_function_address.hpp>
 #include <pika/functional/traits/get_function_annotation.hpp>
@@ -27,7 +26,7 @@ namespace pika::util::detail {
 
     template <typename F, typename... Ts, typename... Us>
     struct invoke_bound_front_result<F, util::detail::pack<Ts...>, Us...>
-      : util::detail::invoke_result<F, Ts..., Us...>
+      : std::invoke_result<F, Ts..., Us...>
     {
     };
 
diff --git a/libs/pika/functional/include/pika/functional/deferred_call.hpp b/libs/pika/functional/include/pika/functional/deferred_call.hpp
index 1f6f3d2fd..ca7657cc0 100644
--- a/libs/pika/functional/include/pika/functional/deferred_call.hpp
+++ b/libs/pika/functional/include/pika/functional/deferred_call.hpp
@@ -9,7 +9,6 @@
 #include <pika/config.hpp>
 #include <pika/datastructures/member_pack.hpp>
 #include <pika/functional/invoke_fused.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/traits/get_function_address.hpp>
 #include <pika/functional/traits/get_function_annotation.hpp>
 #include <pika/type_support/decay.hpp>
@@ -35,7 +34,7 @@ namespace pika::detail {
 namespace pika::util::detail {
     template <typename F, typename... Ts>
     struct invoke_deferred_result
-      : util::detail::invoke_result<::pika::detail::decay_unwrap_t<F>,
+      : std::invoke_result<::pika::detail::decay_unwrap_t<F>,
             ::pika::detail::decay_unwrap_t<Ts>...>
     {
     };
@@ -75,7 +74,7 @@ namespace pika::util::detail {
 
         PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
         PIKA_HOST_DEVICE
-        PIKA_FORCEINLINE util::detail::invoke_result_t<F, Ts...> operator()()
+        PIKA_FORCEINLINE std::invoke_result_t<F, Ts...> operator()()
         {
             return PIKA_INVOKE(
                 PIKA_MOVE(_f), PIKA_MOVE(_args).template get<Is>()...);
diff --git a/libs/pika/functional/include/pika/functional/invoke.hpp b/libs/pika/functional/include/pika/functional/invoke.hpp
index 2825dec24..5c777d685 100644
--- a/libs/pika/functional/include/pika/functional/invoke.hpp
+++ b/libs/pika/functional/include/pika/functional/invoke.hpp
@@ -8,9 +8,9 @@
 
 #include <pika/config.hpp>
 #include <pika/functional/detail/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/type_support/void_guard.hpp>
 
+#include <type_traits>
 #include <utility>
 
 namespace pika::util::detail {
@@ -34,7 +34,7 @@ namespace pika::util::detail {
     ///
     /// \note This function is similar to `std::invoke` (C++17)
     template <typename F, typename... Ts>
-    constexpr PIKA_HOST_DEVICE util::detail::invoke_result_t<F, Ts...>
+    constexpr PIKA_HOST_DEVICE std::invoke_result_t<F, Ts...>
     invoke(F&& f, Ts&&... vs)
     {
         return PIKA_INVOKE(PIKA_FORWARD(F, f), PIKA_FORWARD(Ts, vs)...);
diff --git a/libs/pika/functional/include/pika/functional/invoke_fused.hpp b/libs/pika/functional/include/pika/functional/invoke_fused.hpp
index d86955c0a..185152e2e 100644
--- a/libs/pika/functional/include/pika/functional/invoke_fused.hpp
+++ b/libs/pika/functional/include/pika/functional/invoke_fused.hpp
@@ -8,7 +8,6 @@
 
 #include <pika/config.hpp>
 #include <pika/functional/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/type_support/pack.hpp>
 #include <pika/type_support/void_guard.hpp>
 
@@ -30,13 +29,13 @@ namespace pika::util::detail {
 
     template <typename F, typename Tuple, std::size_t... Is>
     struct invoke_fused_result_impl<F, Tuple&, index_pack<Is...>>
-      : util::detail::invoke_result<F, std::tuple_element_t<Is, Tuple>&...>
+      : std::invoke_result<F, std::tuple_element_t<Is, Tuple>&...>
     {
     };
 
     template <typename F, typename Tuple, std::size_t... Is>
     struct invoke_fused_result_impl<F, Tuple&&, index_pack<Is...>>
-      : util::detail::invoke_result<F, std::tuple_element_t<Is, Tuple>&&...>
+      : std::invoke_result<F, std::tuple_element_t<Is, Tuple>&&...>
     {
     };
 
diff --git a/libs/pika/functional/include/pika/functional/one_shot.hpp b/libs/pika/functional/include/pika/functional/one_shot.hpp
index d294e6ad1..b80d04e1c 100644
--- a/libs/pika/functional/include/pika/functional/one_shot.hpp
+++ b/libs/pika/functional/include/pika/functional/one_shot.hpp
@@ -10,7 +10,6 @@
 #include <pika/config.hpp>
 #include <pika/assert.hpp>
 #include <pika/functional/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/traits/get_function_address.hpp>
 #include <pika/functional/traits/get_function_annotation.hpp>
 
@@ -53,7 +52,7 @@ namespace pika::util::detail {
         }
 
         template <typename... Ts>
-        constexpr PIKA_HOST_DEVICE util::detail::invoke_result_t<F, Ts...>
+        constexpr PIKA_HOST_DEVICE std::invoke_result_t<F, Ts...>
         operator()(Ts&&... vs)
         {
             check_call();
diff --git a/libs/pika/futures/include/pika/futures/packaged_continuation.hpp b/libs/pika/futures/include/pika/futures/packaged_continuation.hpp
index 2756009bb..b568097ce 100644
--- a/libs/pika/futures/include/pika/futures/packaged_continuation.hpp
+++ b/libs/pika/futures/include/pika/futures/packaged_continuation.hpp
@@ -72,11 +72,10 @@ namespace pika::lcos::detail {
 
     template <typename Func, typename Future, typename Continuation>
     std::enable_if_t<!traits::detail::is_unique_future<
-        util::detail::invoke_result_t<Func, Future>>::value>
+        std::invoke_result_t<Func, Future>>::value>
     invoke_continuation(Func& func, Future&& future, Continuation& cont)
     {
-        using is_void =
-            std::is_void<util::detail::invoke_result_t<Func, Future>>;
+        using is_void = std::is_void<std::invoke_result_t<Func, Future>>;
 
         pika::scoped_annotation annotate(func);
         invoke_continuation_nounwrap(
@@ -85,13 +84,12 @@ namespace pika::lcos::detail {
 
     template <typename Func, typename Future, typename Continuation>
     std::enable_if_t<traits::detail::is_unique_future<
-        util::detail::invoke_result_t<Func, Future>>::value>
+        std::invoke_result_t<Func, Future>>::value>
     invoke_continuation(Func& func, Future&& future, Continuation& cont)
     {
         pika::detail::try_catch_exception_ptr(
             [&]() {
-                using inner_future =
-                    util::detail::invoke_result_t<Func, Future>;
+                using inner_future = std::invoke_result_t<Func, Future>;
                 using inner_shared_state_ptr =
                     traits::detail::shared_state_ptr_for_t<inner_future>;
 
@@ -195,8 +193,7 @@ namespace pika::lcos::detail {
         void run_impl_nounwrap(
             traits::detail::shared_state_ptr_for_t<Future>&& f)
         {
-            using is_void =
-                std::is_void<util::detail::invoke_result_t<F, Future>>;
+            using is_void = std::is_void<std::invoke_result_t<F, Future>>;
 
             Future future = traits::future_access<Future>::create(PIKA_MOVE(f));
             invoke_continuation_nounwrap(
@@ -258,8 +255,7 @@ namespace pika::lcos::detail {
         void async_impl_nounwrap(
             traits::detail::shared_state_ptr_for_t<Future>&& f)
         {
-            using is_void =
-                std::is_void<util::detail::invoke_result_t<F, Future>>;
+            using is_void = std::is_void<std::invoke_result_t<F, Future>>;
 
             reset_id r(*this);
 
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 1889bdfb5..737331c88 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
@@ -8,7 +8,6 @@
 #pragma once
 
 #include <pika/config.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/traits/future_traits.hpp>
 #include <pika/futures/traits/is_future.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
@@ -48,9 +47,9 @@ namespace pika::traits {
 
         template <typename Future, typename F>
         struct future_then_result<Future, F,
-            std::void_t<pika::util::detail::invoke_result_t<F&, Future>>>
+            std::void_t<std::invoke_result_t<F&, Future>>>
         {
-            using cont_result = pika::util::detail::invoke_result_t<F&, Future>;
+            using cont_result = std::invoke_result_t<F&, Future>;
 
             // perform unwrapping of future<future<R>>
             using result_type = ::pika::detail::lazy_conditional_t<
diff --git a/libs/pika/include/CMakeLists.txt b/libs/pika/include/CMakeLists.txt
index 839ff9ab3..42775c436 100644
--- a/libs/pika/include/CMakeLists.txt
+++ b/libs/pika/include/CMakeLists.txt
@@ -23,7 +23,6 @@ set(include_headers
     pika/stop_token.hpp
     pika/system_error.hpp
     pika/thread.hpp
-    pika/type_traits.hpp
     pika/unwrap.hpp
 )
 
diff --git a/libs/pika/include/include/pika/type_traits.hpp b/libs/pika/include/include/pika/type_traits.hpp
deleted file mode 100644
index 53df09078..000000000
--- a/libs/pika/include/include/pika/type_traits.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//  Copyright (c) 2020 ETH Zurich
-//
-//  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
-
-#include <pika/functional/invoke_result.hpp>
-
-namespace pika {
-    using pika::util::detail::invoke_result;
-}    // namespace pika
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 7dd004419..50a0a5bcc 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
@@ -7,7 +7,6 @@
 #pragma once
 
 #include <pika/config.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/iterator_support/iterator_adaptor.hpp>
 #include <pika/type_support/lazy_conditional.hpp>
 #include <pika/type_support/type_identity.hpp>
@@ -33,7 +32,7 @@ namespace pika::util {
             // premature instantiations
             using reference_type = ::pika::detail::lazy_conditional_t<
                 std::is_void<Reference>::value,
-                util::detail::invoke_result<Transformer, Iterator>,
+                std::invoke_result<Transformer, Iterator>,
                 ::pika::detail::type_identity<Reference>>;
 
             using value_type =
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 1dbe5d836..19bf07297 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
@@ -8,7 +8,6 @@
 #pragma once
 
 #include <pika/config.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/iterator_support/iterator_facade.hpp>
 #include <pika/iterator_support/traits/is_iterator.hpp>
 #include <pika/type_support/pack.hpp>
@@ -511,7 +510,7 @@ namespace pika::traits {
     namespace functional {
         ///////////////////////////////////////////////////////////////////////
         template <typename F, typename T>
-        struct element_result_of : util::detail::invoke_result<F, T>
+        struct element_result_of : std::invoke_result<F, T>
         {
         };
 
diff --git a/libs/pika/iterator_support/tests/unit/stencil3_iterator.cpp b/libs/pika/iterator_support/tests/unit/stencil3_iterator.cpp
index 18230ce81..23788a8a0 100644
--- a/libs/pika/iterator_support/tests/unit/stencil3_iterator.cpp
+++ b/libs/pika/iterator_support/tests/unit/stencil3_iterator.cpp
@@ -140,8 +140,7 @@ namespace test {
         {
             using element_type =
                 typename std::iterator_traits<Iterator>::reference;
-            using value_type = typename pika::util::detail::invoke_result<F,
-                element_type>::type;
+            using value_type = std::invoke_result_t<F, element_type>;
 
             using type = std::tuple<value_type, element_type, value_type>;
         };
diff --git a/libs/pika/lcos/tests/unit/dataflow_external_future.cpp b/libs/pika/lcos/tests/unit/dataflow_external_future.cpp
index 9651b7bf3..9fc3b90a2 100644
--- a/libs/pika/lcos/tests/unit/dataflow_external_future.cpp
+++ b/libs/pika/lcos/tests/unit/dataflow_external_future.cpp
@@ -60,8 +60,7 @@ struct external_future_executor
     template <typename F, typename... Ts>
     decltype(auto) async_execute(F&& f, Ts&&... ts)
     {
-        using is_void = typename std::is_void<
-            typename pika::util::detail::invoke_result<F, Ts...>::type>;
+        using is_void = typename std::is_void<std::invoke_result_t<F, Ts...>>;
         return async_execute_helper(
             is_void{}, std::forward<F>(f), std::forward<Ts>(ts)...);
     }
@@ -156,9 +155,8 @@ struct external_future_additional_argument_executor
     template <typename F, typename... Ts>
     decltype(auto) async_execute(F&& f, Ts&&... ts)
     {
-        using is_void =
-            typename std::is_void<typename pika::util::detail::invoke_result<F,
-                additional_argument, Ts...>::type>;
+        using is_void = typename std::is_void<
+            std::invoke_result_t<F, additional_argument, Ts...>>;
         return async_execute_helper(
             is_void{}, std::forward<F>(f), std::forward<Ts>(ts)...);
     }
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 e095ccb53..0b35f4e49 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
@@ -11,7 +11,6 @@
 #include <pika/assert.hpp>
 #include <pika/functional/detail/invoke.hpp>
 #include <pika/functional/invoke_fused.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/traits/future_access.hpp>
 #include <pika/memory/intrusive_ptr.hpp>
 #include <pika/pack_traversal/detail/container_category.hpp>
@@ -149,9 +148,8 @@ namespace pika {
 
             /// Calls the visitor with the given element
             template <typename T>
-            auto traverse(T&& value) ->
-                typename pika::util::detail::invoke_result<Visitor&,
-                    async_traverse_visit_tag, T>::type
+            auto traverse(T&& value)
+                -> std::invoke_result_t<Visitor&, async_traverse_visit_tag, T>
             {
                 return PIKA_INVOKE(visitor(), async_traverse_visit_tag{},
                     PIKA_FORWARD(T, value));
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 826f2254d..1d472e667 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
@@ -9,7 +9,6 @@
 #include <pika/config.hpp>
 #include <pika/functional/detail/invoke.hpp>
 #include <pika/functional/invoke_fused.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/pack_traversal/detail/container_category.hpp>
 #include <pika/pack_traversal/traits/pack_traversal_rebind_container.hpp>
 #include <pika/type_support/decay.hpp>
@@ -208,7 +207,7 @@ namespace pika::util::detail {
         /// contain spread types.
         template <typename C, typename... T>
         constexpr auto apply_spread_impl(std::false_type, C&& callable,
-            T&&... args) -> typename invoke_result<C, T...>::type
+            T&&... args) -> std::invoke_result_t<C, T...>
         {
             return PIKA_INVOKE(
                 PIKA_FORWARD(C, callable), PIKA_FORWARD(T, args)...);
@@ -435,12 +434,12 @@ namespace pika::util::detail {
         /// version.
         template <typename Container, typename Mapping>
         using mapped_type_from_t = dereferenced_of_t<spreading::unpacked_of_t<
-            typename invoke_result<Mapping, element_of_t<Container>>::type>>;
+            std::invoke_result_t<Mapping, element_of_t<Container>>>>;
 
         /// Deduces to a true_type if the mapping maps to zero elements.
         template <typename T, typename M>
         using is_empty_mapped = spreading::is_empty_spread<
-            std::decay_t<typename invoke_result<M, element_of_t<T>>::type>>;
+            std::decay_t<std::invoke_result_t<M, element_of_t<T>>>>;
 
         /// We are allowed to reuse the container if we map to the same
         /// type we are accepting and when we have
@@ -602,7 +601,7 @@ namespace pika::util::detail {
 
             template <typename... Args>
             auto operator()(Args&&... args)
-                -> std::void_t<typename invoke_result<M, OldArgs>::type...>
+                -> std::void_t<std::invoke_result_t<M, OldArgs>...>
             {
                 int dummy[] = {
                     0, ((void) mapper_(PIKA_FORWARD(Args, args)), 0)...};
@@ -638,8 +637,8 @@ namespace pika::util::detail {
             M mapper_;
 
             template <typename... Args>
-            auto operator()(Args&&... args) -> typename invoke_result<
-                typename invoke_result<M, OldArg>::type>::type
+            auto operator()(Args&&... args)
+                -> std::invoke_result_t<std::invoke_result_t<M, OldArg>>
             {
                 int dummy[] = {
                     0, ((void) mapper_(PIKA_FORWARD(Args, args)), 0)...};
diff --git a/libs/pika/pack_traversal/include/pika/pack_traversal/detail/unwrap_impl.hpp b/libs/pika/pack_traversal/include/pika/pack_traversal/detail/unwrap_impl.hpp
index 17be06656..da62150ac 100644
--- a/libs/pika/pack_traversal/include/pika/pack_traversal/detail/unwrap_impl.hpp
+++ b/libs/pika/pack_traversal/include/pika/pack_traversal/detail/unwrap_impl.hpp
@@ -10,7 +10,6 @@
 #include <pika/datastructures/traits/is_tuple_like.hpp>
 #include <pika/functional/detail/invoke.hpp>
 #include <pika/functional/invoke_fused.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/futures/traits/future_traits.hpp>
 #include <pika/futures/traits/is_future.hpp>
 #include <pika/pack_traversal/pack_traversal.hpp>
@@ -186,8 +185,8 @@ namespace pika::util::detail {
         /// also when the result is a tuple like type, when we received
         /// a single argument.
         template <typename C, typename T>
-        static auto apply(C&& callable, T&& unwrapped) ->
-            typename invoke_result<C, T>::type
+        static auto apply(C&& callable, T&& unwrapped)
+            -> std::invoke_result_t<C, T>
         {
             return PIKA_INVOKE(
                 PIKA_FORWARD(C, callable), PIKA_FORWARD(T, unwrapped));
diff --git a/libs/pika/resource_partitioner/tests/unit/async_customization.cpp b/libs/pika/resource_partitioner/tests/unit/async_customization.cpp
index 043344d34..f4590a4b5 100644
--- a/libs/pika/resource_partitioner/tests/unit/async_customization.cpp
+++ b/libs/pika/resource_partitioner/tests/unit/async_customization.cpp
@@ -98,8 +98,7 @@ struct test_async_executor
     // of a normal async call with arbitrary arguments
     // --------------------------------------------------------------------
     template <typename F, typename... Ts>
-    future<typename util::detail::invoke_result<F, Ts...>::type>
-    async_execute(F&& f, Ts&&... ts)
+    future<std::invoke_result_t<F, Ts...>> async_execute(F&& f, Ts&&... ts)
     {
         using result_type =
             typename util::detail::invoke_deferred_result<F, Ts...>::type;
diff --git a/libs/pika/runtime/include/pika/runtime/run_as_pika_thread.hpp b/libs/pika/runtime/include/pika/runtime/run_as_pika_thread.hpp
index 48a67a543..b81986b5a 100644
--- a/libs/pika/runtime/include/pika/runtime/run_as_pika_thread.hpp
+++ b/libs/pika/runtime/include/pika/runtime/run_as_pika_thread.hpp
@@ -9,7 +9,6 @@
 #include <pika/config.hpp>
 #include <pika/assert.hpp>
 #include <pika/functional/detail/invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/synchronization/spinlock.hpp>
 #include <pika/threading_base/thread_helpers.hpp>
 
@@ -29,7 +28,7 @@ namespace pika::threads {
     namespace detail {
         // This is the overload for running functions which return a value.
         template <typename F, typename... Ts>
-        typename util::detail::invoke_result<F, Ts...>::type
+        std::invoke_result_t<F, Ts...>
         run_as_pika_thread(std::false_type, F const& f, Ts&&... ts)
         {
             // NOTE: The condition variable needs be able to live past the scope
@@ -39,8 +38,7 @@ namespace pika::threads {
             auto cond = std::make_shared<std::condition_variable_any>();
             bool stopping = false;
 
-            using result_type =
-                typename util::detail::invoke_result<F, Ts...>::type;
+            using result_type = std::invoke_result_t<F, Ts...>;
 
             // Using the optional for storing the returned result value
             // allows to support non-default-constructible and move-only
@@ -138,14 +136,13 @@ namespace pika::threads {
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename F, typename... Ts>
-    typename util::detail::invoke_result<F, Ts...>::type
-    run_as_pika_thread(F const& f, Ts&&... vs)
+    std::invoke_result_t<F, Ts...> run_as_pika_thread(F const& f, Ts&&... vs)
     {
         // This shouldn't be used on a pika-thread
         PIKA_ASSERT(pika::threads::detail::get_self_ptr() == nullptr);
 
-        using result_is_void = typename std::is_void<
-            typename util::detail::invoke_result<F, Ts...>::type>::type;
+        using result_is_void =
+            typename std::is_void<std::invoke_result_t<F, Ts...>>::type;
 
         return detail::run_as_pika_thread(
             result_is_void(), f, PIKA_FORWARD(Ts, vs)...);
diff --git a/libs/pika/tag_invoke/CMakeLists.txt b/libs/pika/tag_invoke/CMakeLists.txt
index 8f7abd579..81ed27cde 100644
--- a/libs/pika/tag_invoke/CMakeLists.txt
+++ b/libs/pika/tag_invoke/CMakeLists.txt
@@ -10,7 +10,6 @@ set(tag_invoke_headers
     pika/functional/detail/invoke.hpp
     pika/functional/detail/tag_fallback_invoke.hpp
     pika/functional/detail/tag_priority_invoke.hpp
-    pika/functional/invoke_result.hpp
     pika/functional/tag_invoke.hpp
 )
 
diff --git a/libs/pika/tag_invoke/include/pika/functional/detail/tag_fallback_invoke.hpp b/libs/pika/tag_invoke/include/pika/functional/detail/tag_fallback_invoke.hpp
index 8c3ef9be4..d6ca81dce 100644
--- a/libs/pika/tag_invoke/include/pika/functional/detail/tag_fallback_invoke.hpp
+++ b/libs/pika/tag_invoke/include/pika/functional/detail/tag_fallback_invoke.hpp
@@ -82,7 +82,7 @@ namespace pika::functional::detail {
     /// can be used in a SFINAE context.
     template <typename Tag, typename... Args>
     using tag_fallback_invoke_result =
-        invoke_result<decltype(tag_fallback_invoke), Tag, Args...>;
+        std::invoke_result<decltype(tag_fallback_invoke), Tag, Args...>;
 
     /// `pika::functional::detail::tag_fallback_invoke_result_t<Tag, Args...>` evaluates to
     /// `pika::functional::detail::tag_fallback_invoke_result_t<Tag, Args...>::type`
@@ -104,7 +104,6 @@ namespace pika::functional::detail {
 #else
 
 #include <pika/config.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/tag_invoke.hpp>
 
 #include <type_traits>
@@ -207,7 +206,7 @@ namespace pika::functional::detail {
         is_nothrow_tag_fallback_invocable<Tag, Args...>::value;
 
     template <typename Tag, typename... Args>
-    using tag_fallback_invoke_result = pika::util::detail::invoke_result<
+    using tag_fallback_invoke_result = std::invoke_result<
         decltype(tag_fallback_invoke_ns::tag_fallback_invoke), Tag, Args...>;
 
     template <typename Tag, typename... Args>
diff --git a/libs/pika/tag_invoke/include/pika/functional/detail/tag_priority_invoke.hpp b/libs/pika/tag_invoke/include/pika/functional/detail/tag_priority_invoke.hpp
index f72f2e574..66e652cba 100644
--- a/libs/pika/tag_invoke/include/pika/functional/detail/tag_priority_invoke.hpp
+++ b/libs/pika/tag_invoke/include/pika/functional/detail/tag_priority_invoke.hpp
@@ -83,7 +83,7 @@ namespace pika::functional::detail {
     /// can be used in a SFINAE context.
     template <typename Tag, typename... Args>
     using tag_override_invoke_result =
-        invoke_result<decltype(tag_override_invoke), Tag, Args...>;
+        std::invoke_result<decltype(tag_override_invoke), Tag, Args...>;
 
     /// `pika::functional::detail::tag_override_invoke_result_t<Tag, Args...>` evaluates to
     /// `pika::functional::detail::tag_override_invoke_result_t<Tag, Args...>::type`
@@ -106,7 +106,6 @@ namespace pika::functional::detail {
 
 #include <pika/config.hpp>
 #include <pika/functional/detail/tag_fallback_invoke.hpp>
-#include <pika/functional/invoke_result.hpp>
 #include <pika/functional/tag_invoke.hpp>
 
 #include <type_traits>
@@ -210,7 +209,7 @@ namespace pika::functional::detail {
         is_nothrow_tag_override_invocable<Tag, Args...>::value;
 
     template <typename Tag, typename... Args>
-    using tag_override_invoke_result = pika::util::detail::invoke_result<
+    using tag_override_invoke_result = std::invoke_result<
         decltype(tag_override_invoke_ns::tag_override_invoke), Tag, Args...>;
 
     template <typename Tag, typename... Args>
diff --git a/libs/pika/tag_invoke/include/pika/functional/invoke_result.hpp b/libs/pika/tag_invoke/include/pika/functional/invoke_result.hpp
deleted file mode 100644
index 897a2aa39..000000000
--- a/libs/pika/tag_invoke/include/pika/functional/invoke_result.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//  Copyright (c) 2013-2015 Agustin Berge
-//
-//  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
-
-#include <pika/config.hpp>
-#include <pika/functional/detail/invoke.hpp>
-
-#include <type_traits>
-#include <utility>
-
-namespace pika::util::detail {
-    template <typename T, typename Enable = void>
-    struct invoke_result_impl
-    {
-    };
-
-    template <typename F, typename... Ts>
-    struct invoke_result_impl<F(Ts...),
-        std::void_t<decltype(PIKA_INVOKE(
-            std::declval<F>(), std::declval<Ts>()...))>>
-    {
-        using type =
-            decltype(PIKA_INVOKE(std::declval<F>(), std::declval<Ts>()...));
-    };
-
-    template <typename F, typename... Ts>
-    struct invoke_result : invoke_result_impl<F && (Ts && ...)>
-    {
-    };
-
-    template <typename F, typename... Ts>
-    using invoke_result_t = typename invoke_result<F, Ts...>::type;
-}    // namespace pika::util::detail
diff --git a/libs/pika/tag_invoke/include/pika/functional/tag_invoke.hpp b/libs/pika/tag_invoke/include/pika/functional/tag_invoke.hpp
index d09d2cc25..1b1eb44b4 100644
--- a/libs/pika/tag_invoke/include/pika/functional/tag_invoke.hpp
+++ b/libs/pika/tag_invoke/include/pika/functional/tag_invoke.hpp
@@ -78,7 +78,8 @@ namespace pika::functional::detail {
     /// returning the result type of the call pika::functional::detail::tag_invoke. This
     /// can be used in a SFINAE context.
     template <typename Tag, typename... Args>
-    using tag_invoke_result = invoke_result<decltype(tag_invoke), Tag, Args...>;
+    using tag_invoke_result =
+        std::invoke_result<decltype(tag_invoke), Tag, Args...>;
 
     /// `pika::functional::detail::tag_invoke_result_t<Tag, Args...>` evaluates to
     /// `pika::functional::detail::tag_invoke_result_t<Tag, Args...>::type`
@@ -99,7 +100,6 @@ namespace pika::functional::detail {
 #else
 
 #include <pika/config.hpp>
-#include <pika/functional/invoke_result.hpp>
 
 #include <type_traits>
 #include <utility>
@@ -200,8 +200,7 @@ namespace pika::functional::detail {
 
     template <typename Tag, typename... Args>
     using tag_invoke_result =
-        pika::util::detail::invoke_result<decltype(tag_invoke_ns::tag_invoke),
-            Tag, Args...>;
+        std::invoke_result<decltype(tag_invoke_ns::tag_invoke), Tag, Args...>;
 
     template <typename Tag, typename... Args>
     using tag_invoke_result_t = typename tag_invoke_result<Tag, Args...>::type;
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 e2b929a7f..a4d874c0a 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
@@ -57,8 +57,7 @@ namespace pika {
             }
 
             template <typename... Ts>
-            pika::util::detail::invoke_result_t<fun_type, Ts...>
-            operator()(Ts&&... ts)
+            std::invoke_result_t<fun_type, Ts...> operator()(Ts&&... ts)
             {
                 scoped_annotation annotate(get_function_annotation());
                 return PIKA_INVOKE(f_, PIKA_FORWARD(Ts, ts)...);