From b16a8e44797eaa7154a1a678fde03ba535bb0465 Mon Sep 17 00:00:00 2001
From: aurianer <aurianer@cscs.ch>
Date: Mon, 9 Dec 2019 14:11:40 +0100
Subject: [PATCH] Clang-format the execution module

---
 .../executors/thread_timed_execution.hpp      |   4 +-
 .../execution/datapar/execution_policy.hpp    |   2 +-
 .../execution/detail/future_await_traits.hpp  |  84 +-
 .../hpx/execution/detail/future_data.hpp      |  14 +-
 .../hpx/execution/detail/future_traits.hpp    |  17 +-
 .../execution/detail/future_transforms.hpp    | 152 ++--
 .../include/hpx/execution/exception_list.hpp  |   2 +-
 .../hpx/execution/execution_policy.hpp        |   2 +-
 .../distribution_policy_executor.hpp          |   2 +-
 .../hpx/execution/executors/execution.hpp     |  17 +-
 .../executors/execution_parameters.hpp        |   4 +-
 .../execution/executors/parallel_executor.hpp |   6 +-
 .../parallel_executor_aggregated.hpp          |   6 +-
 .../executors/post_policy_dispatch.hpp        |   2 +-
 .../executors/sequenced_executor.hpp          |   2 +-
 .../execution/executors/service_executors.hpp |   2 +-
 .../execution/executors/thread_execution.hpp  |   8 +-
 .../thread_execution_information.hpp          |   2 +-
 .../executors/thread_pool_executor.hpp        |   6 +-
 .../execution/executors/timed_execution.hpp   |   2 +-
 .../execution/executors/timed_executors.hpp   |   4 +-
 .../include/hpx/execution/future.hpp          | 849 +++++++++---------
 .../include/hpx/execution/futures_factory.hpp |  30 +-
 .../include/hpx/execution/launch_policy.hpp   | 166 ++--
 .../include/hpx/execution/split_future.hpp    | 220 +++--
 .../hpx/execution/traits/acquire_future.hpp   |  70 +-
 .../execution/traits/acquire_shared_state.hpp |  75 +-
 .../hpx/execution/traits/future_access.hpp    | 129 ++-
 .../execution/traits/future_then_result.hpp   | 107 +--
 .../hpx/execution/traits/future_traits.hpp    |  71 +-
 .../hpx/execution/traits/is_future.hpp        |  79 +-
 .../hpx/execution/traits/is_future_range.hpp  |  50 +-
 .../hpx/execution/traits/is_launch_policy.hpp |  40 +-
 .../hpx/lcos/detail/future_await_traits.hpp   |   5 +-
 .../hpx/lcos/detail/future_data.hpp           |   6 +-
 .../hpx/lcos/detail/future_traits.hpp         |   6 +-
 .../hpx/lcos/detail/future_transforms.hpp     |   5 +-
 .../include_compatibility/hpx/lcos/future.hpp |   6 +-
 .../hpx/lcos/local/futures_factory.hpp        |   5 +-
 .../hpx/lcos/split_future.hpp                 |   6 +-
 .../hpx/runtime/launch_policy.hpp             |   6 +-
 .../hpx/traits/acquire_future.hpp             |   6 +-
 .../hpx/traits/acquire_shared_state.hpp       |   5 +-
 .../hpx/traits/future_access.hpp              |   6 +-
 .../hpx/traits/future_then_result.hpp         |   6 +-
 .../hpx/traits/future_traits.hpp              |   6 +-
 .../hpx/traits/is_future.hpp                  |   6 +-
 .../hpx/traits/is_future_range.hpp            |   6 +-
 .../hpx/traits/is_launch_policy.hpp           |   6 +-
 libs/execution/src/detail/future_data.cpp     |  95 +-
 libs/execution/src/future.cpp                 |   1 -
 libs/execution/src/launch_policy.cpp          |  19 +-
 52 files changed, 1155 insertions(+), 1278 deletions(-)

diff --git a/hpx/parallel/executors/thread_timed_execution.hpp b/hpx/parallel/executors/thread_timed_execution.hpp
index 4af875d13650..f309431acd24 100644
--- a/hpx/parallel/executors/thread_timed_execution.hpp
+++ b/hpx/parallel/executors/thread_timed_execution.hpp
@@ -8,11 +8,11 @@
 #define HPX_PARALLEL_EXECUTORS_THREAD_TIMED_EXECUTION_JAN_09_2017_1117AM
 
 #include <hpx/config.hpp>
-#include <hpx/functional/deferred_call.hpp>
 #include <hpx/execution/future.hpp>
+#include <hpx/execution/traits/is_launch_policy.hpp>
+#include <hpx/functional/deferred_call.hpp>
 #include <hpx/local_lcos/packaged_task.hpp>
 #include <hpx/timing/steady_clock.hpp>
-#include <hpx/execution/traits/is_launch_policy.hpp>
 
 #include <hpx/execution/executors/timed_execution.hpp>
 
diff --git a/libs/execution/include/hpx/execution/datapar/execution_policy.hpp b/libs/execution/include/hpx/execution/datapar/execution_policy.hpp
index 1482fad0208e..32cad487d2fa 100644
--- a/libs/execution/include/hpx/execution/datapar/execution_policy.hpp
+++ b/libs/execution/include/hpx/execution/datapar/execution_policy.hpp
@@ -18,8 +18,8 @@
 #include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/traits/is_execution_policy.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
-#include <hpx/serialization/serialize.hpp>
 #include <hpx/execution/traits/is_launch_policy.hpp>
+#include <hpx/serialization/serialize.hpp>
 
 #include <type_traits>
 #include <utility>
diff --git a/libs/execution/include/hpx/execution/detail/future_await_traits.hpp b/libs/execution/include/hpx/execution/detail/future_await_traits.hpp
index 18718fb05bfd..56305633e836 100644
--- a/libs/execution/include/hpx/execution/detail/future_await_traits.hpp
+++ b/libs/execution/include/hpx/execution/detail/future_await_traits.hpp
@@ -11,8 +11,8 @@
 
 #include <hpx/config.hpp>
 #include <hpx/execution/detail/future_data.hpp>
-#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/execution/traits/future_access.hpp>
+#include <hpx/memory/intrusive_ptr.hpp>
 
 #if defined(HPX_HAVE_EMULATE_COROUTINE_SUPPORT_LIBRARY)
 #include <hpx/util/await_traits.hpp>
