From 8d586c6cc1c51d8a2d3b5b8049aeef8c5f08381c Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Fri, 27 Jan 2023 21:19:29 +0100
Subject: [PATCH 1/9] Move completion schedulers to environments

---
 .../pika/async_cuda/cuda_scheduler.hpp        | 21 ++++--
 .../include/pika/async_cuda/then_on_host.hpp  | 15 ++--
 .../pika/async_cuda/then_with_stream.hpp      | 27 ++++---
 .../async_cuda/tests/unit/cuda_scheduler.cu   |  6 +-
 .../async_cuda/tests/unit/then_with_stream.cu | 42 ++++++++---
 .../include/pika/async_mpi/transform_mpi.hpp  | 14 ++--
 .../pika/execution/algorithms/bulk.hpp        | 19 ++---
 .../pika/execution/algorithms/drop_value.hpp  | 29 +++-----
 .../pika/execution/algorithms/make_future.hpp | 11 ++-
 .../execution/algorithms/schedule_from.hpp    | 50 ++++++-------
 .../pika/execution/algorithms/split_tuple.hpp | 18 +++--
 .../pika/execution/algorithms/sync_wait.hpp   |  9 ++-
 .../pika/execution/algorithms/then.hpp        | 22 ++----
 .../pika/execution/algorithms/transfer.hpp    |  3 +-
 .../execution/algorithms/when_all_vector.hpp  | 51 ++++++++-----
 .../tests/include/algorithm_test_utils.hpp    | 71 +++++++++++++++----
 .../tests/unit/algorithm_execute.cpp          | 17 +++--
 .../tests/unit/algorithm_transfer.cpp         | 19 +++--
 .../pika/execution_base/any_sender.hpp        |  6 +-
 .../execution_base/completion_scheduler.hpp   | 38 +++++-----
 .../include/pika/execution_base/receiver.hpp  | 16 -----
 .../include/pika/execution_base/sender.hpp    | 24 ++++++-
 .../execution_base/tests/unit/any_sender.cpp  |  8 +--
 .../tests/unit/basic_receiver.cpp             |  9 +--
 .../tests/unit/basic_schedule.cpp             | 13 +++-
 .../tests/unit/basic_sender.cpp               |  4 +-
 .../pika/executors/std_thread_scheduler.hpp   | 19 +++--
 .../pika/executors/thread_pool_scheduler.hpp  | 23 ++++--
 .../executors/thread_pool_scheduler_bulk.hpp  | 50 ++++---------
 .../tests/unit/std_thread_scheduler.cpp       | 20 +++---
 .../tests/unit/thread_pool_scheduler.cpp      | 20 +++---
 31 files changed, 389 insertions(+), 305 deletions(-)

diff --git a/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp b/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp
index 7901e7d0c0..978ae80383 100644
--- a/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp
+++ b/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp
@@ -149,12 +149,23 @@ namespace pika::cuda::experimental {
                 return {s.scheduler, PIKA_FORWARD(Receiver, receiver)};
             }
 
-            friend cuda_scheduler tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<
-                    pika::execution::experimental::set_value_t>,
-                cuda_scheduler_sender const& s) noexcept
+            struct env
             {
-                return s.scheduler;
+                cuda_scheduler scheduler;
+
+                friend cuda_scheduler tag_invoke(
+                    pika::execution::experimental::get_completion_scheduler_t<
+                        pika::execution::experimental::set_value_t>,
+                    env const& e) noexcept
+                {
+                    return e.scheduler;
+                }
+            };
+
+            friend env tag_invoke(pika::execution::experimental::get_env_t,
+                cuda_scheduler_sender const& s)
+            {
+                return {s.scheduler};
             }
         };
     }    // namespace detail
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 a623366f72..2e15abeb0c 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
@@ -117,7 +117,7 @@ namespace pika::cuda::experimental {
                     });
             }
 
-            friend constexpr pika::execution::experimental::detail::empty_env
+            friend constexpr pika::execution::experimental::empty_env
             tag_invoke(pika::execution::experimental::get_env_t,
                 then_on_host_receiver_type const&) noexcept
             {
@@ -169,7 +169,7 @@ namespace pika::cuda::experimental {
 
             using completion_signatures =
                 pika::execution::experimental::make_completion_signatures<
-                    Sender, pika::execution::experimental::detail::empty_env,
+                    Sender, pika::execution::experimental::empty_env,
                     pika::execution::experimental::completion_signatures<
                         pika::execution::experimental::set_error_t(
                             std::exception_ptr)>,
@@ -225,12 +225,10 @@ namespace pika::cuda::experimental {
                         PIKA_FORWARD(Receiver, receiver), s.f, s.sched});
             }
 
-            friend cuda_scheduler tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<
-                    pika::execution::experimental::set_value_t>,
-                then_on_host_sender_type const& s) noexcept
+            friend auto tag_invoke(pika::execution::experimental::get_env_t,
+                then_on_host_sender_type const& s)
             {
-                return s.sched;
+                return pika::execution::experimental::get_env(s.sender);
             }
         };
     }    // namespace then_on_host_detail
@@ -254,7 +252,8 @@ namespace pika::cuda::experimental {
         {
             auto completion_sched =
                 pika::execution::experimental::get_completion_scheduler<
-                    pika::execution::experimental::set_value_t>(sender);
+                    pika::execution::experimental::set_value_t>(
+                    pika::execution::experimental::get_env(sender));
             static_assert(
                 std::is_same_v<std::decay_t<decltype(completion_sched)>,
                     cuda_scheduler>,
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 208cdd189f..dc01576b49 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
@@ -184,8 +184,7 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<
-                std::decay_t<Sender>,
-                pika::execution::experimental::detail::empty_env,
+                std::decay_t<Sender>, pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
                     pika::execution::experimental::set_error_t(
                         std::exception_ptr)>,
@@ -462,10 +461,9 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                         });
                 }
 
-                friend constexpr pika::execution::experimental::detail::
-                    empty_env
-                    tag_invoke(pika::execution::experimental::get_env_t,
-                        then_with_cuda_stream_receiver const&) noexcept
+                friend constexpr pika::execution::experimental::empty_env
+                tag_invoke(pika::execution::experimental::get_env_t,
+                    then_with_cuda_stream_receiver const&) noexcept
                 {
                     return {};
                 }
@@ -499,8 +497,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                 pika::util::detail::transform_t<
                     pika::execution::experimental::value_types_of_t<
                         std::decay_t<Sender>,
-                        pika::execution::experimental::detail::empty_env,
-                        std::tuple, pika::detail::variant>,
+                        pika::execution::experimental::empty_env, std::tuple,
+                        pika::detail::variant>,
                     value_types_helper>,
                 pika::detail::monostate>;
 #else
@@ -548,7 +546,7 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                     pika::util::detail::transform_t<
                         pika::execution::experimental::value_types_of_t<
                             then_with_cuda_stream_sender_type,
-                            pika::execution::experimental::detail::empty_env,
+                            pika::execution::experimental::empty_env,
                             pika::util::detail::pack, pika::util::detail::pack>,
                         result_types_helper>,
                     pika::detail::monostate>>>;
@@ -600,12 +598,10 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                 PIKA_FORWARD(Receiver, receiver), s.f, s.sched, s.sender);
         }
 
-        friend cuda_scheduler tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<
-                pika::execution::experimental::set_value_t>,
-            then_with_cuda_stream_sender_type const& s) noexcept
+        friend auto tag_invoke(pika::execution::experimental::get_env_t,
+            then_with_cuda_stream_sender_type const& s)
         {
-            return s.sched;
+            return pika::execution::experimental::get_env(s.sender);
         }
     };
 
@@ -616,7 +612,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
     {
         auto completion_sched =
             pika::execution::experimental::get_completion_scheduler<
-                pika::execution::experimental::set_value_t>(sender);
+                pika::execution::experimental::set_value_t>(
+                pika::execution::experimental::get_env(sender));
         static_assert(std::is_same_v<std::decay_t<decltype(completion_sched)>,
                           cuda_scheduler>,
             "then_with_cuda_stream can only be used with senders whose "
diff --git a/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu b/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu
index 6fa1157450..ce42c54e6c 100644
--- a/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu
+++ b/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu
@@ -30,12 +30,12 @@ inline constexpr bool is_cuda_scheduler_v =
     std::is_same_v<std::decay_t<Scheduler>, cu::cuda_scheduler>;
 
 #define CHECK_CUDA_COMPLETION_SCHEDULER(...)                                   \
-    static_assert(is_cuda_scheduler_v<                                         \
-        decltype(ex::get_completion_scheduler<ex::set_value_t>(__VA_ARGS__))>)
+    static_assert(is_cuda_scheduler_v<decltype(ex::get_completion_scheduler<   \
+            ex::set_value_t>(ex::get_env(__VA_ARGS__)))>)
 
 #define CHECK_NOT_CUDA_COMPLETION_SCHEDULER(...)                               \
     static_assert(!is_cuda_scheduler_v<decltype(ex::get_completion_scheduler<  \
-                      ex::set_value_t>(__VA_ARGS__))>)
+                      ex::set_value_t>(ex::get_env(__VA_ARGS__)))>)
 
 int pika_main()
 {
diff --git a/libs/pika/async_cuda/tests/unit/then_with_stream.cu b/libs/pika/async_cuda/tests/unit/then_with_stream.cu
index 4789978e10..fb4592ecf2 100644
--- a/libs/pika/async_cuda/tests/unit/then_with_stream.cu
+++ b/libs/pika/async_cuda/tests/unit/then_with_stream.cu
@@ -67,12 +67,23 @@ struct const_reference_cuda_sender
         return operation_state<R>{std::move(s.x), std::forward<R>(r)};
     }
 
-    friend cu::cuda_scheduler tag_invoke(
-        pika::execution::experimental::get_completion_scheduler_t<
-            pika::execution::experimental::set_value_t>,
-        const_reference_cuda_sender const& s) noexcept
+    struct env
     {
-        return s.sched;
+        cu::cuda_scheduler sched;
+
+        friend cu::cuda_scheduler tag_invoke(
+            pika::execution::experimental::get_completion_scheduler_t<
+                pika::execution::experimental::set_value_t>,
+            env const& e) noexcept
+        {
+            return e.sched;
+        }
+    };
+
+    friend env tag_invoke(pika::execution::experimental::get_env_t,
+        const_reference_cuda_sender const& s)
+    {
+        return {s.sched};
     }
 };
 
@@ -118,12 +129,23 @@ struct const_reference_error_cuda_sender
         return {std::forward<R>(r)};
     }
 
-    friend cu::cuda_scheduler tag_invoke(
-        pika::execution::experimental::get_completion_scheduler_t<
-            pika::execution::experimental::set_value_t>,
-        const_reference_error_cuda_sender const& s) noexcept
+    struct env
+    {
+        cu::cuda_scheduler sched;
+
+        friend cu::cuda_scheduler tag_invoke(
+            pika::execution::experimental::get_completion_scheduler_t<
+                pika::execution::experimental::set_value_t>,
+            env const& e) noexcept
+        {
+            return e.sched;
+        }
+    };
+
+    friend env tag_invoke(pika::execution::experimental::get_env_t,
+        const_reference_error_cuda_sender const& s)
     {
-        return s.sched;
+        return {s.sched};
     }
 };
 
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 13aaab520b..92fe3c6797 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
@@ -115,7 +115,7 @@ namespace pika::mpi::experimental {
             using completion_signatures =
                 pika::execution::experimental::make_completion_signatures<
                     std::decay_t<Sender>,
-                    pika::execution::experimental::detail::empty_env,
+                    pika::execution::experimental::empty_env,
                     pika::execution::experimental::completion_signatures<
                         pika::execution::experimental::set_error_t(
                             std::exception_ptr)>,
@@ -262,10 +262,9 @@ namespace pika::mpi::experimental {
                             });
                     }
 
-                    friend constexpr pika::execution::experimental::detail::
-                        empty_env
-                        tag_invoke(pika::execution::experimental::get_env_t,
-                            transform_mpi_receiver const&) noexcept
+                    friend constexpr pika::execution::experimental::empty_env
+                    tag_invoke(pika::execution::experimental::get_env_t,
+                        transform_mpi_receiver const&) noexcept
                     {
                         return {};
                     }
@@ -288,7 +287,7 @@ namespace pika::mpi::experimental {
                     pika::util::detail::transform_t<
                         pika::execution::experimental::value_types_of_t<
                             std::decay_t<Sender>,
-                            pika::execution::experimental::detail::empty_env,
+                            pika::execution::experimental::empty_env,
                             std::tuple, pika::detail::variant>,
                         value_types_helper>,
                     pika::detail::monostate>;
@@ -340,8 +339,7 @@ namespace pika::mpi::experimental {
                         pika::util::detail::transform_t<
                             pika::execution::experimental::value_types_of_t<
                                 transform_mpi_sender_type,
-                                pika::execution::experimental::detail::
-                                    empty_env,
+                                pika::execution::experimental::empty_env,
                                 pika::util::detail::pack,
                                 pika::util::detail::pack>,
                             result_types_helper>,
diff --git a/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp b/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
index 394d944fe3..21455900b1 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
@@ -63,20 +63,10 @@ namespace pika::bulk_detail {
 
         static constexpr bool sends_done = false;
 
-        template <typename CPO,
-            // clang-format off
-                PIKA_CONCEPT_REQUIRES_(
-                    pika::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    pika::execution::experimental::detail::has_completion_scheduler_v<
-                        CPO, std::decay_t<Sender>>)
-            // clang-format on
-            >
-        friend constexpr auto tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<CPO>,
-            bulk_sender_type const& sender)
+        friend constexpr decltype(auto) tag_invoke(
+            pika::execution::experimental::get_env_t, bulk_sender_type const& s)
         {
-            return pika::execution::experimental::get_completion_scheduler<CPO>(
-                sender.sender);
+            return pika::execution::experimental::get_env(s.sender);
         }
 
         template <typename Receiver>
@@ -182,7 +172,8 @@ namespace pika::execution::experimental {
         {
             auto scheduler =
                 pika::execution::experimental::get_completion_scheduler<
-                    pika::execution::experimental::set_value_t>(sender);
+                    pika::execution::experimental::set_value_t>(
+                    pika::execution::experimental::get_env(sender));
             return pika::functional::detail::tag_invoke(bulk_t{},
                 PIKA_MOVE(scheduler), PIKA_FORWARD(Sender, sender), shape,
                 PIKA_FORWARD(F, f));
diff --git a/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp b/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
index 942642192c..34a1aacde7 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
@@ -57,8 +57,8 @@ namespace pika::drop_value_detail {
             pika::execution::experimental::set_value(PIKA_MOVE(r.receiver));
         }
 
-        friend constexpr pika::execution::experimental::detail::empty_env
-        tag_invoke(pika::execution::experimental::get_env_t,
+        friend constexpr pika::execution::experimental::empty_env tag_invoke(
+            pika::execution::experimental::get_env_t,
             drop_value_receiver_type const&) noexcept
         {
             return {};
@@ -88,7 +88,7 @@ namespace pika::drop_value_detail {
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<Sender,
-                pika::execution::experimental::detail::empty_env,
+                pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<>,
                 empty_set_value>;
 #else
@@ -106,22 +106,6 @@ namespace pika::drop_value_detail {
         static constexpr bool sends_done = false;
 #endif
 
-        template <typename CPO,
-            // clang-format off
-                PIKA_CONCEPT_REQUIRES_(
-                    pika::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    pika::execution::experimental::detail::has_completion_scheduler_v<
-                        CPO, std::decay_t<Sender>>)
-            // clang-format on
-            >
-        friend constexpr auto tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<CPO>,
-            drop_value_sender_type const& sender)
-        {
-            return pika::execution::experimental::get_completion_scheduler<CPO>(
-                sender.sender);
-        }
-
         template <typename Receiver>
         friend auto tag_invoke(pika::execution::experimental::connect_t,
             drop_value_sender_type&& s, Receiver&& receiver)
@@ -139,6 +123,13 @@ namespace pika::drop_value_detail {
                 drop_value_receiver<Receiver>{
                     PIKA_FORWARD(Receiver, receiver)});
         }
+
+        friend constexpr decltype(auto) tag_invoke(
+            pika::execution::experimental::get_env_t,
+            drop_value_sender_type const& s)
+        {
+            return pika::execution::experimental::get_env(s.sender);
+        }
     };
 }    // namespace pika::drop_value_detail
 
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 5037074f95..66a9fdc060 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
@@ -99,8 +99,8 @@ namespace pika::make_future_detail {
             r_local.data.reset();
         }
 
-        friend constexpr pika::execution::experimental::detail::empty_env
-        tag_invoke(pika::execution::experimental::get_env_t,
+        friend constexpr pika::execution::experimental::empty_env tag_invoke(
+            pika::execution::experimental::get_env_t,
             make_future_receiver const&) noexcept
         {
             return {};
@@ -150,8 +150,8 @@ namespace pika::make_future_detail {
             r_local.data.reset();
         }
 
-        friend constexpr pika::execution::experimental::detail::empty_env
-        tag_invoke(pika::execution::experimental::get_env_t,
+        friend constexpr pika::execution::experimental::empty_env tag_invoke(
+            pika::execution::experimental::get_env_t,
             make_future_receiver const&) noexcept
         {
             return {};
@@ -203,8 +203,7 @@ namespace pika::make_future_detail {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         using value_types =
             typename pika::execution::experimental::value_types_of_t<
-                std::decay_t<Sender>,
-                pika::execution::experimental::detail::empty_env,
+                std::decay_t<Sender>, pika::execution::experimental::empty_env,
                 pika::util::detail::pack, pika::util::detail::pack>;
 #else
         using value_types = typename pika::execution::experimental::
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 852c1234a7..248d752b9a 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
@@ -74,38 +74,34 @@ namespace pika::schedule_from_detail {
 
         static constexpr bool sends_done = false;
 
-        template <typename CPO,
-            // clang-format off
-                PIKA_CONCEPT_REQUIRES_(
-                    pika::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    (std::is_same_v<CPO, pika::execution::experimental::set_value_t> ||
-                        pika::execution::experimental::detail::has_completion_scheduler_v<
-                                pika::execution::experimental::set_error_t,
-                                std::decay_t<Sender>> ||
-                        pika::execution::experimental::detail::has_completion_scheduler_v<
-                                pika::execution::experimental::set_stopped_t,
-                                std::decay_t<Sender>>))
-            // clang-format on
-            >
-        friend constexpr auto tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<CPO>,
-            schedule_from_sender_type const& sender)
+        template <typename Env>
+        struct env
         {
-            if constexpr (std::is_same_v<std::decay_t<CPO>,
-                              pika::execution::experimental::set_value_t>)
+            PIKA_NO_UNIQUE_ADDRESS Env e;
+            PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
+
+            friend auto tag_invoke(
+                pika::execution::experimental::get_completion_scheduler_t<
+                    pika::execution::experimental::set_value_t>,
+                env const& e) noexcept
             {
-                return sender.scheduler;
+                return e.scheduler;
             }
-            else
+
+            template <typename Tag,
+                PIKA_CONCEPT_REQUIRES_(std::is_invocable_v<Tag, env const&>)>
+            friend decltype(auto) tag_invoke(Tag, env const& e)
             {
-                return pika::execution::experimental::get_completion_scheduler<
-                    CPO>(sender.predecessor_sender);
+                return Tag{}(e.e);
             }
-            // This silences a bogus warning from nvcc about no return from
-            // a non-void function.
-#if defined(__NVCC__)
-            __builtin_unreachable();
-#endif
+        };
+
+        friend auto tag_invoke(pika::execution::experimental::get_env_t,
+            schedule_from_sender_type const& s)
+        {
+            auto e =
+                pika::execution::experimental::get_env(s.predecessor_sender);
+            return env<std::decay_t<decltype(e)>>{std::move(e), s.scheduler};
         }
 
         template <typename Receiver>
diff --git a/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp b/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
index d81fc53f72..c4df86c0e9 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
@@ -80,7 +80,7 @@ namespace pika::split_tuple_detail {
         using value_type = typename std::decay<
             pika::execution::experimental::detail::single_result_t<
                 typename pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env,
+                    pika::execution::experimental::empty_env,
                     pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #else
         using value_type = typename std::decay<
@@ -95,8 +95,7 @@ namespace pika::split_tuple_detail {
             pika::util::detail::unique_t<pika::util::detail::prepend_t<
                 pika::util::detail::transform_t<
                     typename pika::execution::experimental::error_types_of_t<
-                        Sender,
-                        pika::execution::experimental::detail::empty_env,
+                        Sender, pika::execution::experimental::empty_env,
                         pika::detail::variant>,
                     std::decay>,
                 std::exception_ptr>>;
@@ -144,8 +143,7 @@ namespace pika::split_tuple_detail {
             using value_type = typename std::decay<
                 pika::execution::experimental::detail::single_result_t<
                     typename pika::execution::experimental::value_types_of_t<
-                        Sender,
-                        pika::execution::experimental::detail::empty_env,
+                        Sender, pika::execution::experimental::empty_env,
                         pika::util::detail::pack, pika::util::detail::pack>>>::
                 type;
 #else
@@ -170,7 +168,7 @@ namespace pika::split_tuple_detail {
                 r.state.set_predecessor_done();
             }
 
-            friend constexpr pika::execution::experimental::detail::empty_env
+            friend constexpr pika::execution::experimental::empty_env
             tag_invoke(pika::execution::experimental::get_env_t,
                 split_tuple_receiver const&) noexcept
             {
@@ -213,7 +211,7 @@ namespace pika::split_tuple_detail {
                 constexpr bool sends_stopped =
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
                     pika::execution::experimental::sends_stopped<Sender,
-                        pika::execution::experimental::detail::empty_env>
+                        pika::execution::experimental::empty_env>
 #else
                     pika::execution::experimental::sender_traits<
                         Sender>::sends_done
@@ -413,7 +411,7 @@ namespace pika::split_tuple_detail {
         using value_type = typename std::decay<
             pika::execution::experimental::detail::single_result_t<
                 typename pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env,
+                    pika::execution::experimental::empty_env,
                     pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #else
         using value_type = typename std::decay<
@@ -449,7 +447,7 @@ namespace pika::split_tuple_detail {
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<Sender,
-                pika::execution::experimental::detail::empty_env,
+                pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
                     pika::execution::experimental::set_error_t(
                         std::exception_ptr)>,
@@ -567,7 +565,7 @@ namespace pika::split_tuple_detail {
         using value_type = typename std::decay<
             pika::execution::experimental::detail::single_result_t<
                 typename pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env,
+                    pika::execution::experimental::empty_env,
                     pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #else
         using value_type = typename std::decay<
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 fc72fd511e..ac3b1ab60a 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
@@ -63,13 +63,12 @@ namespace pika::sync_wait_detail {
             template <typename...> class Variant>
         using predecessor_value_types =
             pika::execution::experimental::value_types_of_t<Sender,
-                pika::execution::experimental::detail::empty_env, Tuple,
-                Variant>;
+                pika::execution::experimental::empty_env, Tuple, Variant>;
 
         template <template <typename...> class Variant>
         using predecessor_error_types =
             pika::execution::experimental::error_types_of_t<Sender,
-                pika::execution::experimental::detail::empty_env, Variant>;
+                pika::execution::experimental::empty_env, Variant>;
 
         // The type of the single void or non-void result that we store. If
         // there are multiple variants or multiple values sync_wait will
@@ -231,8 +230,8 @@ namespace pika::sync_wait_detail {
             r.signal_set_called();
         }
 
-        friend constexpr pika::execution::experimental::detail::empty_env
-        tag_invoke(pika::execution::experimental::get_env_t,
+        friend constexpr pika::execution::experimental::empty_env tag_invoke(
+            pika::execution::experimental::get_env_t,
             sync_wait_receiver_type const&) noexcept
         {
             return {};
diff --git a/libs/pika/execution/include/pika/execution/algorithms/then.hpp b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
index cb283f4611..479e69142f 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/then.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
@@ -149,22 +149,6 @@ namespace pika::then_detail {
 
         static constexpr bool sends_done = false;
 
-        template <typename CPO,
-            // clang-format off
-                PIKA_CONCEPT_REQUIRES_(
-                    pika::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    pika::execution::experimental::detail::has_completion_scheduler_v<
-                        CPO, std::decay_t<Sender>>)
-            // clang-format on
-            >
-        friend constexpr auto tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<CPO>,
-            then_sender_type const& sender)
-        {
-            return pika::execution::experimental::get_completion_scheduler<CPO>(
-                sender.sender);
-        }
-
         template <typename Receiver>
         friend auto tag_invoke(pika::execution::experimental::connect_t,
             then_sender_type&& s, Receiver&& receiver)
@@ -182,6 +166,12 @@ namespace pika::then_detail {
                 then_receiver<Receiver, F>{
                     PIKA_FORWARD(Receiver, receiver), r.f});
         }
+
+        friend constexpr decltype(auto) tag_invoke(
+            pika::execution::experimental::get_env_t, then_sender_type const& s)
+        {
+            return pika::execution::experimental::get_env(s.sender);
+        }
     };
 }    // namespace pika::then_detail
 
diff --git a/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp b/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp
index 240e7cd4a7..ed09c1d9c7 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp
@@ -40,7 +40,8 @@ namespace pika::execution::experimental {
         {
             auto completion_scheduler =
                 pika::execution::experimental::get_completion_scheduler<
-                    pika::execution::experimental::set_value_t>(sender);
+                    pika::execution::experimental::set_value_t>(
+                    pika::execution::experimental::get_env(sender));
             return pika::functional::detail::tag_invoke(transfer_t{},
                 PIKA_MOVE(completion_scheduler), PIKA_FORWARD(Sender, sender),
                 PIKA_FORWARD(Scheduler, scheduler));
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 8b3710dc27..f8dec282f7 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
@@ -67,7 +67,7 @@ namespace pika::when_all_vector_detail {
         using element_value_type =
             std::decay_t<pika::execution::experimental::detail::single_result_t<
                 pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env,
+                    pika::execution::experimental::empty_env,
                     pika::util::detail::pack, pika::util::detail::pack>>>;
 
         static constexpr bool is_void_value_type =
@@ -82,10 +82,13 @@ namespace pika::when_all_vector_detail {
         // This sender sends a single vector of the type sent by the
         // predecessor senders or nothing if the predecessor senders send
         // nothing
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types = Variant<std::conditional_t<is_void_value_type,
-            Tuple<>, Tuple<std::vector<element_value_type>>>>;
+        template <typename...>
+        using set_value_helper =
+            pika::execution::experimental::completion_signatures<
+                std::conditional_t<is_void_value_type,
+                    pika::execution::experimental::set_value_t(),
+                    pika::execution::experimental::set_value_t(
+                        std::vector<element_value_type>)>>;
 
         // This sender sends any error types sent by the predecessor senders
         // or std::exception_ptr
@@ -93,19 +96,19 @@ namespace pika::when_all_vector_detail {
         using error_types = pika::util::detail::unique_concat_t<
             pika::util::detail::transform_t<
                 pika::execution::experimental::error_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env, Variant>,
+                    pika::execution::experimental::empty_env, Variant>,
                 std::decay>,
             Variant<std::exception_ptr>>;
 
         static constexpr bool sends_done = false;
 
         using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                std::conditional_t<is_void_value_type,
-                    pika::execution::experimental::set_value_t(),
-                    pika::execution::experimental::set_value_t(
-                        std::vector<element_value_type>)>,
-                pika::execution::experimental::set_error_t(std::exception_ptr)>;
+            pika::execution::experimental::make_completion_signatures<Sender,
+                pika::execution::experimental::empty_env,
+                pika::execution::experimental::completion_signatures<
+                    pika::execution::experimental::set_error_t(
+                        std::exception_ptr)>,
+                set_value_helper>;
 #else
         // We expect a single value type or nothing from the predecessor
         // sender type
@@ -215,10 +218,9 @@ namespace pika::when_all_vector_detail {
                     r.op_state.finish();
                 }
 
-                friend constexpr pika::execution::experimental::detail::
-                    empty_env
-                    tag_invoke(pika::execution::experimental::get_env_t,
-                        when_all_vector_receiver const&) noexcept
+                friend constexpr pika::execution::experimental::empty_env
+                tag_invoke(pika::execution::experimental::get_env_t,
+                    when_all_vector_receiver const&) noexcept
                 {
                     return {};
                 }
@@ -323,8 +325,21 @@ namespace pika::when_all_vector_detail {
                     }
                     else
                     {
-                        pika::execution::experimental::set_stopped(
-                            PIKA_MOVE(receiver));
+#if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
+                        if constexpr (pika::execution::experimental::
+                                          sends_stopped<Sender>)
+#else
+                        if constexpr (pika::execution::experimental::
+                                          sender_traits<Sender>::sends_done)
+#endif
+                        {
+                            pika::execution::experimental::set_stopped(
+                                PIKA_MOVE(receiver));
+                        }
+                        else
+                        {
+                            PIKA_UNREACHABLE;
+                        }
                     }
                 }
             }
diff --git a/libs/pika/execution/tests/include/algorithm_test_utils.hpp b/libs/pika/execution/tests/include/algorithm_test_utils.hpp
index a68c0c370d..deb1e3674f 100644
--- a/libs/pika/execution/tests/include/algorithm_test_utils.hpp
+++ b/libs/pika/execution/tests/include/algorithm_test_utils.hpp
@@ -163,8 +163,8 @@ struct callback_receiver
         r.set_value_called = true;
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         callback_receiver const&) noexcept
     {
         return {};
@@ -199,8 +199,8 @@ struct error_callback_receiver
         PIKA_TEST(r.expect_set_value);
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         error_callback_receiver const&) noexcept
     {
         return {};
@@ -502,10 +502,25 @@ struct scheduler
             return operation_state<R>{std::forward<R>(r)};
         }
 
-        friend scheduler tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<
-                pika::execution::experimental::set_value_t>,
-            sender const& s) noexcept
+        struct env
+        {
+            std::reference_wrapper<std::atomic<bool>> schedule_called;
+            std::reference_wrapper<std::atomic<bool>> execute_called;
+            std::reference_wrapper<std::atomic<bool>>
+                tag_invoke_overload_called;
+
+            friend scheduler tag_invoke(
+                pika::execution::experimental::get_completion_scheduler_t<
+                    pika::execution::experimental::set_value_t>,
+                env const& e) noexcept
+            {
+                return {e.schedule_called, e.execute_called,
+                    e.tag_invoke_overload_called};
+            }
+        };
+
+        friend env tag_invoke(
+            pika::execution::experimental::get_env_t, sender const& s)
         {
             return {s.schedule_called, s.execute_called,
                 s.tag_invoke_overload_called};
@@ -583,10 +598,25 @@ struct scheduler2
             return operation_state<R>{std::forward<R>(r)};
         }
 
-        friend scheduler2 tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<
-                pika::execution::experimental::set_value_t>,
-            sender const& s) noexcept
+        struct env
+        {
+            std::reference_wrapper<std::atomic<bool>> schedule_called;
+            std::reference_wrapper<std::atomic<bool>> execute_called;
+            std::reference_wrapper<std::atomic<bool>>
+                tag_invoke_overload_called;
+
+            friend scheduler2 tag_invoke(
+                pika::execution::experimental::get_completion_scheduler_t<
+                    pika::execution::experimental::set_value_t>,
+                env const& e) noexcept
+            {
+                return {e.schedule_called, e.execute_called,
+                    e.tag_invoke_overload_called};
+            }
+        };
+
+        friend env tag_invoke(
+            pika::execution::experimental::get_env_t, sender const& s)
         {
             return {s.schedule_called, s.execute_called,
                 s.tag_invoke_overload_called};
@@ -690,6 +720,23 @@ namespace my_namespace {
             {
                 return {};
             }
+
+            struct env
+            {
+                friend my_scheduler tag_invoke(
+                    pika::execution::experimental::get_completion_scheduler_t<
+                        pika::execution::experimental::set_value_t>,
+                    env const&) noexcept
+                {
+                    return {};
+                }
+            };
+
+            friend env tag_invoke(
+                pika::execution::experimental::get_env_t, sender const&)
+            {
+                return {};
+            }
         };
 
         friend sender tag_invoke(
diff --git a/libs/pika/execution/tests/unit/algorithm_execute.cpp b/libs/pika/execution/tests/unit/algorithm_execute.cpp
index 7fdc605b80..7fdea2a8bb 100644
--- a/libs/pika/execution/tests/unit/algorithm_execute.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_execute.cpp
@@ -43,10 +43,19 @@ struct sender
         return {};
     }
 
-    friend Scheduler tag_invoke(
-        pika::execution::experimental::get_completion_scheduler_t<
-            pika::execution::experimental::set_value_t>,
-        sender const&) noexcept
+    struct env
+    {
+        friend Scheduler tag_invoke(
+            pika::execution::experimental::get_completion_scheduler_t<
+                pika::execution::experimental::set_value_t>,
+            env const&) noexcept
+        {
+            return {};
+        }
+    };
+
+    friend env tag_invoke(
+        pika::execution::experimental::get_env_t, sender const&) noexcept
     {
         return {};
     }
diff --git a/libs/pika/execution/tests/unit/algorithm_transfer.cpp b/libs/pika/execution/tests/unit/algorithm_transfer.cpp
index 27f37a7afe..221edf0db7 100644
--- a/libs/pika/execution/tests/unit/algorithm_transfer.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_transfer.cpp
@@ -209,11 +209,22 @@ struct sender_with_completion_scheduler : void_sender
     {
     }
 
-    friend scheduler_transfer tag_invoke(
-        ex::get_completion_scheduler_t<ex::set_value_t>,
-        sender_with_completion_scheduler s) noexcept
+    struct env
     {
-        return s.sched;
+        scheduler_transfer scheduler;
+
+        friend scheduler_transfer tag_invoke(
+            ex::get_completion_scheduler_t<ex::set_value_t>,
+            env const& e) noexcept
+        {
+            return e.scheduler;
+        }
+    };
+
+    friend env tag_invoke(
+        ex::get_env_t, sender_with_completion_scheduler const& s)
+    {
+        return {s.sched};
     }
 };
 
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 abcd069d57..c6696f5af8 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
@@ -552,8 +552,8 @@ namespace pika::execution::experimental::detail {
             PIKA_MOVE(moved_storage.get()).set_stopped();
         }
 
-        friend constexpr pika::execution::experimental::detail::empty_env
-        tag_invoke(pika::execution::experimental::get_env_t,
+        friend constexpr pika::execution::experimental::empty_env tag_invoke(
+            pika::execution::experimental::get_env_t,
             any_receiver const&) noexcept
         {
             return {};
@@ -930,7 +930,7 @@ namespace pika::execution::experimental {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
             using value_types_pack =
                 pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env,
+                    pika::execution::experimental::empty_env,
                     pika::util::detail::pack, pika::util::detail::pack>;
 #else
             using value_types_pack = typename pika::execution::experimental::
diff --git a/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp b/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp
index a26ebe1ed5..304c312200 100644
--- a/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp
@@ -21,8 +21,8 @@ namespace pika::execution::experimental::detail {
     template <typename CPO, typename Sender>
     struct has_completion_scheduler_impl<true, CPO, Sender>
       : pika::execution::experimental::is_scheduler<
-            pika::functional::detail::tag_invoke_result_t<
-                get_completion_scheduler_t<CPO>, std::decay_t<Sender> const&>>
+            std::invoke_result_t<get_completion_scheduler_t<CPO>,
+                std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>>
     {
     };
 
@@ -30,7 +30,8 @@ namespace pika::execution::experimental::detail {
     struct has_completion_scheduler
       : has_completion_scheduler_impl<
             pika::functional::detail::is_tag_invocable_v<
-                get_completion_scheduler_t<CPO>, std::decay_t<Sender> const&>,
+                get_completion_scheduler_t<CPO>,
+                std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>,
             CPO, Sender>
     {
     };
@@ -46,16 +47,15 @@ namespace pika::execution::experimental::detail {
 #include <type_traits>
 
 namespace pika::execution::experimental {
-    template <typename Scheduler>
+    template <typename CPO>
     struct get_completion_scheduler_t final
-      : pika::functional::detail::tag<get_completion_scheduler_t<Scheduler>>
+      : pika::functional::detail::tag<get_completion_scheduler_t<CPO>>
     {
     };
 
-    template <typename Scheduler>
-    PIKA_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE
-        get_completion_scheduler_t<Scheduler>
-            get_completion_scheduler{};
+    template <typename CPO>
+    PIKA_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE get_completion_scheduler_t<CPO>
+        get_completion_scheduler{};
 
     namespace detail {
         template <bool TagInvocable, typename CPO, typename Sender>
@@ -65,18 +65,18 @@ namespace pika::execution::experimental {
 
         template <typename CPO, typename Sender>
         struct has_completion_scheduler_impl<true, CPO, Sender>
-          : pika::execution::experimental::is_scheduler<pika::functional::
-                    detail::tag_invoke_result_t<get_completion_scheduler_t<CPO>,
-                        std::decay_t<Sender> const&>>
+          : pika::execution::experimental::is_scheduler<std::invoke_result_t<
+                get_completion_scheduler_t<CPO>,
+                std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>>
         {
         };
 
         template <typename CPO, typename Sender>
         struct has_completion_scheduler
           : has_completion_scheduler_impl<
-                pika::functional::detail::is_tag_invocable_v<
-                    get_completion_scheduler_t<CPO>,
-                    std::decay_t<Sender> const&>,
+                std::is_invocable_v<get_completion_scheduler_t<CPO>,
+                    std::invoke_result_t<get_env_t,
+                        std::decay_t<Sender> const&>>,
                 CPO, Sender>
         {
         };
@@ -96,11 +96,13 @@ namespace pika::execution::experimental {
         struct is_completion_scheduler_tag_invocable_impl<true, ReceiverCPO,
             Sender, AlgorithmCPO, Ts...>
           : std::integral_constant<bool,
-                pika::functional::detail::is_tag_invocable_v<AlgorithmCPO,
-                    pika::functional::detail::tag_invoke_result_t<
+                std::is_invocable_v<AlgorithmCPO,
+                    std::invoke_result_t<
                         pika::execution::experimental::
                             get_completion_scheduler_t<ReceiverCPO>,
-                        Sender>,
+                        std::invoke_result_t<
+                            pika::execution::experimental::get_env_t,
+                            std::decay_t<Sender> const&>>,
                     Sender, Ts...>>
         {
         };
diff --git a/libs/pika/execution_base/include/pika/execution_base/receiver.hpp b/libs/pika/execution_base/include/pika/execution_base/receiver.hpp
index 3a6a20cb23..3b8101412a 100644
--- a/libs/pika/execution_base/include/pika/execution_base/receiver.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/receiver.hpp
@@ -29,12 +29,6 @@ namespace pika::execution::experimental {
     {
         static constexpr bool value = is_receiver_of_v<Receiver, Completions>;
     };
-
-    namespace detail {
-        struct empty_env
-        {
-        };
-    }    // namespace detail
 }    // namespace pika::execution::experimental
 #else
 #include <pika/config/constexpr.hpp>
@@ -202,16 +196,6 @@ namespace pika::execution::experimental {
 
     template <typename T, typename... As>
     inline constexpr bool is_receiver_of_v = is_receiver_of<T, As...>::value;
-
-    namespace detail {
-        struct empty_env
-        {
-        };
-    }    // namespace detail
-
-    inline constexpr struct get_env_t
-    {
-    } get_env{};
 }    // namespace pika::execution::experimental
 #endif
 
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 14e6122be6..20824660dc 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,7 @@ 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/tag_invoke.hpp>
+#include <pika/functional/detail/tag_fallback_invoke.hpp>
 #include <pika/type_support/equality.hpp>
 
 #include <cstddef>
@@ -465,6 +465,28 @@ namespace pika::execution::experimental {
 
     template <typename S, typename R>
     using connect_result_t = std::invoke_result_t<connect_t, S, R>;
+
+    struct empty_env
+    {
+    };
+
+    inline constexpr struct get_env_t final
+      : pika::functional::detail::tag_fallback<get_env_t>
+    {
+        template <typename T>
+        friend constexpr auto
+        tag_fallback_invoke(get_env_t const&, T const&) noexcept
+        {
+            if constexpr (is_sender_v<T>)
+            {
+                return empty_env{};
+            }
+            else
+            {
+                static_assert(sizeof(T) == 0, "No environment for type T");
+            }
+        }
+    } get_env{};
 }    // namespace pika::execution::experimental
 #endif
 
diff --git a/libs/pika/execution_base/tests/unit/any_sender.cpp b/libs/pika/execution_base/tests/unit/any_sender.cpp
index d6d9d41ead..9c7cf75ef0 100644
--- a/libs/pika/execution_base/tests/unit/any_sender.cpp
+++ b/libs/pika/execution_base/tests/unit/any_sender.cpp
@@ -291,8 +291,8 @@ struct callback_receiver
         r.set_value_called = true;
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         callback_receiver const&) noexcept
     {
         return {};
@@ -334,8 +334,8 @@ struct error_receiver
         PIKA_TEST(false);
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         error_receiver const&) noexcept
     {
         return {};
diff --git a/libs/pika/execution_base/tests/unit/basic_receiver.cpp b/libs/pika/execution_base/tests/unit/basic_receiver.cpp
index e4c69643cf..5b48b0cc02 100644
--- a/libs/pika/execution_base/tests/unit/basic_receiver.cpp
+++ b/libs/pika/execution_base/tests/unit/basic_receiver.cpp
@@ -5,6 +5,7 @@
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <pika/execution_base/receiver.hpp>
+#include <pika/execution_base/sender.hpp>
 #include <pika/testing.hpp>
 
 #include <exception>
@@ -37,7 +38,7 @@ namespace mylib {
             value_called = true;
         }
 
-        friend constexpr ex::detail::empty_env tag_invoke(
+        friend constexpr ex::empty_env tag_invoke(
             ex::get_env_t, receiver_1 const&) noexcept
         {
             return {};
@@ -56,7 +57,7 @@ namespace mylib {
             error_called = true;
         }
 
-        friend constexpr ex::detail::empty_env tag_invoke(
+        friend constexpr ex::empty_env tag_invoke(
             ex::get_env_t, receiver_2 const&) noexcept
         {
             return {};
@@ -81,7 +82,7 @@ namespace mylib {
             value_called = true;
         }
 
-        friend constexpr ex::detail::empty_env tag_invoke(
+        friend constexpr ex::empty_env tag_invoke(
             ex::get_env_t, receiver_3 const&) noexcept
         {
             return {};
@@ -163,7 +164,7 @@ namespace mylib {
             value_called = true;
         }
 
-        friend constexpr ex::detail::empty_env tag_invoke(
+        friend constexpr ex::empty_env tag_invoke(
             ex::get_env_t, non_receiver_4 const&) noexcept
         {
             return {};
diff --git a/libs/pika/execution_base/tests/unit/basic_schedule.cpp b/libs/pika/execution_base/tests/unit/basic_schedule.cpp
index c34e27bca7..6028b6830b 100644
--- a/libs/pika/execution_base/tests/unit/basic_schedule.cpp
+++ b/libs/pika/execution_base/tests/unit/basic_schedule.cpp
@@ -48,8 +48,17 @@ struct sender
         return {};
     }
 
-    friend Scheduler tag_invoke(
-        ex::get_completion_scheduler_t<ex::set_value_t>, sender const&) noexcept
+    struct env
+    {
+        friend Scheduler tag_invoke(
+            ex::get_completion_scheduler_t<ex::set_value_t>,
+            env const&) noexcept
+        {
+            return {};
+        }
+    };
+
+    friend env tag_invoke(ex::get_env_t, sender const&) noexcept
     {
         return {};
     }
diff --git a/libs/pika/execution_base/tests/unit/basic_sender.cpp b/libs/pika/execution_base/tests/unit/basic_sender.cpp
index c08a69c7ed..b9ba3bdd93 100644
--- a/libs/pika/execution_base/tests/unit/basic_sender.cpp
+++ b/libs/pika/execution_base/tests/unit/basic_sender.cpp
@@ -84,7 +84,7 @@ struct receiver
         r.i.get() = v;
     }
 
-    friend constexpr ex::detail::empty_env tag_invoke(
+    friend constexpr ex::empty_env tag_invoke(
         ex::get_env_t, receiver const&) noexcept
     {
         return {};
@@ -171,7 +171,7 @@ struct void_receiver
         ++void_receiver_set_value_calls;
     }
 
-    friend constexpr ex::detail::empty_env tag_invoke(
+    friend constexpr ex::empty_env tag_invoke(
         ex::get_env_t, void_receiver const&) noexcept
     {
         return {};
diff --git a/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp b/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
index dda7a8ea8b..19c49fea46 100644
--- a/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
@@ -98,12 +98,19 @@ namespace pika::execution::experimental {
                 return {PIKA_FORWARD(Receiver, receiver)};
             }
 
-            template <typename CPO,
-                PIKA_CONCEPT_REQUIRES_(std::is_same_v<CPO,
-                    pika::execution::experimental::set_value_t>)>
-            friend constexpr std_thread_scheduler tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<CPO>,
-                sender const&) noexcept
+            struct env
+            {
+                friend constexpr std_thread_scheduler tag_invoke(
+                    pika::execution::experimental::get_completion_scheduler_t<
+                        pika::execution::experimental::set_value_t>,
+                    env const&) noexcept
+                {
+                    return {};
+                }
+            };
+
+            friend constexpr env tag_invoke(
+                pika::execution::experimental::get_env_t, sender const&)
             {
                 return {};
             }
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
index 15231fe210..9bd8d3d566 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
@@ -237,14 +237,23 @@ namespace pika::execution::experimental {
                     s.fallback_annotation};
             }
 
-            template <typename CPO,
-                PIKA_CONCEPT_REQUIRES_(std::is_same_v<CPO,
-                    pika::execution::experimental::set_value_t>)>
-            friend constexpr auto tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<CPO>,
-                sender const& s) noexcept
+            struct env
             {
-                return s.scheduler;
+                PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
+
+                friend auto tag_invoke(
+                    pika::execution::experimental::get_completion_scheduler_t<
+                        pika::execution::experimental::set_value_t>,
+                    env const& e) noexcept
+                {
+                    return e.scheduler;
+                }
+            };
+
+            friend env tag_invoke(
+                pika::execution::experimental::get_env_t, sender const& s)
+            {
+                return {s.scheduler};
             }
         };
 
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
index 3fea5f1c59..f5286e39a1 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
@@ -89,19 +89,18 @@ namespace pika::thread_pool_bulk_detail {
             template <typename...> class Variant>
         using value_types =
             pika::execution::experimental::value_types_of_t<Sender,
-                pika::execution::experimental::detail::empty_env, Tuple,
-                Variant>;
+                pika::execution::experimental::empty_env, Tuple, Variant>;
 
         template <template <typename...> class Variant>
         using error_types =
             pika::util::detail::unique_t<pika::util::detail::prepend_t<
                 pika::execution::experimental::error_types_of_t<Sender,
-                    pika::execution::experimental::detail::empty_env, Variant>,
+                    pika::execution::experimental::empty_env, Variant>,
                 std::exception_ptr>>;
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<Sender,
-                pika::execution::experimental::detail::empty_env,
+                pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
                     pika::execution::experimental::set_error_t(
                         std::exception_ptr)>>;
@@ -122,35 +121,6 @@ namespace pika::thread_pool_bulk_detail {
         static constexpr bool sends_done = false;
 #endif
 
-        template <typename CPO,
-            // clang-format off
-                PIKA_CONCEPT_REQUIRES_(
-                    pika::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    (std::is_same_v<CPO, pika::execution::experimental::set_value_t> ||
-                        pika::execution::experimental::detail::has_completion_scheduler_v<
-                                pika::execution::experimental::set_error_t,
-                                std::decay_t<Sender>> ||
-                        pika::execution::experimental::detail::has_completion_scheduler_v<
-                                pika::execution::experimental::set_stopped_t,
-                                std::decay_t<Sender>>))
-            // clang-format on
-            >
-        friend constexpr auto tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<CPO>,
-            thread_pool_bulk_sender const& s) noexcept
-        {
-            if constexpr (std::is_same_v<std::decay_t<CPO>,
-                              pika::execution::experimental::set_value_t>)
-            {
-                return s.scheduler;
-            }
-            else
-            {
-                return pika::execution::experimental::get_completion_scheduler<
-                    CPO>(s);
-            }
-        }
-
     private:
         template <typename Receiver>
         struct operation_state
@@ -503,10 +473,9 @@ namespace pika::thread_pool_bulk_detail {
                     r.do_work_local(n, chunk_size, local_worker_thread);
                 }
 
-                friend constexpr pika::execution::experimental::detail::
-                    empty_env
-                    tag_invoke(pika::execution::experimental::get_env_t,
-                        bulk_receiver const&) noexcept
+                friend constexpr pika::execution::experimental::empty_env
+                tag_invoke(pika::execution::experimental::get_env_t,
+                    bulk_receiver const&) noexcept
                 {
                     return {};
                 }
@@ -573,6 +542,13 @@ namespace pika::thread_pool_bulk_detail {
             return operation_state<std::decay_t<Receiver>>{s.scheduler,
                 s.sender, s.shape, s.f, PIKA_FORWARD(Receiver, receiver)};
         }
+
+        friend constexpr auto tag_invoke(
+            pika::execution::experimental::get_env_t,
+            thread_pool_bulk_sender const& s)
+        {
+            return pika::execution::experimental::get_env(s.sender);
+        }
     };
 }    // namespace pika::thread_pool_bulk_detail
 
diff --git a/libs/pika/executors/tests/unit/std_thread_scheduler.cpp b/libs/pika/executors/tests/unit/std_thread_scheduler.cpp
index f8ac5da1a8..f5e9685e80 100644
--- a/libs/pika/executors/tests/unit/std_thread_scheduler.cpp
+++ b/libs/pika/executors/tests/unit/std_thread_scheduler.cpp
@@ -79,8 +79,8 @@ struct check_context_receiver
         r.cond.notify_one();
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         check_context_receiver const&) noexcept
     {
         return {};
@@ -248,8 +248,8 @@ struct callback_receiver
         r.cond.notify_one();
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         callback_receiver const&) noexcept
     {
         return {};
@@ -1316,7 +1316,7 @@ void test_completion_scheduler()
     {
         auto sender = ex::schedule(ex::std_thread_scheduler{});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::std_thread_scheduler>,
@@ -1327,7 +1327,7 @@ void test_completion_scheduler()
         auto sender =
             ex::then(ex::schedule(ex::std_thread_scheduler{}), []() {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::std_thread_scheduler>,
@@ -1337,7 +1337,7 @@ void test_completion_scheduler()
     {
         auto sender = ex::transfer_just(ex::std_thread_scheduler{}, 42);
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::std_thread_scheduler>,
@@ -1349,7 +1349,7 @@ void test_completion_scheduler()
         auto sender =
             ex::bulk(ex::schedule(ex::std_thread_scheduler{}), 10, [](int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::std_thread_scheduler>,
@@ -1362,7 +1362,7 @@ void test_completion_scheduler()
                          10, [](int, int) {}),
                 [](int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::std_thread_scheduler>,
@@ -1375,7 +1375,7 @@ void test_completion_scheduler()
                          [](int) {}),
                 10, [](int, int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::std_thread_scheduler>,
diff --git a/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp b/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp
index 2336c9b4af..ac75204a05 100644
--- a/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp
+++ b/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp
@@ -88,8 +88,8 @@ struct check_context_receiver
         r.cond.notify_one();
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         check_context_receiver const&) noexcept
     {
         return {};
@@ -257,8 +257,8 @@ struct callback_receiver
         r.cond.notify_one();
     }
 
-    friend constexpr pika::execution::experimental::detail::empty_env
-    tag_invoke(pika::execution::experimental::get_env_t,
+    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+        pika::execution::experimental::get_env_t,
         callback_receiver const&) noexcept
     {
         return {};
@@ -1868,7 +1868,7 @@ void test_completion_scheduler()
     {
         auto sender = ex::schedule(ex::thread_pool_scheduler{});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -1879,7 +1879,7 @@ void test_completion_scheduler()
         auto sender =
             ex::then(ex::schedule(ex::thread_pool_scheduler{}), []() {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -1889,7 +1889,7 @@ void test_completion_scheduler()
     {
         auto sender = ex::transfer_just(ex::thread_pool_scheduler{}, 42);
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -1900,7 +1900,7 @@ void test_completion_scheduler()
         auto sender =
             ex::bulk(ex::schedule(ex::thread_pool_scheduler{}), 10, [](int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -1913,7 +1913,7 @@ void test_completion_scheduler()
                 [](int, int) {}),
             [](int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -1926,7 +1926,7 @@ void test_completion_scheduler()
                 ex::transfer_just(ex::thread_pool_scheduler{}, 42), [](int) {}),
             10, [](int, int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(sender);
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,

From 04421c402dc2126beb7ce587470db2f84a6595ec Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Tue, 14 Feb 2023 17:44:31 +0100
Subject: [PATCH 2/9] Re-enable disabled bulk and split tests with STDEXEC

---
 libs/pika/execution/tests/unit/algorithm_bulk.cpp  | 8 --------
 libs/pika/execution/tests/unit/algorithm_split.cpp | 4 ----
 2 files changed, 12 deletions(-)

diff --git a/libs/pika/execution/tests/unit/algorithm_bulk.cpp b/libs/pika/execution/tests/unit/algorithm_bulk.cpp
index 9e03367a7c..0b7b1e3b37 100644
--- a/libs/pika/execution/tests/unit/algorithm_bulk.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_bulk.cpp
@@ -49,10 +49,6 @@ auto tag_invoke(ex::bulk_t, S&& s, int num, custom_bulk_operation t)
 
 int main()
 {
-    // TODO: bulk does not have a fallback implementation in the reference
-    // implementation. With P2300 enabled bulk is tested in
-    // thread_pool_scheduler_test.
-#if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
     // Success path
     {
         std::atomic<bool> set_value_called{false};
@@ -263,10 +259,6 @@ int main()
     }
 
     test_adl_isolation(ex::bulk(ex::just(), 1, my_namespace::my_type{}));
-#else
-    // No tests with the P2300 reference implementation
-    PIKA_TEST(true);
-#endif
 
     return 0;
 }
diff --git a/libs/pika/execution/tests/unit/algorithm_split.cpp b/libs/pika/execution/tests/unit/algorithm_split.cpp
index 496268fbf0..ff5f82b488 100644
--- a/libs/pika/execution/tests/unit/algorithm_split.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_split.cpp
@@ -65,9 +65,6 @@ int main()
         PIKA_TEST(set_value_called);
     }
 
-    // The P2300 reference implementation still requires copyable senders (see
-    // issue https://github.com/NVIDIA/stdexec/issues/641).
-#if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
     {
         std::atomic<bool> set_value_called{false};
         auto s1 =
@@ -91,7 +88,6 @@ int main()
         ex::start(os);
         PIKA_TEST(set_value_called);
     }
-#endif
 
     // operator| overload
     {

From 57d3b91694032c0b68c5dd8e2ba68da48ad66e1d Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Tue, 14 Feb 2023 17:50:20 +0100
Subject: [PATCH 3/9] Update CI image tag to get newer version of stdexec

---
 .circleci/config.yml                             | 2 +-
 .github/workflows/linux_coverage.yml             | 2 +-
 .github/workflows/linux_debug.yml                | 2 +-
 .github/workflows/linux_hip.yml                  | 2 +-
 .github/workflows/linux_release_fetchcontent.yml | 2 +-
 .github/workflows/linux_sanitizers.yml           | 2 +-
 .github/workflows/linux_tracy.yml                | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 2111850e65..69ac4fc5dc 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -26,7 +26,7 @@ setup_arm64_machine: &setup_arm64_machine
 
 docker_default: &docker_default
     docker:
-      - image: pikaorg/pika-ci-base:14
+      - image: pikaorg/pika-ci-base:15
 
 defaults: &defaults
     <<: *working_dir_default
diff --git a/.github/workflows/linux_coverage.yml b/.github/workflows/linux_coverage.yml
index cc2182ac36..508be29380 100644
--- a/.github/workflows/linux_coverage.yml
+++ b/.github/workflows/linux_coverage.yml
@@ -15,7 +15,7 @@ jobs:
   build:
     name: github/linux/coverage
     runs-on: ubuntu-latest
-    container: pikaorg/pika-ci-base:14
+    container: pikaorg/pika-ci-base:15
 
     steps:
     - uses: actions/checkout@v3
diff --git a/.github/workflows/linux_debug.yml b/.github/workflows/linux_debug.yml
index f9e68ee529..0aa4b251dd 100644
--- a/.github/workflows/linux_debug.yml
+++ b/.github/workflows/linux_debug.yml
@@ -20,7 +20,7 @@ jobs:
   build:
     name: github/linux/debug/fast
     runs-on: ubuntu-latest
-    container: pikaorg/pika-ci-base:14
+    container: pikaorg/pika-ci-base:15
 
     steps:
     - uses: actions/checkout@v3
diff --git a/.github/workflows/linux_hip.yml b/.github/workflows/linux_hip.yml
index f4c63adc75..7ea639155e 100644
--- a/.github/workflows/linux_hip.yml
+++ b/.github/workflows/linux_hip.yml
@@ -20,7 +20,7 @@ jobs:
   build:
     name: github/linux/hip/fast
     runs-on: ubuntu-latest
-    container: pikaorg/pika-ci-hip:7
+    container: pikaorg/pika-ci-hip:8
     steps:
     - uses: actions/checkout@v3
     - name: Update apt repositories for ccache
diff --git a/.github/workflows/linux_release_fetchcontent.yml b/.github/workflows/linux_release_fetchcontent.yml
index d3608e1387..d618cc3d04 100644
--- a/.github/workflows/linux_release_fetchcontent.yml
+++ b/.github/workflows/linux_release_fetchcontent.yml
@@ -20,7 +20,7 @@ jobs:
   build:
     name: github/linux/fetchcontent/fast
     runs-on: ubuntu-latest
-    container: pikaorg/pika-ci-base:14
+    container: pikaorg/pika-ci-base:15
 
     steps:
     - uses: actions/checkout@v3
diff --git a/.github/workflows/linux_sanitizers.yml b/.github/workflows/linux_sanitizers.yml
index 2a04cdfa4e..e5ecb049cf 100644
--- a/.github/workflows/linux_sanitizers.yml
+++ b/.github/workflows/linux_sanitizers.yml
@@ -20,7 +20,7 @@ jobs:
   build:
     name: github/linux/sanitizers/fast
     runs-on: ubuntu-latest
-    container: pikaorg/pika-ci-base:14
+    container: pikaorg/pika-ci-base:15
 
     steps:
     - uses: actions/checkout@v3
diff --git a/.github/workflows/linux_tracy.yml b/.github/workflows/linux_tracy.yml
index 43f9601757..c5150ff45a 100644
--- a/.github/workflows/linux_tracy.yml
+++ b/.github/workflows/linux_tracy.yml
@@ -20,7 +20,7 @@ jobs:
   build:
     name: github/linux/tracy/fast
     runs-on: ubuntu-latest
-    container: pikaorg/pika-ci-base:14
+    container: pikaorg/pika-ci-base:15
 
     steps:
     - name: Check out Tracy

From 107e8e6bd55b4409b0234fd99e7926816b52cc0d Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Wed, 15 Feb 2023 14:53:26 +0100
Subject: [PATCH 4/9] Add is_sender/receiver tag types to conform to newer
 std::execution concepts

---
 libs/pika/async_cuda/include/pika/async_cuda/then_on_host.hpp | 4 ++++
 .../async_cuda/include/pika/async_cuda/then_with_stream.hpp   | 3 +++
 libs/pika/async_mpi/include/pika/async_mpi/transform_mpi.hpp  | 4 ++++
 .../include/pika/execution/algorithms/drop_value.hpp          | 4 ++++
 .../include/pika/execution/algorithms/keep_future.hpp         | 2 ++
 .../include/pika/execution/algorithms/make_future.hpp         | 2 ++
 .../include/pika/execution/algorithms/split_tuple.hpp         | 4 ++++
 .../include/pika/execution/algorithms/when_all_vector.hpp     | 4 ++++
 .../executors/include/pika/executors/std_thread_scheduler.hpp | 2 ++
 .../include/pika/executors/thread_pool_scheduler.hpp          | 2 ++
 .../include/pika/executors/thread_pool_scheduler_bulk.hpp     | 4 ++++
 libs/pika/futures/include/pika/futures/future.hpp             | 2 ++
 12 files changed, 37 insertions(+)

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 2e15abeb0c..b49380497b 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
@@ -39,6 +39,8 @@ namespace pika::cuda::experimental {
         struct then_on_host_receiver_impl<Receiver,
             F>::then_on_host_receiver_type
         {
+            using is_receiver = void;
+
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<F> f;
             cuda_scheduler sched;
@@ -138,6 +140,8 @@ namespace pika::cuda::experimental {
         template <typename Sender, typename F>
         struct then_on_host_sender_impl<Sender, F>::then_on_host_sender_type
         {
+            using is_sender = void;
+
             std::decay_t<Sender> sender;
             std::decay_t<F> f;
             cuda_scheduler sched;
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 dc01576b49..4c266ca407 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
@@ -149,6 +149,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
     struct then_with_cuda_stream_sender_impl<Sender,
         F>::then_with_cuda_stream_sender_type
     {
+        using is_sender = void;
+
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Sender> sender;
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<F> f;
         cuda_scheduler sched;
@@ -246,6 +248,7 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 
             struct then_with_cuda_stream_receiver
             {
+                using is_receiver = void;
                 using then_with_cuda_stream_receiver_tag = void;
 
                 operation_state& op_state;
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 92fe3c6797..e988bb1e69 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
@@ -99,6 +99,8 @@ namespace pika::mpi::experimental {
         template <typename Sender, typename F>
         struct transform_mpi_sender_impl<Sender, F>::transform_mpi_sender_type
         {
+            using is_sender = void;
+
             std::decay_t<Sender> sender;
             std::decay_t<F> f;
             stream_type stream;
@@ -162,6 +164,8 @@ namespace pika::mpi::experimental {
 
                 struct transform_mpi_receiver
                 {
+                    using is_receiver = void;
+
                     operation_state& op_state;
 
                     template <typename Error>
diff --git a/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp b/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
index 34a1aacde7..9b31f0e255 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
@@ -34,6 +34,8 @@ namespace pika::drop_value_detail {
     template <typename Receiver>
     struct drop_value_receiver_impl<Receiver>::drop_value_receiver_type
     {
+        using is_receiver = void;
+
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
 
         template <typename Error>
@@ -78,6 +80,8 @@ namespace pika::drop_value_detail {
     template <typename Sender>
     struct drop_value_sender_impl<Sender>::drop_value_sender_type
     {
+        using is_sender = void;
+
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Sender> sender;
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
diff --git a/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp b/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp
index b44c7feb48..5c93152d6a 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp
@@ -62,6 +62,8 @@ namespace pika::keep_future_detail {
     template <typename Future>
     struct keep_future_sender_base
     {
+        using is_sender = void;
+
         std::decay_t<Future> future;
 
         template <template <typename...> class Tuple,
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 66a9fdc060..7346e2dee1 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
@@ -58,6 +58,8 @@ namespace pika::make_future_detail {
     template <typename T, typename Allocator>
     struct make_future_receiver
     {
+        using is_receiver = void;
+
         pika::intrusive_ptr<
             resettable_operation_state_future_data<T, Allocator>>
             data;
diff --git a/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp b/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
index c4df86c0e9..91855dd935 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
@@ -119,6 +119,8 @@ namespace pika::split_tuple_detail {
 
         struct split_tuple_receiver
         {
+            using is_receiver = void;
+
             shared_state& state;
 
             template <typename Error>
@@ -403,6 +405,8 @@ namespace pika::split_tuple_detail {
     struct split_tuple_sender_impl<Sender, Allocator,
         Index>::split_tuple_sender_type
     {
+        using is_sender = void;
+
         using allocator_type = Allocator;
         using shared_state_type = shared_state<Sender, Allocator>;
 
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 f8dec282f7..ab2847aa53 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
@@ -47,6 +47,8 @@ namespace pika::when_all_vector_detail {
     template <typename Sender>
     struct when_all_vector_sender_impl<Sender>::when_all_vector_sender_type
     {
+        using is_sender = void;
+
         using senders_type = std::vector<Sender>;
         senders_type senders;
 
@@ -153,6 +155,8 @@ namespace pika::when_all_vector_detail {
         {
             struct when_all_vector_receiver
             {
+                using is_receiver = void;
+
                 operation_state& op_state;
                 std::size_t const i;
 
diff --git a/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp b/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
index 19c49fea46..792e022b6c 100644
--- a/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
@@ -76,6 +76,8 @@ namespace pika::execution::experimental {
 
         struct sender
         {
+            using is_sender = void;
+
             template <template <typename...> class Tuple,
                 template <typename...> class Variant>
             using value_types = Variant<Tuple<>>;
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
index 9bd8d3d566..de125d376e 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
@@ -197,6 +197,8 @@ namespace pika::execution::experimental {
         template <typename Scheduler>
         struct sender
         {
+            using is_sender = void;
+
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
 
             // We explicitly get the fallback annotation when constructing the
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
index f5286e39a1..80905010ed 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
@@ -85,6 +85,8 @@ namespace pika::thread_pool_bulk_detail {
             thread_pool_bulk_sender const&) = default;
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
+        using is_sender = void;
+
         template <template <typename...> class Tuple,
             template <typename...> class Variant>
         using value_types =
@@ -127,6 +129,8 @@ namespace pika::thread_pool_bulk_detail {
         {
             struct bulk_receiver
             {
+                using is_receiver = void;
+
                 operation_state* op_state;
 
                 template <typename E>
diff --git a/libs/pika/futures/include/pika/futures/future.hpp b/libs/pika/futures/include/pika/futures/future.hpp
index 41cf3d5794..c36ee425ec 100644
--- a/libs/pika/futures/include/pika/futures/future.hpp
+++ b/libs/pika/futures/include/pika/futures/future.hpp
@@ -334,6 +334,8 @@ namespace pika::lcos::detail {
     class future_base
     {
     public:
+        using is_sender = void;
+
         using result_type = R;
         using shared_state_type =
             future_data_base<traits::detail::shared_state_ptr_result_t<R>>;

From 11533428ff3065461c19f4c753c4f8804d61328f Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Wed, 15 Feb 2023 14:55:33 +0100
Subject: [PATCH 5/9] Udpate stdexec commit in Jenkins CI configurations

---
 .jenkins/cscs-ault/env-hipcc.sh    | 2 +-
 .jenkins/cscs/env-clang-13.sh      | 2 +-
 .jenkins/cscs/env-clang-14-cuda.sh | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.jenkins/cscs-ault/env-hipcc.sh b/.jenkins/cscs-ault/env-hipcc.sh
index 3a95f02a32..5cdc4e5e16 100644
--- a/.jenkins/cscs-ault/env-hipcc.sh
+++ b/.jenkins/cscs-ault/env-hipcc.sh
@@ -12,7 +12,7 @@ hip_version="5.3.3"
 hwloc_version="2.6.0"
 spack_compiler="gcc@${gcc_version}"
 spack_arch="linux-centos8-zen"
-stdexec_version="c0fe16f451137b00ceb85d912ec3a288990ce766"
+stdexec_version="6510f5bd69cc03b24668f26eda3dd3cca7e81bb2"
 
 # The xnack- architectures are not supported by rocblas@5.3.3
 spack_spec="pika@main+rocm+p2300 amdgpu_target='gfx906:xnack-' arch=${spack_arch} %${spack_compiler} malloc=system cxxstd=${cxx_std} ^boost@${boost_version} ^hwloc@${hwloc_version} ^hip@${hip_version} ^whip amdgpu_target='gfx906:xnack-' ^stdexec@${stdexec_version}"
diff --git a/.jenkins/cscs/env-clang-13.sh b/.jenkins/cscs/env-clang-13.sh
index d46dac2eca..a0053f539a 100644
--- a/.jenkins/cscs/env-clang-13.sh
+++ b/.jenkins/cscs/env-clang-13.sh
@@ -10,7 +10,7 @@ boost_version="1.79.0"
 hwloc_version="2.6.0"
 spack_compiler="clang@${clang_version}"
 spack_arch="cray-cnl7-broadwell"
-stdexec_version="c0fe16f451137b00ceb85d912ec3a288990ce766"
+stdexec_version="6510f5bd69cc03b24668f26eda3dd3cca7e81bb2"
 
 spack_spec="pika@main arch=${spack_arch} %${spack_compiler} cxxflags=-stdlib=libc++ malloc=system cxxstd=${cxx_std} +p2300 ^boost@${boost_version} ^hwloc@${hwloc_version} ^fmt cxxflags=-stdlib=libc++ ^stdexec@${stdexec_version}"
 
diff --git a/.jenkins/cscs/env-clang-14-cuda.sh b/.jenkins/cscs/env-clang-14-cuda.sh
index b7f8db6fad..b945872b23 100644
--- a/.jenkins/cscs/env-clang-14-cuda.sh
+++ b/.jenkins/cscs/env-clang-14-cuda.sh
@@ -11,7 +11,7 @@ hwloc_version="2.7.0"
 cuda_version="11.5.0"
 spack_compiler="clang@${clang_version}"
 spack_arch="cray-cnl7-haswell"
-stdexec_version="c0fe16f451137b00ceb85d912ec3a288990ce766"
+stdexec_version="6510f5bd69cc03b24668f26eda3dd3cca7e81bb2"
 
 spack_spec="pika@main arch=${spack_arch} %${spack_compiler} +cuda malloc=system cxxstd=${cxx_std} +p2300 ^boost@${boost_version} ^cuda@${cuda_version} +allow-unsupported-compilers ^hwloc@${hwloc_version} ^stdexec@${stdexec_version}"
 

From a3bd517f50d8e0bc70e3c09a43e5a5be0e800097 Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Wed, 15 Feb 2023 14:55:45 +0100
Subject: [PATCH 6/9] Update stdexec commit in README

---
 README.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.rst b/README.rst
index 8d03ecdd8b..42f1d17748 100644
--- a/README.rst
+++ b/README.rst
@@ -49,8 +49,8 @@ pika optionally requires:
 * `Boost.Context, Thread, and Chrono <https://boost.org>`_ on macOS
 * `stdexec <https://github.com/NVIDIA/stdexec>`_ when
   ``PIKA_WITH_P2300_REFERENCE_IMPLEMENTATION`` is enabled (currently tested with commit
-  `c0fe16f451137b00ceb85d912ec3a288990ce766
-  <https://github.com/NVIDIA/stdexec/commit/c0fe16f451137b00ceb85d912ec3a288990ce766>`).
+  `6510f5bd69cc03b24668f26eda3dd3cca7e81bb2
+  <https://github.com/NVIDIA/stdexec/commit/6510f5bd69cc03b24668f26eda3dd3cca7e81bb2>`).
   The integration is experimental.
 
 

From 97e77c8fc364837590e333601949bab67f6f200e Mon Sep 17 00:00:00 2001
From: Mikael Simberg <simberg@cscs.ch>
Date: Fri, 17 Feb 2023 13:13:35 +0100
Subject: [PATCH 7/9] Reformat files

---
 .../pika/async_cuda/cuda_scheduler.hpp        |  53 +-
 .../include/pika/async_cuda/then_on_host.hpp  | 127 ++---
 .../pika/async_cuda/then_with_stream.hpp      | 330 +++++-------
 .../async_cuda/tests/unit/cuda_scheduler.cu   |  52 +-
 .../async_cuda/tests/unit/then_with_stream.cu | 189 +++----
 .../include/pika/async_mpi/transform_mpi.hpp  | 198 +++----
 .../pika/execution/algorithms/bulk.hpp        | 116 ++---
 .../pika/execution/algorithms/drop_value.hpp  |  46 +-
 .../pika/execution/algorithms/keep_future.hpp |  51 +-
 .../pika/execution/algorithms/make_future.hpp | 128 ++---
 .../execution/algorithms/schedule_from.hpp    | 193 +++----
 .../pika/execution/algorithms/split_tuple.hpp | 263 ++++------
 .../pika/execution/algorithms/sync_wait.hpp   |  99 ++--
 .../pika/execution/algorithms/then.hpp        | 116 ++---
 .../pika/execution/algorithms/transfer.hpp    |  34 +-
 .../execution/algorithms/when_all_vector.hpp  | 131 ++---
 .../tests/include/algorithm_test_utils.hpp    | 268 ++++------
 .../execution/tests/unit/algorithm_bulk.cpp   |  47 +-
 .../tests/unit/algorithm_execute.cpp          |  26 +-
 .../execution/tests/unit/algorithm_split.cpp  |   9 +-
 .../tests/unit/algorithm_transfer.cpp         | 149 +++---
 .../pika/execution_base/any_sender.hpp        | 235 ++++-----
 .../execution_base/completion_scheduler.hpp   |  57 +--
 .../include/pika/execution_base/receiver.hpp  |  25 +-
 .../include/pika/execution_base/sender.hpp    |  90 ++--
 .../execution_base/tests/unit/any_sender.cpp  | 153 +++---
 .../tests/unit/basic_receiver.cpp             |  66 +--
 .../tests/unit/basic_schedule.cpp             |  28 +-
 .../tests/unit/basic_sender.cpp               | 128 ++---
 .../pika/executors/std_thread_scheduler.hpp   |  21 +-
 .../pika/executors/thread_pool_scheduler.hpp  | 120 ++---
 .../executors/thread_pool_scheduler_bulk.hpp  | 229 ++++-----
 .../tests/unit/std_thread_scheduler.cpp       | 302 +++++------
 .../tests/unit/thread_pool_scheduler.cpp      | 482 +++++++-----------
 .../futures/include/pika/futures/future.hpp   | 337 +++++-------
 35 files changed, 1919 insertions(+), 2979 deletions(-)

diff --git a/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp b/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp
index 978ae80383..cfae379262 100644
--- a/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp
+++ b/libs/pika/async_cuda/include/pika/async_cuda/cuda_scheduler.hpp
@@ -42,23 +42,19 @@ namespace pika::cuda::experimental {
         PIKA_EXPORT cuda_stream const& get_next_stream();
 
         /// \cond NOINTERNAL
-        friend bool operator==(
-            cuda_scheduler const& lhs, cuda_scheduler const& rhs)
+        friend bool operator==(cuda_scheduler const& lhs, cuda_scheduler const& rhs)
         {
             return lhs.pool == rhs.pool;
         }
 
-        friend bool operator!=(
-            cuda_scheduler const& lhs, cuda_scheduler const& rhs)
+        friend bool operator!=(cuda_scheduler const& lhs, cuda_scheduler const& rhs)
         {
             return !(lhs == rhs);
         }
         /// \endcond
 
-        friend cuda_scheduler tag_invoke(
-            pika::execution::experimental::with_priority_t,
-            cuda_scheduler const& scheduler,
-            pika::execution::thread_priority priority)
+        friend cuda_scheduler tag_invoke(pika::execution::experimental::with_priority_t,
+            cuda_scheduler const& scheduler, pika::execution::thread_priority priority)
         {
             auto sched_with_priority = scheduler;
             sched_with_priority.priority = priority;
@@ -66,8 +62,7 @@ namespace pika::cuda::experimental {
         }
 
         friend pika::execution::thread_priority tag_invoke(
-            pika::execution::experimental::get_priority_t,
-            cuda_scheduler const& scheduler)
+            pika::execution::experimental::get_priority_t, cuda_scheduler const& scheduler)
         {
             return scheduler.priority;
         }
@@ -97,33 +92,28 @@ namespace pika::cuda::experimental {
                 operation_state& operator=(operation_state&&) = delete;
                 operation_state& operator=(operation_state const&) = delete;
 
-                friend void tag_invoke(pika::execution::experimental::start_t,
-                    operation_state& os) noexcept
+                friend void tag_invoke(
+                    pika::execution::experimental::start_t, operation_state& os) noexcept
                 {
                     // This currently only acts as an inline scheduler to signal
                     // downstream senders that they should use the
                     // cuda_scheduler.
-                    pika::execution::experimental::set_value(
-                        PIKA_MOVE(os.receiver));
+                    pika::execution::experimental::set_value(PIKA_MOVE(os.receiver));
                 }
             };
 
         public:
-            PIKA_EXPORT explicit cuda_scheduler_sender(
-                cuda_scheduler scheduler);
+            PIKA_EXPORT explicit cuda_scheduler_sender(cuda_scheduler scheduler);
             cuda_scheduler_sender(cuda_scheduler_sender&&) = default;
             cuda_scheduler_sender& operator=(cuda_scheduler_sender&&) = default;
             cuda_scheduler_sender(cuda_scheduler_sender const&) = delete;
-            cuda_scheduler_sender& operator=(
-                cuda_scheduler_sender const&) = delete;
+            cuda_scheduler_sender& operator=(cuda_scheduler_sender const&) = delete;
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-            using completion_signatures =
-                pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_value_t()>;
+            using completion_signatures = pika::execution::experimental::completion_signatures<
+                pika::execution::experimental::set_value_t()>;
 #else
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
+            template <template <typename...> class Tuple, template <typename...> class Variant>
             using value_types = Variant<Tuple<>>;
 
             template <template <typename...> class Variant>
@@ -133,17 +123,14 @@ namespace pika::cuda::experimental {
 #endif
 
             template <typename Receiver>
-            friend operation_state<Receiver>
-            tag_invoke(pika::execution::experimental::connect_t,
+            friend operation_state<Receiver> tag_invoke(pika::execution::experimental::connect_t,
                 cuda_scheduler_sender&& s, Receiver&& receiver)
             {
-                return {
-                    PIKA_MOVE(s.scheduler), PIKA_FORWARD(Receiver, receiver)};
+                return {PIKA_MOVE(s.scheduler), PIKA_FORWARD(Receiver, receiver)};
             }
 
             template <typename Receiver>
-            friend operation_state<Receiver>
-            tag_invoke(pika::execution::experimental::connect_t,
+            friend operation_state<Receiver> tag_invoke(pika::execution::experimental::connect_t,
                 cuda_scheduler_sender const& s, Receiver&& receiver)
             {
                 return {s.scheduler, PIKA_FORWARD(Receiver, receiver)};
@@ -162,8 +149,8 @@ namespace pika::cuda::experimental {
                 }
             };
 
-            friend env tag_invoke(pika::execution::experimental::get_env_t,
-                cuda_scheduler_sender const& s)
+            friend env tag_invoke(
+                pika::execution::experimental::get_env_t, cuda_scheduler_sender const& s)
             {
                 return {s.scheduler};
             }
@@ -171,8 +158,8 @@ namespace pika::cuda::experimental {
     }    // namespace detail
 
     /// Schedule subsequent work for execution on a CUDA device.
-    inline auto tag_invoke(pika::execution::experimental::schedule_t,
-        cuda_scheduler scheduler) noexcept
+    inline auto tag_invoke(
+        pika::execution::experimental::schedule_t, cuda_scheduler scheduler) noexcept
     {
         return detail::cuda_scheduler_sender{PIKA_MOVE(scheduler)};
     }
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 b49380497b..74275ebbec 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
@@ -32,12 +32,10 @@ namespace pika::cuda::experimental {
 
         template <typename Receiver, typename F>
         using then_on_host_receiver =
-            typename then_on_host_receiver_impl<Receiver,
-                F>::then_on_host_receiver_type;
+            typename then_on_host_receiver_impl<Receiver, F>::then_on_host_receiver_type;
 
         template <typename Receiver, typename F>
-        struct then_on_host_receiver_impl<Receiver,
-            F>::then_on_host_receiver_type
+        struct then_on_host_receiver_impl<Receiver, F>::then_on_host_receiver_type
         {
             using is_receiver = void;
 
@@ -46,8 +44,7 @@ namespace pika::cuda::experimental {
             cuda_scheduler sched;
 
             template <typename Receiver_, typename F_>
-            then_on_host_receiver_type(
-                Receiver_&& receiver, F_&& f, cuda_scheduler sched)
+            then_on_host_receiver_type(Receiver_&& receiver, F_&& f, cuda_scheduler sched)
               : receiver(PIKA_FORWARD(Receiver_, receiver))
               , f(PIKA_FORWARD(F_, f))
               , sched(PIKA_MOVE(sched))
@@ -55,12 +52,9 @@ namespace pika::cuda::experimental {
             }
 
             then_on_host_receiver_type(then_on_host_receiver_type&&) = default;
-            then_on_host_receiver_type& operator=(
-                then_on_host_receiver_type&&) = default;
-            then_on_host_receiver_type(
-                then_on_host_receiver_type const&) = delete;
-            then_on_host_receiver_type& operator=(
-                then_on_host_receiver_type const&) = delete;
+            then_on_host_receiver_type& operator=(then_on_host_receiver_type&&) = default;
+            then_on_host_receiver_type(then_on_host_receiver_type const&) = delete;
+            then_on_host_receiver_type& operator=(then_on_host_receiver_type const&) = delete;
 
             template <typename Error>
             friend void tag_invoke(pika::execution::experimental::set_error_t,
@@ -73,8 +67,7 @@ namespace pika::cuda::experimental {
             friend void tag_invoke(pika::execution::experimental::set_stopped_t,
                 then_on_host_receiver_type&& r) noexcept
             {
-                pika::execution::experimental::set_stopped(
-                    PIKA_MOVE(r.receiver));
+                pika::execution::experimental::set_stopped(PIKA_MOVE(r.receiver));
             }
 
             template <typename... Ts>
@@ -83,31 +76,25 @@ namespace pika::cuda::experimental {
             {
                 pika::detail::try_catch_exception_ptr(
                     [&]() {
-                        if constexpr (std::is_void_v<
-                                          std::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.
 #if defined(PIKA_GCC_VERSION) && (PIKA_GCC_VERSION < 100000)
-                            PIKA_INVOKE(
-                                std::move(r.f), PIKA_FORWARD(Ts, ts)...);
+                            PIKA_INVOKE(std::move(r.f), PIKA_FORWARD(Ts, ts)...);
 #else
-                            PIKA_INVOKE(
-                                PIKA_MOVE(r.f), PIKA_FORWARD(Ts, ts)...);
+                            PIKA_INVOKE(PIKA_MOVE(r.f), PIKA_FORWARD(Ts, ts)...);
 #endif
-                            pika::execution::experimental::set_value(
-                                PIKA_MOVE(r.receiver));
+                            pika::execution::experimental::set_value(PIKA_MOVE(r.receiver));
                         }
                         else
                         {
                         // Certain versions of GCC with optimizations fail on
                         // the move with an internal compiler error.
 #if defined(PIKA_GCC_VERSION) && (PIKA_GCC_VERSION < 100000)
-                            auto&& result = PIKA_INVOKE(
-                                std::move(r.f), PIKA_FORWARD(Ts, ts)...);
+                            auto&& result = PIKA_INVOKE(std::move(r.f), PIKA_FORWARD(Ts, ts)...);
 #else
-                            auto&& result = PIKA_INVOKE(
-                                PIKA_MOVE(r.f), PIKA_FORWARD(Ts, ts)...);
+                            auto&& result = PIKA_INVOKE(PIKA_MOVE(r.f), PIKA_FORWARD(Ts, ts)...);
 #endif
                             pika::execution::experimental::set_value(
                                 PIKA_MOVE(r.receiver), PIKA_MOVE(result));
@@ -119,8 +106,8 @@ namespace pika::cuda::experimental {
                     });
             }
 
-            friend constexpr pika::execution::experimental::empty_env
-            tag_invoke(pika::execution::experimental::get_env_t,
+            friend constexpr pika::execution::experimental::empty_env tag_invoke(
+                pika::execution::experimental::get_env_t,
                 then_on_host_receiver_type const&) noexcept
             {
                 return {};
@@ -134,8 +121,8 @@ namespace pika::cuda::experimental {
         };
 
         template <typename Sender, typename F>
-        using then_on_host_sender = typename then_on_host_sender_impl<Sender,
-            F>::then_on_host_sender_type;
+        using then_on_host_sender =
+            typename then_on_host_sender_impl<Sender, F>::then_on_host_sender_type;
 
         template <typename Sender, typename F>
         struct then_on_host_sender_impl<Sender, F>::then_on_host_sender_type
@@ -147,8 +134,7 @@ namespace pika::cuda::experimental {
             cuda_scheduler sched;
 
             template <typename Sender_, typename F_>
-            then_on_host_sender_type(
-                Sender_&& sender, F_&& f, cuda_scheduler sched)
+            then_on_host_sender_type(Sender_&& sender, F_&& f, cuda_scheduler sched)
               : sender(PIKA_FORWARD(Sender_, sender))
               , f(PIKA_FORWARD(F_, f))
               , sched(PIKA_MOVE(sched))
@@ -156,27 +142,22 @@ namespace pika::cuda::experimental {
             }
 
             then_on_host_sender_type(then_on_host_sender_type&&) = default;
-            then_on_host_sender_type& operator=(
-                then_on_host_sender_type&&) = default;
+            then_on_host_sender_type& operator=(then_on_host_sender_type&&) = default;
             then_on_host_sender_type(then_on_host_sender_type const&) = default;
-            then_on_host_sender_type& operator=(
-                then_on_host_sender_type const&) = default;
+            then_on_host_sender_type& operator=(then_on_host_sender_type const&) = default;
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
             template <typename... Ts>
             requires std::is_invocable_v<F, Ts...>
             using invoke_result_helper =
-                pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::detail::
-                        result_type_signature_helper_t<
-                            std::invoke_result_t<F, Ts...>>>;
+                pika::execution::experimental::completion_signatures<pika::execution::experimental::
+                        detail::result_type_signature_helper_t<std::invoke_result_t<F, Ts...>>>;
 
             using completion_signatures =
-                pika::execution::experimental::make_completion_signatures<
-                    Sender, pika::execution::experimental::empty_env,
+                pika::execution::experimental::make_completion_signatures<Sender,
+                    pika::execution::experimental::empty_env,
                     pika::execution::experimental::completion_signatures<
-                        pika::execution::experimental::set_error_t(
-                            std::exception_ptr)>,
+                        pika::execution::experimental::set_error_t(std::exception_ptr)>,
                     invoke_result_helper>;
 #else
             template <typename Tuple>
@@ -186,24 +167,20 @@ namespace pika::cuda::experimental {
             struct invoke_result_helper<Tuple<Ts...>>
             {
                 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;
+                using type = typename std::conditional<std::is_void<result_type>::value, Tuple<>,
+                    Tuple<result_type>>::type;
             };
 
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
-            using value_types =
-                pika::util::detail::unique_t<pika::util::detail::transform_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template value_types<Tuple, Variant>,
-                    invoke_result_helper>>;
+            template <template <typename...> class Tuple, template <typename...> class Variant>
+            using value_types = pika::util::detail::unique_t<pika::util::detail::transform_t<
+                typename pika::execution::experimental::sender_traits<Sender>::template value_types<
+                    Tuple, Variant>,
+                invoke_result_helper>>;
 
             template <template <typename...> class Variant>
-            using error_types =
-                pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template error_types<Variant>,
+            using error_types = pika::util::detail::unique_t<
+                pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                                  Sender>::template error_types<Variant>,
                     std::exception_ptr>>;
 
             static constexpr bool sends_done = false;
@@ -213,11 +190,9 @@ namespace pika::cuda::experimental {
             friend auto tag_invoke(pika::execution::experimental::connect_t,
                 then_on_host_sender_type&& s, Receiver&& receiver)
             {
-                return pika::execution::experimental::connect(
-                    PIKA_MOVE(s.sender),
+                return pika::execution::experimental::connect(PIKA_MOVE(s.sender),
                     then_on_host_receiver<Receiver, F>{
-                        PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f),
-                        PIKA_MOVE(s.sched)});
+                        PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f), PIKA_MOVE(s.sched)});
             }
 
             template <typename Receiver>
@@ -229,8 +204,8 @@ namespace pika::cuda::experimental {
                         PIKA_FORWARD(Receiver, receiver), s.f, s.sched});
             }
 
-            friend auto tag_invoke(pika::execution::experimental::get_env_t,
-                then_on_host_sender_type const& s)
+            friend auto tag_invoke(
+                pika::execution::experimental::get_env_t, then_on_host_sender_type const& s)
             {
                 return pika::execution::experimental::get_env(s.sender);
             }
@@ -251,30 +226,24 @@ namespace pika::cuda::experimental {
     {
     private:
         template <typename Sender, typename F>
-        friend PIKA_FORCEINLINE auto
-        tag_fallback_invoke(then_on_host_t, Sender&& sender, F&& f)
+        friend PIKA_FORCEINLINE auto tag_fallback_invoke(then_on_host_t, Sender&& sender, F&& f)
         {
-            auto completion_sched =
-                pika::execution::experimental::get_completion_scheduler<
-                    pika::execution::experimental::set_value_t>(
-                    pika::execution::experimental::get_env(sender));
-            static_assert(
-                std::is_same_v<std::decay_t<decltype(completion_sched)>,
-                    cuda_scheduler>,
+            auto completion_sched = pika::execution::experimental::get_completion_scheduler<
+                pika::execution::experimental::set_value_t>(
+                pika::execution::experimental::get_env(sender));
+            static_assert(std::is_same_v<std::decay_t<decltype(completion_sched)>, cuda_scheduler>,
                 "then_on_host can only be used with senders whose "
                 "completion scheduler is cuda_scheduler");
 
             return then_on_host_detail::then_on_host_sender<Sender, F>{
-                PIKA_FORWARD(Sender, sender), PIKA_FORWARD(F, f),
-                std::move(completion_sched)};
+                PIKA_FORWARD(Sender, sender), PIKA_FORWARD(F, f), std::move(completion_sched)};
         }
 
         template <typename F>
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(then_on_host_t, F&& f)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(then_on_host_t, F&& f)
         {
-            return pika::execution::experimental::detail::partial_algorithm<
-                then_on_host_t, F>{PIKA_FORWARD(F, f)};
+            return pika::execution::experimental::detail::partial_algorithm<then_on_host_t, F>{
+                PIKA_FORWARD(F, f)};
         }
     } then_on_host{};
 }    // namespace pika::cuda::experimental
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 4c266ca407..83a8e0e01a 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
@@ -36,37 +36,33 @@
 #include <utility>
 
 namespace pika::cuda::experimental::then_with_stream_detail {
-    PIKA_EXPORT pika::cuda::experimental::cublas_handle const&
-    get_thread_local_cublas_handle(
+    PIKA_EXPORT pika::cuda::experimental::cublas_handle const& get_thread_local_cublas_handle(
         cuda_stream const& stream, cublasPointerMode_t pointer_mode);
 
     template <typename F, typename... Ts>
-    auto invoke_with_thread_local_cublas_handle(cuda_stream const& stream,
-        cublasPointerMode_t pointer_mode, F&& f, Ts&&... ts)
-        -> decltype(PIKA_INVOKE(PIKA_FORWARD(F, f),
-            std::declval<cublasHandle_t>(), PIKA_FORWARD(Ts, ts)...))
+    auto invoke_with_thread_local_cublas_handle(
+        cuda_stream const& stream, cublasPointerMode_t pointer_mode, F&& f, Ts&&... ts)
+        -> decltype(PIKA_INVOKE(
+            PIKA_FORWARD(F, f), std::declval<cublasHandle_t>(), PIKA_FORWARD(Ts, ts)...))
     {
         return PIKA_INVOKE(PIKA_FORWARD(F, f),
-            get_thread_local_cublas_handle(stream, pointer_mode).get(),
-            PIKA_FORWARD(Ts, ts)...);
+            get_thread_local_cublas_handle(stream, pointer_mode).get(), PIKA_FORWARD(Ts, ts)...);
     }
 
-    PIKA_EXPORT pika::cuda::experimental::cusolver_handle const&
-    get_thread_local_cusolver_handle(cuda_stream const& stream);
+    PIKA_EXPORT pika::cuda::experimental::cusolver_handle const& get_thread_local_cusolver_handle(
+        cuda_stream const& stream);
 
     template <typename F, typename... Ts>
-    auto invoke_with_thread_local_cusolver_handle(cuda_stream const& stream,
-        F&& f, Ts&&... ts) -> decltype(PIKA_INVOKE(PIKA_FORWARD(F, f),
-        std::declval<cusolverDnHandle_t>(), PIKA_FORWARD(Ts, ts)...))
+    auto invoke_with_thread_local_cusolver_handle(cuda_stream const& stream, F&& f, Ts&&... ts)
+        -> decltype(PIKA_INVOKE(
+            PIKA_FORWARD(F, f), std::declval<cusolverDnHandle_t>(), PIKA_FORWARD(Ts, ts)...))
     {
-        return PIKA_INVOKE(PIKA_FORWARD(F, f),
-            get_thread_local_cusolver_handle(stream).get(),
+        return PIKA_INVOKE(PIKA_FORWARD(F, f), get_thread_local_cusolver_handle(stream).get(),
             PIKA_FORWARD(Ts, ts)...);
     }
 
     template <typename R, typename... Ts>
-    void
-    set_value_event_callback_helper(whip::error_t status, R&& r, Ts&&... ts)
+    void set_value_event_callback_helper(whip::error_t status, R&& r, Ts&&... ts)
     {
         static_assert(sizeof...(Ts) <= 1, "Expecting at most one value");
 
@@ -74,25 +70,22 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 
         if (status == whip::success)
         {
-            pika::execution::experimental::set_value(
-                PIKA_FORWARD(R, r), PIKA_FORWARD(Ts, ts)...);
+            pika::execution::experimental::set_value(PIKA_FORWARD(R, r), PIKA_FORWARD(Ts, ts)...);
         }
         else
         {
             pika::execution::experimental::set_error(PIKA_FORWARD(R, r),
-                std::make_exception_ptr(
-                    pika::exception(pika::error::unknown_error,
-                        fmt::format("Getting event after CUDA stream transform "
-                                    "failed with status {} ({})",
-                            status, whip::get_error_string(status)))));
+                std::make_exception_ptr(pika::exception(pika::error::unknown_error,
+                    fmt::format("Getting event after CUDA stream transform "
+                                "failed with status {} ({})",
+                        status, whip::get_error_string(status)))));
         }
     }
 
     template <typename OperationState>
     void set_value_immediate_void(OperationState& op_state)
     {
-        PIKA_ASSERT(pika::detail::holds_alternative<pika::detail::monostate>(
-            op_state.result));
+        PIKA_ASSERT(pika::detail::holds_alternative<pika::detail::monostate>(op_state.result));
         pika::execution::experimental::set_value(PIKA_MOVE(op_state.receiver));
     }
 
@@ -100,8 +93,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
     void set_value_immediate_non_void(OperationState& op_state)
     {
         PIKA_ASSERT(pika::detail::holds_alternative<Result>(op_state.result));
-        pika::execution::experimental::set_value(PIKA_MOVE(op_state.receiver),
-            PIKA_MOVE(pika::detail::get<Result>(op_state.result)));
+        pika::execution::experimental::set_value(
+            PIKA_MOVE(op_state.receiver), PIKA_MOVE(pika::detail::get<Result>(op_state.result)));
     }
 
     template <typename OperationState>
@@ -110,11 +103,9 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         detail::add_event_callback(
             [&op_state](whip::error_t status) mutable {
                 PIKA_ASSERT(
-                    pika::detail::holds_alternative<pika::detail::monostate>(
-                        op_state.result));
+                    pika::detail::holds_alternative<pika::detail::monostate>(op_state.result));
                 op_state.ts = {};
-                set_value_event_callback_helper(
-                    status, PIKA_MOVE(op_state.receiver));
+                set_value_event_callback_helper(status, PIKA_MOVE(op_state.receiver));
             },
             op_state.stream.value().get());
     }
@@ -124,11 +115,9 @@ namespace pika::cuda::experimental::then_with_stream_detail {
     {
         detail::add_event_callback(
             [&op_state](whip::error_t status) mutable {
-                PIKA_ASSERT(
-                    pika::detail::holds_alternative<Result>(op_state.result));
+                PIKA_ASSERT(pika::detail::holds_alternative<Result>(op_state.result));
                 op_state.ts = {};
-                set_value_event_callback_helper(status,
-                    PIKA_MOVE(op_state.receiver),
+                set_value_event_callback_helper(status, PIKA_MOVE(op_state.receiver),
                     PIKA_MOVE(pika::detail::get<Result>(op_state.result)));
             },
             op_state.stream.value().get());
@@ -142,12 +131,10 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 
     template <typename Sender, typename F>
     using then_with_cuda_stream_sender =
-        typename then_with_cuda_stream_sender_impl<Sender,
-            F>::then_with_cuda_stream_sender_type;
+        typename then_with_cuda_stream_sender_impl<Sender, F>::then_with_cuda_stream_sender_type;
 
     template <typename Sender, typename F>
-    struct then_with_cuda_stream_sender_impl<Sender,
-        F>::then_with_cuda_stream_sender_type
+    struct then_with_cuda_stream_sender_impl<Sender, F>::then_with_cuda_stream_sender_type
     {
         using is_sender = void;
 
@@ -156,20 +143,16 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         cuda_scheduler sched;
 
         template <typename Sender_, typename F_>
-        then_with_cuda_stream_sender_type(
-            Sender_&& sender, F_&& f, cuda_scheduler sched)
+        then_with_cuda_stream_sender_type(Sender_&& sender, F_&& f, cuda_scheduler sched)
           : sender(PIKA_FORWARD(Sender_, sender))
           , f(PIKA_FORWARD(F_, f))
           , sched(PIKA_MOVE(sched))
         {
         }
 
-        then_with_cuda_stream_sender_type(
-            then_with_cuda_stream_sender_type&&) = default;
-        then_with_cuda_stream_sender_type& operator=(
-            then_with_cuda_stream_sender_type&&) = default;
-        then_with_cuda_stream_sender_type(
-            then_with_cuda_stream_sender_type const&) = default;
+        then_with_cuda_stream_sender_type(then_with_cuda_stream_sender_type&&) = default;
+        then_with_cuda_stream_sender_type& operator=(then_with_cuda_stream_sender_type&&) = default;
+        then_with_cuda_stream_sender_type(then_with_cuda_stream_sender_type const&) = default;
         then_with_cuda_stream_sender_type& operator=(
             then_with_cuda_stream_sender_type const&) = default;
 
@@ -178,18 +161,15 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         requires std::is_invocable_v<F, cuda_stream const&,
             std::add_lvalue_reference_t<std::decay_t<Ts>>...>
         using invoke_result_helper =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::detail::
-                    result_type_signature_helper_t<
-                        std::invoke_result_t<F, cuda_stream const&,
-                            std::add_lvalue_reference_t<std::decay_t<Ts>>...>>>;
+            pika::execution::experimental::completion_signatures<pika::execution::experimental::
+                    detail::result_type_signature_helper_t<std::invoke_result_t<F,
+                        cuda_stream const&, std::add_lvalue_reference_t<std::decay_t<Ts>>...>>>;
 
         using completion_signatures =
-            pika::execution::experimental::make_completion_signatures<
-                std::decay_t<Sender>, pika::execution::experimental::empty_env,
+            pika::execution::experimental::make_completion_signatures<std::decay_t<Sender>,
+                pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_error_t(
-                        std::exception_ptr)>,
+                    pika::execution::experimental::set_error_t(std::exception_ptr)>,
                 invoke_result_helper>;
 #else
         template <typename Tuple>
@@ -200,23 +180,20 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         {
             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>>;
+            using type =
+                std::conditional_t<std::is_void_v<result_type>, Tuple<>, Tuple<result_type>>;
         };
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types =
-            pika::util::detail::unique_t<pika::util::detail::transform_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template value_types<Tuple, Variant>,
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = pika::util::detail::unique_t<
+            pika::util::detail::transform_t<typename pika::execution::experimental::sender_traits<
+                                                Sender>::template value_types<Tuple, Variant>,
                 invoke_result_helper>>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template error_types<Variant>,
+        using error_types = pika::util::detail::unique_t<
+            pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                              Sender>::template error_types<Variant>,
                 std::exception_ptr>>;
 
         static constexpr bool sends_done = false;
@@ -241,8 +218,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 
             template <typename R>
             struct is_then_with_cuda_stream_receiver<R,
-                std::void_t<typename std::decay_t<
-                    R>::then_with_cuda_stream_receiver_tag>> : std::true_type
+                std::void_t<typename std::decay_t<R>::then_with_cuda_stream_receiver_tag>>
+              : std::true_type
             {
             };
 
@@ -253,87 +230,68 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 
                 operation_state& op_state;
 
-                explicit then_with_cuda_stream_receiver(
-                    operation_state& op_state)
+                explicit then_with_cuda_stream_receiver(operation_state& op_state)
                   : op_state(op_state)
                 {
                 }
-                then_with_cuda_stream_receiver(
-                    then_with_cuda_stream_receiver&&) = default;
+                then_with_cuda_stream_receiver(then_with_cuda_stream_receiver&&) = default;
                 then_with_cuda_stream_receiver& operator=(
                     then_with_cuda_stream_receiver&&) = default;
-                then_with_cuda_stream_receiver(
-                    then_with_cuda_stream_receiver const&) = delete;
+                then_with_cuda_stream_receiver(then_with_cuda_stream_receiver const&) = delete;
                 then_with_cuda_stream_receiver& operator=(
                     then_with_cuda_stream_receiver const&) = delete;
 
                 template <typename Error>
-                friend void
-                tag_invoke(pika::execution::experimental::set_error_t,
+                friend void tag_invoke(pika::execution::experimental::set_error_t,
                     then_with_cuda_stream_receiver&& r, Error&& error) noexcept
                 {
                     pika::execution::experimental::set_error(
-                        PIKA_MOVE(r.op_state.receiver),
-                        PIKA_FORWARD(Error, error));
+                        PIKA_MOVE(r.op_state.receiver), PIKA_FORWARD(Error, error));
                 }
 
-                friend void tag_invoke(
-                    pika::execution::experimental::set_stopped_t,
+                friend void tag_invoke(pika::execution::experimental::set_stopped_t,
                     then_with_cuda_stream_receiver&& r) noexcept
                 {
-                    pika::execution::experimental::set_stopped(
-                        PIKA_MOVE(r.op_state.receiver));
+                    pika::execution::experimental::set_stopped(PIKA_MOVE(r.op_state.receiver));
                 }
 
                 template <typename... Ts>
                 auto set_value(Ts&&... ts) noexcept
-                    -> decltype(PIKA_INVOKE(
-                                    PIKA_MOVE(f), stream.value(), ts...),
-                        void())
+                    -> decltype(PIKA_INVOKE(PIKA_MOVE(f), stream.value(), ts...), void())
                 {
                     pika::detail::try_catch_exception_ptr(
                         [&]() mutable {
-                            using ts_element_type =
-                                std::tuple<std::decay_t<Ts>...>;
-                            op_state.ts.template emplace<ts_element_type>(
-                                PIKA_FORWARD(Ts, ts)...);
-                            [[maybe_unused]] auto& t =
-                                std::get<ts_element_type>(op_state.ts);
+                            using ts_element_type = std::tuple<std::decay_t<Ts>...>;
+                            op_state.ts.template emplace<ts_element_type>(PIKA_FORWARD(Ts, ts)...);
+                            [[maybe_unused]] auto& t = std::get<ts_element_type>(op_state.ts);
 
                             if (!op_state.stream)
                             {
-                                op_state.stream.emplace(
-                                    op_state.sched.get_next_stream());
+                                op_state.stream.emplace(op_state.sched.get_next_stream());
                             }
 
                             // If the next receiver is also a
                             // then_with_cuda_stream_receiver and it uses the
                             // same scheduler/pool we set its stream to the same
                             // as for this task.
-                            [[maybe_unused]] bool successor_uses_same_stream =
-                                false;
+                            [[maybe_unused]] bool successor_uses_same_stream = false;
                             if constexpr (is_then_with_cuda_stream_receiver<
                                               std::decay_t<Receiver>>::value)
                             {
-                                if (op_state.sched ==
-                                    op_state.receiver.op_state.sched)
+                                if (op_state.sched == op_state.receiver.op_state.sched)
                                 {
                                     PIKA_ASSERT(op_state.stream);
-                                    PIKA_ASSERT(
-                                        !op_state.receiver.op_state.stream);
-                                    op_state.receiver.op_state.stream =
-                                        op_state.stream;
+                                    PIKA_ASSERT(!op_state.receiver.op_state.stream);
+                                    op_state.receiver.op_state.stream = op_state.stream;
 
                                     successor_uses_same_stream = true;
                                 }
                             }
 
-                            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>;
+                            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)
                             {
                             // nvcc fails to compile the invoke_fused call
@@ -344,25 +302,23 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                             // will not be correctly instantiated, so we
                             // compile a dummy form invoke_fused instead that
                             // should also never be called.
-#if defined(__NVCC__) && defined(PIKA_COMPUTE_DEVICE_CODE) &&                  \
-    defined(PIKA_CUDA_VERSION) && (PIKA_CUDA_VERSION < 1103)
+#if defined(__NVCC__) && defined(PIKA_COMPUTE_DEVICE_CODE) && defined(PIKA_CUDA_VERSION) &&        \
+    (PIKA_CUDA_VERSION < 1103)
                                 PIKA_ASSERT(false);
-                                PIKA_INVOKE(PIKA_MOVE(op_state.f),
-                                    op_state.stream.value(), ts...);
+                                PIKA_INVOKE(PIKA_MOVE(op_state.f), op_state.stream.value(), ts...);
 #else
                                 // When the return type is void, there is no
                                 // value to forward to the receiver
                                 pika::util::detail::invoke_fused(
                                     [&](auto&... ts) mutable {
-                                        PIKA_INVOKE(PIKA_MOVE(op_state.f),
-                                            op_state.stream.value(), ts...);
+                                        PIKA_INVOKE(
+                                            PIKA_MOVE(op_state.f), op_state.stream.value(), ts...);
                                     },
                                     t);
 #endif
 
                                 if constexpr (is_then_with_cuda_stream_receiver<
-                                                  std::decay_t<Receiver>>::
-                                                  value)
+                                                  std::decay_t<Receiver>>::value)
                                 {
                                     if (successor_uses_same_stream)
                                     {
@@ -402,29 +358,25 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                             // will not be correctly instantiated, so we
                             // compile a dummy form invoke_fused instead that
                             // should also never be called.
-#if defined(__NVCC__) && defined(PIKA_COMPUTE_DEVICE_CODE) &&                  \
-    defined(PIKA_CUDA_VERSION) && (PIKA_CUDA_VERSION < 1103)
+#if defined(__NVCC__) && defined(PIKA_COMPUTE_DEVICE_CODE) && defined(PIKA_CUDA_VERSION) &&        \
+    (PIKA_CUDA_VERSION < 1103)
                                 PIKA_ASSERT(false);
-                                op_state.result
-                                    .template emplace<invoke_result_type>(
-                                        PIKA_INVOKE(PIKA_MOVE(op_state.f),
-                                            op_state.stream.value(), ts...));
+                                op_state.result.template emplace<invoke_result_type>(PIKA_INVOKE(
+                                    PIKA_MOVE(op_state.f), op_state.stream.value(), ts...));
 #else
                                 // When the return type is non-void, we have to
                                 // forward the value to the receiver
                                 pika::util::detail::invoke_fused(
                                     [&](auto&... ts) mutable {
-                                        op_state.result.template emplace<
-                                            invoke_result_type>(PIKA_INVOKE(
-                                            PIKA_MOVE(op_state.f),
-                                            op_state.stream.value(), ts...));
+                                        op_state.result.template emplace<invoke_result_type>(
+                                            PIKA_INVOKE(PIKA_MOVE(op_state.f),
+                                                op_state.stream.value(), ts...));
                                     },
                                     t);
 #endif
 
                                 if constexpr (is_then_with_cuda_stream_receiver<
-                                                  std::decay_t<Receiver>>::
-                                                  value)
+                                                  std::decay_t<Receiver>>::value)
                                 {
                                     if (successor_uses_same_stream)
                                     {
@@ -435,16 +387,15 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                                         // stream when a
                                         // non-then_with_cuda_stream receiver is
                                         // connected.
-                                        set_value_immediate_non_void<
-                                            invoke_result_type>(op_state);
+                                        set_value_immediate_non_void<invoke_result_type>(op_state);
                                     }
                                     else
                                     {
                                         // When the streams are different, we
                                         // add a callback which will call
                                         // set_value on the receiver.
-                                        set_value_event_callback_non_void<
-                                            invoke_result_type>(op_state);
+                                        set_value_event_callback_non_void<invoke_result_type>(
+                                            op_state);
                                     }
                                 }
                                 else
@@ -453,8 +404,7 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                                     // then_with_cuda_stream_receiver, we add a
                                     // callback which will call set_value on the
                                     // receiver.
-                                    set_value_event_callback_non_void<
-                                        invoke_result_type>(op_state);
+                                    set_value_event_callback_non_void<invoke_result_type>(op_state);
                                 }
                             }
                         },
@@ -464,8 +414,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                         });
                 }
 
-                friend constexpr pika::execution::experimental::empty_env
-                tag_invoke(pika::execution::experimental::get_env_t,
+                friend constexpr pika::execution::experimental::empty_env tag_invoke(
+                    pika::execution::experimental::get_env_t,
                     then_with_cuda_stream_receiver const&) noexcept
                 {
                     return {};
@@ -485,8 +435,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
             }
 
             using operation_state_type =
-                pika::execution::experimental::connect_result_t<
-                    std::decay_t<Sender>, then_with_cuda_stream_receiver>;
+                pika::execution::experimental::connect_result_t<std::decay_t<Sender>,
+                    then_with_cuda_stream_receiver>;
             operation_state_type op_state;
 
             template <typename Tuple>
@@ -498,8 +448,7 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
             using ts_type = pika::util::detail::prepend_t<
                 pika::util::detail::transform_t<
-                    pika::execution::experimental::value_types_of_t<
-                        std::decay_t<Sender>,
+                    pika::execution::experimental::value_types_of_t<std::decay_t<Sender>,
                         pika::execution::experimental::empty_env, std::tuple,
                         pika::detail::variant>,
                     value_types_helper>,
@@ -507,9 +456,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
 #else
             using ts_type = pika::util::detail::prepend_t<
                 pika::util::detail::transform_t<
-                    typename pika::execution::experimental::sender_traits<
-                        std::decay_t<Sender>>::template value_types<std::tuple,
-                        pika::detail::variant>,
+                    typename pika::execution::experimental::sender_traits<std::decay_t<Sender>>::
+                        template value_types<std::tuple, pika::detail::variant>,
                     value_types_helper>,
                 pika::detail::monostate>;
 #endif
@@ -543,43 +491,38 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                 using type = pika::detail::monostate;
             };
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-            using result_type = pika::util::detail::change_pack_t<
-                pika::detail::variant,
+            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<
                         pika::execution::experimental::value_types_of_t<
                             then_with_cuda_stream_sender_type,
-                            pika::execution::experimental::empty_env,
-                            pika::util::detail::pack, pika::util::detail::pack>,
+                            pika::execution::experimental::empty_env, 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,
+            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>,
+                        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;
 
             template <typename Receiver_, typename F_, typename Sender_>
-            operation_state(Receiver_&& receiver, F_&& f, cuda_scheduler sched,
-                Sender_&& sender)
+            operation_state(Receiver_&& receiver, F_&& f, cuda_scheduler sched, Sender_&& sender)
               : receiver(PIKA_FORWARD(Receiver_, receiver))
               , f(PIKA_FORWARD(F_, f))
               , sched(PIKA_MOVE(sched))
               , op_state(pika::execution::experimental::connect(
-                    PIKA_FORWARD(Sender_, sender),
-                    then_with_cuda_stream_receiver{*this}))
+                    PIKA_FORWARD(Sender_, sender), then_with_cuda_stream_receiver{*this}))
             {
             }
 
             friend constexpr void tag_invoke(
-                pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::start(os.op_state);
             }
@@ -589,8 +532,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         friend auto tag_invoke(pika::execution::experimental::connect_t,
             then_with_cuda_stream_sender_type&& s, Receiver&& receiver)
         {
-            return operation_state<Receiver>(PIKA_FORWARD(Receiver, receiver),
-                PIKA_MOVE(s.f), PIKA_MOVE(s.sched), PIKA_MOVE(s.sender));
+            return operation_state<Receiver>(PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f),
+                PIKA_MOVE(s.sched), PIKA_MOVE(s.sender));
         }
 
         template <typename Receiver>
@@ -601,8 +544,8 @@ namespace pika::cuda::experimental::then_with_stream_detail {
                 PIKA_FORWARD(Receiver, receiver), s.f, s.sched, s.sender);
         }
 
-        friend auto tag_invoke(pika::execution::experimental::get_env_t,
-            then_with_cuda_stream_sender_type const& s)
+        friend auto tag_invoke(
+            pika::execution::experimental::get_env_t, then_with_cuda_stream_sender_type const& s)
         {
             return pika::execution::experimental::get_env(s.sender);
         }
@@ -613,18 +556,15 @@ namespace pika::cuda::experimental::then_with_stream_detail {
     template <typename Sender, typename F>
     auto then_with_cuda_stream(Sender&& sender, F&& f)
     {
-        auto completion_sched =
-            pika::execution::experimental::get_completion_scheduler<
-                pika::execution::experimental::set_value_t>(
-                pika::execution::experimental::get_env(sender));
-        static_assert(std::is_same_v<std::decay_t<decltype(completion_sched)>,
-                          cuda_scheduler>,
+        auto completion_sched = pika::execution::experimental::get_completion_scheduler<
+            pika::execution::experimental::set_value_t>(
+            pika::execution::experimental::get_env(sender));
+        static_assert(std::is_same_v<std::decay_t<decltype(completion_sched)>, cuda_scheduler>,
             "then_with_cuda_stream can only be used with senders whose "
             "completion scheduler is cuda_scheduler");
 
         return then_with_stream_detail::then_with_cuda_stream_sender<Sender, F>{
-            PIKA_FORWARD(Sender, sender), PIKA_FORWARD(F, f),
-            std::move(completion_sched)};
+            PIKA_FORWARD(Sender, sender), PIKA_FORWARD(F, f), std::move(completion_sched)};
     }
 
     // This is a wrapper for functions that expect a cudaStream_t in the last
@@ -638,11 +578,9 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         auto operator()(cuda_stream const& stream, Ts&&... ts)
         // nvcc does not compile this correctly with noexcept(...)
 #if defined(PIKA_CLANG_VERSION)
-            noexcept(
-                noexcept(PIKA_INVOKE(f, PIKA_FORWARD(Ts, ts)..., stream.get())))
+            noexcept(noexcept(PIKA_INVOKE(f, PIKA_FORWARD(Ts, ts)..., stream.get())))
 #endif
-                -> decltype(PIKA_INVOKE(
-                    f, PIKA_FORWARD(Ts, ts)..., stream.get()))
+                -> decltype(PIKA_INVOKE(f, PIKA_FORWARD(Ts, ts)..., stream.get()))
         {
             return PIKA_INVOKE(f, PIKA_FORWARD(Ts, ts)..., stream.get());
         }
@@ -682,14 +620,13 @@ namespace pika::cuda::experimental::then_with_stream_detail {
         auto operator()(cuda_stream const& stream, Ts&&... ts)
         // nvcc does not compile this correctly with noexcept(...)
 #if defined(PIKA_CLANG_VERSION)
-            noexcept(noexcept(invoke_with_thread_local_cusolver_handle(
-                stream, f, PIKA_FORWARD(Ts, ts)...)))
+            noexcept(noexcept(
+                invoke_with_thread_local_cusolver_handle(stream, f, PIKA_FORWARD(Ts, ts)...)))
 #endif
                 -> decltype(invoke_with_thread_local_cusolver_handle(
                     stream, f, PIKA_FORWARD(Ts, ts)...))
         {
-            return invoke_with_thread_local_cusolver_handle(
-                stream, f, PIKA_FORWARD(Ts, ts)...);
+            return invoke_with_thread_local_cusolver_handle(stream, f, PIKA_FORWARD(Ts, ts)...);
         }
     };
 }    // namespace pika::cuda::experimental::then_with_stream_detail
@@ -717,17 +654,15 @@ namespace pika::cuda::experimental {
         template <typename Sender, typename F>
         constexpr PIKA_FORCEINLINE auto operator()(Sender&& sender, F&& f) const
         {
-            return then_with_stream_detail::then_with_cuda_stream(
-                PIKA_FORWARD(Sender, sender),
-                then_with_stream_detail::cuda_stream_callable<F>{
-                    PIKA_FORWARD(F, f)});
+            return then_with_stream_detail::then_with_cuda_stream(PIKA_FORWARD(Sender, sender),
+                then_with_stream_detail::cuda_stream_callable<F>{PIKA_FORWARD(F, f)});
         }
 
         template <typename F>
         constexpr PIKA_FORCEINLINE auto operator()(F&& f) const
         {
-            return pika::execution::experimental::detail::partial_algorithm<
-                then_with_stream_t, F>{PIKA_FORWARD(F, f)};
+            return pika::execution::experimental::detail::partial_algorithm<then_with_stream_t, F>{
+                PIKA_FORWARD(F, f)};
         }
     } then_with_stream{};
 
@@ -742,22 +677,19 @@ namespace pika::cuda::experimental {
     inline constexpr struct then_with_cublas_t final
     {
         template <typename Sender, typename F>
-        constexpr PIKA_FORCEINLINE auto operator()(
-            Sender&& sender, F&& f, cublasPointerMode_t pointer_mode) const
+        constexpr PIKA_FORCEINLINE auto
+        operator()(Sender&& sender, F&& f, cublasPointerMode_t pointer_mode) const
         {
-            return then_with_stream_detail::then_with_cuda_stream(
-                PIKA_FORWARD(Sender, sender),
+            return then_with_stream_detail::then_with_cuda_stream(PIKA_FORWARD(Sender, sender),
                 then_with_stream_detail::cublas_handle_callable<F>{
                     PIKA_FORWARD(F, f), pointer_mode});
         }
 
         template <typename F>
-        constexpr PIKA_FORCEINLINE auto
-        operator()(F&& f, cublasPointerMode_t pointer_mode) const
+        constexpr PIKA_FORCEINLINE auto operator()(F&& f, cublasPointerMode_t pointer_mode) const
         {
-            return pika::execution::experimental::detail::partial_algorithm<
-                then_with_cublas_t, F, cublasPointerMode_t>{
-                PIKA_FORWARD(F, f), pointer_mode};
+            return pika::execution::experimental::detail::partial_algorithm<then_with_cublas_t, F,
+                cublasPointerMode_t>{PIKA_FORWARD(F, f), pointer_mode};
         }
     } then_with_cublas{};
 
@@ -774,17 +706,15 @@ namespace pika::cuda::experimental {
         template <typename Sender, typename F>
         constexpr PIKA_FORCEINLINE auto operator()(Sender&& sender, F&& f) const
         {
-            return then_with_stream_detail::then_with_cuda_stream(
-                PIKA_FORWARD(Sender, sender),
-                then_with_stream_detail::cusolver_handle_callable<F>{
-                    PIKA_FORWARD(F, f)});
+            return then_with_stream_detail::then_with_cuda_stream(PIKA_FORWARD(Sender, sender),
+                then_with_stream_detail::cusolver_handle_callable<F>{PIKA_FORWARD(F, f)});
         }
 
         template <typename F>
         constexpr PIKA_FORCEINLINE auto operator()(F&& f) const
         {
-            return pika::execution::experimental::detail::partial_algorithm<
-                then_with_cusolver_t, F>{PIKA_FORWARD(F, f)};
+            return pika::execution::experimental::detail::partial_algorithm<then_with_cusolver_t,
+                F>{PIKA_FORWARD(F, f)};
         }
     } then_with_cusolver{};
 }    // namespace pika::cuda::experimental
diff --git a/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu b/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu
index ce42c54e6c..ac44b14545 100644
--- a/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu
+++ b/libs/pika/async_cuda/tests/unit/cuda_scheduler.cu
@@ -29,13 +29,13 @@ template <typename Scheduler>
 inline constexpr bool is_cuda_scheduler_v =
     std::is_same_v<std::decay_t<Scheduler>, cu::cuda_scheduler>;
 
-#define CHECK_CUDA_COMPLETION_SCHEDULER(...)                                   \
-    static_assert(is_cuda_scheduler_v<decltype(ex::get_completion_scheduler<   \
-            ex::set_value_t>(ex::get_env(__VA_ARGS__)))>)
+#define CHECK_CUDA_COMPLETION_SCHEDULER(...)                                                       \
+ static_assert(is_cuda_scheduler_v<decltype(ex::get_completion_scheduler<ex::set_value_t>(         \
+         ex::get_env(__VA_ARGS__)))>)
 
-#define CHECK_NOT_CUDA_COMPLETION_SCHEDULER(...)                               \
-    static_assert(!is_cuda_scheduler_v<decltype(ex::get_completion_scheduler<  \
-                      ex::set_value_t>(ex::get_env(__VA_ARGS__)))>)
+#define CHECK_NOT_CUDA_COMPLETION_SCHEDULER(...)                                                   \
+ static_assert(!is_cuda_scheduler_v<decltype(ex::get_completion_scheduler<ex::set_value_t>(        \
+                   ex::get_env(__VA_ARGS__)))>)
 
 int pika_main()
 {
@@ -56,21 +56,18 @@ int pika_main()
     }
 
     {
-        auto s =
-            ex::schedule(sched) | cu::then_with_stream([](whip::stream_t) {});
+        auto s = ex::schedule(sched) | cu::then_with_stream([](whip::stream_t) {});
         CHECK_CUDA_COMPLETION_SCHEDULER(s);
     }
 
     {
         auto s = ex::schedule(sched) |
-            cu::then_with_cublas(
-                [](cublasHandle_t) {}, CUBLAS_POINTER_MODE_HOST);
+            cu::then_with_cublas([](cublasHandle_t) {}, CUBLAS_POINTER_MODE_HOST);
         CHECK_CUDA_COMPLETION_SCHEDULER(s);
     }
 
     {
-        auto s = ex::schedule(sched) |
-            cu::then_with_cusolver([](cusolverDnHandle_t) {});
+        auto s = ex::schedule(sched) | cu::then_with_cusolver([](cusolverDnHandle_t) {});
         CHECK_CUDA_COMPLETION_SCHEDULER(s);
     }
 
@@ -86,8 +83,7 @@ int pika_main()
         // handler which is not installed in this test (the pika runtime is not
         // started). The thread pool is never accessed.
         auto s = ex::schedule(sched) |
-            cu::then_with_cublas(
-                [](cublasHandle_t) {}, CUBLAS_POINTER_MODE_HOST) |
+            cu::then_with_cublas([](cublasHandle_t) {}, CUBLAS_POINTER_MODE_HOST) |
             ex::transfer(ex::thread_pool_scheduler{nullptr});
         CHECK_NOT_CUDA_COMPLETION_SCHEDULER(s);
 #endif
@@ -101,22 +97,19 @@ int pika_main()
         // to the scheduler. It will return a stream with a priority "close to"
         // the given priority. Currently this means that anything high or higher
         // maps to high, and anything below high maps to normal.
-        PIKA_TEST_EQ(sched.get_next_stream().get_priority(),
-            pika::execution::thread_priority::normal);
         PIKA_TEST_EQ(
-            ex::with_priority(sched, pika::execution::thread_priority::low)
-                .get_next_stream()
-                .get_priority(),
+            sched.get_next_stream().get_priority(), pika::execution::thread_priority::normal);
+        PIKA_TEST_EQ(ex::with_priority(sched, pika::execution::thread_priority::low)
+                         .get_next_stream()
+                         .get_priority(),
             pika::execution::thread_priority::normal);
-        PIKA_TEST_EQ(
-            ex::with_priority(sched, pika::execution::thread_priority::default_)
-                .get_next_stream()
-                .get_priority(),
+        PIKA_TEST_EQ(ex::with_priority(sched, pika::execution::thread_priority::default_)
+                         .get_next_stream()
+                         .get_priority(),
             pika::execution::thread_priority::normal);
-        PIKA_TEST_EQ(
-            ex::with_priority(sched, pika::execution::thread_priority::high)
-                .get_next_stream()
-                .get_priority(),
+        PIKA_TEST_EQ(ex::with_priority(sched, pika::execution::thread_priority::high)
+                         .get_next_stream()
+                         .get_priority(),
             pika::execution::thread_priority::high);
     }
 
@@ -142,9 +135,8 @@ int pika_main()
         {
             using pika::execution::thread_priority;
 
-            senders.push_back(
-                ex::schedule(ex::with_priority(sched,
-                    i % 2 ? thread_priority::high : thread_priority::normal)) |
+            senders.push_back(ex::schedule(ex::with_priority(
+                                  sched, i % 2 ? thread_priority::high : thread_priority::normal)) |
                 cu::then_with_stream([p, i](whip::stream_t stream) {
                     kernel<<<1, 1, 0, stream>>>(p, i);
                     whip::check_last_error();
diff --git a/libs/pika/async_cuda/tests/unit/then_with_stream.cu b/libs/pika/async_cuda/tests/unit/then_with_stream.cu
index fb4592ecf2..9d125a694a 100644
--- a/libs/pika/async_cuda/tests/unit/then_with_stream.cu
+++ b/libs/pika/async_cuda/tests/unit/then_with_stream.cu
@@ -32,8 +32,7 @@ struct const_reference_cuda_sender
     std::reference_wrapper<std::decay_t<T>> x;
     cu::cuda_scheduler sched;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<std::decay_t<T> const&>>;
 
     template <template <class...> class Variant>
@@ -41,10 +40,9 @@ struct const_reference_cuda_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(std::decay_t<T>&),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(std::decay_t<T>&),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     template <typename R>
     struct operation_state
@@ -52,17 +50,15 @@ struct const_reference_cuda_sender
         std::reference_wrapper<std::decay_t<T>> const x;
         std::decay_t<R> r;
 
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
-            pika::execution::experimental::set_value(
-                std::move(os.r), os.x.get());
+            pika::execution::experimental::set_value(std::move(os.r), os.x.get());
         };
     };
 
     template <typename R>
-    friend auto tag_invoke(pika::execution::experimental::connect_t,
-        const_reference_cuda_sender&& s, R&& r)
+    friend auto
+    tag_invoke(pika::execution::experimental::connect_t, const_reference_cuda_sender&& s, R&& r)
     {
         return operation_state<R>{std::move(s.x), std::forward<R>(r)};
     }
@@ -80,8 +76,8 @@ struct const_reference_cuda_sender
         }
     };
 
-    friend env tag_invoke(pika::execution::experimental::get_env_t,
-        const_reference_cuda_sender const& s)
+    friend env tag_invoke(
+        pika::execution::experimental::get_env_t, const_reference_cuda_sender const& s)
     {
         return {s.sched};
     }
@@ -94,8 +90,7 @@ struct const_reference_error_cuda_sender
     PIKA_NVCC_PRAGMA_HD_WARNING_DISABLE
     ~const_reference_error_cuda_sender() = default;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <class...> class Variant>
@@ -103,18 +98,15 @@ struct const_reference_error_cuda_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(),
-            pika::execution::experimental::set_error_t(
-                std::exception_ptr const&)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(),
+        pika::execution::experimental::set_error_t(std::exception_ptr const&)>;
 
     template <typename R>
     struct operation_state
     {
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             auto const e = std::make_exception_ptr(std::runtime_error("error"));
             pika::execution::experimental::set_error(std::move(os.r), e);
@@ -123,8 +115,7 @@ struct const_reference_error_cuda_sender
 
     template <typename R>
     friend operation_state<R>
-    tag_invoke(pika::execution::experimental::connect_t,
-        const_reference_error_cuda_sender, R&& r)
+    tag_invoke(pika::execution::experimental::connect_t, const_reference_error_cuda_sender, R&& r)
     {
         return {std::forward<R>(r)};
     }
@@ -142,8 +133,8 @@ struct const_reference_error_cuda_sender
         }
     };
 
-    friend env tag_invoke(pika::execution::experimental::get_env_t,
-        const_reference_error_cuda_sender const& s)
+    friend env tag_invoke(
+        pika::execution::experimental::get_env_t, const_reference_error_cuda_sender const& s)
     {
         return {s.sched};
     }
@@ -314,8 +305,7 @@ struct increment
     }
 };
 
-auto non_default_constructible_params(
-    custom_type_non_default_constructible& x, whip::stream_t)
+auto non_default_constructible_params(custom_type_non_default_constructible& x, whip::stream_t)
 {
     return std::move(x);
 }
@@ -334,8 +324,8 @@ int pika_main()
     // Only stream transform
     {
         dummy::reset_counts();
-        auto s = ex::just() | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{});
+        auto s =
+            ex::just() | ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(dummy{});
         // NOTE: then_with_stream calls triggers the receiver on a plain
         // std::thread. We explicitly change the context back to an pika::thread.
         tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{}));
@@ -365,9 +355,8 @@ int pika_main()
     {
         dummy::reset_counts();
         auto s = ex::just() | ex::transfer(cu::cuda_scheduler(pool)) |
-            cu::then_with_stream(dummy{}) |
-            ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{}) |
-            ex::transfer(cu::cuda_scheduler(pool)) |
+            cu::then_with_stream(dummy{}) | ex::transfer(ex::thread_pool_scheduler{}) |
+            ex::then(dummy{}) | ex::transfer(cu::cuda_scheduler(pool)) |
             cu::then_with_stream(dummy{});
         tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{}));
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(1));
@@ -381,8 +370,7 @@ int pika_main()
     {
         dummy::reset_counts();
         auto s = ex::schedule(ex::thread_pool_scheduler{}) | ex::then(dummy{}) |
-            ex::transfer(cu::cuda_scheduler(pool)) |
-            cu::then_with_stream(dummy{}) |
+            ex::transfer(cu::cuda_scheduler(pool)) | cu::then_with_stream(dummy{}) |
             ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{});
         tt::sync_wait(std::move(s));
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(2));
@@ -396,11 +384,9 @@ int pika_main()
     // Only stream transform with non-void values
     {
         dummy::reset_counts();
-        auto s = ex::just(1) | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{});
-        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(
-                         std::move(s), ex::thread_pool_scheduler{})),
-            2.0);
+        auto s =
+            ex::just(1) | ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(dummy{});
+        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{})), 2.0);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::stream_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::host_int_calls.load(), std::size_t(0));
@@ -414,9 +400,7 @@ int pika_main()
         auto s = ex::just(1) | ex::transfer(cu::cuda_scheduler{pool}) |
             cu::then_with_stream(dummy{}) | cu::then_with_stream(dummy{}) |
             cu::then_with_stream(dummy{});
-        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(
-                         std::move(s), ex::thread_pool_scheduler{})),
-            4.0);
+        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{})), 4.0);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::stream_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::host_int_calls.load(), std::size_t(0));
@@ -430,35 +414,24 @@ int pika_main()
         auto s = ex::just(custom_type_non_default_constructible{42}) |
             ex::transfer(cu::cuda_scheduler{pool}) |
             cu::then_with_stream(&non_default_constructible_params);
-        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s),
-                                       ex::thread_pool_scheduler{}))
-                         .x,
-            42);
+        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{})).x, 42);
     }
 
     {
-        auto s =
-            ex::just(custom_type_non_default_constructible_non_copyable{42}) |
+        auto s = ex::just(custom_type_non_default_constructible_non_copyable{42}) |
             ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(
-                &non_default_constructible_non_copyable_params);
-        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s),
-                                       ex::thread_pool_scheduler{}))
-                         .x,
-            42);
+            cu::then_with_stream(&non_default_constructible_non_copyable_params);
+        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{})).x, 42);
     }
 
     // Mixing stream transform with host scheduler with non-void values
     {
         dummy::reset_counts();
         auto s = ex::just(1) | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{}) |
-            ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{}) |
-            ex::transfer(cu::cuda_scheduler{pool}) |
+            cu::then_with_stream(dummy{}) | ex::transfer(ex::thread_pool_scheduler{}) |
+            ex::then(dummy{}) | ex::transfer(cu::cuda_scheduler{pool}) |
             cu::then_with_stream(dummy{});
-        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(
-                         std::move(s), ex::thread_pool_scheduler{})),
-            4.0);
+        PIKA_TEST_EQ(tt::sync_wait(ex::transfer(std::move(s), ex::thread_pool_scheduler{})), 4.0);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::stream_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::host_int_calls.load(), std::size_t(0));
@@ -469,9 +442,8 @@ int pika_main()
 
     {
         dummy::reset_counts();
-        auto s = ex::just(1) | ex::transfer(ex::thread_pool_scheduler{}) |
-            ex::then(dummy{}) | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{}) |
+        auto s = ex::just(1) | ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{}) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(dummy{}) |
             ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{});
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 4.0);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
@@ -485,10 +457,10 @@ int pika_main()
     {
         dummy::reset_counts();
 
-        auto s = ex::transfer_just(ex::thread_pool_scheduler{}, 1) |
-            ex::then(dummy{}) | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{}) | cu::then_with_stream(dummy{}) |
-            ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{});
+        auto s = ex::transfer_just(ex::thread_pool_scheduler{}, 1) | ex::then(dummy{}) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(dummy{}) |
+            cu::then_with_stream(dummy{}) | ex::transfer(ex::thread_pool_scheduler{}) |
+            ex::then(dummy{});
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 5.0);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::stream_void_calls.load(), std::size_t(0));
@@ -503,25 +475,20 @@ int pika_main()
         whip::stream_t first_stream{};
         whip::stream_t second_stream{};
         tt::sync_wait(ex::schedule(cu::cuda_scheduler{pool}) |
+            cu::then_with_stream([&](whip::stream_t stream) { first_stream = stream; }) |
             cu::then_with_stream(
-                [&](whip::stream_t stream) { first_stream = stream; }) |
-            cu::then_with_stream([&](whip::stream_t stream) {
-                PIKA_TEST_EQ(stream, first_stream);
-            }) |
-            cu::then_with_stream([&](whip::stream_t stream) {
-                PIKA_TEST_EQ(stream, first_stream);
-            }) |
+                [&](whip::stream_t stream) { PIKA_TEST_EQ(stream, first_stream); }) |
+            cu::then_with_stream(
+                [&](whip::stream_t stream) { PIKA_TEST_EQ(stream, first_stream); }) |
             ex::transfer(cu::cuda_scheduler{pool}) |
             cu::then_with_stream([&](whip::stream_t stream) {
                 PIKA_TEST_NEQ(stream, first_stream);
                 second_stream = stream;
             }) |
-            cu::then_with_stream([&](whip::stream_t stream) {
-                PIKA_TEST_EQ(stream, second_stream);
-            }) |
-            cu::then_with_stream([&](whip::stream_t stream) {
-                PIKA_TEST_EQ(stream, second_stream);
-            }));
+            cu::then_with_stream(
+                [&](whip::stream_t stream) { PIKA_TEST_EQ(stream, second_stream); }) |
+            cu::then_with_stream(
+                [&](whip::stream_t stream) { PIKA_TEST_EQ(stream, second_stream); }));
     }
 
     {
@@ -532,21 +499,14 @@ int pika_main()
         whip::malloc(&p, sizeof(type));
 
         auto s = ex::just(p, &p_h, sizeof(type), whip::memcpy_host_to_device) |
-            ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(whip::memcpy_async) |
-            ex::transfer(ex::thread_pool_scheduler{}) |
-            ex::then([p] { return p; }) |
-            ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(increment{}) |
-            cu::then_with_stream(increment{}) |
-            cu::then_with_stream(increment{});
-        tt::sync_wait(
-            ex::when_all(ex::just(&p_h), std::move(s), ex::just(sizeof(type)),
-                ex::just(whip::memcpy_device_to_host)) |
-            ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(whip::memcpy_async) |
-            ex::transfer(ex::thread_pool_scheduler{}) |
-            ex::then([&p_h] { PIKA_TEST_EQ(p_h, 3); }) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(whip::memcpy_async) |
+            ex::transfer(ex::thread_pool_scheduler{}) | ex::then([p] { return p; }) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(increment{}) |
+            cu::then_with_stream(increment{}) | cu::then_with_stream(increment{});
+        tt::sync_wait(ex::when_all(ex::just(&p_h), std::move(s), ex::just(sizeof(type)),
+                          ex::just(whip::memcpy_device_to_host)) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(whip::memcpy_async) |
+            ex::transfer(ex::thread_pool_scheduler{}) | ex::then([&p_h] { PIKA_TEST_EQ(p_h, 3); }) |
             ex::transfer(ex::thread_pool_scheduler{}));
 
         whip::free(p);
@@ -555,12 +515,11 @@ int pika_main()
     // cuBLAS and cuSOLVER
     {
         dummy::reset_counts();
-        auto s = ex::just(1) | ex::transfer(ex::thread_pool_scheduler{}) |
-            ex::then(dummy{}) | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{}) |
+        auto s = ex::just(1) | ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{}) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(dummy{}) |
             cu::then_with_cublas(dummy{}, CUBLAS_POINTER_MODE_HOST) |
-            cu::then_with_cusolver(dummy{}) |
-            ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{});
+            cu::then_with_cusolver(dummy{}) | ex::transfer(ex::thread_pool_scheduler{}) |
+            ex::then(dummy{});
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 6);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::stream_void_calls.load(), std::size_t(0));
@@ -588,12 +547,11 @@ int pika_main()
 
     {
         dummy::reset_counts();
-        auto s = ex::just(1) | ex::transfer(ex::thread_pool_scheduler{}) |
-            ex::then(dummy{}) | ex::transfer(cu::cuda_scheduler{pool}) |
-            cu::then_with_stream(dummy{}) | cu::then_on_host(dummy{}) |
-            cu::then_with_cublas(dummy{}, CUBLAS_POINTER_MODE_HOST) |
-            cu::then_with_cusolver(dummy{}) |
-            ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{});
+        auto s = ex::just(1) | ex::transfer(ex::thread_pool_scheduler{}) | ex::then(dummy{}) |
+            ex::transfer(cu::cuda_scheduler{pool}) | cu::then_with_stream(dummy{}) |
+            cu::then_on_host(dummy{}) | cu::then_with_cublas(dummy{}, CUBLAS_POINTER_MODE_HOST) |
+            cu::then_with_cusolver(dummy{}) | ex::transfer(ex::thread_pool_scheduler{}) |
+            ex::then(dummy{});
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 7.0);
         PIKA_TEST_EQ(dummy::host_void_calls.load(), std::size_t(0));
         PIKA_TEST_EQ(dummy::stream_void_calls.load(), std::size_t(0));
@@ -623,9 +581,9 @@ int pika_main()
     // them to the operation state)
     {
         int x = 42;
-        auto result = tt::sync_wait(cu::then_with_stream(
-            const_reference_cuda_sender<int>{x, cu::cuda_scheduler{pool}},
-            [](int& x, whip::stream_t) { return x + 1; }));
+        auto result = tt::sync_wait(
+            cu::then_with_stream(const_reference_cuda_sender<int>{x, cu::cuda_scheduler{pool}},
+                [](int& x, whip::stream_t) { return x + 1; }));
         PIKA_TEST_EQ(result, 43);
     }
 
@@ -633,9 +591,9 @@ int pika_main()
         bool exception_thrown = false;
         try
         {
-            tt::sync_wait(cu::then_with_stream(
-                const_reference_error_cuda_sender{cu::cuda_scheduler{pool}},
-                [](whip::stream_t) { PIKA_TEST(false); }));
+            tt::sync_wait(
+                cu::then_with_stream(const_reference_error_cuda_sender{cu::cuda_scheduler{pool}},
+                    [](whip::stream_t) { PIKA_TEST(false); }));
         }
         catch (std::runtime_error const& e)
         {
@@ -650,8 +608,7 @@ int pika_main()
 
 int main(int argc, char* argv[])
 {
-    PIKA_TEST_EQ_MSG(pika::init(pika_main, argc, argv), 0,
-        "pika main exited with non-zero status");
+    PIKA_TEST_EQ_MSG(pika::init(pika_main, argc, argv), 0, "pika main exited with non-zero status");
 
     return 0;
 }
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 e988bb1e69..21ffedbc62 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
@@ -31,8 +31,7 @@
 namespace pika::mpi::experimental {
     namespace transform_mpi_detail {
         template <typename Receiver, typename... Ts>
-        void set_value_request_callback_helper(
-            int mpi_status, Receiver&& receiver, Ts&&... ts)
+        void set_value_request_callback_helper(int mpi_status, Receiver&& receiver, Ts&&... ts)
         {
             static_assert(sizeof...(Ts) <= 1, "Expecting at most one value");
             if (mpi_status == MPI_SUCCESS)
@@ -42,36 +41,30 @@ namespace pika::mpi::experimental {
             }
             else
             {
-                pika::execution::experimental::set_error(
-                    PIKA_FORWARD(Receiver, receiver),
+                pika::execution::experimental::set_error(PIKA_FORWARD(Receiver, receiver),
                     std::make_exception_ptr(mpi_exception(mpi_status)));
             }
         }
 
         template <typename OperationState>
-        void set_value_request_callback_void(
-            MPI_Request request, OperationState& op_state)
+        void set_value_request_callback_void(MPI_Request request, OperationState& op_state)
         {
             detail::add_request_callback(
                 [&op_state](int status) mutable {
                     op_state.ts = {};
-                    set_value_request_callback_helper(
-                        status, PIKA_MOVE(op_state.receiver));
+                    set_value_request_callback_helper(status, PIKA_MOVE(op_state.receiver));
                 },
                 request, op_state.stream);
         }
 
         template <typename Result, typename OperationState>
-        void set_value_request_callback_non_void(
-            MPI_Request request, OperationState& op_state)
+        void set_value_request_callback_non_void(MPI_Request request, OperationState& op_state)
         {
             detail::add_request_callback(
                 [&op_state](int status) mutable {
                     op_state.ts = {};
-                    PIKA_ASSERT(
-                        std::holds_alternative<Result>(op_state.result));
-                    set_value_request_callback_helper(status,
-                        PIKA_MOVE(op_state.receiver),
+                    PIKA_ASSERT(std::holds_alternative<Result>(op_state.result));
+                    set_value_request_callback_helper(status, PIKA_MOVE(op_state.receiver),
                         PIKA_MOVE(std::get<Result>(op_state.result)));
                 },
                 request, op_state.stream);
@@ -79,8 +72,7 @@ namespace pika::mpi::experimental {
 
         template <typename F, typename... Ts>
         inline constexpr bool is_mpi_request_invocable_v =
-            std::is_invocable_v<F,
-                std::add_lvalue_reference_t<std::decay_t<Ts>>..., MPI_Request*>;
+            std::is_invocable_v<F, 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<std::invoke_result_t<F,
@@ -93,8 +85,8 @@ namespace pika::mpi::experimental {
         };
 
         template <typename Sender, typename F>
-        using transform_mpi_sender = typename transform_mpi_sender_impl<Sender,
-            F>::transform_mpi_sender_type;
+        using transform_mpi_sender =
+            typename transform_mpi_sender_impl<Sender, F>::transform_mpi_sender_type;
 
         template <typename Sender, typename F>
         struct transform_mpi_sender_impl<Sender, F>::transform_mpi_sender_type
@@ -108,19 +100,15 @@ namespace pika::mpi::experimental {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
             template <typename... Ts>
             requires is_mpi_request_invocable_v<F, Ts...>
-            using invoke_result_helper =
-                pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::detail::
-                        result_type_signature_helper_t<
-                            mpi_request_invoke_result_t<F, Ts...>>>;
+            using invoke_result_helper = pika::execution::experimental::completion_signatures<
+                pika::execution::experimental::detail::result_type_signature_helper_t<
+                    mpi_request_invoke_result_t<F, Ts...>>>;
 
             using completion_signatures =
-                pika::execution::experimental::make_completion_signatures<
-                    std::decay_t<Sender>,
+                pika::execution::experimental::make_completion_signatures<std::decay_t<Sender>,
                     pika::execution::experimental::empty_env,
                     pika::execution::experimental::completion_signatures<
-                        pika::execution::experimental::set_error_t(
-                            std::exception_ptr)>,
+                        pika::execution::experimental::set_error_t(std::exception_ptr)>,
                     invoke_result_helper>;
 #else
             template <typename Tuple>
@@ -132,24 +120,20 @@ namespace pika::mpi::experimental {
                 static_assert(is_mpi_request_invocable_v<F, Ts...>,
                     "F not invocable with the value_types specified.");
                 using result_type = mpi_request_invoke_result_t<F, Ts...>;
-                using type =
-                    std::conditional_t<std::is_void<result_type>::value,
-                        Tuple<>, Tuple<result_type>>;
+                using type = std::conditional_t<std::is_void<result_type>::value, Tuple<>,
+                    Tuple<result_type>>;
             };
 
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
-            using value_types =
-                pika::util::detail::unique_t<pika::util::detail::transform_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template value_types<Tuple, Variant>,
-                    invoke_result_helper>>;
+            template <template <typename...> class Tuple, template <typename...> class Variant>
+            using value_types = pika::util::detail::unique_t<pika::util::detail::transform_t<
+                typename pika::execution::experimental::sender_traits<Sender>::template value_types<
+                    Tuple, Variant>,
+                invoke_result_helper>>;
 
             template <template <typename...> class Variant>
-            using error_types =
-                pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template error_types<Variant>,
+            using error_types = pika::util::detail::unique_t<
+                pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                                  Sender>::template error_types<Variant>,
                     std::exception_ptr>>;
 
             static constexpr bool sends_done = false;
@@ -169,56 +153,44 @@ namespace pika::mpi::experimental {
                     operation_state& op_state;
 
                     template <typename Error>
-                    friend constexpr void
-                    tag_invoke(pika::execution::experimental::set_error_t,
+                    friend constexpr void tag_invoke(pika::execution::experimental::set_error_t,
                         transform_mpi_receiver&& r, Error&& error) noexcept
                     {
                         pika::execution::experimental::set_error(
-                            PIKA_MOVE(r.op_state.receiver),
-                            PIKA_FORWARD(Error, error));
+                            PIKA_MOVE(r.op_state.receiver), PIKA_FORWARD(Error, error));
                     }
 
-                    friend constexpr void tag_invoke(
-                        pika::execution::experimental::set_stopped_t,
+                    friend constexpr void tag_invoke(pika::execution::experimental::set_stopped_t,
                         transform_mpi_receiver&& r) noexcept
                     {
-                        pika::execution::experimental::set_stopped(
-                            PIKA_MOVE(r.op_state.receiver));
+                        pika::execution::experimental::set_stopped(PIKA_MOVE(r.op_state.receiver));
                     };
 
                     template <typename... Ts,
-                        typename = std::enable_if_t<
-                            is_mpi_request_invocable_v<F, Ts...>>>
-                    friend constexpr void
-                    tag_invoke(pika::execution::experimental::set_value_t,
+                        typename = std::enable_if_t<is_mpi_request_invocable_v<F, Ts...>>>
+                    friend constexpr void tag_invoke(pika::execution::experimental::set_value_t,
                         transform_mpi_receiver&& r, Ts&&... ts) noexcept
                     {
                         pika::detail::try_catch_exception_ptr(
                             [&]() mutable {
-                                using ts_element_type =
-                                    std::tuple<std::decay_t<Ts>...>;
+                                using ts_element_type = std::tuple<std::decay_t<Ts>...>;
                                 r.op_state.ts.template emplace<ts_element_type>(
                                     PIKA_FORWARD(Ts, ts)...);
-                                auto& t =
-                                    std::get<ts_element_type>(r.op_state.ts);
+                                auto& t = std::get<ts_element_type>(r.op_state.ts);
 
                                 MPI_Request request{MPI_REQUEST_NULL};
 
-                                using invoke_result_type =
-                                    mpi_request_invoke_result_t<F, Ts...>;
+                                using invoke_result_type = mpi_request_invoke_result_t<F, Ts...>;
 
                                 // throttle if too many "in flight"
                                 detail::wait_for_throttling(r.op_state.stream);
 
-                                if constexpr (std::is_void_v<
-                                                  invoke_result_type>)
+                                if constexpr (std::is_void_v<invoke_result_type>)
                                 {
                                     pika::util::detail::invoke_fused(
                                         [&](auto&... ts) mutable {
-                                            PIKA_INVOKE(PIKA_MOVE(r.op_state.f),
-                                                ts..., &request);
-                                            PIKA_ASSERT_MSG(
-                                                request != MPI_REQUEST_NULL,
+                                            PIKA_INVOKE(PIKA_MOVE(r.op_state.f), ts..., &request);
+                                            PIKA_ASSERT_MSG(request != MPI_REQUEST_NULL,
                                                 "The MPI_Request is still "
                                                 "MPI_REQUEST_NULL after being "
                                                 "passed to the user callback "
@@ -228,8 +200,7 @@ namespace pika::mpi::experimental {
                                             // When the return type is void,
                                             // there is no value to forward to
                                             // the receiver
-                                            set_value_request_callback_void(
-                                                request, r.op_state);
+                                            set_value_request_callback_void(request, r.op_state);
                                         },
                                         t);
                                 }
@@ -237,12 +208,10 @@ namespace pika::mpi::experimental {
                                 {
                                     pika::util::detail::invoke_fused(
                                         [&](auto&... ts) mutable {
-                                            r.op_state.result.template emplace<
-                                                invoke_result_type>(PIKA_INVOKE(
-                                                PIKA_MOVE(r.op_state.f), ts...,
-                                                &request));
-                                            PIKA_ASSERT_MSG(
-                                                request != MPI_REQUEST_NULL,
+                                            r.op_state.result.template emplace<invoke_result_type>(
+                                                PIKA_INVOKE(
+                                                    PIKA_MOVE(r.op_state.f), ts..., &request));
+                                            PIKA_ASSERT_MSG(request != MPI_REQUEST_NULL,
                                                 "The MPI_Request is still "
                                                 "MPI_REQUEST_NULL after being "
                                                 "passed to the user callback "
@@ -252,8 +221,7 @@ namespace pika::mpi::experimental {
                                             // When the return type is non-void,
                                             // we have to forward the value to
                                             // the receiver
-                                            set_value_request_callback_non_void<
-                                                invoke_result_type>(
+                                            set_value_request_callback_non_void<invoke_result_type>(
                                                 request, r.op_state);
                                         },
                                         t);
@@ -261,13 +229,12 @@ namespace pika::mpi::experimental {
                             },
                             [&](std::exception_ptr ep) {
                                 pika::execution::experimental::set_error(
-                                    PIKA_MOVE(r.op_state.receiver),
-                                    PIKA_MOVE(ep));
+                                    PIKA_MOVE(r.op_state.receiver), PIKA_MOVE(ep));
                             });
                     }
 
-                    friend constexpr pika::execution::experimental::empty_env
-                    tag_invoke(pika::execution::experimental::get_env_t,
+                    friend constexpr pika::execution::experimental::empty_env tag_invoke(
+                        pika::execution::experimental::get_env_t,
                         transform_mpi_receiver const&) noexcept
                     {
                         return {};
@@ -275,33 +242,29 @@ namespace pika::mpi::experimental {
                 };
 
                 using operation_state_type =
-                    pika::execution::experimental::connect_result_t<
-                        std::decay_t<Sender>, transform_mpi_receiver>;
+                    pika::execution::experimental::connect_result_t<std::decay_t<Sender>,
+                        transform_mpi_receiver>;
                 operation_state_type op_state;
 
                 template <typename Tuple>
                 struct value_types_helper
                 {
-                    using type =
-                        pika::util::detail::transform_t<Tuple, std::decay>;
+                    using type = pika::util::detail::transform_t<Tuple, std::decay>;
                 };
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
                 using ts_type = pika::util::detail::prepend_t<
                     pika::util::detail::transform_t<
-                        pika::execution::experimental::value_types_of_t<
-                            std::decay_t<Sender>,
-                            pika::execution::experimental::empty_env,
-                            std::tuple, pika::detail::variant>,
+                        pika::execution::experimental::value_types_of_t<std::decay_t<Sender>,
+                            pika::execution::experimental::empty_env, std::tuple,
+                            pika::detail::variant>,
                         value_types_helper>,
                     pika::detail::monostate>;
 #else
                 using ts_type = pika::util::detail::prepend_t<
                     pika::util::detail::transform_t<
-                        typename pika::execution::experimental::sender_traits<
-                            std::decay_t<Sender>>::
-                            template value_types<std::tuple,
-                                pika::detail::variant>,
+                        typename pika::execution::experimental::sender_traits<std::decay_t<
+                            Sender>>::template value_types<std::tuple, pika::detail::variant>,
                         value_types_helper>,
                     pika::detail::monostate>;
 #endif
@@ -337,24 +300,19 @@ namespace pika::mpi::experimental {
                     using type = pika::detail::monostate;
                 };
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-                using result_type = pika::util::detail::change_pack_t<
-                    pika::detail::variant,
+                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<
                             pika::execution::experimental::value_types_of_t<
-                                transform_mpi_sender_type,
-                                pika::execution::experimental::empty_env,
-                                pika::util::detail::pack,
-                                pika::util::detail::pack>,
+                                transform_mpi_sender_type, pika::execution::experimental::empty_env,
+                                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,
+                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<
-                            transform_mpi_sender_type::value_types<
-                                pika::util::detail::pack,
+                            transform_mpi_sender_type::value_types<pika::util::detail::pack,
                                 pika::util::detail::pack>,
                             result_types_helper>,
                         pika::detail::monostate>>>;
@@ -362,28 +320,24 @@ namespace pika::mpi::experimental {
                 result_type result;
 
                 template <typename Receiver_, typename F_, typename Sender_>
-                operation_state(Receiver_&& receiver, F_&& f, Sender_&& sender,
-                    stream_type s)
+                operation_state(Receiver_&& receiver, F_&& f, Sender_&& sender, stream_type s)
                   : receiver(PIKA_FORWARD(Receiver_, receiver))
                   , f(PIKA_FORWARD(F_, f))
                   , stream{s}
                   , op_state(pika::execution::experimental::connect(
-                        PIKA_FORWARD(Sender_, sender),
-                        transform_mpi_receiver{*this}))
+                        PIKA_FORWARD(Sender_, sender), transform_mpi_receiver{*this}))
                 {
                 }
 
                 friend constexpr auto tag_invoke(
-                    pika::execution::experimental::start_t,
-                    operation_state& os) noexcept
+                    pika::execution::experimental::start_t, operation_state& os) noexcept
                 {
                     return pika::execution::experimental::start(os.op_state);
                 }
             };
 
             template <typename Receiver>
-            friend constexpr auto
-            tag_invoke(pika::execution::experimental::connect_t,
+            friend constexpr auto tag_invoke(pika::execution::experimental::connect_t,
                 transform_mpi_sender_type const& s, Receiver&& receiver)
             {
                 return operation_state<Receiver>(
@@ -391,12 +345,10 @@ namespace pika::mpi::experimental {
             }
 
             template <typename Receiver>
-            friend constexpr auto
-            tag_invoke(pika::execution::experimental::connect_t,
+            friend constexpr auto tag_invoke(pika::execution::experimental::connect_t,
                 transform_mpi_sender_type&& s, Receiver&& receiver)
             {
-                return operation_state<Receiver>(
-                    PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f),
+                return operation_state<Receiver>(PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f),
                     PIKA_MOVE(s.sender), s.stream);
             }
         };
@@ -407,12 +359,9 @@ namespace pika::mpi::experimental {
     {
     private:
         template <typename Sender, typename F,
-            PIKA_CONCEPT_REQUIRES_(
-                pika::execution::experimental::is_sender_v<Sender>)>
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(transform_mpi_t, Sender&& sender, F&& f,
-            mpi::experimental::stream_type s =
-                mpi::experimental::stream_type::automatic)
+            PIKA_CONCEPT_REQUIRES_(pika::execution::experimental::is_sender_v<Sender>)>
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(transform_mpi_t, Sender&& sender,
+            F&& f, mpi::experimental::stream_type s = mpi::experimental::stream_type::automatic)
         {
             return transform_mpi_detail::transform_mpi_sender<Sender, F>{
                 PIKA_FORWARD(Sender, sender), PIKA_FORWARD(F, f), s};
@@ -422,14 +371,11 @@ namespace pika::mpi::experimental {
         // tag invoke overload for mpi_transform
         //
         template <typename F>
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(transform_mpi_t, F&& f,
-            mpi::experimental::stream_type s =
-                mpi::experimental::stream_type::automatic)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(transform_mpi_t, F&& f,
+            mpi::experimental::stream_type s = mpi::experimental::stream_type::automatic)
         {
-            return ::pika::execution::experimental::detail::partial_algorithm<
-                transform_mpi_t, F, mpi::experimental::stream_type>{
-                PIKA_FORWARD(F, f), s};
+            return ::pika::execution::experimental::detail::partial_algorithm<transform_mpi_t, F,
+                mpi::experimental::stream_type>{PIKA_FORWARD(F, f), s};
         }
 
     } transform_mpi{};
diff --git a/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp b/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
index 21455900b1..6b57a5da49 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/bulk.hpp
@@ -10,25 +10,25 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #else
-#include <pika/concepts/concepts.hpp>
-#include <pika/datastructures/variant.hpp>
-#include <pika/errors/try_catch_exception_ptr.hpp>
-#include <pika/execution/algorithms/detail/partial_algorithm.hpp>
-#include <pika/execution/algorithms/then.hpp>
-#include <pika/execution_base/completion_scheduler.hpp>
-#include <pika/execution_base/receiver.hpp>
-#include <pika/execution_base/sender.hpp>
-#include <pika/functional/detail/tag_priority_invoke.hpp>
-#include <pika/iterator_support/counting_shape.hpp>
-#include <pika/type_support/pack.hpp>
-
-#include <exception>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
+# include <pika/concepts/concepts.hpp>
+# include <pika/datastructures/variant.hpp>
+# include <pika/errors/try_catch_exception_ptr.hpp>
+# include <pika/execution/algorithms/detail/partial_algorithm.hpp>
+# include <pika/execution/algorithms/then.hpp>
+# include <pika/execution_base/completion_scheduler.hpp>
+# include <pika/execution_base/receiver.hpp>
+# include <pika/execution_base/sender.hpp>
+# include <pika/functional/detail/tag_priority_invoke.hpp>
+# include <pika/iterator_support/counting_shape.hpp>
+# include <pika/type_support/pack.hpp>
+
+# include <exception>
+# include <iterator>
+# include <tuple>
+# include <type_traits>
+# include <utility>
 
 namespace pika::bulk_detail {
     template <typename Sender, typename Shape, typename F>
@@ -38,8 +38,7 @@ namespace pika::bulk_detail {
     };
 
     template <typename Sender, typename Shape, typename F>
-    using bulk_sender =
-        typename bulk_sender_impl<Sender, Shape, F>::bulk_sender_type;
+    using bulk_sender = typename bulk_sender_impl<Sender, Shape, F>::bulk_sender_type;
 
     template <typename Sender, typename Shape, typename F>
     struct bulk_sender_impl<Sender, Shape, F>::bulk_sender_type
@@ -48,17 +47,14 @@ namespace pika::bulk_detail {
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Shape> shape;
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<F> f;
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types =
-            typename pika::execution::experimental::sender_traits<
-                Sender>::template value_types<Tuple, Variant>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = typename pika::execution::experimental::sender_traits<
+            Sender>::template value_types<Tuple, Variant>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template error_types<Variant>,
+        using error_types = pika::util::detail::unique_t<
+            pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                              Sender>::template error_types<Variant>,
                 std::exception_ptr>>;
 
         static constexpr bool sends_done = false;
@@ -85,18 +81,17 @@ namespace pika::bulk_detail {
             }
 
             template <typename Error>
-            friend void tag_invoke(pika::execution::experimental::set_error_t,
-                bulk_receiver&& r, Error&& error) noexcept
+            friend void tag_invoke(pika::execution::experimental::set_error_t, bulk_receiver&& r,
+                Error&& error) noexcept
             {
                 pika::execution::experimental::set_error(
                     PIKA_MOVE(r.receiver), PIKA_FORWARD(Error, error));
             }
 
-            friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-                bulk_receiver&& r) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::set_stopped_t, bulk_receiver&& r) noexcept
             {
-                pika::execution::experimental::set_stopped(
-                    PIKA_MOVE(r.receiver));
+                pika::execution::experimental::set_stopped(PIKA_MOVE(r.receiver));
             }
 
             template <typename... Ts>
@@ -118,11 +113,10 @@ namespace pika::bulk_detail {
             }
 
             template <typename... Ts>
-            friend auto tag_invoke(pika::execution::experimental::set_value_t,
-                bulk_receiver&& r, Ts&&... ts) noexcept
+            friend auto tag_invoke(
+                pika::execution::experimental::set_value_t, bulk_receiver&& r, Ts&&... ts) noexcept
                 -> decltype(pika::execution::experimental::set_value(
-                                std::declval<std::decay_t<Receiver>&&>(),
-                                PIKA_FORWARD(Ts, ts)...),
+                                std::declval<std::decay_t<Receiver>&&>(), PIKA_FORWARD(Ts, ts)...),
                     void())
             {
                 // set_value is in a member function only because of a
@@ -134,28 +128,26 @@ namespace pika::bulk_detail {
         };
 
         template <typename Receiver>
-        friend auto tag_invoke(pika::execution::experimental::connect_t,
-            bulk_sender_type&& s, Receiver&& receiver)
+        friend auto tag_invoke(
+            pika::execution::experimental::connect_t, bulk_sender_type&& s, Receiver&& receiver)
         {
             return pika::execution::experimental::connect(PIKA_MOVE(s.sender),
-                bulk_receiver<Receiver>(PIKA_FORWARD(Receiver, receiver),
-                    PIKA_MOVE(s.shape), PIKA_MOVE(s.f)));
+                bulk_receiver<Receiver>(
+                    PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.shape), PIKA_MOVE(s.f)));
         }
 
         template <typename Receiver>
-        friend auto tag_invoke(pika::execution::experimental::connect_t,
-            bulk_sender_type const& s, Receiver&& receiver)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, bulk_sender_type const& s,
+            Receiver&& receiver)
         {
-            return pika::execution::experimental::connect(s.sender,
-                bulk_receiver<Receiver>(
-                    PIKA_FORWARD(Receiver, receiver), s.shape, s.f));
+            return pika::execution::experimental::connect(
+                s.sender, bulk_receiver<Receiver>(PIKA_FORWARD(Receiver, receiver), s.shape, s.f));
         }
     };
 }    // namespace pika::bulk_detail
 
 namespace pika::execution::experimental {
-    inline constexpr struct bulk_t final
-      : pika::functional::detail::tag_priority<bulk_t>
+    inline constexpr struct bulk_t final : pika::functional::detail::tag_priority<bulk_t>
     {
     private:
         // clang-format off
@@ -170,13 +162,11 @@ namespace pika::execution::experimental {
         friend constexpr PIKA_FORCEINLINE auto
         tag_override_invoke(bulk_t, Sender&& sender, Shape const& shape, F&& f)
         {
-            auto scheduler =
-                pika::execution::experimental::get_completion_scheduler<
-                    pika::execution::experimental::set_value_t>(
-                    pika::execution::experimental::get_env(sender));
-            return pika::functional::detail::tag_invoke(bulk_t{},
-                PIKA_MOVE(scheduler), PIKA_FORWARD(Sender, sender), shape,
-                PIKA_FORWARD(F, f));
+            auto scheduler = pika::execution::experimental::get_completion_scheduler<
+                pika::execution::experimental::set_value_t>(
+                pika::execution::experimental::get_env(sender));
+            return pika::functional::detail::tag_invoke(bulk_t{}, PIKA_MOVE(scheduler),
+                PIKA_FORWARD(Sender, sender), shape, PIKA_FORWARD(F, f));
         }
 
         // clang-format off
@@ -189,10 +179,8 @@ namespace pika::execution::experimental {
         friend constexpr PIKA_FORCEINLINE auto
         tag_fallback_invoke(bulk_t, Sender&& sender, Shape const& shape, F&& f)
         {
-            return bulk_detail::bulk_sender<Sender,
-                pika::util::detail::counting_shape_type<Shape>, F>{
-                PIKA_FORWARD(Sender, sender),
-                pika::util::detail::make_counting_shape(shape),
+            return bulk_detail::bulk_sender<Sender, pika::util::detail::counting_shape_type<Shape>,
+                F>{PIKA_FORWARD(Sender, sender), pika::util::detail::make_counting_shape(shape),
                 PIKA_FORWARD(F, f)};
         }
 
@@ -207,13 +195,11 @@ namespace pika::execution::experimental {
         tag_fallback_invoke(bulk_t, Sender&& sender, Shape&& shape, F&& f)
         {
             return bulk_detail::bulk_sender<Sender, Shape, F>{
-                PIKA_FORWARD(Sender, sender), PIKA_FORWARD(Shape, shape),
-                PIKA_FORWARD(F, f)};
+                PIKA_FORWARD(Sender, sender), PIKA_FORWARD(Shape, shape), PIKA_FORWARD(F, f)};
         }
 
         template <typename Shape, typename F>
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(bulk_t, Shape&& shape, F&& f)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(bulk_t, Shape&& shape, F&& f)
         {
             return detail::partial_algorithm<bulk_t, Shape, F>{
                 PIKA_FORWARD(Shape, shape), PIKA_FORWARD(F, f)};
diff --git a/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp b/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
index 9b31f0e255..042a68c501 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/drop_value.hpp
@@ -46,8 +46,8 @@ namespace pika::drop_value_detail {
                 PIKA_MOVE(r.receiver), PIKA_FORWARD(Error, error));
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-            drop_value_receiver_type&& r) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_stopped_t, drop_value_receiver_type&& r) noexcept
         {
             pika::execution::experimental::set_stopped(PIKA_MOVE(r.receiver));
         }
@@ -60,8 +60,7 @@ namespace pika::drop_value_detail {
         }
 
         friend constexpr pika::execution::experimental::empty_env tag_invoke(
-            pika::execution::experimental::get_env_t,
-            drop_value_receiver_type const&) noexcept
+            pika::execution::experimental::get_env_t, drop_value_receiver_type const&) noexcept
         {
             return {};
         }
@@ -74,8 +73,7 @@ namespace pika::drop_value_detail {
     };
 
     template <typename Sender>
-    using drop_value_sender =
-        typename drop_value_sender_impl<Sender>::drop_value_sender_type;
+    using drop_value_sender = typename drop_value_sender_impl<Sender>::drop_value_sender_type;
 
     template <typename Sender>
     struct drop_value_sender_impl<Sender>::drop_value_sender_type
@@ -86,51 +84,44 @@ namespace pika::drop_value_detail {
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         template <class...>
-        using empty_set_value =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t()>;
+        using empty_set_value = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t()>;
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<Sender,
                 pika::execution::experimental::empty_env,
-                pika::execution::experimental::completion_signatures<>,
-                empty_set_value>;
+                pika::execution::experimental::completion_signatures<>, empty_set_value>;
 #else
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         using value_types = Variant<Tuple<>>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template error_types<Variant>,
+        using error_types = pika::util::detail::unique_t<
+            pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                              Sender>::template error_types<Variant>,
                 std::exception_ptr>>;
 
         static constexpr bool sends_done = false;
 #endif
 
         template <typename Receiver>
-        friend auto tag_invoke(pika::execution::experimental::connect_t,
-            drop_value_sender_type&& s, Receiver&& receiver)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, drop_value_sender_type&& s,
+            Receiver&& receiver)
         {
             return pika::execution::experimental::connect(PIKA_MOVE(s.sender),
-                drop_value_receiver<Receiver>{
-                    PIKA_FORWARD(Receiver, receiver)});
+                drop_value_receiver<Receiver>{PIKA_FORWARD(Receiver, receiver)});
         }
 
         template <typename Receiver>
         friend auto tag_invoke(pika::execution::experimental::connect_t,
             drop_value_sender_type const& r, Receiver&& receiver)
         {
-            return pika::execution::experimental::connect(r.sender,
-                drop_value_receiver<Receiver>{
-                    PIKA_FORWARD(Receiver, receiver)});
+            return pika::execution::experimental::connect(
+                r.sender, drop_value_receiver<Receiver>{PIKA_FORWARD(Receiver, receiver)});
         }
 
         friend constexpr decltype(auto) tag_invoke(
-            pika::execution::experimental::get_env_t,
-            drop_value_sender_type const& s)
+            pika::execution::experimental::get_env_t, drop_value_sender_type const& s)
         {
             return pika::execution::experimental::get_env(s.sender);
         }
@@ -144,8 +135,7 @@ namespace pika::execution::experimental {
         template <typename Sender, PIKA_CONCEPT_REQUIRES_(is_sender_v<Sender>)>
         constexpr PIKA_FORCEINLINE auto operator()(Sender&& sender) const
         {
-            return drop_value_detail::drop_value_sender<Sender>{
-                PIKA_FORWARD(Sender, sender)};
+            return drop_value_detail::drop_value_sender<Sender>{PIKA_FORWARD(Sender, sender)};
         }
 
         constexpr PIKA_FORCEINLINE auto operator()() const
diff --git a/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp b/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp
index 5c93152d6a..ddb21ce7a7 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/keep_future.hpp
@@ -29,18 +29,15 @@ namespace pika::keep_future_detail {
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
         std::decay_t<Future> future;
 
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             pika::detail::try_catch_exception_ptr(
                 [&]() {
-                    auto state =
-                        pika::traits::detail::get_shared_state(os.future);
+                    auto state = pika::traits::detail::get_shared_state(os.future);
 
                     if (!state)
                     {
-                        PIKA_THROW_EXCEPTION(pika::error::no_state,
-                            "operation_state::start",
+                        PIKA_THROW_EXCEPTION(pika::error::no_state, "operation_state::start",
                             "the future has no valid shared state");
                     }
 
@@ -53,8 +50,7 @@ namespace pika::keep_future_detail {
                     });
                 },
                 [&](std::exception_ptr ep) {
-                    pika::execution::experimental::set_error(
-                        PIKA_MOVE(os.receiver), PIKA_MOVE(ep));
+                    pika::execution::experimental::set_error(PIKA_MOVE(os.receiver), PIKA_MOVE(ep));
                 });
         }
     };
@@ -66,8 +62,7 @@ namespace pika::keep_future_detail {
 
         std::decay_t<Future> future;
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         using value_types = Variant<Tuple<std::decay_t<Future>>>;
 
         template <template <typename...> class Variant>
@@ -75,27 +70,24 @@ namespace pika::keep_future_detail {
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t(
-                    std::decay_t<Future>),
-                pika::execution::experimental::set_error_t(std::exception_ptr)>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t(std::decay_t<Future>),
+            pika::execution::experimental::set_error_t(std::exception_ptr)>;
     };
 
     template <typename Future>
     struct keep_future_sender;
 
     template <typename T>
-    struct keep_future_sender<pika::future<T>>
-      : public keep_future_sender_base<pika::future<T>>
+    struct keep_future_sender<pika::future<T>> : public keep_future_sender_base<pika::future<T>>
     {
         using future_type = pika::future<T>;
         using base_type = keep_future_sender_base<pika::future<T>>;
         using base_type::future;
 
         template <typename Future,
-            typename = std::enable_if_t<
-                !std::is_same<std::decay_t<Future>, keep_future_sender>::value>>
+            typename =
+                std::enable_if_t<!std::is_same<std::decay_t<Future>, keep_future_sender>::value>>
         explicit keep_future_sender(Future&& future)
           : base_type{PIKA_FORWARD(Future, future)}
         {
@@ -107,17 +99,15 @@ namespace pika::keep_future_detail {
         keep_future_sender& operator=(keep_future_sender const&) = delete;
 
         template <typename Receiver>
-        friend operation_state<Receiver, future_type>
-        tag_invoke(pika::execution::experimental::connect_t,
-            keep_future_sender&& s, Receiver&& receiver)
+        friend operation_state<Receiver, future_type> tag_invoke(
+            pika::execution::experimental::connect_t, keep_future_sender&& s, Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.future)};
         }
 
         template <typename Receiver>
         friend operation_state<Receiver, future_type>
-        tag_invoke(pika::execution::experimental::connect_t,
-            keep_future_sender const&, Receiver&&)
+        tag_invoke(pika::execution::experimental::connect_t, keep_future_sender const&, Receiver&&)
         {
             static_assert(sizeof(Receiver) == 0,
                 "Are you missing a std::move? The keep_future sender of a "
@@ -136,8 +126,8 @@ namespace pika::keep_future_detail {
         using base_type::future;
 
         template <typename Future,
-            typename = std::enable_if_t<
-                !std::is_same<std::decay_t<Future>, keep_future_sender>::value>>
+            typename =
+                std::enable_if_t<!std::is_same<std::decay_t<Future>, keep_future_sender>::value>>
         explicit keep_future_sender(Future&& future)
           : base_type{PIKA_FORWARD(Future, future)}
         {
@@ -149,17 +139,16 @@ namespace pika::keep_future_detail {
         keep_future_sender& operator=(keep_future_sender const&) = default;
 
         template <typename Receiver>
-        friend operation_state<Receiver, future_type>
-        tag_invoke(pika::execution::experimental::connect_t,
-            keep_future_sender&& s, Receiver&& receiver)
+        friend operation_state<Receiver, future_type> tag_invoke(
+            pika::execution::experimental::connect_t, keep_future_sender&& s, Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.future)};
         }
 
         template <typename Receiver>
         friend operation_state<Receiver, future_type>
-        tag_invoke(pika::execution::experimental::connect_t,
-            keep_future_sender const& s, Receiver&& receiver)
+        tag_invoke(pika::execution::experimental::connect_t, keep_future_sender const& s,
+            Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), s.future};
         }
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 7346e2dee1..7dfc194a12 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/make_future.hpp
@@ -9,7 +9,7 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #endif
 
 #include <pika/allocator_support/allocator_deleter.hpp>
@@ -43,14 +43,11 @@ namespace pika::make_future_detail {
         virtual void reset_operation_state() = 0;
 
         using init_no_addref =
-            typename pika::lcos::detail::future_data_allocator<T,
-                Allocator>::init_no_addref;
+            typename pika::lcos::detail::future_data_allocator<T, Allocator>::init_no_addref;
 
         template <typename Allocator_>
-        resettable_operation_state_future_data(
-            init_no_addref no_addref, Allocator_ const& alloc)
-          : pika::lcos::detail::future_data_allocator<T, Allocator>(
-                no_addref, alloc)
+        resettable_operation_state_future_data(init_no_addref no_addref, Allocator_ const& alloc)
+          : pika::lcos::detail::future_data_allocator<T, Allocator>(no_addref, alloc)
         {
         }
     };
@@ -60,12 +57,10 @@ namespace pika::make_future_detail {
     {
         using is_receiver = void;
 
-        pika::intrusive_ptr<
-            resettable_operation_state_future_data<T, Allocator>>
-            data;
+        pika::intrusive_ptr<resettable_operation_state_future_data<T, Allocator>> data;
 
-        friend void tag_invoke(pika::execution::experimental::set_error_t,
-            make_future_receiver&& r, std::exception_ptr ep) noexcept
+        friend void tag_invoke(pika::execution::experimental::set_error_t, make_future_receiver&& r,
+            std::exception_ptr ep) noexcept
         {
             // We move the receiver into a local variable from the operation
             // state which the receiver refers to. This allows us to safely
@@ -77,15 +72,15 @@ namespace pika::make_future_detail {
             r_local.data.reset();
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-            make_future_receiver&&) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_stopped_t, make_future_receiver&&) noexcept
         {
             std::terminate();
         }
 
         template <typename U>
-        friend void tag_invoke(pika::execution::experimental::set_value_t,
-            make_future_receiver&& r, U&& u) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_value_t, make_future_receiver&& r, U&& u) noexcept
         {
             // We move the receiver into a local variable from the operation
             // state which the receiver refers to. This allows us to safely
@@ -94,16 +89,13 @@ namespace pika::make_future_detail {
 
             pika::detail::try_catch_exception_ptr(
                 [&]() { r_local.data->set_value(PIKA_FORWARD(U, u)); },
-                [&](std::exception_ptr ep) {
-                    r_local.data->set_exception(PIKA_MOVE(ep));
-                });
+                [&](std::exception_ptr ep) { r_local.data->set_exception(PIKA_MOVE(ep)); });
             r_local.data->reset_operation_state();
             r_local.data.reset();
         }
 
         friend constexpr pika::execution::experimental::empty_env tag_invoke(
-            pika::execution::experimental::get_env_t,
-            make_future_receiver const&) noexcept
+            pika::execution::experimental::get_env_t, make_future_receiver const&) noexcept
         {
             return {};
         }
@@ -112,12 +104,10 @@ namespace pika::make_future_detail {
     template <typename Allocator>
     struct make_future_receiver<void, Allocator>
     {
-        pika::intrusive_ptr<
-            resettable_operation_state_future_data<void, Allocator>>
-            data;
+        pika::intrusive_ptr<resettable_operation_state_future_data<void, Allocator>> data;
 
-        friend void tag_invoke(pika::execution::experimental::set_error_t,
-            make_future_receiver&& r, std::exception_ptr ep) noexcept
+        friend void tag_invoke(pika::execution::experimental::set_error_t, make_future_receiver&& r,
+            std::exception_ptr ep) noexcept
         {
             // We move the receiver into a local variable from the operation
             // state which the receiver refers to. This allows us to safely
@@ -129,14 +119,14 @@ namespace pika::make_future_detail {
             r_local.data.reset();
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-            make_future_receiver&&) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_stopped_t, make_future_receiver&&) noexcept
         {
             std::terminate();
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_value_t,
-            make_future_receiver&& r) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_value_t, make_future_receiver&& r) noexcept
         {
             // We move the receiver into a local variable from the operation
             // state which the receiver refers to. This allows us to safely
@@ -145,16 +135,13 @@ namespace pika::make_future_detail {
 
             pika::detail::try_catch_exception_ptr(
                 [&]() { r_local.data->set_value(pika::util::detail::unused); },
-                [&](std::exception_ptr ep) {
-                    r_local.data->set_exception(PIKA_MOVE(ep));
-                });
+                [&](std::exception_ptr ep) { r_local.data->set_exception(PIKA_MOVE(ep)); });
             r_local.data->reset_operation_state();
             r_local.data.reset();
         }
 
         friend constexpr pika::execution::experimental::empty_env tag_invoke(
-            pika::execution::experimental::get_env_t,
-            make_future_receiver const&) noexcept
+            pika::execution::experimental::get_env_t, make_future_receiver const&) noexcept
         {
             return {};
         }
@@ -166,26 +153,22 @@ namespace pika::make_future_detail {
         PIKA_NON_COPYABLE(future_data);
 
         using operation_state_type = std::decay_t<OperationState>;
-        using other_allocator = typename std::allocator_traits<
-            Allocator>::template rebind_alloc<future_data>;
+        using other_allocator =
+            typename std::allocator_traits<Allocator>::template rebind_alloc<future_data>;
         using init_no_addref =
-            typename pika::lcos::detail::future_data_allocator<T,
-                Allocator>::init_no_addref;
+            typename pika::lcos::detail::future_data_allocator<T, Allocator>::init_no_addref;
 
         // The operation state is stored in an optional so that it can be
         // reset explicitly as soon as set_* is called.
         std::optional<operation_state_type> op_state;
 
         template <typename Sender>
-        future_data(init_no_addref no_addref, other_allocator const& alloc,
-            Sender&& sender)
-          : resettable_operation_state_future_data<T, Allocator>(
-                no_addref, alloc)
+        future_data(init_no_addref no_addref, other_allocator const& alloc, Sender&& sender)
+          : resettable_operation_state_future_data<T, Allocator>(no_addref, alloc)
         {
             op_state.emplace(pika::detail::with_result_of([&]() {
                 return pika::execution::experimental::connect(
-                    PIKA_FORWARD(Sender, sender),
-                    make_future_receiver<T, Allocator>{this});
+                    PIKA_FORWARD(Sender, sender), make_future_receiver<T, Allocator>{this});
             }));
             pika::execution::experimental::start(op_state.value());
         }
@@ -204,39 +187,35 @@ namespace pika::make_future_detail {
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         using value_types =
-            typename pika::execution::experimental::value_types_of_t<
-                std::decay_t<Sender>, pika::execution::experimental::empty_env,
-                pika::util::detail::pack, pika::util::detail::pack>;
+            typename pika::execution::experimental::value_types_of_t<std::decay_t<Sender>,
+                pika::execution::experimental::empty_env, 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::detail::pack, pika::util::detail::pack>;
+        using value_types =
+            typename pika::execution::experimental::sender_traits<std::decay_t<Sender>>::
+                template value_types<pika::util::detail::pack, pika::util::detail::pack>;
 #endif
         using result_type =
-            std::decay_t<pika::execution::experimental::detail::single_result_t<
-                value_types>>;
-        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>;
+            std::decay_t<pika::execution::experimental::detail::single_result_t<value_types>>;
+        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>;
         using init_no_addref = typename shared_state::init_no_addref;
-        using other_allocator = typename std::allocator_traits<
-            allocator_type>::template rebind_alloc<shared_state>;
+        using other_allocator =
+            typename std::allocator_traits<allocator_type>::template rebind_alloc<shared_state>;
         using allocator_traits = std::allocator_traits<other_allocator>;
-        using unique_ptr = std::unique_ptr<shared_state,
-            pika::detail::allocator_deleter<other_allocator>>;
+        using unique_ptr =
+            std::unique_ptr<shared_state, pika::detail::allocator_deleter<other_allocator>>;
 
         other_allocator alloc(allocator);
         unique_ptr p(allocator_traits::allocate(alloc, 1),
             pika::detail::allocator_deleter<other_allocator>{alloc});
 
-        allocator_traits::construct(alloc, p.get(), init_no_addref{}, alloc,
-            PIKA_FORWARD(Sender, sender));
+        allocator_traits::construct(
+            alloc, p.get(), init_no_addref{}, alloc, PIKA_FORWARD(Sender, sender));
 
-        return pika::traits::future_access<future<result_type>>::create(
-            p.release(), false);
+        return pika::traits::future_access<future<result_type>>::create(p.release(), false);
     }
 }    // namespace pika::make_future_detail
 
@@ -253,12 +232,10 @@ namespace pika::execution::experimental {
                 pika::detail::is_allocator_v<Allocator>
             )>
         // clang-format on
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(make_future_t, Sender&& sender,
-            Allocator const& allocator = Allocator{})
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
+            make_future_t, Sender&& sender, Allocator const& allocator = Allocator{})
         {
-            return make_future_detail::make_future(
-                PIKA_FORWARD(Sender, sender), allocator);
+            return make_future_detail::make_future(PIKA_FORWARD(Sender, sender), allocator);
         }
 
         // clang-format off
@@ -267,11 +244,10 @@ namespace pika::execution::experimental {
                 pika::detail::is_allocator_v<Allocator>
             )>
         // clang-format on
-        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
-            make_future_t, Allocator const& allocator = Allocator{})
+        friend constexpr PIKA_FORCEINLINE auto
+        tag_fallback_invoke(make_future_t, Allocator const& allocator = Allocator{})
         {
-            return detail::partial_algorithm<make_future_t, Allocator>{
-                allocator};
+            return detail::partial_algorithm<make_future_t, Allocator>{allocator};
         }
     } make_future{};
 }    // namespace pika::execution::experimental
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 248d752b9a..79dc58ae3e 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
@@ -9,26 +9,26 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #else
-#include <pika/concepts/concepts.hpp>
-#include <pika/datastructures/variant.hpp>
-#include <pika/execution_base/completion_scheduler.hpp>
-#include <pika/execution_base/receiver.hpp>
-#include <pika/execution_base/sender.hpp>
-#include <pika/functional/bind_front.hpp>
-#include <pika/functional/detail/tag_fallback_invoke.hpp>
-#include <pika/functional/invoke_fused.hpp>
-#include <pika/type_support/detail/with_result_of.hpp>
-#include <pika/type_support/pack.hpp>
-
-#include <atomic>
-#include <cstddef>
-#include <exception>
-#include <optional>
-#include <tuple>
-#include <type_traits>
-#include <utility>
+# include <pika/concepts/concepts.hpp>
+# include <pika/datastructures/variant.hpp>
+# include <pika/execution_base/completion_scheduler.hpp>
+# include <pika/execution_base/receiver.hpp>
+# include <pika/execution_base/sender.hpp>
+# include <pika/functional/bind_front.hpp>
+# include <pika/functional/detail/tag_fallback_invoke.hpp>
+# include <pika/functional/invoke_fused.hpp>
+# include <pika/type_support/detail/with_result_of.hpp>
+# include <pika/type_support/pack.hpp>
+
+# include <atomic>
+# include <cstddef>
+# include <exception>
+# include <optional>
+# include <tuple>
+# include <type_traits>
+# include <utility>
 
 namespace pika::schedule_from_detail {
     template <typename Sender, typename Scheduler>
@@ -38,39 +38,34 @@ namespace pika::schedule_from_detail {
     };
 
     template <typename Sender, typename Scheduler>
-    using schedule_from_sender = typename schedule_from_sender_impl<Sender,
-        Scheduler>::schedule_from_sender_type;
+    using schedule_from_sender =
+        typename schedule_from_sender_impl<Sender, Scheduler>::schedule_from_sender_type;
 
     template <typename Sender, typename Scheduler>
-    struct schedule_from_sender_impl<Sender,
-        Scheduler>::schedule_from_sender_type
+    struct schedule_from_sender_impl<Sender, Scheduler>::schedule_from_sender_type
     {
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Sender> predecessor_sender;
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types =
-            typename pika::execution::experimental::sender_traits<
-                Sender>::template value_types<Tuple, Variant>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = typename pika::execution::experimental::sender_traits<
+            Sender>::template value_types<Tuple, Variant>;
 
         template <template <typename...> class Variant>
         using predecessor_sender_error_types =
-            typename pika::execution::experimental::sender_traits<
-                Sender>::template error_types<Variant>;
+            typename pika::execution::experimental::sender_traits<Sender>::template error_types<
+                Variant>;
 
         using scheduler_sender_type =
-            std::invoke_result_t<pika::execution::experimental::schedule_t,
-                Scheduler>;
+            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<
-                scheduler_sender_type>::template error_types<Variant>;
+        using scheduler_sender_error_types = typename pika::execution::experimental::sender_traits<
+            scheduler_sender_type>::template error_types<Variant>;
 
         template <template <typename...> class Variant>
-        using error_types = pika::util::detail::unique_concat_t<
-            predecessor_sender_error_types<Variant>,
-            scheduler_sender_error_types<Variant>>;
+        using error_types =
+            pika::util::detail::unique_concat_t<predecessor_sender_error_types<Variant>,
+                scheduler_sender_error_types<Variant>>;
 
         static constexpr bool sends_done = false;
 
@@ -80,27 +75,24 @@ namespace pika::schedule_from_detail {
             PIKA_NO_UNIQUE_ADDRESS Env e;
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
 
-            friend auto tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<
-                    pika::execution::experimental::set_value_t>,
+            friend auto tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
+                                       pika::execution::experimental::set_value_t>,
                 env const& e) noexcept
             {
                 return e.scheduler;
             }
 
-            template <typename Tag,
-                PIKA_CONCEPT_REQUIRES_(std::is_invocable_v<Tag, env const&>)>
+            template <typename Tag, PIKA_CONCEPT_REQUIRES_(std::is_invocable_v<Tag, env const&>)>
             friend decltype(auto) tag_invoke(Tag, env const& e)
             {
                 return Tag{}(e.e);
             }
         };
 
-        friend auto tag_invoke(pika::execution::experimental::get_env_t,
-            schedule_from_sender_type const& s)
+        friend auto tag_invoke(
+            pika::execution::experimental::get_env_t, schedule_from_sender_type const& s)
         {
-            auto e =
-                pika::execution::experimental::get_env(s.predecessor_sender);
+            auto e = pika::execution::experimental::get_env(s.predecessor_sender);
             return env<std::decay_t<decltype(e)>>{std::move(e), s.scheduler};
         }
 
@@ -122,8 +114,7 @@ namespace pika::schedule_from_detail {
             using value_type = pika::util::detail::prepend_t<
                 pika::util::detail::transform_t<
                     typename pika::execution::experimental::sender_traits<
-                        Sender>::template value_types<std::tuple,
-                        pika::detail::variant>,
+                        Sender>::template value_types<std::tuple, pika::detail::variant>,
                     value_types_helper>,
                 pika::detail::monostate>;
             value_type ts;
@@ -133,21 +124,18 @@ namespace pika::schedule_from_detail {
                     predecessor_sender_receiver>;
             sender_operation_state_type sender_os;
 
-            using scheduler_operation_state_type =
-                pika::execution::experimental::connect_result_t<
-                    std::invoke_result_t<
-                        pika::execution::experimental::schedule_t, Scheduler>,
-                    scheduler_sender_receiver>;
+            using scheduler_operation_state_type = pika::execution::experimental::connect_result_t<
+                std::invoke_result_t<pika::execution::experimental::schedule_t, Scheduler>,
+                scheduler_sender_receiver>;
             std::optional<scheduler_operation_state_type> scheduler_op_state;
 
             template <typename Sender_, typename Scheduler_, typename Receiver_>
-            operation_state(Sender_&& predecessor_sender,
-                Scheduler_&& scheduler, Receiver_&& receiver)
+            operation_state(
+                Sender_&& predecessor_sender, Scheduler_&& scheduler, Receiver_&& receiver)
               : scheduler(PIKA_FORWARD(Scheduler_, scheduler))
               , receiver(PIKA_FORWARD(Receiver_, receiver))
               , sender_os(pika::execution::experimental::connect(
-                    PIKA_FORWARD(Sender_, predecessor_sender),
-                    predecessor_sender_receiver{*this}))
+                    PIKA_FORWARD(Sender_, predecessor_sender), predecessor_sender_receiver{*this}))
             {
             }
 
@@ -161,16 +149,13 @@ namespace pika::schedule_from_detail {
                 operation_state& op_state;
 
                 template <typename Error>
-                friend void
-                tag_invoke(pika::execution::experimental::set_error_t,
+                friend void tag_invoke(pika::execution::experimental::set_error_t,
                     predecessor_sender_receiver&& r, Error&& error) noexcept
                 {
-                    r.op_state.set_error_predecessor_sender(
-                        PIKA_FORWARD(Error, error));
+                    r.op_state.set_error_predecessor_sender(PIKA_FORWARD(Error, error));
                 }
 
-                friend void tag_invoke(
-                    pika::execution::experimental::set_stopped_t,
+                friend void tag_invoke(pika::execution::experimental::set_stopped_t,
                     predecessor_sender_receiver&& r) noexcept
                 {
                     r.op_state.set_stopped_predecessor_sender();
@@ -182,30 +167,25 @@ namespace pika::schedule_from_detail {
                 template <typename Tuple>
                 struct value_types_helper
                 {
-                    using type =
-                        pika::util::detail::transform_t<Tuple, std::decay>;
+                    using type = pika::util::detail::transform_t<Tuple, std::decay>;
                 };
 
                 using value_type = pika::util::detail::prepend_t<
                     pika::util::detail::transform_t<
                         typename pika::execution::experimental::sender_traits<
-                            Sender>::template value_types<std::tuple,
-                            pika::detail::variant>,
+                            Sender>::template value_types<std::tuple, pika::detail::variant>,
                         value_types_helper>,
                     pika::detail::monostate>;
 
                 template <typename... Ts>
-                friend auto
-                tag_invoke(pika::execution::experimental::set_value_t,
+                friend auto tag_invoke(pika::execution::experimental::set_value_t,
                     predecessor_sender_receiver&& r, Ts&&... ts) noexcept
                     -> decltype(std::declval<value_type>()
-                                    .template emplace<
-                                        std::tuple<std::decay_t<Ts>...>>(
+                                    .template emplace<std::tuple<std::decay_t<Ts>...>>(
                                         PIKA_FORWARD(Ts, ts)...),
                         void())
                 {
-                    r.op_state.set_value_predecessor_sender(
-                        PIKA_FORWARD(Ts, ts)...);
+                    r.op_state.set_value_predecessor_sender(PIKA_FORWARD(Ts, ts)...);
                 }
             };
 
@@ -224,30 +204,25 @@ namespace pika::schedule_from_detail {
             template <typename... Us>
             void set_value_predecessor_sender(Us&&... us) noexcept
             {
-                ts.template emplace<std::tuple<std::decay_t<Us>...>>(
-                    PIKA_FORWARD(Us, us)...);
-#if defined(PIKA_HAVE_CXX17_COPY_ELISION)
+                ts.template emplace<std::tuple<std::decay_t<Us>...>>(PIKA_FORWARD(Us, us)...);
+# if defined(PIKA_HAVE_CXX17_COPY_ELISION)
                 // with_result_of is used to emplace the operation
                 // state returned from connect without any
                 // intermediate copy construction (the operation
                 // state is not required to be copyable nor movable).
                 scheduler_op_state.emplace(pika::detail::with_result_of([&]() {
                     return pika::execution::experimental::connect(
-                        pika::execution::experimental::schedule(
-                            PIKA_MOVE(scheduler)),
+                        pika::execution::experimental::schedule(PIKA_MOVE(scheduler)),
                         scheduler_sender_receiver{*this});
                 }));
-#else
+# else
                 // MSVC doesn't get copy elision quite right, the operation
                 // state must be constructed explicitly directly in place
-                scheduler_op_state.emplace_f(
-                    pika::execution::experimental::connect,
-                    pika::execution::experimental::schedule(
-                        PIKA_MOVE(scheduler)),
+                scheduler_op_state.emplace_f(pika::execution::experimental::connect,
+                    pika::execution::experimental::schedule(PIKA_MOVE(scheduler)),
                     scheduler_sender_receiver{*this});
-#endif
-                pika::execution::experimental::start(
-                    scheduler_op_state.value());
+# endif
+                pika::execution::experimental::start(scheduler_op_state.value());
             }
 
             struct scheduler_sender_receiver
@@ -255,23 +230,19 @@ namespace pika::schedule_from_detail {
                 operation_state& op_state;
 
                 template <typename Error>
-                friend void
-                tag_invoke(pika::execution::experimental::set_error_t,
+                friend void tag_invoke(pika::execution::experimental::set_error_t,
                     scheduler_sender_receiver&& r, Error&& error) noexcept
                 {
-                    r.op_state.set_error_scheduler_sender(
-                        PIKA_FORWARD(Error, error));
+                    r.op_state.set_error_scheduler_sender(PIKA_FORWARD(Error, error));
                 }
 
-                friend void tag_invoke(
-                    pika::execution::experimental::set_stopped_t,
+                friend void tag_invoke(pika::execution::experimental::set_stopped_t,
                     scheduler_sender_receiver&& r) noexcept
                 {
                     r.op_state.set_stopped_scheduler_sender();
                 }
 
-                friend void tag_invoke(
-                    pika::execution::experimental::set_value_t,
+                friend void tag_invoke(pika::execution::experimental::set_value_t,
                     scheduler_sender_receiver&& r) noexcept
                 {
                     r.op_state.set_value_scheduler_sender();
@@ -288,14 +259,13 @@ namespace pika::schedule_from_detail {
                 }
 
                 template <typename Ts,
-                    typename = std::enable_if_t<!std::is_same_v<
-                        std::decay_t<Ts>, pika::detail::monostate>>>
+                    typename = std::enable_if_t<
+                        !std::is_same_v<std::decay_t<Ts>, pika::detail::monostate>>>
                 void operator()(Ts&& ts)
                 {
                     pika::util::detail::invoke_fused(
                         pika::util::detail::bind_front(
-                            pika::execution::experimental::set_value,
-                            PIKA_MOVE(receiver)),
+                            pika::execution::experimental::set_value, PIKA_MOVE(receiver)),
                         PIKA_FORWARD(Ts, ts));
                 }
             };
@@ -318,20 +288,18 @@ namespace pika::schedule_from_detail {
             {
                 scheduler_op_state.reset();
                 pika::detail::visit(
-                    scheduler_sender_value_visitor{PIKA_MOVE(receiver)},
-                    PIKA_MOVE(ts));
+                    scheduler_sender_value_visitor{PIKA_MOVE(receiver)}, PIKA_MOVE(ts));
             }
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::start(os.sender_os);
             }
         };
 
         template <typename Receiver>
-        friend operation_state<Receiver>
-        tag_invoke(pika::execution::experimental::connect_t,
+        friend operation_state<Receiver> tag_invoke(pika::execution::experimental::connect_t,
             schedule_from_sender_type&& s, Receiver&& receiver)
         {
             return {PIKA_MOVE(s.predecessor_sender), PIKA_MOVE(s.scheduler),
@@ -339,12 +307,10 @@ namespace pika::schedule_from_detail {
         }
 
         template <typename Receiver>
-        friend operation_state<Receiver>
-        tag_invoke(pika::execution::experimental::connect_t,
+        friend operation_state<Receiver> tag_invoke(pika::execution::experimental::connect_t,
             schedule_from_sender_type const& s, Receiver&& receiver)
         {
-            return {s.predecessor_sender, s.scheduler,
-                PIKA_FORWARD(Receiver, receiver)};
+            return {s.predecessor_sender, s.scheduler, PIKA_FORWARD(Receiver, receiver)};
         }
     };
 }    // namespace pika::schedule_from_detail
@@ -360,12 +326,11 @@ namespace pika::execution::experimental {
                 is_sender_v<Sender>
             )>
         // clang-format on
-        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
-            schedule_from_t, Scheduler&& scheduler, Sender&& predecessor_sender)
+        friend constexpr PIKA_FORCEINLINE auto
+        tag_fallback_invoke(schedule_from_t, Scheduler&& scheduler, Sender&& predecessor_sender)
         {
-            return schedule_from_detail::schedule_from_sender<Sender,
-                Scheduler>{PIKA_FORWARD(Sender, predecessor_sender),
-                PIKA_FORWARD(Scheduler, scheduler)};
+            return schedule_from_detail::schedule_from_sender<Sender, Scheduler>{
+                PIKA_FORWARD(Sender, predecessor_sender), PIKA_FORWARD(Scheduler, scheduler)};
         }
     } schedule_from{};
 }    // namespace pika::execution::experimental
diff --git a/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp b/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
index 91855dd935..24ee2e4b27 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/split_tuple.hpp
@@ -47,8 +47,7 @@ namespace pika::split_tuple_detail {
         template <typename Error>
         void operator()(Error const& error)
         {
-            pika::execution::experimental::set_error(
-                PIKA_MOVE(receiver), error);
+            pika::execution::experimental::set_error(PIKA_MOVE(receiver), error);
         }
     };
 
@@ -57,8 +56,8 @@ namespace pika::split_tuple_detail {
     {
         struct split_tuple_receiver;
 
-        using allocator_type = typename std::allocator_traits<
-            Allocator>::template rebind_alloc<shared_state>;
+        using allocator_type =
+            typename std::allocator_traits<Allocator>::template rebind_alloc<shared_state>;
         PIKA_NO_UNIQUE_ADDRESS allocator_type alloc;
         using mutex_type = pika::spinlock;
         mutex_type mtx;
@@ -66,9 +65,8 @@ namespace pika::split_tuple_detail {
         std::atomic<bool> start_called{false};
         std::atomic<bool> predecessor_done{false};
 
-        using operation_state_type =
-            std::decay_t<pika::execution::experimental::connect_result_t<Sender,
-                split_tuple_receiver>>;
+        using operation_state_type = std::decay_t<
+            pika::execution::experimental::connect_result_t<Sender, split_tuple_receiver>>;
         // We store the operation state in an optional so that we can reset
         // it as soon as the the split_tuple_receiver has been signaled.
         // This is useful to ensure that resources held by the predecessor
@@ -78,44 +76,38 @@ namespace pika::split_tuple_detail {
         // nvcc does not like decay_t, so this uses decay<>::type instead.
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         using value_type = typename std::decay<
-            pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::empty_env,
-                    pika::util::detail::pack, pika::util::detail::pack>>>::type;
+            pika::execution::experimental::detail::single_result_t<typename pika::execution::
+                    experimental::value_types_of_t<Sender, pika::execution::experimental::empty_env,
+                        pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #else
-        using value_type = typename std::decay<
-            pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template value_types<pika::util::detail::pack,
-                    pika::util::detail::pack>>>::type;
+        using value_type =
+            typename std::decay<pika::execution::experimental::detail::single_result_t<
+                typename pika::execution::experimental::sender_traits<Sender>::template value_types<
+                    pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #endif
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-        using error_type =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                pika::util::detail::transform_t<
-                    typename pika::execution::experimental::error_types_of_t<
-                        Sender, pika::execution::experimental::empty_env,
-                        pika::detail::variant>,
-                    std::decay>,
-                std::exception_ptr>>;
+        using error_type = pika::util::detail::unique_t<pika::util::detail::prepend_t<
+            pika::util::detail::transform_t<
+                typename pika::execution::experimental::error_types_of_t<Sender,
+                    pika::execution::experimental::empty_env, pika::detail::variant>,
+                std::decay>,
+            std::exception_ptr>>;
 #else
-        using error_type =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                pika::util::detail::transform_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template error_types<pika::detail::variant>,
-                    std::decay>,
-                std::exception_ptr>>;
+        using error_type = pika::util::detail::unique_t<pika::util::detail::prepend_t<
+            pika::util::detail::transform_t<
+                typename pika::execution::experimental::sender_traits<Sender>::template error_types<
+                    pika::detail::variant>,
+                std::decay>,
+            std::exception_ptr>>;
 #endif
-        pika::detail::variant<pika::detail::monostate,
-            pika::execution::detail::stopped_type, error_type, value_type>
+        pika::detail::variant<pika::detail::monostate, pika::execution::detail::stopped_type,
+            error_type, value_type>
             v;
 
         using continuation_type = pika::util::detail::unique_function<void()>;
 
-        std::array<continuation_type, std::tuple_size_v<value_type>>
-            continuations;
+        std::array<continuation_type, std::tuple_size_v<value_type>> continuations;
 
         struct split_tuple_receiver
         {
@@ -127,13 +119,12 @@ namespace pika::split_tuple_detail {
             friend void tag_invoke(pika::execution::experimental::set_error_t,
                 split_tuple_receiver&& r, Error&& error) noexcept
             {
-                r.state.v.template emplace<error_type>(
-                    error_type(PIKA_FORWARD(Error, error)));
+                r.state.v.template emplace<error_type>(error_type(PIKA_FORWARD(Error, error)));
                 r.state.set_predecessor_done();
             }
 
-            friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-                split_tuple_receiver&& r) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::set_stopped_t, split_tuple_receiver&& r) noexcept
             {
                 r.state.set_predecessor_done();
             };
@@ -142,27 +133,25 @@ namespace pika::split_tuple_detail {
                 // parent typedef is not instantiated early enough for use
                 // here.
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-            using value_type = typename std::decay<
-                pika::execution::experimental::detail::single_result_t<
-                    typename pika::execution::experimental::value_types_of_t<
-                        Sender, pika::execution::experimental::empty_env,
-                        pika::util::detail::pack, pika::util::detail::pack>>>::
-                type;
-#else
-            using value_type = typename std::decay<
-                pika::execution::experimental::detail::single_result_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template value_types<pika::util::detail::pack,
+            using value_type =
+                typename std::decay<pika::execution::experimental::detail::single_result_t<
+                    typename pika::execution::experimental::value_types_of_t<Sender,
+                        pika::execution::experimental::empty_env, pika::util::detail::pack,
                         pika::util::detail::pack>>>::type;
+#else
+            using value_type =
+                typename std::decay<pika::execution::experimental::detail::single_result_t<
+                    typename pika::execution::experimental::sender_traits<Sender>::
+                        template value_types<pika::util::detail::pack, pika::util::detail::pack>>>::
+                    type;
 #endif
 
             template <typename T>
             friend auto tag_invoke(pika::execution::experimental::set_value_t,
                 split_tuple_receiver&& r, T&& t) noexcept
-                -> decltype(std::declval<pika::detail::variant<
-                                pika::detail::monostate, value_type>>()
-                                .template emplace<value_type>(
-                                    PIKA_FORWARD(T, t)),
+                -> decltype(std::declval<
+                                pika::detail::variant<pika::detail::monostate, value_type>>()
+                                .template emplace<value_type>(PIKA_FORWARD(T, t)),
                     void())
             {
                 r.state.v.template emplace<value_type>(PIKA_FORWARD(T, t));
@@ -170,17 +159,15 @@ namespace pika::split_tuple_detail {
                 r.state.set_predecessor_done();
             }
 
-            friend constexpr pika::execution::experimental::empty_env
-            tag_invoke(pika::execution::experimental::get_env_t,
-                split_tuple_receiver const&) noexcept
+            friend constexpr pika::execution::experimental::empty_env tag_invoke(
+                pika::execution::experimental::get_env_t, split_tuple_receiver const&) noexcept
             {
                 return {};
             }
         };
 
         template <typename Sender_,
-            typename = std::enable_if_t<
-                !std::is_same<std::decay_t<Sender_>, shared_state>::value>>
+            typename = std::enable_if_t<!std::is_same<std::decay_t<Sender_>, shared_state>::value>>
         shared_state(Sender_&& sender, allocator_type const& alloc)
           : alloc(alloc)
         {
@@ -215,14 +202,12 @@ namespace pika::split_tuple_detail {
                     pika::execution::experimental::sends_stopped<Sender,
                         pika::execution::experimental::empty_env>
 #else
-                    pika::execution::experimental::sender_traits<
-                        Sender>::sends_done
+                    pika::execution::experimental::sender_traits<Sender>::sends_done
 #endif
                     ;
                 if constexpr (sends_stopped)
                 {
-                    pika::execution::experimental::set_stopped(
-                        PIKA_MOVE(receiver));
+                    pika::execution::experimental::set_stopped(PIKA_MOVE(receiver));
                 }
                 else
                 {
@@ -233,8 +218,7 @@ namespace pika::split_tuple_detail {
             void operator()(error_type const& error)
             {
                 pika::detail::visit(
-                    error_visitor<Receiver>{PIKA_FORWARD(Receiver, receiver)},
-                    error);
+                    error_visitor<Receiver>{PIKA_FORWARD(Receiver, receiver)}, error);
             }
 
             void operator()(value_type& t)
@@ -321,8 +305,7 @@ namespace pika::split_tuple_detail {
                 // values/errors have been stored into the shared state.
                 // We can trigger the continuation directly.
                 pika::detail::visit(
-                    stopped_error_value_visitor<Index, Receiver>{
-                        PIKA_FORWARD(Receiver, receiver)},
+                    stopped_error_value_visitor<Index, Receiver>{PIKA_FORWARD(Receiver, receiver)},
                     v);
             }
             else
@@ -339,9 +322,8 @@ namespace pika::split_tuple_detail {
                     // release the lock early and call the continuation
                     // directly again.
                     l.unlock();
-                    pika::detail::visit(
-                        stopped_error_value_visitor<Index, Receiver>{
-                            PIKA_FORWARD(Receiver, receiver)},
+                    pika::detail::visit(stopped_error_value_visitor<Index, Receiver>{PIKA_FORWARD(
+                                            Receiver, receiver)},
                         v);
                 }
                 else
@@ -354,12 +336,10 @@ namespace pika::split_tuple_detail {
                     // itself. The continuation will be called later
                     // when set_error/set_stopped/set_value is called.
                     continuations[Index] = [this,
-                                               receiver = PIKA_FORWARD(Receiver,
-                                                   receiver)]() mutable {
+                                               receiver =
+                                                   PIKA_FORWARD(Receiver, receiver)]() mutable {
                         pika::detail::visit(
-                            stopped_error_value_visitor<Index, Receiver>{
-                                PIKA_MOVE(receiver)},
-                            v);
+                            stopped_error_value_visitor<Index, Receiver>{PIKA_MOVE(receiver)}, v);
                     };
                 }
             }
@@ -385,8 +365,7 @@ namespace pika::split_tuple_detail {
             {
                 allocator_type other_alloc(p->alloc);
                 std::allocator_traits<allocator_type>::destroy(other_alloc, p);
-                std::allocator_traits<allocator_type>::deallocate(
-                    other_alloc, p, 1);
+                std::allocator_traits<allocator_type>::deallocate(other_alloc, p, 1);
             }
         }
     };
@@ -398,12 +377,11 @@ namespace pika::split_tuple_detail {
     };
 
     template <typename Sender, typename Allocator, std::size_t Index>
-    using split_tuple_sender = typename split_tuple_sender_impl<Sender,
-        Allocator, Index>::split_tuple_sender_type;
+    using split_tuple_sender =
+        typename split_tuple_sender_impl<Sender, Allocator, Index>::split_tuple_sender_type;
 
     template <typename Sender, typename Allocator, std::size_t Index>
-    struct split_tuple_sender_impl<Sender, Allocator,
-        Index>::split_tuple_sender_type
+    struct split_tuple_sender_impl<Sender, Allocator, Index>::split_tuple_sender_type
     {
         using is_sender = void;
 
@@ -413,22 +391,19 @@ namespace pika::split_tuple_detail {
         // nvcc does not like decay_t, so this uses decay<>::type instead.
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         using value_type = typename std::decay<
-            pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::empty_env,
-                    pika::util::detail::pack, pika::util::detail::pack>>>::type;
+            pika::execution::experimental::detail::single_result_t<typename pika::execution::
+                    experimental::value_types_of_t<Sender, pika::execution::experimental::empty_env,
+                        pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #else
-        using value_type = typename std::decay<
-            pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template value_types<pika::util::detail::pack,
-                    pika::util::detail::pack>>>::type;
+        using value_type =
+            typename std::decay<pika::execution::experimental::detail::single_result_t<
+                typename pika::execution::experimental::sender_traits<Sender>::template value_types<
+                    pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #endif
         static_assert(std::tuple_size_v<value_type> >= 1,
             "split_tuple takes a sender that sends a tuple of at least one "
             "type");
-        using split_tuple_sender_value_type =
-            std::decay_t<std::tuple_element_t<Index, value_type>>;
+        using split_tuple_sender_value_type = std::decay_t<std::tuple_element_t<Index, value_type>>;
 
         template <typename T>
         struct add_const_lvalue_reference
@@ -438,37 +413,30 @@ namespace pika::split_tuple_detail {
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         template <typename...>
-        using set_value_helper =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t(
-                    split_tuple_sender_value_type)>;
+        using set_value_helper = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t(split_tuple_sender_value_type)>;
 
         template <typename T>
-        using set_error_helper =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_error_t(
-                    typename add_const_lvalue_reference<T>::type)>;
+        using set_error_helper = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_error_t(
+                typename add_const_lvalue_reference<T>::type)>;
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<Sender,
                 pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_error_t(
-                        std::exception_ptr)>,
+                    pika::execution::experimental::set_error_t(std::exception_ptr)>,
                 set_value_helper, set_error_helper>;
 #else
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         using value_types = Variant<Tuple<split_tuple_sender_value_type>>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                pika::util::detail::transform_t<
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template error_types<Variant>,
-                    add_const_lvalue_reference>,
-                std::exception_ptr>>;
+        using error_types = pika::util::detail::unique_t<pika::util::detail::prepend_t<
+            pika::util::detail::transform_t<typename pika::execution::experimental::sender_traits<
+                                                Sender>::template error_types<Variant>,
+                add_const_lvalue_reference>,
+            std::exception_ptr>>;
 
         static constexpr bool sends_done =
             pika::execution::experimental::sender_traits<Sender>::sends_done;
@@ -476,15 +444,13 @@ namespace pika::split_tuple_detail {
 
         pika::intrusive_ptr<shared_state_type> state;
 
-        explicit split_tuple_sender_type(
-            pika::intrusive_ptr<shared_state_type> state)
+        explicit split_tuple_sender_type(pika::intrusive_ptr<shared_state_type> state)
           : state(std::move(state))
         {
         }
 
         split_tuple_sender_type(split_tuple_sender_type const&) = default;
-        split_tuple_sender_type& operator=(
-            split_tuple_sender_type const&) = default;
+        split_tuple_sender_type& operator=(split_tuple_sender_type const&) = default;
         split_tuple_sender_type(split_tuple_sender_type&&) = default;
         split_tuple_sender_type& operator=(split_tuple_sender_type&&) = default;
 
@@ -495,8 +461,7 @@ namespace pika::split_tuple_detail {
             pika::intrusive_ptr<shared_state_type> state;
 
             template <typename Receiver_>
-            operation_state(Receiver_&& receiver,
-                pika::intrusive_ptr<shared_state_type> state)
+            operation_state(Receiver_&& receiver, pika::intrusive_ptr<shared_state_type> state)
               : receiver(PIKA_FORWARD(Receiver_, receiver))
               , state(PIKA_MOVE(state))
             {
@@ -507,27 +472,24 @@ namespace pika::split_tuple_detail {
             operation_state(operation_state const&) = delete;
             operation_state& operator=(operation_state const&) = delete;
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 os.state->start();
-                os.state->template add_continuation<Index>(
-                    PIKA_MOVE(os.receiver));
+                os.state->template add_continuation<Index>(PIKA_MOVE(os.receiver));
             }
         };
 
         template <typename Receiver>
-        friend operation_state<Receiver>
-        tag_invoke(pika::execution::experimental::connect_t,
+        friend operation_state<Receiver> tag_invoke(pika::execution::experimental::connect_t,
             split_tuple_sender_type&& s, Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.state)};
         }
 
         template <typename Receiver>
-        friend operation_state<Receiver>
-        tag_invoke(pika::execution::experimental::connect_t,
-            split_tuple_sender_type const&, Receiver&&)
+        friend operation_state<Receiver> tag_invoke(
+            pika::execution::experimental::connect_t, split_tuple_sender_type const&, Receiver&&)
         {
             static_assert(sizeof(Receiver) == 0,
                 "Are you missing a std::move? The split_tuple sender is not "
@@ -537,8 +499,7 @@ namespace pika::split_tuple_detail {
     };
 
     template <typename Sender, typename Allocator, std::size_t... Is>
-    auto make_split_tuple_senders(
-        pika::intrusive_ptr<shared_state<Sender, Allocator>> state,
+    auto make_split_tuple_senders(pika::intrusive_ptr<shared_state<Sender, Allocator>> state,
         pika::util::detail::index_pack<Is...>)
     {
         return std::tuple(split_tuple_sender<Sender, Allocator, Is>(state)...);
@@ -553,38 +514,34 @@ namespace pika::split_tuple_detail {
         using other_allocator = typename std::allocator_traits<
             allocator_type>::template rebind_alloc<shared_state_type>;
         using allocator_traits = std::allocator_traits<other_allocator>;
-        using unique_ptr = std::unique_ptr<shared_state_type,
-            pika::detail::allocator_deleter<other_allocator>>;
+        using unique_ptr =
+            std::unique_ptr<shared_state_type, pika::detail::allocator_deleter<other_allocator>>;
 
         other_allocator alloc(allocator);
         unique_ptr p(allocator_traits::allocate(alloc, 1),
             pika::detail::allocator_deleter<other_allocator>{alloc});
 
-        new (p.get())
-            shared_state_type{PIKA_FORWARD(Sender_, sender), allocator};
+        new (p.get()) shared_state_type{PIKA_FORWARD(Sender_, sender), allocator};
         pika::intrusive_ptr<shared_state_type> state = p.release();
 
         // nvcc does not like decay_t, so this uses decay<>::type instead.
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         using value_type = typename std::decay<
-            pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::empty_env,
-                    pika::util::detail::pack, pika::util::detail::pack>>>::type;
+            pika::execution::experimental::detail::single_result_t<typename pika::execution::
+                    experimental::value_types_of_t<Sender, pika::execution::experimental::empty_env,
+                        pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #else
-        using value_type = typename std::decay<
-            pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template value_types<pika::util::detail::pack,
-                    pika::util::detail::pack>>>::type;
+        using value_type =
+            typename std::decay<pika::execution::experimental::detail::single_result_t<
+                typename pika::execution::experimental::sender_traits<Sender>::template value_types<
+                    pika::util::detail::pack, pika::util::detail::pack>>>::type;
 #endif
 
         // nvcc does not like tuple_size_v, so this uses tuple_size<>::value
         // instead.
-        return make_split_tuple_senders<std::decay_t<Sender>,
-            std::decay_t<Allocator>>(std::move(state),
-            pika::util::detail::make_index_pack_t<
-                std::tuple_size<value_type>::value>{});
+        return make_split_tuple_senders<std::decay_t<Sender>, std::decay_t<Allocator>>(
+            std::move(state),
+            pika::util::detail::make_index_pack_t<std::tuple_size<value_type>::value>{});
     }
 }    // namespace pika::split_tuple_detail
 
@@ -601,19 +558,16 @@ namespace pika::execution::experimental {
     {
     private:
         template <typename Sender, PIKA_CONCEPT_REQUIRES_(is_sender_v<Sender>)>
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(split_tuple_t, Sender&& sender)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(split_tuple_t, Sender&& sender)
         {
             return split_tuple_detail::make_split_tuple_senders(
-                PIKA_FORWARD(Sender, sender),
-                pika::detail::internal_allocator<>{});
+                PIKA_FORWARD(Sender, sender), pika::detail::internal_allocator<>{});
         }
 
         template <typename Sender, typename Allocator,
-            PIKA_CONCEPT_REQUIRES_(
-                is_sender_v<Sender>&& pika::detail::is_allocator_v<Allocator>)>
-        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
-            split_tuple_t, Sender&& sender, Allocator const& allocator)
+            PIKA_CONCEPT_REQUIRES_(is_sender_v<Sender>&& pika::detail::is_allocator_v<Allocator>)>
+        friend constexpr PIKA_FORCEINLINE auto
+        tag_fallback_invoke(split_tuple_t, Sender&& sender, Allocator const& allocator)
         {
             return split_tuple_detail::make_split_tuple_senders(
                 PIKA_FORWARD(Sender, sender), allocator);
@@ -624,8 +578,7 @@ namespace pika::execution::experimental {
         friend constexpr PIKA_FORCEINLINE auto
         tag_fallback_invoke(split_tuple_t, Allocator const& allocator = {})
         {
-            return detail::partial_algorithm<split_tuple_t, Allocator>{
-                allocator};
+            return detail::partial_algorithm<split_tuple_t, Allocator>{allocator};
         }
     } split_tuple{};
 }    // namespace pika::execution::experimental
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 ac3b1ab60a..d08ea87f87 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/sync_wait.hpp
@@ -9,7 +9,7 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #endif
 
 #include <pika/concepts/concepts.hpp>
@@ -51,32 +51,26 @@ namespace pika::sync_wait_detail {
     };
 
     template <typename Sender>
-    using sync_wait_receiver =
-        typename sync_wait_receiver_impl<Sender>::sync_wait_receiver_type;
+    using sync_wait_receiver = typename sync_wait_receiver_impl<Sender>::sync_wait_receiver_type;
 
     template <typename Sender>
     struct sync_wait_receiver_impl<Sender>::sync_wait_receiver_type
     {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         // value and error_types of the predecessor sender
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using predecessor_value_types =
-            pika::execution::experimental::value_types_of_t<Sender,
-                pika::execution::experimental::empty_env, Tuple, Variant>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using predecessor_value_types = pika::execution::experimental::value_types_of_t<Sender,
+            pika::execution::experimental::empty_env, Tuple, Variant>;
 
         template <template <typename...> class Variant>
-        using predecessor_error_types =
-            pika::execution::experimental::error_types_of_t<Sender,
-                pika::execution::experimental::empty_env, Variant>;
+        using predecessor_error_types = pika::execution::experimental::error_types_of_t<Sender,
+            pika::execution::experimental::empty_env, Variant>;
 
         // The type of the single void or non-void result that we store. If
         // there are multiple variants or multiple values sync_wait will
         // fail to compile.
-        using result_type =
-            std::decay_t<pika::execution::experimental::detail::single_result_t<
-                predecessor_value_types<pika::util::detail::pack,
-                    pika::util::detail::pack>>>;
+        using result_type = std::decay_t<pika::execution::experimental::detail::single_result_t<
+            predecessor_value_types<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
@@ -89,36 +83,29 @@ namespace pika::sync_wait_detail {
 
         // The type of the value to store in the variant, void_value_type if
         // result_type is void, or result_type if it is not
-        using value_type =
-            std::conditional_t<is_void_result, void_value_type, result_type>;
+        using value_type = std::conditional_t<is_void_result, void_value_type, result_type>;
 
         // The type of errors to store in the variant. This in itself is a
         // variant.
-        using error_type =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                pika::util::detail::transform_t<
-                    predecessor_error_types<pika::detail::variant>, std::decay>,
-                std::exception_ptr>>;
+        using error_type = pika::util::detail::unique_t<pika::util::detail::prepend_t<
+            pika::util::detail::transform_t<predecessor_error_types<pika::detail::variant>,
+                std::decay>,
+            std::exception_ptr>>;
 #else
         // value and error_types of the predecessor sender
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using predecessor_value_types =
-            typename pika::execution::experimental::sender_traits<
-                Sender>::template value_types<Tuple, Variant>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using predecessor_value_types = typename pika::execution::experimental::sender_traits<
+            Sender>::template value_types<Tuple, Variant>;
 
         template <template <typename...> class Variant>
-        using predecessor_error_types =
-            typename pika::execution::experimental::sender_traits<
-                Sender>::template error_types<Variant>;
+        using predecessor_error_types = typename pika::execution::experimental::sender_traits<
+            Sender>::template error_types<Variant>;
 
         // The type of the single void or non-void result that we store. If
         // there are multiple variants or multiple values sync_wait will
         // fail to compile.
-        using result_type =
-            std::decay_t<pika::execution::experimental::detail::single_result_t<
-                predecessor_value_types<pika::util::detail::pack,
-                    pika::util::detail::pack>>>;
+        using result_type = std::decay_t<pika::execution::experimental::detail::single_result_t<
+            predecessor_value_types<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
@@ -131,16 +118,14 @@ namespace pika::sync_wait_detail {
 
         // The type of the value to store in the variant, void_value_type if
         // result_type is void, or result_type if it is not
-        using value_type =
-            std::conditional_t<is_void_result, void_value_type, result_type>;
+        using value_type = std::conditional_t<is_void_result, void_value_type, result_type>;
 
         // The type of errors to store in the variant. This in itself is a
         // variant.
-        using error_type =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                pika::util::detail::transform_t<
-                    predecessor_error_types<pika::detail::variant>, std::decay>,
-                std::exception_ptr>>;
+        using error_type = pika::util::detail::unique_t<pika::util::detail::prepend_t<
+            pika::util::detail::transform_t<predecessor_error_types<pika::detail::variant>,
+                std::decay>,
+            std::exception_ptr>>;
 #endif
 
         // We use a spinlock here to allow taking the lock on non-pika threads.
@@ -151,9 +136,7 @@ namespace pika::sync_wait_detail {
             pika::condition_variable cond_var;
             mutex_type mtx;
             std::atomic<bool> set_called = false;
-            pika::detail::variant<pika::detail::monostate, error_type,
-                value_type>
-                value;
+            pika::detail::variant<pika::detail::monostate, error_type, value_type> value;
 
             void wait()
             {
@@ -182,8 +165,8 @@ namespace pika::sync_wait_detail {
                 }
                 else if (pika::detail::holds_alternative<error_type>(value))
                 {
-                    pika::detail::visit(sync_wait_error_visitor{},
-                        pika::detail::get<error_type>(value));
+                    pika::detail::visit(
+                        sync_wait_error_visitor{}, pika::detail::get<error_type>(value));
                 }
 
                 // If the variant holds a pika::detail::monostate something has gone
@@ -198,8 +181,7 @@ namespace pika::sync_wait_detail {
         {
             std::unique_lock<mutex_type> l(state.mtx);
             state.set_called = true;
-            [[maybe_unused]] pika::util::ignore_while_checking<decltype(l)> il(
-                &l);
+            [[maybe_unused]] pika::util::ignore_while_checking<decltype(l)> il(&l);
 
             state.cond_var.notify_one();
         }
@@ -208,21 +190,19 @@ namespace pika::sync_wait_detail {
         friend void tag_invoke(pika::execution::experimental::set_error_t,
             sync_wait_receiver_type&& r, Error&& error) noexcept
         {
-            r.state.value.template emplace<error_type>(
-                PIKA_FORWARD(Error, error));
+            r.state.value.template emplace<error_type>(PIKA_FORWARD(Error, error));
             r.signal_set_called();
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-            sync_wait_receiver_type&& r) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_stopped_t, sync_wait_receiver_type&& r) noexcept
         {
             r.signal_set_called();
         }
 
         template <typename... Us,
-            typename =
-                std::enable_if_t<(is_void_result && sizeof...(Us) == 0) ||
-                    (!is_void_result && sizeof...(Us) == 1)>>
+            typename = std::enable_if_t<(is_void_result && sizeof...(Us) == 0) ||
+                (!is_void_result && sizeof...(Us) == 1)>>
         friend void tag_invoke(pika::execution::experimental::set_value_t,
             sync_wait_receiver_type&& r, Us&&... us) noexcept
         {
@@ -231,8 +211,7 @@ namespace pika::sync_wait_detail {
         }
 
         friend constexpr pika::execution::experimental::empty_env tag_invoke(
-            pika::execution::experimental::get_env_t,
-            sync_wait_receiver_type const&) noexcept
+            pika::execution::experimental::get_env_t, sync_wait_receiver_type const&) noexcept
         {
             return {};
         }
@@ -240,8 +219,7 @@ namespace pika::sync_wait_detail {
 }    // namespace pika::sync_wait_detail
 
 namespace pika::this_thread::experimental {
-    inline constexpr struct sync_wait_t final
-      : pika::functional::detail::tag_fallback<sync_wait_t>
+    inline constexpr struct sync_wait_t final : pika::functional::detail::tag_fallback<sync_wait_t>
     {
     private:
         // clang-format off
@@ -250,8 +228,7 @@ namespace pika::this_thread::experimental {
                 pika::execution::experimental::is_sender_v<Sender>
             )>
         // clang-format on
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(sync_wait_t, Sender&& sender)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(sync_wait_t, Sender&& sender)
         {
             using receiver_type = sync_wait_detail::sync_wait_receiver<Sender>;
             using state_type = typename receiver_type::shared_state;
diff --git a/libs/pika/execution/include/pika/execution/algorithms/then.hpp b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
index 479e69142f..453ccff433 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/then.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
@@ -9,21 +9,21 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #else
-#include <pika/concepts/concepts.hpp>
-#include <pika/errors/try_catch_exception_ptr.hpp>
-#include <pika/execution/algorithms/detail/partial_algorithm.hpp>
-#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>
-
-#include <exception>
-#include <type_traits>
-#include <utility>
+# include <pika/concepts/concepts.hpp>
+# include <pika/errors/try_catch_exception_ptr.hpp>
+# include <pika/execution/algorithms/detail/partial_algorithm.hpp>
+# 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>
+
+# include <exception>
+# include <type_traits>
+# include <utility>
 
 namespace pika::then_detail {
     template <typename Receiver, typename F>
@@ -33,8 +33,7 @@ namespace pika::then_detail {
     };
 
     template <typename Receiver, typename F>
-    using then_receiver =
-        typename then_receiver_impl<Receiver, F>::then_receiver_type;
+    using then_receiver = typename then_receiver_impl<Receiver, F>::then_receiver_type;
 
     template <typename Receiver, typename F>
     struct then_receiver_impl<Receiver, F>::then_receiver_type
@@ -43,15 +42,15 @@ namespace pika::then_detail {
         PIKA_NO_UNIQUE_ADDRESS std::decay_t<F> f;
 
         template <typename Error>
-        friend void tag_invoke(pika::execution::experimental::set_error_t,
-            then_receiver_type&& r, Error&& error) noexcept
+        friend void tag_invoke(pika::execution::experimental::set_error_t, then_receiver_type&& r,
+            Error&& error) noexcept
         {
             pika::execution::experimental::set_error(
                 PIKA_MOVE(r.receiver), PIKA_FORWARD(Error, error));
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-            then_receiver_type&& r) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_stopped_t, then_receiver_type&& r) noexcept
         {
             pika::execution::experimental::set_stopped(PIKA_MOVE(r.receiver));
         }
@@ -62,43 +61,38 @@ namespace pika::then_detail {
         {
             pika::detail::try_catch_exception_ptr(
                 [&]() {
-                    if constexpr (std::is_void_v<
-                                      std::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.
-#if defined(PIKA_GCC_VERSION) && (PIKA_GCC_VERSION < 100000)
+# if defined(PIKA_GCC_VERSION) && (PIKA_GCC_VERSION < 100000)
                         PIKA_INVOKE(std::move(f), PIKA_FORWARD(Ts, ts)...);
-#else
+# else
                         PIKA_INVOKE(PIKA_MOVE(f), PIKA_FORWARD(Ts, ts)...);
-#endif
-                        pika::execution::experimental::set_value(
-                            PIKA_MOVE(receiver));
+# endif
+                        pika::execution::experimental::set_value(PIKA_MOVE(receiver));
                     }
                     else
                     {
                     // Certain versions of GCC with optimizations fail on
                     // the move with an internal compiler error.
-#if defined(PIKA_GCC_VERSION) && (PIKA_GCC_VERSION < 100000)
-                        auto&& result =
-                            PIKA_INVOKE(std::move(f), PIKA_FORWARD(Ts, ts)...);
-#else
-                        auto&& result =
-                            PIKA_INVOKE(PIKA_MOVE(f), PIKA_FORWARD(Ts, ts)...);
-#endif
+# if defined(PIKA_GCC_VERSION) && (PIKA_GCC_VERSION < 100000)
+                        auto&& result = PIKA_INVOKE(std::move(f), PIKA_FORWARD(Ts, ts)...);
+# else
+                        auto&& result = PIKA_INVOKE(PIKA_MOVE(f), PIKA_FORWARD(Ts, ts)...);
+# endif
                         pika::execution::experimental::set_value(
                             PIKA_MOVE(receiver), PIKA_MOVE(result));
                     }
                 },
                 [&](std::exception_ptr ep) {
-                    pika::execution::experimental::set_error(
-                        PIKA_MOVE(receiver), PIKA_MOVE(ep));
+                    pika::execution::experimental::set_error(PIKA_MOVE(receiver), PIKA_MOVE(ep));
                 });
         }
 
         template <typename... Ts>
-        friend void tag_invoke(pika::execution::experimental::set_value_t,
-            then_receiver_type&& r, Ts&&... ts) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_value_t, then_receiver_type&& r, Ts&&... ts) noexcept
         {
             // GCC 7 fails with an internal compiler error unless the actual
             // body is in a helper function.
@@ -128,43 +122,38 @@ namespace pika::then_detail {
         struct invoke_result_helper<Tuple<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>>;
+            using type =
+                std::conditional_t<std::is_void<result_type>::value, Tuple<>, Tuple<result_type>>;
         };
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types =
-            pika::util::detail::unique_t<pika::util::detail::transform_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template value_types<Tuple, Variant>,
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = pika::util::detail::unique_t<
+            pika::util::detail::transform_t<typename pika::execution::experimental::sender_traits<
+                                                Sender>::template value_types<Tuple, Variant>,
                 invoke_result_helper>>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template error_types<Variant>,
+        using error_types = pika::util::detail::unique_t<
+            pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                              Sender>::template error_types<Variant>,
                 std::exception_ptr>>;
 
         static constexpr bool sends_done = false;
 
         template <typename Receiver>
-        friend auto tag_invoke(pika::execution::experimental::connect_t,
-            then_sender_type&& s, Receiver&& receiver)
+        friend auto tag_invoke(
+            pika::execution::experimental::connect_t, then_sender_type&& s, Receiver&& receiver)
         {
             return pika::execution::experimental::connect(PIKA_MOVE(s.sender),
-                then_receiver<Receiver, F>{
-                    PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f)});
+                then_receiver<Receiver, F>{PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(s.f)});
         }
 
         template <typename Receiver>
-        friend auto tag_invoke(pika::execution::experimental::connect_t,
-            then_sender_type const& r, Receiver&& receiver)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, then_sender_type const& r,
+            Receiver&& receiver)
         {
-            return pika::execution::experimental::connect(r.sender,
-                then_receiver<Receiver, F>{
-                    PIKA_FORWARD(Receiver, receiver), r.f});
+            return pika::execution::experimental::connect(
+                r.sender, then_receiver<Receiver, F>{PIKA_FORWARD(Receiver, receiver), r.f});
         }
 
         friend constexpr decltype(auto) tag_invoke(
@@ -176,8 +165,7 @@ namespace pika::then_detail {
 }    // namespace pika::then_detail
 
 namespace pika::execution::experimental {
-    inline constexpr struct then_t final
-      : pika::functional::detail::tag_fallback<then_t>
+    inline constexpr struct then_t final : pika::functional::detail::tag_fallback<then_t>
     {
     private:
         // clang-format off
@@ -186,16 +174,14 @@ namespace pika::execution::experimental {
                 is_sender_v<Sender>
             )>
         // clang-format on
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(then_t, Sender&& sender, F&& f)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(then_t, Sender&& sender, F&& f)
         {
             return then_detail::then_sender<Sender, F>{
                 PIKA_FORWARD(Sender, sender), PIKA_FORWARD(F, f)};
         }
 
         template <typename F>
-        friend constexpr PIKA_FORCEINLINE auto
-        tag_fallback_invoke(then_t, F&& f)
+        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(then_t, F&& f)
         {
             return detail::partial_algorithm<then_t, F>{PIKA_FORWARD(F, f)};
         }
diff --git a/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp b/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp
index ed09c1d9c7..c5e9a9ec8c 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/transfer.hpp
@@ -9,20 +9,19 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #else
-#include <pika/concepts/concepts.hpp>
-#include <pika/execution/algorithms/detail/partial_algorithm.hpp>
-#include <pika/execution_base/completion_scheduler.hpp>
-#include <pika/execution_base/receiver.hpp>
-#include <pika/execution_base/sender.hpp>
-#include <pika/functional/detail/tag_priority_invoke.hpp>
+# include <pika/concepts/concepts.hpp>
+# include <pika/execution/algorithms/detail/partial_algorithm.hpp>
+# include <pika/execution_base/completion_scheduler.hpp>
+# include <pika/execution_base/receiver.hpp>
+# include <pika/execution_base/sender.hpp>
+# include <pika/functional/detail/tag_priority_invoke.hpp>
 
-#include <utility>
+# include <utility>
 
 namespace pika::execution::experimental {
-    inline constexpr struct transfer_t final
-      : pika::functional::detail::tag_priority<transfer_t>
+    inline constexpr struct transfer_t final : pika::functional::detail::tag_priority<transfer_t>
     {
     private:
         // clang-format off
@@ -38,10 +37,9 @@ namespace pika::execution::experimental {
         friend constexpr PIKA_FORCEINLINE auto
         tag_override_invoke(transfer_t, Sender&& sender, Scheduler&& scheduler)
         {
-            auto completion_scheduler =
-                pika::execution::experimental::get_completion_scheduler<
-                    pika::execution::experimental::set_value_t>(
-                    pika::execution::experimental::get_env(sender));
+            auto completion_scheduler = pika::execution::experimental::get_completion_scheduler<
+                pika::execution::experimental::set_value_t>(
+                pika::execution::experimental::get_env(sender));
             return pika::functional::detail::tag_invoke(transfer_t{},
                 PIKA_MOVE(completion_scheduler), PIKA_FORWARD(Sender, sender),
                 PIKA_FORWARD(Scheduler, scheduler));
@@ -54,11 +52,11 @@ namespace pika::execution::experimental {
                 is_scheduler_v<Scheduler>
             )>
         // clang-format on
-        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
-            transfer_t, Sender&& predecessor_sender, Scheduler&& scheduler)
+        friend constexpr PIKA_FORCEINLINE auto
+        tag_fallback_invoke(transfer_t, Sender&& predecessor_sender, Scheduler&& scheduler)
         {
-            return schedule_from(PIKA_FORWARD(Scheduler, scheduler),
-                PIKA_FORWARD(Sender, predecessor_sender));
+            return schedule_from(
+                PIKA_FORWARD(Scheduler, scheduler), PIKA_FORWARD(Sender, predecessor_sender));
         }
 
         template <typename Scheduler>
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 ab2847aa53..f72d4f8fc1 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
@@ -9,7 +9,7 @@
 #include <pika/config.hpp>
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #endif
 
 #include <pika/assert.hpp>
@@ -41,8 +41,8 @@ namespace pika::when_all_vector_detail {
     };
 
     template <typename Sender>
-    using when_all_vector_sender = typename when_all_vector_sender_impl<
-        Sender>::when_all_vector_sender_type;
+    using when_all_vector_sender =
+        typename when_all_vector_sender_impl<Sender>::when_all_vector_sender_type;
 
     template <typename Sender>
     struct when_all_vector_sender_impl<Sender>::when_all_vector_sender_type
@@ -57,8 +57,7 @@ namespace pika::when_all_vector_detail {
         {
         }
 
-        explicit constexpr when_all_vector_sender_type(
-            senders_type const& senders)
+        explicit constexpr when_all_vector_sender_type(senders_type const& senders)
           : senders(senders)
         {
         }
@@ -67,13 +66,11 @@ namespace pika::when_all_vector_detail {
         // We expect a single value type or nothing from the predecessor
         // sender type
         using element_value_type =
-            std::decay_t<pika::execution::experimental::detail::single_result_t<
-                pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::empty_env,
-                    pika::util::detail::pack, pika::util::detail::pack>>>;
+            std::decay_t<pika::execution::experimental::detail::single_result_t<pika::execution::
+                    experimental::value_types_of_t<Sender, pika::execution::experimental::empty_env,
+                        pika::util::detail::pack, pika::util::detail::pack>>>;
 
-        static constexpr bool is_void_value_type =
-            std::is_void_v<element_value_type>;
+        static constexpr bool is_void_value_type = std::is_void_v<element_value_type>;
 
         // This is a helper empty type for the case that nothing is sent
         // from the predecessors
@@ -85,20 +82,16 @@ namespace pika::when_all_vector_detail {
         // predecessor senders or nothing if the predecessor senders send
         // nothing
         template <typename...>
-        using set_value_helper =
-            pika::execution::experimental::completion_signatures<
-                std::conditional_t<is_void_value_type,
-                    pika::execution::experimental::set_value_t(),
-                    pika::execution::experimental::set_value_t(
-                        std::vector<element_value_type>)>>;
+        using set_value_helper = pika::execution::experimental::completion_signatures<
+            std::conditional_t<is_void_value_type, pika::execution::experimental::set_value_t(),
+                pika::execution::experimental::set_value_t(std::vector<element_value_type>)>>;
 
         // This sender sends any error types sent by the predecessor senders
         // or std::exception_ptr
         template <template <typename...> class Variant>
         using error_types = pika::util::detail::unique_concat_t<
-            pika::util::detail::transform_t<
-                pika::execution::experimental::error_types_of_t<Sender,
-                    pika::execution::experimental::empty_env, Variant>,
+            pika::util::detail::transform_t<pika::execution::experimental::error_types_of_t<Sender,
+                                                pika::execution::experimental::empty_env, Variant>,
                 std::decay>,
             Variant<std::exception_ptr>>;
 
@@ -108,20 +101,17 @@ namespace pika::when_all_vector_detail {
             pika::execution::experimental::make_completion_signatures<Sender,
                 pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_error_t(
-                        std::exception_ptr)>,
+                    pika::execution::experimental::set_error_t(std::exception_ptr)>,
                 set_value_helper>;
 #else
         // We expect a single value type or nothing from the predecessor
         // sender type
         using element_value_type =
             std::decay_t<pika::execution::experimental::detail::single_result_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template value_types<pika::util::detail::pack,
-                    pika::util::detail::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>;
+        static constexpr bool is_void_value_type = std::is_void_v<element_value_type>;
 
         // This is a helper empty type for the case that nothing is sent
         // from the predecessors
@@ -132,18 +122,16 @@ namespace pika::when_all_vector_detail {
         // This sender sends a single vector of the type sent by the
         // predecessor senders or nothing if the predecessor senders send
         // nothing
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types = Variant<std::conditional_t<is_void_value_type,
-            Tuple<>, Tuple<std::vector<element_value_type>>>>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = Variant<std::conditional_t<is_void_value_type, Tuple<>,
+            Tuple<std::vector<element_value_type>>>>;
 
         // This sender sends any error types sent by the predecessor senders
         // or std::exception_ptr
         template <template <typename...> class Variant>
         using error_types = pika::util::detail::unique_concat_t<
-            pika::util::detail::transform_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template error_types<Variant>,
+            pika::util::detail::transform_t<typename pika::execution::experimental::sender_traits<
+                                                Sender>::template error_types<Variant>,
                 std::decay>,
             Variant<std::exception_ptr>>;
 
@@ -161,8 +149,7 @@ namespace pika::when_all_vector_detail {
                 std::size_t const i;
 
                 template <typename Error>
-                friend void
-                tag_invoke(pika::execution::experimental::set_error_t,
+                friend void tag_invoke(pika::execution::experimental::set_error_t,
                     when_all_vector_receiver&& r, Error&& error) noexcept
                 {
                     if (!r.op_state.set_stopped_error_called.exchange(true))
@@ -181,8 +168,7 @@ namespace pika::when_all_vector_detail {
                     r.op_state.finish();
                 }
 
-                friend void tag_invoke(
-                    pika::execution::experimental::set_stopped_t,
+                friend void tag_invoke(pika::execution::experimental::set_stopped_t,
                     when_all_vector_receiver&& r) noexcept
                 {
                     r.op_state.set_stopped_error_called = true;
@@ -190,8 +176,7 @@ namespace pika::when_all_vector_detail {
                 };
 
                 template <typename... Ts>
-                friend void
-                tag_invoke(pika::execution::experimental::set_value_t,
+                friend void tag_invoke(pika::execution::experimental::set_value_t,
                     when_all_vector_receiver&& r, Ts&&... ts) noexcept
                 {
                     if (!r.op_state.set_stopped_error_called)
@@ -204,14 +189,12 @@ namespace pika::when_all_vector_detail {
                             // predecessor senders that send nothing.
                             if constexpr (sizeof...(Ts) == 1)
                             {
-                                r.op_state.ts[r.i].emplace(
-                                    PIKA_FORWARD(Ts, ts)...);
+                                r.op_state.ts[r.i].emplace(PIKA_FORWARD(Ts, ts)...);
                             }
                         }
                         catch (...)
                         {
-                            if (!r.op_state.set_stopped_error_called.exchange(
-                                    true))
+                            if (!r.op_state.set_stopped_error_called.exchange(true))
                             {
                                 // NOLINTNEXTLINE(bugprone-throw-keyword-missing)
                                 r.op_state.error = std::current_exception();
@@ -222,8 +205,8 @@ namespace pika::when_all_vector_detail {
                     r.op_state.finish();
                 }
 
-                friend constexpr pika::execution::experimental::empty_env
-                tag_invoke(pika::execution::experimental::get_env_t,
+                friend constexpr pika::execution::experimental::empty_env tag_invoke(
+                    pika::execution::experimental::get_env_t,
                     when_all_vector_receiver const&) noexcept
                 {
                     return {};
@@ -240,15 +223,13 @@ namespace pika::when_all_vector_detail {
             // The values sent by the predecessor senders are stored in a
             // vector of optional or the dummy type void_value_type if the
             // predecessor senders send nothing
-            using value_types_storage_type =
-                std::conditional_t<is_void_value_type, void_value_type,
-                    std::vector<std::optional<element_value_type>>>;
+            using value_types_storage_type = std::conditional_t<is_void_value_type, void_value_type,
+                std::vector<std::optional<element_value_type>>>;
             value_types_storage_type ts;
 
             // The first error sent by any predecessor sender is stored in a
             // optional of a variant of the error_types
-            using error_types_storage_type =
-                std::optional<error_types<pika::detail::variant>>;
+            using error_types_storage_type = std::optional<error_types<pika::detail::variant>>;
             error_types_storage_type error;
 
             // Set to true when set_stopped or set_error has been called
@@ -258,8 +239,7 @@ namespace pika::when_all_vector_detail {
             // the operation states to handle the non-movability and
             // non-copyability of them
             using operation_state_type =
-                pika::execution::experimental::connect_result_t<Sender,
-                    when_all_vector_receiver>;
+                pika::execution::experimental::connect_result_t<Sender, when_all_vector_receiver>;
             using operation_states_storage_type =
                 std::unique_ptr<std::optional<operation_state_type>[]>;
             operation_states_storage_type op_states = nullptr;
@@ -270,15 +250,13 @@ namespace pika::when_all_vector_detail {
               , receiver(PIKA_FORWARD(Receiver_, receiver))
             {
                 op_states =
-                    std::make_unique<std::optional<operation_state_type>[]>(
-                        num_predecessors);
+                    std::make_unique<std::optional<operation_state_type>[]>(num_predecessors);
                 std::size_t i = 0;
                 for (auto&& sender : senders)
                 {
                     op_states[i].emplace(pika::detail::with_result_of([&]() {
                         return pika::execution::experimental::connect(
-                            PIKA_MOVE(sender),
-                            when_all_vector_receiver{*this, i});
+                            PIKA_MOVE(sender), when_all_vector_receiver{*this, i});
                     }));
                     ++i;
                 }
@@ -302,8 +280,7 @@ namespace pika::when_all_vector_detail {
                     {
                         if constexpr (is_void_value_type)
                         {
-                            pika::execution::experimental::set_value(
-                                PIKA_MOVE(receiver));
+                            pika::execution::experimental::set_value(PIKA_MOVE(receiver));
                         }
                         else
                         {
@@ -322,23 +299,20 @@ namespace pika::when_all_vector_detail {
                         pika::detail::visit(
                             [this](auto&& error) {
                                 pika::execution::experimental::set_error(
-                                    PIKA_MOVE(receiver),
-                                    PIKA_FORWARD(decltype(error), error));
+                                    PIKA_MOVE(receiver), PIKA_FORWARD(decltype(error), error));
                             },
                             PIKA_MOVE(error.value()));
                     }
                     else
                     {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-                        if constexpr (pika::execution::experimental::
-                                          sends_stopped<Sender>)
+                        if constexpr (pika::execution::experimental::sends_stopped<Sender>)
 #else
-                        if constexpr (pika::execution::experimental::
-                                          sender_traits<Sender>::sends_done)
+                        if constexpr (pika::execution::experimental::sender_traits<
+                                          Sender>::sends_done)
 #endif
                         {
-                            pika::execution::experimental::set_stopped(
-                                PIKA_MOVE(receiver));
+                            pika::execution::experimental::set_stopped(PIKA_MOVE(receiver));
                         }
                         else
                         {
@@ -348,8 +322,8 @@ namespace pika::when_all_vector_detail {
                 }
             }
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 // If there are no predecessors we can signal the
                 // continuation as soon as start is called.
@@ -359,16 +333,14 @@ namespace pika::when_all_vector_detail {
                     // send nothing to the continuation.
                     if constexpr (is_void_value_type)
                     {
-                        pika::execution::experimental::set_value(
-                            PIKA_MOVE(os.receiver));
+                        pika::execution::experimental::set_value(PIKA_MOVE(os.receiver));
                     }
                     // If the predecessor sender type sends something we
                     // send an empty vector of that type to the continuation.
                     else
                     {
                         pika::execution::experimental::set_value(
-                            PIKA_MOVE(os.receiver),
-                            std::vector<element_value_type>{});
+                            PIKA_MOVE(os.receiver), std::vector<element_value_type>{});
                     }
                 }
                 // Otherwise we start all the operation states and wait for
@@ -377,8 +349,7 @@ namespace pika::when_all_vector_detail {
                 {
                     for (std::size_t i = 0; i < os.num_predecessors; ++i)
                     {
-                        pika::execution::experimental::start(
-                            os.op_states.get()[i].value());
+                        pika::execution::experimental::start(os.op_states.get()[i].value());
                     }
                 }
             }
@@ -410,16 +381,14 @@ namespace pika::execution::experimental {
         friend constexpr PIKA_FORCEINLINE auto
         tag_fallback_invoke(when_all_vector_t, std::vector<Sender>&& senders)
         {
-            return when_all_vector_detail::when_all_vector_sender<Sender>{
-                PIKA_MOVE(senders)};
+            return when_all_vector_detail::when_all_vector_sender<Sender>{PIKA_MOVE(senders)};
         }
 
         template <typename Sender, PIKA_CONCEPT_REQUIRES_(is_sender_v<Sender>)>
-        friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(
-            when_all_vector_t, std::vector<Sender> const& senders)
+        friend constexpr PIKA_FORCEINLINE auto
+        tag_fallback_invoke(when_all_vector_t, std::vector<Sender> const& senders)
         {
-            return when_all_vector_detail::when_all_vector_sender<Sender>{
-                senders};
+            return when_all_vector_detail::when_all_vector_sender<Sender>{senders};
         }
     } when_all_vector{};
 }    // namespace pika::execution::experimental
diff --git a/libs/pika/execution/tests/include/algorithm_test_utils.hpp b/libs/pika/execution/tests/include/algorithm_test_utils.hpp
index deb1e3674f..8375752033 100644
--- a/libs/pika/execution/tests/include/algorithm_test_utils.hpp
+++ b/libs/pika/execution/tests/include/algorithm_test_utils.hpp
@@ -20,8 +20,7 @@
 
 struct void_sender
 {
-    template <template <typename...> class Tuple,
-        template <typename...> class Variant>
+    template <template <typename...> class Tuple, template <typename...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <typename...> class Variant>
@@ -29,16 +28,14 @@ struct void_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t()>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t()>;
 
     template <typename R>
     struct operation_state
     {
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             pika::execution::experimental::set_value(std::move(os.r));
         }
@@ -55,8 +52,7 @@ struct void_sender
 template <typename... Ts>
 struct error_sender
 {
-    template <template <typename...> class Tuple,
-        template <typename...> class Variant>
+    template <template <typename...> class Tuple, template <typename...> class Variant>
     using value_types = Variant<Tuple<Ts...>>;
 
     template <template <typename...> class Variant>
@@ -64,17 +60,15 @@ struct error_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(Ts...),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(Ts...),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     template <typename R>
     struct operation_state
     {
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             try
             {
@@ -82,8 +76,7 @@ struct error_sender
             }
             catch (...)
             {
-                pika::execution::experimental::set_error(
-                    std::move(os.r), std::current_exception());
+                pika::execution::experimental::set_error(std::move(os.r), std::current_exception());
             }
         }
     };
@@ -99,8 +92,7 @@ struct error_sender
 template <typename... Ts>
 struct const_reference_error_sender
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<Ts...>>;
 
     template <template <class...> class Variant>
@@ -108,18 +100,15 @@ struct const_reference_error_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(Ts...),
-            pika::execution::experimental::set_error_t(
-                std::exception_ptr const&)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(Ts...),
+        pika::execution::experimental::set_error_t(std::exception_ptr const&)>;
 
     template <typename R>
     struct operation_state
     {
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             auto const e = std::make_exception_ptr(std::runtime_error("error"));
             pika::execution::experimental::set_error(std::move(os.r), e);
@@ -128,8 +117,7 @@ struct const_reference_error_sender
 
     template <typename R>
     friend operation_state<R>
-    tag_invoke(pika::execution::experimental::connect_t,
-        const_reference_error_sender, R&& r)
+    tag_invoke(pika::execution::experimental::connect_t, const_reference_error_sender, R&& r)
     {
         return {std::forward<R>(r)};
     }
@@ -142,30 +130,28 @@ struct callback_receiver
     std::atomic<bool>& set_value_called;
 
     template <typename E>
-    friend void tag_invoke(pika::execution::experimental::set_error_t,
-        callback_receiver&&, E&&) noexcept
+    friend void
+    tag_invoke(pika::execution::experimental::set_error_t, callback_receiver&&, E&&) noexcept
     {
         PIKA_TEST(false);
     }
 
-    friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-        callback_receiver&&) noexcept
+    friend void tag_invoke(
+        pika::execution::experimental::set_stopped_t, callback_receiver&&) noexcept
     {
         PIKA_TEST(false);
     };
 
     template <typename... Ts>
-    friend auto tag_invoke(pika::execution::experimental::set_value_t,
-        callback_receiver&& r, Ts&&... ts) noexcept
-        -> decltype(PIKA_INVOKE(f, std::forward<Ts>(ts)...), void())
+    friend auto tag_invoke(pika::execution::experimental::set_value_t, callback_receiver&& r,
+        Ts&&... ts) noexcept -> decltype(PIKA_INVOKE(f, std::forward<Ts>(ts)...), void())
     {
         PIKA_INVOKE(r.f, std::forward<Ts>(ts)...);
         r.set_value_called = true;
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        callback_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, callback_receiver const&) noexcept
     {
         return {};
     }
@@ -179,29 +165,28 @@ struct error_callback_receiver
     bool expect_set_value = false;
 
     template <typename E>
-    friend void tag_invoke(pika::execution::experimental::set_error_t,
-        error_callback_receiver&& r, E&& e) noexcept
+    friend void tag_invoke(
+        pika::execution::experimental::set_error_t, error_callback_receiver&& r, E&& e) noexcept
     {
         PIKA_INVOKE(r.f, std::forward<E>(e));
         r.set_error_called = true;
     }
 
-    friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-        error_callback_receiver&&) noexcept
+    friend void tag_invoke(
+        pika::execution::experimental::set_stopped_t, error_callback_receiver&&) noexcept
     {
         PIKA_TEST(false);
     };
 
     template <typename... Ts>
-    friend void tag_invoke(pika::execution::experimental::set_value_t,
-        error_callback_receiver&& r, Ts&&...) noexcept
+    friend void tag_invoke(
+        pika::execution::experimental::set_value_t, error_callback_receiver&& r, Ts&&...) noexcept
     {
         PIKA_TEST(r.expect_set_value);
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        error_callback_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, error_callback_receiver const&) noexcept
     {
         return {};
     }
@@ -242,8 +227,7 @@ struct custom_sender_tag_invoke
 {
     std::atomic<bool>& tag_invoke_overload_called;
 
-    template <template <typename...> class Tuple,
-        template <typename...> class Variant>
+    template <template <typename...> class Tuple, template <typename...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <typename...> class Variant>
@@ -251,9 +235,8 @@ struct custom_sender_tag_invoke
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t()>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t()>;
 
     template <typename R>
     struct operation_state
@@ -278,8 +261,7 @@ struct custom_sender
     std::atomic<bool>& connect_called;
     std::atomic<bool>& tag_invoke_overload_called;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <class...> class Variant>
@@ -287,18 +269,16 @@ struct custom_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     template <typename R>
     struct operation_state
     {
         std::atomic<bool>& start_called;
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             os.start_called = true;
             pika::execution::experimental::set_value(std::move(os.r));
@@ -306,8 +286,7 @@ struct custom_sender
     };
 
     template <typename R>
-    friend auto tag_invoke(
-        pika::execution::experimental::connect_t, custom_sender&& s, R&& r)
+    friend auto tag_invoke(pika::execution::experimental::connect_t, custom_sender&& s, R&& r)
     {
         s.connect_called = true;
         return operation_state<R>{s.start_called, std::forward<R>(r)};
@@ -323,8 +302,7 @@ struct custom_typed_sender
     std::atomic<bool>& connect_called;
     std::atomic<bool>& tag_invoke_overload_called;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<std::decay_t<T>>>;
 
     template <template <class...> class Variant>
@@ -332,10 +310,9 @@ struct custom_typed_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(std::decay_t<T>),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(std::decay_t<T>),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     template <typename R>
     struct operation_state
@@ -343,22 +320,18 @@ struct custom_typed_sender
         std::decay_t<T> x;
         std::atomic<bool>& start_called;
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             os.start_called = true;
-            pika::execution::experimental::set_value(
-                std::move(os.r), std::move(os.x));
+            pika::execution::experimental::set_value(std::move(os.r), std::move(os.x));
         };
     };
 
     template <typename R>
-    friend auto tag_invoke(pika::execution::experimental::connect_t,
-        custom_typed_sender&& s, R&& r)
+    friend auto tag_invoke(pika::execution::experimental::connect_t, custom_typed_sender&& s, R&& r)
     {
         s.connect_called = true;
-        return operation_state<R>{
-            std::move(s.x), s.start_called, std::forward<R>(r)};
+        return operation_state<R>{std::move(s.x), s.start_called, std::forward<R>(r)};
     }
 };
 
@@ -375,8 +348,7 @@ struct const_reference_sender
 {
     std::reference_wrapper<std::decay_t<T>> x;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<std::decay_t<T> const&>>;
 
     template <template <class...> class Variant>
@@ -384,10 +356,9 @@ struct const_reference_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(std::decay_t<T>&),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(std::decay_t<T>&),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     template <typename R>
     struct operation_state
@@ -395,17 +366,15 @@ struct const_reference_sender
         std::reference_wrapper<std::decay_t<T>> const x;
         std::decay_t<R> r;
 
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
-            pika::execution::experimental::set_value(
-                std::move(os.r), os.x.get());
+            pika::execution::experimental::set_value(std::move(os.r), os.x.get());
         };
     };
 
     template <typename R>
-    friend auto tag_invoke(pika::execution::experimental::connect_t,
-        const_reference_sender&& s, R&& r)
+    friend auto
+    tag_invoke(pika::execution::experimental::connect_t, const_reference_sender&& s, R&& r)
     {
         return operation_state<R>{std::move(s.x), std::forward<R>(r)};
     }
@@ -424,12 +393,10 @@ struct custom_type_non_default_constructible
     custom_type_non_default_constructible() = delete;
     explicit custom_type_non_default_constructible(int x)
       : x(x){};
-    custom_type_non_default_constructible(
-        custom_type_non_default_constructible&&) = default;
+    custom_type_non_default_constructible(custom_type_non_default_constructible&&) = default;
     custom_type_non_default_constructible& operator=(
         custom_type_non_default_constructible&&) = default;
-    custom_type_non_default_constructible(
-        custom_type_non_default_constructible const&) = default;
+    custom_type_non_default_constructible(custom_type_non_default_constructible const&) = default;
     custom_type_non_default_constructible& operator=(
         custom_type_non_default_constructible const&) = default;
 };
@@ -457,8 +424,7 @@ struct scheduler
     std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
     template <typename F>
-    friend void
-    tag_invoke(pika::execution::experimental::execute_t, scheduler s, F&& f)
+    friend void tag_invoke(pika::execution::experimental::execute_t, scheduler s, F&& f)
     {
         s.execute_called.get() = true;
         PIKA_INVOKE(std::forward<F>(f), );
@@ -470,8 +436,7 @@ struct scheduler
         std::reference_wrapper<std::atomic<bool>> execute_called;
         std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
+        template <template <class...> class Tuple, template <class...> class Variant>
         using value_types = Variant<Tuple<>>;
 
         template <template <class...> class Variant>
@@ -479,25 +444,23 @@ struct scheduler
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t()>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t()>;
 
         template <typename R>
         struct operation_state
         {
             std::decay_t<R> r;
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::set_value(std::move(os.r));
             };
         };
 
         template <typename R>
-        friend auto
-        tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
         {
             return operation_state<R>{std::forward<R>(r)};
         }
@@ -506,33 +469,26 @@ struct scheduler
         {
             std::reference_wrapper<std::atomic<bool>> schedule_called;
             std::reference_wrapper<std::atomic<bool>> execute_called;
-            std::reference_wrapper<std::atomic<bool>>
-                tag_invoke_overload_called;
+            std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
-            friend scheduler tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<
-                    pika::execution::experimental::set_value_t>,
+            friend scheduler tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
+                                            pika::execution::experimental::set_value_t>,
                 env const& e) noexcept
             {
-                return {e.schedule_called, e.execute_called,
-                    e.tag_invoke_overload_called};
+                return {e.schedule_called, e.execute_called, e.tag_invoke_overload_called};
             }
         };
 
-        friend env tag_invoke(
-            pika::execution::experimental::get_env_t, sender const& s)
+        friend env tag_invoke(pika::execution::experimental::get_env_t, sender const& s)
         {
-            return {s.schedule_called, s.execute_called,
-                s.tag_invoke_overload_called};
+            return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
         }
     };
 
-    friend sender tag_invoke(
-        pika::execution::experimental::schedule_t, scheduler s)
+    friend sender tag_invoke(pika::execution::experimental::schedule_t, scheduler s)
     {
         s.schedule_called.get() = true;
-        return {
-            s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
+        return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
     }
 
     bool operator==(scheduler const&) const noexcept
@@ -553,8 +509,7 @@ struct scheduler2
     std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
     template <typename F>
-    friend void
-    tag_invoke(pika::execution::experimental::execute_t, scheduler2 s, F&& f)
+    friend void tag_invoke(pika::execution::experimental::execute_t, scheduler2 s, F&& f)
     {
         s.execute_called.get() = true;
         PIKA_INVOKE(std::forward<F>(f), );
@@ -566,8 +521,7 @@ struct scheduler2
         std::reference_wrapper<std::atomic<bool>> execute_called;
         std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
+        template <template <class...> class Tuple, template <class...> class Variant>
         using value_types = Variant<Tuple<>>;
 
         template <template <class...> class Variant>
@@ -575,25 +529,23 @@ struct scheduler2
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t()>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t()>;
 
         template <typename R>
         struct operation_state
         {
             std::decay_t<R> r;
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::set_value(std::move(os.r));
             };
         };
 
         template <typename R>
-        friend auto
-        tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
         {
             return operation_state<R>{std::forward<R>(r)};
         }
@@ -602,33 +554,26 @@ struct scheduler2
         {
             std::reference_wrapper<std::atomic<bool>> schedule_called;
             std::reference_wrapper<std::atomic<bool>> execute_called;
-            std::reference_wrapper<std::atomic<bool>>
-                tag_invoke_overload_called;
+            std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
-            friend scheduler2 tag_invoke(
-                pika::execution::experimental::get_completion_scheduler_t<
-                    pika::execution::experimental::set_value_t>,
+            friend scheduler2 tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
+                                             pika::execution::experimental::set_value_t>,
                 env const& e) noexcept
             {
-                return {e.schedule_called, e.execute_called,
-                    e.tag_invoke_overload_called};
+                return {e.schedule_called, e.execute_called, e.tag_invoke_overload_called};
             }
         };
 
-        friend env tag_invoke(
-            pika::execution::experimental::get_env_t, sender const& s)
+        friend env tag_invoke(pika::execution::experimental::get_env_t, sender const& s)
         {
-            return {s.schedule_called, s.execute_called,
-                s.tag_invoke_overload_called};
+            return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
         }
     };
 
-    friend sender tag_invoke(
-        pika::execution::experimental::schedule_t, scheduler2 s)
+    friend sender tag_invoke(pika::execution::experimental::schedule_t, scheduler2 s)
     {
         s.schedule_called.get() = true;
-        return {
-            s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
+        return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
     }
 
     bool operator==(scheduler2 const&) const noexcept
@@ -648,8 +593,7 @@ namespace tag_namespace {
         template <typename Sender>
         auto operator()(Sender&& sender) const
         {
-            return pika::functional::detail::tag_invoke(
-                *this, std::forward<Sender>(sender));
+            return pika::functional::detail::tag_invoke(*this, std::forward<Sender>(sender));
         }
 
         struct wrapper
@@ -681,8 +625,7 @@ namespace my_namespace {
     {
         struct sender
         {
-            template <template <class...> class Tuple,
-                template <class...> class Variant>
+            template <template <class...> class Tuple, template <class...> class Variant>
             using value_types = Variant<Tuple<>>;
 
             template <template <class...> class Variant>
@@ -690,25 +633,23 @@ namespace my_namespace {
 
             static constexpr bool sends_done = false;
 
-            using completion_signatures =
-                pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_value_t()>;
+            using completion_signatures = pika::execution::experimental::completion_signatures<
+                pika::execution::experimental::set_value_t()>;
 
             template <typename R>
             struct operation_state
             {
                 std::decay_t<R> r;
 
-                friend void tag_invoke(pika::execution::experimental::start_t,
-                    operation_state& os) noexcept
+                friend void tag_invoke(
+                    pika::execution::experimental::start_t, operation_state& os) noexcept
                 {
                     pika::execution::experimental::set_value(std::move(os.r));
                 };
             };
 
             template <typename R>
-            friend auto tag_invoke(
-                pika::execution::experimental::connect_t, sender&&, R&& r)
+            friend auto tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
             {
                 return operation_state<R>{std::forward<R>(r)};
             }
@@ -732,15 +673,13 @@ namespace my_namespace {
                 }
             };
 
-            friend env tag_invoke(
-                pika::execution::experimental::get_env_t, sender const&)
+            friend env tag_invoke(pika::execution::experimental::get_env_t, sender const&)
             {
                 return {};
             }
         };
 
-        friend sender tag_invoke(
-            pika::execution::experimental::schedule_t, my_scheduler)
+        friend sender tag_invoke(pika::execution::experimental::schedule_t, my_scheduler)
         {
             return {};
         }
@@ -759,8 +698,7 @@ namespace my_namespace {
     template <typename... Ts>
     struct my_sender
     {
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         using value_types = Variant<Tuple<Ts...>>;
 
         template <template <typename...> class Variant>
@@ -768,19 +706,17 @@ namespace my_namespace {
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t(Ts...)>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t(Ts...)>;
 
         template <typename R>
         struct operation_state
         {
             std::decay_t<R> r;
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
-                pika::execution::experimental::set_value(
-                    std::move(os.r), Ts{}...);
+                pika::execution::experimental::set_value(std::move(os.r), Ts{}...);
             }
         };
 
diff --git a/libs/pika/execution/tests/unit/algorithm_bulk.cpp b/libs/pika/execution/tests/unit/algorithm_bulk.cpp
index 0b7b1e3b37..169c418385 100644
--- a/libs/pika/execution/tests/unit/algorithm_bulk.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_bulk.cpp
@@ -43,8 +43,7 @@ template <typename S>
 auto tag_invoke(ex::bulk_t, S&& s, int num, custom_bulk_operation t)
 {
     t.tag_invoke_overload_called = true;
-    return ex::bulk(
-        std::forward<S>(s), num, [t = std::move(t)](int n) { t(n); });
+    return ex::bulk(std::forward<S>(s), num, [t = std::move(t)](int n) { t(n); });
 }
 
 int main()
@@ -84,8 +83,8 @@ int main()
     {
         std::atomic<bool> set_value_called{false};
         std::atomic<int> set_value_count{0};
-        auto s = ex::bulk(ex::just(custom_type_non_default_constructible{42}),
-            10, [&](int n, auto x) {
+        auto s =
+            ex::bulk(ex::just(custom_type_non_default_constructible{42}), 10, [&](int n, auto x) {
                 PIKA_TEST_EQ(n, set_value_count);
                 ++set_value_count;
                 ++(x.x);
@@ -102,9 +101,8 @@ int main()
     {
         std::atomic<bool> set_value_called{false};
         std::atomic<int> set_value_count{0};
-        auto s = ex::bulk(
-            ex::just(custom_type_non_default_constructible_non_copyable{42}),
-            10, [&](int n, auto&&) {
+        auto s = ex::bulk(ex::just(custom_type_non_default_constructible_non_copyable{42}), 10,
+            [&](int n, auto&&) {
                 PIKA_TEST_EQ(n, set_value_count);
                 ++set_value_count;
             });
@@ -136,11 +134,10 @@ int main()
         std::atomic<bool> set_value_called{false};
         std::atomic<int> set_value_count{0};
         int x = 42;
-        auto s = ex::bulk(ex::just(const_reference_sender<decltype(x)>{x}), 10,
-            [&](int n, auto&&) {
-                PIKA_TEST_EQ(n, set_value_count);
-                ++set_value_count;
-            });
+        auto s = ex::bulk(ex::just(const_reference_sender<decltype(x)>{x}), 10, [&](int n, auto&&) {
+            PIKA_TEST_EQ(n, set_value_count);
+            ++set_value_count;
+        });
         auto f = [](auto x) { PIKA_TEST_EQ(x.x, 42); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -154,8 +151,8 @@ int main()
         std::atomic<bool> set_value_called{false};
         std::atomic<int> set_value_count{0};
         auto f = [&](int, int) { ++set_value_count; };
-        auto s = ex::just(42) | ex::bulk(10, f) | ex::bulk(10, f) |
-            ex::bulk(10, f) | ex::bulk(10, f);
+        auto s =
+            ex::just(42) | ex::bulk(10, f) | ex::bulk(10, f) | ex::bulk(10, f) | ex::bulk(10, f);
         auto f1 = [](int x) { PIKA_TEST_EQ(x, 42); };
         auto r = callback_receiver<decltype(f1)>{f1, set_value_called};
         auto os = ex::connect(std::move(s), r);
@@ -171,9 +168,8 @@ int main()
         std::atomic<bool> custom_bulk_call_operator_called{false};
         std::atomic<int> custom_bulk_call_count{0};
         auto s = ex::bulk(ex::just(), 10,
-            custom_bulk_operation{tag_invoke_overload_called,
-                custom_bulk_call_operator_called, custom_bulk_call_count,
-                false});
+            custom_bulk_operation{tag_invoke_overload_called, custom_bulk_call_operator_called,
+                custom_bulk_call_count, false});
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -187,8 +183,7 @@ int main()
     // Failure path
     {
         std::atomic<bool> set_error_called{false};
-        auto s = ex::bulk(
-            ex::just(), 0, [](int) { throw std::runtime_error("error"); });
+        auto s = ex::bulk(ex::just(), 0, [](int) { throw std::runtime_error("error"); });
         auto r = error_callback_receiver<decltype(check_exception_ptr)>{
             check_exception_ptr, set_error_called, true};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -217,10 +212,8 @@ int main()
                 throw std::runtime_error("error");
             return x + 1;
         });
-        auto s3 =
-            ex::bulk(std::move(s2), 10, [](int, int) { PIKA_TEST(false); });
-        auto s4 =
-            ex::bulk(std::move(s3), 10, [](int, int) { PIKA_TEST(false); });
+        auto s3 = ex::bulk(std::move(s2), 10, [](int, int) { PIKA_TEST(false); });
+        auto s4 = ex::bulk(std::move(s3), 10, [](int, int) { PIKA_TEST(false); });
         auto r = error_callback_receiver<decltype(check_exception_ptr)>{
             check_exception_ptr, set_error_called};
         auto os = ex::connect(std::move(s4), std::move(r));
@@ -234,9 +227,8 @@ int main()
         std::atomic<bool> custom_bulk_call_operator_called{false};
         std::atomic<int> custom_bulk_call_count{0};
         auto s = ex::bulk(ex::just(), 10,
-            custom_bulk_operation{tag_invoke_overload_called,
-                custom_bulk_call_operator_called, custom_bulk_call_count,
-                true});
+            custom_bulk_operation{tag_invoke_overload_called, custom_bulk_call_operator_called,
+                custom_bulk_call_count, true});
         auto r = error_callback_receiver<decltype(check_exception_ptr)>{
             check_exception_ptr, receiver_set_error_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -249,8 +241,7 @@ int main()
 
     {
         std::atomic<bool> set_error_called{false};
-        auto s = ex::bulk(
-            const_reference_error_sender{}, 10, [](int) { PIKA_TEST(false); });
+        auto s = ex::bulk(const_reference_error_sender{}, 10, [](int) { PIKA_TEST(false); });
         auto r = error_callback_receiver<decltype(check_exception_ptr)>{
             check_exception_ptr, set_error_called};
         auto os = ex::connect(std::move(s), std::move(r));
diff --git a/libs/pika/execution/tests/unit/algorithm_execute.cpp b/libs/pika/execution/tests/unit/algorithm_execute.cpp
index 7fdea2a8bb..7b1392edcb 100644
--- a/libs/pika/execution/tests/unit/algorithm_execute.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_execute.cpp
@@ -17,8 +17,7 @@ static std::size_t tag_invoke_execute_calls = 0;
 template <typename Scheduler>
 struct sender
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <class...> class Variant>
@@ -26,14 +25,13 @@ struct sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t()>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t()>;
 
     struct operation_state
     {
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state&) noexcept {};
+        friend void tag_invoke(
+            pika::execution::experimental::start_t, operation_state&) noexcept {};
     };
 
     template <typename R>
@@ -45,17 +43,15 @@ struct sender
 
     struct env
     {
-        friend Scheduler tag_invoke(
-            pika::execution::experimental::get_completion_scheduler_t<
-                pika::execution::experimental::set_value_t>,
+        friend Scheduler tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
+                                        pika::execution::experimental::set_value_t>,
             env const&) noexcept
         {
             return {};
         }
     };
 
-    friend env tag_invoke(
-        pika::execution::experimental::get_env_t, sender const&) noexcept
+    friend env tag_invoke(pika::execution::experimental::get_env_t, sender const&) noexcept
     {
         return {};
     }
@@ -63,8 +59,7 @@ struct sender
 
 struct scheduler_1
 {
-    friend sender<scheduler_1> tag_invoke(
-        pika::execution::experimental::schedule_t, scheduler_1)
+    friend sender<scheduler_1> tag_invoke(pika::execution::experimental::schedule_t, scheduler_1)
     {
         ++friend_tag_invoke_schedule_calls;
         return {};
@@ -83,8 +78,7 @@ struct scheduler_1
 
 struct scheduler_2
 {
-    friend sender<scheduler_2> tag_invoke(
-        pika::execution::experimental::schedule_t, scheduler_2)
+    friend sender<scheduler_2> tag_invoke(pika::execution::experimental::schedule_t, scheduler_2)
     {
         PIKA_TEST(false);
         return {};
diff --git a/libs/pika/execution/tests/unit/algorithm_split.cpp b/libs/pika/execution/tests/unit/algorithm_split.cpp
index ff5f82b488..cbefb8e2dd 100644
--- a/libs/pika/execution/tests/unit/algorithm_split.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_split.cpp
@@ -22,8 +22,7 @@ namespace tt = pika::this_thread::experimental;
 // This overload is only used to check dispatching. It is not a useful
 // implementation.
 template <typename Allocator = pika::detail::internal_allocator<>>
-auto tag_invoke(
-    ex::split_t, custom_sender_tag_invoke s, Allocator const& = Allocator{})
+auto tag_invoke(ex::split_t, custom_sender_tag_invoke s, Allocator const& = Allocator{})
 {
     s.tag_invoke_overload_called = true;
     return void_sender{};
@@ -67,8 +66,7 @@ int main()
 
     {
         std::atomic<bool> set_value_called{false};
-        auto s1 =
-            ex::just(custom_type_non_default_constructible_non_copyable{42});
+        auto s1 = ex::just(custom_type_non_default_constructible_non_copyable{42});
         auto s2 = ex::split(std::move(s1));
         auto f = [](auto& x) { PIKA_TEST_EQ(x.x, 42); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
@@ -104,8 +102,7 @@ int main()
     {
         std::atomic<bool> receiver_set_value_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
-        auto s =
-            custom_sender_tag_invoke{tag_invoke_overload_called} | ex::split();
+        auto s = custom_sender_tag_invoke{tag_invoke_overload_called} | ex::split();
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
diff --git a/libs/pika/execution/tests/unit/algorithm_transfer.cpp b/libs/pika/execution/tests/unit/algorithm_transfer.cpp
index 221edf0db7..34873bee49 100644
--- a/libs/pika/execution/tests/unit/algorithm_transfer.cpp
+++ b/libs/pika/execution/tests/unit/algorithm_transfer.cpp
@@ -27,8 +27,8 @@ struct scheduler_schedule_from
     std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
     template <typename F>
-    friend void tag_invoke(pika::execution::experimental::execute_t,
-        scheduler_schedule_from s, F&& f)
+    friend void
+    tag_invoke(pika::execution::experimental::execute_t, scheduler_schedule_from s, F&& f)
     {
         s.execute_called.get() = true;
         PIKA_INVOKE(std::forward<F>(f), );
@@ -40,8 +40,7 @@ struct scheduler_schedule_from
         std::reference_wrapper<std::atomic<bool>> execute_called;
         std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
+        template <template <class...> class Tuple, template <class...> class Variant>
         using value_types = Variant<Tuple<>>;
 
         template <template <class...> class Variant>
@@ -49,25 +48,23 @@ struct scheduler_schedule_from
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t()>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t()>;
 
         template <typename R>
         struct operation_state
         {
             std::decay_t<R> r;
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::set_value(std::move(os.r));
             };
         };
 
         template <typename R>
-        friend auto
-        tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
         {
             return operation_state<R>{std::forward<R>(r)};
         }
@@ -77,17 +74,14 @@ struct scheduler_schedule_from
                 pika::execution::experimental::set_value_t>,
             sender const& s) noexcept
         {
-            return {s.schedule_called, s.execute_called,
-                s.tag_invoke_overload_called};
+            return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
         }
     };
 
-    friend sender tag_invoke(
-        pika::execution::experimental::schedule_t, scheduler_schedule_from s)
+    friend sender tag_invoke(pika::execution::experimental::schedule_t, scheduler_schedule_from s)
     {
         s.schedule_called.get() = true;
-        return {
-            s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
+        return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
     }
 
     bool operator==(scheduler_schedule_from const&) const noexcept
@@ -105,8 +99,8 @@ template <typename Sender>
 auto tag_invoke(ex::schedule_from_t, scheduler_schedule_from sched, Sender&&)
 {
     sched.tag_invoke_overload_called.get() = true;
-    return scheduler_schedule_from::sender{sched.schedule_called,
-        sched.execute_called, sched.tag_invoke_overload_called};
+    return scheduler_schedule_from::sender{
+        sched.schedule_called, sched.execute_called, sched.tag_invoke_overload_called};
 }
 
 // transfer customization
@@ -117,8 +111,7 @@ struct scheduler_transfer
     std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
     template <typename F>
-    friend void tag_invoke(
-        pika::execution::experimental::execute_t, scheduler_transfer s, F&& f)
+    friend void tag_invoke(pika::execution::experimental::execute_t, scheduler_transfer s, F&& f)
     {
         s.execute_called.get() = true;
         PIKA_INVOKE(std::forward<F>(f), );
@@ -130,8 +123,7 @@ struct scheduler_transfer
         std::reference_wrapper<std::atomic<bool>> execute_called;
         std::reference_wrapper<std::atomic<bool>> tag_invoke_overload_called;
 
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
+        template <template <class...> class Tuple, template <class...> class Variant>
         using value_types = Variant<Tuple<>>;
 
         template <template <class...> class Variant>
@@ -139,25 +131,23 @@ struct scheduler_transfer
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t()>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t()>;
 
         template <typename R>
         struct operation_state
         {
             std::decay_t<R> r;
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::set_value(std::move(os.r));
             };
         };
 
         template <typename R>
-        friend auto
-        tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, sender&&, R&& r)
         {
             return operation_state<R>{std::forward<R>(r)};
         }
@@ -167,17 +157,14 @@ struct scheduler_transfer
                 pika::execution::experimental::set_value_t>,
             sender const& s) noexcept
         {
-            return {s.schedule_called, s.execute_called,
-                s.tag_invoke_overload_called};
+            return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
         }
     };
 
-    friend sender tag_invoke(
-        pika::execution::experimental::schedule_t, scheduler_transfer s)
+    friend sender tag_invoke(pika::execution::experimental::schedule_t, scheduler_transfer s)
     {
         s.schedule_called.get() = true;
-        return {
-            s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
+        return {s.schedule_called, s.execute_called, s.tag_invoke_overload_called};
     }
 
     bool operator==(scheduler_transfer const&) const noexcept
@@ -192,12 +179,11 @@ struct scheduler_transfer
 };
 
 template <typename Sender, typename Scheduler>
-decltype(auto) tag_invoke(ex::transfer_t, scheduler_transfer completion_sched,
-    Sender&& sender, Scheduler&& sched)
+decltype(auto)
+tag_invoke(ex::transfer_t, scheduler_transfer completion_sched, Sender&& sender, Scheduler&& sched)
 {
     completion_sched.tag_invoke_overload_called.get() = true;
-    return ex::schedule_from(
-        std::forward<Scheduler>(sched), std::forward<Sender>(sender));
+    return ex::schedule_from(std::forward<Scheduler>(sched), std::forward<Sender>(sender));
 }
 
 struct sender_with_completion_scheduler : void_sender
@@ -214,15 +200,13 @@ struct sender_with_completion_scheduler : void_sender
         scheduler_transfer scheduler;
 
         friend scheduler_transfer tag_invoke(
-            ex::get_completion_scheduler_t<ex::set_value_t>,
-            env const& e) noexcept
+            ex::get_completion_scheduler_t<ex::set_value_t>, env const& e) noexcept
         {
             return e.scheduler;
         }
     };
 
-    friend env tag_invoke(
-        ex::get_env_t, sender_with_completion_scheduler const& s)
+    friend env tag_invoke(ex::get_env_t, sender_with_completion_scheduler const& s)
     {
         return {s.sched};
     }
@@ -237,8 +221,8 @@ int main()
         std::atomic<bool> scheduler_execute_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
         auto s = ex::transfer(ex::just(),
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -255,8 +239,8 @@ int main()
         std::atomic<bool> scheduler_execute_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
         auto s = ex::transfer(ex::just(3),
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](int x) { PIKA_TEST_EQ(x, 3); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -274,8 +258,8 @@ int main()
         std::atomic<bool> tag_invoke_overload_called{false};
         int x = 3;
         auto s = ex::transfer(const_reference_sender<decltype(x)>{x},
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](int x) { PIKA_TEST_EQ(x, 3); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -291,10 +275,9 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> scheduler_execute_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
-        auto s =
-            ex::transfer(ex::just(custom_type_non_default_constructible{42}),
-                scheduler{scheduler_schedule_called, scheduler_execute_called,
-                    tag_invoke_overload_called});
+        auto s = ex::transfer(ex::just(custom_type_non_default_constructible{42}),
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](auto x) { PIKA_TEST_EQ(x.x, 42); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -310,10 +293,9 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> scheduler_execute_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
-        auto s = ex::transfer(
-            ex::just(custom_type_non_default_constructible_non_copyable{42}),
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+        auto s = ex::transfer(ex::just(custom_type_non_default_constructible_non_copyable{42}),
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](auto x) { PIKA_TEST_EQ(x.x, 42); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -330,8 +312,8 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
         auto s = ex::transfer(ex::just(std::string("hello"), 3),
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](std::string s, int x) {
             PIKA_TEST_EQ(s, std::string("hello"));
             PIKA_TEST_EQ(x, 3);
@@ -352,8 +334,8 @@ int main()
         std::atomic<bool> tag_invoke_overload_called{false};
         int x = 3;
         auto s = ex::transfer(const_reference_sender<int>{x},
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](int x) { PIKA_TEST_EQ(x, 3); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -371,8 +353,8 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
         auto s = ex::just(std::string("hello"), 3) |
-            ex::transfer(scheduler{scheduler_schedule_called,
-                scheduler_execute_called, tag_invoke_overload_called});
+            ex::transfer(scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [](std::string s, int x) {
             PIKA_TEST_EQ(s, std::string("hello"));
             PIKA_TEST_EQ(x, 3);
@@ -393,8 +375,8 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> scheduler_execute_called{false};
         auto s = ex::transfer(ex::just(),
-            scheduler_schedule_from{scheduler_schedule_called,
-                scheduler_execute_called, tag_invoke_overload_called});
+            scheduler_schedule_from{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -410,22 +392,18 @@ int main()
         std::atomic<bool> source_scheduler_tag_invoke_overload_called{false};
         std::atomic<bool> source_scheduler_schedule_called{false};
         std::atomic<bool> source_scheduler_execute_called{false};
-        std::atomic<bool> destination_scheduler_tag_invoke_overload_called{
-            false};
+        std::atomic<bool> destination_scheduler_tag_invoke_overload_called{false};
         std::atomic<bool> destination_scheduler_schedule_called{false};
         std::atomic<bool> destination_scheduler_execute_called{false};
 
         scheduler_transfer source_scheduler{source_scheduler_schedule_called,
-            source_scheduler_execute_called,
-            source_scheduler_tag_invoke_overload_called};
+            source_scheduler_execute_called, source_scheduler_tag_invoke_overload_called};
         scheduler destination_scheduler{
-            scheduler{destination_scheduler_schedule_called,
-                destination_scheduler_execute_called,
+            scheduler{destination_scheduler_schedule_called, destination_scheduler_execute_called,
                 destination_scheduler_tag_invoke_overload_called}};
 
         auto s = ex::transfer(
-            sender_with_completion_scheduler{std::move(source_scheduler)},
-            destination_scheduler);
+            sender_with_completion_scheduler{std::move(source_scheduler)}, destination_scheduler);
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -444,22 +422,17 @@ int main()
         std::atomic<bool> source_scheduler_tag_invoke_overload_called{false};
         std::atomic<bool> source_scheduler_schedule_called{false};
         std::atomic<bool> source_scheduler_execute_called{false};
-        std::atomic<bool> destination_scheduler_tag_invoke_overload_called{
-            false};
+        std::atomic<bool> destination_scheduler_tag_invoke_overload_called{false};
         std::atomic<bool> destination_scheduler_schedule_called{false};
         std::atomic<bool> destination_scheduler_execute_called{false};
 
         scheduler_transfer source_scheduler{source_scheduler_schedule_called,
-            source_scheduler_execute_called,
-            source_scheduler_tag_invoke_overload_called};
-        scheduler_schedule_from destination_scheduler{
-            destination_scheduler_schedule_called,
-            destination_scheduler_execute_called,
-            destination_scheduler_tag_invoke_overload_called};
+            source_scheduler_execute_called, source_scheduler_tag_invoke_overload_called};
+        scheduler_schedule_from destination_scheduler{destination_scheduler_schedule_called,
+            destination_scheduler_execute_called, destination_scheduler_tag_invoke_overload_called};
 
         auto s = ex::transfer(
-            sender_with_completion_scheduler{std::move(source_scheduler)},
-            destination_scheduler);
+            sender_with_completion_scheduler{std::move(source_scheduler)}, destination_scheduler);
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -480,8 +453,8 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> scheduler_execute_called{false};
         auto s = ex::transfer(error_sender{},
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto r = error_callback_receiver<decltype(check_exception_ptr)>{
             check_exception_ptr, set_error_called};
         auto os = ex::connect(std::move(s), std::move(r));
@@ -508,8 +481,8 @@ int main()
         std::atomic<bool> scheduler_schedule_called{false};
         std::atomic<bool> scheduler_execute_called{false};
         auto s = ex::transfer(const_reference_error_sender{},
-            scheduler{scheduler_schedule_called, scheduler_execute_called,
-                tag_invoke_overload_called});
+            scheduler{
+                scheduler_schedule_called, scheduler_execute_called, tag_invoke_overload_called});
         auto r = error_callback_receiver<decltype(check_exception_ptr)>{
             check_exception_ptr, set_error_called};
         auto os = ex::connect(std::move(s), std::move(r));
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 c6696f5af8..8150daf5c9 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
@@ -31,16 +31,15 @@
 // guarded by whether the embedded storage can actually be used (i.e. if the
 // stored type is small enough) that path should never be taken.
 #if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Warray-bounds"
 #endif
 
 namespace pika::detail {
     template <typename T>
     struct empty_vtable_type
     {
-        static_assert(
-            sizeof(T) == 0, "No empty vtable type defined for given type T");
+        static_assert(sizeof(T) == 0, "No empty vtable type defined for given type T");
     };
 
     template <typename T>
@@ -56,8 +55,8 @@ namespace pika::detail {
     // - https://github.com/llvm/llvm-project/issues/53780
     // - https://github.com/llvm/llvm-project/commit/73b22935a7a863679021598db6a45fcfb62cd321
     // - https://reviews.llvm.org/D119615
-#if defined(PIKA_HAVE_CXX20_TRIVIAL_VIRTUAL_DESTRUCTOR) &&                     \
-    !(defined(PIKA_COMPUTE_CODE) && defined(PIKA_CLANG_VERSION) &&             \
+#if defined(PIKA_HAVE_CXX20_TRIVIAL_VIRTUAL_DESTRUCTOR) &&                                         \
+    !(defined(PIKA_COMPUTE_CODE) && defined(PIKA_CLANG_VERSION) &&                                 \
         (PIKA_CLANG_VERSION >= 140000) && (PIKA_CLANG_VERSION < 150000))
     template <typename T>
     inline constexpr empty_vtable_t<T> empty_vtable{};
@@ -88,8 +87,7 @@ namespace pika::detail {
     {
     protected:
         using base_type = Base;
-        static constexpr std::size_t embedded_storage_size =
-            EmbeddedStorageSize;
+        static constexpr std::size_t embedded_storage_size = EmbeddedStorageSize;
         static constexpr std::size_t alignment_size = AlignmentSize;
 
         // The union has two members:
@@ -100,29 +98,24 @@ namespace pika::detail {
         //   don't fit in the embedded storage.
         union
         {
-            std::aligned_storage_t<embedded_storage_size, alignment_size>
-                embedded_storage;
+            std::aligned_storage_t<embedded_storage_size, alignment_size> embedded_storage;
             base_type* heap_storage = nullptr;
         };
-        base_type* object =
-            const_cast<base_type*>(get_empty_vtable<base_type>());
+        base_type* object = const_cast<base_type*>(get_empty_vtable<base_type>());
 
         // Returns true when it's safe to use the embedded storage, i.e.
         // when the size and alignment of Impl are small enough.
         template <typename Impl>
         static constexpr bool can_use_embedded_storage()
         {
-            constexpr bool fits_storage =
-                sizeof(std::decay_t<Impl>) <= embedded_storage_size;
-            constexpr bool sufficiently_aligned =
-                alignof(std::decay_t<Impl>) <= alignment_size;
+            constexpr bool fits_storage = sizeof(std::decay_t<Impl>) <= embedded_storage_size;
+            constexpr bool sufficiently_aligned = alignof(std::decay_t<Impl>) <= alignment_size;
             return fits_storage && sufficiently_aligned;
         }
 
         bool using_embedded_storage() const noexcept
         {
-            return object ==
-                reinterpret_cast<base_type const*>(&embedded_storage);
+            return object == reinterpret_cast<base_type const*>(&embedded_storage);
         }
 
         void reset_vtable()
@@ -247,8 +240,7 @@ namespace pika::detail {
     class copyable_sbo_storage
       : public movable_sbo_storage<Base, EmbeddedStorageSize, AlignmentSize>
     {
-        using storage_base_type =
-            movable_sbo_storage<Base, EmbeddedStorageSize, AlignmentSize>;
+        using storage_base_type = movable_sbo_storage<Base, EmbeddedStorageSize, AlignmentSize>;
 
         using typename storage_base_type::base_type;
 
@@ -267,8 +259,7 @@ namespace pika::detail {
             {
                 if (other.using_embedded_storage())
                 {
-                    base_type* p =
-                        reinterpret_cast<base_type*>(&embedded_storage);
+                    base_type* p = reinterpret_cast<base_type*>(&embedded_storage);
                     other.get().clone_into(p);
                     object = p;
                 }
@@ -321,8 +312,7 @@ namespace pika::execution::experimental::detail {
         virtual void start() & noexcept = 0;
     };
 
-    struct PIKA_EXPORT empty_any_operation_state final
-      : any_operation_state_base
+    struct PIKA_EXPORT empty_any_operation_state final : any_operation_state_base
     {
         bool empty() const noexcept override;
         void start() & noexcept override;
@@ -331,11 +321,9 @@ namespace pika::execution::experimental::detail {
 
 namespace pika::detail {
     template <>
-    struct empty_vtable_type<
-        pika::execution::experimental::detail::any_operation_state_base>
+    struct empty_vtable_type<pika::execution::experimental::detail::any_operation_state_base>
     {
-        using type =
-            pika::execution::experimental::detail::empty_any_operation_state;
+        using type = pika::execution::experimental::detail::empty_any_operation_state;
     };
 }    // namespace pika::detail
 
@@ -348,8 +336,7 @@ namespace pika::execution::experimental::detail {
         template <typename Sender_, typename Receiver_>
         any_operation_state_impl(Sender_&& sender, Receiver_&& receiver)
           : operation_state(pika::execution::experimental::connect(
-                PIKA_FORWARD(Sender_, sender),
-                PIKA_FORWARD(Receiver_, receiver)))
+                PIKA_FORWARD(Sender_, sender), PIKA_FORWARD(Receiver_, receiver)))
         {
         }
 
@@ -364,8 +351,7 @@ namespace pika::execution::experimental::detail {
         using base_type = detail::any_operation_state_base;
         template <typename Sender, typename Receiver>
         using impl_type = detail::any_operation_state_impl<Sender, Receiver>;
-        using storage_type =
-            pika::detail::movable_sbo_storage<base_type, 8 * sizeof(void*)>;
+        using storage_type = pika::detail::movable_sbo_storage<base_type, 8 * sizeof(void*)>;
 
         storage_type storage{};
 
@@ -384,8 +370,7 @@ namespace pika::execution::experimental::detail {
         any_operation_state& operator=(any_operation_state const&) = delete;
 
         PIKA_EXPORT friend void tag_invoke(
-            pika::execution::experimental::start_t,
-            any_operation_state& os) noexcept;
+            pika::execution::experimental::start_t, any_operation_state& os) noexcept;
     };
 
     template <typename... Ts>
@@ -437,11 +422,9 @@ namespace pika::execution::experimental::detail {
 
 namespace pika::detail {
     template <typename... Ts>
-    struct empty_vtable_type<
-        pika::execution::experimental::detail::any_receiver_base<Ts...>>
+    struct empty_vtable_type<pika::execution::experimental::detail::any_receiver_base<Ts...>>
     {
-        using type =
-            pika::execution::experimental::detail::empty_any_receiver<Ts...>;
+        using type = pika::execution::experimental::detail::empty_any_receiver<Ts...>;
     };
 }    // namespace pika::detail
 
@@ -452,8 +435,8 @@ namespace pika::execution::experimental::detail {
         std::decay_t<Receiver> receiver;
 
         template <typename Receiver_,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Receiver_>, any_receiver_impl>>>
+            typename =
+                std::enable_if_t<!std::is_same_v<std::decay_t<Receiver_>, any_receiver_impl>>>
         explicit any_receiver_impl(Receiver_&& receiver)
           : receiver(PIKA_FORWARD(Receiver_, receiver))
         {
@@ -466,14 +449,12 @@ namespace pika::execution::experimental::detail {
 
         void set_value(Ts... ts) && override
         {
-            pika::execution::experimental::set_value(
-                PIKA_MOVE(receiver), PIKA_MOVE(ts)...);
+            pika::execution::experimental::set_value(PIKA_MOVE(receiver), PIKA_MOVE(ts)...);
         }
 
         void set_error(std::exception_ptr ep) && noexcept override
         {
-            pika::execution::experimental::set_error(
-                PIKA_MOVE(receiver), PIKA_MOVE(ep));
+            pika::execution::experimental::set_error(PIKA_MOVE(receiver), PIKA_MOVE(ep));
         }
 
         void set_stopped() && noexcept override
@@ -488,28 +469,23 @@ namespace pika::execution::experimental::detail {
         using base_type = detail::any_receiver_base<Ts...>;
         template <typename Receiver>
         using impl_type = detail::any_receiver_impl<Receiver, Ts...>;
-        using storage_type =
-            pika::detail::movable_sbo_storage<base_type, 4 * sizeof(void*)>;
+        using storage_type = pika::detail::movable_sbo_storage<base_type, 4 * sizeof(void*)>;
 
         storage_type storage{};
 
     public:
         template <typename Receiver,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Receiver>, any_receiver>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Receiver>, any_receiver>>>
         explicit any_receiver(Receiver&& receiver)
         {
-            storage.template store<impl_type<Receiver>>(
-                PIKA_FORWARD(Receiver, receiver));
+            storage.template store<impl_type<Receiver>>(PIKA_FORWARD(Receiver, receiver));
         }
 
         template <typename Receiver,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Receiver>, any_receiver>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Receiver>, any_receiver>>>
         any_receiver& operator=(Receiver&& receiver)
         {
-            storage.template store<impl_type<Receiver>>(
-                PIKA_FORWARD(Receiver, receiver));
+            storage.template store<impl_type<Receiver>>(PIKA_FORWARD(Receiver, receiver));
             return *this;
         }
 
@@ -519,8 +495,8 @@ namespace pika::execution::experimental::detail {
         any_receiver& operator=(any_receiver&&) = default;
         any_receiver& operator=(any_receiver const&) = delete;
 
-        friend void tag_invoke(pika::execution::experimental::set_value_t,
-            any_receiver&& r, Ts... ts) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_value_t, any_receiver&& r, Ts... ts) noexcept
         {
             // We first move the storage to a temporary variable so that
             // this any_receiver is empty after this set_value. Doing
@@ -530,8 +506,8 @@ namespace pika::execution::experimental::detail {
             PIKA_MOVE(moved_storage.get()).set_value(PIKA_MOVE(ts)...);
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_error_t,
-            any_receiver&& r, std::exception_ptr ep) noexcept
+        friend void tag_invoke(pika::execution::experimental::set_error_t, any_receiver&& r,
+            std::exception_ptr ep) noexcept
         {
             // We first move the storage to a temporary variable so that
             // this any_receiver is empty after this set_error. Doing
@@ -541,8 +517,8 @@ namespace pika::execution::experimental::detail {
             PIKA_MOVE(moved_storage.get()).set_error(PIKA_MOVE(ep));
         }
 
-        friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-            any_receiver&& r) noexcept
+        friend void tag_invoke(
+            pika::execution::experimental::set_stopped_t, any_receiver&& r) noexcept
         {
             // We first move the storage to a temporary variable so that
             // this any_receiver is empty after this set_stopped. Doing
@@ -553,8 +529,7 @@ namespace pika::execution::experimental::detail {
         }
 
         friend constexpr pika::execution::experimental::empty_env tag_invoke(
-            pika::execution::experimental::get_env_t,
-            any_receiver const&) noexcept
+            pika::execution::experimental::get_env_t, any_receiver const&) noexcept
         {
             return {};
         }
@@ -565,8 +540,7 @@ namespace pika::execution::experimental::detail {
     {
         virtual ~unique_any_sender_base() = default;
         virtual void move_into(void* p) = 0;
-        virtual any_operation_state connect(
-            any_receiver<Ts...>&& receiver) && = 0;
+        virtual any_operation_state connect(any_receiver<Ts...>&& receiver) && = 0;
         virtual bool empty() const noexcept
         {
             return false;
@@ -579,8 +553,7 @@ namespace pika::execution::experimental::detail {
         virtual any_sender_base* clone() const = 0;
         virtual void clone_into(void* p) const = 0;
         using unique_any_sender_base<Ts...>::connect;
-        virtual any_operation_state connect(
-            any_receiver<Ts...>&& receiver) const& = 0;
+        virtual any_operation_state connect(any_receiver<Ts...>&& receiver) const& = 0;
     };
 
     template <typename... Ts>
@@ -596,8 +569,7 @@ namespace pika::execution::experimental::detail {
             return true;
         }
 
-        [[noreturn]] any_operation_state connect(any_receiver<Ts...>&&) &&
-            override
+        [[noreturn]] any_operation_state connect(any_receiver<Ts...>&&) && override
         {
             throw_bad_any_call("unique_any_sender", "connect");
         }
@@ -626,14 +598,12 @@ namespace pika::execution::experimental::detail {
             return true;
         }
 
-        [[noreturn]] any_operation_state connect(
-            any_receiver<Ts...>&&) const& override
+        [[noreturn]] any_operation_state connect(any_receiver<Ts...>&&) const& override
         {
             throw_bad_any_call("any_sender", "connect");
         }
 
-        [[noreturn]] any_operation_state connect(any_receiver<Ts...>&&) &&
-            override
+        [[noreturn]] any_operation_state connect(any_receiver<Ts...>&&) && override
         {
             throw_bad_any_call("any_sender", "connect");
         }
@@ -645,8 +615,8 @@ namespace pika::execution::experimental::detail {
         std::decay_t<Sender> sender;
 
         template <typename Sender_,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Sender_>, unique_any_sender_impl>>>
+            typename =
+                std::enable_if_t<!std::is_same_v<std::decay_t<Sender_>, unique_any_sender_impl>>>
         explicit unique_any_sender_impl(Sender_&& sender)
           : sender(PIKA_FORWARD(Sender_, sender))
         {
@@ -669,8 +639,7 @@ namespace pika::execution::experimental::detail {
         std::decay_t<Sender> sender;
 
         template <typename Sender_,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Sender_>, any_sender_impl>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Sender_>, any_sender_impl>>>
         explicit any_sender_impl(Sender_&& sender)
           : sender(PIKA_FORWARD(Sender_, sender))
         {
@@ -691,8 +660,7 @@ namespace pika::execution::experimental::detail {
             new (p) any_sender_impl(sender);
         }
 
-        any_operation_state connect(
-            any_receiver<Ts...>&& receiver) const& override
+        any_operation_state connect(any_receiver<Ts...>&& receiver) const& override
         {
             return any_operation_state{sender, PIKA_MOVE(receiver)};
         }
@@ -739,8 +707,7 @@ namespace pika::execution::experimental {
         using base_type = detail::unique_any_sender_base<Ts...>;
         template <typename Sender>
         using impl_type = detail::unique_any_sender_impl<Sender, Ts...>;
-        using storage_type =
-            pika::detail::movable_sbo_storage<base_type, 4 * sizeof(void*)>;
+        using storage_type = pika::detail::movable_sbo_storage<base_type, 4 * sizeof(void*)>;
 
         storage_type storage{};
 
@@ -748,21 +715,17 @@ namespace pika::execution::experimental {
         unique_any_sender() = default;
 
         template <typename Sender,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Sender>, unique_any_sender>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Sender>, unique_any_sender>>>
         unique_any_sender(Sender&& sender)
         {
-            storage.template store<impl_type<Sender>>(
-                PIKA_FORWARD(Sender, sender));
+            storage.template store<impl_type<Sender>>(PIKA_FORWARD(Sender, sender));
         }
 
         template <typename Sender,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Sender>, unique_any_sender>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Sender>, unique_any_sender>>>
         unique_any_sender& operator=(Sender&& sender)
         {
-            storage.template store<impl_type<Sender>>(
-                PIKA_FORWARD(Sender, sender));
+            storage.template store<impl_type<Sender>>(PIKA_FORWARD(Sender, sender));
             return *this;
         }
 
@@ -772,8 +735,7 @@ namespace pika::execution::experimental {
         unique_any_sender& operator=(unique_any_sender&&) = default;
         unique_any_sender& operator=(unique_any_sender const&) = delete;
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         using value_types = Variant<Tuple<Ts...>>;
 
         template <template <typename...> class Variant>
@@ -781,16 +743,14 @@ namespace pika::execution::experimental {
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t(Ts...),
-                pika::execution::experimental::set_error_t(std::exception_ptr),
-                pika::execution::experimental::set_stopped_t()>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t(Ts...),
+            pika::execution::experimental::set_error_t(std::exception_ptr),
+            pika::execution::experimental::set_stopped_t()>;
 
         template <typename R>
         friend detail::any_operation_state
-        tag_invoke(pika::execution::experimental::connect_t,
-            unique_any_sender&& s, R&& r)
+        tag_invoke(pika::execution::experimental::connect_t, unique_any_sender&& s, R&& r)
         {
             // We first move the storage to a temporary variable so that this
             // any_sender is empty after this connect. Doing
@@ -803,8 +763,7 @@ namespace pika::execution::experimental {
 
         template <typename R>
         friend detail::any_operation_state
-        tag_invoke(pika::execution::experimental::connect_t,
-            unique_any_sender const&, R&&)
+        tag_invoke(pika::execution::experimental::connect_t, unique_any_sender const&, R&&)
         {
             static_assert(sizeof(R) == 0,
                 "Are you missing a std::move? unique_any_sender is not "
@@ -832,8 +791,7 @@ namespace pika::execution::experimental {
         using base_type = detail::any_sender_base<Ts...>;
         template <typename Sender>
         using impl_type = detail::any_sender_impl<Sender, Ts...>;
-        using storage_type =
-            pika::detail::copyable_sbo_storage<base_type, 4 * sizeof(void*)>;
+        using storage_type = pika::detail::copyable_sbo_storage<base_type, 4 * sizeof(void*)>;
 
         storage_type storage{};
 
@@ -841,8 +799,7 @@ namespace pika::execution::experimental {
         any_sender() = default;
 
         template <typename Sender,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Sender>, any_sender>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Sender>, any_sender>>>
         any_sender(Sender&& sender)
         {
             static_assert(std::is_copy_constructible_v<std::decay_t<Sender>>,
@@ -850,13 +807,11 @@ namespace pika::execution::experimental {
                 "constructible. Ensure the used sender type is copy "
                 "constructible or use unique_any_sender if you do not require "
                 "copyability.");
-            storage.template store<impl_type<Sender>>(
-                PIKA_FORWARD(Sender, sender));
+            storage.template store<impl_type<Sender>>(PIKA_FORWARD(Sender, sender));
         }
 
         template <typename Sender,
-            typename = std::enable_if_t<
-                !std::is_same_v<std::decay_t<Sender>, any_sender>>>
+            typename = std::enable_if_t<!std::is_same_v<std::decay_t<Sender>, any_sender>>>
         any_sender& operator=(Sender&& sender)
         {
             static_assert(std::is_copy_constructible_v<std::decay_t<Sender>>,
@@ -864,8 +819,7 @@ namespace pika::execution::experimental {
                 "constructible. Ensure the used sender type is copy "
                 "constructible or use unique_any_sender if you do not require "
                 "copyability.");
-            storage.template store<impl_type<Sender>>(
-                PIKA_FORWARD(Sender, sender));
+            storage.template store<impl_type<Sender>>(PIKA_FORWARD(Sender, sender));
             return *this;
         }
 
@@ -875,8 +829,7 @@ namespace pika::execution::experimental {
         any_sender& operator=(any_sender&&) = default;
         any_sender& operator=(any_sender const&) = default;
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         using value_types = Variant<Tuple<Ts...>>;
 
         template <template <typename...> class Variant>
@@ -884,24 +837,21 @@ namespace pika::execution::experimental {
 
         static constexpr bool sends_done = false;
 
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                pika::execution::experimental::set_value_t(Ts...),
-                pika::execution::experimental::set_error_t(std::exception_ptr),
-                pika::execution::experimental::set_stopped_t()>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            pika::execution::experimental::set_value_t(Ts...),
+            pika::execution::experimental::set_error_t(std::exception_ptr),
+            pika::execution::experimental::set_stopped_t()>;
 
         template <typename R>
         friend detail::any_operation_state
-        tag_invoke(pika::execution::experimental::connect_t,
-            any_sender const& s, R&& r)
+        tag_invoke(pika::execution::experimental::connect_t, any_sender const& s, R&& r)
         {
-            return s.storage.get().connect(
-                detail::any_receiver<Ts...>{PIKA_FORWARD(R, r)});
+            return s.storage.get().connect(detail::any_receiver<Ts...>{PIKA_FORWARD(R, r)});
         }
 
         template <typename R>
-        friend detail::any_operation_state tag_invoke(
-            pika::execution::experimental::connect_t, any_sender&& s, R&& r)
+        friend detail::any_operation_state
+        tag_invoke(pika::execution::experimental::connect_t, any_sender&& s, R&& r)
         {
             // We first move the storage to a temporary variable so that this
             // any_sender is empty after this connect. Doing
@@ -928,23 +878,21 @@ namespace pika::execution::experimental {
         auto make_any_sender_impl(Sender&& sender)
         {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-            using value_types_pack =
-                pika::execution::experimental::value_types_of_t<Sender,
-                    pika::execution::experimental::empty_env,
-                    pika::util::detail::pack, pika::util::detail::pack>;
+            using value_types_pack = pika::execution::experimental::value_types_of_t<Sender,
+                pika::execution::experimental::empty_env, 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::detail::pack, pika::util::detail::pack>;
+            using value_types_pack =
+                typename pika::execution::experimental::sender_traits<std::decay_t<Sender>>::
+                    template value_types<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 "
                 "sender to send exactly one variant");
             using single_value_type_variant =
-                typename pika::util::detail::at_index_impl<0,
-                    value_types_pack>::type;
-            using any_sender_type = pika::util::detail::change_pack_t<AnySender,
-                single_value_type_variant>;
+                typename pika::util::detail::at_index_impl<0, value_types_pack>::type;
+            using any_sender_type =
+                pika::util::detail::change_pack_t<AnySender, single_value_type_variant>;
 
             return any_sender_type(std::forward<Sender>(sender));
         }
@@ -953,39 +901,32 @@ namespace pika::execution::experimental {
     template <typename Sender, typename = std::enable_if_t<is_sender_v<Sender>>>
     auto make_unique_any_sender(Sender&& sender)
     {
-        return detail::make_any_sender_impl<unique_any_sender>(
-            std::forward<Sender>(sender));
+        return detail::make_any_sender_impl<unique_any_sender>(std::forward<Sender>(sender));
     }
 
     template <typename Sender, typename = std::enable_if_t<is_sender_v<Sender>>>
     auto make_any_sender(Sender&& sender)
     {
-        return detail::make_any_sender_impl<any_sender>(
-            std::forward<Sender>(sender));
+        return detail::make_any_sender_impl<any_sender>(std::forward<Sender>(sender));
     }
 }    // namespace pika::execution::experimental
 
 namespace pika::detail {
     template <typename... Ts>
-    struct empty_vtable_type<
-        pika::execution::experimental::detail::unique_any_sender_base<Ts...>>
+    struct empty_vtable_type<pika::execution::experimental::detail::unique_any_sender_base<Ts...>>
     {
-        using type =
-            pika::execution::experimental::detail::empty_unique_any_sender<
-                Ts...>;
+        using type = pika::execution::experimental::detail::empty_unique_any_sender<Ts...>;
     };
 
     template <typename... Ts>
-    struct empty_vtable_type<
-        pika::execution::experimental::detail::any_sender_base<Ts...>>
+    struct empty_vtable_type<pika::execution::experimental::detail::any_sender_base<Ts...>>
     {
-        using type =
-            pika::execution::experimental::detail::empty_any_sender<Ts...>;
+        using type = pika::execution::experimental::detail::empty_any_sender<Ts...>;
     };
 }    // namespace pika::detail
 
 #if defined(__GNUC__)
-#pragma GCC diagnostic pop
+# pragma GCC diagnostic pop
 #endif
 
 #include <pika/config/warnings_suffix.hpp>
diff --git a/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp b/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp
index 304c312200..b7fbf97691 100644
--- a/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/completion_scheduler.hpp
@@ -8,9 +8,9 @@
 
 #include <pika/config.hpp>
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
-#include <pika/execution_base/sender.hpp>
-#include <pika/functional/tag_invoke.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/sender.hpp>
+# include <pika/functional/tag_invoke.hpp>
 
 namespace pika::execution::experimental::detail {
     template <bool TagInvocable, typename CPO, typename Sender>
@@ -29,22 +29,20 @@ namespace pika::execution::experimental::detail {
     template <typename CPO, typename Sender>
     struct has_completion_scheduler
       : has_completion_scheduler_impl<
-            pika::functional::detail::is_tag_invocable_v<
-                get_completion_scheduler_t<CPO>,
+            pika::functional::detail::is_tag_invocable_v<get_completion_scheduler_t<CPO>,
                 std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>,
             CPO, Sender>
     {
     };
 
     template <typename CPO, typename Sender>
-    inline constexpr bool has_completion_scheduler_v =
-        has_completion_scheduler<CPO, Sender>::value;
+    inline constexpr bool has_completion_scheduler_v = has_completion_scheduler<CPO, Sender>::value;
 }    // namespace pika::execution::experimental::detail
 #else
-#include <pika/execution_base/sender.hpp>
-#include <pika/functional/tag_invoke.hpp>
+# include <pika/execution_base/sender.hpp>
+# include <pika/functional/tag_invoke.hpp>
 
-#include <type_traits>
+# include <type_traits>
 
 namespace pika::execution::experimental {
     template <typename CPO>
@@ -65,9 +63,9 @@ namespace pika::execution::experimental {
 
         template <typename CPO, typename Sender>
         struct has_completion_scheduler_impl<true, CPO, Sender>
-          : pika::execution::experimental::is_scheduler<std::invoke_result_t<
-                get_completion_scheduler_t<CPO>,
-                std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>>
+          : pika::execution::experimental::is_scheduler<
+                std::invoke_result_t<get_completion_scheduler_t<CPO>,
+                    std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>>
         {
         };
 
@@ -75,8 +73,7 @@ namespace pika::execution::experimental {
         struct has_completion_scheduler
           : has_completion_scheduler_impl<
                 std::is_invocable_v<get_completion_scheduler_t<CPO>,
-                    std::invoke_result_t<get_env_t,
-                        std::decay_t<Sender> const&>>,
+                    std::invoke_result_t<get_env_t, std::decay_t<Sender> const&>>,
                 CPO, Sender>
         {
         };
@@ -85,43 +82,37 @@ namespace pika::execution::experimental {
         inline constexpr bool has_completion_scheduler_v =
             has_completion_scheduler<CPO, Sender>::value;
 
-        template <bool HasCompletionScheduler, typename ReceiverCPO,
-            typename Sender, typename AlgorithmCPO, typename... Ts>
+        template <bool HasCompletionScheduler, typename ReceiverCPO, typename Sender,
+            typename AlgorithmCPO, typename... Ts>
         struct is_completion_scheduler_tag_invocable_impl : std::false_type
         {
         };
 
-        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
-            typename... Ts>
-        struct is_completion_scheduler_tag_invocable_impl<true, ReceiverCPO,
-            Sender, AlgorithmCPO, Ts...>
+        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO, typename... Ts>
+        struct is_completion_scheduler_tag_invocable_impl<true, ReceiverCPO, Sender, AlgorithmCPO,
+            Ts...>
           : std::integral_constant<bool,
                 std::is_invocable_v<AlgorithmCPO,
                     std::invoke_result_t<
-                        pika::execution::experimental::
-                            get_completion_scheduler_t<ReceiverCPO>,
-                        std::invoke_result_t<
-                            pika::execution::experimental::get_env_t,
+                        pika::execution::experimental::get_completion_scheduler_t<ReceiverCPO>,
+                        std::invoke_result_t<pika::execution::experimental::get_env_t,
                             std::decay_t<Sender> const&>>,
                     Sender, Ts...>>
         {
         };
 
-        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
-            typename... Ts>
+        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO, typename... Ts>
         struct is_completion_scheduler_tag_invocable
           : is_completion_scheduler_tag_invocable_impl<
-                pika::execution::experimental::detail::
-                    has_completion_scheduler_v<ReceiverCPO, Sender>,
+                pika::execution::experimental::detail::has_completion_scheduler_v<ReceiverCPO,
+                    Sender>,
                 ReceiverCPO, Sender, AlgorithmCPO, Ts...>
         {
         };
 
-        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
-            typename... Ts>
+        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO, typename... Ts>
         inline constexpr bool is_completion_scheduler_tag_invocable_v =
-            is_completion_scheduler_tag_invocable<ReceiverCPO, Sender,
-                AlgorithmCPO, Ts...>::value;
+            is_completion_scheduler_tag_invocable<ReceiverCPO, Sender, AlgorithmCPO, Ts...>::value;
 
     }    // namespace detail
 }    // namespace pika::execution::experimental
diff --git a/libs/pika/execution_base/include/pika/execution_base/receiver.hpp b/libs/pika/execution_base/include/pika/execution_base/receiver.hpp
index 3b8101412a..f043a25f5d 100644
--- a/libs/pika/execution_base/include/pika/execution_base/receiver.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/receiver.hpp
@@ -9,7 +9,7 @@
 
 #include <pika/config.hpp>
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 
 namespace pika::execution::experimental {
     template <typename Receiver>
@@ -31,16 +31,16 @@ namespace pika::execution::experimental {
     };
 }    // namespace pika::execution::experimental
 #else
-#include <pika/config/constexpr.hpp>
-#include <pika/functional/tag_invoke.hpp>
+# include <pika/config/constexpr.hpp>
+# include <pika/functional/tag_invoke.hpp>
 
-#include <exception>
-#include <type_traits>
-#include <utility>
+# include <exception>
+# include <type_traits>
+# include <utility>
 
 namespace pika::execution::experimental {
 
-#if defined(DOXYGEN)
+# if defined(DOXYGEN)
     /// set_value is a customization point object. The expression
     /// `pika::execution::set_value(r, as...)` is equivalent to:
     ///     * `r.set_value(as...)`, if that expression is valid. If the function selected
@@ -82,7 +82,7 @@ namespace pika::execution::experimental {
     /// The customization is implemented in terms of `pika::functional::detail::tag_invoke`.
     template <typename R, typename E>
     void set_error(R&& r, E&& e);
-#endif
+# endif
 
     /// Receiving values from asynchronous computations is handled by the `Receiver`
     /// concept. A `Receiver` needs to be able to receive an error or be marked as
@@ -160,8 +160,7 @@ namespace pika::execution::experimental {
 
     template <typename T, typename E>
     struct is_receiver
-      : detail::is_receiver_impl<
-            std::is_move_constructible<std::decay_t<T>>::value &&
+      : detail::is_receiver_impl<std::is_move_constructible<std::decay_t<T>>::value &&
                 std::is_constructible<std::decay_t<T>, T>::value,
             T, E>
     {
@@ -182,15 +181,13 @@ namespace pika::execution::experimental {
 
         template <typename T, typename... As>
         struct is_receiver_of_impl<true, T, As...>
-          : std::integral_constant<bool,
-                std::is_invocable_v<set_value_t, std::decay_t<T>&&, As...>>
+          : std::integral_constant<bool, std::is_invocable_v<set_value_t, std::decay_t<T>&&, As...>>
         {
         };
     }    // namespace detail
 
     template <typename T, typename... As>
-    struct is_receiver_of
-      : detail::is_receiver_of_impl<is_receiver_v<T>, T, As...>
+    struct is_receiver_of : detail::is_receiver_of_impl<is_receiver_v<T>, T, As...>
     {
     };
 
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 20824660dc..ac0b45ea3c 100644
--- a/libs/pika/execution_base/include/pika/execution_base/sender.hpp
+++ b/libs/pika/execution_base/include/pika/execution_base/sender.hpp
@@ -8,7 +8,7 @@
 
 #include <pika/config.hpp>
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 
 namespace pika::execution::experimental {
     template <typename Scheduler>
@@ -39,20 +39,20 @@ namespace pika::execution::experimental {
     };
 }    // namespace pika::execution::experimental
 #else
-#include <pika/config/constexpr.hpp>
-#include <pika/execution_base/operation_state.hpp>
-#include <pika/execution_base/receiver.hpp>
-#include <pika/functional/detail/tag_fallback_invoke.hpp>
-#include <pika/type_support/equality.hpp>
-
-#include <cstddef>
-#include <exception>
-#include <memory>
-#include <type_traits>
-#include <utility>
+# include <pika/config/constexpr.hpp>
+# include <pika/execution_base/operation_state.hpp>
+# include <pika/execution_base/receiver.hpp>
+# include <pika/functional/detail/tag_fallback_invoke.hpp>
+# include <pika/type_support/equality.hpp>
+
+# include <cstddef>
+# include <exception>
+# include <memory>
+# include <type_traits>
+# include <utility>
 
 namespace pika::execution::experimental {
-#if defined(DOXYGEN)
+# if defined(DOXYGEN)
     /// connect is a customization point object.
     /// For some subexpression `s` and `r`, let `S` be the type such that `decltype((s))`
     /// is `S` and let `R` be the type such that `decltype((r))` is `R`. The result of
@@ -93,7 +93,7 @@ namespace pika::execution::experimental {
     /// The customization is implemented in terms of
     /// `pika::functional::detail::tag_invoke`.
 
-#endif
+# endif
     // We define an empty dummy type for compatibility. Senders can define both
     // value/error_types for our non-conformant implementation, and
     // completion_signatures for the conformant implementation. Senders do not
@@ -190,15 +190,13 @@ namespace pika::execution::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::detail::is_equality_comparable_v<Executor>>>
-          : std::true_type
+                pika::detail::is_equality_comparable_v<Executor>>> : std::true_type
         {
         };
 
         template <typename Executor>
         struct is_executor_base
-          : is_executor_of_base_impl<std::decay_t<Executor>,
-                invocable_archetype>
+          : is_executor_of_base_impl<std::decay_t<Executor>, invocable_archetype>
         {
         };
     }    // namespace detail
@@ -211,8 +209,7 @@ namespace pika::execution::experimental {
 
         template <typename S, typename R>
         struct has_member_connect<S, R,
-            std::void_t<decltype(std::declval<S>().connect(std::declval<R>()))>>
-          : std::true_type
+            std::void_t<decltype(std::declval<S>().connect(std::declval<R>()))>> : std::true_type
         {
         };
     }    // namespace detail
@@ -268,8 +265,7 @@ namespace pika::execution::experimental {
         };
 
         template <typename S>
-        struct has_member_schedule<S,
-            std::void_t<decltype(std::declval<S>().schedule())>>
+        struct has_member_schedule<S, std::void_t<decltype(std::declval<S>().schedule())>>
           : std::true_type
         {
         };
@@ -300,22 +296,19 @@ namespace pika::execution::experimental {
                     std::is_invocable_v<connect_t, Sender&, Receiver const&> ||
                     std::is_invocable_v<connect_t, Sender const&, Receiver&&> ||
                     std::is_invocable_v<connect_t, Sender const&, Receiver&> ||
-                    std::is_invocable_v<connect_t, Sender const&,
-                        Receiver const&>>
+                    std::is_invocable_v<connect_t, Sender const&, Receiver const&>>
         {
         };
     }    // namespace detail
 
     template <typename Sender, typename Receiver>
     struct is_sender_to
-      : detail::is_sender_to_impl<
-            is_sender_v<Sender> && is_receiver_v<Receiver>, Sender, Receiver>
+      : detail::is_sender_to_impl<is_sender_v<Sender> && is_receiver_v<Receiver>, Sender, Receiver>
     {
     };
 
     template <typename Sender, typename Receiver>
-    inline constexpr bool is_sender_to_v =
-        is_sender_to<Sender, Receiver>::value;
+    inline constexpr bool is_sender_to_v = is_sender_to<Sender, Receiver>::value;
 
     namespace detail {
         template <typename... As>
@@ -324,8 +317,8 @@ namespace pika::execution::experimental {
         struct variant_mock;
 
         template <typename Sender>
-        constexpr bool has_value_types(
-            typename Sender::template value_types<tuple_mock, variant_mock>*)
+        constexpr bool
+        has_value_types(typename Sender::template value_types<tuple_mock, variant_mock>*)
         {
             return true;
         }
@@ -337,8 +330,7 @@ namespace pika::execution::experimental {
         }
 
         template <typename Sender>
-        constexpr bool
-        has_error_types(typename Sender::template error_types<variant_mock>*)
+        constexpr bool has_error_types(typename Sender::template error_types<variant_mock>*)
         {
             return true;
         }
@@ -364,8 +356,7 @@ namespace pika::execution::experimental {
         template <typename Sender>
         struct has_sender_types
           : std::integral_constant<bool,
-                has_value_types<Sender>(nullptr) &&
-                    has_error_types<Sender>(nullptr) &&
+                has_value_types<Sender>(nullptr) && has_error_types<Sender>(nullptr) &&
                     has_sends_done<Sender>(nullptr)>
         {
         };
@@ -376,10 +367,8 @@ namespace pika::execution::experimental {
         template <typename Sender>
         struct sender_traits_base<true /* HasSenderTraits */, Sender>
         {
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
-            using value_types =
-                typename Sender::template value_types<Tuple, Variant>;
+            template <template <typename...> class Tuple, template <typename...> class Variant>
+            using value_types = typename Sender::template value_types<Tuple, Variant>;
 
             template <template <typename...> class Variant>
             using error_types = typename Sender::template error_types<Variant>;
@@ -397,16 +386,14 @@ namespace pika::execution::experimental {
         template <typename Sender>
         struct is_typed_sender
           : std::integral_constant<bool,
-                is_sender<Sender>::value &&
-                    detail::has_sender_types<Sender>::value>
+                is_sender<Sender>::value && detail::has_sender_types<Sender>::value>
         {
         };
     }    // namespace detail
 
     template <typename Sender>
     struct sender_traits
-      : detail::sender_traits_base<detail::has_sender_types<Sender>::value,
-            Sender>
+      : detail::sender_traits_base<detail::has_sender_types<Sender>::value, Sender>
     {
     };
 
@@ -421,16 +408,14 @@ namespace pika::execution::experimental {
     };
 
     namespace detail {
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
+        template <template <typename...> class Tuple, template <typename...> class Variant>
         struct value_types
         {
             template <typename Sender>
             struct apply
             {
-                using type =
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template value_types<Tuple, Variant>;
+                using type = typename pika::execution::experimental::sender_traits<
+                    Sender>::template value_types<Tuple, Variant>;
             };
         };
 
@@ -440,9 +425,8 @@ namespace pika::execution::experimental {
             template <typename Sender>
             struct apply
             {
-                using type =
-                    typename pika::execution::experimental::sender_traits<
-                        Sender>::template error_types<Variant>;
+                using type = typename pika::execution::experimental::sender_traits<
+                    Sender>::template error_types<Variant>;
             };
         };
     }    // namespace detail
@@ -470,12 +454,10 @@ namespace pika::execution::experimental {
     {
     };
 
-    inline constexpr struct get_env_t final
-      : pika::functional::detail::tag_fallback<get_env_t>
+    inline constexpr struct get_env_t final : pika::functional::detail::tag_fallback<get_env_t>
     {
         template <typename T>
-        friend constexpr auto
-        tag_fallback_invoke(get_env_t const&, T const&) noexcept
+        friend constexpr auto tag_fallback_invoke(get_env_t const&, T const&) noexcept
         {
             if constexpr (is_sender_v<T>)
             {
diff --git a/libs/pika/execution_base/tests/unit/any_sender.cpp b/libs/pika/execution_base/tests/unit/any_sender.cpp
index 9c7cf75ef0..13f0f48222 100644
--- a/libs/pika/execution_base/tests/unit/any_sender.cpp
+++ b/libs/pika/execution_base/tests/unit/any_sender.cpp
@@ -33,8 +33,7 @@ struct custom_type_non_copyable
     custom_type_non_copyable(custom_type_non_copyable&&) = default;
     custom_type_non_copyable& operator=(custom_type_non_copyable&&) = default;
     custom_type_non_copyable(custom_type_non_copyable const&) = delete;
-    custom_type_non_copyable& operator=(
-        custom_type_non_copyable const&) = delete;
+    custom_type_non_copyable& operator=(custom_type_non_copyable const&) = delete;
 };
 
 template <typename... Ts>
@@ -42,8 +41,7 @@ struct non_copyable_sender
 {
     std::tuple<std::decay_t<Ts>...> ts;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<Ts...>>;
 
     template <template <class...> class Variant>
@@ -51,15 +49,13 @@ struct non_copyable_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(Ts...),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(Ts...),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     non_copyable_sender() = default;
     template <typename T,
-        typename = std::enable_if_t<
-            !std::is_same_v<std::decay_t<T>, non_copyable_sender>>>
+        typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, non_copyable_sender>>>
     non_copyable_sender(T&& t)
       : ts(std::forward<T>(t))
     {
@@ -80,8 +76,7 @@ struct non_copyable_sender
         std::decay_t<R> r;
         std::tuple<std::decay_t<Ts>...> ts;
 
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             pika::util::detail::invoke_fused(
                 pika::util::detail::bind_front(
@@ -92,8 +87,7 @@ struct non_copyable_sender
 
     template <typename R>
     friend operation_state<R>
-    tag_invoke(pika::execution::experimental::connect_t,
-        non_copyable_sender&& s, R&& r) noexcept
+    tag_invoke(pika::execution::experimental::connect_t, non_copyable_sender&& s, R&& r) noexcept
     {
         return {std::forward<R>(r), std::move(s.ts)};
     }
@@ -104,8 +98,7 @@ struct sender
 {
     std::tuple<std::decay_t<Ts>...> ts;
 
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<Ts...>>;
 
     template <template <class...> class Variant>
@@ -113,14 +106,12 @@ struct sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(Ts...),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(Ts...),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     sender() = default;
-    template <typename T,
-        typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, sender>>>
+    template <typename T, typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, sender>>>
     sender(T&& t)
       : ts(std::forward<T>(t))
     {
@@ -141,8 +132,7 @@ struct sender
         std::decay_t<R> r;
         std::tuple<std::decay_t<Ts>...> ts;
 
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             pika::util::detail::invoke_fused(
                 pika::util::detail::bind_front(
@@ -175,23 +165,21 @@ struct large_non_copyable_sender : non_copyable_sender<Ts...>
 
     large_non_copyable_sender() = default;
     template <typename T,
-        typename = std::enable_if_t<
-            !std::is_same_v<std::decay_t<T>, large_non_copyable_sender>>>
+        typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, large_non_copyable_sender>>>
     large_non_copyable_sender(T&& t)
       : non_copyable_sender<Ts...>(std::forward<T>(t))
     {
     }
     template <typename T1, typename T2, typename... Ts_>
     large_non_copyable_sender(T1&& t1, T2&& t2, Ts_&&... ts)
-      : non_copyable_sender<Ts...>(std::forward<T1>(t1), std::forward<T2>(t2),
-            std::forward<Ts_>(ts)...)
+      : non_copyable_sender<Ts...>(
+            std::forward<T1>(t1), std::forward<T2>(t2), std::forward<Ts_>(ts)...)
     {
     }
     large_non_copyable_sender(large_non_copyable_sender&&) = default;
     large_non_copyable_sender(large_non_copyable_sender const&) = delete;
     large_non_copyable_sender& operator=(large_non_copyable_sender&&) = default;
-    large_non_copyable_sender& operator=(
-        large_non_copyable_sender const&) = delete;
+    large_non_copyable_sender& operator=(large_non_copyable_sender const&) = delete;
 };
 
 template <typename... Ts>
@@ -203,16 +191,14 @@ struct large_sender : sender<Ts...>
 
     large_sender() = default;
     template <typename T,
-        typename =
-            std::enable_if_t<!std::is_same_v<std::decay_t<T>, large_sender>>>
+        typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, large_sender>>>
     large_sender(T&& t)
       : sender<Ts...>(std::forward<T>(t))
     {
     }
     template <typename T1, typename T2, typename... Ts_>
     large_sender(T1&& t1, T2&& t2, Ts_&&... ts)
-      : sender<Ts...>(std::forward<T1>(t1), std::forward<T2>(t2),
-            std::forward<Ts_>(ts)...)
+      : sender<Ts...>(std::forward<T1>(t1), std::forward<T2>(t2), std::forward<Ts_>(ts)...)
     {
     }
     large_sender(large_sender&&) = default;
@@ -223,8 +209,7 @@ struct large_sender : sender<Ts...>
 
 struct error_sender
 {
-    template <template <typename...> class Tuple,
-        template <typename...> class Variant>
+    template <template <typename...> class Tuple, template <typename...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <typename...> class Variant>
@@ -232,17 +217,15 @@ struct error_sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures =
-        pika::execution::experimental::completion_signatures<
-            pika::execution::experimental::set_value_t(),
-            pika::execution::experimental::set_error_t(std::exception_ptr)>;
+    using completion_signatures = pika::execution::experimental::completion_signatures<
+        pika::execution::experimental::set_value_t(),
+        pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
     template <typename R>
     struct operation_state
     {
         std::decay_t<R> r;
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             try
             {
@@ -250,8 +233,7 @@ struct error_sender
             }
             catch (...)
             {
-                pika::execution::experimental::set_error(
-                    std::move(os.r), std::current_exception());
+                pika::execution::experimental::set_error(std::move(os.r), std::current_exception());
             }
         }
     };
@@ -271,29 +253,28 @@ struct callback_receiver
     std::atomic<bool>& set_value_called;
 
     template <typename E>
-    friend void tag_invoke(pika::execution::experimental::set_error_t,
-        callback_receiver&&, E&&) noexcept
+    friend void
+    tag_invoke(pika::execution::experimental::set_error_t, callback_receiver&&, E&&) noexcept
     {
         PIKA_TEST(false);
     }
 
-    friend void tag_invoke(pika::execution::experimental::set_stopped_t,
-        callback_receiver&&) noexcept
+    friend void tag_invoke(
+        pika::execution::experimental::set_stopped_t, callback_receiver&&) noexcept
     {
         PIKA_TEST(false);
     };
 
     template <typename... Ts>
-    friend auto tag_invoke(pika::execution::experimental::set_value_t,
-        callback_receiver&& r, Ts&&... ts) noexcept
+    friend auto tag_invoke(
+        pika::execution::experimental::set_value_t, callback_receiver&& r, Ts&&... ts) noexcept
     {
         PIKA_INVOKE(std::move(r.f), std::forward<Ts>(ts)...);
         r.set_value_called = true;
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        callback_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, callback_receiver const&) noexcept
     {
         return {};
     }
@@ -303,8 +284,8 @@ struct error_receiver
 {
     std::atomic<bool>& set_error_called;
 
-    friend void tag_invoke(pika::execution::experimental::set_error_t,
-        error_receiver&& r, std::exception_ptr&& e) noexcept
+    friend void tag_invoke(pika::execution::experimental::set_error_t, error_receiver&& r,
+        std::exception_ptr&& e) noexcept
     {
         try
         {
@@ -321,22 +302,20 @@ struct error_receiver
         r.set_error_called = true;
     }
 
-    friend void tag_invoke(
-        pika::execution::experimental::set_stopped_t, error_receiver&&) noexcept
+    friend void tag_invoke(pika::execution::experimental::set_stopped_t, error_receiver&&) noexcept
     {
         PIKA_TEST(false);
     };
 
     template <typename... Ts>
-    friend void tag_invoke(pika::execution::experimental::set_value_t,
-        error_receiver&&, Ts&&...) noexcept
+    friend void
+    tag_invoke(pika::execution::experimental::set_value_t, error_receiver&&, Ts&&...) noexcept
     {
         PIKA_TEST(false);
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        error_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, error_receiver const&) noexcept
     {
         return {};
     }
@@ -371,8 +350,7 @@ void test_any_sender(F&& f, Ts&&... ts)
 
     {
         std::atomic<bool> set_value_called{false};
-        auto os = ex::connect(
-            std::move(as1), callback_receiver<F>{f, set_value_called});
+        auto os = ex::connect(std::move(as1), callback_receiver<F>{f, set_value_called});
         ex::start(os);
         PIKA_TEST(set_value_called);
         PIKA_TEST(as1.empty());
@@ -390,8 +368,7 @@ void test_any_sender(F&& f, Ts&&... ts)
 
     {
         std::atomic<bool> set_value_called{false};
-        auto os = ex::connect(
-            std::move(as2), callback_receiver<F>{f, set_value_called});
+        auto os = ex::connect(std::move(as2), callback_receiver<F>{f, set_value_called});
         ex::start(os);
         PIKA_TEST(set_value_called);
         PIKA_TEST(as2.empty());
@@ -458,8 +435,7 @@ void test_unique_any_sender(F&& f, Ts&&... ts)
     // We expect set_value to be called here
     {
         std::atomic<bool> set_value_called = false;
-        auto os = ex::connect(
-            std::move(as2), callback_receiver<F>{f, set_value_called});
+        auto os = ex::connect(std::move(as2), callback_receiver<F>{f, set_value_called});
         ex::start(os);
         PIKA_TEST(set_value_called);
         PIKA_TEST(as2.empty());
@@ -652,10 +628,8 @@ void test_globals()
 {
     // TODO: No ensure_started implementation in reference implementation.
 #if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-    global_unique_any_sender =
-        std::move(global_unique_any_sender) | ex::ensure_started();
-    global_any_sender =
-        std::move(global_any_sender) | ex::ensure_started() | ex::split();
+    global_unique_any_sender = std::move(global_unique_any_sender) | ex::ensure_started();
+    global_any_sender = std::move(global_any_sender) | ex::ensure_started() | ex::split();
 #endif
 }
 
@@ -673,23 +647,17 @@ void test_empty_any_sender()
 void test_make_any_sender()
 {
     static_assert(
-        std::is_same_v<decltype(ex::make_unique_any_sender(ex::just())),
-            ex::unique_any_sender<>>);
-    static_assert(std::is_same_v<decltype(ex::make_any_sender(ex::just())),
-        ex::any_sender<>>);
+        std::is_same_v<decltype(ex::make_unique_any_sender(ex::just())), ex::unique_any_sender<>>);
+    static_assert(std::is_same_v<decltype(ex::make_any_sender(ex::just())), ex::any_sender<>>);
+    static_assert(std::is_same_v<decltype(ex::make_unique_any_sender(ex::just(3))),
+        ex::unique_any_sender<int>>);
+    static_assert(std::is_same_v<decltype(ex::make_any_sender(ex::just(42))), ex::any_sender<int>>);
     static_assert(
-        std::is_same_v<decltype(ex::make_unique_any_sender(ex::just(3))),
-            ex::unique_any_sender<int>>);
-    static_assert(std::is_same_v<decltype(ex::make_any_sender(ex::just(42))),
-        ex::any_sender<int>>);
-    static_assert(std::is_same_v<decltype(ex::make_unique_any_sender(
-                                     ex::just(3, std::string("hello")))),
-        ex::unique_any_sender<int, std::string>>);
-    static_assert(std::is_same_v<decltype(ex::make_any_sender(
-                                     ex::just(42, std::string("bye")))),
+        std::is_same_v<decltype(ex::make_unique_any_sender(ex::just(3, std::string("hello")))),
+            ex::unique_any_sender<int, std::string>>);
+    static_assert(std::is_same_v<decltype(ex::make_any_sender(ex::just(42, std::string("bye")))),
         ex::any_sender<int, std::string>>);
-    static_assert(!std::is_same_v<decltype(ex::make_any_sender(
-                                      ex::just(42, std::string("bye")))),
+    static_assert(!std::is_same_v<decltype(ex::make_any_sender(ex::just(42, std::string("bye")))),
                   ex::any_sender<int, std::string, double>>);
 }
 
@@ -734,8 +702,7 @@ int main()
         42, 3.14);
 
     test_unique_any_sender<large_sender>([] {});
-    test_unique_any_sender<large_sender, int>(
-        [](int x) { PIKA_TEST_EQ(x, 42); }, 42);
+    test_unique_any_sender<large_sender, int>([](int x) { PIKA_TEST_EQ(x, 42); }, 42);
     test_unique_any_sender<large_sender, int, double>(
         [](int x, double y) {
             PIKA_TEST_EQ(x, 42);
@@ -744,16 +711,14 @@ int main()
         42, 3.14);
 
     test_unique_any_sender<non_copyable_sender>([] {});
-    test_unique_any_sender<non_copyable_sender, int>(
-        [](int x) { PIKA_TEST_EQ(x, 42); }, 42);
+    test_unique_any_sender<non_copyable_sender, int>([](int x) { PIKA_TEST_EQ(x, 42); }, 42);
     test_unique_any_sender<non_copyable_sender, int, double>(
         [](int x, double y) {
             PIKA_TEST_EQ(x, 42);
             PIKA_TEST_EQ(y, 3.14);
         },
         42, 3.14);
-    test_unique_any_sender<non_copyable_sender, int, double,
-        custom_type_non_copyable>(
+    test_unique_any_sender<non_copyable_sender, int, double, custom_type_non_copyable>(
         [](int x, double y, custom_type_non_copyable z) {
             PIKA_TEST_EQ(x, 42);
             PIKA_TEST_EQ(y, 3.14);
@@ -762,16 +727,14 @@ int main()
         42, 3.14, custom_type_non_copyable(43));
 
     test_unique_any_sender<large_non_copyable_sender>([] {});
-    test_unique_any_sender<large_non_copyable_sender, int>(
-        [](int x) { PIKA_TEST_EQ(x, 42); }, 42);
+    test_unique_any_sender<large_non_copyable_sender, int>([](int x) { PIKA_TEST_EQ(x, 42); }, 42);
     test_unique_any_sender<large_non_copyable_sender, int, double>(
         [](int x, double y) {
             PIKA_TEST_EQ(x, 42);
             PIKA_TEST_EQ(y, 3.14);
         },
         42, 3.14);
-    test_unique_any_sender<large_non_copyable_sender, int, double,
-        custom_type_non_copyable>(
+    test_unique_any_sender<large_non_copyable_sender, int, double, custom_type_non_copyable>(
         [](int x, double y, custom_type_non_copyable z) {
             PIKA_TEST_EQ(x, 42);
             PIKA_TEST_EQ(y, 3.14);
diff --git a/libs/pika/execution_base/tests/unit/basic_receiver.cpp b/libs/pika/execution_base/tests/unit/basic_receiver.cpp
index 5b48b0cc02..509734800a 100644
--- a/libs/pika/execution_base/tests/unit/basic_receiver.cpp
+++ b/libs/pika/execution_base/tests/unit/basic_receiver.cpp
@@ -27,8 +27,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, receiver_1&&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, receiver_1&&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -38,8 +37,7 @@ namespace mylib {
             value_called = true;
         }
 
-        friend constexpr ex::empty_env tag_invoke(
-            ex::get_env_t, receiver_1 const&) noexcept
+        friend constexpr ex::empty_env tag_invoke(ex::get_env_t, receiver_1 const&) noexcept
         {
             return {};
         }
@@ -57,8 +55,7 @@ namespace mylib {
             error_called = true;
         }
 
-        friend constexpr ex::empty_env tag_invoke(
-            ex::get_env_t, receiver_2 const&) noexcept
+        friend constexpr ex::empty_env tag_invoke(ex::get_env_t, receiver_2 const&) noexcept
         {
             return {};
         }
@@ -71,8 +68,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, receiver_3&&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, receiver_3&&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -82,8 +78,7 @@ namespace mylib {
             value_called = true;
         }
 
-        friend constexpr ex::empty_env tag_invoke(
-            ex::get_env_t, receiver_3 const&) noexcept
+        friend constexpr ex::empty_env tag_invoke(ex::get_env_t, receiver_3 const&) noexcept
         {
             return {};
         }
@@ -96,8 +91,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_1&&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, non_receiver_1&&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -115,8 +109,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_2&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, non_receiver_2&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -134,8 +127,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_3&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, non_receiver_3&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -153,8 +145,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_4&&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, non_receiver_4&&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -164,8 +155,7 @@ namespace mylib {
             value_called = true;
         }
 
-        friend constexpr ex::empty_env tag_invoke(
-            ex::get_env_t, non_receiver_4 const&) noexcept
+        friend constexpr ex::empty_env tag_invoke(ex::get_env_t, non_receiver_4 const&) noexcept
         {
             return {};
         }
@@ -178,8 +168,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_5&&, std::exception_ptr) noexcept
+        friend void tag_invoke(ex::set_error_t, non_receiver_5&&, std::exception_ptr) noexcept
         {
             error_called = true;
         }
@@ -192,8 +181,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_6&&, std::exception_ptr)
+        friend void tag_invoke(ex::set_error_t, non_receiver_6&&, std::exception_ptr)
         {
             error_called = true;
         }
@@ -206,8 +194,7 @@ namespace mylib {
             done_called = true;
         }
 
-        friend void tag_invoke(
-            ex::set_error_t, non_receiver_7&&, std::exception_ptr)
+        friend void tag_invoke(ex::set_error_t, non_receiver_7&&, std::exception_ptr)
         {
             error_called = true;
         }
@@ -221,16 +208,15 @@ template <typename Receiver, typename... Ts>
 struct receiver_of_helper
 {
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-    static constexpr bool value = ex::receiver_of<Receiver,
-        ex::completion_signatures<ex::set_value_t(Ts...)>>;
+    static constexpr bool value =
+        ex::receiver_of<Receiver, ex::completion_signatures<ex::set_value_t(Ts...)>>;
 #else
     static constexpr bool value = ex::is_receiver_of_v<Receiver, Ts...>;
 #endif
 };
 
 template <typename Receiver, typename... Ts>
-inline constexpr bool receiver_of_helper_v =
-    receiver_of_helper<Receiver, Ts...>::value;
+inline constexpr bool receiver_of_helper_v = receiver_of_helper<Receiver, Ts...>::value;
 
 template <typename Receiver, typename Error = std::exception_ptr>
 struct receiver_helper
@@ -243,34 +229,30 @@ struct receiver_helper
 };
 
 template <typename Receiver, typename Error = std::exception_ptr>
-inline constexpr bool receiver_helper_v =
-    receiver_helper<Receiver, Error>::value;
+inline constexpr bool receiver_helper_v = receiver_helper<Receiver, Error>::value;
 
 int main()
 {
-    static_assert(ex::is_receiver_v<mylib::receiver_1>,
-        "mylib::receiver_1 should be a receiver");
+    static_assert(ex::is_receiver_v<mylib::receiver_1>, "mylib::receiver_1 should be a receiver");
     static_assert(receiver_of_helper_v<mylib::receiver_1, int>,
         "mylib::receiver_1 should be a receiver of an int");
     static_assert(!receiver_of_helper_v<mylib::receiver_1, std::string>,
         "mylib::receiver_1 should not be a receiver of a std::string");
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-    static_assert(receiver_helper_v<mylib::receiver_2>,
-        "mylib::receiver_2 should be a receiver");
+    static_assert(receiver_helper_v<mylib::receiver_2>, "mylib::receiver_2 should be a receiver");
 #else
     // This implicitly checks if the receiver has a set_error std::exception_ptr
     // overload.
     static_assert(!receiver_helper_v<mylib::receiver_2>,
         "mylib::receiver_2 should not be a receiver of std::exception_ptr");
-    static_assert(receiver_helper_v<mylib::receiver_2, int>,
-        "mylib::receiver_2 should be a receiver");
+    static_assert(
+        receiver_helper_v<mylib::receiver_2, int>, "mylib::receiver_2 should be a receiver");
 #endif
     static_assert(!receiver_of_helper_v<mylib::receiver_2, int>,
         "mylib::receiver_2 should not be a receiver of int");
 
-    static_assert(ex::is_receiver_v<mylib::receiver_3>,
-        "mylib::receiver_3 should be a receiver");
+    static_assert(ex::is_receiver_v<mylib::receiver_3>, "mylib::receiver_3 should be a receiver");
     static_assert(receiver_of_helper_v<mylib::receiver_3, int>,
         "mylib::receiver_3 should be a receiver of an int");
     static_assert(!receiver_of_helper_v<mylib::receiver_3, std::string>,
@@ -288,8 +270,8 @@ int main()
         "mylib::non_receiver_3 should not be a receiver");
     static_assert(!receiver_of_helper_v<mylib::non_receiver_3, int>,
         "mylib::non_receiver_3 should not be a receiver of int");
-    static_assert(ex::is_receiver_v<mylib::non_receiver_4>,
-        "mylib::non_receiver_4 should be a receiver");
+    static_assert(
+        ex::is_receiver_v<mylib::non_receiver_4>, "mylib::non_receiver_4 should be a receiver");
     static_assert(!receiver_of_helper_v<mylib::non_receiver_4, int>,
         "mylib::non_receiver_4 should not be a receiver of int");
     static_assert(!ex::is_receiver_v<mylib::non_receiver_5>,
diff --git a/libs/pika/execution_base/tests/unit/basic_schedule.cpp b/libs/pika/execution_base/tests/unit/basic_schedule.cpp
index 6028b6830b..8e5863d798 100644
--- a/libs/pika/execution_base/tests/unit/basic_schedule.cpp
+++ b/libs/pika/execution_base/tests/unit/basic_schedule.cpp
@@ -21,8 +21,7 @@ static std::size_t tag_invoke_schedule_calls = 0;
 template <typename Scheduler>
 struct sender
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <class...> class Variant>
@@ -30,13 +29,12 @@ struct sender
 
     static constexpr bool sends_done = false;
 
-    using completion_signatures = ex::completion_signatures<ex::set_value_t(),
-        ex::set_error_t(std::exception_ptr)>;
+    using completion_signatures =
+        ex::completion_signatures<ex::set_value_t(), ex::set_error_t(std::exception_ptr)>;
 
     struct operation_state
     {
-        friend operation_state tag_invoke(
-            ex::start_t, operation_state&) noexcept
+        friend operation_state tag_invoke(ex::start_t, operation_state&) noexcept
         {
             return {};
         }
@@ -51,8 +49,7 @@ struct sender
     struct env
     {
         friend Scheduler tag_invoke(
-            ex::get_completion_scheduler_t<ex::set_value_t>,
-            env const&) noexcept
+            ex::get_completion_scheduler_t<ex::set_value_t>, env const&) noexcept
         {
             return {};
         }
@@ -121,16 +118,11 @@ sender<scheduler_2> tag_invoke(ex::schedule_t, scheduler_2)
 
 int main()
 {
-    static_assert(!ex::is_scheduler_v<non_scheduler_1>,
-        "non_scheduler_1 is not a scheduler");
-    static_assert(!ex::is_scheduler_v<non_scheduler_2>,
-        "non_scheduler_2 is not a scheduler");
-    static_assert(!ex::is_scheduler_v<non_scheduler_3>,
-        "non_scheduler_3 is not a scheduler");
-    static_assert(
-        ex::is_scheduler_v<scheduler_1>, "scheduler_1 is a scheduler");
-    static_assert(
-        ex::is_scheduler_v<scheduler_2>, "scheduler_2 is a scheduler");
+    static_assert(!ex::is_scheduler_v<non_scheduler_1>, "non_scheduler_1 is not a scheduler");
+    static_assert(!ex::is_scheduler_v<non_scheduler_2>, "non_scheduler_2 is not a scheduler");
+    static_assert(!ex::is_scheduler_v<non_scheduler_3>, "non_scheduler_3 is not a scheduler");
+    static_assert(ex::is_scheduler_v<scheduler_1>, "scheduler_1 is a scheduler");
+    static_assert(ex::is_scheduler_v<scheduler_2>, "scheduler_2 is a scheduler");
 
     scheduler_1 s1;
     auto snd1 = ex::schedule(s1);
diff --git a/libs/pika/execution_base/tests/unit/basic_sender.cpp b/libs/pika/execution_base/tests/unit/basic_sender.cpp
index b9ba3bdd93..a45aa39403 100644
--- a/libs/pika/execution_base/tests/unit/basic_sender.cpp
+++ b/libs/pika/execution_base/tests/unit/basic_sender.cpp
@@ -35,8 +35,7 @@ struct non_sender_2
 
 struct non_sender_3
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     static constexpr bool sends_done = false;
@@ -44,8 +43,7 @@ struct non_sender_3
 
 struct non_sender_4
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 
     template <template <class...> class Variant>
@@ -65,17 +63,13 @@ struct non_sender_6
 
 struct non_sender_7
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<>>;
 };
 
 struct receiver
 {
-    friend void tag_invoke(
-        ex::set_error_t, receiver&&, std::exception_ptr) noexcept
-    {
-    }
+    friend void tag_invoke(ex::set_error_t, receiver&&, std::exception_ptr) noexcept {}
 
     friend void tag_invoke(ex::set_stopped_t, receiver&&) noexcept {}
 
@@ -84,8 +78,7 @@ struct receiver
         r.i.get() = v;
     }
 
-    friend constexpr ex::empty_env tag_invoke(
-        ex::get_env_t, receiver const&) noexcept
+    friend constexpr ex::empty_env tag_invoke(ex::get_env_t, receiver const&) noexcept
     {
         return {};
     }
@@ -95,8 +88,7 @@ struct receiver
 
 struct sender_1
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<int>>;
 
     template <template <class...> class Variant>
@@ -105,8 +97,7 @@ struct sender_1
     static constexpr bool sends_done = false;
 
     using completion_signatures =
-        ex::completion_signatures<ex::set_value_t(int),
-            ex::set_error_t(std::exception_ptr)>;
+        ex::completion_signatures<ex::set_value_t(int), ex::set_error_t(std::exception_ptr)>;
 
     struct operation_state
     {
@@ -126,8 +117,7 @@ struct sender_1
 
 struct sender_2
 {
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
+    template <template <class...> class Tuple, template <class...> class Variant>
     using value_types = Variant<Tuple<int>>;
 
     template <template <class...> class Variant>
@@ -136,8 +126,7 @@ struct sender_2
     static constexpr bool sends_done = false;
 
     using completion_signatures =
-        ex::completion_signatures<ex::set_value_t(int),
-            ex::set_error_t(std::exception_ptr)>;
+        ex::completion_signatures<ex::set_value_t(int), ex::set_error_t(std::exception_ptr)>;
 
     struct operation_state
     {
@@ -159,10 +148,7 @@ static std::size_t void_receiver_set_value_calls = 0;
 
 struct void_receiver
 {
-    friend void tag_invoke(
-        ex::set_error_t, void_receiver&&, std::exception_ptr) noexcept
-    {
-    }
+    friend void tag_invoke(ex::set_error_t, void_receiver&&, std::exception_ptr) noexcept {}
 
     friend void tag_invoke(ex::set_stopped_t, void_receiver&&) noexcept {}
 
@@ -171,8 +157,7 @@ struct void_receiver
         ++void_receiver_set_value_calls;
     }
 
-    friend constexpr ex::empty_env tag_invoke(
-        ex::get_env_t, void_receiver const&) noexcept
+    friend constexpr ex::empty_env tag_invoke(ex::get_env_t, void_receiver const&) noexcept
     {
         return {};
     }
@@ -186,8 +171,7 @@ constexpr bool unspecialized(...)
 }
 
 template <typename Sender>
-constexpr bool
-unspecialized(typename ex::sender_traits<Sender>::__unspecialized*)
+constexpr bool unspecialized(typename ex::sender_traits<Sender>::__unspecialized*)
 {
     return true;
 }
@@ -196,70 +180,52 @@ unspecialized(typename ex::sender_traits<Sender>::__unspecialized*)
 int main()
 {
 #if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
+    static_assert(unspecialized<void>(nullptr), "void should not have sender_traits");
     static_assert(
-        unspecialized<void>(nullptr), "void should not have sender_traits");
-    static_assert(unspecialized<std::nullptr_t>(nullptr),
-        "std::nullptr_t should not have sender_traits");
-    static_assert(unspecialized<int>(nullptr),
-        "non_sender_1 should not have sender_traits");
-    static_assert(unspecialized<double>(nullptr),
-        "non_sender_1 should not have sender_traits");
-    static_assert(unspecialized<non_sender_1>(nullptr),
-        "non_sender_1 should not have sender_traits");
-    static_assert(unspecialized<non_sender_2>(nullptr),
-        "non_sender_2 should not have sender_traits");
-    static_assert(unspecialized<non_sender_3>(nullptr),
-        "non_sender_3 should not have sender_traits");
-    static_assert(unspecialized<non_sender_4>(nullptr),
-        "non_sender_4 should not have sender_traits");
-    static_assert(unspecialized<non_sender_5>(nullptr),
-        "non_sender_5 should not have sender_traits");
-    static_assert(unspecialized<non_sender_6>(nullptr),
-        "non_sender_6 should not have sender_traits");
-    static_assert(unspecialized<non_sender_7>(nullptr),
-        "non_sender_7 should not have sender_traits");
-    static_assert(!unspecialized<sender_1>(nullptr),
-        "sender_1 should have sender_traits");
-    static_assert(!unspecialized<sender_2>(nullptr),
-        "sender_2 should have sender_traits");
-#endif
-
-    static_assert(!ex::is_sender_v<void>, "void is not a sender");
+        unspecialized<std::nullptr_t>(nullptr), "std::nullptr_t should not have sender_traits");
+    static_assert(unspecialized<int>(nullptr), "non_sender_1 should not have sender_traits");
+    static_assert(unspecialized<double>(nullptr), "non_sender_1 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<std::nullptr_t>, "std::nullptr_t is not a sender");
-    static_assert(!ex::is_sender_v<int>, "int is not a sender");
-    static_assert(!ex::is_sender_v<double>, "double is not a sender");
+        unspecialized<non_sender_1>(nullptr), "non_sender_1 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<non_sender_1>, "non_sender_1 is not a sender");
+        unspecialized<non_sender_2>(nullptr), "non_sender_2 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<non_sender_2>, "non_sender_2 is not a sender");
+        unspecialized<non_sender_3>(nullptr), "non_sender_3 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<non_sender_3>, "non_sender_3 is not a sender");
+        unspecialized<non_sender_4>(nullptr), "non_sender_4 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<non_sender_4>, "non_sender_4 is not a sender");
+        unspecialized<non_sender_5>(nullptr), "non_sender_5 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<non_sender_5>, "non_sender_5 is not a sender");
+        unspecialized<non_sender_6>(nullptr), "non_sender_6 should not have sender_traits");
     static_assert(
-        !ex::is_sender_v<non_sender_6>, "non_sender_6 is not a sender");
-    static_assert(
-        !ex::is_sender_v<non_sender_7>, "non_sender_7 is not a sender");
+        unspecialized<non_sender_7>(nullptr), "non_sender_7 should not have sender_traits");
+    static_assert(!unspecialized<sender_1>(nullptr), "sender_1 should have sender_traits");
+    static_assert(!unspecialized<sender_2>(nullptr), "sender_2 should have sender_traits");
+#endif
+
+    static_assert(!ex::is_sender_v<void>, "void is not a sender");
+    static_assert(!ex::is_sender_v<std::nullptr_t>, "std::nullptr_t is not a sender");
+    static_assert(!ex::is_sender_v<int>, "int is not a sender");
+    static_assert(!ex::is_sender_v<double>, "double is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_1>, "non_sender_1 is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_2>, "non_sender_2 is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_3>, "non_sender_3 is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_4>, "non_sender_4 is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_5>, "non_sender_5 is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_6>, "non_sender_6 is not a sender");
+    static_assert(!ex::is_sender_v<non_sender_7>, "non_sender_7 is not a sender");
     static_assert(ex::is_sender_v<sender_1>, "sender_1 is a sender");
     static_assert(ex::is_sender_v<sender_2>, "sender_2 is a sender");
 
-    static_assert(ex::is_sender_to_v<sender_1, receiver>,
-        "sender_1 is a sender to receiver");
-    static_assert(ex::is_sender_to_v<sender_1, receiver>,
-        "sender_1 is a sender to receiver");
-    static_assert(!ex::is_sender_to_v<sender_1, non_sender_1>,
-        "sender_1 is not a sender to non_sender_1");
-    static_assert(!ex::is_sender_to_v<sender_1, sender_1>,
-        "sender_1 is not a sender to sender_1");
-    static_assert(ex::is_sender_to_v<sender_2, receiver>,
-        "sender_2 is a sender to receiver");
-    static_assert(!ex::is_sender_to_v<sender_2, non_sender_2>,
-        "sender_2 is not a sender to non_sender_2");
-    static_assert(!ex::is_sender_to_v<sender_2, sender_2>,
-        "sender_2 is not a sender to sender_2");
+    static_assert(ex::is_sender_to_v<sender_1, receiver>, "sender_1 is a sender to receiver");
+    static_assert(ex::is_sender_to_v<sender_1, receiver>, "sender_1 is a sender to receiver");
+    static_assert(
+        !ex::is_sender_to_v<sender_1, non_sender_1>, "sender_1 is not a sender to non_sender_1");
+    static_assert(!ex::is_sender_to_v<sender_1, sender_1>, "sender_1 is not a sender to sender_1");
+    static_assert(ex::is_sender_to_v<sender_2, receiver>, "sender_2 is a sender to receiver");
+    static_assert(
+        !ex::is_sender_to_v<sender_2, non_sender_2>, "sender_2 is not a sender to non_sender_2");
+    static_assert(!ex::is_sender_to_v<sender_2, sender_2>, "sender_2 is not a sender to sender_2");
 
     {
         int i = 1;
diff --git a/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp b/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
index 792e022b6c..ba51475c3a 100644
--- a/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/std_thread_scheduler.hpp
@@ -46,8 +46,8 @@ namespace pika::execution::experimental {
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
 
             template <typename Receiver_,
-                typename = std::enable_if_t<std::is_same_v<
-                    std::decay_t<Receiver_>, std::decay_t<Receiver>>>>
+                typename = std::enable_if_t<
+                    std::is_same_v<std::decay_t<Receiver_>, std::decay_t<Receiver>>>>
             operation_state(Receiver_&& receiver)
               : receiver(PIKA_FORWARD(Receiver_, receiver))
             {
@@ -62,8 +62,7 @@ namespace pika::execution::experimental {
                 pika::detail::try_catch_exception_ptr(
                     [&]() {
                         std::thread t{[&os]() mutable {
-                            pika::execution::experimental::set_value(
-                                PIKA_MOVE(os.receiver));
+                            pika::execution::experimental::set_value(PIKA_MOVE(os.receiver));
                         }};
                         t.detach();
                     },
@@ -78,8 +77,7 @@ namespace pika::execution::experimental {
         {
             using is_sender = void;
 
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
+            template <template <typename...> class Tuple, template <typename...> class Variant>
             using value_types = Variant<Tuple<>>;
 
             template <template <typename...> class Variant>
@@ -87,11 +85,9 @@ namespace pika::execution::experimental {
 
             static constexpr bool sends_done = false;
 
-            using completion_signatures =
-                pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_value_t(),
-                    pika::execution::experimental::set_error_t(
-                        std::exception_ptr)>;
+            using completion_signatures = pika::execution::experimental::completion_signatures<
+                pika::execution::experimental::set_value_t(),
+                pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
             template <typename Receiver>
             friend operation_state<Receiver>
@@ -111,8 +107,7 @@ namespace pika::execution::experimental {
                 }
             };
 
-            friend constexpr env tag_invoke(
-                pika::execution::experimental::get_env_t, sender const&)
+            friend constexpr env tag_invoke(pika::execution::experimental::get_env_t, sender const&)
             {
                 return {};
             }
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
index de125d376e..c3766fd6bc 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
@@ -29,8 +29,7 @@ namespace pika::execution::experimental {
     struct thread_pool_scheduler
     {
         constexpr thread_pool_scheduler() = default;
-        explicit thread_pool_scheduler(
-            pika::threads::detail::thread_pool_base* pool)
+        explicit thread_pool_scheduler(pika::threads::detail::thread_pool_base* pool)
           : pool_(pool)
         {
         }
@@ -39,8 +38,7 @@ namespace pika::execution::experimental {
         bool operator==(thread_pool_scheduler const& rhs) const noexcept
         {
             return pool_ == rhs.pool_ && priority_ == rhs.priority_ &&
-                stacksize_ == rhs.stacksize_ &&
-                schedulehint_ == rhs.schedulehint_;
+                stacksize_ == rhs.stacksize_ && schedulehint_ == rhs.schedulehint_;
         }
 
         bool operator!=(thread_pool_scheduler const& rhs) const noexcept
@@ -55,10 +53,8 @@ namespace pika::execution::experimental {
         }
 
         // support with_priority property
-        friend thread_pool_scheduler tag_invoke(
-            pika::execution::experimental::with_priority_t,
-            thread_pool_scheduler const& scheduler,
-            pika::execution::thread_priority priority)
+        friend thread_pool_scheduler tag_invoke(pika::execution::experimental::with_priority_t,
+            thread_pool_scheduler const& scheduler, pika::execution::thread_priority priority)
         {
             auto sched_with_priority = scheduler;
             sched_with_priority.priority_ = priority;
@@ -66,17 +62,14 @@ namespace pika::execution::experimental {
         }
 
         friend pika::execution::thread_priority tag_invoke(
-            pika::execution::experimental::get_priority_t,
-            thread_pool_scheduler const& scheduler)
+            pika::execution::experimental::get_priority_t, thread_pool_scheduler const& scheduler)
         {
             return scheduler.priority_;
         }
 
         // support with_stacksize property
-        friend thread_pool_scheduler tag_invoke(
-            pika::execution::experimental::with_stacksize_t,
-            thread_pool_scheduler const& scheduler,
-            pika::execution::thread_stacksize stacksize)
+        friend thread_pool_scheduler tag_invoke(pika::execution::experimental::with_stacksize_t,
+            thread_pool_scheduler const& scheduler, pika::execution::thread_stacksize stacksize)
         {
             auto sched_with_stacksize = scheduler;
             sched_with_stacksize.stacksize_ = stacksize;
@@ -84,17 +77,14 @@ namespace pika::execution::experimental {
         }
 
         friend pika::execution::thread_stacksize tag_invoke(
-            pika::execution::experimental::get_stacksize_t,
-            thread_pool_scheduler const& scheduler)
+            pika::execution::experimental::get_stacksize_t, thread_pool_scheduler const& scheduler)
         {
             return scheduler.stacksize_;
         }
 
         // support with_hint property
-        friend thread_pool_scheduler tag_invoke(
-            pika::execution::experimental::with_hint_t,
-            thread_pool_scheduler const& scheduler,
-            pika::execution::thread_schedule_hint hint)
+        friend thread_pool_scheduler tag_invoke(pika::execution::experimental::with_hint_t,
+            thread_pool_scheduler const& scheduler, pika::execution::thread_schedule_hint hint)
         {
             auto sched_with_hint = scheduler;
             sched_with_hint.schedulehint_ = hint;
@@ -102,8 +92,7 @@ namespace pika::execution::experimental {
         }
 
         friend pika::execution::thread_schedule_hint tag_invoke(
-            pika::execution::experimental::get_hint_t,
-            thread_pool_scheduler const& scheduler)
+            pika::execution::experimental::get_hint_t, thread_pool_scheduler const& scheduler)
         {
             return scheduler.schedulehint_;
         }
@@ -118,8 +107,7 @@ namespace pika::execution::experimental {
             return sched_with_annotation;
         }
 
-        friend thread_pool_scheduler tag_invoke(
-            pika::execution::experimental::with_annotation_t,
+        friend thread_pool_scheduler tag_invoke(pika::execution::experimental::with_annotation_t,
             thread_pool_scheduler const& scheduler, std::string annotation)
         {
             auto sched_with_annotation = scheduler;
@@ -129,8 +117,7 @@ namespace pika::execution::experimental {
         }
 
         // support get_annotation property
-        friend constexpr char const* tag_invoke(
-            pika::execution::experimental::get_annotation_t,
+        friend constexpr char const* tag_invoke(pika::execution::experimental::get_annotation_t,
             thread_pool_scheduler const& scheduler) noexcept
         {
             return scheduler.annotation_;
@@ -141,15 +128,13 @@ namespace pika::execution::experimental {
         {
             pika::detail::thread_description desc(f, fallback_annotation);
             threads::detail::thread_init_data data(
-                threads::detail::make_thread_function_nullary(
-                    PIKA_FORWARD(F, f)),
-                desc, priority_, schedulehint_, stacksize_);
+                threads::detail::make_thread_function_nullary(PIKA_FORWARD(F, f)), desc, priority_,
+                schedulehint_, stacksize_);
             threads::detail::register_work(data, pool_);
         }
 
         template <typename F>
-        friend void
-        tag_invoke(execute_t, thread_pool_scheduler const& sched, F&& f)
+        friend void tag_invoke(execute_t, thread_pool_scheduler const& sched, F&& f)
         {
             sched.execute(PIKA_FORWARD(F, f), sched.get_fallback_annotation());
         }
@@ -162,8 +147,8 @@ namespace pika::execution::experimental {
             char const* fallback_annotation;
 
             template <typename Scheduler_, typename Receiver_>
-            operation_state(Scheduler_&& scheduler, Receiver_&& receiver,
-                char const* fallback_annotation)
+            operation_state(
+                Scheduler_&& scheduler, Receiver_&& receiver, char const* fallback_annotation)
               : scheduler(PIKA_FORWARD(Scheduler_, scheduler))
               , receiver(PIKA_FORWARD(Receiver_, receiver))
               , fallback_annotation(fallback_annotation)
@@ -182,8 +167,7 @@ namespace pika::execution::experimental {
                     [&]() {
                         os.scheduler.execute(
                             [receiver = PIKA_MOVE(os.receiver)]() mutable {
-                                pika::execution::experimental::set_value(
-                                    PIKA_MOVE(receiver));
+                                pika::execution::experimental::set_value(PIKA_MOVE(receiver));
                             },
                             os.fallback_annotation);
                     },
@@ -205,11 +189,9 @@ namespace pika::execution::experimental {
             // sender so that if the scheduler has no annotation, the annotation
             // is instead taken from the context creating the sender, not from
             // the context when the task is actually spawned (if different).
-            char const* fallback_annotation =
-                scheduler.get_fallback_annotation();
+            char const* fallback_annotation = scheduler.get_fallback_annotation();
 
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
+            template <template <typename...> class Tuple, template <typename...> class Variant>
             using value_types = Variant<Tuple<>>;
 
             template <template <typename...> class Variant>
@@ -217,50 +199,44 @@ namespace pika::execution::experimental {
 
             static constexpr bool sends_done = false;
 
-            using completion_signatures =
-                pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_value_t(),
-                    pika::execution::experimental::set_error_t(
-                        std::exception_ptr)>;
+            using completion_signatures = pika::execution::experimental::completion_signatures<
+                pika::execution::experimental::set_value_t(),
+                pika::execution::experimental::set_error_t(std::exception_ptr)>;
 
             template <typename Receiver>
             friend operation_state<Scheduler, Receiver>
             tag_invoke(connect_t, sender&& s, Receiver&& receiver)
             {
-                return {PIKA_MOVE(s.scheduler),
-                    PIKA_FORWARD(Receiver, receiver), s.fallback_annotation};
+                return {PIKA_MOVE(s.scheduler), PIKA_FORWARD(Receiver, receiver),
+                    s.fallback_annotation};
             }
 
             template <typename Receiver>
             friend operation_state<Scheduler, Receiver>
             tag_invoke(connect_t, sender const& s, Receiver&& receiver)
             {
-                return {s.scheduler, PIKA_FORWARD(Receiver, receiver),
-                    s.fallback_annotation};
+                return {s.scheduler, PIKA_FORWARD(Receiver, receiver), s.fallback_annotation};
             }
 
             struct env
             {
                 PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
 
-                friend auto tag_invoke(
-                    pika::execution::experimental::get_completion_scheduler_t<
-                        pika::execution::experimental::set_value_t>,
+                friend auto tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
+                                           pika::execution::experimental::set_value_t>,
                     env const& e) noexcept
                 {
                     return e.scheduler;
                 }
             };
 
-            friend env tag_invoke(
-                pika::execution::experimental::get_env_t, sender const& s)
+            friend env tag_invoke(pika::execution::experimental::get_env_t, sender const& s)
             {
                 return {s.scheduler};
             }
         };
 
-        friend sender<thread_pool_scheduler> tag_invoke(
-            schedule_t, thread_pool_scheduler&& sched)
+        friend sender<thread_pool_scheduler> tag_invoke(schedule_t, thread_pool_scheduler&& sched)
         {
             return {PIKA_MOVE(sched)};
         }
@@ -291,23 +267,21 @@ namespace pika::execution::experimental {
         // want to use implementation details of it.
 #if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         template <typename Sender, PIKA_CONCEPT_REQUIRES_(is_sender_v<Sender>)>
-        friend auto tag_invoke(schedule_from_t,
-            thread_pool_scheduler&& scheduler, Sender&& predecessor_sender)
+        friend auto
+        tag_invoke(schedule_from_t, thread_pool_scheduler&& scheduler, Sender&& predecessor_sender)
         {
-            return schedule_from_detail::schedule_from_sender<Sender,
-                thread_pool_scheduler>{PIKA_FORWARD(Sender, predecessor_sender),
-                with_annotation(
-                    PIKA_MOVE(scheduler), scheduler.get_fallback_annotation())};
+            return schedule_from_detail::schedule_from_sender<Sender, thread_pool_scheduler>{
+                PIKA_FORWARD(Sender, predecessor_sender),
+                with_annotation(PIKA_MOVE(scheduler), scheduler.get_fallback_annotation())};
         }
 
         template <typename Sender, PIKA_CONCEPT_REQUIRES_(is_sender_v<Sender>)>
-        friend auto tag_invoke(schedule_from_t,
-            thread_pool_scheduler const& scheduler, Sender&& predecessor_sender)
+        friend auto tag_invoke(
+            schedule_from_t, thread_pool_scheduler const& scheduler, Sender&& predecessor_sender)
         {
-            return schedule_from_detail::schedule_from_sender<Sender,
-                thread_pool_scheduler>{PIKA_FORWARD(Sender, predecessor_sender),
-                with_annotation(
-                    scheduler, scheduler.get_fallback_annotation())};
+            return schedule_from_detail::schedule_from_sender<Sender, thread_pool_scheduler>{
+                PIKA_FORWARD(Sender, predecessor_sender),
+                with_annotation(scheduler, scheduler.get_fallback_annotation())};
         }
 #endif
         /// \endcond
@@ -323,14 +297,12 @@ namespace pika::execution::experimental {
             }
 
             // Next is the annotation from the current context scheduling work
-            pika::threads::detail::thread_id_type id =
-                pika::threads::detail::get_self_id();
+            pika::threads::detail::thread_id_type id = pika::threads::detail::get_self_id();
             if (id)
             {
                 pika::detail::thread_description desc =
                     pika::threads::detail::get_thread_description(id);
-                if (desc.kind() ==
-                    pika::detail::thread_description::data_type_description)
+                if (desc.kind() == pika::detail::thread_description::data_type_description)
                 {
                     return desc.get_description();
                 }
@@ -345,10 +317,8 @@ namespace pika::execution::experimental {
 
         pika::threads::detail::thread_pool_base* pool_ =
             pika::threads::detail::get_self_or_default_pool();
-        pika::execution::thread_priority priority_ =
-            pika::execution::thread_priority::normal;
-        pika::execution::thread_stacksize stacksize_ =
-            pika::execution::thread_stacksize::small_;
+        pika::execution::thread_priority priority_ = pika::execution::thread_priority::normal;
+        pika::execution::thread_stacksize stacksize_ = pika::execution::thread_stacksize::small_;
         pika::execution::thread_schedule_hint schedulehint_{};
         char const* annotation_ = nullptr;
         /// \endcond
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
index 80905010ed..324c07d5d2 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler_bulk.hpp
@@ -8,7 +8,7 @@
 
 #include <pika/config.hpp>
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-#include <pika/execution_base/p2300_forward.hpp>
+# include <pika/execution_base/p2300_forward.hpp>
 #endif
 
 #include <pika/assert.hpp>
@@ -69,8 +69,7 @@ namespace pika::thread_pool_bulk_detail {
 
     public:
         template <typename Sender_, typename Shape_, typename F_>
-        thread_pool_bulk_sender(
-            pika::execution::experimental::thread_pool_scheduler&& scheduler,
+        thread_pool_bulk_sender(pika::execution::experimental::thread_pool_scheduler&& scheduler,
             Sender_&& sender, Shape_&& shape, F_&& f)
           : scheduler(PIKA_MOVE(scheduler))
           , sender(PIKA_FORWARD(Sender_, sender))
@@ -81,43 +80,35 @@ namespace pika::thread_pool_bulk_detail {
         thread_pool_bulk_sender(thread_pool_bulk_sender&&) = default;
         thread_pool_bulk_sender(thread_pool_bulk_sender const&) = default;
         thread_pool_bulk_sender& operator=(thread_pool_bulk_sender&&) = default;
-        thread_pool_bulk_sender& operator=(
-            thread_pool_bulk_sender const&) = default;
+        thread_pool_bulk_sender& operator=(thread_pool_bulk_sender const&) = default;
 
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
         using is_sender = void;
 
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types =
-            pika::execution::experimental::value_types_of_t<Sender,
-                pika::execution::experimental::empty_env, Tuple, Variant>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = pika::execution::experimental::value_types_of_t<Sender,
+            pika::execution::experimental::empty_env, Tuple, Variant>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                pika::execution::experimental::error_types_of_t<Sender,
-                    pika::execution::experimental::empty_env, Variant>,
+        using error_types = pika::util::detail::unique_t<
+            pika::util::detail::prepend_t<pika::execution::experimental::error_types_of_t<Sender,
+                                              pika::execution::experimental::empty_env, Variant>,
                 std::exception_ptr>>;
 
         using completion_signatures =
             pika::execution::experimental::make_completion_signatures<Sender,
                 pika::execution::experimental::empty_env,
                 pika::execution::experimental::completion_signatures<
-                    pika::execution::experimental::set_error_t(
-                        std::exception_ptr)>>;
+                    pika::execution::experimental::set_error_t(std::exception_ptr)>>;
 #else
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types =
-            typename pika::execution::experimental::sender_traits<
-                Sender>::template value_types<Tuple, Variant>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = typename pika::execution::experimental::sender_traits<
+            Sender>::template value_types<Tuple, Variant>;
 
         template <template <typename...> class Variant>
-        using error_types =
-            pika::util::detail::unique_t<pika::util::detail::prepend_t<
-                typename pika::execution::experimental::sender_traits<
-                    Sender>::template error_types<Variant>,
+        using error_types = pika::util::detail::unique_t<
+            pika::util::detail::prepend_t<typename pika::execution::experimental::sender_traits<
+                                              Sender>::template error_types<Variant>,
                 std::exception_ptr>>;
 
         static constexpr bool sends_done = false;
@@ -134,20 +125,17 @@ namespace pika::thread_pool_bulk_detail {
                 operation_state* op_state;
 
                 template <typename E>
-                friend void
-                tag_invoke(pika::execution::experimental::set_error_t,
-                    bulk_receiver&& r, E&& e) noexcept
+                friend void tag_invoke(
+                    pika::execution::experimental::set_error_t, bulk_receiver&& r, E&& e) noexcept
                 {
                     pika::execution::experimental::set_error(
                         PIKA_MOVE(r.op_state->receiver), PIKA_FORWARD(E, e));
                 }
 
                 friend void tag_invoke(
-                    pika::execution::experimental::set_stopped_t,
-                    bulk_receiver&& r) noexcept
+                    pika::execution::experimental::set_stopped_t, bulk_receiver&& r) noexcept
                 {
-                    pika::execution::experimental::set_stopped(
-                        PIKA_MOVE(r.op_state->receiver));
+                    pika::execution::experimental::set_stopped(PIKA_MOVE(r.op_state->receiver));
                 };
 
                 struct task_function;
@@ -168,20 +156,15 @@ namespace pika::thread_pool_bulk_detail {
                     template <typename Ts>
                     void do_work_chunk(Ts& ts, std::uint32_t const index) const
                     {
-                        auto const i_begin =
-                            static_cast<size_type>(index) * task_f->chunk_size;
-                        auto const i_end =
-                            (std::min)(static_cast<size_type>(index + 1) *
-                                    task_f->chunk_size,
-                                task_f->n);
+                        auto const i_begin = static_cast<size_type>(index) * task_f->chunk_size;
+                        auto const i_end = (std::min)(
+                            static_cast<size_type>(index + 1) * task_f->chunk_size, task_f->n);
                         auto it = pika::util::begin(op_state->shape);
                         std::advance(it, i_begin);
                         for (std::uint32_t i = i_begin; i < i_end; ++i)
                         {
                             pika::util::detail::invoke_fused(
-                                pika::util::detail::bind_front(
-                                    op_state->f, *it),
-                                ts);
+                                pika::util::detail::bind_front(op_state->f, *it), ts);
                             ++it;
                         }
                     }
@@ -191,12 +174,11 @@ namespace pika::thread_pool_bulk_detail {
                     // queue owned by worker_thread. It then tries to steal
                     // chunks from neighboring threads.
                     template <typename Ts,
-                        typename = std::enable_if_t<!std::is_same_v<
-                            std::decay_t<Ts>, pika::detail::monostate>>>
+                        typename = std::enable_if_t<
+                            !std::is_same_v<std::decay_t<Ts>, pika::detail::monostate>>>
                     void operator()(Ts& ts) const
                     {
-                        auto& local_queue =
-                            op_state->queues[task_f->worker_thread].data_;
+                        auto& local_queue = op_state->queues[task_f->worker_thread].data_;
 
                         // Handle local queue first
                         std::optional<std::uint32_t> index;
@@ -206,14 +188,12 @@ namespace pika::thread_pool_bulk_detail {
                         }
 
                         // Then steal from neighboring queues
-                        for (std::uint32_t offset = 1;
-                             offset < op_state->num_worker_threads; ++offset)
+                        for (std::uint32_t offset = 1; offset < op_state->num_worker_threads;
+                             ++offset)
                         {
                             std::size_t neighbor_worker_thread =
-                                (task_f->worker_thread + offset) %
-                                op_state->num_worker_threads;
-                            auto& neighbor_queue =
-                                op_state->queues[neighbor_worker_thread].data_;
+                                (task_f->worker_thread + offset) % op_state->num_worker_threads;
+                            auto& neighbor_queue = op_state->queues[neighbor_worker_thread].data_;
 
                             while ((index = neighbor_queue.pop_right()))
                             {
@@ -237,13 +217,12 @@ namespace pika::thread_pool_bulk_detail {
                     // processed their chunks and the connected receiver
                     // should be signalled.
                     template <typename Ts,
-                        typename = std::enable_if_t<!std::is_same_v<
-                            std::decay_t<Ts>, pika::detail::monostate>>>
+                        typename = std::enable_if_t<
+                            !std::is_same_v<std::decay_t<Ts>, pika::detail::monostate>>>
                     void operator()(Ts&& ts) const
                     {
                         pika::util::detail::invoke_fused(
-                            pika::util::detail::bind_front(
-                                pika::execution::experimental::set_value,
+                            pika::util::detail::bind_front(pika::execution::experimental::set_value,
                                 PIKA_MOVE(op_state->receiver)),
                             PIKA_FORWARD(Ts, ts));
                     }
@@ -260,9 +239,7 @@ namespace pika::thread_pool_bulk_detail {
                     // Visit the values sent by the predecessor sender.
                     void do_work() const
                     {
-                        pika::detail::visit(
-                            set_value_loop_visitor{op_state, this},
-                            op_state->ts);
+                        pika::detail::visit(set_value_loop_visitor{op_state, this}, op_state->ts);
                     }
 
                     // Store an exception and mark that an exception was
@@ -297,8 +274,7 @@ namespace pika::thread_pool_bulk_detail {
                             else
                             {
                                 pika::detail::visit(
-                                    set_value_end_loop_visitor{op_state},
-                                    PIKA_MOVE(op_state->ts));
+                                    set_value_end_loop_visitor{op_state}, PIKA_MOVE(op_state->ts));
                             }
                         }
                     }
@@ -344,27 +320,22 @@ namespace pika::thread_pool_bulk_detail {
                 }
 
                 // Initialize a queue for a worker thread.
-                void init_queue(std::uint32_t const worker_thread,
-                    std::uint32_t const num_chunks)
+                void init_queue(std::uint32_t const worker_thread, std::uint32_t const num_chunks)
                 {
                     auto& queue = op_state->queues[worker_thread].data_;
                     auto const part_begin = static_cast<std::uint32_t>(
-                        (worker_thread * num_chunks) /
-                        op_state->num_worker_threads);
+                        (worker_thread * num_chunks) / op_state->num_worker_threads);
                     auto const part_end = static_cast<std::uint32_t>(
-                        ((worker_thread + 1) * num_chunks) /
-                        op_state->num_worker_threads);
+                        ((worker_thread + 1) * num_chunks) / op_state->num_worker_threads);
                     queue.reset(part_begin, part_end);
                 }
 
                 // Spawn a task which will process a number of chunks. If
                 // the queue contains no chunks no task will be spawned.
-                void do_work_task(size_type const n,
-                    std::uint32_t const chunk_size,
+                void do_work_task(size_type const n, std::uint32_t const chunk_size,
                     std::uint32_t const worker_thread) const
                 {
-                    task_function task_f{
-                        this->op_state, n, chunk_size, worker_thread};
+                    task_function task_f{this->op_state, n, chunk_size, worker_thread};
 
                     auto& queue = op_state->queues[worker_thread].data_;
                     if (queue.empty())
@@ -376,13 +347,11 @@ namespace pika::thread_pool_bulk_detail {
                     }
 
                     // Only apply hint if none was given.
-                    auto hint = pika::execution::experimental::get_hint(
-                        op_state->scheduler);
+                    auto hint = pika::execution::experimental::get_hint(op_state->scheduler);
                     if (hint == pika::execution::thread_schedule_hint())
                     {
                         hint = pika::execution::thread_schedule_hint(
-                            pika::execution::thread_schedule_hint_mode::thread,
-                            worker_thread);
+                            pika::execution::thread_schedule_hint_mode::thread, worker_thread);
                     }
 
                     // Get the current thread description and apply it to
@@ -396,35 +365,27 @@ namespace pika::thread_pool_bulk_detail {
 
                     // Spawn the task.
                     threads::detail::thread_init_data data(
-                        threads::detail::make_thread_function_nullary(
-                            PIKA_MOVE(task_f)),
-                        desc,
-                        pika::execution::experimental::get_priority(
-                            op_state->scheduler),
-                        hint,
-                        pika::execution::experimental::get_stacksize(
-                            op_state->scheduler));
-                    threads::detail::register_work(
-                        data, op_state->scheduler.get_thread_pool());
+                        threads::detail::make_thread_function_nullary(PIKA_MOVE(task_f)), desc,
+                        pika::execution::experimental::get_priority(op_state->scheduler), hint,
+                        pika::execution::experimental::get_stacksize(op_state->scheduler));
+                    threads::detail::register_work(data, op_state->scheduler.get_thread_pool());
                 }
 
                 // Do the work on the worker thread that called set_value
                 // from the predecessor sender. This thread participates in
                 // the work and does not need a new task since it already
                 // runs on a task.
-                void do_work_local(size_type n, std::uint32_t chunk_size,
-                    std::uint32_t worker_thread) const
+                void do_work_local(
+                    size_type n, std::uint32_t chunk_size, std::uint32_t worker_thread) const
                 {
-                    task_function{
-                        this->op_state, n, chunk_size, worker_thread}();
+                    task_function{this->op_state, n, chunk_size, worker_thread}();
                 }
 
-                using range_value_type = pika::traits::iter_value_t<
-                    pika::traits::range_iterator_t<Shape>>;
+                using range_value_type =
+                    pika::traits::iter_value_t<pika::traits::range_iterator_t<Shape>>;
 
                 template <typename... Ts>
-                friend void
-                tag_invoke(pika::execution::experimental::set_value_t,
+                friend void tag_invoke(pika::execution::experimental::set_value_t,
                     bulk_receiver&& r, Ts&&... ts) noexcept
                 {
                     // Don't spawn tasks if there is no work to be done
@@ -432,36 +393,30 @@ namespace pika::thread_pool_bulk_detail {
                     if (n == 0)
                     {
                         pika::execution::experimental::set_value(
-                            PIKA_MOVE(r.op_state->receiver),
-                            PIKA_FORWARD(Ts, ts)...);
+                            PIKA_MOVE(r.op_state->receiver), PIKA_FORWARD(Ts, ts)...);
                         return;
                     }
 
                     // Calculate chunk size and number of chunks
-                    auto const chunk_size =
-                        get_chunk_size(r.op_state->num_worker_threads, n);
+                    auto const chunk_size = get_chunk_size(r.op_state->num_worker_threads, n);
                     auto const num_chunks = (n + chunk_size - 1) / chunk_size;
 
                     // Store sent values in the operation state
-                    r.op_state->ts.template emplace<std::tuple<Ts...>>(
-                        PIKA_FORWARD(Ts, ts)...);
+                    r.op_state->ts.template emplace<std::tuple<Ts...>>(PIKA_FORWARD(Ts, ts)...);
 
                     // Initialize the queues for all worker threads so that
                     // worker threads can start stealing immediately when
                     // they start.
                     for (std::size_t worker_thread = 0;
-                         worker_thread < r.op_state->num_worker_threads;
-                         ++worker_thread)
+                         worker_thread < r.op_state->num_worker_threads; ++worker_thread)
                     {
                         r.init_queue(worker_thread, num_chunks);
                     }
 
                     // Spawn the worker threads for all except the local queue.
-                    auto const local_worker_thread =
-                        pika::get_local_worker_thread_num();
+                    auto const local_worker_thread = pika::get_local_worker_thread_num();
                     for (std::size_t worker_thread = 0;
-                         worker_thread < r.op_state->num_worker_threads;
-                         ++worker_thread)
+                         worker_thread < r.op_state->num_worker_threads; ++worker_thread)
                     {
                         // The queue for the local thread is handled later
                         // inline.
@@ -477,41 +432,34 @@ namespace pika::thread_pool_bulk_detail {
                     r.do_work_local(n, chunk_size, local_worker_thread);
                 }
 
-                friend constexpr pika::execution::experimental::empty_env
-                tag_invoke(pika::execution::experimental::get_env_t,
-                    bulk_receiver const&) noexcept
+                friend constexpr pika::execution::experimental::empty_env tag_invoke(
+                    pika::execution::experimental::get_env_t, bulk_receiver const&) noexcept
                 {
                     return {};
                 }
             };
 
             using operation_state_type =
-                pika::execution::experimental::connect_result_t<Sender,
-                    bulk_receiver>;
+                pika::execution::experimental::connect_result_t<Sender, bulk_receiver>;
 
             pika::execution::experimental::thread_pool_scheduler scheduler;
             operation_state_type op_state;
-            std::size_t num_worker_threads =
-                scheduler.get_thread_pool()->get_os_thread_count();
+            std::size_t num_worker_threads = scheduler.get_thread_pool()->get_os_thread_count();
             std::vector<pika::concurrency::detail::cache_aligned_data<
                 pika::concurrency::detail::contiguous_index_queue<>>>
                 queues{num_worker_threads};
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Shape> shape;
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<F> f;
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-            std::atomic<decltype(pika::util::size(shape))> tasks_remaining{
-                num_worker_threads};
-            pika::util::detail::prepend_t<
-                value_types<std::tuple, pika::detail::variant>,
+            std::atomic<decltype(pika::util::size(shape))> tasks_remaining{num_worker_threads};
+            pika::util::detail::prepend_t<value_types<std::tuple, pika::detail::variant>,
                 pika::detail::monostate>
                 ts;
             std::atomic<bool> exception_thrown{false};
             std::optional<std::exception_ptr> exception;
 
-            template <typename Sender_, typename Shape_, typename F_,
-                typename Receiver_>
-            operation_state(
-                pika::execution::experimental::thread_pool_scheduler scheduler,
+            template <typename Sender_, typename Shape_, typename F_, typename Receiver_>
+            operation_state(pika::execution::experimental::thread_pool_scheduler scheduler,
                 Sender_&& sender, Shape_&& shape, F_&& f, Receiver_&& receiver)
               : scheduler(PIKA_MOVE(scheduler))
               , op_state(pika::execution::experimental::connect(
@@ -522,8 +470,8 @@ namespace pika::thread_pool_bulk_detail {
             {
             }
 
-            friend void tag_invoke(pika::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(
+                pika::execution::experimental::start_t, operation_state& os) noexcept
             {
                 pika::execution::experimental::start(os.op_state);
             }
@@ -534,22 +482,21 @@ namespace pika::thread_pool_bulk_detail {
         friend auto tag_invoke(pika::execution::experimental::connect_t,
             thread_pool_bulk_sender&& s, Receiver&& receiver)
         {
-            return operation_state<std::decay_t<Receiver>>{
-                PIKA_MOVE(s.scheduler), PIKA_MOVE(s.sender), PIKA_MOVE(s.shape),
-                PIKA_MOVE(s.f), PIKA_FORWARD(Receiver, receiver)};
+            return operation_state<std::decay_t<Receiver>>{PIKA_MOVE(s.scheduler),
+                PIKA_MOVE(s.sender), PIKA_MOVE(s.shape), PIKA_MOVE(s.f),
+                PIKA_FORWARD(Receiver, receiver)};
         }
 
         template <typename Receiver>
-        friend auto tag_invoke(pika::execution::experimental::connect_t,
-            thread_pool_bulk_sender& s, Receiver&& receiver)
+        friend auto tag_invoke(pika::execution::experimental::connect_t, thread_pool_bulk_sender& s,
+            Receiver&& receiver)
         {
-            return operation_state<std::decay_t<Receiver>>{s.scheduler,
-                s.sender, s.shape, s.f, PIKA_FORWARD(Receiver, receiver)};
+            return operation_state<std::decay_t<Receiver>>{
+                s.scheduler, s.sender, s.shape, s.f, PIKA_FORWARD(Receiver, receiver)};
         }
 
         friend constexpr auto tag_invoke(
-            pika::execution::experimental::get_env_t,
-            thread_pool_bulk_sender const& s)
+            pika::execution::experimental::get_env_t, thread_pool_bulk_sender const& s)
         {
             return pika::execution::experimental::get_env(s.sender);
         }
@@ -559,24 +506,22 @@ namespace pika::thread_pool_bulk_detail {
 namespace pika::execution::experimental {
     template <typename Sender, typename Shape, typename F,
         PIKA_CONCEPT_REQUIRES_(std::is_integral_v<std::decay_t<Shape>>)>
-    constexpr auto tag_invoke(bulk_t, thread_pool_scheduler scheduler,
-        Sender&& sender, Shape&& shape, F&& f)
+    constexpr auto
+    tag_invoke(bulk_t, thread_pool_scheduler scheduler, Sender&& sender, Shape&& shape, F&& f)
     {
-        return thread_pool_bulk_detail::thread_pool_bulk_sender<
-            std::decay_t<Sender>,
-            pika::util::detail::counting_shape_type<std::decay_t<Shape>>,
-            std::decay_t<F>>{PIKA_MOVE(scheduler), PIKA_FORWARD(Sender, sender),
+        return thread_pool_bulk_detail::thread_pool_bulk_sender<std::decay_t<Sender>,
+            pika::util::detail::counting_shape_type<std::decay_t<Shape>>, std::decay_t<F>>{
+            PIKA_MOVE(scheduler), PIKA_FORWARD(Sender, sender),
             pika::util::detail::make_counting_shape(shape), PIKA_FORWARD(F, f)};
     }
 
     template <typename Sender, typename Shape, typename F,
         PIKA_CONCEPT_REQUIRES_(!std::is_integral_v<std::decay_t<Shape>>)>
-    constexpr auto tag_invoke(bulk_t, thread_pool_scheduler scheduler,
-        Sender&& sender, Shape&& shape, F&& f)
+    constexpr auto
+    tag_invoke(bulk_t, thread_pool_scheduler scheduler, Sender&& sender, Shape&& shape, F&& f)
     {
-        return thread_pool_bulk_detail::thread_pool_bulk_sender<
-            std::decay_t<Sender>, std::decay_t<Shape>, std::decay_t<F>>{
-            PIKA_MOVE(scheduler), PIKA_FORWARD(Sender, sender),
-            PIKA_FORWARD(Shape, shape), PIKA_FORWARD(F, f)};
+        return thread_pool_bulk_detail::thread_pool_bulk_sender<std::decay_t<Sender>,
+            std::decay_t<Shape>, std::decay_t<F>>{PIKA_MOVE(scheduler),
+            PIKA_FORWARD(Sender, sender), PIKA_FORWARD(Shape, shape), PIKA_FORWARD(F, f)};
     }
 }    // namespace pika::execution::experimental
diff --git a/libs/pika/executors/tests/unit/std_thread_scheduler.cpp b/libs/pika/executors/tests/unit/std_thread_scheduler.cpp
index f5e9685e80..d25f85493e 100644
--- a/libs/pika/executors/tests/unit/std_thread_scheduler.cpp
+++ b/libs/pika/executors/tests/unit/std_thread_scheduler.cpp
@@ -44,9 +44,7 @@ void test_execute()
     std::thread::id parent_id = std::this_thread::get_id();
 
     ex::std_thread_scheduler sched{};
-    ex::execute(sched, [parent_id]() {
-        PIKA_TEST_NEQ(std::this_thread::get_id(), parent_id);
-    });
+    ex::execute(sched, [parent_id]() { PIKA_TEST_NEQ(std::this_thread::get_id(), parent_id); });
 }
 
 struct check_context_receiver
@@ -57,8 +55,7 @@ struct check_context_receiver
     bool& executed;
 
     template <typename E>
-    friend void
-    tag_invoke(ex::set_error_t, check_context_receiver&&, E&&) noexcept
+    friend void tag_invoke(ex::set_error_t, check_context_receiver&&, E&&) noexcept
     {
         PIKA_TEST(false);
     }
@@ -69,8 +66,7 @@ struct check_context_receiver
     }
 
     template <typename... Ts>
-    friend void
-    tag_invoke(ex::set_value_t, check_context_receiver&& r, Ts&&...) noexcept
+    friend void tag_invoke(ex::set_value_t, check_context_receiver&& r, Ts&&...) noexcept
     {
         PIKA_TEST_NEQ(r.parent_id, std::this_thread::get_id());
         PIKA_TEST_NEQ(std::thread::id(), std::this_thread::get_id());
@@ -80,8 +76,7 @@ struct check_context_receiver
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        check_context_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, check_context_receiver const&) noexcept
     {
         return {};
     }
@@ -97,8 +92,7 @@ void test_sender_receiver_basic()
     ex::std_thread_scheduler sched{};
 
     auto begin = ex::schedule(sched);
-    auto os = ex::connect(std::move(begin),
-        check_context_receiver{parent_id, mtx, cond, executed});
+    auto os = ex::connect(std::move(begin), check_context_receiver{parent_id, mtx, cond, executed});
     ex::start(os);
 
     {
@@ -124,12 +118,9 @@ void test_sender_receiver_then()
         sender_receiver_then_thread_id = std::this_thread::get_id();
         PIKA_TEST_NEQ(sender_receiver_then_thread_id, parent_id);
     });
-    auto work2 = ex::then(std::move(work1), []() {
-        PIKA_TEST_EQ(
-            sender_receiver_then_thread_id, std::this_thread::get_id());
-    });
-    auto os = ex::connect(std::move(work2),
-        check_context_receiver{parent_id, mtx, cond, executed});
+    auto work2 = ex::then(std::move(work1),
+        []() { PIKA_TEST_EQ(sender_receiver_then_thread_id, std::this_thread::get_id()); });
+    auto os = ex::connect(std::move(work2), check_context_receiver{parent_id, mtx, cond, executed});
     ex::start(os);
 
     {
@@ -154,8 +145,7 @@ void test_sender_receiver_then_wait()
         ++then_count;
     });
     auto work2 = ex::then(std::move(work1), [&then_count, &executed]() {
-        PIKA_TEST_EQ(
-            sender_receiver_then_thread_id, std::this_thread::get_id());
+        PIKA_TEST_EQ(sender_receiver_then_thread_id, std::this_thread::get_id());
         ++then_count;
         executed = true;
     });
@@ -180,8 +170,8 @@ void test_sender_receiver_then_sync_wait()
     });
     auto result = tt::sync_wait(std::move(work));
     PIKA_TEST_EQ(then_count, std::size_t(1));
-    static_assert(std::is_same<int, std::decay_t<decltype(result)>>::value,
-        "result should be an int");
+    static_assert(
+        std::is_same<int, std::decay_t<decltype(result)>>::value, "result should be an int");
     PIKA_TEST_EQ(result, 42);
 }
 
@@ -198,23 +188,19 @@ void test_sender_receiver_then_arguments()
         ++then_count;
         return 3;
     });
-    auto work2 =
-        ex::then(std::move(work1), [&then_count](int x) -> std::string {
-            PIKA_TEST_EQ(
-                sender_receiver_then_thread_id, std::this_thread::get_id());
-            ++then_count;
-            return std::string("hello") + std::to_string(x);
-        });
+    auto work2 = ex::then(std::move(work1), [&then_count](int x) -> std::string {
+        PIKA_TEST_EQ(sender_receiver_then_thread_id, std::this_thread::get_id());
+        ++then_count;
+        return std::string("hello") + std::to_string(x);
+    });
     auto work3 = ex::then(std::move(work2), [&then_count](std::string s) {
-        PIKA_TEST_EQ(
-            sender_receiver_then_thread_id, std::this_thread::get_id());
+        PIKA_TEST_EQ(sender_receiver_then_thread_id, std::this_thread::get_id());
         ++then_count;
         return 2 * s.size();
     });
     auto result = tt::sync_wait(std::move(work3));
     PIKA_TEST_EQ(then_count, std::size_t(3));
-    static_assert(
-        std::is_same<std::size_t, std::decay_t<decltype(result)>>::value,
+    static_assert(std::is_same<std::size_t, std::decay_t<decltype(result)>>::value,
         "result should be a std::size_t");
     PIKA_TEST_EQ(result, std::size_t(12));
 }
@@ -239,8 +225,7 @@ struct callback_receiver
     }
 
     template <typename... Ts>
-    friend void
-    tag_invoke(ex::set_value_t, callback_receiver&& r, Ts&&...) noexcept
+    friend void tag_invoke(ex::set_value_t, callback_receiver&& r, Ts&&...) noexcept
     {
         r.f();
         std::lock_guard l{r.mtx};
@@ -249,8 +234,7 @@ struct callback_receiver
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        callback_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, callback_receiver const&) noexcept
     {
         return {};
     }
@@ -267,9 +251,8 @@ void test_transfer_basic()
         current_id = std::this_thread::get_id();
         PIKA_TEST_NEQ(current_id, parent_id);
     });
-    auto work2 = ex::then(std::move(work1), [=, &current_id]() {
-        PIKA_TEST_EQ(current_id, std::this_thread::get_id());
-    });
+    auto work2 = ex::then(std::move(work1),
+        [=, &current_id]() { PIKA_TEST_EQ(current_id, std::this_thread::get_id()); });
     auto transfer1 = ex::transfer(work2, sched);
     auto work3 = ex::then(transfer1, [=, &current_id]() {
         std::thread::id new_id = std::this_thread::get_id();
@@ -277,9 +260,8 @@ void test_transfer_basic()
         current_id = new_id;
         PIKA_TEST_NEQ(current_id, parent_id);
     });
-    auto work4 = ex::then(work3, [=, &current_id]() {
-        PIKA_TEST_EQ(current_id, std::this_thread::get_id());
-    });
+    auto work4 = ex::then(
+        work3, [=, &current_id]() { PIKA_TEST_EQ(current_id, std::this_thread::get_id()); });
     auto transfer2 = ex::transfer(work4, sched);
     auto work5 = ex::then(transfer2, [=, &current_id]() {
         std::thread::id new_id = std::this_thread::get_id();
@@ -329,8 +311,7 @@ void test_transfer_arguments()
     });
 
     auto result = tt::sync_wait(std::move(work5));
-    static_assert(
-        std::is_same<std::string, std::decay_t<decltype(result)>>::value,
+    static_assert(std::is_same<std::string, std::decay_t<decltype(result)>>::value,
         "result should be a std::string");
     PIKA_TEST_EQ(result, std::string("result: 0!"));
 }
@@ -341,9 +322,8 @@ void test_just_void()
         std::thread::id parent_id = std::this_thread::get_id();
 
         auto begin = ex::just();
-        auto work1 = ex::then(begin, [parent_id]() {
-            PIKA_TEST_EQ(parent_id, std::this_thread::get_id());
-        });
+        auto work1 =
+            ex::then(begin, [parent_id]() { PIKA_TEST_EQ(parent_id, std::this_thread::get_id()); });
         tt::sync_wait(std::move(work1));
     }
 
@@ -352,9 +332,8 @@ void test_just_void()
 
         auto begin = ex::just();
         auto transfer1 = ex::transfer(begin, ex::std_thread_scheduler{});
-        auto work1 = ex::then(transfer1, [parent_id]() {
-            PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
-        });
+        auto work1 = ex::then(
+            transfer1, [parent_id]() { PIKA_TEST_NEQ(parent_id, std::this_thread::get_id()); });
         tt::sync_wait(std::move(work1));
     }
 }
@@ -418,9 +397,8 @@ void test_transfer_just_void()
     std::thread::id parent_id = std::this_thread::get_id();
 
     auto begin = ex::transfer_just(ex::std_thread_scheduler{});
-    auto work1 = ex::then(begin, [parent_id]() {
-        PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
-    });
+    auto work1 =
+        ex::then(begin, [parent_id]() { PIKA_TEST_NEQ(parent_id, std::this_thread::get_id()); });
     tt::sync_wait(std::move(work1));
 }
 
@@ -440,8 +418,7 @@ void test_transfer_just_two_args()
 {
     std::thread::id parent_id = std::this_thread::get_id();
 
-    auto begin =
-        ex::transfer_just(ex::std_thread_scheduler{}, 3, std::string("hello"));
+    auto begin = ex::transfer_just(ex::std_thread_scheduler{}, 3, std::string("hello"));
     auto work1 = ex::then(begin, [parent_id](int x, std::string y) {
         PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
         PIKA_TEST_EQ(x, 3);
@@ -472,12 +449,11 @@ void test_when_all()
             return 3.14;
         });
 
-        auto when1 =
-            ex::when_all(std::move(work1), std::move(work2), std::move(work3));
+        auto when1 = ex::when_all(std::move(work1), std::move(work2), std::move(work3));
 
         bool executed{false};
-        tt::sync_wait(std::move(when1) |
-            ex::then([parent_id, &executed](int x, std::string y, double z) {
+        tt::sync_wait(
+            std::move(when1) | ex::then([parent_id, &executed](int x, std::string y, double z) {
                 PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
                 PIKA_TEST_EQ(x, 42);
                 PIKA_TEST_EQ(y, std::string("hello"));
@@ -704,8 +680,7 @@ void test_ensure_started()
     }
 
     {
-        auto s = ex::transfer_just(sched, 42) | ex::ensure_started() |
-            ex::transfer(sched);
+        auto s = ex::transfer_just(sched, 42) | ex::ensure_started() | ex::transfer(sched);
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 42);
     }
 
@@ -713,8 +688,7 @@ void test_ensure_started()
     // copyable.
 #if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
     {
-        auto s =
-            ex::transfer_just(sched, 42) | ex::ensure_started() | ex::split();
+        auto s = ex::transfer_just(sched, 42) | ex::ensure_started() | ex::split();
         PIKA_TEST_EQ(tt::sync_wait(s), 42);
         PIKA_TEST_EQ(tt::sync_wait(s), 42);
         PIKA_TEST_EQ(tt::sync_wait(s), 42);
@@ -760,9 +734,8 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             3);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -795,9 +768,8 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -829,9 +801,8 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -855,8 +826,7 @@ void test_split()
     }
 
     {
-        auto s =
-            ex::transfer_just(sched, 42) | ex::split() | ex::transfer(sched);
+        auto s = ex::transfer_just(sched, 42) | ex::split() | ex::transfer(sched);
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 42);
     }
 
@@ -879,8 +849,7 @@ void test_split_when_all()
     {
         std::atomic<std::size_t> first_task_calls{0};
         std::atomic<std::size_t> successor_task_calls{0};
-        auto s = ex::schedule(sched) | ex::then([&]() { ++first_task_calls; }) |
-            ex::split();
+        auto s = ex::schedule(sched) | ex::then([&]() { ++first_task_calls; }) | ex::split();
         auto succ1 = s | ex::then([&]() {
             ++successor_task_calls;
             return 1;
@@ -889,9 +858,8 @@ void test_split_when_all()
             ++successor_task_calls;
             return 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             3);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -912,9 +880,8 @@ void test_split_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -935,9 +902,8 @@ void test_split_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -951,27 +917,27 @@ void test_let_value()
 
     // void predecessor
     {
-        auto result = tt::sync_wait(
-            ex::schedule(sched) | ex::let_value([]() { return ex::just(42); }));
+        auto result =
+            tt::sync_wait(ex::schedule(sched) | ex::let_value([]() { return ex::just(42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     {
-        auto result = tt::sync_wait(ex::schedule(sched) |
-            ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
+        auto result = tt::sync_wait(
+            ex::schedule(sched) | ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     {
-        auto result = tt::sync_wait(ex::just() |
-            ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
+        auto result = tt::sync_wait(
+            ex::just() | ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     // int predecessor, value ignored
     {
-        auto result = tt::sync_wait(ex::transfer_just(sched, 43) |
-            ex::let_value([](int&) { return ex::just(42); }));
+        auto result = tt::sync_wait(
+            ex::transfer_just(sched, 43) | ex::let_value([](int&) { return ex::just(42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
@@ -982,33 +948,29 @@ void test_let_value()
     }
 
     {
-        auto result = tt::sync_wait(ex::just(43) |
-            ex::let_value([=](int&) { return ex::transfer_just(sched, 42); }));
+        auto result = tt::sync_wait(
+            ex::just(43) | ex::let_value([=](int&) { return ex::transfer_just(sched, 42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     // int predecessor, value used
     {
-        auto result = tt::sync_wait(
-            ex::transfer_just(sched, 43) | ex::let_value([](int& x) {
-                return ex::just(42) | ex::then([&](int y) { return x + y; });
-            }));
+        auto result = tt::sync_wait(ex::transfer_just(sched, 43) | ex::let_value([](int& x) {
+            return ex::just(42) | ex::then([&](int y) { return x + y; });
+        }));
         PIKA_TEST_EQ(result, 85);
     }
 
     {
-        auto result = tt::sync_wait(
-            ex::transfer_just(sched, 43) | ex::let_value([=](int& x) {
-                return ex::transfer_just(sched, 42) |
-                    ex::then([&](int y) { return x + y; });
-            }));
+        auto result = tt::sync_wait(ex::transfer_just(sched, 43) | ex::let_value([=](int& x) {
+            return ex::transfer_just(sched, 42) | ex::then([&](int y) { return x + y; });
+        }));
         PIKA_TEST_EQ(result, 85);
     }
 
     {
         auto result = tt::sync_wait(ex::just(43) | ex::let_value([=](int& x) {
-            return ex::transfer_just(sched, 42) |
-                ex::then([&](int y) { return x + y; });
+            return ex::transfer_just(sched, 42) | ex::then([&](int y) { return x + y; });
         }));
         PIKA_TEST_EQ(result, 85);
     }
@@ -1038,8 +1000,7 @@ void test_let_value()
     }
 }
 
-void check_exception_ptr_message(
-    std::exception_ptr ep, std::string const& message)
+void check_exception_ptr_message(std::exception_ptr ep, std::string const& message)
 {
     try
     {
@@ -1061,37 +1022,34 @@ void test_let_error()
     // void predecessor
     {
         std::atomic<bool> called{false};
-        tt::sync_wait(ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([&called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::just();
-        }));
+        tt::sync_wait(ex::schedule(sched) | ex::then([]() { throw std::runtime_error("error"); }) |
+            ex::let_error([&called](std::exception_ptr& ep) {
+                called = true;
+                check_exception_ptr_message(ep, "error");
+                return ex::just();
+            }));
         PIKA_TEST(called);
     }
 
     {
         std::atomic<bool> called{false};
-        tt::sync_wait(ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([=, &called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched);
-        }));
+        tt::sync_wait(ex::schedule(sched) | ex::then([]() { throw std::runtime_error("error"); }) |
+            ex::let_error([=, &called](std::exception_ptr& ep) {
+                called = true;
+                check_exception_ptr_message(ep, "error");
+                return ex::transfer_just(sched);
+            }));
         PIKA_TEST(called);
     }
 
     {
         std::atomic<bool> called{false};
-        tt::sync_wait(ex::just() | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([=, &called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched);
-        }));
+        tt::sync_wait(ex::just() | ex::then([]() { throw std::runtime_error("error"); }) |
+            ex::let_error([=, &called](std::exception_ptr& ep) {
+                called = true;
+                check_exception_ptr_message(ep, "error");
+                return ex::transfer_just(sched);
+            }));
         PIKA_TEST(called);
     }
 
@@ -1131,8 +1089,8 @@ void test_let_error()
 
     // predecessor doesn't throw, let sender is ignored
     {
-        auto result = tt::sync_wait(ex::transfer_just(sched, 42) |
-            ex::let_error([](std::exception_ptr) {
+        auto result =
+            tt::sync_wait(ex::transfer_just(sched, 42) | ex::let_error([](std::exception_ptr) {
                 PIKA_TEST(false);
                 return ex::just(43);
             }));
@@ -1140,8 +1098,8 @@ void test_let_error()
     }
 
     {
-        auto result = tt::sync_wait(ex::transfer_just(sched, 42) |
-            ex::let_error([=](std::exception_ptr) {
+        auto result =
+            tt::sync_wait(ex::transfer_just(sched, 42) | ex::let_error([=](std::exception_ptr) {
                 PIKA_TEST(false);
                 return ex::transfer_just(sched, 43);
             }));
@@ -1149,11 +1107,10 @@ void test_let_error()
     }
 
     {
-        auto result =
-            tt::sync_wait(ex::just(42) | ex::let_error([=](std::exception_ptr) {
-                PIKA_TEST(false);
-                return ex::transfer_just(sched, 43);
-            }));
+        auto result = tt::sync_wait(ex::just(42) | ex::let_error([=](std::exception_ptr) {
+            PIKA_TEST(false);
+            return ex::transfer_just(sched, 43);
+        }));
         PIKA_TEST_EQ(result, 42);
     }
 }
@@ -1175,8 +1132,7 @@ void test_detach()
 
         {
             std::unique_lock l{mtx};
-            PIKA_TEST(cond.wait_for(
-                l, std::chrono::seconds(1), [&]() { return called; }));
+            PIKA_TEST(cond.wait_for(l, std::chrono::seconds(1), [&]() { return called; }));
         }
         PIKA_TEST(called);
     }
@@ -1196,8 +1152,7 @@ void test_detach()
 
         {
             std::unique_lock l{mtx};
-            PIKA_TEST(cond.wait_for(
-                l, std::chrono::seconds(1), [&]() { return called; }));
+            PIKA_TEST(cond.wait_for(l, std::chrono::seconds(1), [&]() { return called; }));
         }
         PIKA_TEST(called);
     }
@@ -1214,11 +1169,10 @@ void test_bulk()
         std::vector<int> v(n, 0);
         std::thread::id parent_id = std::this_thread::get_id();
 
-        tt::sync_wait(
-            ex::schedule(ex::std_thread_scheduler{}) | ex::bulk(n, [&](int i) {
-                ++v[i];
-                PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
-            }));
+        tt::sync_wait(ex::schedule(ex::std_thread_scheduler{}) | ex::bulk(n, [&](int i) {
+            ++v[i];
+            PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
+        }));
 
         for (int i = 0; i < n; ++i)
         {
@@ -1231,8 +1185,7 @@ void test_bulk()
         std::vector<int> v(n, -1);
         std::thread::id parent_id = std::this_thread::get_id();
 
-        auto v_out = tt::sync_wait(
-            ex::transfer_just(ex::std_thread_scheduler{}, std::move(v)) |
+        auto v_out = tt::sync_wait(ex::transfer_just(ex::std_thread_scheduler{}, std::move(v)) |
             ex::bulk(n, [&parent_id](int i, std::vector<int>& v) {
                 v[i] = i;
                 PIKA_TEST_NEQ(parent_id, std::this_thread::get_id());
@@ -1272,14 +1225,13 @@ void test_bulk()
 
         try
         {
-            tt::sync_wait(ex::transfer_just(ex::std_thread_scheduler{}) |
-                ex::bulk(n, [&v](int i) {
-                    if (i == i_fail)
-                    {
-                        throw std::runtime_error("error");
-                    }
-                    v[i] = i;
-                }));
+            tt::sync_wait(ex::transfer_just(ex::std_thread_scheduler{}) | ex::bulk(n, [&v](int i) {
+                if (i == i_fail)
+                {
+                    throw std::runtime_error("error");
+                }
+                v[i] = i;
+            }));
 
             if (expect_exception)
             {
@@ -1318,19 +1270,16 @@ void test_completion_scheduler()
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::std_thread_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::std_thread_scheduler>,
             "the completion scheduler should be a std_thread_scheduler");
     }
 
     {
-        auto sender =
-            ex::then(ex::schedule(ex::std_thread_scheduler{}), []() {});
+        auto sender = ex::then(ex::schedule(ex::std_thread_scheduler{}), []() {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::std_thread_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::std_thread_scheduler>,
             "the completion scheduler should be a std_thread_scheduler");
     }
 
@@ -1339,46 +1288,39 @@ void test_completion_scheduler()
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::std_thread_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::std_thread_scheduler>,
             "the completion scheduler should be a std_thread_scheduler");
     }
 
 #if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
     {
-        auto sender =
-            ex::bulk(ex::schedule(ex::std_thread_scheduler{}), 10, [](int) {});
+        auto sender = ex::bulk(ex::schedule(ex::std_thread_scheduler{}), 10, [](int) {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::std_thread_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::std_thread_scheduler>,
             "the completion scheduler should be a std_thread_scheduler");
     }
 
     {
-        auto sender =
-            ex::then(ex::bulk(ex::transfer_just(ex::std_thread_scheduler{}, 42),
-                         10, [](int, int) {}),
-                [](int) {});
+        auto sender = ex::then(
+            ex::bulk(ex::transfer_just(ex::std_thread_scheduler{}, 42), 10, [](int, int) {}),
+            [](int) {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::std_thread_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::std_thread_scheduler>,
             "the completion scheduler should be a std_thread_scheduler");
     }
 
     {
         auto sender =
-            ex::bulk(ex::then(ex::transfer_just(ex::std_thread_scheduler{}, 42),
-                         [](int) {}),
-                10, [](int, int) {});
+            ex::bulk(ex::then(ex::transfer_just(ex::std_thread_scheduler{}, 42), [](int) {}), 10,
+                [](int, int) {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::std_thread_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::std_thread_scheduler>,
             "the completion scheduler should be a std_thread_scheduler");
     }
 #endif
diff --git a/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp b/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp
index ac75204a05..661e5913e3 100644
--- a/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp
+++ b/libs/pika/executors/tests/unit/thread_pool_scheduler.cpp
@@ -51,9 +51,7 @@ void test_execute()
     pika::thread::id parent_id = pika::this_thread::get_id();
 
     ex::thread_pool_scheduler sched{};
-    ex::execute(sched, [parent_id]() {
-        PIKA_TEST_NEQ(pika::this_thread::get_id(), parent_id);
-    });
+    ex::execute(sched, [parent_id]() { PIKA_TEST_NEQ(pika::this_thread::get_id(), parent_id); });
 }
 
 struct check_context_receiver
@@ -64,8 +62,7 @@ struct check_context_receiver
     bool& executed;
 
     template <typename E>
-    friend void
-    tag_invoke(ex::set_error_t, check_context_receiver&&, E&&) noexcept
+    friend void tag_invoke(ex::set_error_t, check_context_receiver&&, E&&) noexcept
     {
         PIKA_TEST(false);
     }
@@ -76,12 +73,10 @@ struct check_context_receiver
     }
 
     template <typename... Ts>
-    friend void
-    tag_invoke(ex::set_value_t, check_context_receiver&& r, Ts&&...) noexcept
+    friend void tag_invoke(ex::set_value_t, check_context_receiver&& r, Ts&&...) noexcept
     {
         PIKA_TEST_NEQ(r.parent_id, pika::this_thread::get_id());
-        PIKA_TEST_NEQ(
-            pika::thread::id(pika::threads::detail::invalid_thread_id),
+        PIKA_TEST_NEQ(pika::thread::id(pika::threads::detail::invalid_thread_id),
             pika::this_thread::get_id());
         std::lock_guard l{r.mtx};
         r.executed = true;
@@ -89,8 +84,7 @@ struct check_context_receiver
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        check_context_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, check_context_receiver const&) noexcept
     {
         return {};
     }
@@ -106,8 +100,7 @@ void test_sender_receiver_basic()
     ex::thread_pool_scheduler sched{};
 
     auto begin = ex::schedule(sched);
-    auto os = ex::connect(std::move(begin),
-        check_context_receiver{parent_id, mtx, cond, executed});
+    auto os = ex::connect(std::move(begin), check_context_receiver{parent_id, mtx, cond, executed});
     ex::start(os);
 
     {
@@ -133,12 +126,9 @@ void test_sender_receiver_then()
         sender_receiver_then_thread_id = pika::this_thread::get_id();
         PIKA_TEST_NEQ(sender_receiver_then_thread_id, parent_id);
     });
-    auto work2 = ex::then(std::move(work1), []() {
-        PIKA_TEST_EQ(
-            sender_receiver_then_thread_id, pika::this_thread::get_id());
-    });
-    auto os = ex::connect(std::move(work2),
-        check_context_receiver{parent_id, mtx, cond, executed});
+    auto work2 = ex::then(std::move(work1),
+        []() { PIKA_TEST_EQ(sender_receiver_then_thread_id, pika::this_thread::get_id()); });
+    auto os = ex::connect(std::move(work2), check_context_receiver{parent_id, mtx, cond, executed});
     ex::start(os);
 
     {
@@ -163,8 +153,7 @@ void test_sender_receiver_then_wait()
         ++then_count;
     });
     auto work2 = ex::then(std::move(work1), [&then_count, &executed]() {
-        PIKA_TEST_EQ(
-            sender_receiver_then_thread_id, pika::this_thread::get_id());
+        PIKA_TEST_EQ(sender_receiver_then_thread_id, pika::this_thread::get_id());
         ++then_count;
         executed = true;
     });
@@ -189,8 +178,8 @@ void test_sender_receiver_then_sync_wait()
     });
     auto result = tt::sync_wait(std::move(work));
     PIKA_TEST_EQ(then_count, std::size_t(1));
-    static_assert(std::is_same<int, std::decay_t<decltype(result)>>::value,
-        "result should be an int");
+    static_assert(
+        std::is_same<int, std::decay_t<decltype(result)>>::value, "result should be an int");
     PIKA_TEST_EQ(result, 42);
 }
 
@@ -207,23 +196,19 @@ void test_sender_receiver_then_arguments()
         ++then_count;
         return 3;
     });
-    auto work2 =
-        ex::then(std::move(work1), [&then_count](int x) -> std::string {
-            PIKA_TEST_EQ(
-                sender_receiver_then_thread_id, pika::this_thread::get_id());
-            ++then_count;
-            return std::string("hello") + std::to_string(x);
-        });
+    auto work2 = ex::then(std::move(work1), [&then_count](int x) -> std::string {
+        PIKA_TEST_EQ(sender_receiver_then_thread_id, pika::this_thread::get_id());
+        ++then_count;
+        return std::string("hello") + std::to_string(x);
+    });
     auto work3 = ex::then(std::move(work2), [&then_count](std::string s) {
-        PIKA_TEST_EQ(
-            sender_receiver_then_thread_id, pika::this_thread::get_id());
+        PIKA_TEST_EQ(sender_receiver_then_thread_id, pika::this_thread::get_id());
         ++then_count;
         return 2 * s.size();
     });
     auto result = tt::sync_wait(std::move(work3));
     PIKA_TEST_EQ(then_count, std::size_t(3));
-    static_assert(
-        std::is_same<std::size_t, std::decay_t<decltype(result)>>::value,
+    static_assert(std::is_same<std::size_t, std::decay_t<decltype(result)>>::value,
         "result should be a std::size_t");
     PIKA_TEST_EQ(result, std::size_t(12));
 }
@@ -248,8 +233,7 @@ struct callback_receiver
     }
 
     template <typename... Ts>
-    friend void
-    tag_invoke(ex::set_value_t, callback_receiver&& r, Ts&&...) noexcept
+    friend void tag_invoke(ex::set_value_t, callback_receiver&& r, Ts&&...) noexcept
     {
         r.f();
         std::lock_guard l{r.mtx};
@@ -258,8 +242,7 @@ struct callback_receiver
     }
 
     friend constexpr pika::execution::experimental::empty_env tag_invoke(
-        pika::execution::experimental::get_env_t,
-        callback_receiver const&) noexcept
+        pika::execution::experimental::get_env_t, callback_receiver const&) noexcept
     {
         return {};
     }
@@ -273,8 +256,7 @@ void test_properties()
     bool executed{false};
 
     constexpr std::array<pika::execution::thread_priority, 3> priorities{
-        {pika::execution::thread_priority::low,
-            pika::execution::thread_priority::normal,
+        {pika::execution::thread_priority::low, pika::execution::thread_priority::normal,
             pika::execution::thread_priority::high}};
 
     for (auto const prio : priorities)
@@ -282,9 +264,7 @@ void test_properties()
         auto exec_prop = ex::with_priority(sched, prio);
         PIKA_TEST_EQ(ex::get_priority(exec_prop), prio);
 
-        auto check = [prio]() {
-            PIKA_TEST_EQ(prio, pika::this_thread::get_priority());
-        };
+        auto check = [prio]() { PIKA_TEST_EQ(prio, pika::this_thread::get_priority()); };
         executed = false;
         auto os = ex::connect(ex::schedule(exec_prop),
             callback_receiver<decltype(check)>{check, mtx, cond, executed});
@@ -298,10 +278,8 @@ void test_properties()
     }
 
     constexpr std::array<pika::execution::thread_stacksize, 4> stacksizes{
-        {pika::execution::thread_stacksize::small_,
-            pika::execution::thread_stacksize::medium,
-            pika::execution::thread_stacksize::large,
-            pika::execution::thread_stacksize::huge}};
+        {pika::execution::thread_stacksize::small_, pika::execution::thread_stacksize::medium,
+            pika::execution::thread_stacksize::large, pika::execution::thread_stacksize::huge}};
 
     for (auto const stacksize : stacksizes)
     {
@@ -310,8 +288,7 @@ void test_properties()
 
         auto check = [stacksize]() {
             PIKA_TEST_EQ(stacksize,
-                pika::threads::detail::get_thread_id_data(
-                    pika::threads::detail::get_self_id())
+                pika::threads::detail::get_thread_id_data(pika::threads::detail::get_self_id())
                     ->get_stack_size_enum());
         };
         executed = false;
@@ -327,8 +304,7 @@ void test_properties()
     }
 
     constexpr std::array<pika::execution::thread_schedule_hint, 4> hints{
-        {pika::execution::thread_schedule_hint{},
-            pika::execution::thread_schedule_hint{1},
+        {pika::execution::thread_schedule_hint{}, pika::execution::thread_schedule_hint{1},
             pika::execution::thread_schedule_hint{
                 pika::execution::thread_schedule_hint_mode::thread, 2},
             pika::execution::thread_schedule_hint{
@@ -346,14 +322,12 @@ void test_properties()
     {
         char const* annotation = "<test>";
         auto exec_prop = ex::with_annotation(sched, annotation);
-        PIKA_TEST_EQ(std::string(ex::get_annotation(exec_prop)),
-            std::string(annotation));
+        PIKA_TEST_EQ(std::string(ex::get_annotation(exec_prop)), std::string(annotation));
 
         auto check = [annotation]() {
 #if defined(PIKA_HAVE_THREAD_DESCRIPTION)
             PIKA_TEST_EQ(std::string(annotation),
-                pika::threads::detail::get_thread_description(
-                    pika::threads::detail::get_self_id())
+                pika::threads::detail::get_thread_description(pika::threads::detail::get_self_id())
                     .get_description());
 #else
             (void) annotation;
@@ -384,17 +358,15 @@ void test_transfer_basic()
         current_id = pika::this_thread::get_id();
         PIKA_TEST_NEQ(current_id, parent_id);
     });
-    auto work2 = ex::then(work1, [=, &current_id]() {
-        PIKA_TEST_EQ(current_id, pika::this_thread::get_id());
-    });
+    auto work2 = ex::then(
+        work1, [=, &current_id]() { PIKA_TEST_EQ(current_id, pika::this_thread::get_id()); });
     auto transfer1 = ex::transfer(work2, sched);
     auto work3 = ex::then(transfer1, [=, &current_id]() {
         current_id = pika::this_thread::get_id();
         PIKA_TEST_NEQ(current_id, parent_id);
     });
-    auto work4 = ex::then(work3, [=, &current_id]() {
-        PIKA_TEST_EQ(current_id, pika::this_thread::get_id());
-    });
+    auto work4 = ex::then(
+        work3, [=, &current_id]() { PIKA_TEST_EQ(current_id, pika::this_thread::get_id()); });
     auto transfer2 = ex::transfer(work4, sched);
     auto work5 = ex::then(transfer2, [=, &current_id]() {
         current_id = pika::this_thread::get_id();
@@ -438,8 +410,7 @@ void test_transfer_arguments()
     });
 
     auto result = tt::sync_wait(std::move(work5));
-    static_assert(
-        std::is_same<std::string, std::decay_t<decltype(result)>>::value,
+    static_assert(std::is_same<std::string, std::decay_t<decltype(result)>>::value,
         "result should be a std::string");
     PIKA_TEST_EQ(result, std::string("result: 0!"));
 }
@@ -450,9 +421,8 @@ void test_just_void()
         pika::thread::id parent_id = pika::this_thread::get_id();
 
         auto begin = ex::just();
-        auto work1 = ex::then(begin, [parent_id]() {
-            PIKA_TEST_EQ(parent_id, pika::this_thread::get_id());
-        });
+        auto work1 = ex::then(
+            begin, [parent_id]() { PIKA_TEST_EQ(parent_id, pika::this_thread::get_id()); });
         tt::sync_wait(std::move(work1));
     }
 
@@ -461,9 +431,8 @@ void test_just_void()
 
         auto begin = ex::just();
         auto transfer1 = ex::transfer(begin, ex::thread_pool_scheduler{});
-        auto work1 = ex::then(transfer1, [parent_id]() {
-            PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
-        });
+        auto work1 = ex::then(
+            transfer1, [parent_id]() { PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id()); });
         tt::sync_wait(std::move(work1));
     }
 }
@@ -527,9 +496,8 @@ void test_transfer_just_void()
     pika::thread::id parent_id = pika::this_thread::get_id();
 
     auto begin = ex::transfer_just(ex::thread_pool_scheduler{});
-    auto work1 = ex::then(begin, [parent_id]() {
-        PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
-    });
+    auto work1 =
+        ex::then(begin, [parent_id]() { PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id()); });
     tt::sync_wait(std::move(work1));
 }
 
@@ -549,8 +517,7 @@ void test_transfer_just_two_args()
 {
     pika::thread::id parent_id = pika::this_thread::get_id();
 
-    auto begin =
-        ex::transfer_just(ex::thread_pool_scheduler{}, 3, std::string("hello"));
+    auto begin = ex::transfer_just(ex::thread_pool_scheduler{}, 3, std::string("hello"));
     auto work1 = ex::then(begin, [parent_id](int x, std::string y) {
         PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
         PIKA_TEST_EQ(x, 3);
@@ -581,12 +548,11 @@ void test_when_all()
             return 3.14;
         });
 
-        auto when1 =
-            ex::when_all(std::move(work1), std::move(work2), std::move(work3));
+        auto when1 = ex::when_all(std::move(work1), std::move(work2), std::move(work3));
 
         bool executed{false};
-        tt::sync_wait(std::move(when1) |
-            ex::then([parent_id, &executed](int x, std::string y, double z) {
+        tt::sync_wait(
+            std::move(when1) | ex::then([parent_id, &executed](int x, std::string y, double z) {
                 PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
                 PIKA_TEST_EQ(x, 42);
                 PIKA_TEST_EQ(y, std::string("hello"));
@@ -806,10 +772,8 @@ void test_future_sender()
         std::atomic<bool> called{false};
         auto f = pika::async([&]() { called = true; });
 
-        static_assert(ex::is_sender_v<std::decay_t<decltype(f)>>,
-            "a future should be a sender");
-        static_assert(
-            std::is_void<decltype(tt::sync_wait(std::move(f)))>::value,
+        static_assert(ex::is_sender_v<std::decay_t<decltype(f)>>, "a future should be a sender");
+        static_assert(std::is_void<decltype(tt::sync_wait(std::move(f)))>::value,
             "sync_wait should return void");
 
         tt::sync_wait(std::move(f));
@@ -837,8 +801,7 @@ void test_future_sender()
             return 42;
         });
 
-        static_assert(ex::is_sender_v<std::decay_t<decltype(f)>>,
-            "a future should be a sender");
+        static_assert(ex::is_sender_v<std::decay_t<decltype(f)>>, "a future should be a sender");
 
         PIKA_TEST_EQ(tt::sync_wait(std::move(f)), 42);
         PIKA_TEST(called);
@@ -865,9 +828,7 @@ void test_future_sender()
             return 42;
         });
 
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::then(std::move(f), [](int x) { return x / 2; })),
-            21);
+        PIKA_TEST_EQ(tt::sync_wait(ex::then(std::move(f), [](int x) { return x / 2; })), 21);
         PIKA_TEST(called);
     }
 
@@ -875,10 +836,9 @@ void test_future_sender()
         std::atomic<std::size_t> calls{0};
         auto sf = pika::async([&]() { ++calls; }).share();
 
-        static_assert(ex::is_sender_v<std::decay_t<decltype(sf)>>,
-            "a shared_future should be a sender");
         static_assert(
-            std::is_void<decltype(tt::sync_wait(std::move(sf)))>::value,
+            ex::is_sender_v<std::decay_t<decltype(sf)>>, "a shared_future should be a sender");
+        static_assert(std::is_void<decltype(tt::sync_wait(std::move(sf)))>::value,
             "sync_wait should return void");
 
         tt::sync_wait(sf);
@@ -906,8 +866,8 @@ void test_future_sender()
             return 42;
         }).share();
 
-        static_assert(ex::is_sender_v<std::decay_t<decltype(sf)>>,
-            "a shared_future should be a sender");
+        static_assert(
+            ex::is_sender_v<std::decay_t<decltype(sf)>>, "a shared_future should be a sender");
 
         PIKA_TEST_EQ(tt::sync_wait(sf), 42);
         PIKA_TEST_EQ(tt::sync_wait(sf), 42);
@@ -946,55 +906,45 @@ void test_future_sender()
     }
 
     {
-        auto f = ex::transfer_just(ex::thread_pool_scheduler{}, 3) |
-            ex::make_future();
+        auto f = ex::transfer_just(ex::thread_pool_scheduler{}, 3) | ex::make_future();
         PIKA_TEST_EQ(f.get(), 3);
     }
 
     {
         std::atomic<bool> called{false};
-        auto s = ex::schedule(ex::thread_pool_scheduler{}) |
-            ex::then([&] { called = true; });
+        auto s = ex::schedule(ex::thread_pool_scheduler{}) | ex::then([&] { called = true; });
         auto f = ex::make_future(std::move(s));
         f.get();
         PIKA_TEST(called);
     }
 
     {
-        auto s1 =
-            ex::transfer_just(ex::thread_pool_scheduler{}, std::size_t(42));
+        auto s1 = ex::transfer_just(ex::thread_pool_scheduler{}, std::size_t(42));
         auto s2 = ex::transfer_just(ex::thread_pool_scheduler{}, 3.14);
-        auto s3 = ex::transfer_just(
-            ex::thread_pool_scheduler{}, std::string("hello"));
-        auto f = ex::make_future(ex::then(
-            ex::when_all(std::move(s1), std::move(s2), std::move(s3)),
+        auto s3 = ex::transfer_just(ex::thread_pool_scheduler{}, std::string("hello"));
+        auto f = ex::make_future(ex::then(ex::when_all(std::move(s1), std::move(s2), std::move(s3)),
             [](std::size_t x, double, std::string z) { return z.size() + x; }));
         PIKA_TEST_EQ(f.get(), std::size_t(47));
     }
 
     // mixing senders and futures
     {
-        PIKA_TEST_EQ(tt::sync_wait(ex::make_future(
-                         ex::transfer_just(ex::thread_pool_scheduler{}, 42))),
-            42);
+        PIKA_TEST_EQ(
+            tt::sync_wait(ex::make_future(ex::transfer_just(ex::thread_pool_scheduler{}, 42))), 42);
     }
 
     {
-        PIKA_TEST_EQ(
-            ex::make_future(ex::transfer(pika::async([]() { return 42; }),
-                                ex::thread_pool_scheduler{}))
-                .get(),
+        PIKA_TEST_EQ(ex::make_future(ex::transfer(pika::async([]() { return 42; }),
+                                         ex::thread_pool_scheduler{}))
+                         .get(),
             42);
     }
 
     {
-        auto s1 =
-            ex::transfer_just(ex::thread_pool_scheduler{}, std::size_t(42));
+        auto s1 = ex::transfer_just(ex::thread_pool_scheduler{}, std::size_t(42));
         auto s2 = ex::transfer_just(ex::thread_pool_scheduler{}, 3.14);
-        auto s3 = ex::transfer_just(
-            ex::thread_pool_scheduler{}, std::string("hello"));
-        auto f = ex::make_future(ex::then(
-            ex::when_all(std::move(s1), std::move(s2), std::move(s3)),
+        auto s3 = ex::transfer_just(ex::thread_pool_scheduler{}, std::string("hello"));
+        auto f = ex::make_future(ex::then(ex::when_all(std::move(s1), std::move(s2), std::move(s3)),
             [](std::size_t x, double, std::string z) { return z.size() + x; }));
         auto sf = f.then([](auto&& f) { return f.get() - 40; }).share();
         auto t1 = sf.then([](auto&& sf) { return sf.get() + 1; });
@@ -1002,9 +952,7 @@ void test_future_sender()
         auto t1s = ex::then(std::move(t1), [](std::size_t x) { return x + 1; });
         auto t1f = ex::make_future(std::move(t1s));
         auto last = pika::dataflow(
-            pika::unwrapping(
-                [](std::size_t x, std::size_t y) { return x + y; }),
-            t1f, t2);
+            pika::unwrapping([](std::size_t x, std::size_t y) { return x + y; }), t1f, t2);
 
         PIKA_TEST_EQ(last.get(), std::size_t(18));
     }
@@ -1024,8 +972,7 @@ void test_ensure_started()
     }
 
     {
-        auto s = ex::transfer_just(sched, 42) | ex::ensure_started() |
-            ex::transfer(sched);
+        auto s = ex::transfer_just(sched, 42) | ex::ensure_started() | ex::transfer(sched);
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 42);
     }
 
@@ -1033,8 +980,7 @@ void test_ensure_started()
     // copyable.
 #if !defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
     {
-        auto s =
-            ex::transfer_just(sched, 42) | ex::ensure_started() | ex::split();
+        auto s = ex::transfer_just(sched, 42) | ex::ensure_started() | ex::split();
         PIKA_TEST_EQ(tt::sync_wait(s), 42);
         PIKA_TEST_EQ(tt::sync_wait(s), 42);
         PIKA_TEST_EQ(tt::sync_wait(s), 42);
@@ -1080,9 +1026,8 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             3);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -1115,9 +1060,8 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -1149,9 +1093,8 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -1175,8 +1118,7 @@ void test_split()
     }
 
     {
-        auto s =
-            ex::transfer_just(sched, 42) | ex::split() | ex::transfer(sched);
+        auto s = ex::transfer_just(sched, 42) | ex::split() | ex::transfer(sched);
         PIKA_TEST_EQ(tt::sync_wait(std::move(s)), 42);
     }
 
@@ -1199,8 +1141,7 @@ void test_split_when_all()
     {
         std::atomic<std::size_t> first_task_calls{0};
         std::atomic<std::size_t> successor_task_calls{0};
-        auto s = ex::schedule(sched) | ex::then([&]() { ++first_task_calls; }) |
-            ex::split();
+        auto s = ex::schedule(sched) | ex::then([&]() { ++first_task_calls; }) | ex::split();
         auto succ1 = s | ex::then([&]() {
             ++successor_task_calls;
             return 1;
@@ -1209,9 +1150,8 @@ void test_split_when_all()
             ++successor_task_calls;
             return 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             3);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -1232,9 +1172,8 @@ void test_split_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -1255,9 +1194,8 @@ void test_split_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-        PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; })),
+        PIKA_TEST_EQ(tt::sync_wait(ex::when_all(succ1, succ2) |
+                         ex::then([](int const& x, int const& y) { return x + y; })),
             9);
         PIKA_TEST_EQ(first_task_calls, std::size_t(1));
         PIKA_TEST_EQ(successor_task_calls, std::size_t(2));
@@ -1271,27 +1209,27 @@ void test_let_value()
 
     // void predecessor
     {
-        auto result = tt::sync_wait(
-            ex::schedule(sched) | ex::let_value([]() { return ex::just(42); }));
+        auto result =
+            tt::sync_wait(ex::schedule(sched) | ex::let_value([]() { return ex::just(42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     {
-        auto result = tt::sync_wait(ex::schedule(sched) |
-            ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
+        auto result = tt::sync_wait(
+            ex::schedule(sched) | ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     {
-        auto result = tt::sync_wait(ex::just() |
-            ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
+        auto result = tt::sync_wait(
+            ex::just() | ex::let_value([=]() { return ex::transfer_just(sched, 42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     // int predecessor, value ignored
     {
-        auto result = tt::sync_wait(ex::transfer_just(sched, 43) |
-            ex::let_value([](int&) { return ex::just(42); }));
+        auto result = tt::sync_wait(
+            ex::transfer_just(sched, 43) | ex::let_value([](int&) { return ex::just(42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
@@ -1302,33 +1240,29 @@ void test_let_value()
     }
 
     {
-        auto result = tt::sync_wait(ex::just(43) |
-            ex::let_value([=](int&) { return ex::transfer_just(sched, 42); }));
+        auto result = tt::sync_wait(
+            ex::just(43) | ex::let_value([=](int&) { return ex::transfer_just(sched, 42); }));
         PIKA_TEST_EQ(result, 42);
     }
 
     // int predecessor, value used
     {
-        auto result = tt::sync_wait(
-            ex::transfer_just(sched, 43) | ex::let_value([](int& x) {
-                return ex::just(42) | ex::then([&](int y) { return x + y; });
-            }));
+        auto result = tt::sync_wait(ex::transfer_just(sched, 43) | ex::let_value([](int& x) {
+            return ex::just(42) | ex::then([&](int y) { return x + y; });
+        }));
         PIKA_TEST_EQ(result, 85);
     }
 
     {
-        auto result = tt::sync_wait(
-            ex::transfer_just(sched, 43) | ex::let_value([=](int& x) {
-                return ex::transfer_just(sched, 42) |
-                    ex::then([&](int y) { return x + y; });
-            }));
+        auto result = tt::sync_wait(ex::transfer_just(sched, 43) | ex::let_value([=](int& x) {
+            return ex::transfer_just(sched, 42) | ex::then([&](int y) { return x + y; });
+        }));
         PIKA_TEST_EQ(result, 85);
     }
 
     {
         auto result = tt::sync_wait(ex::just(43) | ex::let_value([=](int& x) {
-            return ex::transfer_just(sched, 42) |
-                ex::then([&](int y) { return x + y; });
+            return ex::transfer_just(sched, 42) | ex::then([&](int y) { return x + y; });
         }));
         PIKA_TEST_EQ(result, 85);
     }
@@ -1358,8 +1292,7 @@ void test_let_value()
     }
 }
 
-void check_exception_ptr_message(
-    std::exception_ptr ep, std::string const& message)
+void check_exception_ptr_message(std::exception_ptr ep, std::string const& message)
 {
     try
     {
@@ -1381,37 +1314,34 @@ void test_let_error()
     // void predecessor
     {
         std::atomic<bool> called{false};
-        tt::sync_wait(ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([&called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::just();
-        }));
+        tt::sync_wait(ex::schedule(sched) | ex::then([]() { throw std::runtime_error("error"); }) |
+            ex::let_error([&called](std::exception_ptr& ep) {
+                called = true;
+                check_exception_ptr_message(ep, "error");
+                return ex::just();
+            }));
         PIKA_TEST(called);
     }
 
     {
         std::atomic<bool> called{false};
-        tt::sync_wait(ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([=, &called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched);
-        }));
+        tt::sync_wait(ex::schedule(sched) | ex::then([]() { throw std::runtime_error("error"); }) |
+            ex::let_error([=, &called](std::exception_ptr& ep) {
+                called = true;
+                check_exception_ptr_message(ep, "error");
+                return ex::transfer_just(sched);
+            }));
         PIKA_TEST(called);
     }
 
     {
         std::atomic<bool> called{false};
-        tt::sync_wait(ex::just() | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([=, &called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched);
-        }));
+        tt::sync_wait(ex::just() | ex::then([]() { throw std::runtime_error("error"); }) |
+            ex::let_error([=, &called](std::exception_ptr& ep) {
+                called = true;
+                check_exception_ptr_message(ep, "error");
+                return ex::transfer_just(sched);
+            }));
         PIKA_TEST(called);
     }
 
@@ -1451,8 +1381,8 @@ void test_let_error()
 
     // predecessor doesn't throw, let sender is ignored
     {
-        auto result = tt::sync_wait(ex::transfer_just(sched, 42) |
-            ex::let_error([](std::exception_ptr) {
+        auto result =
+            tt::sync_wait(ex::transfer_just(sched, 42) | ex::let_error([](std::exception_ptr) {
                 PIKA_TEST(false);
                 return ex::just(43);
             }));
@@ -1460,8 +1390,8 @@ void test_let_error()
     }
 
     {
-        auto result = tt::sync_wait(ex::transfer_just(sched, 42) |
-            ex::let_error([=](std::exception_ptr) {
+        auto result =
+            tt::sync_wait(ex::transfer_just(sched, 42) | ex::let_error([=](std::exception_ptr) {
                 PIKA_TEST(false);
                 return ex::transfer_just(sched, 43);
             }));
@@ -1469,11 +1399,10 @@ void test_let_error()
     }
 
     {
-        auto result =
-            tt::sync_wait(ex::just(42) | ex::let_error([=](std::exception_ptr) {
-                PIKA_TEST(false);
-                return ex::transfer_just(sched, 43);
-            }));
+        auto result = tt::sync_wait(ex::just(42) | ex::let_error([=](std::exception_ptr) {
+            PIKA_TEST(false);
+            return ex::transfer_just(sched, 43);
+        }));
         PIKA_TEST_EQ(result, 42);
     }
 }
@@ -1495,8 +1424,7 @@ void test_detach()
 
         {
             std::unique_lock l{mtx};
-            PIKA_TEST(cond.wait_for(
-                l, std::chrono::seconds(1), [&]() { return called; }));
+            PIKA_TEST(cond.wait_for(l, std::chrono::seconds(1), [&]() { return called; }));
         }
         PIKA_TEST(called);
     }
@@ -1516,8 +1444,7 @@ void test_detach()
 
         {
             std::unique_lock l{mtx};
-            PIKA_TEST(cond.wait_for(
-                l, std::chrono::seconds(1), [&]() { return called; }));
+            PIKA_TEST(cond.wait_for(l, std::chrono::seconds(1), [&]() { return called; }));
         }
         PIKA_TEST(called);
     }
@@ -1532,10 +1459,8 @@ void test_keep_future_sender()
     }
 
     {
-        tt::sync_wait(pika::make_ready_future<void>().share() |
-            ex::keep_future() | ex::then([](pika::shared_future<void>&& f) {
-                PIKA_TEST(f.is_ready());
-            }));
+        tt::sync_wait(pika::make_ready_future<void>().share() | ex::keep_future() |
+            ex::then([](pika::shared_future<void>&& f) { PIKA_TEST(f.is_ready()); }));
     }
 
     {
@@ -1547,8 +1472,8 @@ void test_keep_future_sender()
     }
 
     {
-        tt::sync_wait(pika::make_ready_future<int>(42).share() |
-            ex::keep_future() | ex::then([](pika::shared_future<int>&& f) {
+        tt::sync_wait(pika::make_ready_future<int>(42).share() | ex::keep_future() |
+            ex::then([](pika::shared_future<int>&& f) {
                 PIKA_TEST(f.is_ready());
                 PIKA_TEST_EQ(f.get(), 42);
             }));
@@ -1559,8 +1484,7 @@ void test_keep_future_sender()
         auto f = pika::async([&]() { called = true; });
 
         auto r = tt::sync_wait(std::move(f) | ex::keep_future());
-        static_assert(
-            std::is_same<std::decay_t<decltype(r)>, pika::future<void>>::value,
+        static_assert(std::is_same<std::decay_t<decltype(r)>, pika::future<void>>::value,
             "sync_wait should return future<void>");
 
         PIKA_TEST(called);
@@ -1589,8 +1513,7 @@ void test_keep_future_sender()
         });
 
         auto r = tt::sync_wait(std::move(f) | ex::keep_future());
-        static_assert(
-            std::is_same<std::decay_t<decltype(r)>, pika::future<int>>::value,
+        static_assert(std::is_same<std::decay_t<decltype(r)>, pika::future<int>>::value,
             "sync_wait should return future<int>");
 
         PIKA_TEST(called);
@@ -1656,8 +1579,7 @@ void test_keep_future_sender()
 
         PIKA_TEST_EQ(tt::sync_wait(sf | ex::keep_future()).get(), 42);
         PIKA_TEST_EQ(tt::sync_wait(sf | ex::keep_future()).get(), 42);
-        PIKA_TEST_EQ(
-            tt::sync_wait(std::move(sf) | ex::keep_future()).get(), 42);
+        PIKA_TEST_EQ(tt::sync_wait(std::move(sf) | ex::keep_future()).get(), 42);
         PIKA_TEST_EQ(calls, std::size_t(1));
 
         bool exception_thrown = false;
@@ -1677,8 +1599,8 @@ void test_keep_future_sender()
     {
         auto f = pika::async([&]() { return 42; });
 
-        auto r = tt::sync_wait(std::move(f) | ex::keep_future() |
-            ex::transfer(ex::thread_pool_scheduler{}));
+        auto r = tt::sync_wait(
+            std::move(f) | ex::keep_future() | ex::transfer(ex::thread_pool_scheduler{}));
         PIKA_TEST(r.is_ready());
         PIKA_TEST_EQ(r.get(), 42);
     }
@@ -1686,8 +1608,8 @@ void test_keep_future_sender()
     {
         auto sf = pika::async([&]() { return 42; }).share();
 
-        auto r = tt::sync_wait(std::move(sf) | ex::keep_future() |
-            ex::transfer(ex::thread_pool_scheduler{}));
+        auto r = tt::sync_wait(
+            std::move(sf) | ex::keep_future() | ex::transfer(ex::thread_pool_scheduler{}));
         PIKA_TEST(r.is_ready());
         PIKA_TEST_EQ(r.get(), 42);
     }
@@ -1702,8 +1624,8 @@ void test_keep_future_sender()
         // or storing a const&. The copy is not possible because the type is
         // noncopyable, and storing a reference is not acceptable since the
         // reference may outlive the value.
-        auto r = tt::sync_wait(std::move(sf) | ex::keep_future() |
-            ex::transfer(ex::thread_pool_scheduler{}));
+        auto r = tt::sync_wait(
+            std::move(sf) | ex::keep_future() | ex::transfer(ex::thread_pool_scheduler{}));
         PIKA_TEST(r.is_ready());
         PIKA_TEST_EQ(r.get().x, 42);
     }
@@ -1713,11 +1635,9 @@ void test_keep_future_sender()
         auto f = pika::async([]() { return 42; });
         auto sf = pika::async([]() { return 3.14; }).share();
 
-        auto fun = pika::unwrapping(
-            [](int&& x, double const& y) { return x * 2 + (int(y) / 2); });
+        auto fun = pika::unwrapping([](int&& x, double const& y) { return x * 2 + (int(y) / 2); });
         PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(std::move(f) | ex::keep_future(),
-                              sf | ex::keep_future()) |
+            tt::sync_wait(ex::when_all(std::move(f) | ex::keep_future(), sf | ex::keep_future()) |
                 ex::then(fun)),
             85);
     }
@@ -1726,11 +1646,9 @@ void test_keep_future_sender()
         auto f = pika::async([]() { return 42; });
         auto sf = pika::async([]() { return 3.14; }).share();
 
-        auto fun = pika::unwrapping(
-            [](int&& x, double const& y) { return x * 2 + (int(y) / 2); });
+        auto fun = pika::unwrapping([](int&& x, double const& y) { return x * 2 + (int(y) / 2); });
         PIKA_TEST_EQ(
-            tt::sync_wait(ex::when_all(std::move(f) | ex::keep_future(),
-                              sf | ex::keep_future()) |
+            tt::sync_wait(ex::when_all(std::move(f) | ex::keep_future(), sf | ex::keep_future()) |
                 ex::transfer(ex::thread_pool_scheduler{}) | ex::then(fun)),
             85);
     }
@@ -1745,11 +1663,10 @@ void test_bulk()
         std::vector<int> v(n, 0);
         pika::thread::id parent_id = pika::this_thread::get_id();
 
-        tt::sync_wait(
-            ex::schedule(ex::thread_pool_scheduler{}) | ex::bulk(n, [&](int i) {
-                ++v[i];
-                PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
-            }));
+        tt::sync_wait(ex::schedule(ex::thread_pool_scheduler{}) | ex::bulk(n, [&](int i) {
+            ++v[i];
+            PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
+        }));
 
         for (int i = 0; i < n; ++i)
         {
@@ -1762,8 +1679,7 @@ void test_bulk()
         std::vector<int> v(n, -1);
         pika::thread::id parent_id = pika::this_thread::get_id();
 
-        auto v_out = tt::sync_wait(
-            ex::transfer_just(ex::thread_pool_scheduler{}, std::move(v)) |
+        auto v_out = tt::sync_wait(ex::transfer_just(ex::thread_pool_scheduler{}, std::move(v)) |
             ex::bulk(n, [&parent_id](int i, std::vector<int>& v) {
                 v[i] = i;
                 PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
@@ -1781,11 +1697,10 @@ void test_bulk()
         std::vector<int> v(n, 0);
         pika::thread::id parent_id = pika::this_thread::get_id();
 
-        auto s =
-            ex::schedule(ex::thread_pool_scheduler{}) | ex::bulk(n, [&](int i) {
-                ++v[i];
-                PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
-            });
+        auto s = ex::schedule(ex::thread_pool_scheduler{}) | ex::bulk(n, [&](int i) {
+            ++v[i];
+            PIKA_TEST_NEQ(parent_id, pika::this_thread::get_id());
+        });
         tt::sync_wait(s);
 
         for (int i = 0; i < n; ++i)
@@ -1825,14 +1740,13 @@ void test_bulk()
 
         try
         {
-            tt::sync_wait(ex::transfer_just(ex::thread_pool_scheduler{}) |
-                ex::bulk(n, [&v](int i) {
-                    if (i == i_fail)
-                    {
-                        throw std::runtime_error("error");
-                    }
-                    v[i] = i;
-                }));
+            tt::sync_wait(ex::transfer_just(ex::thread_pool_scheduler{}) | ex::bulk(n, [&v](int i) {
+                if (i == i_fail)
+                {
+                    throw std::runtime_error("error");
+                }
+                v[i] = i;
+            }));
 
             if (expect_exception)
             {
@@ -1870,19 +1784,16 @@ void test_completion_scheduler()
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::thread_pool_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::thread_pool_scheduler>,
             "the completion scheduler should be a thread_pool_scheduler");
     }
 
     {
-        auto sender =
-            ex::then(ex::schedule(ex::thread_pool_scheduler{}), []() {});
+        auto sender = ex::then(ex::schedule(ex::thread_pool_scheduler{}), []() {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::thread_pool_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::thread_pool_scheduler>,
             "the completion scheduler should be a thread_pool_scheduler");
     }
 
@@ -1891,45 +1802,38 @@ void test_completion_scheduler()
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::thread_pool_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::thread_pool_scheduler>,
             "the completion scheduler should be a thread_pool_scheduler");
     }
 
     {
-        auto sender =
-            ex::bulk(ex::schedule(ex::thread_pool_scheduler{}), 10, [](int) {});
+        auto sender = ex::bulk(ex::schedule(ex::thread_pool_scheduler{}), 10, [](int) {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::thread_pool_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::thread_pool_scheduler>,
             "the completion scheduler should be a thread_pool_scheduler");
     }
 
     {
         auto sender = ex::then(
-            ex::bulk(ex::transfer_just(ex::thread_pool_scheduler{}, 42), 10,
-                [](int, int) {}),
+            ex::bulk(ex::transfer_just(ex::thread_pool_scheduler{}, 42), 10, [](int, int) {}),
             [](int) {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::thread_pool_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::thread_pool_scheduler>,
             "the completion scheduler should be a thread_pool_scheduler");
     }
 
     {
-        auto sender = ex::bulk(
-            ex::then(
-                ex::transfer_just(ex::thread_pool_scheduler{}, 42), [](int) {}),
-            10, [](int, int) {});
+        auto sender =
+            ex::bulk(ex::then(ex::transfer_just(ex::thread_pool_scheduler{}, 42), [](int) {}), 10,
+                [](int, int) {});
         auto completion_scheduler =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
-            std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
-                ex::thread_pool_scheduler>,
+            std::is_same_v<std::decay_t<decltype(completion_scheduler)>, ex::thread_pool_scheduler>,
             "the completion scheduler should be a thread_pool_scheduler");
     }
 }
@@ -1940,34 +1844,30 @@ void test_drop_value()
 
     {
         tt::sync_wait(ex::drop_value(ex::schedule(sched)));
-        static_assert(std::is_void_v<decltype(tt::sync_wait(
-                ex::drop_value(ex::schedule(sched))))>);
+        static_assert(std::is_void_v<decltype(tt::sync_wait(ex::drop_value(ex::schedule(sched))))>);
     }
 
     {
         tt::sync_wait(ex::drop_value(ex::transfer_just(sched, 3)));
-        static_assert(std::is_void_v<decltype(tt::sync_wait(
-                ex::drop_value(ex::transfer_just(sched, 3))))>);
+        static_assert(
+            std::is_void_v<decltype(tt::sync_wait(ex::drop_value(ex::transfer_just(sched, 3))))>);
     }
 
     {
-        tt::sync_wait(
-            ex::drop_value(ex::transfer_just(sched, std::string("hello"))));
-        static_assert(std::is_void_v<decltype(tt::sync_wait(ex::drop_value(
-                ex::transfer_just(sched, std::string("hello")))))>);
+        tt::sync_wait(ex::drop_value(ex::transfer_just(sched, std::string("hello"))));
+        static_assert(std::is_void_v<decltype(tt::sync_wait(
+                ex::drop_value(ex::transfer_just(sched, std::string("hello")))))>);
     }
 
     {
-        tt::sync_wait(ex::drop_value(ex::transfer_just(
-            sched, custom_type_non_default_constructible_non_copyable{0})));
-        static_assert(std::is_void_v<decltype(tt::sync_wait(
-                ex::drop_value(ex::transfer_just(sched,
-                    custom_type_non_default_constructible_non_copyable{0}))))>);
+        tt::sync_wait(ex::drop_value(
+            ex::transfer_just(sched, custom_type_non_default_constructible_non_copyable{0})));
+        static_assert(std::is_void_v<decltype(tt::sync_wait(ex::drop_value(ex::transfer_just(
+                sched, custom_type_non_default_constructible_non_copyable{0}))))>);
     }
 
     {
-        auto s = ex::drop_value(
-            ex::then(ex::just(), [] { throw std::runtime_error("error"); }));
+        auto s = ex::drop_value(ex::then(ex::just(), [] { throw std::runtime_error("error"); }));
 
         bool exception_thrown = false;
 
@@ -1996,22 +1896,21 @@ void test_split_tuple()
     }
 
     {
-        auto [s1, s2, s3] = ex::split_tuple(ex::transfer_just(
-            sched, std::tuple(42, std::string{"hello"}, 3.14)));
+        auto [s1, s2, s3] =
+            ex::split_tuple(ex::transfer_just(sched, std::tuple(42, std::string{"hello"}, 3.14)));
         PIKA_TEST_EQ(tt::sync_wait(std::move(s1)), 42);
         PIKA_TEST_EQ(tt::sync_wait(std::move(s2)), std::string{"hello"});
         PIKA_TEST_EQ(tt::sync_wait(std::move(s3)), 3.14);
     }
 
     {
-        auto [s1, s2, s3] = ex::split_tuple(ex::transfer_just(
-            sched, std::tuple(42, std::string{"hello"}, 3.14)));
+        auto [s1, s2, s3] =
+            ex::split_tuple(ex::transfer_just(sched, std::tuple(42, std::string{"hello"}, 3.14)));
         auto s1_transfer = std::move(s1) | ex::transfer(sched);
         auto s2_transfer = std::move(s2) | ex::transfer(sched);
         auto s3_transfer = std::move(s3) | ex::transfer(sched);
         PIKA_TEST_EQ(tt::sync_wait(std::move(s1_transfer)), 42);
-        PIKA_TEST_EQ(
-            tt::sync_wait(std::move(s2_transfer)), std::string{"hello"});
+        PIKA_TEST_EQ(tt::sync_wait(std::move(s2_transfer)), std::string{"hello"});
         PIKA_TEST_EQ(tt::sync_wait(std::move(s3_transfer)), 3.14);
     }
 
@@ -2090,8 +1989,7 @@ int pika_main()
 
 int main(int argc, char* argv[])
 {
-    PIKA_TEST_EQ_MSG(pika::init(pika_main, argc, argv), 0,
-        "pika main exited with non-zero status");
+    PIKA_TEST_EQ_MSG(pika::init(pika_main, argc, argv), 0, "pika main exited with non-zero status");
 
     return 0;
 }
diff --git a/libs/pika/futures/include/pika/futures/future.hpp b/libs/pika/futures/include/pika/futures/future.hpp
index c36ee425ec..e8ab4179f5 100644
--- a/libs/pika/futures/include/pika/futures/future.hpp
+++ b/libs/pika/futures/include/pika/futures/future.hpp
@@ -111,8 +111,7 @@ namespace pika::lcos::detail {
     struct future_get_result
     {
         template <typename SharedState>
-        PIKA_FORCEINLINE static R*
-        call(SharedState const& state, error_code& ec = throws)
+        PIKA_FORCEINLINE static R* call(SharedState const& state, error_code& ec = throws)
         {
             return state->get_result(ec);
         }
@@ -140,8 +139,7 @@ namespace pika::lcos::detail {
     };
 
     template <typename ContResult>
-    using continuation_result_t =
-        typename continuation_result<ContResult>::type;
+    using continuation_result_t = typename continuation_result<ContResult>::type;
 
     template <typename ContResult>
     struct continuation_result<pika::future<ContResult>>
@@ -155,27 +153,20 @@ namespace pika::lcos::detail {
     make_continuation(Future const& future, Policy&& policy, F&& f);
 
     // create non-unwrapping continuations
-    template <typename ContResult, typename Future, typename Executor,
-        typename F>
+    template <typename ContResult, typename Future, typename Executor, typename F>
     inline traits::detail::shared_state_ptr_t<ContResult>
     make_continuation_exec(Future const& future, Executor&& exec, F&& f);
 
-    template <typename ContResult, typename Future, typename Executor,
-        typename Policy, typename F>
+    template <typename ContResult, typename Future, typename Executor, typename Policy, typename F>
     inline traits::detail::shared_state_ptr_t<ContResult>
-    make_continuation_exec_policy(
-        Future const& future, Executor&& exec, Policy&& policy, F&& f);
+    make_continuation_exec_policy(Future const& future, Executor&& exec, Policy&& policy, F&& f);
 
-    template <typename ContResult, typename Allocator, typename Future,
-        typename Policy, typename F>
+    template <typename ContResult, typename Allocator, typename Future, typename Policy, typename F>
     inline traits::detail::shared_state_ptr_t<continuation_result_t<ContResult>>
-    make_continuation_alloc(
-        Allocator const& a, Future const& future, Policy&& policy, F&& f);
+    make_continuation_alloc(Allocator const& a, Future const& future, Policy&& policy, F&& f);
 
-    template <typename ContResult, typename Allocator, typename Future,
-        typename Policy, typename F>
-    inline traits::detail::shared_state_ptr_t<ContResult>
-    make_continuation_alloc_nounwrap(
+    template <typename ContResult, typename Allocator, typename Future, typename Policy, typename F>
+    inline traits::detail::shared_state_ptr_t<ContResult> make_continuation_alloc_nounwrap(
         Allocator const& a, Future const& future, Policy&& policy, F&& f);
 
     ///////////////////////////////////////////////////////////////////////////
@@ -183,8 +174,7 @@ namespace pika::lcos::detail {
     struct future_then_dispatch
     {
         template <typename F>
-        PIKA_FORCEINLINE static decltype(auto)
-        call(Future&& /* fut */, F&& /* f */)
+        PIKA_FORCEINLINE static decltype(auto) call(Future&& /* fut */, F&& /* f */)
         {
             // dummy impl to fail compilation if this function is called
             static_assert(sizeof(Future) == 0, "Cannot use the \
@@ -193,8 +183,7 @@ namespace pika::lcos::detail {
         }
 
         template <typename T0, typename F>
-        PIKA_FORCEINLINE static decltype(auto)
-        call(Future&& /* fut */, T0&& /* t */, F&& /* f */)
+        PIKA_FORCEINLINE static decltype(auto) call(Future&& /* fut */, T0&& /* t */, F&& /* f */)
         {
             // dummy impl to fail compilation if this function is called
             static_assert(sizeof(Future) == 0, "Cannot use the \
@@ -203,8 +192,8 @@ namespace pika::lcos::detail {
         }
 
         template <typename Allocator, typename F>
-        PIKA_FORCEINLINE static decltype(auto) call_alloc(
-            Allocator const& /* alloc */, Future&& /* fut */, F&& /* f */)
+        PIKA_FORCEINLINE static decltype(auto)
+        call_alloc(Allocator const& /* alloc */, Future&& /* fut */, F&& /* f */)
         {
             // dummy impl to fail compilation if this function is called
             static_assert(sizeof(Future) == 0, "Cannot use the \
@@ -224,17 +213,14 @@ namespace pika::lcos::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Future>
-    inline traits::detail::shared_state_ptr_t<void>
-    downcast_to_void(Future& future, bool addref)
+    inline traits::detail::shared_state_ptr_t<void> downcast_to_void(Future& future, bool addref)
     {
         using shared_state_type = traits::detail::shared_state_ptr_t<void>;
         using element_type = typename shared_state_type::element_type;
 
         // same as static_pointer_cast, but with addref option
         return shared_state_type(
-            static_cast<element_type*>(
-                traits::detail::get_shared_state(future).get()),
-            addref);
+            static_cast<element_type*>(traits::detail::get_shared_state(future).get()), addref);
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -260,8 +246,7 @@ namespace pika::lcos::detail {
         operation_state(operation_state const&) = delete;
         operation_state& operator=(operation_state const&) = delete;
 
-        friend void tag_invoke(pika::execution::experimental::start_t,
-            operation_state& os) noexcept
+        friend void tag_invoke(pika::execution::experimental::start_t, operation_state& os) noexcept
         {
             os.start_helper();
         }
@@ -275,8 +260,7 @@ namespace pika::lcos::detail {
 
                     if (!state)
                     {
-                        PIKA_THROW_EXCEPTION(pika::error::no_state,
-                            "operation_state::start",
+                        PIKA_THROW_EXCEPTION(pika::error::no_state, "operation_state::start",
                             "the future has no valid shared state");
                     }
 
@@ -288,8 +272,7 @@ namespace pika::lcos::detail {
                         {
                             if constexpr (std::is_void_v<result_type>)
                             {
-                                pika::execution::experimental::set_value(
-                                    PIKA_MOVE(receiver_));
+                                pika::execution::experimental::set_value(PIKA_MOVE(receiver_));
                             }
                             else
                             {
@@ -300,14 +283,12 @@ namespace pika::lcos::detail {
                         else if (future_.has_exception())
                         {
                             pika::execution::experimental::set_error(
-                                PIKA_MOVE(receiver_),
-                                future_.get_exception_ptr());
+                                PIKA_MOVE(receiver_), future_.get_exception_ptr());
                         }
                     });
                 },
                 [&](std::exception_ptr ep) {
-                    pika::execution::experimental::set_error(
-                        PIKA_MOVE(receiver_), PIKA_MOVE(ep));
+                    pika::execution::experimental::set_error(PIKA_MOVE(receiver_), PIKA_MOVE(ep));
                 });
         }
 
@@ -337,20 +318,17 @@ namespace pika::lcos::detail {
         using is_sender = void;
 
         using result_type = R;
-        using shared_state_type =
-            future_data_base<traits::detail::shared_state_ptr_result_t<R>>;
+        using shared_state_type = future_data_base<traits::detail::shared_state_ptr_result_t<R>>;
 
         // Sender compatibility
 #if defined(PIKA_HAVE_P2300_REFERENCE_IMPLEMENTATION)
-        using completion_signatures =
-            pika::execution::experimental::completion_signatures<
-                typename set_value_signature_helper<result_type>::type,
-                pika::execution::experimental::set_error_t(std::exception_ptr)>;
+        using completion_signatures = pika::execution::experimental::completion_signatures<
+            typename set_value_signature_helper<result_type>::type,
+            pika::execution::experimental::set_error_t(std::exception_ptr)>;
 #else
-        template <template <typename...> class Tuple,
-            template <typename...> class Variant>
-        using value_types = std::conditional_t<std::is_void_v<result_type>,
-            Variant<Tuple<>>, Variant<Tuple<result_type>>>;
+        template <template <typename...> class Tuple, template <typename...> class Variant>
+        using value_types = std::conditional_t<std::is_void_v<result_type>, Variant<Tuple<>>,
+            Variant<Tuple<result_type>>>;
 
         template <template <typename...> class Variant>
         using error_types = Variant<std::exception_ptr>;
@@ -360,8 +338,7 @@ namespace pika::lcos::detail {
 
     private:
         template <typename F>
-        struct future_then_dispatch
-          : lcos::detail::future_then_dispatch<Derived, F>
+        struct future_then_dispatch : lcos::detail::future_then_dispatch<Derived, F>
         {
         };
 
@@ -423,16 +400,14 @@ namespace pika::lcos::detail {
         {
             if (!shared_state_)
             {
-                PIKA_THROW_EXCEPTION(pika::error::no_state,
-                    "future_base<R>::get_exception_ptr",
+                PIKA_THROW_EXCEPTION(pika::error::no_state, "future_base<R>::get_exception_ptr",
                     "this future has no valid shared state");
             }
 
             using result_type = typename shared_state_type::result_type;
 
             error_code ec(throwmode::lightweight);
-            lcos::detail::future_get_result<result_type>::call(
-                this->shared_state_, ec);
+            lcos::detail::future_get_result<result_type>::call(this->shared_state_, ec);
             if (!ec)
             {
                 PIKA_ASSERT(!has_exception());
@@ -478,20 +453,17 @@ namespace pika::lcos::detail {
             -> decltype(future_then_dispatch<std::decay_t<F>>::call(
                 PIKA_MOVE(fut), PIKA_FORWARD(F, f)))
         {
-            using result_type =
-                decltype(future_then_dispatch<std::decay_t<F>>::call(
-                    PIKA_MOVE(fut), PIKA_FORWARD(F, f)));
+            using result_type = decltype(future_then_dispatch<std::decay_t<F>>::call(
+                PIKA_MOVE(fut), PIKA_FORWARD(F, f)));
 
             if (!fut.shared_state_)
             {
-                PIKA_THROWS_IF(ec, pika::error::no_state,
-                    "future_base<R>::then",
+                PIKA_THROWS_IF(ec, pika::error::no_state, "future_base<R>::then",
                     "this future has no valid shared state");
                 return result_type();
             }
 
-            return future_then_dispatch<std::decay_t<F>>::call(
-                PIKA_MOVE(fut), PIKA_FORWARD(F, f));
+            return future_then_dispatch<std::decay_t<F>>::call(PIKA_MOVE(fut), PIKA_FORWARD(F, f));
         }
 
         template <typename F, typename T0>
@@ -499,14 +471,12 @@ namespace pika::lcos::detail {
             -> decltype(future_then_dispatch<std::decay_t<T0>>::call(
                 PIKA_MOVE(fut), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f)))
         {
-            using result_type =
-                decltype(future_then_dispatch<std::decay_t<T0>>::call(
-                    PIKA_MOVE(fut), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f)));
+            using result_type = decltype(future_then_dispatch<std::decay_t<T0>>::call(
+                PIKA_MOVE(fut), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f)));
 
             if (!fut.shared_state_)
             {
-                PIKA_THROWS_IF(ec, pika::error::no_state,
-                    "future_base<R>::then",
+                PIKA_THROWS_IF(ec, pika::error::no_state, "future_base<R>::then",
                     "this future has no valid shared state");
                 return result_type();
             }
@@ -516,19 +486,17 @@ namespace pika::lcos::detail {
         }
 
         template <typename Allocator, typename F>
-        static auto then_alloc(Allocator const& alloc, Derived&& fut, F&& f,
-            error_code& ec = throws)
+        static auto
+        then_alloc(Allocator const& alloc, Derived&& fut, F&& f, error_code& ec = throws)
             -> decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
                 alloc, PIKA_MOVE(fut), PIKA_FORWARD(F, f)))
         {
-            using result_type =
-                decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
-                    alloc, PIKA_MOVE(fut), PIKA_FORWARD(F, f)));
+            using result_type = decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
+                alloc, PIKA_MOVE(fut), PIKA_FORWARD(F, f)));
 
             if (!fut.shared_state_)
             {
-                PIKA_THROWS_IF(ec, pika::error::no_state,
-                    "future_base<R>::then_alloc",
+                PIKA_THROWS_IF(ec, pika::error::no_state, "future_base<R>::then_alloc",
                     "this future has no valid shared state");
                 return result_type();
             }
@@ -542,8 +510,7 @@ namespace pika::lcos::detail {
         {
             if (!shared_state_)
             {
-                PIKA_THROWS_IF(ec, pika::error::no_state,
-                    "future_base<R>::wait",
+                PIKA_THROWS_IF(ec, pika::error::no_state, "future_base<R>::wait",
                     "this future has no valid shared state");
                 return;
             }
@@ -562,13 +529,11 @@ namespace pika::lcos::detail {
         //     absolute timeout (30.2.4) specified by abs_time has expired.
         // Throws: timeout-related exceptions (30.2.4).
         pika::future_status wait_until(
-            pika::chrono::steady_time_point const& abs_time,
-            error_code& ec = throws) const
+            pika::chrono::steady_time_point const& abs_time, error_code& ec = throws) const
         {
             if (!shared_state_)
             {
-                PIKA_THROWS_IF(ec, pika::error::no_state,
-                    "future_base<R>::wait_until",
+                PIKA_THROWS_IF(ec, pika::error::no_state, "future_base<R>::wait_until",
                     "this future has no valid shared state");
                 return pika::future_status::uninitialized;
             }
@@ -587,8 +552,7 @@ namespace pika::lcos::detail {
         //     relative timeout (30.2.4) specified by rel_time has expired.
         // Throws: timeout-related exceptions (30.2.4).
         pika::future_status wait_for(
-            pika::chrono::steady_duration const& rel_time,
-            error_code& ec = throws) const
+            pika::chrono::steady_duration const& rel_time, error_code& ec = throws) const
         {
             return wait_until(rel_time.from_now(), ec);
         }
@@ -596,8 +560,7 @@ namespace pika::lcos::detail {
 #if defined(PIKA_HAVE_CXX20_COROUTINES)
         bool await_ready() const noexcept
         {
-            return lcos::detail::await_ready(
-                *static_cast<Derived const*>(this));
+            return lcos::detail::await_ready(*static_cast<Derived const*>(this));
         }
 
         template <typename Promise>
@@ -641,8 +604,7 @@ namespace pika {
 
         template <typename Receiver>
         friend lcos::detail::operation_state<Receiver, future>
-        tag_invoke(pika::execution::experimental::connect_t, future&& f,
-            Receiver&& receiver)
+        tag_invoke(pika::execution::experimental::connect_t, future&& f, Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(f)};
         }
@@ -708,8 +670,7 @@ namespace pika {
         //     constructor invocation.
         //   - other.valid() == false.
         future(future<future>&& other) noexcept
-          : base_type(other.valid() ? lcos::detail::unwrap(PIKA_MOVE(other)) :
-                                      nullptr)
+          : base_type(other.valid() ? lcos::detail::unwrap(PIKA_MOVE(other)) : nullptr)
         {
         }
 
@@ -720,8 +681,7 @@ namespace pika {
         //     constructor invocation.
         //   - other.valid() == false.
         future(future<shared_future<R>>&& other) noexcept
-          : base_type(other.valid() ? lcos::detail::unwrap(PIKA_MOVE(other)) :
-                                      nullptr)
+          : base_type(other.valid() ? lcos::detail::unwrap(PIKA_MOVE(other)) : nullptr)
         {
         }
 
@@ -733,14 +693,10 @@ namespace pika {
         //   - other.valid() == false.
         template <typename T>
         future(future<T>&& other,
-            std::enable_if_t<std::is_void_v<R> && !traits::is_future_v<T>, T>* =
-                nullptr)
-          : base_type(other.valid() ?
-                    lcos::detail::downcast_to_void(other, false) :
-                    nullptr)
+            std::enable_if_t<std::is_void_v<R> && !traits::is_future_v<T>, T>* = nullptr)
+          : base_type(other.valid() ? lcos::detail::downcast_to_void(other, false) : nullptr)
         {
-            traits::future_access<future<T>>::detach_shared_state(
-                PIKA_MOVE(other));
+            traits::future_access<future<T>>::detach_shared_state(PIKA_MOVE(other));
         }
 
         // Effects:
@@ -787,15 +743,13 @@ namespace pika {
 
             using result_type = typename shared_state_type::result_type;
             result_type* result =
-                lcos::detail::future_get_result<result_type>::call(
-                    this->shared_state_);
+                lcos::detail::future_get_result<result_type>::call(this->shared_state_);
 
             // no error has been reported, return the result
             return lcos::detail::future_value<R>::get(PIKA_MOVE(*result));
         }
 
-        typename pika::traits::future_traits<future>::result_type get(
-            error_code& ec)
+        typename pika::traits::future_traits<future>::result_type get(error_code& ec)
         {
             if (!this->shared_state_)
             {
@@ -808,8 +762,7 @@ namespace pika {
 
             using result_type = typename shared_state_type::result_type;
             result_type* result =
-                lcos::detail::future_get_result<result_type>::call(
-                    this->shared_state_, ec);
+                lcos::detail::future_get_result<result_type>::call(this->shared_state_, ec);
             if (ec)
             {
                 return lcos::detail::future_value<R>::get_default();
@@ -836,8 +789,7 @@ namespace pika {
             // "error: cannot use an entity undefined in device code" without
             // specifying what entity it refers to.
             PIKA_ASSERT(false);
-            using future_type = decltype(base_type::then(
-                PIKA_MOVE(*this), PIKA_FORWARD(F, f), ec));
+            using future_type = decltype(base_type::then(PIKA_MOVE(*this), PIKA_FORWARD(F, f), ec));
             return future_type{};
 #else
             invalidate on_exit(*this);
@@ -850,13 +802,12 @@ namespace pika {
         {
 #if defined(PIKA_COMPUTE_DEVICE_CODE)
             PIKA_ASSERT(false);
-            using future_type = decltype(base_type::then(PIKA_MOVE(*this),
-                PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec));
+            using future_type = decltype(base_type::then(
+                PIKA_MOVE(*this), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec));
             return future_type{};
 #else
             invalidate on_exit(*this);
-            return base_type::then(
-                PIKA_MOVE(*this), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec);
+            return base_type::then(PIKA_MOVE(*this), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec);
 #endif
         }
 
@@ -871,13 +822,12 @@ namespace pika {
         {
 #if defined(PIKA_COMPUTE_DEVICE_CODE)
             PIKA_ASSERT(false);
-            using future_type = decltype(base_type::then_alloc(
-                alloc, std::move(*this), std::forward<F>(f), ec));
+            using future_type =
+                decltype(base_type::then_alloc(alloc, std::move(*this), std::forward<F>(f), ec));
             return future_type{};
 #else
             invalidate on_exit(*this);
-            return base_type::then_alloc(
-                alloc, PIKA_MOVE(*this), PIKA_FORWARD(F, f), ec);
+            return base_type::then_alloc(alloc, PIKA_MOVE(*this), PIKA_FORWARD(F, f), ec);
 #endif
         }
 
@@ -902,9 +852,8 @@ namespace pika {
         }
         else
         {
-            return f.then(pika::launch::sync, [](pika::future<U>&& f) -> R {
-                return detail::void_guard<R>(), f.get();
-            });
+            return f.then(pika::launch::sync,
+                [](pika::future<U>&& f) -> R { return detail::void_guard<R>(), f.get(); });
         }
     }
 
@@ -919,8 +868,8 @@ namespace pika {
         }
         else
         {
-            return f.then(pika::launch::sync,
-                [conv = PIKA_FORWARD(Conv, conv)](pika::future<U>&& f) -> R {
+            return f.then(
+                pika::launch::sync, [conv = PIKA_FORWARD(Conv, conv)](pika::future<U>&& f) -> R {
                     return PIKA_INVOKE(conv, f.get());
                 });
         }
@@ -950,16 +899,14 @@ namespace pika {
 
         template <typename Receiver>
         friend lcos::detail::operation_state<Receiver, shared_future>
-        tag_invoke(pika::execution::experimental::connect_t, shared_future&& f,
-            Receiver&& receiver)
+        tag_invoke(pika::execution::experimental::connect_t, shared_future&& f, Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), PIKA_MOVE(f)};
         }
 
         template <typename Receiver>
         friend lcos::detail::operation_state<Receiver, shared_future>
-        tag_invoke(pika::execution::experimental::connect_t, shared_future& f,
-            Receiver&& receiver)
+        tag_invoke(pika::execution::experimental::connect_t, shared_future& f, Receiver&& receiver)
         {
             return {PIKA_FORWARD(Receiver, receiver), f};
         }
@@ -972,8 +919,7 @@ namespace pika {
         friend struct pika::traits::detail::future_access_customization_point;
 
         // Effects: constructs a future object from an shared state
-        explicit shared_future(
-            pika::intrusive_ptr<shared_state_type> const& state)
+        explicit shared_future(pika::intrusive_ptr<shared_state_type> const& state)
           : base_type(state)
         {
         }
@@ -1021,8 +967,7 @@ namespace pika {
         //     constructor invocation.
         //   - other.valid() == false.
         shared_future(future<shared_future>&& other) noexcept
-          : base_type(
-                other.valid() ? lcos::detail::unwrap(other.share()) : nullptr)
+          : base_type(other.valid() ? lcos::detail::unwrap(other.share()) : nullptr)
         {
         }
 
@@ -1033,11 +978,8 @@ namespace pika {
         //     constructor invocation.
         template <typename T>
         shared_future(shared_future<T> const& other,
-            std::enable_if_t<std::is_void_v<R> && !traits::is_future_v<T>, T>* =
-                nullptr)
-          : base_type(other.valid() ?
-                    lcos::detail::downcast_to_void(other, true) :
-                    nullptr)
+            std::enable_if_t<std::is_void_v<R> && !traits::is_future_v<T>, T>* = nullptr)
+          : base_type(other.valid() ? lcos::detail::downcast_to_void(other, true) : nullptr)
         {
         }
 
@@ -1074,20 +1016,17 @@ namespace pika {
         // Throws: the stored exception, if an exception was stored in the
         //         shared state.
         // Postcondition: valid() == false.
-        typename pika::traits::future_traits<shared_future>::result_type
-        get() const    //-V659
+        typename pika::traits::future_traits<shared_future>::result_type get() const    //-V659
         {
             if (!this->shared_state_)
             {
-                PIKA_THROW_EXCEPTION(pika::error::no_state,
-                    "shared_future<R>::get",
+                PIKA_THROW_EXCEPTION(pika::error::no_state, "shared_future<R>::get",
                     "this future has no valid shared state");
             }
 
             using result_type = typename shared_state_type::result_type;
             result_type* result =
-                lcos::detail::future_get_result<result_type>::call(
-                    this->shared_state_);
+                lcos::detail::future_get_result<result_type>::call(this->shared_state_);
 
             // no error has been reported, return the result
             return lcos::detail::future_value<R>::get(*result);
@@ -1099,21 +1038,17 @@ namespace pika {
             using result_type = typename shared_state_type::result_type;
             if (!this->shared_state_)
             {
-                PIKA_THROWS_IF(ec, pika::error::no_state,
-                    "shared_future<R>::get",
+                PIKA_THROWS_IF(ec, pika::error::no_state, "shared_future<R>::get",
                     "this future has no valid shared state");
-                static result_type res(
-                    lcos::detail::future_value<R>::get_default());
+                static result_type res(lcos::detail::future_value<R>::get_default());
                 return res;
             }
 
             result_type* result =
-                lcos::detail::future_get_result<result_type>::call(
-                    this->shared_state_, ec);
+                lcos::detail::future_get_result<result_type>::call(this->shared_state_, ec);
             if (ec)
             {
-                static result_type res(
-                    lcos::detail::future_value<R>::get_default());
+                static result_type res(lcos::detail::future_value<R>::get_default());
                 return res;
             }
 
@@ -1133,12 +1068,11 @@ namespace pika {
         {
 #if defined(PIKA_COMPUTE_DEVICE_CODE)
             PIKA_ASSERT(false);
-            using future_type = decltype(base_type::then(
-                shared_future(*this), PIKA_FORWARD(F, f), ec));
+            using future_type =
+                decltype(base_type::then(shared_future(*this), PIKA_FORWARD(F, f), ec));
             return future_type{};
 #else
-            return base_type::then(
-                shared_future(*this), PIKA_FORWARD(F, f), ec);
+            return base_type::then(shared_future(*this), PIKA_FORWARD(F, f), ec);
 #endif
         }
 
@@ -1147,12 +1081,12 @@ namespace pika {
         {
 #if defined(PIKA_COMPUTE_DEVICE_CODE)
             PIKA_ASSERT(false);
-            using future_type = decltype(base_type::then(shared_future(*this),
-                PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec));
+            using future_type = decltype(base_type::then(
+                shared_future(*this), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec));
             return future_type{};
 #else
-            return base_type::then(shared_future(*this), PIKA_FORWARD(T0, t0),
-                PIKA_FORWARD(F, f), ec);
+            return base_type::then(
+                shared_future(*this), PIKA_FORWARD(T0, t0), PIKA_FORWARD(F, f), ec);
 #endif
         }
 
@@ -1171,8 +1105,7 @@ namespace pika {
                 alloc, shared_future(*this), PIKA_FORWARD(F, f), ec));
             return future_type{};
 #else
-            return base_type::then_alloc(
-                alloc, shared_future(*this), PIKA_FORWARD(F, f), ec);
+            return base_type::then_alloc(alloc, shared_future(*this), PIKA_FORWARD(F, f), ec);
 #endif
         }
 
@@ -1191,17 +1124,14 @@ namespace pika {
             "the argument type must be implicitly convertible to the requested "
             "result type");
 
-        if constexpr (std::is_convertible_v<pika::shared_future<U>,
-                          pika::future<R>>)
+        if constexpr (std::is_convertible_v<pika::shared_future<U>, pika::future<R>>)
         {
             return pika::future<R>(PIKA_MOVE(f));
         }
         else
         {
-            return f.then(
-                pika::launch::sync, [](pika::shared_future<U>&& f) -> R {
-                    return detail::void_guard<R>(), f.get();
-                });
+            return f.then(pika::launch::sync,
+                [](pika::shared_future<U>&& f) -> R { return detail::void_guard<R>(), f.get(); });
         }
         // This silences a bogus warning from nvcc about no return from a
         // non-void function.
@@ -1219,8 +1149,7 @@ namespace pika {
             "the argument type must be convertible to the requested "
             "result type by using the supplied conversion function");
 
-        if constexpr (std::is_convertible_v<pika::shared_future<U>,
-                          pika::future<R>>)
+        if constexpr (std::is_convertible_v<pika::shared_future<U>, pika::future<R>>)
         {
             return pika::future<R>(PIKA_MOVE(f));
         }
@@ -1228,9 +1157,7 @@ namespace pika {
         {
             return f.then(pika::launch::sync,
                 [conv = PIKA_FORWARD(Conv, conv)](
-                    pika::shared_future<U> const& f) -> R {
-                    return PIKA_INVOKE(conv, f.get());
-                });
+                    pika::shared_future<U> const& f) -> R { return PIKA_INVOKE(conv, f.get()); });
         }
     }
 
@@ -1244,22 +1171,19 @@ namespace pika {
     }
 
     template <typename R>
-    pika::shared_future<R>&
-    make_shared_future(pika::shared_future<R>& f) noexcept
+    pika::shared_future<R>& make_shared_future(pika::shared_future<R>& f) noexcept
     {
         return f;
     }
 
     template <typename R>
-    pika::shared_future<R>&&
-    make_shared_future(pika::shared_future<R>&& f) noexcept
+    pika::shared_future<R>&& make_shared_future(pika::shared_future<R>&& f) noexcept
     {
         return PIKA_MOVE(f);
     }
 
     template <typename R>
-    pika::shared_future<R> const&
-    make_shared_future(pika::shared_future<R> const& f) noexcept
+    pika::shared_future<R> const& make_shared_future(pika::shared_future<R> const& f) noexcept
     {
         return f;
     }
@@ -1270,41 +1194,40 @@ namespace pika {
     ///////////////////////////////////////////////////////////////////////////
     // Extension (see wg21.link/P0319), with allocator
     template <typename T, typename Allocator, typename... Ts>
-    std::enable_if_t<std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>,
-        future<T>>
+    std::enable_if_t<std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>, future<T>>
     make_ready_future_alloc(Allocator const& a, Ts&&... ts)
     {
         using result_type = T;
 
         using base_allocator = Allocator;
-        using shared_state = traits::shared_state_allocator_t<
-            lcos::detail::future_data<result_type>, base_allocator>;
+        using shared_state =
+            traits::shared_state_allocator_t<lcos::detail::future_data<result_type>,
+                base_allocator>;
 
-        using other_allocator = typename std::allocator_traits<
-            base_allocator>::template rebind_alloc<shared_state>;
+        using other_allocator =
+            typename std::allocator_traits<base_allocator>::template rebind_alloc<shared_state>;
         using traits = std::allocator_traits<other_allocator>;
 
         using init_no_addref = typename shared_state::init_no_addref;
 
-        using unique_ptr = std::unique_ptr<shared_state,
-            pika::detail::allocator_deleter<other_allocator>>;
+        using unique_ptr =
+            std::unique_ptr<shared_state, pika::detail::allocator_deleter<other_allocator>>;
 
         using lcos::detail::in_place;
         other_allocator alloc(a);
-        unique_ptr p(traits::allocate(alloc, 1),
-            pika::detail::allocator_deleter<other_allocator>{alloc});
-        traits::construct(alloc, p.get(), init_no_addref{}, in_place{}, alloc,
-            PIKA_FORWARD(Ts, ts)...);
+        unique_ptr p(
+            traits::allocate(alloc, 1), pika::detail::allocator_deleter<other_allocator>{alloc});
+        traits::construct(
+            alloc, p.get(), init_no_addref{}, in_place{}, alloc, PIKA_FORWARD(Ts, ts)...);
 
-        return pika::traits::future_access<future<result_type>>::create(
-            p.release(), false);
+        return pika::traits::future_access<future<result_type>>::create(p.release(), false);
     }
 
     // Extension (see wg21.link/P0319)
     template <typename T, typename... Ts>
-    PIKA_FORCEINLINE std::enable_if_t<
-        std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>, future<T>>
-    make_ready_future(Ts&&... ts)
+    PIKA_FORCEINLINE
+        std::enable_if_t<std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>, future<T>>
+        make_ready_future(Ts&&... ts)
     {
         return make_ready_future_alloc<T>(
             pika::detail::internal_allocator<>{}, PIKA_FORWARD(Ts, ts)...);
@@ -1312,8 +1235,7 @@ namespace pika {
     ///////////////////////////////////////////////////////////////////////////
     // extension: create a pre-initialized future object, with allocator
     template <int DeductionGuard = 0, typename Allocator, typename T>
-    future<pika::detail::decay_unwrap_t<T>>
-    make_ready_future_alloc(Allocator const& a, T&& init)
+    future<pika::detail::decay_unwrap_t<T>> make_ready_future_alloc(Allocator const& a, T&& init)
     {
         return pika::make_ready_future_alloc<pika::detail::decay_unwrap_t<T>>(
             a, PIKA_FORWARD(T, init));
@@ -1321,8 +1243,7 @@ namespace pika {
 
     // extension: create a pre-initialized future object
     template <int DeductionGuard = 0, typename T>
-    PIKA_FORCEINLINE future<pika::detail::decay_unwrap_t<T>>
-    make_ready_future(T&& init)
+    PIKA_FORCEINLINE future<pika::detail::decay_unwrap_t<T>> make_ready_future(T&& init)
     {
         return pika::make_ready_future_alloc<pika::detail::decay_unwrap_t<T>>(
             pika::detail::internal_allocator<>{}, PIKA_FORWARD(T, init));
@@ -1337,8 +1258,7 @@ namespace pika {
         using shared_state = lcos::detail::future_data<T>;
         using init_no_addref = typename shared_state::init_no_addref;
 
-        pika::intrusive_ptr<shared_state> p(
-            new shared_state(init_no_addref{}, e), false);
+        pika::intrusive_ptr<shared_state> p(new shared_state(init_no_addref{}, e), false);
 
         return pika::traits::future_access<future<T>>::create(PIKA_MOVE(p));
     }
@@ -1362,8 +1282,8 @@ 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::detail::decay_unwrap_t<T>> make_ready_future_at(
-        pika::chrono::steady_time_point const& abs_time, T&& init)
+    future<pika::detail::decay_unwrap_t<T>>
+    make_ready_future_at(pika::chrono::steady_time_point const& abs_time, T&& init)
     {
         using result_type = pika::detail::decay_unwrap_t<T>;
         using shared_state = lcos::detail::timed_future_data<result_type>;
@@ -1371,16 +1291,14 @@ namespace pika {
         pika::intrusive_ptr<shared_state> p(
             new shared_state(abs_time.value(), PIKA_FORWARD(T, init)));
 
-        return pika::traits::future_access<future<result_type>>::create(
-            PIKA_MOVE(p));
+        return pika::traits::future_access<future<result_type>>::create(PIKA_MOVE(p));
     }
 
     template <int DeductionGuard = 0, typename T>
-    future<pika::detail::decay_unwrap_t<T>> make_ready_future_after(
-        pika::chrono::steady_duration const& rel_time, T&& init)
+    future<pika::detail::decay_unwrap_t<T>>
+    make_ready_future_after(pika::chrono::steady_duration const& rel_time, T&& init)
     {
-        return pika::make_ready_future_at(
-            rel_time.from_now(), PIKA_FORWARD(T, init));
+        return pika::make_ready_future_at(rel_time.from_now(), PIKA_FORWARD(T, init));
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -1400,16 +1318,14 @@ namespace pika {
 
     // Extension (see wg21.link/P0319)
     template <typename T>
-    PIKA_FORCEINLINE std::enable_if_t<std::is_void_v<T>, future<void>>
-    make_ready_future()
+    PIKA_FORCEINLINE std::enable_if_t<std::is_void_v<T>, future<void>> make_ready_future()
     {
         return pika::make_ready_future();
     }
 
     // extension: create a pre-initialized future object which gets ready at
     // a given point in time
-    inline future<void> make_ready_future_at(
-        pika::chrono::steady_time_point const& abs_time)
+    inline future<void> make_ready_future_at(pika::chrono::steady_time_point const& abs_time)
     {
         using shared_state = lcos::detail::timed_future_data<void>;
 
@@ -1425,8 +1341,7 @@ namespace pika {
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    inline future<void> make_ready_future_after(
-        pika::chrono::steady_duration const& rel_time)
+    inline future<void> make_ready_future_after(pika::chrono::steady_duration const& rel_time)
     {
         return pika::make_ready_future_at(rel_time.from_now());
     }
@@ -1441,5 +1356,5 @@ namespace pika {
 
 #include <pika/futures/packaged_continuation.hpp>
 
-#define PIKA_MAKE_EXCEPTIONAL_FUTURE(T, errorcode, f, msg)                     \
-    pika::make_exceptional_future<T>(PIKA_GET_EXCEPTION(errorcode, f, msg)) /**/
+#define PIKA_MAKE_EXCEPTIONAL_FUTURE(T, errorcode, f, msg)                                         \
+ pika::make_exceptional_future<T>(PIKA_GET_EXCEPTION(errorcode, f, msg)) /**/

From 864f82a32c1f7444b6d8f5431312c76efa87207a Mon Sep 17 00:00:00 2001
From: Mikael Simberg <simberg@cscs.ch>
Date: Mon, 20 Feb 2023 13:48:34 +0100
Subject: [PATCH 8/9] Fix a few environment handling problems with
 thread_pool_scheduler, then, and schedule_from

---
 .../include/pika/execution/algorithms/schedule_from.hpp      | 5 +++--
 .../execution/include/pika/execution/algorithms/then.hpp     | 2 +-
 .../include/pika/executors/thread_pool_scheduler.hpp         | 5 +++--
 3 files changed, 7 insertions(+), 5 deletions(-)

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 79dc58ae3e..097c4002e2 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/schedule_from.hpp
@@ -75,8 +75,9 @@ namespace pika::schedule_from_detail {
             PIKA_NO_UNIQUE_ADDRESS Env e;
             PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
 
-            friend auto tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
-                                       pika::execution::experimental::set_value_t>,
+            friend std::decay_t<Scheduler> tag_invoke(
+                pika::execution::experimental::get_completion_scheduler_t<
+                    pika::execution::experimental::set_value_t>,
                 env const& e) noexcept
             {
                 return e.scheduler;
diff --git a/libs/pika/execution/include/pika/execution/algorithms/then.hpp b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
index 453ccff433..7edcefc5e2 100644
--- a/libs/pika/execution/include/pika/execution/algorithms/then.hpp
+++ b/libs/pika/execution/include/pika/execution/algorithms/then.hpp
@@ -156,7 +156,7 @@ namespace pika::then_detail {
                 r.sender, then_receiver<Receiver, F>{PIKA_FORWARD(Receiver, receiver), r.f});
         }
 
-        friend constexpr decltype(auto) tag_invoke(
+        friend decltype(auto) tag_invoke(
             pika::execution::experimental::get_env_t, then_sender_type const& s)
         {
             return pika::execution::experimental::get_env(s.sender);
diff --git a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
index c3766fd6bc..e2e1578aaa 100644
--- a/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
+++ b/libs/pika/executors/include/pika/executors/thread_pool_scheduler.hpp
@@ -222,8 +222,9 @@ namespace pika::execution::experimental {
             {
                 PIKA_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
 
-                friend auto tag_invoke(pika::execution::experimental::get_completion_scheduler_t<
-                                           pika::execution::experimental::set_value_t>,
+                friend std::decay_t<Scheduler> tag_invoke(
+                    pika::execution::experimental::get_completion_scheduler_t<
+                        pika::execution::experimental::set_value_t>,
                     env const& e) noexcept
                 {
                     return e.scheduler;

From 967bcf0d31c101af773b3163bd3af3ce1a4427eb Mon Sep 17 00:00:00 2001
From: Mikael Simberg <mikael.simberg@iki.fi>
Date: Mon, 20 Feb 2023 15:35:59 +0100
Subject: [PATCH 9/9] Decay sender type before checking concept in
 transform_mpi

---
 libs/pika/async_mpi/include/pika/async_mpi/transform_mpi.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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 21ffedbc62..4594c70817 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
@@ -359,7 +359,8 @@ namespace pika::mpi::experimental {
     {
     private:
         template <typename Sender, typename F,
-            PIKA_CONCEPT_REQUIRES_(pika::execution::experimental::is_sender_v<Sender>)>
+            PIKA_CONCEPT_REQUIRES_(
+                pika::execution::experimental::is_sender_v<std::decay_t<Sender>>)>
         friend constexpr PIKA_FORCEINLINE auto tag_fallback_invoke(transform_mpi_t, Sender&& sender,
             F&& f, mpi::experimental::stream_type s = mpi::experimental::stream_type::automatic)
         {