@@ -25,17 +25,22 @@
 #include <utility>
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace hpx { namespace lcos { namespace detail
-{
+namespace hpx { namespace lcos { namespace detail {
     ///////////////////////////////////////////////////////////////////////////
     // this was removed from the TS, so we define our own
     struct suspend_if
     {
         bool is_ready_;
 
-        explicit suspend_if(bool cond) noexcept : is_ready_(!cond) {}
+        explicit suspend_if(bool cond) noexcept
+          : is_ready_(!cond)
+        {
+        }
 
-        bool await_ready() noexcept { return is_ready_; }
+        bool await_ready() noexcept
+        {
+            return is_ready_;
+        }
         void await_suspend(std::experimental::coroutine_handle<>) noexcept {}
         void await_resume() noexcept {}
     };
@@ -50,18 +55,16 @@ namespace hpx { namespace lcos { namespace detail
     }
 
     template <typename T, typename Promise>
-    HPX_FORCEINLINE void await_suspend(future<T>& f,
-        std::experimental::coroutine_handle<Promise> rh)
+    HPX_FORCEINLINE void await_suspend(
+        future<T>& f, std::experimental::coroutine_handle<Promise> rh)
     {
         // f.then([=](future<T> result) {});
         auto st = traits::detail::get_shared_state(f);
-        st->set_on_completed(
-            [=]() mutable
-            {
-                if (st->has_exception())
-                    rh.promise().set_exception(st->get_exception_ptr());
-                rh();
-            });
+        st->set_on_completed([=]() mutable {
+            if (st->has_exception())
+                rh.promise().set_exception(st->get_exception_ptr());
+            rh();
+        });
     }
 
     template <typename T>
@@ -72,13 +75,13 @@ namespace hpx { namespace lcos { namespace detail
 
     // Allow wrapped futures to be unwrapped, if possible.
     template <typename T>
-    HPX_FORCEINLINE T await_resume(future<future<T> >& f)
+    HPX_FORCEINLINE T await_resume(future<future<T>>& f)
     {
         return f.get().get();
     }
 
     template <typename T>
-    HPX_FORCEINLINE T await_resume(future<shared_future<T> >& f)
+    HPX_FORCEINLINE T await_resume(future<shared_future<T>>& f)
     {
         return f.get().get();
     }
@@ -92,18 +95,16 @@ namespace hpx { namespace lcos { namespace detail
     }
 
     template <typename T, typename Promise>
-    HPX_FORCEINLINE void await_suspend(shared_future<T>& f,
-        std::experimental::coroutine_handle<Promise> rh)
+    HPX_FORCEINLINE void await_suspend(
+        shared_future<T>& f, std::experimental::coroutine_handle<Promise> rh)
     {
         // f.then([=](shared_future<T> result) {})
         auto st = traits::detail::get_shared_state(f);
-        st->set_on_completed(
-            [=]() mutable
-            {
-                if (st->has_exception())
-                    rh.promise().set_exception(st->get_exception_ptr());
-                rh();
-            });
+        st->set_on_completed([=]() mutable {
+            if (st->has_exception())
+                rh.promise().set_exception(st->get_exception_ptr());
+            rh();
+        });
     }
 
     template <typename T>
@@ -129,8 +130,8 @@ namespace hpx { namespace lcos { namespace detail
         hpx::lcos::future<T> get_return_object()
         {
             hpx::intrusive_ptr<base_type> shared_state(this);
-            return hpx::traits::future_access<hpx::lcos::future<T> >::
-                create(std::move(shared_state));
+            return hpx::traits::future_access<hpx::lcos::future<T>>::create(
+                std::move(shared_state));
         }
 
         std::experimental::suspend_never initial_suspend()
@@ -148,27 +149,29 @@ namespace hpx { namespace lcos { namespace detail
 
         void set_exception(std::exception_ptr e)
         {
-            try {
+            try
+            {
                 std::rethrow_exception(std::move(e));
             }
-            catch (...) {
+            catch (...)
+            {
                 this->base_type::set_exception(std::current_exception());
             }
         }
 
         void destroy()
         {
-            std::experimental::coroutine_handle<Derived>::
-                from_promise(*static_cast<Derived*>(this)).destroy();
+            std::experimental::coroutine_handle<Derived>::from_promise(
+                *static_cast<Derived*>(this))
+                .destroy();
         }
     };
-}}}
+}}}    // namespace hpx::lcos::detail
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace std { namespace experimental
-{
+namespace std { namespace experimental {
     // Allow for functions which use co_await to return an hpx::future<T>
-    template <typename T, typename ...Ts>
+    template <typename T, typename... Ts>
     struct coroutine_traits<hpx::lcos::future<T>, Ts...>
     {
         struct promise_type
@@ -178,14 +181,14 @@ namespace std { namespace experimental
                 hpx::lcos::detail::coroutine_promise_base<T, promise_type>;
 
             template <typename U>
-            void return_value(U && value)
+            void return_value(U&& value)
             {
                 this->base_type::set_value(std::forward<U>(value));
             }
         };
     };
 
-    template <typename ...Ts>
+    template <typename... Ts>
     struct coroutine_traits<hpx::lcos::future<void>, Ts...>
     {
         struct promise_type
@@ -200,8 +203,7 @@ namespace std { namespace experimental
             }
         };
     };
-}}
-
-#endif // HPX_HAVE_AWAIT
-#endif // HPX_LCOS_ACBA3E3F_7B29_41D1_AE85_C73CB69D089C
+}}    // namespace std::experimental
 
+#endif    // HPX_HAVE_AWAIT
+#endif    // HPX_LCOS_ACBA3E3F_7B29_41D1_AE85_C73CB69D089C
diff --git a/libs/execution/include/hpx/execution/detail/future_data.hpp b/libs/execution/include/hpx/execution/detail/future_data.hpp
index f2a199cb88f1..84fd84ba869d 100644
--- a/libs/execution/include/hpx/execution/detail/future_data.hpp
+++ b/libs/execution/include/hpx/execution/detail/future_data.hpp
@@ -11,18 +11,18 @@
 #include <hpx/assertion.hpp>
 #include <hpx/coroutines/detail/get_stack_pointer.hpp>
 #include <hpx/errors.hpp>
+#include <hpx/execution/launch_policy.hpp>
+#include <hpx/execution/traits/future_access.hpp>
 #include <hpx/functional/bind.hpp>
 #include <hpx/functional/unique_function.hpp>
-#include <hpx/synchronization/condition_variable.hpp>
-#include <hpx/synchronization/spinlock.hpp>
 #include <hpx/memory/intrusive_ptr.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/thread_executor.hpp>
 #include <hpx/runtime/threads/thread_helpers.hpp>
+#include <hpx/synchronization/condition_variable.hpp>
+#include <hpx/synchronization/spinlock.hpp>
 #include <hpx/thread_support/assert_owns_lock.hpp>
 #include <hpx/thread_support/atomic_count.hpp>
 #include <hpx/timing/steady_clock.hpp>
-#include <hpx/execution/traits/future_access.hpp>
 #include <hpx/traits/get_remote_result.hpp>
 #include <hpx/type_support/decay.hpp>
 #include <hpx/type_support/unused.hpp>
@@ -864,10 +864,8 @@ namespace hpx { namespace lcos { namespace detail {
 
         // run in a separate thread
         virtual threads::thread_id_type apply(
-            threads::thread_pool_base* /*pool*/,
-            const char* /*annotation*/,
-            launch /*policy*/,
-            threads::thread_priority /*priority*/,
+            threads::thread_pool_base* /*pool*/, const char* /*annotation*/,
+            launch /*policy*/, threads::thread_priority /*priority*/,
             threads::thread_stacksize /*stacksize*/,
             threads::thread_schedule_hint /*schedulehint*/, error_code& /*ec*/)
         {
diff --git a/libs/execution/include/hpx/execution/detail/future_traits.hpp b/libs/execution/include/hpx/execution/detail/future_traits.hpp
index 7d0552db7439..499e76ff9229 100644
--- a/libs/execution/include/hpx/execution/detail/future_traits.hpp
+++ b/libs/execution/include/hpx/execution/detail/future_traits.hpp
@@ -9,30 +9,27 @@
 #define HPX_LCOS_DETAIL_FUTURE_TRAITS_DEC_05_2017_0214PM
 
 #include <hpx/config.hpp>
-#include <hpx/type_support/always_void.hpp>
 #include <hpx/execution/traits/future_traits.hpp>
+#include <hpx/type_support/always_void.hpp>
 
 #include <iterator>
 
-namespace hpx { namespace lcos { namespace detail
-{
+namespace hpx { namespace lcos { namespace detail {
     ///////////////////////////////////////////////////////////////////////////
     template <typename Iter, typename Enable = void>
     struct future_iterator_traits
-    {};
+    {
+    };
 
     template <typename Iterator>
     struct future_iterator_traits<Iterator,
         typename hpx::util::always_void<
-            typename std::iterator_traits<Iterator>::value_type
-        >::type>
+            typename std::iterator_traits<Iterator>::value_type>::type>
     {
-        typedef
-            typename std::iterator_traits<Iterator>::value_type
-            type;
+        typedef typename std::iterator_traits<Iterator>::value_type type;
 
         typedef hpx::traits::future_traits<type> traits_type;
     };
-}}}
+}}}    // namespace hpx::lcos::detail
 
 #endif
diff --git a/libs/execution/include/hpx/execution/detail/future_transforms.hpp b/libs/execution/include/hpx/execution/detail/future_transforms.hpp
index 79c79c45bacb..cd401edfd3a3 100644
--- a/libs/execution/include/hpx/execution/detail/future_transforms.hpp
+++ b/libs/execution/include/hpx/execution/detail/future_transforms.hpp
@@ -10,9 +10,9 @@
 #include <hpx/execution/detail/future_traits.hpp>
 #include <hpx/execution/traits/acquire_future.hpp>
 #include <hpx/execution/traits/acquire_shared_state.hpp>
-#include <hpx/util/detail/reserve.hpp>
 #include <hpx/execution/traits/is_future.hpp>
 #include <hpx/functional/deferred_call.hpp>
+#include <hpx/util/detail/reserve.hpp>
 
 #include <algorithm>
 #include <cstddef>
@@ -21,89 +21,85 @@
 #include <utility>
 #include <vector>
 
-namespace hpx {
-namespace lcos {
-    namespace detail {
-        /// Returns true when the given future is ready,
-        /// the future is deferred executed if possible first.
-        template <typename T,
-            typename std::enable_if<traits::is_future<
-                typename std::decay<T>::type>::value>::type* = nullptr>
-        bool async_visit_future(T&& current)
+namespace hpx { namespace lcos { namespace detail {
+    /// Returns true when the given future is ready,
+    /// the future is deferred executed if possible first.
+    template <typename T,
+        typename std::enable_if<traits::is_future<
+            typename std::decay<T>::type>::value>::type* = nullptr>
+    bool async_visit_future(T&& current)
+    {
+        // Check for state right away as the element might not be able to
+        // produce a shared state (even if it's ready).
+        if (current.is_ready())
         {
-            // Check for state right away as the element might not be able to
-            // produce a shared state (even if it's ready).
-            if (current.is_ready())
-            {
-                return true;
-            }
-
-            auto const& state =
-                traits::detail::get_shared_state(std::forward<T>(current));
-
-            if (state.get() == nullptr)
-            {
-                return true;
-            }
-
-            // Execute_deferred might have made the future ready
-            state->execute_deferred();
-
-            // Detach the context if the future isn't ready
-            return state->is_ready();
+            return true;
         }
 
-        /// Attach the continuation next to the given future
-        template <typename T, typename N,
-            typename std::enable_if<traits::is_future<
-                typename std::decay<T>::type>::value>::type* = nullptr>
-        void async_detach_future(T&& current, N&& next)
-        {
-            auto const& state =
-                traits::detail::get_shared_state(std::forward<T>(current));
-
-            // Attach a continuation to this future which will
-            // re-evaluate it and continue to the next argument (if any).
-            state->set_on_completed(util::deferred_call(std::forward<N>(next)));
-        }
+        auto const& state =
+            traits::detail::get_shared_state(std::forward<T>(current));
 
-        /// Acquire a future range from the given begin and end iterator
-        template <typename Iterator,
-            typename Container =
-                std::vector<typename future_iterator_traits<Iterator>::type>>
-        Container acquire_future_iterators(Iterator begin, Iterator end)
+        if (state.get() == nullptr)
         {
-            Container lazy_values;
-
-            auto difference = std::distance(begin, end);
-            if (difference > 0)
-                traits::detail::reserve_if_reservable(
-                    lazy_values, static_cast<std::size_t>(difference));
-
-            std::transform(begin, end, std::back_inserter(lazy_values),
-                traits::acquire_future_disp());
-
-            return lazy_values;    // Should be optimized by RVO
+            return true;
         }
 
-        /// Acquire a future range from the given
-        /// begin iterator and count
-        template <typename Iterator,
-            typename Container =
-                std::vector<typename future_iterator_traits<Iterator>::type>>
-        Container acquire_future_n(Iterator begin, std::size_t count)
-        {
-            Container values;
-            traits::detail::reserve_if_reservable(values, count);
-
-            traits::acquire_future_disp func;
-            for (std::size_t i = 0; i != count; ++i)
-                values.push_back(func(*begin++));
-
-            return values;    // Should be optimized by RVO
-        }
-    }    // end namespace detail
-}    // end namespace lcos
-}    // end namespace hpx
+        // Execute_deferred might have made the future ready
+        state->execute_deferred();
+
+        // Detach the context if the future isn't ready
+        return state->is_ready();
+    }
+
+    /// Attach the continuation next to the given future
+    template <typename T, typename N,
+        typename std::enable_if<traits::is_future<
+            typename std::decay<T>::type>::value>::type* = nullptr>
+    void async_detach_future(T&& current, N&& next)
+    {
+        auto const& state =
+            traits::detail::get_shared_state(std::forward<T>(current));
+
+        // Attach a continuation to this future which will
+        // re-evaluate it and continue to the next argument (if any).
+        state->set_on_completed(util::deferred_call(std::forward<N>(next)));
+    }
+
+    /// Acquire a future range from the given begin and end iterator
+    template <typename Iterator,
+        typename Container =
+            std::vector<typename future_iterator_traits<Iterator>::type>>
+    Container acquire_future_iterators(Iterator begin, Iterator end)
+    {
+        Container lazy_values;
+
+        auto difference = std::distance(begin, end);
+        if (difference > 0)
+            traits::detail::reserve_if_reservable(
+                lazy_values, static_cast<std::size_t>(difference));
+
+        std::transform(begin, end, std::back_inserter(lazy_values),
+            traits::acquire_future_disp());
+
+        return lazy_values;    // Should be optimized by RVO
+    }
+
+    /// Acquire a future range from the given
+    /// begin iterator and count
+    template <typename Iterator,
+        typename Container =
+            std::vector<typename future_iterator_traits<Iterator>::type>>
+    Container acquire_future_n(Iterator begin, std::size_t count)
+    {
+        Container values;
+        traits::detail::reserve_if_reservable(values, count);
+
+        traits::acquire_future_disp func;
+        for (std::size_t i = 0; i != count; ++i)
+            values.push_back(func(*begin++));
+
+        return values;    // Should be optimized by RVO
+    }
+}}}    // namespace hpx::lcos::detail
 
 #endif    // HPX_LCOS_DETAIL_FUTURE_TRANSFORMS_HPP
diff --git a/libs/execution/include/hpx/execution/exception_list.hpp b/libs/execution/include/hpx/execution/exception_list.hpp
index e32536e0d90e..5d795ff7dcf8 100644
--- a/libs/execution/include/hpx/execution/exception_list.hpp
+++ b/libs/execution/include/hpx/execution/exception_list.hpp
@@ -11,8 +11,8 @@
 #include <hpx/config.hpp>
 #include <hpx/assertion.hpp>
 #include <hpx/errors.hpp>
-#include <hpx/hpx_finalize.hpp>
 #include <hpx/execution/future.hpp>
+#include <hpx/hpx_finalize.hpp>
 #include <hpx/type_support/decay.hpp>
 
 #include <hpx/execution/execution_policy_fwd.hpp>
diff --git a/libs/execution/include/hpx/execution/execution_policy.hpp b/libs/execution/include/hpx/execution/execution_policy.hpp
index e7d685602548..091fa5ee9381 100644
--- a/libs/execution/include/hpx/execution/execution_policy.hpp
+++ b/libs/execution/include/hpx/execution/execution_policy.hpp
@@ -22,8 +22,8 @@
 #include <hpx/execution/traits/is_execution_policy.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/execution/traits/is_executor_parameters.hpp>
-#include <hpx/serialization/serialize.hpp>
 #include <hpx/execution/traits/is_launch_policy.hpp>
+#include <hpx/serialization/serialize.hpp>
 #include <hpx/type_support/decay.hpp>
 
 #include <memory>
diff --git a/libs/execution/include/hpx/execution/executors/distribution_policy_executor.hpp b/libs/execution/include/hpx/execution/executors/distribution_policy_executor.hpp
index d03ce4705447..c9e463e51025 100644
--- a/libs/execution/include/hpx/execution/executors/distribution_policy_executor.hpp
+++ b/libs/execution/include/hpx/execution/executors/distribution_policy_executor.hpp
@@ -12,9 +12,9 @@
 
 #include <hpx/config.hpp>
 #include <hpx/datastructures/detail/pack.hpp>
+#include <hpx/execution/future.hpp>
 #include <hpx/functional/result_of.hpp>
 #include <hpx/functional/traits/is_action.hpp>
-#include <hpx/execution/future.hpp>
 #include <hpx/runtime/components/server/invoke_function.hpp>
 #include <hpx/traits/is_distribution_policy.hpp>
 #include <hpx/type_support/decay.hpp>
diff --git a/libs/execution/include/hpx/execution/executors/execution.hpp b/libs/execution/include/hpx/execution/executors/execution.hpp
index 1d6b3f2c6c3a..0342137d5f71 100644
--- a/libs/execution/include/hpx/execution/executors/execution.hpp
+++ b/libs/execution/include/hpx/execution/executors/execution.hpp
@@ -18,18 +18,18 @@
 #include <hpx/datastructures/detail/pack.hpp>
 #include <hpx/datastructures/tuple.hpp>
 #include <hpx/errors.hpp>
-#include <hpx/functional/bind_back.hpp>
-#include <hpx/functional/invoke.hpp>
-#include <hpx/iterator_support/range.hpp>
 #include <hpx/execution/executors/fused_bulk_execute.hpp>
-#include <hpx/execution/traits/executor_traits.hpp>
-#include <hpx/execution/traits/is_executor.hpp>
-#include <hpx/functional/deferred_call.hpp>
 #include <hpx/execution/future.hpp>
-#include <hpx/lcos/wait_all.hpp>
+#include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/traits/future_access.hpp>
 #include <hpx/execution/traits/future_then_result.hpp>
 #include <hpx/execution/traits/future_traits.hpp>
+#include <hpx/execution/traits/is_executor.hpp>
+#include <hpx/functional/bind_back.hpp>
+#include <hpx/functional/deferred_call.hpp>
+#include <hpx/functional/invoke.hpp>
+#include <hpx/iterator_support/range.hpp>
+#include <hpx/lcos/wait_all.hpp>
 #include <hpx/type_support/detail/wrap_int.hpp>
 #include <hpx/util/unwrap.hpp>
 
@@ -1142,7 +1142,8 @@ namespace hpx { namespace parallel { namespace execution {
                         -> result_future_type {
                             // use unwrap directly (instead of lazily) to avoid
                             // having to pull in dataflow
-                            return hpx::util::unwrap(func(std::move(predecessor)));
+                            return hpx::util::unwrap(
+                                func(std::move(predecessor)));
                         });
 
                 return hpx::traits::future_access<result_future_type>::create(
diff --git a/libs/execution/include/hpx/execution/executors/execution_parameters.hpp b/libs/execution/include/hpx/execution/executors/execution_parameters.hpp
index 0277c9145890..c27c477844f1 100644
--- a/libs/execution/include/hpx/execution/executors/execution_parameters.hpp
+++ b/libs/execution/include/hpx/execution/executors/execution_parameters.hpp
@@ -14,13 +14,13 @@
 #include <hpx/config.hpp>
 #include <hpx/concepts/has_member_xxx.hpp>
 #include <hpx/datastructures/detail/pack.hpp>
+#include <hpx/execution/future.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/execution/traits/is_executor_parameters.hpp>
-#include <hpx/execution/future.hpp>
+#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/preprocessor/cat.hpp>
 #include <hpx/preprocessor/stringize.hpp>
 #include <hpx/serialization/base_object.hpp>
-#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/type_support/decay.hpp>
 #include <hpx/type_support/detail/wrap_int.hpp>
 
diff --git a/libs/execution/include/hpx/execution/executors/parallel_executor.hpp b/libs/execution/include/hpx/execution/executors/parallel_executor.hpp
index d4ab5ffb8a94..c6fff25014b3 100644
--- a/libs/execution/include/hpx/execution/executors/parallel_executor.hpp
+++ b/libs/execution/include/hpx/execution/executors/parallel_executor.hpp
@@ -18,14 +18,15 @@
 #include <hpx/execution/executors/fused_bulk_execute.hpp>
 #include <hpx/execution/executors/post_policy_dispatch.hpp>
 #include <hpx/execution/executors/static_chunk_size.hpp>
+#include <hpx/execution/future.hpp>
+#include <hpx/execution/launch_policy.hpp>
+#include <hpx/execution/traits/future_traits.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/functional/bind_back.hpp>
 #include <hpx/functional/deferred_call.hpp>
 #include <hpx/functional/invoke.hpp>
 #include <hpx/functional/one_shot.hpp>
 #include <hpx/iterator_support/range.hpp>
-#include <hpx/execution/future.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/policies/scheduler_base.hpp>
 #include <hpx/runtime/threads/thread_data.hpp>
 #include <hpx/runtime/threads/thread_data_fwd.hpp>
@@ -33,7 +34,6 @@
 #include <hpx/runtime/threads/thread_pool_base.hpp>
 #include <hpx/serialization/serialize.hpp>
 #include <hpx/synchronization/latch.hpp>
-#include <hpx/execution/traits/future_traits.hpp>
 #include <hpx/util/unwrap.hpp>
 
 #include <algorithm>
diff --git a/libs/execution/include/hpx/execution/executors/parallel_executor_aggregated.hpp b/libs/execution/include/hpx/execution/executors/parallel_executor_aggregated.hpp
index 2934b7cac959..ccece382ae34 100644
--- a/libs/execution/include/hpx/execution/executors/parallel_executor_aggregated.hpp
+++ b/libs/execution/include/hpx/execution/executors/parallel_executor_aggregated.hpp
@@ -16,16 +16,16 @@
 #include <hpx/execution/algorithms/detail/predicates.hpp>
 #include <hpx/execution/executors/post_policy_dispatch.hpp>
 #include <hpx/execution/executors/static_chunk_size.hpp>
+#include <hpx/execution/future.hpp>
+#include <hpx/execution/launch_policy.hpp>
+#include <hpx/execution/traits/future_traits.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/functional/invoke.hpp>
 #include <hpx/iterator_support/range.hpp>
-#include <hpx/execution/future.hpp>
 #include <hpx/runtime/get_worker_thread_num.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/thread_helpers.hpp>
 #include <hpx/serialization/serialize.hpp>
 #include <hpx/synchronization/latch.hpp>
-#include <hpx/execution/traits/future_traits.hpp>
 
 #include <algorithm>
 #include <cstddef>
diff --git a/libs/execution/include/hpx/execution/executors/post_policy_dispatch.hpp b/libs/execution/include/hpx/execution/executors/post_policy_dispatch.hpp
index 561cb9c52e4d..df2da8a932ab 100644
--- a/libs/execution/include/hpx/execution/executors/post_policy_dispatch.hpp
+++ b/libs/execution/include/hpx/execution/executors/post_policy_dispatch.hpp
@@ -10,9 +10,9 @@
 
 #include <hpx/config.hpp>
 #include <hpx/coroutines/thread_enums.hpp>
+#include <hpx/execution/launch_policy.hpp>
 #include <hpx/functional/deferred_call.hpp>
 #include <hpx/runtime/get_worker_thread_num.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/thread_data_fwd.hpp>
 #include <hpx/runtime/threads/thread_helpers.hpp>
 #include <hpx/runtime/threads/thread_pool_base.hpp>
diff --git a/libs/execution/include/hpx/execution/executors/sequenced_executor.hpp b/libs/execution/include/hpx/execution/executors/sequenced_executor.hpp
index 760af893327d..75bbd6c142c2 100644
--- a/libs/execution/include/hpx/execution/executors/sequenced_executor.hpp
+++ b/libs/execution/include/hpx/execution/executors/sequenced_executor.hpp
@@ -11,10 +11,10 @@
 
 #include <hpx/config.hpp>
 #include <hpx/async_launch_policy_dispatch.hpp>
+#include <hpx/execution/future.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/functional/deferred_call.hpp>
 #include <hpx/functional/invoke.hpp>
-#include <hpx/execution/future.hpp>
 #include <hpx/runtime/threads/thread_executor.hpp>
 #include <hpx/sync_launch_policy_dispatch.hpp>
 #include <hpx/util/unwrap.hpp>
diff --git a/libs/execution/include/hpx/execution/executors/service_executors.hpp b/libs/execution/include/hpx/execution/executors/service_executors.hpp
index 5d20d3d1c605..3bdfc827ce35 100644
--- a/libs/execution/include/hpx/execution/executors/service_executors.hpp
+++ b/libs/execution/include/hpx/execution/executors/service_executors.hpp
@@ -12,8 +12,8 @@
 #include <hpx/config.hpp>
 #include <hpx/execution/executors/static_chunk_size.hpp>
 #include <hpx/execution/executors/thread_execution.hpp>
-#include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/future.hpp>
+#include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/runtime/threads/executors/service_executors.hpp>
 
 namespace hpx { namespace parallel { namespace execution {
diff --git a/libs/execution/include/hpx/execution/executors/thread_execution.hpp b/libs/execution/include/hpx/execution/executors/thread_execution.hpp
index f0daa55886f7..001c60cf2621 100644
--- a/libs/execution/include/hpx/execution/executors/thread_execution.hpp
+++ b/libs/execution/include/hpx/execution/executors/thread_execution.hpp
@@ -18,17 +18,17 @@
 #include <hpx/datastructures/tuple.hpp>
 #include <hpx/execution/executors/execution.hpp>
 #include <hpx/execution/executors/fused_bulk_execute.hpp>
+#include <hpx/execution/future.hpp>
+#include <hpx/execution/futures_factory.hpp>
+#include <hpx/execution/traits/future_access.hpp>
+#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/functional/bind.hpp>
 #include <hpx/functional/bind_back.hpp>
 #include <hpx/functional/deferred_call.hpp>
 #include <hpx/iterator_support/range.hpp>
-#include <hpx/execution/future.hpp>
-#include <hpx/execution/futures_factory.hpp>
 #include <hpx/runtime/threads/executors/current_executor.hpp>
 #include <hpx/runtime/threads/thread_executor.hpp>
 #include <hpx/runtime/threads/thread_helpers.hpp>
-#include <hpx/execution/traits/future_access.hpp>
-#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/util/unwrap.hpp>
 
 #include <algorithm>
diff --git a/libs/execution/include/hpx/execution/executors/thread_execution_information.hpp b/libs/execution/include/hpx/execution/executors/thread_execution_information.hpp
index d3090f5f29ad..8ba0a9c7e356 100644
--- a/libs/execution/include/hpx/execution/executors/thread_execution_information.hpp
+++ b/libs/execution/include/hpx/execution/executors/thread_execution_information.hpp
@@ -9,11 +9,11 @@
 #define HPX_PARALLEL_EXECUTORS_THREAD_EXECUTION_INFORMATION_JAN_17_2017_0130PM
 
 #include <hpx/config.hpp>
+#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/runtime/get_os_thread_count.hpp>
 #include <hpx/runtime/threads/policies/scheduler_mode.hpp>
 #include <hpx/runtime/threads/thread_executor.hpp>
 #include <hpx/topology/topology.hpp>
-#include <hpx/execution/traits/is_launch_policy.hpp>
 
 #include <hpx/execution/executors/execution_information.hpp>
 
diff --git a/libs/execution/include/hpx/execution/executors/thread_pool_executor.hpp b/libs/execution/include/hpx/execution/executors/thread_pool_executor.hpp
index 5790b8a7a879..f586ab5b8405 100644
--- a/libs/execution/include/hpx/execution/executors/thread_pool_executor.hpp
+++ b/libs/execution/include/hpx/execution/executors/thread_pool_executor.hpp
@@ -18,14 +18,15 @@
 #include <hpx/execution/executors/fused_bulk_execute.hpp>
 #include <hpx/execution/executors/post_policy_dispatch.hpp>
 #include <hpx/execution/executors/static_chunk_size.hpp>
+#include <hpx/execution/future.hpp>
+#include <hpx/execution/launch_policy.hpp>
+#include <hpx/execution/traits/future_traits.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/functional/bind_back.hpp>
 #include <hpx/functional/deferred_call.hpp>
 #include <hpx/functional/invoke.hpp>
 #include <hpx/functional/one_shot.hpp>
 #include <hpx/iterator_support/range.hpp>
-#include <hpx/execution/future.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/policies/scheduler_base.hpp>
 #include <hpx/runtime/threads/thread_data.hpp>
 #include <hpx/runtime/threads/thread_data_fwd.hpp>
@@ -33,7 +34,6 @@
 #include <hpx/runtime/threads/thread_pool_base.hpp>
 #include <hpx/serialization/serialize.hpp>
 #include <hpx/synchronization/latch.hpp>
-#include <hpx/execution/traits/future_traits.hpp>
 #include <hpx/util/unwrap.hpp>
 
 #include <algorithm>
diff --git a/libs/execution/include/hpx/execution/executors/timed_execution.hpp b/libs/execution/include/hpx/execution/executors/timed_execution.hpp
index 8f63322e9d45..b4c71ebff379 100644
--- a/libs/execution/include/hpx/execution/executors/timed_execution.hpp
+++ b/libs/execution/include/hpx/execution/executors/timed_execution.hpp
@@ -11,9 +11,9 @@
 #include <hpx/config.hpp>
 #include <hpx/execution/executors/timed_execution_fwd.hpp>
 
+#include <hpx/execution/future.hpp>
 #include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/traits/is_executor.hpp>
-#include <hpx/execution/future.hpp>
 #include <hpx/timing/steady_clock.hpp>
 #include <hpx/type_support/detail/wrap_int.hpp>
 
diff --git a/libs/execution/include/hpx/execution/executors/timed_executors.hpp b/libs/execution/include/hpx/execution/executors/timed_executors.hpp
index 894616c0ce91..7de5dceb1f69 100644
--- a/libs/execution/include/hpx/execution/executors/timed_executors.hpp
+++ b/libs/execution/include/hpx/execution/executors/timed_executors.hpp
@@ -10,12 +10,12 @@
 #define HPX_PARALLEL_TIMED_EXECUTORS_JAN_06_2017_0802AM
 
 #include <hpx/config.hpp>
+#include <hpx/execution/future.hpp>
 #include <hpx/execution/traits/executor_traits.hpp>
+#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/functional/bind.hpp>
-#include <hpx/execution/future.hpp>
 #include <hpx/runtime/threads/thread.hpp>
 #include <hpx/timing/steady_clock.hpp>
-#include <hpx/execution/traits/is_launch_policy.hpp>
 #include <hpx/type_support/decay.hpp>
 #include <hpx/type_support/detail/wrap_int.hpp>
 
diff --git a/libs/execution/include/hpx/execution/future.hpp b/libs/execution/include/hpx/execution/future.hpp
index facad85c5c9d..9d4d26523050 100644
--- a/libs/execution/include/hpx/execution/future.hpp
+++ b/libs/execution/include/hpx/execution/future.hpp
@@ -14,17 +14,9 @@
 #include <hpx/assertion.hpp>
 #include <hpx/concepts/concepts.hpp>
 #include <hpx/errors.hpp>
-#include <hpx/functional/bind.hpp>
-#include <hpx/functional/function.hpp>
-#include <hpx/functional/invoke.hpp>
-#include <hpx/functional/result_of.hpp>
-#include <hpx/functional/traits/is_callable.hpp>
 #include <hpx/execution/detail/future_data.hpp>
 #include <hpx/execution/detail/future_traits.hpp>
-#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/execution/launch_policy.hpp>
-#include <hpx/serialization/detail/polymorphic_nonintrusive_factory.hpp>
-#include <hpx/timing/steady_clock.hpp>
 #include <hpx/execution/traits/acquire_shared_state.hpp>
 #include <hpx/execution/traits/future_access.hpp>
 #include <hpx/execution/traits/future_then_result.hpp>
@@ -32,6 +24,14 @@
 #include <hpx/execution/traits/is_executor.hpp>
 #include <hpx/execution/traits/is_future.hpp>
 #include <hpx/execution/traits/is_launch_policy.hpp>
+#include <hpx/functional/bind.hpp>
+#include <hpx/functional/function.hpp>
+#include <hpx/functional/invoke.hpp>
+#include <hpx/functional/result_of.hpp>
+#include <hpx/functional/traits/is_callable.hpp>
+#include <hpx/memory/intrusive_ptr.hpp>
+#include <hpx/serialization/detail/polymorphic_nonintrusive_factory.hpp>
+#include <hpx/timing/steady_clock.hpp>
 #include <hpx/type_support/always_void.hpp>
 #include <hpx/type_support/decay.hpp>
 #include <hpx/type_support/identity.hpp>
@@ -39,9 +39,11 @@
 #include <hpx/type_support/void_guard.hpp>
 #include <hpx/util/serialize_exception.hpp>
 
+// clang-format off
 #if defined(HPX_HAVE_AWAIT)
-    #include <hpx/execution/detail/future_await_traits.hpp>
+  #include <hpx/execution/detail/future_await_traits.hpp>
 #endif
+// clang-format on
 
 #include <exception>
 #include <iterator>
@@ -49,15 +51,13 @@
 #include <type_traits>
 #include <utility>
 
-
 namespace hpx {
     // Due to the removal of the lcos_fwd include
     using lcos::future;
     using lcos::shared_future;
-}
+}    // namespace hpx
 
-namespace hpx { namespace lcos { namespace detail
-{
+namespace hpx { namespace lcos { namespace detail {
     ///////////////////////////////////////////////////////////////////////////
     enum future_state
     {
@@ -91,7 +91,8 @@ namespace hpx { namespace lcos { namespace detail
         typedef typename shared_state::init_no_addref init_no_addref;
 
         std::unique_ptr<value_type> value(
-            serialization::detail::constructor_selector<value_type>::create(ar));
+            serialization::detail::constructor_selector<value_type>::create(
+                ar));
 
         hpx::intrusive_ptr<shared_state> p(
             new shared_state(init_no_addref{}, in_place{}, std::move(*value)),
@@ -101,9 +102,9 @@ namespace hpx { namespace lcos { namespace detail
     }
 
     template <typename Archive, typename Future>
-    typename std::enable_if<
-        !std::is_void<typename hpx::traits::future_traits<Future>::type>::value
-    >::type serialize_future_load(Archive& ar, Future& f)
+    typename std::enable_if<!std::is_void<
+        typename hpx::traits::future_traits<Future>::type>::value>::type
+    serialize_future_load(Archive& ar, Future& f)
     {
         typedef typename hpx::traits::future_traits<Future>::type value_type;
         typedef lcos::detail::future_data<value_type> shared_state;
@@ -115,8 +116,9 @@ namespace hpx { namespace lcos { namespace detail
         {
             serialize_future_load(
                 ar, f, std::is_default_constructible<value_type>());
-
-        } else if (state == future_state::has_exception) {
+        }
+        else if (state == future_state::has_exception)
+        {
             std::exception_ptr exception;
             ar >> exception;
 
@@ -125,19 +127,22 @@ namespace hpx { namespace lcos { namespace detail
                 false);
 
             f = hpx::traits::future_access<Future>::create(std::move(p));
-        } else if (state == future_state::invalid) {
+        }
+        else if (state == future_state::invalid)
+        {
             f = Future();
-        } else {
-            HPX_THROW_EXCEPTION(invalid_status,
-                "serialize_future_load",
+        }
+        else
+        {
+            HPX_THROW_EXCEPTION(invalid_status, "serialize_future_load",
                 "attempting to deserialize a future with an unknown state");
         }
     }
 
     template <typename Archive, typename Future>
-    typename std::enable_if<
-        std::is_void<typename hpx::traits::future_traits<Future>::type>::value
-    >::type serialize_future_load(Archive& ar, Future& f) //-V659
+    typename std::enable_if<std::is_void<
+        typename hpx::traits::future_traits<Future>::type>::value>::type
+    serialize_future_load(Archive& ar, Future& f)    //-V659
     {
         typedef lcos::detail::future_data<void> shared_state;
         typedef typename shared_state::init_no_addref init_no_addref;
@@ -147,11 +152,14 @@ namespace hpx { namespace lcos { namespace detail
         if (state == future_state::has_value)
         {
             hpx::intrusive_ptr<shared_state> p(
-                new shared_state(init_no_addref{}, in_place{}, hpx::util::unused),
+                new shared_state(
+                    init_no_addref{}, in_place{}, hpx::util::unused),
                 false);
 
             f = hpx::traits::future_access<Future>::create(std::move(p));
-        } else if (state == future_state::has_exception) {
+        }
+        else if (state == future_state::has_exception)
+        {
             std::exception_ptr exception;
             ar >> exception;
 
@@ -160,11 +168,14 @@ namespace hpx { namespace lcos { namespace detail
                 false);
 
             f = hpx::traits::future_access<Future>::create(std::move(p));
-        } else if (state == future_state::invalid) {
+        }
+        else if (state == future_state::invalid)
+        {
             f = Future();
-        } else {
-            HPX_THROW_EXCEPTION(invalid_status,
-                "serialize_future_load",
+        }
+        else
+        {
+            HPX_THROW_EXCEPTION(invalid_status, "serialize_future_load",
                 "attempting to deserialize a future with an unknown state");
         }
     }
@@ -188,11 +199,12 @@ namespace hpx { namespace lcos { namespace detail
     }
 
     template <typename Archive, typename Future>
-    typename std::enable_if<
-        !std::is_void<typename hpx::traits::future_traits<Future>::type>::value
-    >::type serialize_future_save(Archive& ar, Future const& f)
+    typename std::enable_if<!std::is_void<
+        typename hpx::traits::future_traits<Future>::type>::value>::type
+    serialize_future_save(Archive& ar, Future const& f)
     {
-        typedef typename hpx::traits::future_traits<Future>::result_type value_type;
+        typedef
+            typename hpx::traits::future_traits<Future>::result_type value_type;
 
         int state = future_state::invalid;
         if (f.valid() && !f.is_ready())
@@ -209,8 +221,7 @@ namespace hpx { namespace lcos { namespace detail
             }
             else
             {
-                HPX_THROW_EXCEPTION(invalid_status,
-                    "serialize_future_save",
+                HPX_THROW_EXCEPTION(invalid_status, "serialize_future_save",
                     "future must be ready in order for it to be serialized");
             }
             return;
@@ -219,28 +230,31 @@ namespace hpx { namespace lcos { namespace detail
         if (f.has_value())
         {
             state = future_state::has_value;
-            value_type const & value =
-                *hpx::traits::future_access<Future>::
-                    get_shared_state(f)->get_result();
+            value_type const& value =
+                *hpx::traits::future_access<Future>::get_shared_state(f)
+                     ->get_result();
             ar << state;
 
             serialize_future_save(
                 ar, value, std::is_default_constructible<value_type>());
-
-        } else if (f.has_exception()) {
+        }
+        else if (f.has_exception())
+        {
             state = future_state::has_exception;
             std::exception_ptr exception = f.get_exception_ptr();
             ar << state << exception;
-        } else {
+        }
+        else
+        {
             state = future_state::invalid;
             ar << state;
         }
     }
 
     template <typename Archive, typename Future>
-    typename std::enable_if<
-        std::is_void<typename hpx::traits::future_traits<Future>::type>::value
-    >::type serialize_future_save(Archive& ar, Future const& f) //-V659
+    typename std::enable_if<std::is_void<
+        typename hpx::traits::future_traits<Future>::type>::value>::type
+    serialize_future_save(Archive& ar, Future const& f)    //-V659
     {
         int state = future_state::invalid;
         if (f.valid() && !f.is_ready())
@@ -257,8 +271,7 @@ namespace hpx { namespace lcos { namespace detail
             }
             else
             {
-                HPX_THROW_EXCEPTION(invalid_status,
-                    "serialize_future_save",
+                HPX_THROW_EXCEPTION(invalid_status, "serialize_future_save",
                     "future must be ready in order for it to be serialized");
             }
             return;
@@ -289,7 +302,8 @@ namespace hpx { namespace lcos { namespace detail
     }
 
     template <typename Future>
-    void serialize_future(serialization::output_archive& ar, Future& f, unsigned)
+    void serialize_future(
+        serialization::output_archive& ar, Future& f, unsigned)
     {
         serialize_future_save(ar, f);
     }
@@ -297,10 +311,11 @@ namespace hpx { namespace lcos { namespace detail
     ///////////////////////////////////////////////////////////////////////////
     template <typename Future, typename Enable = void>
     struct future_unwrap_result
-    {};
+    {
+    };
 
     template <template <typename> class Future, typename R>
-    struct future_unwrap_result<Future<Future<R> > >
+    struct future_unwrap_result<Future<Future<R>>>
     {
         typedef R result_type;
 
@@ -308,7 +323,7 @@ namespace hpx { namespace lcos { namespace detail
     };
 
     template <typename R>
-    struct future_unwrap_result<future<shared_future<R> > >
+    struct future_unwrap_result<future<shared_future<R>>>
     {
         typedef R result_type;
 
@@ -317,12 +332,10 @@ namespace hpx { namespace lcos { namespace detail
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename T>
-    struct future_value
-      : future_data_result<T>
+    struct future_value : future_data_result<T>
     {
         template <typename U>
-        HPX_FORCEINLINE static
-        U get(U && u)
+        HPX_FORCEINLINE static U get(U&& u)
         {
             return std::forward<U>(u);
         }
@@ -334,11 +347,9 @@ namespace hpx { namespace lcos { namespace detail
     };
 
     template <typename T>
-    struct future_value<T&>
-      : future_data_result<T&>
+    struct future_value<T&> : future_data_result<T&>
     {
-        HPX_FORCEINLINE static
-        T& get(T* u)
+        HPX_FORCEINLINE static T& get(T* u)
         {
             return *u;
         }
@@ -351,15 +362,11 @@ namespace hpx { namespace lcos { namespace detail
     };
 
     template <>
-    struct future_value<void>
-      : future_data_result<void>
+    struct future_value<void> : future_data_result<void>
     {
-        HPX_FORCEINLINE static
-        void get(hpx::util::unused_type)
-        {}
+        HPX_FORCEINLINE static void get(hpx::util::unused_type) {}
 
-        static void get_default()
-        {}
+        static void get_default() {}
     };
 
     ///////////////////////////////////////////////////////////////////////////
@@ -367,8 +374,8 @@ namespace hpx { namespace lcos { namespace detail
     struct future_get_result
     {
         template <typename SharedState>
-        HPX_FORCEINLINE static R*
-        call(SharedState const& state, error_code& ec = throws)
+        HPX_FORCEINLINE static R* call(
+            SharedState const& state, error_code& ec = throws)
         {
             return state->get_result(ec);
         }
@@ -378,8 +385,8 @@ namespace hpx { namespace lcos { namespace detail
     struct future_get_result<util::unused_type>
     {
         template <typename SharedState>
-        HPX_FORCEINLINE static util::unused_type*
-        call(SharedState const& state, error_code& ec = throws)
+        HPX_FORCEINLINE static util::unused_type* call(
+            SharedState const& state, error_code& ec = throws)
         {
             return state->get_result_void(ec);
         }
@@ -394,35 +401,32 @@ namespace hpx { namespace lcos { namespace detail
 
     template <typename ContResult, typename Future, typename Policy, typename F>
     inline typename hpx::traits::detail::shared_state_ptr<
-        typename continuation_result<ContResult>::type
-    >::type
-    make_continuation(Future const& future, Policy && policy, F && f);
+        typename continuation_result<ContResult>::type>::type
+    make_continuation(Future const& future, Policy&& policy, F&& f);
 
     // create non-unwrapping continuations
     template <typename ContResult, typename Future, typename Executor,
         typename F>
     inline typename traits::detail::shared_state_ptr<ContResult>::type
-    make_continuation_exec(Future const& future, Executor && exec, F && f);
+    make_continuation_exec(Future const& future, Executor&& exec, F&& f);
 
     template <typename ContResult, typename Allocator, typename Future,
         typename Policy, typename F>
     inline typename traits::detail::shared_state_ptr<
-        typename continuation_result<ContResult>::type
-    >::type
-    make_continuation_alloc(Allocator const& a,
-        Future const& future, Policy&& policy, F&& f);
+        typename continuation_result<ContResult>::type>::type
+    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 typename traits::detail::shared_state_ptr<ContResult>::type
-    make_continuation_alloc_nounwrap(Allocator const& a,
-        Future const& future, Policy&& policy, F&& f);
+    make_continuation_alloc_nounwrap(
+        Allocator const& a, Future const& future, Policy&& policy, F&& f);
 
     template <typename Executor, typename Future, typename F>
-    inline typename hpx::traits::future_then_executor_result<
-        Executor, typename std::decay<Future>::type, F
-    >::type
-    then_execute_helper(Executor &&, F &&, Future &&);
+    inline typename hpx::traits::future_then_executor_result<Executor,
+        typename std::decay<Future>::type, F>::type
+    then_execute_helper(Executor&&, F&&, Future&&);
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Future, typename FD, typename Enable = void>
@@ -431,45 +435,42 @@ namespace hpx { namespace lcos { namespace detail
     // launch
     template <typename Future, typename Policy>
     struct future_then_dispatch<Future, Policy,
-        typename std::enable_if<
-            traits::is_launch_policy<Policy>::value
-        >::type>
+        typename std::enable_if<traits::is_launch_policy<Policy>::value>::type>
     {
         template <typename Policy_, typename F>
-        HPX_FORCEINLINE
-        static typename hpx::traits::future_then_result<Future, F>::type
-        call(Future && fut, Policy_ && policy, F && f)
+        HPX_FORCEINLINE static
+            typename hpx::traits::future_then_result<Future, F>::type
+            call(Future&& fut, Policy_&& policy, F&& f)
         {
-            using result_type =
-                typename hpx::traits::future_then_result<Future, F>::result_type;
+            using result_type = typename hpx::traits::future_then_result<Future,
+                F>::result_type;
             using continuation_result_type =
                 typename hpx::util::invoke_result<F, Future>::type;
 
-            typename hpx::traits::detail::shared_state_ptr<result_type>::type p =
-                detail::make_continuation_alloc<continuation_result_type>(
-                    hpx::util::internal_allocator<>{},
-                    std::move(fut), std::forward<Policy_>(policy),
-                    std::forward<F>(f));
-            return hpx::traits::future_access<future<result_type> >::create(
+            typename hpx::traits::detail::shared_state_ptr<result_type>::type
+                p = detail::make_continuation_alloc<continuation_result_type>(
+                    hpx::util::internal_allocator<>{}, std::move(fut),
+                    std::forward<Policy_>(policy), std::forward<F>(f));
+            return hpx::traits::future_access<future<result_type>>::create(
                 std::move(p));
         }
 
         template <typename Allocator, typename Policy_, typename F>
         HPX_FORCEINLINE static
-        typename hpx::traits::future_then_result<Future, F>::type
-        call_alloc(
-            Allocator const& alloc, Future&& fut, Policy_&& policy, F&& f)
+            typename hpx::traits::future_then_result<Future, F>::type
+            call_alloc(
+                Allocator const& alloc, Future&& fut, Policy_&& policy, F&& f)
         {
-            using result_type =
-                typename hpx::traits::future_then_result<Future, F>::result_type;
+            using result_type = typename hpx::traits::future_then_result<Future,
+                F>::result_type;
             using continuation_result_type =
                 typename hpx::util::invoke_result<F, Future>::type;
 
-            typename hpx::traits::detail::shared_state_ptr<result_type>::type p =
-                detail::make_continuation_alloc<continuation_result_type>(
+            typename hpx::traits::detail::shared_state_ptr<result_type>::type
+                p = detail::make_continuation_alloc<continuation_result_type>(
                     alloc, std::move(fut), std::forward<Policy_>(policy),
                     std::forward<F>(f));
-            return hpx::traits::future_access<future<result_type> >::create(
+            return hpx::traits::future_access<future<result_type>>::create(
                 std::move(p));
         }
     };
@@ -481,17 +482,15 @@ namespace hpx { namespace lcos { namespace detail
     // threads::executor
     template <typename Future, typename Executor>
     struct future_then_dispatch<Future, Executor,
-        typename std::enable_if<
-            traits::is_one_way_executor<Executor>::value ||
+        typename std::enable_if<traits::is_one_way_executor<Executor>::value ||
             traits::is_two_way_executor<Executor>::value ||
-            traits::is_threads_executor<Executor>::value
-        >::type>
+            traits::is_threads_executor<Executor>::value>::type>
     {
         template <typename Executor_, typename F>
-        HPX_FORCEINLINE
-        static typename hpx::traits::future_then_executor_result<
-            Executor_, Future, F>::type
-        call(Future && fut, Executor_ && exec, F && f)
+        HPX_FORCEINLINE static
+            typename hpx::traits::future_then_executor_result<Executor_, Future,
+                F>::type
+            call(Future&& fut, Executor_&& exec, F&& f)
         {
             // simply forward this to executor
             return detail::then_execute_helper(std::forward<Executor_>(exec),
@@ -499,10 +498,10 @@ namespace hpx { namespace lcos { namespace detail
         }
 
         template <typename Allocator, typename Executor_, typename F>
-        HPX_FORCEINLINE
-        static typename hpx::traits::future_then_executor_result<
-            Executor_, Future, F>::type
-        call_alloc(Allocator const&, Future && fut, Executor_ && exec, F && f)
+        HPX_FORCEINLINE static
+            typename hpx::traits::future_then_executor_result<Executor_, Future,
+                F>::type
+            call_alloc(Allocator const&, Future&& fut, Executor_&& exec, F&& f)
         {
             return call(std::forward<Future>(fut),
                 std::forward<Executor_>(exec), std::forward<F>(f));
@@ -511,18 +510,15 @@ namespace hpx { namespace lcos { namespace detail
 
     // plain function, or function object
     template <typename Future, typename FD>
-    struct future_then_dispatch<Future, FD, typename std::enable_if<
-        !traits::is_launch_policy<FD>::value &&
-        !(
-            traits::is_one_way_executor<FD>::value ||
-            traits::is_two_way_executor<FD>::value ||
-            traits::is_threads_executor<FD>::value)
-        >::type>
+    struct future_then_dispatch<Future, FD,
+        typename std::enable_if<!traits::is_launch_policy<FD>::value &&
+            !(traits::is_one_way_executor<FD>::value ||
+                traits::is_two_way_executor<FD>::value ||
+                traits::is_threads_executor<FD>::value)>::type>
     {
         template <typename F>
-        HPX_FORCEINLINE static auto
-        call(Future && fut, F && f)
-        ->  decltype(future_then_dispatch<Future, launch>::call(
+        HPX_FORCEINLINE static auto call(Future&& fut, F&& f)
+            -> decltype(future_then_dispatch<Future, launch>::call(
                 std::move(fut), launch::all, std::forward<F>(f)))
         {
             return future_then_dispatch<Future, launch>::call(
@@ -530,9 +526,9 @@ namespace hpx { namespace lcos { namespace detail
         }
 
         template <typename Allocator, typename F>
-        HPX_FORCEINLINE static auto
-        call_alloc(Allocator const& alloc, Future && fut, F && f)
-        ->  decltype(future_then_dispatch<Future, launch>::call_alloc(
+        HPX_FORCEINLINE static auto call_alloc(
+            Allocator const& alloc, Future&& fut, F&& f)
+            -> decltype(future_then_dispatch<Future, launch>::call_alloc(
                 alloc, std::move(fut), launch::all, std::forward<F>(f)))
         {
             return future_then_dispatch<Future, launch>::call_alloc(
@@ -541,10 +537,10 @@ namespace hpx { namespace lcos { namespace detail
     };
 
     ///////////////////////////////////////////////////////////////////////////
-//     template <typename R>
-//     typename hpx::traits::detail::shared_state_ptr<
-//         typename future_unwrap_result<future<R>>::result_type>::type
-//     unwrap(future<R> && future, error_code& ec = throws);
+    //     template <typename R>
+    //     typename hpx::traits::detail::shared_state_ptr<
+    //         typename future_unwrap_result<future<R>>::result_type>::type
+    //     unwrap(future<R> && future, error_code& ec = throws);
 
     template <typename Allocator, typename Future>
     typename traits::detail::shared_state_ptr<
@@ -568,35 +564,37 @@ namespace hpx { namespace lcos { namespace detail
     public:
         typedef R result_type;
         typedef future_data_base<
-                typename traits::detail::shared_state_ptr_result<R>::type
-            > shared_state_type;
+            typename traits::detail::shared_state_ptr_result<R>::type>
+            shared_state_type;
 
     private:
         template <typename F>
-        struct future_then_dispatch
-          : detail::future_then_dispatch<Derived, F>
-        {};
+        struct future_then_dispatch : detail::future_then_dispatch<Derived, F>
+        {
+        };
 
     public:
         future_base() noexcept
           : shared_state_()
-        {}
+        {
+        }
 
-        explicit future_base(
-            hpx::intrusive_ptr<shared_state_type> const& p
-        ) : shared_state_(p)
-        {}
+        explicit future_base(hpx::intrusive_ptr<shared_state_type> const& p)
+          : shared_state_(p)
+        {
+        }
 
-        explicit future_base(
-            hpx::intrusive_ptr<shared_state_type> && p
-        ) : shared_state_(std::move(p))
-        {}
+        explicit future_base(hpx::intrusive_ptr<shared_state_type>&& p)
+          : shared_state_(std::move(p))
+        {
+        }
 
         future_base(future_base const& other)
           : shared_state_(other.shared_state_)
-        {}
+        {
+        }
 
-        future_base(future_base && other) noexcept
+        future_base(future_base&& other) noexcept
           : shared_state_(std::move(other.shared_state_))
         {
             other.shared_state_ = nullptr;
@@ -607,7 +605,7 @@ namespace hpx { namespace lcos { namespace detail
             shared_state_.swap(other.shared_state_);
         }
 
-        future_base& operator=(future_base const & other)
+        future_base& operator=(future_base const& other)
         {
             if (this != &other)
             {
@@ -616,7 +614,7 @@ namespace hpx { namespace lcos { namespace detail
             return *this;
         }
 
-        future_base& operator=(future_base && other) noexcept
+        future_base& operator=(future_base&& other) noexcept
         {
             if (this != &other)
             {
@@ -668,7 +666,8 @@ namespace hpx { namespace lcos { namespace detail
             typedef typename shared_state_type::result_type result_type;
 
             error_code ec(lightweight);
-            detail::future_get_result<result_type>::call(this->shared_state_, ec);
+            detail::future_get_result<result_type>::call(
+                this->shared_state_, ec);
             if (!ec)
             {
                 HPX_ASSERT(!has_exception());
@@ -710,18 +709,18 @@ namespace hpx { namespace lcos { namespace detail
         //   - valid() == false on original future object immediately after it
         //     returns.
         template <typename F>
-        static auto then(Derived && fut, F && f, error_code& ec = throws)
-        ->  decltype(future_then_dispatch<typename std::decay<F>::type>::call(
-                std::move(fut), std::forward<F>(f)))
+        static auto then(Derived&& fut, F&& f, error_code& ec = throws)
+            -> decltype(
+                future_then_dispatch<typename std::decay<F>::type>::call(
+                    std::move(fut), std::forward<F>(f)))
         {
-            using result_type =
-                decltype(future_then_dispatch<typename std::decay<F>::type>::call(
+            using result_type = decltype(
+                future_then_dispatch<typename std::decay<F>::type>::call(
                     std::move(fut), std::forward<F>(f)));
 
             if (!fut.shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "future_base<R>::then",
+                HPX_THROWS_IF(ec, no_state, "future_base<R>::then",
                     "this future has no valid shared state");
                 return result_type();
             }
@@ -731,18 +730,18 @@ namespace hpx { namespace lcos { namespace detail
         }
 
         template <typename F, typename T0>
-        static auto then(Derived && fut, T0 && t0, F && f, error_code& ec = throws)
-        ->  decltype(future_then_dispatch<typename std::decay<T0>::type>::call(
-                std::move(fut), std::forward<T0>(t0), std::forward<F>(f)))
+        static auto then(Derived&& fut, T0&& t0, F&& f, error_code& ec = throws)
+            -> decltype(
+                future_then_dispatch<typename std::decay<T0>::type>::call(
+                    std::move(fut), std::forward<T0>(t0), std::forward<F>(f)))
         {
-            using result_type =
-                decltype(future_then_dispatch<typename std::decay<T0>::type>::call(
+            using result_type = decltype(
+                future_then_dispatch<typename std::decay<T0>::type>::call(
                     std::move(fut), std::forward<T0>(t0), std::forward<F>(f)));
 
             if (!fut.shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "future_base<R>::then",
+                HPX_THROWS_IF(ec, no_state, "future_base<R>::then",
                     "this future has no valid shared state");
                 return result_type();
             }
@@ -752,10 +751,11 @@ namespace hpx { namespace lcos { namespace detail
         }
 
         template <typename Allocator, typename F>
-        static auto then_alloc(Allocator const& alloc, Derived && fut, F && f,
-                error_code& ec = throws)
-        ->  decltype(future_then_dispatch<typename std::decay<F>::type>::
-                call_alloc(alloc, std::move(fut), std::forward<F>(f)))
+        static auto then_alloc(Allocator const& alloc, Derived&& fut, F&& f,
+            error_code& ec = throws)
+            -> decltype(
+                future_then_dispatch<typename std::decay<F>::type>::call_alloc(
+                    alloc, std::move(fut), std::forward<F>(f)))
         {
             using result_type = decltype(
                 future_then_dispatch<typename std::decay<F>::type>::call_alloc(
@@ -763,8 +763,7 @@ namespace hpx { namespace lcos { namespace detail
 
             if (!fut.shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "future_base<R>::then",
+                HPX_THROWS_IF(ec, no_state, "future_base<R>::then",
                     "this future has no valid shared state");
                 return result_type();
             }
@@ -779,8 +778,7 @@ namespace hpx { namespace lcos { namespace detail
         {
             if (!shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "future_base<R>::wait",
+                HPX_THROWS_IF(ec, no_state, "future_base<R>::wait",
                     "this future has no valid shared state");
                 return;
             }
@@ -798,14 +796,12 @@ namespace hpx { namespace lcos { namespace detail
         //   - future_status::timeout if the function is returning because the
         //     absolute timeout (30.2.4) specified by abs_time has expired.
         // Throws: timeout-related exceptions (30.2.4).
-        future_status
-        wait_until(hpx::util::steady_time_point const& abs_time,
+        future_status wait_until(hpx::util::steady_time_point const& abs_time,
             error_code& ec = throws) const
         {
             if (!shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "future_base<R>::wait_until",
+                HPX_THROWS_IF(ec, no_state, "future_base<R>::wait_until",
                     "this future has no valid shared state");
                 return future_status::uninitialized;
             }
@@ -823,8 +819,7 @@ namespace hpx { namespace lcos { namespace detail
         //   - future_status::timeout if the function is returning because the
         //     relative timeout (30.2.4) specified by rel_time has expired.
         // Throws: timeout-related exceptions (30.2.4).
-        future_status
-        wait_for(hpx::util::steady_duration const& rel_time,
+        future_status wait_for(hpx::util::steady_duration const& rel_time,
             error_code& ec = throws) const
         {
             return wait_until(rel_time.from_now(), ec);
@@ -843,7 +838,7 @@ namespace hpx { namespace lcos { namespace detail
         }
 
         auto await_resume()
-        ->  decltype(detail::await_resume(std::declval<Derived>()))
+            -> decltype(detail::await_resume(std::declval<Derived>()))
         {
             return detail::await_resume(*static_cast<Derived*>(this));
         }
@@ -852,10 +847,9 @@ namespace hpx { namespace lcos { namespace detail
     protected:
         hpx::intrusive_ptr<shared_state_type> shared_state_;
     };
-}}}
+}}}    // namespace hpx::lcos::detail
 
-namespace hpx { namespace lcos
-{
+namespace hpx { namespace lcos {
     ///////////////////////////////////////////////////////////////////////////
     template <typename R>
     class future : public detail::future_base<future<R>, R>
@@ -871,7 +865,8 @@ namespace hpx { namespace lcos
         {
             explicit invalidate(future& f)
               : f_(f)
-            {}
+            {
+            }
 
             ~invalidate()
             {
@@ -889,20 +884,21 @@ namespace hpx { namespace lcos
         friend struct hpx::traits::detail::future_access_customization_point;
 
         // Effects: constructs a future object from an shared state
-        explicit future(
-            hpx::intrusive_ptr<shared_state_type> const& state
-        ) : base_type(state)
-        {}
+        explicit future(hpx::intrusive_ptr<shared_state_type> const& state)
+          : base_type(state)
+        {
+        }
 
-        explicit future(
-            hpx::intrusive_ptr<shared_state_type> && state
-        ) : base_type(std::move(state))
-        {}
+        explicit future(hpx::intrusive_ptr<shared_state_type>&& state)
+          : base_type(std::move(state))
+        {
+        }
 
         template <typename SharedState>
         explicit future(hpx::intrusive_ptr<SharedState> const& state)
           : base_type(hpx::static_pointer_cast<shared_state_type>(state))
-        {}
+        {
+        }
 
     public:
         // Effects: constructs an empty future object that does not refer to
@@ -910,7 +906,8 @@ namespace hpx { namespace lcos
         // Postcondition: valid() == false.
         future() noexcept
           : base_type()
-        {}
+        {
+        }
 
         // Effects: move constructs a future object that refers to the shared
         //          state that was originally referred to by other (if any).
@@ -918,9 +915,10 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     constructor invocation.
         //   - other.valid() == false.
-        future(future && other) noexcept
+        future(future&& other) noexcept
           : base_type(std::move(other))
-        {}
+        {
+        }
 
         // Effects: constructs a future object by moving the instance referred
         //          to by rhs and unwrapping the inner future.
@@ -928,9 +926,11 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     constructor invocation.
         //   - other.valid() == false.
-        future(future<future> && other) noexcept
-          : base_type(other.valid() ? detail::unwrap(std::move(other)) : nullptr)
-        {}
+        future(future<future>&& other) noexcept
+          : base_type(
+                other.valid() ? detail::unwrap(std::move(other)) : nullptr)
+        {
+        }
 
         // Effects: constructs a future object by moving the instance referred
         //          to by rhs and unwrapping the inner future.
@@ -938,9 +938,11 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     constructor invocation.
         //   - other.valid() == false.
-        future(future<shared_future<R> > && other) noexcept
-          : base_type(other.valid() ? detail::unwrap(std::move(other)) : nullptr)
-        {}
+        future(future<shared_future<R>>&& other) noexcept
+          : base_type(
+                other.valid() ? detail::unwrap(std::move(other)) : nullptr)
+        {
+        }
 
         // Effects: constructs a future<void> object that will be ready when
         //          the given future is ready
@@ -950,21 +952,20 @@ namespace hpx { namespace lcos
         //   - other.valid() == false.
         template <typename T>
         future(future<T>&& other,
-            typename std::enable_if<
-                std::is_void<R>::value && !traits::is_future<T>::value, T
-            >::type* = nullptr
-        ) : base_type(other.valid() ?
-                detail::downcast_to_void(other, false) : nullptr)
+            typename std::enable_if<std::is_void<R>::value &&
+                    !traits::is_future<T>::value,
+                T>::type* = nullptr)
+          : base_type(other.valid() ? detail::downcast_to_void(other, false) :
+                                      nullptr)
         {
-            traits::future_access<future<T> >::
-                detach_shared_state(std::move(other));
+            traits::future_access<future<T>>::detach_shared_state(
+                std::move(other));
         }
 
         // Effects:
         //   - releases any shared state (30.6.4);
         //   - destroys *this.
-        ~future()
-        {}
+        ~future() {}
 
         // Effects:
         //   - releases any shared state (30.6.4).
@@ -973,7 +974,7 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     assignment.
         //   - other.valid() == false.
-        future& operator=(future && other) noexcept
+        future& operator=(future&& other) noexcept
         {
             base_type::operator=(std::move(other));
             return *this;
@@ -997,13 +998,11 @@ namespace hpx { namespace lcos
         // Throws: the stored exception, if an exception was stored in the
         //         shared state.
         // Postcondition: valid() == false.
-        typename hpx::traits::future_traits<future>::result_type
-        get()
+        typename hpx::traits::future_traits<future>::result_type get()
         {
             if (!this->shared_state_)
             {
-                HPX_THROW_EXCEPTION(no_state,
-                    "future<R>::get",
+                HPX_THROW_EXCEPTION(no_state, "future<R>::get",
                     "this future has no valid shared state");
             }
 
@@ -1017,13 +1016,12 @@ namespace hpx { namespace lcos
             return detail::future_value<R>::get(std::move(*result));
         }
 
-        typename hpx::traits::future_traits<future>::result_type
-        get(error_code& ec)
+        typename hpx::traits::future_traits<future>::result_type get(
+            error_code& ec)
         {
             if (!this->shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "future<R>::get",
+                HPX_THROWS_IF(ec, no_state, "future<R>::get",
                     "this future has no valid shared state");
                 return detail::future_value<R>::get_default();
             }
@@ -1033,45 +1031,42 @@ namespace hpx { namespace lcos
             typedef typename shared_state_type::result_type result_type;
             result_type* result = detail::future_get_result<result_type>::call(
                 this->shared_state_, ec);
-            if (ec) return detail::future_value<R>::get_default();
+            if (ec)
+                return detail::future_value<R>::get_default();
 
             // no error has been reported, return the result
             return detail::future_value<R>::get(std::move(*result));
         }
         using base_type::get_exception_ptr;
 
-        using base_type::valid;
-        using base_type::is_ready;
-        using base_type::has_value;
         using base_type::has_exception;
+        using base_type::has_value;
+        using base_type::is_ready;
+        using base_type::valid;
 
         template <typename F>
         typename util::lazy_enable_if<
             !hpx::traits::is_launch_policy<
                 typename std::decay<F>::type>::value &&
-            !hpx::traits::is_one_way_executor<
-                typename std::decay<F>::type>::value &&
-            !hpx::traits::is_two_way_executor<
-                typename std::decay<F>::type>::value &&
-            !hpx::traits::is_threads_executor<
-                typename std::decay<F>::type>::value
-          , hpx::traits::future_then_result<future, F>
-        >::type
-        then(F && f, error_code& ec = throws)
+                !hpx::traits::is_one_way_executor<
+                    typename std::decay<F>::type>::value &&
+                !hpx::traits::is_two_way_executor<
+                    typename std::decay<F>::type>::value &&
+                !hpx::traits::is_threads_executor<
+                    typename std::decay<F>::type>::value,
+            hpx::traits::future_then_result<future, F>>::type
+        then(F&& f, error_code& ec = throws)
         {
             invalidate on_exit(*this);
-            return base_type::then(std::move(*this),
-                std::forward<F>(f), ec);
+            return base_type::then(std::move(*this), std::forward<F>(f), ec);
         }
 
         template <typename Policy, typename F>
         typename util::lazy_enable_if<
             hpx::traits::is_launch_policy<
-                typename std::decay<Policy>::type
-            >::value,
-            hpx::traits::future_then_result<future, F>
-        >::type
-        then(Policy && policy, F && f, error_code& ec = throws)
+                typename std::decay<Policy>::type>::value,
+            hpx::traits::future_then_result<future, F>>::type
+        then(Policy&& policy, F&& f, error_code& ec = throws)
         {
             invalidate on_exit(*this);
             return base_type::then(std::move(*this),
@@ -1082,27 +1077,26 @@ namespace hpx { namespace lcos
         typename util::lazy_enable_if<
             hpx::traits::is_one_way_executor<
                 typename std::decay<Executor>::type>::value ||
-            hpx::traits::is_two_way_executor<
-                typename std::decay<Executor>::type>::value ||
-            hpx::traits::is_threads_executor<
-                typename std::decay<Executor>::type>::value
-          , hpx::traits::future_then_executor_result<Executor, future, F>
-        >::type
-        then(Executor && exec, F && f, error_code& ec = throws)
+                hpx::traits::is_two_way_executor<
+                    typename std::decay<Executor>::type>::value ||
+                hpx::traits::is_threads_executor<
+                    typename std::decay<Executor>::type>::value,
+            hpx::traits::future_then_executor_result<Executor, future, F>>::type
+        then(Executor&& exec, F&& f, error_code& ec = throws)
         {
             invalidate on_exit(*this);
-            return base_type::then(std::move(*this),
-                exec, std::forward<F>(f), ec);
+            return base_type::then(
+                std::move(*this), exec, std::forward<F>(f), ec);
         }
 
         template <typename Allocator, typename F>
-        auto then_alloc(Allocator const& alloc, F && f, error_code& ec = throws)
-        ->  decltype(base_type::then_alloc(alloc, std::move(*this),
-                std::forward<F>(f), ec))
+        auto then_alloc(Allocator const& alloc, F&& f, error_code& ec = throws)
+            -> decltype(base_type::then_alloc(
+                alloc, std::move(*this), std::forward<F>(f), ec))
         {
             invalidate on_exit(*this);
-            return base_type::then_alloc(alloc, std::move(*this),
-                std::forward<F>(f), ec);
+            return base_type::then_alloc(
+                alloc, std::move(*this), std::forward<F>(f), ec);
         }
 
         using base_type::wait;
@@ -1111,39 +1105,31 @@ namespace hpx { namespace lcos
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         template <typename T, typename Future>
         typename std::enable_if<
-            std::is_convertible<Future, hpx::future<T> >::value,
-            hpx::future<T>
-        >::type
-        make_future_helper(Future && f)
+            std::is_convertible<Future, hpx::future<T>>::value,
+            hpx::future<T>>::type
+        make_future_helper(Future&& f)
         {
             return std::forward<Future>(f);
         }
 
         template <typename T, typename Future>
         typename std::enable_if<
-           !std::is_convertible<Future, hpx::future<T> >::value,
-            hpx::future<T>
-        >::type
-        make_future_helper(Future && f) //-V659
-        {
-            return f.then(
-                hpx::launch::sync,
-                [](Future && f) -> T
-                {
-                    return util::void_guard<T>(), f.get();
-                });
+            !std::is_convertible<Future, hpx::future<T>>::value,
+            hpx::future<T>>::type
+        make_future_helper(Future&& f)    //-V659
+        {
+            return f.then(hpx::launch::sync,
+                [](Future&& f) -> T { return util::void_guard<T>(), f.get(); });
         }
-    }
+    }    // namespace detail
 
     // Allow to convert any future<U> into any other future<R> based on an
     // existing conversion path U --> R.
     template <typename R, typename U>
-    hpx::future<R>
-    make_future(hpx::future<U> && f)
+    hpx::future<R> make_future(hpx::future<U>&& f)
     {
         static_assert(
             std::is_convertible<R, U>::value || std::is_void<R>::value,
@@ -1153,47 +1139,40 @@ namespace hpx { namespace lcos
         return detail::make_future_helper<R>(std::move(f));
     }
 
-    namespace detail
-    {
+    namespace detail {
         template <typename T, typename Future, typename Conv>
         typename std::enable_if<
-            std::is_convertible<Future, hpx::future<T> >::value,
-            hpx::future<T>
-        >::type
-        convert_future_helper(Future && f, Conv && conv)
+            std::is_convertible<Future, hpx::future<T>>::value,
+            hpx::future<T>>::type
+        convert_future_helper(Future&& f, Conv&& conv)
         {
             return std::forward<Future>(f);
         }
 
         template <typename T, typename Future, typename Conv>
         typename std::enable_if<
-           !std::is_convertible<Future, hpx::future<T> >::value,
-            hpx::future<T>
-        >::type
-        convert_future_helper(Future && f, Conv && conv) //-V659
-        {
-            return f.then(
-                hpx::launch::sync,
-                [HPX_CAPTURE_FORWARD(conv)](Future && f) -> T
-                {
+            !std::is_convertible<Future, hpx::future<T>>::value,
+            hpx::future<T>>::type
+        convert_future_helper(Future&& f, Conv&& conv)    //-V659
+        {
+            return f.then(hpx::launch::sync,
+                [HPX_CAPTURE_FORWARD(conv)](Future&& f) -> T {
                     return hpx::util::invoke(conv, f.get());
                 });
         }
-    }
+    }    // namespace detail
 
     // Allow to convert any future<U> into any other future<R> based on a given
     // conversion function: R conv(U).
     template <typename R, typename U, typename Conv>
-    hpx::future<R>
-    make_future(hpx::future<U> && f, Conv && conv)
+    hpx::future<R> make_future(hpx::future<U>&& f, Conv&& conv)
     {
         return detail::convert_future_helper<R>(
             std::move(f), std::forward<Conv>(conv));
     }
-}}
+}}    // namespace hpx::lcos
 
-namespace hpx { namespace lcos
-{
+namespace hpx { namespace lcos {
     ///////////////////////////////////////////////////////////////////////////
     template <typename R>
     class shared_future : public detail::future_base<shared_future<R>, R>
@@ -1213,19 +1192,21 @@ namespace hpx { namespace lcos
 
         // Effects: constructs a future object from an shared state
         explicit shared_future(
-            hpx::intrusive_ptr<shared_state_type> const& state
-        ) : base_type(state)
-        {}
+            hpx::intrusive_ptr<shared_state_type> const& state)
+          : base_type(state)
+        {
+        }
 
-        explicit shared_future(
-            hpx::intrusive_ptr<shared_state_type> && state
-        ) : base_type(std::move(state))
-        {}
+        explicit shared_future(hpx::intrusive_ptr<shared_state_type>&& state)
+          : base_type(std::move(state))
+        {
+        }
 
         template <typename SharedState>
         explicit shared_future(hpx::intrusive_ptr<SharedState> const& state)
           : base_type(hpx::static_pointer_cast<shared_state_type>(state))
-        {}
+        {
+        }
 
     public:
         // Effects: constructs an empty future object that does not refer to
@@ -1233,14 +1214,16 @@ namespace hpx { namespace lcos
         // Postcondition: valid() == false.
         shared_future() noexcept
           : base_type()
-        {}
+        {
+        }
 
         // Effects: constructs a shared_future object that refers to the same
         //          shared state as other (if any).
         // Postcondition: valid() returns the same value as other.valid().
         shared_future(shared_future const& other)
           : base_type(other)
-        {}
+        {
+        }
 
         // Effects: move constructs a future object that refers to the shared
         //          state that was originally referred to by other (if any).
@@ -1248,11 +1231,12 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     constructor invocation.
         //   - other.valid() == false.
-        shared_future(shared_future && other) noexcept
+        shared_future(shared_future&& other) noexcept
           : base_type(std::move(other))
-        {}
+        {
+        }
 
-        shared_future(future<R> && other) noexcept
+        shared_future(future<R>&& other) noexcept
           : base_type(hpx::traits::detail::get_shared_state(other))
         {
             other = future<R>();
@@ -1264,9 +1248,10 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     constructor invocation.
         //   - other.valid() == false.
-        shared_future(future<shared_future> && other) noexcept
+        shared_future(future<shared_future>&& other) noexcept
           : base_type(other.valid() ? detail::unwrap(other.share()) : nullptr)
-        {}
+        {
+        }
 
         // Effects: constructs a future<void> object that will be ready when
         //          the given future is ready
@@ -1275,18 +1260,18 @@ namespace hpx { namespace lcos
         //     constructor invocation.
         template <typename T>
         shared_future(shared_future<T> const& other,
-            typename std::enable_if<
-                std::is_void<R>::value && !traits::is_future<T>::value, T
-            >::type* = nullptr
-        ) : base_type(other.valid() ?
-                detail::downcast_to_void(other, true) : nullptr)
-        {}
+            typename std::enable_if<std::is_void<R>::value &&
+                    !traits::is_future<T>::value,
+                T>::type* = nullptr)
+          : base_type(
+                other.valid() ? detail::downcast_to_void(other, true) : nullptr)
+        {
+        }
 
         // Effects:
         //   - releases any shared state (30.6.4);
         //   - destroys *this.
-        ~shared_future()
-        {}
+        ~shared_future() {}
 
         // Effects:
         //   - releases any shared state (30.6.4).
@@ -1294,7 +1279,7 @@ namespace hpx { namespace lcos
         //     refers to the same shared state as other (if any).
         // Postconditions:
         //   - valid() == other.valid().
-        shared_future& operator=(shared_future const & other)
+        shared_future& operator=(shared_future const& other)
         {
             base_type::operator=(other);
             return *this;
@@ -1307,7 +1292,7 @@ namespace hpx { namespace lcos
         //   - valid() returns the same value as other.valid() prior to the
         //     assignment.
         //   - other.valid() == false.
-        shared_future& operator=(shared_future && other) noexcept
+        shared_future& operator=(shared_future&& other) noexcept
         {
             base_type::operator=(std::move(other));
             return *this;
@@ -1324,13 +1309,12 @@ namespace hpx { namespace lcos
         // Throws: the stored exception, if an exception was stored in the
         //         shared state.
         // Postcondition: valid() == false.
-        typename hpx::traits::future_traits<shared_future>::result_type
-        get() const //-V659
+        typename hpx::traits::future_traits<shared_future>::result_type get()
+            const    //-V659
         {
             if (!this->shared_state_)
             {
-                HPX_THROW_EXCEPTION(no_state,
-                    "shared_future<R>::get",
+                HPX_THROW_EXCEPTION(no_state, "shared_future<R>::get",
                     "this future has no valid shared state");
             }
 
@@ -1341,14 +1325,13 @@ namespace hpx { namespace lcos
             // no error has been reported, return the result
             return detail::future_value<R>::get(*result);
         }
-        typename hpx::traits::future_traits<shared_future>::result_type
-        get(error_code& ec) const //-V659
+        typename hpx::traits::future_traits<shared_future>::result_type get(
+            error_code& ec) const    //-V659
         {
             typedef typename shared_state_type::result_type result_type;
             if (!this->shared_state_)
             {
-                HPX_THROWS_IF(ec, no_state,
-                    "shared_future<R>::get",
+                HPX_THROWS_IF(ec, no_state, "shared_future<R>::get",
                     "this future has no valid shared state");
                 static result_type res(detail::future_value<R>::get_default());
                 return res;
@@ -1367,37 +1350,34 @@ namespace hpx { namespace lcos
         }
         using base_type::get_exception_ptr;
 
-        using base_type::valid;
-        using base_type::is_ready;
-        using base_type::has_value;
         using base_type::has_exception;
+        using base_type::has_value;
+        using base_type::is_ready;
+        using base_type::valid;
 
         template <typename F>
         typename util::lazy_enable_if<
             !hpx::traits::is_launch_policy<
                 typename std::decay<F>::type>::value &&
-            !hpx::traits::is_threads_executor<
-                typename std::decay<F>::type>::value &&
-            !hpx::traits::is_one_way_executor<
-                typename std::decay<F>::type>::value &&
-            !hpx::traits::is_two_way_executor<
-                typename std::decay<F>::type>::value
-          , hpx::traits::future_then_result<shared_future, F>
-        >::type
-        then(F && f, error_code& ec = throws) const
+                !hpx::traits::is_threads_executor<
+                    typename std::decay<F>::type>::value &&
+                !hpx::traits::is_one_way_executor<
+                    typename std::decay<F>::type>::value &&
+                !hpx::traits::is_two_way_executor<
+                    typename std::decay<F>::type>::value,
+            hpx::traits::future_then_result<shared_future, F>>::type
+        then(F&& f, error_code& ec = throws) const
         {
-            return base_type::then(shared_future(*this),
-                std::forward<F>(f), ec);
+            return base_type::then(
+                shared_future(*this), std::forward<F>(f), ec);
         }
 
         template <typename Policy, typename F>
         typename util::lazy_enable_if<
             hpx::traits::is_launch_policy<
-                typename std::decay<Policy>::type
-            >::value,
-            hpx::traits::future_then_result<shared_future, F>
-        >::type
-        then(Policy && policy, F && f, error_code& ec = throws) const
+                typename std::decay<Policy>::type>::value,
+            hpx::traits::future_then_result<shared_future, F>>::type
+        then(Policy&& policy, F&& f, error_code& ec = throws) const
         {
             return base_type::then(shared_future(*this),
                 std::forward<Policy>(policy), std::forward<F>(f), ec);
@@ -1407,25 +1387,25 @@ namespace hpx { namespace lcos
         typename util::lazy_enable_if<
             hpx::traits::is_one_way_executor<
                 typename std::decay<Executor>::type>::value ||
-            hpx::traits::is_two_way_executor<
-                typename std::decay<Executor>::type>::value ||
-            hpx::traits::is_threads_executor<
-                typename std::decay<Executor>::type>::value
-          , hpx::traits::future_then_executor_result<Executor, shared_future, F>
-        >::type
-        then(Executor && exec, F && f, error_code& ec = throws) const
+                hpx::traits::is_two_way_executor<
+                    typename std::decay<Executor>::type>::value ||
+                hpx::traits::is_threads_executor<
+                    typename std::decay<Executor>::type>::value,
+            hpx::traits::future_then_executor_result<Executor, shared_future,
+                F>>::type
+        then(Executor&& exec, F&& f, error_code& ec = throws) const
         {
-            return base_type::then(shared_future(*this),
-                exec, std::forward<F>(f), ec);
+            return base_type::then(
+                shared_future(*this), exec, std::forward<F>(f), ec);
         }
 
         template <typename Allocator, typename F>
-        auto then_alloc(Allocator const& alloc, F && f, error_code& ec = throws)
-        ->  decltype(base_type::then_alloc(alloc, std::move(*this),
-                std::forward<F>(f), ec))
+        auto then_alloc(Allocator const& alloc, F&& f, error_code& ec = throws)
+            -> decltype(base_type::then_alloc(
+                alloc, std::move(*this), std::forward<F>(f), ec))
         {
-            return base_type::then_alloc(alloc, shared_future(*this),
-                std::forward<F>(f), ec);
+            return base_type::then_alloc(
+                alloc, shared_future(*this), std::forward<F>(f), ec);
         }
 
         using base_type::wait;
@@ -1437,8 +1417,7 @@ namespace hpx { namespace lcos
     // Allow to convert any shared_future<U> into any other future<R> based on
     // an existing conversion path U --> R.
     template <typename R, typename U>
-    hpx::future<R>
-    make_future(hpx::shared_future<U> f)
+    hpx::future<R> make_future(hpx::shared_future<U> f)
     {
         static_assert(
             std::is_convertible<R, U>::value || std::is_void<R>::value,
@@ -1451,18 +1430,14 @@ namespace hpx { namespace lcos
     // Allow to convert any future<U> into any other future<R> based on a given
     // conversion function: R conv(U).
     template <typename R, typename U, typename Conv>
-    hpx::future<R>
-    make_future(hpx::shared_future<U> const& f, Conv && conv)
+    hpx::future<R> make_future(hpx::shared_future<U> const& f, Conv&& conv)
     {
-        static_assert(
-            hpx::traits::is_invocable_r<R, Conv, U>::value,
+        static_assert(hpx::traits::is_invocable_r<R, Conv, U>::value,
             "the argument type must be convertible to the requested "
             "result type by using the supplied conversion function");
 
-        return f.then(
-                hpx::launch::sync,
-            [HPX_CAPTURE_FORWARD(conv)](hpx::shared_future<U> const& f)
-            {
+        return f.then(hpx::launch::sync,
+            [HPX_CAPTURE_FORWARD(conv)](hpx::shared_future<U> const& f) {
                 return hpx::util::invoke(conv, f.get());
             });
     }
@@ -1471,54 +1446,48 @@ namespace hpx { namespace lcos
     // Convert any type of future<T> or shared_future<T> into a corresponding
     // shared_future<T>.
     template <typename R>
-    hpx::shared_future<R>
-    make_shared_future(hpx::future<R> && f)
+    hpx::shared_future<R> make_shared_future(hpx::future<R>&& f)
     {
         return f.share();
     }
 
     template <typename R>
-    hpx::shared_future<R>&
-    make_shared_future(hpx::shared_future<R>& f)
+    hpx::shared_future<R>& make_shared_future(hpx::shared_future<R>& f)
     {
         return f;
     }
 
     template <typename R>
-    hpx::shared_future<R> &&
-    make_shared_future(hpx::shared_future<R> && f)
+    hpx::shared_future<R>&& make_shared_future(hpx::shared_future<R>&& f)
     {
         return f;
     }
 
     template <typename R>
-    hpx::shared_future<R> const&
-    make_shared_future(hpx::shared_future<R> const& f)
+    hpx::shared_future<R> const& make_shared_future(
+        hpx::shared_future<R> const& f)
     {
         return f;
     }
-}}
+}}    // namespace hpx::lcos
 
-namespace hpx { namespace lcos
-{
+namespace hpx { namespace lcos {
     ///////////////////////////////////////////////////////////////////////////
     // Extension (see wg21.link/P0319), with allocator
-    template <typename T, typename Allocator, typename ... Ts>
-    typename std::enable_if<
-        std::is_constructible<T, Ts&&...>::value || std::is_void<T>::value,
-        future<T>
-    >::type
+    template <typename T, typename Allocator, typename... Ts>
+    typename std::enable_if<std::is_constructible<T, Ts&&...>::value ||
+            std::is_void<T>::value,
+        future<T>>::type
     make_ready_future_alloc(Allocator const& a, Ts&&... ts)
     {
         using result_type = T;
 
         using base_allocator = Allocator;
         using shared_state = typename traits::detail::shared_state_allocator<
-                lcos::detail::future_data<result_type>, base_allocator
-            >::type;
+            lcos::detail::future_data<result_type>, base_allocator>::type;
 
-        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;
@@ -1538,22 +1507,21 @@ namespace hpx { namespace lcos
     }
 
     // Extension (see wg21.link/P0319)
-    template <typename T, typename ... Ts>
-    HPX_FORCEINLINE typename std::enable_if<
-        std::is_constructible<T, Ts&&...>::value || std::is_void<T>::value,
-        future<T>
-    >::type
-    make_ready_future(Ts&&... ts)
+    template <typename T, typename... Ts>
+    HPX_FORCEINLINE
+        typename std::enable_if<std::is_constructible<T, Ts&&...>::value ||
+                std::is_void<T>::value,
+            future<T>>::type
+        make_ready_future(Ts&&... ts)
     {
         return make_ready_future_alloc<T>(
-            hpx::util::internal_allocator<>{},
-            std::forward<Ts>(ts)...);
+            hpx::util::internal_allocator<>{}, std::forward<Ts>(ts)...);
     }
     ///////////////////////////////////////////////////////////////////////////
     // extension: create a pre-initialized future object, with allocator
     template <int DeductionGuard = 0, typename Allocator, typename T>
-    future<typename hpx::util::decay_unwrap<T>::type>
-    make_ready_future_alloc(Allocator const& a, T&& init)
+    future<typename hpx::util::decay_unwrap<T>::type> make_ready_future_alloc(
+        Allocator const& a, T&& init)
     {
         using result_type = typename hpx::util::decay_unwrap<T>::type;
         return make_ready_future_alloc<result_type>(a, std::forward<T>(init));
@@ -1566,11 +1534,9 @@ namespace hpx { namespace lcos
     {
         using result_type = typename hpx::util::decay_unwrap<T>::type;
         return make_ready_future_alloc<result_type>(
-            hpx::util::internal_allocator<>{},
-            std::forward<T>(init));
+            hpx::util::internal_allocator<>{}, std::forward<T>(init));
     }
 
-
     ///////////////////////////////////////////////////////////////////////////
     // extension: create a pre-initialized future object which holds the
     // given error
@@ -1583,7 +1549,7 @@ namespace hpx { namespace lcos
         hpx::intrusive_ptr<shared_state> p(
             new shared_state(init_no_addref{}, e), false);
 
-        return hpx::traits::future_access<future<T> >::create(std::move(p));
+        return hpx::traits::future_access<future<T>>::create(std::move(p));
     }
 
     template <typename T, typename E>
@@ -1592,7 +1558,9 @@ namespace hpx { namespace lcos
         try
         {
             throw e;
-        } catch (...) {
+        }
+        catch (...)
+        {
             return lcos::make_exceptional_future<T>(std::current_exception());
         }
 
@@ -1603,9 +1571,8 @@ namespace hpx { namespace lcos
     // extension: create a pre-initialized future object which gets ready at
     // a given point in time
     template <int DeductionGuard = 0, typename T>
-    future<typename hpx::util::decay_unwrap<T>::type>
-    make_ready_future_at(hpx::util::steady_time_point const& abs_time,
-        T&& init)
+    future<typename hpx::util::decay_unwrap<T>::type> make_ready_future_at(
+        hpx::util::steady_time_point const& abs_time, T&& init)
     {
         typedef typename hpx::util::decay_unwrap<T>::type result_type;
         typedef lcos::detail::timed_future_data<result_type> shared_state;
@@ -1613,17 +1580,15 @@ namespace hpx { namespace lcos
         hpx::intrusive_ptr<shared_state> p(
             new shared_state(abs_time.value(), std::forward<T>(init)));
 
-        return hpx::traits::future_access<future<result_type> >::create(
+        return hpx::traits::future_access<future<result_type>>::create(
             std::move(p));
     }
 
     template <int DeductionGuard = 0, typename T>
-    future<typename hpx::util::decay_unwrap<T>::type>
-    make_ready_future_after(hpx::util::steady_duration const& rel_time,
-        T&& init)
+    future<typename hpx::util::decay_unwrap<T>::type> make_ready_future_after(
+        hpx::util::steady_duration const& rel_time, T&& init)
     {
-        return make_ready_future_at(rel_time.from_now(),
-            std::forward<T>(init));
+        return make_ready_future_at(rel_time.from_now(), std::forward<T>(init));
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -1643,10 +1608,9 @@ namespace hpx { namespace lcos
 
     // Extension (see wg21.link/P0319)
     template <typename T>
-    HPX_FORCEINLINE typename std::enable_if<
-        std::is_void<T>::value, future<void>
-    >::type
-    make_ready_future()
+    HPX_FORCEINLINE
+        typename std::enable_if<std::is_void<T>::value, future<void>>::type
+        make_ready_future()
     {
         return make_ready_future();
     }
@@ -1658,14 +1622,12 @@ namespace hpx { namespace lcos
     {
         typedef lcos::detail::timed_future_data<void> shared_state;
 
-        return hpx::traits::future_access<future<void> >::create(
+        return hpx::traits::future_access<future<void>>::create(
             new shared_state(abs_time.value(), hpx::util::unused));
     }
 
     template <typename T>
-    typename std::enable_if<
-        std::is_void<T>::value, future<void>
-    >::type
+    typename std::enable_if<std::is_void<T>::value, future<void>>::type
     make_ready_future_at(hpx::util::steady_time_point const& abs_time)
     {
         return make_ready_future_at(abs_time);
@@ -1679,52 +1641,47 @@ namespace hpx { namespace lcos
     }
 
     template <typename T>
-    typename std::enable_if<
-        std::is_void<T>::value, future<void>
-    >::type
+    typename std::enable_if<std::is_void<T>::value, future<void>>::type
     make_ready_future_after(hpx::util::steady_duration const& rel_time)
     {
         return make_ready_future_at(rel_time.from_now());
     }
-}}
+}}    // namespace hpx::lcos
 
-namespace hpx { namespace serialization
-{
+namespace hpx { namespace serialization {
     template <typename Archive, typename T>
-    HPX_FORCEINLINE
-    void serialize(Archive& ar, ::hpx::lcos::future<T>& f, unsigned version)
+    HPX_FORCEINLINE void serialize(
+        Archive& ar, ::hpx::lcos::future<T>& f, unsigned version)
     {
         hpx::lcos::detail::serialize_future(ar, f, version);
     }
 
     template <typename Archive, typename T>
-    HPX_FORCEINLINE
-    void serialize(Archive& ar, ::hpx::lcos::shared_future<T>& f, unsigned version)
+    HPX_FORCEINLINE void serialize(
+        Archive& ar, ::hpx::lcos::shared_future<T>& f, unsigned version)
     {
         hpx::lcos::detail::serialize_future(ar, f, version);
     }
-}}
+}}    // namespace hpx::serialization
 
 ///////////////////////////////////////////////////////////////////////////////
 // hoist names into main namespace
-namespace hpx
-{
+namespace hpx {
     using lcos::make_ready_future;
     using lcos::make_ready_future_alloc;
 
     using lcos::make_exceptional_future;
-    using lcos::make_ready_future_at;
     using lcos::make_ready_future_after;
+    using lcos::make_ready_future_at;
 
     using lcos::make_future;
 
     using lcos::make_shared_future;
-}
+}    // namespace hpx
 
 #include <hpx/lcos/local/packaged_continuation.hpp>
 
-#define HPX_MAKE_EXCEPTIONAL_FUTURE(T, errorcode, f, msg)                     \
-    hpx::make_exceptional_future<T>(HPX_GET_EXCEPTION(errorcode, f, msg))     \
-    /**/
+#define HPX_MAKE_EXCEPTIONAL_FUTURE(T, errorcode, f, msg)                      \
+    hpx::make_exceptional_future<T>(HPX_GET_EXCEPTION(errorcode, f, msg)) /**/
 
 #endif
diff --git a/libs/execution/include/hpx/execution/futures_factory.hpp b/libs/execution/include/hpx/execution/futures_factory.hpp
index 6d59b9a0ce5a..628c6f299c02 100644
--- a/libs/execution/include/hpx/execution/futures_factory.hpp
+++ b/libs/execution/include/hpx/execution/futures_factory.hpp
@@ -12,14 +12,14 @@
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/coroutines/thread_enums.hpp>
 #include <hpx/errors.hpp>
-#include <hpx/functional/deferred_call.hpp>
 #include <hpx/execution/detail/future_data.hpp>
 #include <hpx/execution/future.hpp>
+#include <hpx/execution/launch_policy.hpp>
+#include <hpx/execution/traits/future_access.hpp>
+#include <hpx/functional/deferred_call.hpp>
 #include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/runtime/get_worker_thread_num.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/thread_helpers.hpp>
-#include <hpx/execution/traits/future_access.hpp>
 #include <hpx/util/thread_description.hpp>
 
 #include <hpx/execution/executors/execution.hpp>
@@ -103,8 +103,7 @@ namespace hpx { namespace lcos { namespace local {
         protected:
             // run in a separate thread
             threads::thread_id_type apply(threads::thread_pool_base* pool,
-                const char *annotation,
-                launch policy,
+                const char* annotation, launch policy,
                 threads::thread_priority priority,
                 threads::thread_stacksize stacksize,
                 threads::thread_schedule_hint schedulehint,
@@ -248,8 +247,8 @@ namespace hpx { namespace lcos { namespace local {
         protected:
             // run in a separate thread
             threads::thread_id_type apply(threads::thread_pool_base* pool,
-                const char *annotation,
-                launch policy, threads::thread_priority priority,
+                const char* annotation, launch policy,
+                threads::thread_priority priority,
                 threads::thread_stacksize stacksize,
                 threads::thread_schedule_hint schedulehint,
                 error_code& ec) override
@@ -272,8 +271,7 @@ namespace hpx { namespace lcos { namespace local {
                     return threads::register_thread_nullary(pool,
                         util::deferred_call(
                             &base_type::run_impl, std::move(this_)),
-                        util::thread_description(
-                            this->f_, annotation),
+                        util::thread_description(this->f_, annotation),
                         threads::pending_do_not_schedule, true,
                         threads::thread_priority_boost,
                         threads::thread_schedule_hint(
@@ -285,8 +283,7 @@ namespace hpx { namespace lcos { namespace local {
                     threads::register_thread_nullary(pool,
                         util::deferred_call(
                             &base_type::run_impl, std::move(this_)),
-                        util::thread_description(
-                            this->f_, annotation),
+                        util::thread_description(this->f_, annotation),
                         threads::pending, false, priority, schedulehint,
                         stacksize, ec);
                     return threads::invalid_thread_id;
@@ -780,7 +777,7 @@ namespace hpx { namespace lcos { namespace local {
 
         // asynchronous execution
         threads::thread_id_type apply(
-            const char *annotation = "futures_factory::apply",
+            const char* annotation = "futures_factory::apply",
             launch policy = launch::async,
             threads::thread_priority priority =
                 threads::thread_priority_default,
@@ -791,12 +788,11 @@ namespace hpx { namespace lcos { namespace local {
             error_code& ec = throws) const
         {
             return apply(threads::detail::get_self_or_default_pool(),
-                annotation, policy,
-                priority, stacksize, schedulehint, ec);
+                annotation, policy, priority, stacksize, schedulehint, ec);
         }
 
         threads::thread_id_type apply(threads::thread_pool_base* pool,
-            const char *annotation = "futures_factory::apply",
+            const char* annotation = "futures_factory::apply",
             launch policy = launch::async,
             threads::thread_priority priority =
                 threads::thread_priority_default,
@@ -813,8 +809,8 @@ namespace hpx { namespace lcos { namespace local {
                     "futures_factory invalid (has it been moved?)");
                 return threads::invalid_thread_id;
             }
-            return task_->apply(
-                pool, annotation, policy, priority, stacksize, schedulehint, ec);
+            return task_->apply(pool, annotation, policy, priority, stacksize,
+                schedulehint, ec);
         }
 
         // This is the same as get_future, except that it moves the
diff --git a/libs/execution/include/hpx/execution/launch_policy.hpp b/libs/execution/include/hpx/execution/launch_policy.hpp
index 810d48b960c7..0f60f61f9098 100644
--- a/libs/execution/include/hpx/execution/launch_policy.hpp
+++ b/libs/execution/include/hpx/execution/launch_policy.hpp
@@ -16,34 +16,33 @@
 #include <type_traits>
 #include <utility>
 
-namespace hpx
-{
+namespace hpx {
     /// \cond NOINTERNAL
-    namespace detail
-    {
+    namespace detail {
         enum class launch_policy
         {
             async = 0x01,
             deferred = 0x02,
-            task = 0x04,  // see N3632
+            task = 0x04,    // see N3632
             sync = 0x08,
-            fork = 0x10,  // same as async, but forces continuation stealing
+            fork = 0x10,    // same as async, but forces continuation stealing
             apply = 0x20,
 
-            sync_policies = 0x0a,       // sync | deferred
-            async_policies = 0x15,      // async | task | fork
-            all = 0x3f                  // async | deferred | task | sync |
-                                        // fork | apply
+            sync_policies = 0x0a,     // sync | deferred
+            async_policies = 0x15,    // async | task | fork
+            all = 0x3f                // async | deferred | task | sync |
+                                      // fork | apply
         };
 
         struct policy_holder_base
         {
             HPX_CONSTEXPR explicit policy_holder_base(launch_policy p,
-                    threads::thread_priority priority =
-                        threads::thread_priority_default) noexcept
-              : policy_(p),
-                priority_(priority)
-            {}
+                threads::thread_priority priority =
+                    threads::thread_priority_default) noexcept
+              : policy_(p)
+              , priority_(priority)
+            {
+            }
 
             HPX_CONSTEXPR explicit operator bool() const noexcept
             {
@@ -72,7 +71,8 @@ namespace hpx
             friend class serialization::access;
 
             HPX_EXPORT void load(serialization::input_archive& ar, unsigned);
-            HPX_EXPORT void save(serialization::output_archive& ar, unsigned) const;
+            HPX_EXPORT void save(
+                serialization::output_archive& ar, unsigned) const;
 
             HPX_SERIALIZATION_SPLIT_MEMBER()
         };
@@ -82,14 +82,16 @@ namespace hpx
         struct policy_holder : policy_holder_base
         {
             HPX_CONSTEXPR explicit policy_holder(launch_policy p,
-                    threads::thread_priority priority =
-                        threads::thread_priority_default) noexcept
+                threads::thread_priority priority =
+                    threads::thread_priority_default) noexcept
               : policy_holder_base(p, priority)
-            {}
+            {
+            }
 
             HPX_CONSTEXPR explicit policy_holder(policy_holder_base p) noexcept
               : policy_holder_base(p)
-            {}
+            {
+            }
 
             HPX_CONSTEXPR operator launch_policy() const noexcept
             {
@@ -115,14 +117,16 @@ namespace hpx
         struct policy_holder<void> : policy_holder_base
         {
             HPX_CONSTEXPR explicit policy_holder(launch_policy p,
-                    threads::thread_priority priority =
-                        threads::thread_priority_default) noexcept
+                threads::thread_priority priority =
+                    threads::thread_priority_default) noexcept
               : policy_holder_base(p, priority)
-            {}
+            {
+            }
 
             HPX_CONSTEXPR explicit policy_holder(policy_holder_base p) noexcept
               : policy_holder_base(p)
-            {}
+            {
+            }
 
             HPX_CONSTEXPR operator launch_policy() const noexcept
             {
@@ -148,10 +152,11 @@ namespace hpx
         struct async_policy : policy_holder<async_policy>
         {
             HPX_CONSTEXPR explicit async_policy(
-                    threads::thread_priority priority =
-                        threads::thread_priority_default) noexcept
+                threads::thread_priority priority =
+                    threads::thread_priority_default) noexcept
               : policy_holder<async_policy>(launch_policy::async, priority)
-            {}
+            {
+            }
 
             HPX_CONSTEXPR async_policy operator()(
                 threads::thread_priority priority) const noexcept
@@ -163,10 +168,11 @@ namespace hpx
         struct fork_policy : policy_holder<fork_policy>
         {
             HPX_CONSTEXPR explicit fork_policy(
-                    threads::thread_priority priority =
-                        threads::thread_priority_boost) noexcept
+                threads::thread_priority priority =
+                    threads::thread_priority_boost) noexcept
               : policy_holder<fork_policy>(launch_policy::fork, priority)
-            {}
+            {
+            }
 
             HPX_CONSTEXPR fork_policy operator()(
                 threads::thread_priority priority) const noexcept
@@ -179,25 +185,28 @@ namespace hpx
         {
             HPX_CONSTEXPR sync_policy() noexcept
               : policy_holder<sync_policy>(launch_policy::sync)
-            {}
+            {
+            }
         };
 
         struct deferred_policy : policy_holder<deferred_policy>
         {
             HPX_CONSTEXPR deferred_policy() noexcept
               : policy_holder<deferred_policy>(launch_policy::deferred)
-            {}
+            {
+            }
         };
 
         struct apply_policy : policy_holder<apply_policy>
         {
             HPX_CONSTEXPR apply_policy() noexcept
               : policy_holder<apply_policy>(launch_policy::apply)
-            {}
+            {
+            }
         };
 
         template <typename Pred>
-        struct select_policy : policy_holder<select_policy<Pred> >
+        struct select_policy : policy_holder<select_policy<Pred>>
         {
             template <typename F,
                 typename U =
@@ -209,7 +218,8 @@ namespace hpx
               : policy_holder<select_policy<Pred>>(
                     launch_policy::async, priority)
               , pred_(std::forward<F>(f))
-            {}
+            {
+            }
 
             HPX_CONSTEXPR launch_policy get_policy() const
             {
@@ -234,7 +244,7 @@ namespace hpx
             }
 
             template <typename F>
-            select_policy<typename std::decay<F>::type> operator()(F && f,
+            select_policy<typename std::decay<F>::type> operator()(F&& f,
                 threads::thread_priority priority =
                     threads::thread_priority_default) const
             {
@@ -250,10 +260,8 @@ namespace hpx
             policy_holder<Right> const& rhs) noexcept
         {
             return policy_holder_base(
-                static_cast<launch_policy>(
-                    static_cast<int>(lhs.policy()) &
-                        static_cast<int>(rhs.policy())
-                ));
+                static_cast<launch_policy>(static_cast<int>(lhs.policy()) &
+                    static_cast<int>(rhs.policy())));
         }
 
         template <typename Left, typename Right>
@@ -262,10 +270,8 @@ namespace hpx
             policy_holder<Right> const& rhs) noexcept
         {
             return policy_holder_base(
-                static_cast<launch_policy>(
-                    static_cast<int>(lhs.policy()) |
-                        static_cast<int>(rhs.policy())
-                ));
+                static_cast<launch_policy>(static_cast<int>(lhs.policy()) |
+                    static_cast<int>(rhs.policy())));
         }
 
         template <typename Left, typename Right>
@@ -274,20 +280,16 @@ namespace hpx
             policy_holder<Right> const& rhs) noexcept
         {
             return policy_holder_base(
-                static_cast<launch_policy>(
-                    static_cast<int>(lhs.policy()) ^
-                        static_cast<int>(rhs.policy())
-                ));
+                static_cast<launch_policy>(static_cast<int>(lhs.policy()) ^
+                    static_cast<int>(rhs.policy())));
         }
 
         template <typename Derived>
-        HPX_CONSTEXPR inline policy_holder<Derived>
-        operator~(policy_holder<Derived> const& p) noexcept
+        HPX_CONSTEXPR inline policy_holder<Derived> operator~(
+            policy_holder<Derived> const& p) noexcept
         {
             return policy_holder<Derived>(
-                static_cast<launch_policy>(
-                    ~static_cast<int>(p.policy())
-                ));
+                static_cast<launch_policy>(~static_cast<int>(p.policy())));
         }
 
         template <typename Left, typename Right>
@@ -318,7 +320,8 @@ namespace hpx
         HPX_CONSTEXPR inline bool operator==(policy_holder<Left> const& lhs,
             policy_holder<Right> const& rhs) noexcept
         {
-            return static_cast<int>(lhs.policy()) == static_cast<int>(rhs.policy());
+            return static_cast<int>(lhs.policy()) ==
+                static_cast<int>(rhs.policy());
         }
 
         template <typename Left, typename Right>
@@ -327,7 +330,7 @@ namespace hpx
         {
             return !(lhs == rhs);
         }
-    }
+    }    // namespace detail
     /// \endcond
 
     ///////////////////////////////////////////////////////////////////////////
@@ -339,50 +342,59 @@ namespace hpx
         /// possible launch modes
         HPX_CONSTEXPR launch() noexcept
           : detail::policy_holder<>{detail::launch_policy::all}
-        {}
+        {
+        }
 
         /// \cond NOINTERNAL
         template <typename Derived>
         HPX_CONSTEXPR launch(detail::policy_holder<Derived> const& ph) noexcept
           : detail::policy_holder<>{ph}
-        {}
+        {
+        }
 
         HPX_CONSTEXPR launch(detail::policy_holder_base const& ph) noexcept
           : detail::policy_holder<>{ph}
-        {}
+        {
+        }
         /// \endcond
 
         /// Create a launch policy representing asynchronous execution
         HPX_CONSTEXPR launch(detail::async_policy) noexcept
           : detail::policy_holder<>{detail::launch_policy::async}
-        {}
+        {
+        }
 
         /// Create a launch policy representing asynchronous execution. The
         /// new thread is executed in a preferred way
         HPX_CONSTEXPR launch(detail::fork_policy) noexcept
           : detail::policy_holder<>{detail::launch_policy::fork}
-        {}
+        {
+        }
 
         /// Create a launch policy representing synchronous execution
         HPX_CONSTEXPR launch(detail::sync_policy) noexcept
           : detail::policy_holder<>{detail::launch_policy::sync}
-        {}
+        {
+        }
 
         /// Create a launch policy representing deferred execution
         HPX_CONSTEXPR launch(detail::deferred_policy) noexcept
           : detail::policy_holder<>{detail::launch_policy::deferred}
-        {}
+        {
+        }
 
         /// Create a launch policy representing fire and forget execution
         HPX_CONSTEXPR launch(detail::apply_policy) noexcept
           : detail::policy_holder<>{detail::launch_policy::apply}
-        {}
+        {
+        }
 
         /// Create a launch policy representing fire and forget execution
         template <typename F>
         HPX_CONSTEXPR launch(detail::select_policy<F> const& p) noexcept
           : detail::policy_holder<>{p.policy()}
-        {}
+        {
+        }
 
         ///////////////////////////////////////////////////////////////////////
         /// \cond NOINTERNAL
@@ -424,28 +436,22 @@ namespace hpx
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    namespace detail
-    {
-        HPX_FORCEINLINE HPX_CONSTEXPR
-        bool has_async_policy(launch p) noexcept
+    namespace detail {
+        HPX_FORCEINLINE HPX_CONSTEXPR bool has_async_policy(launch p) noexcept
         {
-            return bool(
-                static_cast<int>(p.get_policy()) &
-                    static_cast<int>(detail::launch_policy::async_policies)
-            );
+            return bool(static_cast<int>(p.get_policy()) &
+                static_cast<int>(detail::launch_policy::async_policies));
         }
 
         template <typename F>
-        HPX_FORCEINLINE HPX_CONSTEXPR
-        bool has_async_policy(detail::policy_holder<F> const& p) noexcept
+        HPX_FORCEINLINE HPX_CONSTEXPR bool has_async_policy(
+            detail::policy_holder<F> const& p) noexcept
         {
-            return bool(
-                static_cast<int>(p.policy()) &
-                    static_cast<int>(detail::launch_policy::async_policies)
-            );
+            return bool(static_cast<int>(p.policy()) &
+                static_cast<int>(detail::launch_policy::async_policies));
         }
-    }
+    }    // namespace detail
     /// \endcond
-}
+}    // namespace hpx
 
 #endif
diff --git a/libs/execution/include/hpx/execution/split_future.hpp b/libs/execution/include/hpx/execution/split_future.hpp
index 6dae011b0909..d379c83416f5 100644
--- a/libs/execution/include/hpx/execution/split_future.hpp
+++ b/libs/execution/include/hpx/execution/split_future.hpp
@@ -10,8 +10,7 @@
 #define HPX_LCOS_SPLIT_FUTURE_JUL_08_2016_0824AM
 
 #if defined(DOXYGEN)
-namespace hpx
-{
+namespace hpx {
     /// The function \a split_future is an operator allowing to split a given
     /// future of a sequence of values (any tuple, std::pair, or std::array)
     /// into an equivalent container of futures where each future represents
@@ -38,9 +37,8 @@ namespace hpx
     ///             here the returned futures are directly representing the
     ///             futures which were passed to the function.
     ///
-    template <typename ... Ts>
-    inline tuple<future<Ts>...>
-    split_future(future<tuple<Ts...> > && f);
+    template <typename... Ts>
+    inline tuple<future<Ts>...> split_future(future<tuple<Ts...>>&& f);
 
     /// The function \a split_future is an operator allowing to split a given
     /// future of a sequence of values (any std::vector)
@@ -60,25 +58,25 @@ namespace hpx
     ///             futures will be exceptional as well.
     ///
     template <typename T>
-    inline std::vector<future<T>>
-    split_future(future<std::vector<T> > && f, std::size_t size);
-}
+    inline std::vector<future<T>> split_future(
+        future<std::vector<T>>&& f, std::size_t size);
+}    // namespace hpx
 
-#else // DOXYGEN
+#else    // DOXYGEN
 
 #include <hpx/config.hpp>
 #include <hpx/datastructures/detail/pack.hpp>
 #include <hpx/datastructures/tuple.hpp>
 #include <hpx/errors.hpp>
-#include <hpx/functional/deferred_call.hpp>
 #include <hpx/execution/detail/future_data.hpp>
 #include <hpx/execution/future.hpp>
-#include <hpx/lcos/local/packaged_continuation.hpp>
-#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/execution/traits/acquire_future.hpp>
 #include <hpx/execution/traits/acquire_shared_state.hpp>
 #include <hpx/execution/traits/future_access.hpp>
 #include <hpx/execution/traits/future_traits.hpp>
+#include <hpx/functional/deferred_call.hpp>
+#include <hpx/lcos/local/packaged_continuation.hpp>
+#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/type_support/unused.hpp>
 
 #include <array>
@@ -91,10 +89,8 @@ namespace hpx
 #if !defined(HPX_COMPUTE_DEVICE_CODE)
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace hpx { namespace lcos
-{
-    namespace detail
-    {
+namespace hpx { namespace lcos {
+    namespace detail {
         ///////////////////////////////////////////////////////////////////////
         template <typename ContResult>
         class split_nth_continuation : public future_data<ContResult>
@@ -107,13 +103,15 @@ namespace hpx { namespace lcos
                 typename traits::detail::shared_state_ptr_for<T>::type const&
                     state)
             {
-                try {
+                try
+                {
                     typedef typename traits::future_traits<T>::type result_type;
                     result_type* result = state->get_result();
                     this->base_type::set_value(
                         std::move(hpx::util::get<I>(*result)));
                 }
-                catch (...) {
+                catch (...)
+                {
                     this->base_type::set_exception(std::current_exception());
                 }
             }
@@ -124,7 +122,7 @@ namespace hpx { namespace lcos
             {
                 typedef
                     typename traits::detail::shared_state_ptr_for<Future>::type
-                    shared_state_ptr;
+                        shared_state_ptr;
 
                 // Bind an on_completed handler to this future which will wait
                 // for the future and will transfer its result to the new
@@ -141,16 +139,16 @@ namespace hpx { namespace lcos
         };
 
         ///////////////////////////////////////////////////////////////////////
-        template <typename Result, typename Tuple, std::size_t I, typename Future>
+        template <typename Result, typename Tuple, std::size_t I,
+            typename Future>
         inline typename hpx::traits::detail::shared_state_ptr<
-            typename hpx::util::tuple_element<I, Tuple>::type
-        >::type
+            typename hpx::util::tuple_element<I, Tuple>::type>::type
         extract_nth_continuation(Future& future)
         {
             typedef split_nth_continuation<Result> shared_state;
 
-            typename hpx::traits::detail::shared_state_ptr<Result>::type
-                p(new shared_state());
+            typename hpx::traits::detail::shared_state_ptr<Result>::type p(
+                new shared_state());
 
             static_cast<shared_state*>(p.get())->template attach<I>(future);
             return p;
@@ -159,48 +157,40 @@ namespace hpx { namespace lcos
         ///////////////////////////////////////////////////////////////////////
         template <std::size_t I, typename Tuple>
         HPX_FORCEINLINE
-        hpx::future<typename hpx::util::tuple_element<I, Tuple>::type>
-        extract_nth_future(hpx::future<Tuple>& future)
+            hpx::future<typename hpx::util::tuple_element<I, Tuple>::type>
+            extract_nth_future(hpx::future<Tuple>& future)
         {
-            typedef typename hpx::util::tuple_element<
-                    I, Tuple
-                >::type result_type;
-
-            return hpx::traits::future_access<
-                    hpx::future<result_type>
-                >::create(
-                    extract_nth_continuation<result_type, Tuple, I>(future));
+            typedef
+                typename hpx::util::tuple_element<I, Tuple>::type result_type;
+
+            return hpx::traits::future_access<hpx::future<result_type>>::create(
+                extract_nth_continuation<result_type, Tuple, I>(future));
         }
 
         template <std::size_t I, typename Tuple>
         HPX_FORCEINLINE
-        hpx::future<typename hpx::util::tuple_element<I, Tuple>::type>
-        extract_nth_future(hpx::shared_future<Tuple>& future)
+            hpx::future<typename hpx::util::tuple_element<I, Tuple>::type>
+            extract_nth_future(hpx::shared_future<Tuple>& future)
         {
-            typedef typename hpx::util::tuple_element<
-                    I, Tuple
-                >::type result_type;
-
-            return hpx::traits::future_access<
-                    hpx::future<result_type>
-                >::create(
-                    extract_nth_continuation<result_type, Tuple, I>(future));
+            typedef
+                typename hpx::util::tuple_element<I, Tuple>::type result_type;
+
+            return hpx::traits::future_access<hpx::future<result_type>>::create(
+                extract_nth_continuation<result_type, Tuple, I>(future));
         }
 
         ///////////////////////////////////////////////////////////////////////
-        template <typename ... Ts, std::size_t ... Is>
-        HPX_FORCEINLINE
-        hpx::util::tuple<hpx::future<Ts>...>
-        split_future_helper(hpx::future<hpx::util::tuple<Ts...> > && f,
+        template <typename... Ts, std::size_t... Is>
+        HPX_FORCEINLINE hpx::util::tuple<hpx::future<Ts>...>
+        split_future_helper(hpx::future<hpx::util::tuple<Ts...>>&& f,
             hpx::util::detail::pack_c<std::size_t, Is...>)
         {
             return hpx::util::make_tuple(extract_nth_future<Is>(f)...);
         }
 
-        template <typename ... Ts, std::size_t ... Is>
-        HPX_FORCEINLINE
-        hpx::util::tuple<hpx::future<Ts>...>
-        split_future_helper(hpx::shared_future<hpx::util::tuple<Ts...> > && f,
+        template <typename... Ts, std::size_t... Is>
+        HPX_FORCEINLINE hpx::util::tuple<hpx::future<Ts>...>
+        split_future_helper(hpx::shared_future<hpx::util::tuple<Ts...>>&& f,
             hpx::util::detail::pack_c<std::size_t, Is...>)
         {
             return hpx::util::make_tuple(extract_nth_future<Is>(f)...);
@@ -208,21 +198,19 @@ namespace hpx { namespace lcos
 
         ///////////////////////////////////////////////////////////////////////
         template <typename T1, typename T2>
-        HPX_FORCEINLINE
-        std::pair<hpx::future<T1>, hpx::future<T2> >
-        split_future_helper(hpx::future<std::pair<T1, T2> > && f)
+        HPX_FORCEINLINE std::pair<hpx::future<T1>, hpx::future<T2>>
+        split_future_helper(hpx::future<std::pair<T1, T2>>&& f)
         {
-            return std::make_pair(extract_nth_future<0>(f),
-                extract_nth_future<1>(f));
+            return std::make_pair(
+                extract_nth_future<0>(f), extract_nth_future<1>(f));
         }
 
         template <typename T1, typename T2>
-        HPX_FORCEINLINE
-        std::pair<hpx::future<T1>, hpx::future<T2> >
-        split_future_helper(hpx::shared_future<std::pair<T1, T2> > && f)
+        HPX_FORCEINLINE std::pair<hpx::future<T1>, hpx::future<T2>>
+        split_future_helper(hpx::shared_future<std::pair<T1, T2>>&& f)
         {
-            return std::make_pair(extract_nth_future<0>(f),
-                extract_nth_future<1>(f));
+            return std::make_pair(
+                extract_nth_future<0>(f), extract_nth_future<1>(f));
         }
 
         ///////////////////////////////////////////////////////////////////////
@@ -233,12 +221,12 @@ namespace hpx { namespace lcos
 
         private:
             template <typename T>
-            void on_ready(
-                std::size_t i,
+            void on_ready(std::size_t i,
                 typename traits::detail::shared_state_ptr_for<T>::type const&
                     state)
             {
-                try {
+                try
+                {
                     typedef typename traits::future_traits<T>::type result_type;
                     result_type* result = state->get_result();
                     if (i >= result->size())
@@ -249,7 +237,8 @@ namespace hpx { namespace lcos
                     }
                     this->base_type::set_value(std::move((*result)[i]));
                 }
-                catch (...) {
+                catch (...)
+                {
                     this->base_type::set_exception(std::current_exception());
                 }
             }
@@ -260,7 +249,7 @@ namespace hpx { namespace lcos
             {
                 typedef
                     typename traits::detail::shared_state_ptr_for<Future>::type
-                    shared_state_ptr;
+                        shared_state_ptr;
 
                 // Bind an on_completed handler to this future which will wait
                 // for the future and will transfer its result to the new
@@ -270,28 +259,28 @@ namespace hpx { namespace lcos
                     hpx::traits::detail::get_shared_state(future);
 
                 state->execute_deferred();
-                state->set_on_completed(util::deferred_call(
-                    &split_continuation::on_ready<Future>, std::move(this_),
-                    i, state));
+                state->set_on_completed(
+                    util::deferred_call(&split_continuation::on_ready<Future>,
+                        std::move(this_), i, state));
             }
         };
 
         template <typename T, typename Future>
-        inline hpx::future<T>
-        extract_future_array(std::size_t i, Future& future)
+        inline hpx::future<T> extract_future_array(
+            std::size_t i, Future& future)
         {
             typedef split_continuation<T> shared_state;
 
-            typename hpx::traits::detail::shared_state_ptr<T>::type
-                p(new shared_state());
+            typename hpx::traits::detail::shared_state_ptr<T>::type p(
+                new shared_state());
 
             static_cast<shared_state*>(p.get())->attach(i, future);
-            return hpx::traits::future_access<hpx::future<T> >::create(p);
+            return hpx::traits::future_access<hpx::future<T>>::create(p);
         }
 
         template <std::size_t N, typename T, typename Future>
-        inline std::array<hpx::future<T>, N>
-        split_future_helper_array(Future && f)
+        inline std::array<hpx::future<T>, N> split_future_helper_array(
+            Future&& f)
         {
             std::array<hpx::future<T>, N> result;
 
@@ -302,10 +291,10 @@ namespace hpx { namespace lcos
         }
 
         template <typename T, typename Future>
-        inline std::vector<hpx::future<T> >
-        split_future_helper_vector(Future && f, std::size_t size)
+        inline std::vector<hpx::future<T>> split_future_helper_vector(
+            Future&& f, std::size_t size)
         {
-            std::vector<hpx::future<T> > result;
+            std::vector<hpx::future<T>> result;
             result.reserve(size);
 
             for (std::size_t i = 0; i != size; ++i)
@@ -313,67 +302,63 @@ namespace hpx { namespace lcos
 
             return result;
         }
-    }
+    }    // namespace detail
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename ... Ts>
-    HPX_FORCEINLINE hpx::util::tuple<hpx::future<Ts>...>
-    split_future(hpx::future<hpx::util::tuple<Ts...> > && f)
+    template <typename... Ts>
+    HPX_FORCEINLINE hpx::util::tuple<hpx::future<Ts>...> split_future(
+        hpx::future<hpx::util::tuple<Ts...>>&& f)
     {
-        return detail::split_future_helper(
-                std::move(f),
-                typename hpx::util::detail::make_index_pack<sizeof...(Ts)>::type()
-            );
+        return detail::split_future_helper(std::move(f),
+            typename hpx::util::detail::make_index_pack<sizeof...(Ts)>::type());
     }
 
-    HPX_FORCEINLINE hpx::util::tuple<hpx::future<void> >
-    split_future(hpx::future<hpx::util::tuple<> > && f)
+    HPX_FORCEINLINE hpx::util::tuple<hpx::future<void>> split_future(
+        hpx::future<hpx::util::tuple<>>&& f)
     {
         return hpx::util::make_tuple(hpx::future<void>(std::move(f)));
     }
 
-    template <typename ... Ts>
-    HPX_FORCEINLINE hpx::util::tuple<hpx::future<Ts>...>
-    split_future(hpx::shared_future<hpx::util::tuple<Ts...> > && f)
+    template <typename... Ts>
+    HPX_FORCEINLINE hpx::util::tuple<hpx::future<Ts>...> split_future(
+        hpx::shared_future<hpx::util::tuple<Ts...>>&& f)
     {
-        return detail::split_future_helper(
-                std::move(f),
-                typename hpx::util::detail::make_index_pack<sizeof...(Ts)>::type()
-            );
+        return detail::split_future_helper(std::move(f),
+            typename hpx::util::detail::make_index_pack<sizeof...(Ts)>::type());
     }
 
-    HPX_FORCEINLINE hpx::util::tuple<hpx::future<void> >
-    split_future(hpx::shared_future<hpx::util::tuple<> > && f)
+    HPX_FORCEINLINE hpx::util::tuple<hpx::future<void>> split_future(
+        hpx::shared_future<hpx::util::tuple<>>&& f)
     {
         return hpx::util::make_tuple(hpx::make_future<void>(std::move(f)));
     }
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename T1, typename T2>
-    HPX_FORCEINLINE std::pair<hpx::future<T1>, hpx::future<T2> >
-    split_future(hpx::future<std::pair<T1, T2> > && f)
+    HPX_FORCEINLINE std::pair<hpx::future<T1>, hpx::future<T2>> split_future(
+        hpx::future<std::pair<T1, T2>>&& f)
     {
         return detail::split_future_helper(std::move(f));
     }
 
     template <typename T1, typename T2>
-    HPX_FORCEINLINE std::pair<hpx::future<T1>, hpx::future<T2> >
-    split_future(hpx::shared_future<std::pair<T1, T2> > && f)
+    HPX_FORCEINLINE std::pair<hpx::future<T1>, hpx::future<T2>> split_future(
+        hpx::shared_future<std::pair<T1, T2>>&& f)
     {
         return detail::split_future_helper(std::move(f));
     }
 
     ///////////////////////////////////////////////////////////////////////////
     template <std::size_t N, typename T>
-    HPX_FORCEINLINE std::array<hpx::future<T>, N>
-    split_future(hpx::future<std::array<T, N> > && f)
+    HPX_FORCEINLINE std::array<hpx::future<T>, N> split_future(
+        hpx::future<std::array<T, N>>&& f)
     {
         return detail::split_future_helper_array<N, T>(std::move(f));
     }
 
     template <typename T>
-    HPX_FORCEINLINE std::array<hpx::future<void>, 1>
-    split_future(hpx::future<std::array<T, 0> > && f)
+    HPX_FORCEINLINE std::array<hpx::future<void>, 1> split_future(
+        hpx::future<std::array<T, 0>>&& f)
     {
         std::array<hpx::future<void>, 1> result;
         result[0] = hpx::future<void>(std::move(f));
@@ -381,15 +366,15 @@ namespace hpx { namespace lcos
     }
 
     template <std::size_t N, typename T>
-    HPX_FORCEINLINE std::array<hpx::future<T>, N>
-    split_future(hpx::shared_future<std::array<T, N> > && f)
+    HPX_FORCEINLINE std::array<hpx::future<T>, N> split_future(
+        hpx::shared_future<std::array<T, N>>&& f)
     {
         return detail::split_future_helper_array<N, T>(std::move(f));
     }
 
     template <typename T>
-    HPX_FORCEINLINE std::array<hpx::future<void>, 1>
-    split_future(hpx::shared_future<std::array<T, 0> > && f)
+    HPX_FORCEINLINE std::array<hpx::future<void>, 1> split_future(
+        hpx::shared_future<std::array<T, 0>>&& f)
     {
         std::array<hpx::future<void>, 1> result;
         result[0] = hpx::make_future<void>(std::move(f));
@@ -398,22 +383,21 @@ namespace hpx { namespace lcos
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename T>
-    HPX_FORCEINLINE std::vector<hpx::future<T> >
-    split_future(hpx::future<std::vector<T> > && f, std::size_t size)
+    HPX_FORCEINLINE std::vector<hpx::future<T>> split_future(
+        hpx::future<std::vector<T>>&& f, std::size_t size)
     {
         return detail::split_future_helper_vector<T>(std::move(f), size);
     }
 
     template <typename T>
-    HPX_FORCEINLINE std::vector<hpx::future<T> >
-    split_future(hpx::shared_future<std::vector<T> > && f, std::size_t size)
+    HPX_FORCEINLINE std::vector<hpx::future<T>> split_future(
+        hpx::shared_future<std::vector<T>>&& f, std::size_t size)
     {
         return detail::split_future_helper_vector<T>(std::move(f), size);
     }
-}}
+}}    // namespace hpx::lcos
 
-namespace hpx
-{
+namespace hpx {
     using lcos::split_future;
 }
 #endif
diff --git a/libs/execution/include/hpx/execution/traits/acquire_future.hpp b/libs/execution/include/hpx/execution/traits/acquire_future.hpp
index 98fe6e9092ba..84715a44f113 100644
--- a/libs/execution/include/hpx/execution/traits/acquire_future.hpp
+++ b/libs/execution/include/hpx/execution/traits/acquire_future.hpp
@@ -9,25 +9,22 @@
 #define HPX_TRAITS_ACQUIRE_FUTURE_HPP
 
 #include <hpx/config.hpp>
-#include <hpx/iterator_support/range.hpp>
-#include <hpx/util/detail/reserve.hpp>
 #include <hpx/concepts/has_member_xxx.hpp>
 #include <hpx/execution/traits/is_future.hpp>
 #include <hpx/execution/traits/is_future_range.hpp>
+#include <hpx/iterator_support/range.hpp>
 #include <hpx/iterator_support/traits/is_range.hpp>
+#include <hpx/util/detail/reserve.hpp>
 
 #include <algorithm>
 #include <array>
 #include <cstddef>
-#include <cstddef>
 #include <iterator>
 #include <type_traits>
 #include <utility>
 
-namespace hpx { namespace traits
-{
-    namespace detail
-    {
+namespace hpx { namespace traits {
+    namespace detail {
         template <typename T, typename Enable = void>
         struct acquire_future_impl;
     }
@@ -35,20 +32,19 @@ namespace hpx { namespace traits
     template <typename T, typename Enable = void>
     struct acquire_future
       : detail::acquire_future_impl<typename std::decay<T>::type>
-    {};
+    {
+    };
 
     struct acquire_future_disp
     {
         template <typename T>
-        HPX_FORCEINLINE typename acquire_future<T>::type
-        operator()(T && t) const
+        HPX_FORCEINLINE typename acquire_future<T>::type operator()(T&& t) const
         {
             return acquire_future<T>()(std::forward<T>(t));
         }
     };
 
-    namespace detail
-    {
+    namespace detail {
         ///////////////////////////////////////////////////////////////////////
         template <typename T, typename Enable>
         struct acquire_future_impl
@@ -58,8 +54,7 @@ namespace hpx { namespace traits
             typedef T type;
 
             template <typename T_>
-            HPX_FORCEINLINE
-            T operator()(T_ && value) const
+            HPX_FORCEINLINE T operator()(T_&& value) const
             {
                 return std::forward<T_>(value);
             }
@@ -67,36 +62,36 @@ namespace hpx { namespace traits
 
         ///////////////////////////////////////////////////////////////////////
         template <typename R>
-        struct acquire_future_impl<hpx::lcos::future<R> >
+        struct acquire_future_impl<hpx::lcos::future<R>>
         {
             typedef hpx::lcos::future<R> type;
 
-            HPX_FORCEINLINE hpx::lcos::future<R>
-            operator()(hpx::lcos::future<R>& future) const
+            HPX_FORCEINLINE hpx::lcos::future<R> operator()(
+                hpx::lcos::future<R>& future) const
             {
                 return std::move(future);
             }
 
-            HPX_FORCEINLINE hpx::lcos::future<R>
-            operator()(hpx::lcos::future<R>&& future) const
+            HPX_FORCEINLINE hpx::lcos::future<R> operator()(
+                hpx::lcos::future<R>&& future) const
             {
                 return std::move(future);
             }
         };
 
         template <typename R>
-        struct acquire_future_impl<hpx::lcos::shared_future<R> >
+        struct acquire_future_impl<hpx::lcos::shared_future<R>>
         {
             typedef hpx::lcos::shared_future<R> type;
 
-            HPX_FORCEINLINE hpx::lcos::shared_future<R>
-            operator()(hpx::lcos::shared_future<R> const& future) const
+            HPX_FORCEINLINE hpx::lcos::shared_future<R> operator()(
+                hpx::lcos::shared_future<R> const& future) const
             {
                 return future;
             }
 
-            HPX_FORCEINLINE hpx::lcos::shared_future<R>
-            operator()(hpx::lcos::shared_future<R>&& future) const
+            HPX_FORCEINLINE hpx::lcos::shared_future<R> operator()(
+                hpx::lcos::shared_future<R>&& future) const
             {
                 return std::move(future);
             }
@@ -107,12 +102,9 @@ namespace hpx { namespace traits
 
         ///////////////////////////////////////////////////////////////////////
         template <typename Range>
-        struct acquire_future_impl<
-            Range,
+        struct acquire_future_impl<Range,
             typename std::enable_if<
-                traits::is_future_range<Range>::value
-            >::type
-        >
+                traits::is_future_range<Range>::value>::type>
         {
             typedef typename traits::future_range_traits<Range>::future_type
                 future_type;
@@ -121,21 +113,18 @@ namespace hpx { namespace traits
 
             template <typename Range_>
             typename std::enable_if<
-                has_push_back<typename std::decay<Range_>::type>::value
-            >::type
-            transform_future_disp(Range_ && futures, Range& values) const
+                has_push_back<typename std::decay<Range_>::type>::value>::type
+            transform_future_disp(Range_&& futures, Range& values) const
             {
                 detail::reserve_if_random_access_by_range(values, futures);
-                std::transform(
-                    util::begin(futures), util::end(futures),
+                std::transform(util::begin(futures), util::end(futures),
                     std::back_inserter(values), acquire_future_disp());
             }
 
             template <typename Range_>
             typename std::enable_if<
-                !has_push_back<typename std::decay<Range_>::type>::value
-            >::type
-            transform_future_disp(Range_ && futures, Range& values) const
+                !has_push_back<typename std::decay<Range_>::type>::value>::type
+            transform_future_disp(Range_&& futures, Range& values) const
             {
                 detail::reserve_if_random_access_by_range(values, futures);
                 std::transform(util::begin(futures), util::end(futures),
@@ -143,15 +132,14 @@ namespace hpx { namespace traits
             }
 
             template <typename Range_>
-            HPX_FORCEINLINE Range
-            operator()(Range_ && futures) const
+            HPX_FORCEINLINE Range operator()(Range_&& futures) const
             {
                 Range values;
                 transform_future_disp(std::forward<Range_>(futures), values);
                 return values;
             }
         };
-    }
-}}
+    }    // namespace detail
+}}       // namespace hpx::traits
 
 #endif /*HPX_TRAITS_ACQUIRE_FUTURE_HPP*/
diff --git a/libs/execution/include/hpx/execution/traits/acquire_shared_state.hpp b/libs/execution/include/hpx/execution/traits/acquire_shared_state.hpp
index accad830da67..f8e08930a7c0 100644
--- a/libs/execution/include/hpx/execution/traits/acquire_shared_state.hpp
+++ b/libs/execution/include/hpx/execution/traits/acquire_shared_state.hpp
@@ -9,13 +9,13 @@
 #define HPX_TRAITS_ACQUIRE_SHARED_STATE_HPP
 
 #include <hpx/config.hpp>
-#include <hpx/iterator_support/traits/is_range.hpp>
-#include <hpx/iterator_support/range.hpp>
-#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/execution/traits/future_access.hpp>
 #include <hpx/execution/traits/future_traits.hpp>
 #include <hpx/execution/traits/is_future.hpp>
 #include <hpx/execution/traits/is_future_range.hpp>
+#include <hpx/iterator_support/range.hpp>
+#include <hpx/iterator_support/traits/is_range.hpp>
+#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/util/detail/reserve.hpp>
 
 #include <algorithm>
@@ -25,10 +25,8 @@
 #include <utility>
 #include <vector>
 
-namespace hpx { namespace traits
-{
-    namespace detail
-    {
+namespace hpx { namespace traits {
+    namespace detail {
         template <typename T, typename Enable = void>
         struct acquire_shared_state_impl;
     }
@@ -36,21 +34,20 @@ namespace hpx { namespace traits
     template <typename T, typename Enable = void>
     struct acquire_shared_state
       : detail::acquire_shared_state_impl<typename std::decay<T>::type>
-    {};
+    {
+    };
 
     struct acquire_shared_state_disp
     {
         template <typename T>
-        HPX_FORCEINLINE typename acquire_shared_state<T>::type
-        operator()(T && t) const
+        HPX_FORCEINLINE typename acquire_shared_state<T>::type operator()(
+            T&& t) const
         {
             return acquire_shared_state<T>()(std::forward<T>(t));
         }
     };
 
-
-    namespace detail
-    {
+    namespace detail {
         ///////////////////////////////////////////////////////////////////////
         template <typename T, typename Enable>
         struct acquire_shared_state_impl
@@ -60,8 +57,7 @@ namespace hpx { namespace traits
             typedef T type;
 
             template <typename T_>
-            HPX_FORCEINLINE
-            T operator()(T_ && value) const
+            HPX_FORCEINLINE T operator()(T_&& value) const
             {
                 return std::forward<T_>(value);
             }
@@ -69,19 +65,13 @@ namespace hpx { namespace traits
 
         ///////////////////////////////////////////////////////////////////////
         template <typename Future>
-        struct acquire_shared_state_impl<
-            Future,
-            typename std::enable_if<
-                is_future<Future>::value
-            >::type
-        >
+        struct acquire_shared_state_impl<Future,
+            typename std::enable_if<is_future<Future>::value>::type>
         {
             typedef typename traits::detail::shared_state_ptr<
-                typename traits::future_traits<Future>::type
-            >::type const& type;
+                typename traits::future_traits<Future>::type>::type const& type;
 
-            HPX_FORCEINLINE type
-            operator()(Future const& f) const
+            HPX_FORCEINLINE type operator()(Future const& f) const
             {
                 return traits::future_access<Future>::get_shared_state(f);
             }
@@ -89,23 +79,21 @@ namespace hpx { namespace traits
 
         ///////////////////////////////////////////////////////////////////////
         template <typename Range>
-        struct acquire_shared_state_impl<
-            Range,
+        struct acquire_shared_state_impl<Range,
             typename std::enable_if<
-                traits::is_future_range<Range>::value
-            >::type
-        >
+                traits::is_future_range<Range>::value>::type>
         {
             typedef typename traits::future_range_traits<Range>::future_type
                 future_type;
 
-            typedef typename traits::detail::shared_state_ptr_for<future_type>::type
-                shared_state_ptr;
+            typedef
+                typename traits::detail::shared_state_ptr_for<future_type>::type
+                    shared_state_ptr;
             typedef std::vector<shared_state_ptr> type;
 
             template <typename Range_>
-            HPX_FORCEINLINE std::vector<shared_state_ptr>
-            operator()(Range_&& futures) const
+            HPX_FORCEINLINE std::vector<shared_state_ptr> operator()(
+                Range_&& futures) const
             {
                 std::vector<shared_state_ptr> values;
                 detail::reserve_if_random_access_by_range(values, futures);
@@ -116,23 +104,22 @@ namespace hpx { namespace traits
                 return values;
             }
         };
-    }
+    }    // namespace detail
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         template <typename T>
-        HPX_FORCEINLINE typename acquire_shared_state<T>::type
-        get_shared_state(T && t)
+        HPX_FORCEINLINE typename acquire_shared_state<T>::type get_shared_state(
+            T&& t)
         {
             return acquire_shared_state<T>()(std::forward<T>(t));
         }
 
         template <typename R>
         HPX_FORCEINLINE
-        hpx::intrusive_ptr<lcos::detail::future_data_base<R> > const&
-        get_shared_state(
-            hpx::intrusive_ptr<lcos::detail::future_data_base<R> > const& t)
+            hpx::intrusive_ptr<lcos::detail::future_data_base<R>> const&
+            get_shared_state(
+                hpx::intrusive_ptr<lcos::detail::future_data_base<R>> const& t)
         {
             return t;
         }
@@ -148,7 +135,7 @@ namespace hpx { namespace traits
                 return traits::detail::get_shared_state(f);
             }
         };
-    }
-}}
+    }    // namespace detail
+}}       // namespace hpx::traits
 
 #endif /*HPX_TRAITS_ACQUIRE_SHARED_STATE_HPP*/
diff --git a/libs/execution/include/hpx/execution/traits/future_access.hpp b/libs/execution/include/hpx/execution/traits/future_access.hpp
index fd648b0de8ff..298e01c0aa9f 100644
--- a/libs/execution/include/hpx/execution/traits/future_access.hpp
+++ b/libs/execution/include/hpx/execution/traits/future_access.hpp
@@ -8,30 +8,31 @@
 #define HPX_TRAITS_FUTURE_ACCESS_JUN_24_2015_0930AM
 
 #include <hpx/config.hpp>
-#include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/execution/traits/future_traits.hpp>
+#include <hpx/memory/intrusive_ptr.hpp>
 
 #include <type_traits>
 #include <utility>
 #include <vector>
 
-namespace hpx { namespace lcos
-{
-    template <typename R> class future;
-    template <typename R> class shared_future;
+namespace hpx { namespace lcos {
+    template <typename R>
+    class future;
+    template <typename R>
+    class shared_future;
 
-    namespace detail
-    {
-        template <typename Result> struct future_data_base;
+    namespace detail {
+        template <typename Result>
+        struct future_data_base;
     }
-}}
+}}    // namespace hpx::lcos
 
-namespace hpx { namespace traits
-{
+namespace hpx { namespace traits {
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
-        struct future_data_void {};
+    namespace detail {
+        struct future_data_void
+        {
+        };
 
         template <typename Result>
         struct shared_state_ptr_result
@@ -63,73 +64,71 @@ namespace hpx { namespace traits
         template <typename Future, typename Enable = void>
         struct shared_state_ptr_for
           : shared_state_ptr<typename traits::future_traits<Future>::type>
-        {};
+        {
+        };
 
         template <typename Future>
-        struct shared_state_ptr_for<Future const>
-          : shared_state_ptr_for<Future>
-        {};
+        struct shared_state_ptr_for<Future const> : shared_state_ptr_for<Future>
+        {
+        };
 
         template <typename Future>
-        struct shared_state_ptr_for<Future&>
-          : shared_state_ptr_for<Future>
-        {};
+        struct shared_state_ptr_for<Future&> : shared_state_ptr_for<Future>
+        {
+        };
 
         template <typename Future>
-        struct shared_state_ptr_for<Future &&>
-          : shared_state_ptr_for<Future>
-        {};
+        struct shared_state_ptr_for<Future&&> : shared_state_ptr_for<Future>
+        {
+        };
 
         template <typename Future>
-        struct shared_state_ptr_for<std::vector<Future> >
+        struct shared_state_ptr_for<std::vector<Future>>
         {
-            typedef std::vector<
-                    typename shared_state_ptr_for<Future>::type
-                > type;
+            typedef std::vector<typename shared_state_ptr_for<Future>::type>
+                type;
         };
 
         ///////////////////////////////////////////////////////////////////////
         template <typename SharedState, typename Allocator>
         struct shared_state_allocator;
-    }
+    }    // namespace detail
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename T, typename Enable = void>
-    struct is_shared_state
-      : std::false_type
-    {};
+    struct is_shared_state : std::false_type
+    {
+    };
 
     template <typename R>
     struct is_shared_state<
-            hpx::intrusive_ptr<lcos::detail::future_data_base<R> > >
-      : std::true_type
-    {};
+        hpx::intrusive_ptr<lcos::detail::future_data_base<R>>> : std::true_type
+    {
+    };
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         template <typename T, typename Enable = void>
         struct future_access_customization_point;
     }
 
     template <typename T>
-    struct future_access
-      : detail::future_access_customization_point<T>
-    {};
+    struct future_access : detail::future_access_customization_point<T>
+    {
+    };
 
     template <typename R>
-    struct future_access<lcos::future<R> >
+    struct future_access<lcos::future<R>>
     {
         template <typename SharedState>
-        static lcos::future<R>
-        create(hpx::intrusive_ptr<SharedState> const& shared_state)
+        static lcos::future<R> create(
+            hpx::intrusive_ptr<SharedState> const& shared_state)
         {
             return lcos::future<R>(shared_state);
         }
 
         template <typename T = void>
-        static lcos::future<R>
-        create(typename detail::shared_state_ptr_for<
+        static lcos::future<R> create(typename detail::shared_state_ptr_for<
             lcos::future<lcos::future<R>>>::type const& shared_state)
         {
             return lcos::future<lcos::future<R>>(shared_state);
@@ -150,34 +149,34 @@ namespace hpx { namespace traits
         }
 
         template <typename SharedState>
-        static lcos::future<R>
-        create(SharedState* shared_state, bool addref = true)
+        static lcos::future<R> create(
+            SharedState* shared_state, bool addref = true)
         {
             return lcos::future<R>(
                 hpx::intrusive_ptr<SharedState>(shared_state, addref));
         }
 
         HPX_FORCEINLINE static
-        typename traits::detail::shared_state_ptr<R>::type const&
-        get_shared_state(lcos::future<R> const& f)
+            typename traits::detail::shared_state_ptr<R>::type const&
+            get_shared_state(lcos::future<R> const& f)
         {
             return f.shared_state_;
         }
 
         HPX_FORCEINLINE static
-        typename traits::detail::shared_state_ptr<R>::type::element_type*
-        detach_shared_state(lcos::future<R> && f)
+            typename traits::detail::shared_state_ptr<R>::type::element_type*
+            detach_shared_state(lcos::future<R>&& f)
         {
             return f.shared_state_.detach();
         }
     };
 
     template <typename R>
-    struct future_access<lcos::shared_future<R> >
+    struct future_access<lcos::shared_future<R>>
     {
         template <typename SharedState>
-        static lcos::shared_future<R>
-        create(hpx::intrusive_ptr<SharedState> const& shared_state)
+        static lcos::shared_future<R> create(
+            hpx::intrusive_ptr<SharedState> const& shared_state)
         {
             return lcos::shared_future<R>(shared_state);
         }
@@ -191,8 +190,8 @@ namespace hpx { namespace traits
         }
 
         template <typename SharedState>
-        static lcos::shared_future<R>
-        create(hpx::intrusive_ptr<SharedState> && shared_state)
+        static lcos::shared_future<R> create(
+            hpx::intrusive_ptr<SharedState>&& shared_state)
         {
             return lcos::shared_future<R>(std::move(shared_state));
         }
@@ -207,23 +206,23 @@ namespace hpx { namespace traits
         }
 
         template <typename SharedState>
-        static lcos::shared_future<R>
-        create(SharedState* shared_state, bool addref = true)
+        static lcos::shared_future<R> create(
+            SharedState* shared_state, bool addref = true)
         {
             return lcos::shared_future<R>(
                 hpx::intrusive_ptr<SharedState>(shared_state, addref));
         }
 
         HPX_FORCEINLINE static
-        typename traits::detail::shared_state_ptr<R>::type const&
-        get_shared_state(lcos::shared_future<R> const& f)
+            typename traits::detail::shared_state_ptr<R>::type const&
+            get_shared_state(lcos::shared_future<R> const& f)
         {
             return f.shared_state_;
         }
 
         HPX_FORCEINLINE static
-        typename traits::detail::shared_state_ptr<R>::type::element_type*
-        detach_shared_state(lcos::shared_future<R> const& f)
+            typename traits::detail::shared_state_ptr<R>::type::element_type*
+            detach_shared_state(lcos::shared_future<R> const& f)
         {
             return f.shared_state_.get();
         }
@@ -233,8 +232,8 @@ namespace hpx { namespace traits
     template <typename SharedState, typename Allocator>
     struct shared_state_allocator
       : detail::shared_state_allocator<SharedState, Allocator>
-    {};
-}}
+    {
+    };
+}}    // namespace hpx::traits
 
 #endif
-
diff --git a/libs/execution/include/hpx/execution/traits/future_then_result.hpp b/libs/execution/include/hpx/execution/traits/future_then_result.hpp
index 27bee462f281..f9587e181b62 100644
--- a/libs/execution/include/hpx/execution/traits/future_then_result.hpp
+++ b/libs/execution/include/hpx/execution/traits/future_then_result.hpp
@@ -10,63 +10,59 @@
 
 #include <hpx/config.hpp>
 #include <hpx/datastructures/detail/pack.hpp>
+#include <hpx/execution/traits/future_traits.hpp>
+#include <hpx/execution/traits/is_executor.hpp>
+#include <hpx/execution/traits/is_future.hpp>
 #include <hpx/functional/result_of.hpp>
 #include <hpx/type_support/always_void.hpp>
 #include <hpx/type_support/identity.hpp>
 #include <hpx/type_support/lazy_conditional.hpp>
-#include <hpx/execution/traits/is_executor.hpp>
-#include <hpx/execution/traits/is_future.hpp>
-#include <hpx/execution/traits/future_traits.hpp>
 
 #include <type_traits>
 #include <utility>
 
-namespace hpx { namespace traits
-{
+namespace hpx { namespace traits {
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
-        struct no_executor {};
+    namespace detail {
+        struct no_executor
+        {
+        };
 
         template <typename Executor, typename T, typename Ts,
             typename Enable = void>
         struct executor_future;
 
-        template <typename Executor, typename T, typename ...Ts>
+        template <typename Executor, typename T, typename... Ts>
         struct executor_future<Executor, T, hpx::util::detail::pack<Ts...>,
             typename std::enable_if<
-                hpx::traits::is_two_way_executor<Executor>::value
-            >::type>
+                hpx::traits::is_two_way_executor<Executor>::value>::type>
         {
-            using type = decltype(
-                std::declval<Executor&&>().async_execute(
-                    std::declval<T(*)(Ts...)>(), std::declval<Ts>()...));
+            using type = decltype(std::declval<Executor&&>().async_execute(
+                std::declval<T (*)(Ts...)>(), std::declval<Ts>()...));
         };
 
         template <typename Executor, typename T, typename Ts>
         struct executor_future<Executor, T, Ts,
             typename std::enable_if<
-                !hpx::traits::is_two_way_executor<Executor>::value
-            >::type>
+                !hpx::traits::is_two_way_executor<Executor>::value>::type>
         {
             using type = hpx::lcos::future<T>;
         };
-    }
+    }    // namespace detail
 
-    template <typename Executor, typename T, typename ...Ts>
+    template <typename Executor, typename T, typename... Ts>
     struct executor_future
-      : detail::executor_future<
-            typename std::decay<Executor>::type,
-            T, hpx::util::detail::pack<typename std::decay<Ts>::type...> >
-    {};
+      : detail::executor_future<typename std::decay<Executor>::type, T,
+            hpx::util::detail::pack<typename std::decay<Ts>::type...>>
+    {
+    };
 
-    template <typename Executor, typename T, typename ...Ts>
+    template <typename Executor, typename T, typename... Ts>
     using executor_future_t =
         typename executor_future<Executor, T, Ts...>::type;
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         template <typename Future, typename F>
         struct continuation_not_callable
         {
@@ -77,11 +73,11 @@ namespace hpx { namespace traits
             }
 #else
             static auto error(Future future, F& f)
-             -> decltype(f(std::move(future)));
+                -> decltype(f(std::move(future)));
 #endif
 
-            using type = decltype(
-                error(std::declval<Future>(), std::declval<F&>()));
+            using type =
+                decltype(error(std::declval<Future>(), std::declval<F&>()));
         };
 
         ///////////////////////////////////////////////////////////////////////
@@ -92,22 +88,18 @@ namespace hpx { namespace traits
         };
 
         template <typename Future, typename F>
-        struct future_then_result<
-            Future, F,
+        struct future_then_result<Future, F,
             typename hpx::util::always_void<
-                typename hpx::util::invoke_result<F&, Future>::type
-            >::type
-        >
+                typename hpx::util::invoke_result<F&, Future>::type>::type>
         {
-            typedef typename hpx::util::invoke_result<F&, Future>::type
-                cont_result;
+            typedef
+                typename hpx::util::invoke_result<F&, Future>::type cont_result;
 
             // perform unwrapping of future<future<R>>
             typedef typename util::lazy_conditional<
-                    hpx::traits::detail::is_unique_future<cont_result>::value,
-                    hpx::traits::future_traits<cont_result>,
-                    hpx::util::identity<cont_result>
-                >::type result_type;
+                hpx::traits::detail::is_unique_future<cont_result>::value,
+                hpx::traits::future_traits<cont_result>,
+                hpx::util::identity<cont_result>>::type result_type;
 
             typedef hpx::lcos::future<result_type> type;
         };
@@ -121,41 +113,38 @@ namespace hpx { namespace traits
         };
 
         template <typename Executor, typename Future, typename F>
-        struct future_then_executor_result<
-                Executor, Future, F,
-                typename hpx::util::always_void<
-                    typename hpx::util::invoke_result<F&, Future>::type
-                >::type>
+        struct future_then_executor_result<Executor, Future, F,
+            typename hpx::util::always_void<
+                typename hpx::util::invoke_result<F&, Future>::type>::type>
         {
             typedef typename hpx::util::invoke_result<F&, Future>::type
                 func_result_type;
 
-            typedef typename traits::executor_future<
-                    Executor, func_result_type, Future
-                >::type cont_result;
+            typedef typename traits::executor_future<Executor, func_result_type,
+                Future>::type cont_result;
 
             // perform unwrapping of future<future<R>>
             typedef typename util::lazy_conditional<
-                    hpx::traits::detail::is_unique_future<cont_result>::value,
-                    hpx::traits::future_traits<cont_result>,
-                    hpx::util::identity<cont_result>
-                >::type result_type;
+                hpx::traits::detail::is_unique_future<cont_result>::value,
+                hpx::traits::future_traits<cont_result>,
+                hpx::util::identity<cont_result>>::type result_type;
 
             typedef hpx::lcos::future<result_type> type;
         };
-    }
+    }    // namespace detail
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Future, typename F>
-    struct future_then_result
-      : detail::future_then_result<Future, F>
-    {};
+    struct future_then_result : detail::future_then_result<Future, F>
+    {
+    };
 
     template <typename Executor, typename Future, typename F>
     struct future_then_executor_result
-      : detail::future_then_executor_result<
-            typename std::decay<Executor>::type, Future, F>
-    {};
-}}
+      : detail::future_then_executor_result<typename std::decay<Executor>::type,
+            Future, F>
+    {
+    };
+}}    // namespace hpx::traits
 
 #endif
diff --git a/libs/execution/include/hpx/execution/traits/future_traits.hpp b/libs/execution/include/hpx/execution/traits/future_traits.hpp
index 82a356770910..6964bd44f7ab 100644
--- a/libs/execution/include/hpx/execution/traits/future_traits.hpp
+++ b/libs/execution/include/hpx/execution/traits/future_traits.hpp
@@ -12,58 +12,61 @@
 
 #include <type_traits>
 
-namespace hpx { namespace lcos
-{
-    template <typename R> class future;
-    template <typename R> class shared_future;
-}}
-
-namespace hpx { namespace traits
-{
+namespace hpx { namespace lcos {
+
+    template <typename R>
+    class future;
+
+    template <typename R>
+    class shared_future;
+
+}}    // namespace hpx::lcos
+
+namespace hpx { namespace traits {
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         template <typename Future, typename Enable = void>
         struct future_traits_customization_point
-        {};
-    }
+        {
+        };
+    }    // namespace detail
 
     template <typename T>
-    struct future_traits
-      : detail::future_traits_customization_point<T>
-    {};
+    struct future_traits : detail::future_traits_customization_point<T>
+    {
+    };
 
     template <typename Future>
-    struct future_traits<Future const>
-      : future_traits<Future>
-    {};
+    struct future_traits<Future const> : future_traits<Future>
+    {
+    };
 
     template <typename Future>
-    struct future_traits<Future&>
-      : future_traits<Future>
-    {};
+    struct future_traits<Future&> : future_traits<Future>
+    {
+    };
 
     template <typename Future>
-    struct future_traits<Future const &>
-      : future_traits<Future>
-    {};
+    struct future_traits<Future const&> : future_traits<Future>
+    {
+    };
 
     template <typename R>
-    struct future_traits<lcos::future<R> >
+    struct future_traits<lcos::future<R>>
     {
         typedef R type;
         typedef R result_type;
     };
 
     template <typename R>
-    struct future_traits<lcos::shared_future<R> >
+    struct future_traits<lcos::shared_future<R>>
     {
         typedef R type;
         typedef R const& result_type;
     };
 
     template <>
-    struct future_traits<lcos::shared_future<void> >
+    struct future_traits<lcos::shared_future<void>>
     {
         typedef void type;
         typedef void result_type;
@@ -71,16 +74,16 @@ namespace hpx { namespace traits
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Future, typename Enable = void>
-    struct is_future_void
-      : std::false_type
-    {};
+    struct is_future_void : std::false_type
+    {
+    };
 
     template <typename Future>
     struct is_future_void<Future,
-            typename std::enable_if<is_future<Future>::value>::type>
+        typename std::enable_if<is_future<Future>::value>::type>
       : std::is_void<typename future_traits<Future>::type>
-    {};
-}}
+    {
+    };
+}}    // namespace hpx::traits
 
 #endif
-
diff --git a/libs/execution/include/hpx/execution/traits/is_future.hpp b/libs/execution/include/hpx/execution/traits/is_future.hpp
index 1bd30385339f..cd9008f4a509 100644
--- a/libs/execution/include/hpx/execution/traits/is_future.hpp
+++ b/libs/execution/include/hpx/execution/traits/is_future.hpp
@@ -17,62 +17,65 @@
 #include <functional>
 #include <type_traits>
 
-namespace hpx { namespace lcos
-{
-    template <typename R> class future;
-    template <typename R> class shared_future;
-}}
-
-namespace hpx { namespace traits
-{
-    namespace detail
-    {
+namespace hpx { namespace lcos {
+
+    template <typename R>
+    class future;
+
+    template <typename R>
+    class shared_future;
+
+}}    // namespace hpx::lcos
+
+namespace hpx { namespace traits {
+    namespace detail {
         template <typename Future, typename Enable = void>
-        struct is_unique_future
-          : std::false_type
-        {};
+        struct is_unique_future : std::false_type
+        {
+        };
 
         template <typename R>
-        struct is_unique_future<lcos::future<R> >
-          : std::true_type
-        {};
+        struct is_unique_future<lcos::future<R>> : std::true_type
+        {
+        };
 
         template <typename Future, typename Enable = void>
-        struct is_future_customization_point
-          : std::false_type
-        {};
-    }
+        struct is_future_customization_point : std::false_type
+        {
+        };
+    }    // namespace detail
 
     template <typename Future>
-    struct is_future
-      : detail::is_future_customization_point<Future>
-    {};
+    struct is_future : detail::is_future_customization_point<Future>
+    {
+    };
 
     template <typename R>
-    struct is_future<lcos::future<R> >
-      : std::true_type
-    {};
+    struct is_future<lcos::future<R>> : std::true_type
+    {
+    };
 
     template <typename R>
-    struct is_future<lcos::shared_future<R> >
-      : std::true_type
-    {};
+    struct is_future<lcos::shared_future<R>> : std::true_type
+    {
+    };
 
     template <typename Future>
-    struct is_ref_wrapped_future
-      : std::false_type
-    {};
+    struct is_ref_wrapped_future : std::false_type
+    {
+    };
 
     template <typename Future>
-    struct is_ref_wrapped_future<boost::reference_wrapper<Future> >
+    struct is_ref_wrapped_future<boost::reference_wrapper<Future>>
       : is_future<Future>
-    {};
+    {
+    };
 
     template <typename Future>
-    struct is_ref_wrapped_future<std::reference_wrapper<Future> >
+    struct is_ref_wrapped_future<std::reference_wrapper<Future>>
       : is_future<Future>
-    {};
-}}
+    {
+    };
+}}    // namespace hpx::traits
 
 #endif
-
diff --git a/libs/execution/include/hpx/execution/traits/is_future_range.hpp b/libs/execution/include/hpx/execution/traits/is_future_range.hpp
index 626bb06ce235..e841b5b09f70 100644
--- a/libs/execution/include/hpx/execution/traits/is_future_range.hpp
+++ b/libs/execution/include/hpx/execution/traits/is_future_range.hpp
@@ -19,40 +19,41 @@
 #include <functional>
 #include <type_traits>
 
-namespace hpx { namespace traits
-{
+namespace hpx { namespace traits {
     ///////////////////////////////////////////////////////////////////////////
     template <typename R, typename Enable = void>
-    struct is_future_range
-      : std::false_type
-    {};
+    struct is_future_range : std::false_type
+    {
+    };
 
     template <typename R>
-    struct is_future_range<
-        R,
-        typename std::enable_if<is_range<R>::value>::type
-    > : is_future<typename range_traits<R>::value_type>
-    {};
+    struct is_future_range<R, typename std::enable_if<is_range<R>::value>::type>
+      : is_future<typename range_traits<R>::value_type>
+    {
+    };
 
     template <typename R, typename Enable = void>
-    struct is_ref_wrapped_future_range
-      : std::false_type
-    {};
+    struct is_ref_wrapped_future_range : std::false_type
+    {
+    };
 
     template <typename R>
-    struct is_ref_wrapped_future_range< ::boost::reference_wrapper<R> >
+    struct is_ref_wrapped_future_range<::boost::reference_wrapper<R>>
       : is_future_range<R>
-    {};
+    {
+    };
 
     template <typename R>
-    struct is_ref_wrapped_future_range< ::std::reference_wrapper<R> >
+    struct is_ref_wrapped_future_range<::std::reference_wrapper<R>>
       : is_future_range<R>
-    {};
+    {
+    };
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename R, bool IsFutureRange = is_future_range<R>::value>
     struct future_range_traits
-    {};
+    {
+    };
 
     template <typename R>
     struct future_range_traits<R, true>
@@ -61,15 +62,14 @@ namespace hpx { namespace traits
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         template <typename T>
         struct is_future_or_future_range
           : std::integral_constant<bool,
-                is_future<T>::value || is_future_range<T>::value
-            >
-        {};
-    }
-}}
+                is_future<T>::value || is_future_range<T>::value>
+        {
+        };
+    }    // namespace detail
+}}       // namespace hpx::traits
 
 #endif /*HPX_TRAITS_IS_FUTURE_RANGE_HPP*/
diff --git a/libs/execution/include/hpx/execution/traits/is_launch_policy.hpp b/libs/execution/include/hpx/execution/traits/is_launch_policy.hpp
index b4deb5efd796..a5630f6b9284 100644
--- a/libs/execution/include/hpx/execution/traits/is_launch_policy.hpp
+++ b/libs/execution/include/hpx/execution/traits/is_launch_policy.hpp
@@ -8,59 +8,57 @@
 #define HPX_TRAITS_IS_LAUNCH_POLICY_APR_8_2014_0436PM
 
 #include <hpx/config.hpp>
-#include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/launch_policy.hpp>
+#include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/type_support/decay.hpp>
 
 #include <type_traits>
 
-namespace hpx { namespace threads
-{
+namespace hpx { namespace threads {
     class executor;
-}}
+}}    // namespace hpx::threads
 
-namespace hpx { namespace traits
-{
-    namespace detail
-    {
+namespace hpx { namespace traits {
+    namespace detail {
         template <typename Policy>
         struct is_launch_policy
           : std::is_base_of<hpx::detail::policy_holder_base, Policy>
-        {};
+        {
+        };
 
         template <typename Policy>
-        struct is_threads_executor
-          : std::is_base_of<threads::executor, Policy>
-        {};
-    }
+        struct is_threads_executor : std::is_base_of<threads::executor, Policy>
+        {
+        };
+    }    // namespace detail
 
     template <typename Policy>
     struct is_launch_policy
       : detail::is_launch_policy<typename hpx::util::decay<Policy>::type>
-    {};
+    {
+    };
 
     template <typename Policy>
     struct is_threads_executor
       : detail::is_threads_executor<typename hpx::util::decay<Policy>::type>
-    {};
+    {
+    };
 
     template <typename Policy>
     struct is_launch_policy_or_executor
       : std::integral_constant<bool,
             is_launch_policy<Policy>::value ||
                 is_threads_executor<Policy>::value>
-    {};
+    {
+    };
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Executor>
     struct executor_execution_category<Executor,
-        typename std::enable_if<
-            is_threads_executor<Executor>::value
-        >::type>
+        typename std::enable_if<is_threads_executor<Executor>::value>::type>
     {
         typedef parallel::execution::parallel_execution_tag type;
     };
-}}
+}}    // namespace hpx::traits
 
 #endif
-
diff --git a/libs/execution/include_compatibility/hpx/lcos/detail/future_await_traits.hpp b/libs/execution/include_compatibility/hpx/lcos/detail/future_await_traits.hpp
index af687ce010d1..539be9f3f8aa 100644
--- a/libs/execution/include_compatibility/hpx/lcos/detail/future_await_traits.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/detail/future_await_traits.hpp
@@ -10,12 +10,11 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
+#pragma message(                                                               \
     "The header hpx/lcos/detail/future_await_traits.hpp is deprecated, \
     please include hpx/execution/detail/future_await_traits.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/detail/future_await_traits.hpp is deprecated, \
+#warning "The header hpx/lcos/detail/future_await_traits.hpp is deprecated, \
     please include hpx/execution/detail/future_await_traits.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/lcos/detail/future_data.hpp b/libs/execution/include_compatibility/hpx/lcos/detail/future_data.hpp
index e1cf8235956f..5a45cc947208 100644
--- a/libs/execution/include_compatibility/hpx/lcos/detail/future_data.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/detail/future_data.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/lcos/detail/future_data.hpp is deprecated, \
+#pragma message("The header hpx/lcos/detail/future_data.hpp is deprecated, \
     please include hpx/execution/detail/future_data.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/detail/future_data.hpp is deprecated, \
+#warning "The header hpx/lcos/detail/future_data.hpp is deprecated, \
     please include hpx/execution/detail/future_data.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/lcos/detail/future_traits.hpp b/libs/execution/include_compatibility/hpx/lcos/detail/future_traits.hpp
index f133df6ce5f8..d760edaa5e3d 100644
--- a/libs/execution/include_compatibility/hpx/lcos/detail/future_traits.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/detail/future_traits.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/lcos/detail/future_traits.hpp is deprecated, \
+#pragma message("The header hpx/lcos/detail/future_traits.hpp is deprecated, \
     please include hpx/execution/detail/future_traits.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/detail/future_traits.hpp is deprecated, \
+#warning "The header hpx/lcos/detail/future_traits.hpp is deprecated, \
     please include hpx/execution/detail/future_traits.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/lcos/detail/future_transforms.hpp b/libs/execution/include_compatibility/hpx/lcos/detail/future_transforms.hpp
index 8f5920c36d83..2094da5eb5d5 100644
--- a/libs/execution/include_compatibility/hpx/lcos/detail/future_transforms.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/detail/future_transforms.hpp
@@ -10,12 +10,11 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
+#pragma message(                                                               \
     "The header hpx/lcos/detail/future_transforms.hpp is deprecated, \
     please include hpx/execution/detail/future_transforms.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/detail/future_transforms.hpp is deprecated, \
+#warning "The header hpx/lcos/detail/future_transforms.hpp is deprecated, \
     please include hpx/execution/detail/future_transforms.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/lcos/future.hpp b/libs/execution/include_compatibility/hpx/lcos/future.hpp
index e1c1f130115b..6cf8d44ce3dd 100644
--- a/libs/execution/include_compatibility/hpx/lcos/future.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/future.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/lcos/future.hpp is deprecated, \
+#pragma message("The header hpx/lcos/future.hpp is deprecated, \
     please include hpx/execution/future.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/future.hpp is deprecated, \
+#warning "The header hpx/lcos/future.hpp is deprecated, \
     please include hpx/execution/future.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/lcos/local/futures_factory.hpp b/libs/execution/include_compatibility/hpx/lcos/local/futures_factory.hpp
index f3ba93434a58..461121abcd7b 100644
--- a/libs/execution/include_compatibility/hpx/lcos/local/futures_factory.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/local/futures_factory.hpp
@@ -10,12 +10,11 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
+#pragma message(                                                               \
     "The header hpx/lcos/local/futures_factory.hpp is deprecated, \
     please include hpx/execution/futures_factory.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/local/futures_factory.hpp is deprecated, \
+#warning "The header hpx/lcos/local/futures_factory.hpp is deprecated, \
     please include hpx/execution/futures_factory.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/lcos/split_future.hpp b/libs/execution/include_compatibility/hpx/lcos/split_future.hpp
index 96626e1df105..351a878f77cc 100644
--- a/libs/execution/include_compatibility/hpx/lcos/split_future.hpp
+++ b/libs/execution/include_compatibility/hpx/lcos/split_future.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/lcos/split_future.hpp is deprecated, \
+#pragma message("The header hpx/lcos/split_future.hpp is deprecated, \
     please include hpx/execution/split_future.hpp instead")
 #else
-#warning \
-    "The header hpx/lcos/split_future.hpp is deprecated, \
+#warning "The header hpx/lcos/split_future.hpp is deprecated, \
     please include hpx/execution/split_future.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/runtime/launch_policy.hpp b/libs/execution/include_compatibility/hpx/runtime/launch_policy.hpp
index 46df30ed30a9..e7b9ee1a2729 100644
--- a/libs/execution/include_compatibility/hpx/runtime/launch_policy.hpp
+++ b/libs/execution/include_compatibility/hpx/runtime/launch_policy.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/runtime/launch_policy.hpp is deprecated, \
+#pragma message("The header hpx/runtime/launch_policy.hpp is deprecated, \
     please include hpx/execution/launch_policy.hpp instead")
 #else
-#warning \
-    "The header hpx/runtime/launch_policy.hpp is deprecated, \
+#warning "The header hpx/runtime/launch_policy.hpp is deprecated, \
     please include hpx/execution/launch_policy.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/acquire_future.hpp b/libs/execution/include_compatibility/hpx/traits/acquire_future.hpp
index 442091fe6a3f..054369e21463 100644
--- a/libs/execution/include_compatibility/hpx/traits/acquire_future.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/acquire_future.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/acquire_future.hpp is deprecated, \
+#pragma message("The header hpx/traits/acquire_future.hpp is deprecated, \
     please include hpx/execution/traits/acquire_future.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/acquire_future.hpp is deprecated, \
+#warning "The header hpx/traits/acquire_future.hpp is deprecated, \
     please include hpx/execution/traits/acquire_future.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/acquire_shared_state.hpp b/libs/execution/include_compatibility/hpx/traits/acquire_shared_state.hpp
index 058e454bdd21..fa5e0212de4b 100644
--- a/libs/execution/include_compatibility/hpx/traits/acquire_shared_state.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/acquire_shared_state.hpp
@@ -10,12 +10,11 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
+#pragma message(                                                               \
     "The header hpx/traits/acquire_shared_state.hpp is deprecated, \
     please include hpx/execution/traits/acquire_shared_state.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/acquire_shared_state.hpp is deprecated, \
+#warning "The header hpx/traits/acquire_shared_state.hpp is deprecated, \
     please include hpx/execution/traits/acquire_shared_state.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/future_access.hpp b/libs/execution/include_compatibility/hpx/traits/future_access.hpp
index 7945a3ca6720..ff96f5e5e925 100644
--- a/libs/execution/include_compatibility/hpx/traits/future_access.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/future_access.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/future_access.hpp is deprecated, \
+#pragma message("The header hpx/traits/future_access.hpp is deprecated, \
     please include hpx/execution/traits/future_access.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/future_access.hpp is deprecated, \
+#warning "The header hpx/traits/future_access.hpp is deprecated, \
     please include hpx/execution/traits/future_access.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/future_then_result.hpp b/libs/execution/include_compatibility/hpx/traits/future_then_result.hpp
index 59ad0d98618a..89750313b97d 100644
--- a/libs/execution/include_compatibility/hpx/traits/future_then_result.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/future_then_result.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/future_then_result.hpp is deprecated, \
+#pragma message("The header hpx/traits/future_then_result.hpp is deprecated, \
     please include hpx/execution/traits/future_then_result.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/future_then_result.hpp is deprecated, \
+#warning "The header hpx/traits/future_then_result.hpp is deprecated, \
     please include hpx/execution/traits/future_then_result.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/future_traits.hpp b/libs/execution/include_compatibility/hpx/traits/future_traits.hpp
index 409d43429490..d4763a74d894 100644
--- a/libs/execution/include_compatibility/hpx/traits/future_traits.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/future_traits.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/future_traits.hpp is deprecated, \
+#pragma message("The header hpx/traits/future_traits.hpp is deprecated, \
     please include hpx/execution/traits/future_traits.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/future_traits.hpp is deprecated, \
+#warning "The header hpx/traits/future_traits.hpp is deprecated, \
     please include hpx/execution/traits/future_traits.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/is_future.hpp b/libs/execution/include_compatibility/hpx/traits/is_future.hpp
index 19829bb16887..a0ee23bbea67 100644
--- a/libs/execution/include_compatibility/hpx/traits/is_future.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/is_future.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/is_future.hpp is deprecated, \
+#pragma message("The header hpx/traits/is_future.hpp is deprecated, \
     please include hpx/execution/traits/is_future.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/is_future.hpp is deprecated, \
+#warning "The header hpx/traits/is_future.hpp is deprecated, \
     please include hpx/execution/traits/is_future.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/is_future_range.hpp b/libs/execution/include_compatibility/hpx/traits/is_future_range.hpp
index 3247f04066a4..81f84e00e597 100644
--- a/libs/execution/include_compatibility/hpx/traits/is_future_range.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/is_future_range.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/is_future_range.hpp is deprecated, \
+#pragma message("The header hpx/traits/is_future_range.hpp is deprecated, \
     please include hpx/execution/traits/is_future_range.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/is_future_range.hpp is deprecated, \
+#warning "The header hpx/traits/is_future_range.hpp is deprecated, \
     please include hpx/execution/traits/is_future_range.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/include_compatibility/hpx/traits/is_launch_policy.hpp b/libs/execution/include_compatibility/hpx/traits/is_launch_policy.hpp
index e797b11fe7d0..450e8270acf7 100644
--- a/libs/execution/include_compatibility/hpx/traits/is_launch_policy.hpp
+++ b/libs/execution/include_compatibility/hpx/traits/is_launch_policy.hpp
@@ -10,12 +10,10 @@
 
 #if defined(HPX_EXECUTION_HAVE_DEPRECATION_WARNINGS)
 #if defined(HPX_MSVC)
-#pragma message( \
-    "The header hpx/traits/is_launch_policy.hpp is deprecated, \
+#pragma message("The header hpx/traits/is_launch_policy.hpp is deprecated, \
     please include hpx/execution/traits/is_launch_policy.hpp instead")
 #else
-#warning \
-    "The header hpx/traits/is_launch_policy.hpp is deprecated, \
+#warning "The header hpx/traits/is_launch_policy.hpp is deprecated, \
     please include hpx/execution/traits/is_launch_policy.hpp instead"
 #endif
 #endif
diff --git a/libs/execution/src/detail/future_data.cpp b/libs/execution/src/detail/future_data.cpp
index be781c57069b..ef06263987c1 100644
--- a/libs/execution/src/detail/future_data.cpp
+++ b/libs/execution/src/detail/future_data.cpp
@@ -4,22 +4,22 @@
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <hpx/execution/future.hpp>
 #include <hpx/execution/detail/future_data.hpp>
+#include <hpx/execution/future.hpp>
 
 #include <hpx/config.hpp>
 #include <hpx/assertion.hpp>
 #include <hpx/custom_exception_info.hpp>
 #include <hpx/errors.hpp>
+#include <hpx/execution/futures_factory.hpp>
+#include <hpx/execution/launch_policy.hpp>
 #include <hpx/functional/deferred_call.hpp>
 #include <hpx/functional/unique_function.hpp>
-#include <hpx/execution/futures_factory.hpp>
 #include <hpx/memory/intrusive_ptr.hpp>
 #include <hpx/runtime/components/client_base.hpp>
-#include <hpx/execution/launch_policy.hpp>
 #include <hpx/runtime/threads/thread.hpp>
-#include <hpx/util/annotated_function.hpp>
 #include <hpx/synchronization/detail/yield_k.hpp>
+#include <hpx/util/annotated_function.hpp>
 
 #include <cstddef>
 #include <exception>
@@ -27,8 +27,7 @@
 #include <mutex>
 #include <utility>
 
-namespace hpx { namespace lcos { namespace detail
-{
+namespace hpx { namespace lcos { namespace detail {
     future_data_refcnt_base::~future_data_refcnt_base() = default;
 
     ///////////////////////////////////////////////////////////////////////////
@@ -61,8 +60,7 @@ namespace hpx { namespace lcos { namespace detail
         // launch a new thread executing the given function
         threads::thread_id_type tid = p.apply("run_on_completed_on_new_thread",
             policy, threads::thread_priority_boost,
-            threads::thread_stacksize_current,
-            threads::thread_schedule_hint());
+            threads::thread_stacksize_current, threads::thread_schedule_hint());
 
         // wait for the task to run
         if (is_hpx_thread)
@@ -76,18 +74,18 @@ namespace hpx { namespace lcos { namespace detail
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    future_data_base<traits::detail::future_data_void>::
-        ~future_data_base()
-    {}
+    future_data_base<traits::detail::future_data_void>::~future_data_base() {}
 
     static util::unused_type unused_;
 
-    util::unused_type* future_data_base<traits::detail::future_data_void>::
-        get_result_void(void const* storage, error_code& ec)
+    util::unused_type*
+    future_data_base<traits::detail::future_data_void>::get_result_void(
+        void const* storage, error_code& ec)
     {
         // yields control if needed
         state s = wait(ec);
-        if (ec) return nullptr;
+        if (ec)
+            return nullptr;
 
         // No locking is required. Once a future has been made ready, which
         // is a postcondition of wait, either:
@@ -111,8 +109,7 @@ namespace hpx { namespace lcos { namespace detail
         if (s == empty)
         {
             // the value has already been moved out of this future
-            HPX_THROWS_IF(ec, no_state,
-                "future_data_base::get_result",
+            HPX_THROWS_IF(ec, no_state, "future_data_base::get_result",
                 "this future has no valid shared state");
             return nullptr;
         }
@@ -126,11 +123,13 @@ namespace hpx { namespace lcos { namespace detail
                 static_cast<std::exception_ptr const*>(storage);
             // an error has been reported in the meantime, throw or set
             // the error code
-            if (&ec == &throws) {
+            if (&ec == &throws)
+            {
                 std::rethrow_exception(*exception_ptr);
                 // never reached
             }
-            else {
+            else
+            {
                 ec = make_error_code(*exception_ptr);
             }
         }
@@ -142,21 +141,24 @@ namespace hpx { namespace lcos { namespace detail
     void future_data_base<traits::detail::future_data_void>::run_on_completed(
         completed_callback_type&& on_completed) noexcept
     {
-        try {
+        try
+        {
             hpx::util::annotate_function annotate(on_completed);
             on_completed();
         }
-        catch (...) {
+        catch (...)
+        {
             // If the completion handler throws an exception, there's nothing
             // we can do, report the exception and terminate.
-            hpx::detail::report_exception_and_terminate(std::current_exception());
+            hpx::detail::report_exception_and_terminate(
+                std::current_exception());
         }
     }
 
     void future_data_base<traits::detail::future_data_void>::run_on_completed(
         completed_callback_vector_type&& on_completed) noexcept
     {
-        for (auto&& func: on_completed)
+        for (auto&& func : on_completed)
         {
             run_on_completed(std::move(func));
         }
@@ -165,8 +167,9 @@ namespace hpx { namespace lcos { namespace detail
     // make sure continuation invocation does not recurse deeper than
     // allowed
     template <typename Callback>
-    void future_data_base<traits::detail::future_data_void>::
-        handle_on_completed(Callback && on_completed)
+    void
+    future_data_base<traits::detail::future_data_void>::handle_on_completed(
+        Callback&& on_completed)
     {
         // We need to run the completion on a new thread if we are on a
         // non HPX thread.
@@ -191,16 +194,16 @@ namespace hpx { namespace lcos { namespace detail
 
             try
             {
-                run_on_completed_on_new_thread(
-                    util::deferred_call(
-                        p, std::forward<Callback>(on_completed)));
+                run_on_completed_on_new_thread(util::deferred_call(
+                    p, std::forward<Callback>(on_completed)));
             }
-            catch(...)
+            catch (...)
             {
                 // If an exception while creating the new task or inside the
                 // completion handler is thrown, there is nothing we can do...
                 // ... but terminate and report the error
-                hpx::detail::report_exception_and_terminate(std::current_exception());
+                hpx::detail::report_exception_and_terminate(
+                    std::current_exception());
             }
         }
     }
@@ -210,18 +213,18 @@ namespace hpx { namespace lcos { namespace detail
     using completed_callback_vector_type =
         future_data_refcnt_base::completed_callback_vector_type;
 
-    template HPX_EXPORT
-    void future_data_base<traits::detail::future_data_void>::
-        handle_on_completed<completed_callback_vector_type>(
-            completed_callback_vector_type&&);
+    template HPX_EXPORT void
+    future_data_base<traits::detail::future_data_void>::handle_on_completed<
+        completed_callback_vector_type>(completed_callback_vector_type&&);
 
     /// Set the callback which needs to be invoked when the future becomes
     /// ready. If the future is ready the function will be invoked
     /// immediately.
-    void future_data_base<traits::detail::future_data_void>::
-        set_on_completed(completed_callback_type data_sink)
+    void future_data_base<traits::detail::future_data_void>::set_on_completed(
+        completed_callback_type data_sink)
     {
-        if (!data_sink) return;
+        if (!data_sink)
+            return;
 
         if (is_ready())
         {
@@ -257,7 +260,8 @@ namespace hpx { namespace lcos { namespace detail
             if (s == empty)
             {
                 cond_.wait(l, "future_data_base::wait", ec);
-                if (ec) return s;
+                if (ec)
+                    return s;
             }
         }
 
@@ -266,8 +270,9 @@ namespace hpx { namespace lcos { namespace detail
         return s;
     }
 
-    future_status future_data_base<traits::detail::future_data_void>::
-        wait_until(util::steady_clock::time_point const& abs_time, error_code& ec)
+    future_status
+    future_data_base<traits::detail::future_data_void>::wait_until(
+        util::steady_clock::time_point const& abs_time, error_code& ec)
     {
         // block if this entry is empty
         if (state_.load(std::memory_order_acquire) == empty)
@@ -275,10 +280,10 @@ namespace hpx { namespace lcos { namespace detail
             std::unique_lock<mutex_type> l(mtx_);
             if (state_.load(std::memory_order_relaxed) == empty)
             {
-                threads::thread_state_ex_enum const reason =
-                    cond_.wait_until(l, abs_time,
-                        "future_data_base::wait_until", ec);
-                if (ec) return future_status::uninitialized;
+                threads::thread_state_ex_enum const reason = cond_.wait_until(
+                    l, abs_time, "future_data_base::wait_until", ec);
+                if (ec)
+                    return future_status::uninitialized;
 
                 if (reason == threads::wait_timeout)
                     return future_status::timeout;
@@ -288,6 +293,6 @@ namespace hpx { namespace lcos { namespace detail
         if (&ec != &throws)
             ec = make_success_code();
 
-        return future_status::ready; //-V110
+        return future_status::ready;    //-V110
     }
-}}}
+}}}    // namespace hpx::lcos::detail
diff --git a/libs/execution/src/future.cpp b/libs/execution/src/future.cpp
index 9f2423b67ba9..1584e3ad4a94 100644
--- a/libs/execution/src/future.cpp
+++ b/libs/execution/src/future.cpp
@@ -19,4 +19,3 @@ namespace hpx { namespace lcos { namespace detail {
         handle_futures.await_future(state);
     }
 }}}    // namespace hpx::lcos::detail
-
diff --git a/libs/execution/src/launch_policy.cpp b/libs/execution/src/launch_policy.cpp
index 30a5f0d5d782..7204535c26f4 100644
--- a/libs/execution/src/launch_policy.cpp
+++ b/libs/execution/src/launch_policy.cpp
@@ -10,8 +10,7 @@
 #include <hpx/serialization/output_archive.hpp>
 #include <hpx/serialization/serialize.hpp>
 
-namespace hpx
-{
+namespace hpx {
     ///////////////////////////////////////////////////////////////////////////
     const detail::async_policy launch::async =
         detail::async_policy{threads::thread_priority_default};
@@ -32,15 +31,14 @@ namespace hpx
         detail::policy_holder<>{detail::launch_policy::async_policies};
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace detail
-    {
+    namespace detail {
         void policy_holder_base::load(
             serialization::input_archive& ar, unsigned)
         {
             int value = 0;
-            ar & value;
+            ar& value;
             policy_ = static_cast<launch_policy>(value);
-            ar & value;
+            ar& value;
             priority_ = static_cast<threads::thread_priority>(value);
         }
 
@@ -48,10 +46,9 @@ namespace hpx
             serialization::output_archive& ar, unsigned) const
         {
             int value = static_cast<int>(policy_);
-            ar & value;
+            ar& value;
             value = static_cast<int>(priority_);
-            ar & value;
+            ar& value;
         }
-    }
-}
-
+    }    // namespace detail
+}    // namespace hpx