diff --git a/examples/any_unique.cpp b/examples/any_unique.cpp
index 16989a24..056afcbd 100644
--- a/examples/any_unique.cpp
+++ b/examples/any_unique.cpp
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 #include <unifex/any_unique.hpp>
-#include <unifex/type_traits.hpp>
 #include <unifex/memory_resource.hpp>
 #include <unifex/type_index.hpp>
+#include <unifex/type_traits.hpp>
 
+#include <atomic>
 #include <string>
 #include <typeindex>
-#include <atomic>
 
 template <typename T>
 using is_type_index = std::is_same<std::type_index, T>;
@@ -35,21 +35,18 @@ inline constexpr struct get_typeid_cpo {
   }
 
   template <typename T>
-  auto operator()(const T& x) const noexcept ->
-      unifex::tag_invoke_result_t<get_typeid_cpo, const T&> {
-    static_assert(
-      std::is_same_v<
-          unifex::type_index,
-          unifex::tag_invoke_result_t<get_typeid_cpo, const T&>>);
+  auto operator()(const T& x) const noexcept
+      -> unifex::tag_invoke_result_t<get_typeid_cpo, const T&> {
+    static_assert(std::is_same_v<
+                  unifex::type_index,
+                  unifex::tag_invoke_result_t<get_typeid_cpo, const T&>>);
     return tag_invoke(get_typeid_cpo{}, x);
   }
 } get_typeid;
 
 struct destructor {
   explicit destructor(bool& x) : ref_(x) {}
-  ~destructor() {
-    ref_ = true;
-  }
+  ~destructor() { ref_ = true; }
   bool& ref_;
 };
 
@@ -57,22 +54,20 @@ struct destructor {
 using namespace unifex::pmr;
 
 class counting_memory_resource : public memory_resource {
- public:
+public:
   explicit counting_memory_resource(memory_resource* r) noexcept : inner_(r) {}
 
-  std::size_t total_allocated_bytes() const {
-    return allocated_.load();
-  }
+  std::size_t total_allocated_bytes() const { return allocated_.load(); }
 
- private:
+private:
   void* do_allocate(std::size_t bytes, std::size_t alignment) override {
     void* p = inner_->allocate(bytes, alignment);
     allocated_ += bytes;
     return p;
   }
 
-  void do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
-      override {
+  void
+  do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override {
     allocated_ -= bytes;
     inner_->deallocate(p, bytes, alignment);
   }
diff --git a/examples/async_mutex.cpp b/examples/async_mutex.cpp
index a758ac2a..864498b0 100644
--- a/examples/async_mutex.cpp
+++ b/examples/async_mutex.cpp
@@ -21,12 +21,12 @@
 
 #if !UNIFEX_NO_COROUTINES
 
-#include <unifex/scheduler_concepts.hpp>
-#include <unifex/task.hpp>
-#include <unifex/when_all.hpp>
-#include <unifex/single_thread_context.hpp>
+#  include <unifex/scheduler_concepts.hpp>
+#  include <unifex/single_thread_context.hpp>
+#  include <unifex/task.hpp>
+#  include <unifex/when_all.hpp>
 
-#include <cstdio>
+#  include <cstdio>
 
 using namespace unifex;
 
@@ -48,8 +48,8 @@ int main() {
   single_thread_context ctx1;
   single_thread_context ctx2;
 
-  sync_wait(when_all(makeTask(ctx1.get_scheduler()),
-                     makeTask(ctx2.get_scheduler())));
+  sync_wait(
+      when_all(makeTask(ctx1.get_scheduler()), makeTask(ctx2.get_scheduler())));
 
   if (sharedState != 200'000) {
     std::printf("error: incorrect result %i, expected 2000000\n", sharedState);
@@ -59,18 +59,18 @@ int main() {
   return 0;
 }
 
-#else // UNIFEX_NO_COROUTINES
+#else  // UNIFEX_NO_COROUTINES
 
-#include <cstdio>
+#  include <cstdio>
 
 int main() {
-    // Very simple usage of async_mutex.
+  // Very simple usage of async_mutex.
 
-    unifex::async_mutex m;
-    unifex::sync_wait(m.async_lock());
-    m.unlock();
-    
-    return 0;
+  unifex::async_mutex m;
+  unifex::sync_wait(m.async_lock());
+  m.unlock();
+
+  return 0;
 }
 
-#endif // UNIFEX_NO_COROUTINES
+#endif  // UNIFEX_NO_COROUTINES
diff --git a/examples/async_trace.cpp b/examples/async_trace.cpp
index bf221370..af741599 100644
--- a/examples/async_trace.cpp
+++ b/examples/async_trace.cpp
@@ -15,20 +15,20 @@
  */
 #include <unifex/async_trace.hpp>
 
-#include <unifex/sequence.hpp>
 #include <unifex/scheduler_concepts.hpp>
+#include <unifex/sequence.hpp>
 #include <unifex/sync_wait.hpp>
 
 #include <unifex/config.hpp>
+#include <unifex/defer.hpp>
+#include <unifex/finally.hpp>
 #include <unifex/just.hpp>
-#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/then.hpp>
-#include <unifex/finally.hpp>
+#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/when_all.hpp>
-#include <unifex/defer.hpp>
 
 #if !UNIFEX_NO_COROUTINES
-#include <unifex/task.hpp>
+#  include <unifex/task.hpp>
 #endif
 
 #include <chrono>
@@ -44,16 +44,16 @@ using namespace std::chrono_literals;
 auto dump_async_trace(std::string tag = {}) {
   return then(
       async_trace_sender{},
-      [tag = std::move(tag)](const std::vector<async_trace_entry> &entries) {
+      [tag = std::move(tag)](const std::vector<async_trace_entry>& entries) {
         std::cout << "Async Trace (" << tag << "):\n";
-        for (auto &entry : entries) {
-        std::cout << " " << entry.depth << " [-> " << entry.parentIndex
+        for (auto& entry : entries) {
+          std::cout << " " << entry.depth << " [-> " << entry.parentIndex
                     << "]: "
-        #if UNIFEX_ENABLE_CONTINUATION_VISITATIONS
+#if UNIFEX_ENABLE_CONTINUATION_VISITATIONS
                     << entry.continuation.type().name()
-        #else
+#else
                     << "(continuation typenames disabled)"
-        #endif
+#endif
                     << " @ 0x";
           std::cout.setf(std::ios::hex, std::ios::basefield);
           std::cout << entry.continuation.address();
@@ -64,14 +64,13 @@ auto dump_async_trace(std::string tag = {}) {
 }
 
 template <typename Sender>
-auto dump_async_trace_on_start(Sender &&sender, std::string tag = {}) {
+auto dump_async_trace_on_start(Sender&& sender, std::string tag = {}) {
   return unifex::sequence(dump_async_trace(std::move(tag)), (Sender &&) sender);
 }
 
 template <typename Sender>
-auto dump_async_trace_on_completion(Sender &&sender, std::string tag = {}) {
-  return unifex::finally((Sender &&) sender,
-                          dump_async_trace(std::move(tag)));
+auto dump_async_trace_on_completion(Sender&& sender, std::string tag = {}) {
+  return unifex::finally((Sender &&) sender, dump_async_trace(std::move(tag)));
 }
 
 #if !UNIFEX_NO_COROUTINES
@@ -87,42 +86,39 @@ int main() {
 
   auto startTime = steady_clock::now();
 
-  sync_wait(
-    then(
+  sync_wait(then(
       when_all(
-        then(
-          dump_async_trace_on_start(
-            schedule_after(context.get_scheduler(), 100ms), "part1"),
-          [=]() {
-            auto time = steady_clock::now() - startTime;
-            auto timeMs = duration_cast<milliseconds>(time).count();
-            std::cout << "part1 finished - [" << timeMs << "]\n";
-            return time;
-          }),
-        then(
-          dump_async_trace_on_completion(
-            schedule_after(context.get_scheduler(), 200ms), "part2"),
-          [=]() {
-            auto time = steady_clock::now() - startTime;
-            auto timeMs = duration_cast<milliseconds>(time).count();
-            std::cout << "part2 finished - [" << timeMs << "]\n";
-            return time;
-          }),
+          then(
+              dump_async_trace_on_start(
+                  schedule_after(context.get_scheduler(), 100ms), "part1"),
+              [=]() {
+                auto time = steady_clock::now() - startTime;
+                auto timeMs = duration_cast<milliseconds>(time).count();
+                std::cout << "part1 finished - [" << timeMs << "]\n";
+                return time;
+              }),
+          then(
+              dump_async_trace_on_completion(
+                  schedule_after(context.get_scheduler(), 200ms), "part2"),
+              [=]() {
+                auto time = steady_clock::now() - startTime;
+                auto timeMs = duration_cast<milliseconds>(time).count();
+                std::cout << "part2 finished - [" << timeMs << "]\n";
+                return time;
+              }),
 #if !UNIFEX_NO_COROUTINES
-        dump_async_trace_in_coroutine()
+          dump_async_trace_in_coroutine()
 #else
-        just(42)
-#endif // UNIFEX_NO_COROUTINES
-      ),
-      [](auto &&a, auto &&b, auto &&c) {
+          just(42)
+#endif  // UNIFEX_NO_COROUTINES
+              ),
+      [](auto&& a, auto&& b, auto&& c) {
         std::cout
             << "when_all finished - ["
             << duration_cast<milliseconds>(std::get<0>(std::get<0>(a))).count()
             << ", "
             << duration_cast<milliseconds>(std::get<0>(std::get<0>(b))).count()
-            << ", "
-            << std::get<0>(std::get<0>(c))
-            << "]\n";
+            << ", " << std::get<0>(std::get<0>(c)) << "]\n";
       }));
 
   std::cout << "all done\n";
diff --git a/examples/coroutine_stream_consumer.cpp b/examples/coroutine_stream_consumer.cpp
index 792baab1..6b8f9af3 100644
--- a/examples/coroutine_stream_consumer.cpp
+++ b/examples/coroutine_stream_consumer.cpp
@@ -17,29 +17,29 @@
 
 #if !UNIFEX_NO_COROUTINES
 
-#include <unifex/delay.hpp>
-#include <unifex/range_stream.hpp>
-#include <unifex/scheduler_concepts.hpp>
-#include <unifex/single.hpp>
-#include <unifex/stop_immediately.hpp>
-#include <unifex/sync_wait.hpp>
-#include <unifex/take_until.hpp>
-#include <unifex/task.hpp>
-#include <unifex/timed_single_thread_context.hpp>
-#include <unifex/via_stream.hpp>
-#include <unifex/let_done.hpp>
-#include <unifex/then.hpp>
-#include <unifex/just.hpp>
-#include <unifex/done_as_optional.hpp>
-
-#include <chrono>
-#include <cstdio>
+#  include <unifex/delay.hpp>
+#  include <unifex/done_as_optional.hpp>
+#  include <unifex/just.hpp>
+#  include <unifex/let_done.hpp>
+#  include <unifex/range_stream.hpp>
+#  include <unifex/scheduler_concepts.hpp>
+#  include <unifex/single.hpp>
+#  include <unifex/stop_immediately.hpp>
+#  include <unifex/sync_wait.hpp>
+#  include <unifex/take_until.hpp>
+#  include <unifex/task.hpp>
+#  include <unifex/then.hpp>
+#  include <unifex/timed_single_thread_context.hpp>
+#  include <unifex/via_stream.hpp>
+
+#  include <chrono>
+#  include <cstdio>
 
 using namespace unifex;
 
-template<typename Sender>
+template <typename Sender>
 auto done_as_void(Sender&& sender) {
-  return let_done((Sender&&)sender, [] { return just(); });
+  return let_done((Sender &&) sender, [] { return just(); });
 }
 
 int main() {
@@ -78,9 +78,9 @@ int main() {
   return 0;
 }
 
-#else // UNIFEX_NO_COROUTINES
+#else  // UNIFEX_NO_COROUTINES
 
-#include <cstdio>
+#  include <cstdio>
 
 int main() {
   std::printf(
@@ -88,4 +88,4 @@ int main() {
   return 0;
 }
 
-#endif // UNIFEX_NO_COROUTINES
+#endif  // UNIFEX_NO_COROUTINES
diff --git a/examples/delayed_stream_cancellation.cpp b/examples/delayed_stream_cancellation.cpp
index edd71f58..d3f6a314 100644
--- a/examples/delayed_stream_cancellation.cpp
+++ b/examples/delayed_stream_cancellation.cpp
@@ -17,12 +17,12 @@
 #include <unifex/for_each.hpp>
 #include <unifex/inplace_stop_token.hpp>
 #include <unifex/range_stream.hpp>
+#include <unifex/scheduler_concepts.hpp>
+#include <unifex/stop_when.hpp>
 #include <unifex/sync_wait.hpp>
+#include <unifex/then.hpp>
 #include <unifex/timed_single_thread_context.hpp>
 #include <unifex/via_stream.hpp>
-#include <unifex/scheduler_concepts.hpp>
-#include <unifex/then.hpp>
-#include <unifex/stop_when.hpp>
 
 #include <chrono>
 #include <cstdio>
@@ -37,17 +37,17 @@ int main() {
 
   auto startTime = steady_clock::now();
 
-  sync_wait(
-      stop_when(
-          for_each(
-              delay(range_stream{0, 100}, context.get_scheduler(), 100ms),
-              [startTime](int value) {
-                auto ms = duration_cast<milliseconds>(steady_clock::now() - startTime);
-                std::printf("[%i ms] %i\n", (int)ms.count(), value);
-              }),
-          then(
-            schedule_after(context.get_scheduler(), 500ms),
-            [] { std::printf("cancelling\n"); })));
+  sync_wait(stop_when(
+      for_each(
+          delay(range_stream{0, 100}, context.get_scheduler(), 100ms),
+          [startTime](int value) {
+            auto ms =
+                duration_cast<milliseconds>(steady_clock::now() - startTime);
+            std::printf("[%i ms] %i\n", (int)ms.count(), value);
+          }),
+      then(schedule_after(context.get_scheduler(), 500ms), [] {
+        std::printf("cancelling\n");
+      })));
 
   return 0;
 }
diff --git a/examples/for_each_synchronous.cpp b/examples/for_each_synchronous.cpp
index b26d1db4..1dd1900d 100644
--- a/examples/for_each_synchronous.cpp
+++ b/examples/for_each_synchronous.cpp
@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <unifex/sync_wait.hpp>
-#include <unifex/transform_stream.hpp>
 #include <unifex/for_each.hpp>
-#include <unifex/then.hpp>
 #include <unifex/range_stream.hpp>
+#include <unifex/sync_wait.hpp>
+#include <unifex/then.hpp>
+#include <unifex/transform_stream.hpp>
 
 #include <cstdio>
 
diff --git a/examples/for_each_via_trampoline.cpp b/examples/for_each_via_trampoline.cpp
index b97a6ced..491e04a3 100644
--- a/examples/for_each_via_trampoline.cpp
+++ b/examples/for_each_via_trampoline.cpp
@@ -16,8 +16,8 @@
 #include <unifex/for_each.hpp>
 #include <unifex/range_stream.hpp>
 #include <unifex/sync_wait.hpp>
-#include <unifex/trampoline_scheduler.hpp>
 #include <unifex/then.hpp>
+#include <unifex/trampoline_scheduler.hpp>
 #include <unifex/transform_stream.hpp>
 #include <unifex/via_stream.hpp>
 
diff --git a/examples/fp_delegation.cpp b/examples/fp_delegation.cpp
index bc50efca..eb010d0d 100644
--- a/examples/fp_delegation.cpp
+++ b/examples/fp_delegation.cpp
@@ -36,29 +36,25 @@ namespace {
 class delegating_scheduler;
 
 class delegating_context {
-  public:
+public:
   delegating_context(int capacity) : capacity_{capacity} {}
 
   bool reserve() {
     auto lck = std::scoped_lock{m_};
     bool reservation_made = reservation_count_ < capacity_;
-    if(reservation_made) {
+    if (reservation_made) {
       ++reservation_count_;
     }
     return reservation_made;
   }
 
-  int get_count() {
-    return run_count_;
-  }
+  int get_count() { return run_count_; }
 
-  void run() {
-    run_count_++;
-  }
+  void run() { run_count_++; }
 
   delegating_scheduler get_scheduler() noexcept;
 
-  private:
+private:
   friend class delegating_sender;
   std::mutex m_;
   int reservation_count_{0};
@@ -67,34 +63,30 @@ class delegating_context {
   timed_single_thread_context single_thread_context_;
 };
 
-template<typename T>
+template <typename T>
 struct FuncWrapper {
   T func_;
-  operator std::invoke_result_t<T>() {
-    return func_();
-  }
+  operator std::invoke_result_t<T>() { return func_(); }
 };
 
 template <typename DelegatedOperationState, typename LocalOperationState>
 class delegating_operation final {
-  public:
-  template<class InitFunc>
-  delegating_operation(InitFunc&& func, delegating_context* context) :
-    op_{
-      std::in_place_type_t<remove_cvref_t<decltype(func())>>{},
-      FuncWrapper<InitFunc>{std::forward<InitFunc>(func)}},
-    context_{context} {
-  }
-
+public:
+  template <class InitFunc>
+  delegating_operation(InitFunc&& func, delegating_context* context)
+    : op_{std::in_place_type_t<remove_cvref_t<decltype(func())>>{},
+          FuncWrapper<InitFunc>{std::forward<InitFunc>(func)}}
+    , context_{context} {}
 
   inline void start() noexcept {
-    if(std::holds_alternative<DelegatedOperationState>(op_)) {
+    if (std::holds_alternative<DelegatedOperationState>(op_)) {
       // Start a delegated operation
       std::get<DelegatedOperationState>(op_).start();
     } else {
       // Start immediately on the local context
       context_->run();
-      std::get<LocalOperationState>(op_).start();;
+      std::get<LocalOperationState>(op_).start();
+      ;
     }
   }
 
@@ -103,10 +95,12 @@ class delegating_operation final {
 };
 
 class delegating_sender {
-  public:
+public:
   template <
-      template <typename...> class Variant,
-      template <typename...> class Tuple>
+      template <typename...>
+      class Variant,
+      template <typename...>
+      class Tuple>
   using value_types = Variant<Tuple<>>;
 
   template <template <typename...> class Variant>
@@ -114,26 +108,22 @@ class delegating_sender {
 
   static constexpr bool sends_done = true;
 
-  template<typename OpType>
+  template <typename OpType>
   struct LocalContextType {
     OpType op_;
 
-    inline void start() noexcept {
-      op_.start();
-    }
+    inline void start() noexcept { op_.start(); }
   };
 
-  using SchedSender =
-      schedule_result_t<
-          decltype(UNIFEX_DECLVAL(timed_single_thread_context&).get_scheduler())>;
+  using SchedSender = schedule_result_t<
+      decltype(UNIFEX_DECLVAL(timed_single_thread_context&).get_scheduler())>;
 
   template <typename Receiver>
-  using operation =
-      delegating_operation<
-          connect_result_t<
-              schedule_result_t<get_scheduler_result_t<Receiver>>,
-              Receiver>,
-          LocalContextType<connect_result_t<SchedSender, Receiver>>>;
+  using operation = delegating_operation<
+      connect_result_t<
+          schedule_result_t<get_scheduler_result_t<Receiver>>,
+          Receiver>,
+      LocalContextType<connect_result_t<SchedSender, Receiver>>>;
 
   template <typename Receiver>
   operation<Receiver> connect(Receiver&& receiver) {
@@ -141,19 +131,19 @@ class delegating_sender {
     using LC = LocalContextType<connect_result_t<SchedSender, Receiver>>;
     using op = operation<Receiver>;
 
-    if(context_->reserve()) {
+    if (context_->reserve()) {
       auto local_op = [&receiver, context = context_]() mutable {
         return LC{unifex::connect(
-          unifex::schedule(context->single_thread_context_.get_scheduler()),
-          (Receiver&&)receiver)};};
+            unifex::schedule(context->single_thread_context_.get_scheduler()),
+            (Receiver &&) receiver)};
+      };
       return op{std::move(local_op), context_};
     }
 
     auto target_op = [&receiver]() mutable {
       return unifex::connect(
-        unifex::schedule(
-          unifex::get_scheduler(std::as_const(receiver))),
-          (Receiver&&)receiver);
+          unifex::schedule(unifex::get_scheduler(std::as_const(receiver))),
+          (Receiver &&) receiver);
     };
 
     return op{std::move(target_op), context_};
@@ -163,15 +153,15 @@ class delegating_sender {
 };
 
 class delegating_scheduler {
-  public:
-  auto schedule() const noexcept {
-    return delegating_sender{context_};
-  }
+public:
+  auto schedule() const noexcept { return delegating_sender{context_}; }
 
-  [[maybe_unused]] friend bool operator==(delegating_scheduler, delegating_scheduler) noexcept {
+  [[maybe_unused]] friend bool
+  operator==(delegating_scheduler, delegating_scheduler) noexcept {
     return true;
   }
-  [[maybe_unused]] friend bool operator!=(delegating_scheduler, delegating_scheduler) noexcept {
+  [[maybe_unused]] friend bool
+  operator!=(delegating_scheduler, delegating_scheduler) noexcept {
     return false;
   }
 
@@ -181,30 +171,33 @@ class delegating_scheduler {
 delegating_scheduler delegating_context::get_scheduler() noexcept {
   return delegating_scheduler{this};
 }
-} // namespace
+}  // namespace
 
 int main() {
   delegating_context inner_delegating_ctx{2};
   delegating_context outer_delegating_ctx{3};
 
   // Try inner context, then outer context, delegating to ctx if necessary
-  sync_wait(
-      then(
-          for_each(
-              via_stream(
-                  outer_delegating_ctx.get_scheduler(),
-                  transform_stream(
-                      via_stream(
-                          inner_delegating_ctx.get_scheduler(),
-                          transform_stream(
-                              range_stream{0, 10},
-                              [](int value) { return value + 1; })),
-                          [](int value) { return value * value; })),
-              [](int value) { std::printf("got %i\n", value); }),
-          []() { std::printf("done\n"); }));
-
-  std::printf("inner_delegating_ctx operations: %d\n", inner_delegating_ctx.get_count());
-  std::printf("outer_delegating_ctx operations: %d\n", outer_delegating_ctx.get_count());
+  sync_wait(then(
+      for_each(
+          via_stream(
+              outer_delegating_ctx.get_scheduler(),
+              transform_stream(
+                  via_stream(
+                      inner_delegating_ctx.get_scheduler(),
+                      transform_stream(
+                          range_stream{0, 10},
+                          [](int value) { return value + 1; })),
+                  [](int value) { return value * value; })),
+          [](int value) { std::printf("got %i\n", value); }),
+      []() { std::printf("done\n"); }));
+
+  std::printf(
+      "inner_delegating_ctx operations: %d\n",
+      inner_delegating_ctx.get_count());
+  std::printf(
+      "outer_delegating_ctx operations: %d\n",
+      outer_delegating_ctx.get_count());
 
   return 0;
 }
diff --git a/examples/get_scheduler.cpp b/examples/get_scheduler.cpp
index 5fd37ddf..02119949 100644
--- a/examples/get_scheduler.cpp
+++ b/examples/get_scheduler.cpp
@@ -33,8 +33,7 @@ int main() {
 
   // Check that the schedule() operation can pick up the current
   // scheduler from the receiver which we inject by using 'with_query_value()'.
-  sync_wait(with_query_value(schedule(), get_scheduler,
-                             ctx.get_scheduler()));
+  sync_wait(with_query_value(schedule(), get_scheduler, ctx.get_scheduler()));
 
   // Check that the schedule_after(d) operation can pick up the current
   // scheduler from the receiver.
@@ -45,14 +44,16 @@ int main() {
   // composed operations.
   sync_wait(with_query_value(
       then(
-          for_each(via_stream(current_scheduler,
-                              transform_stream(range_stream{0, 10},
-                                               [](int value) {
-                                                 return value * value;
-                                               })),
-                   [](int value) { std::printf("got %i\n", value); }),
+          for_each(
+              via_stream(
+                  current_scheduler,
+                  transform_stream(
+                      range_stream{0, 10},
+                      [](int value) { return value * value; })),
+              [](int value) { std::printf("got %i\n", value); }),
           []() { std::printf("done\n"); }),
-      get_scheduler, ctx.get_scheduler()));
+      get_scheduler,
+      ctx.get_scheduler()));
 
   return 0;
 }
diff --git a/examples/heap_allocate_operation.cpp b/examples/heap_allocate_operation.cpp
index cbacb6c7..a27f051b 100644
--- a/examples/heap_allocate_operation.cpp
+++ b/examples/heap_allocate_operation.cpp
@@ -15,10 +15,10 @@
  */
 
 #include <unifex/allocate.hpp>
+#include <unifex/scheduler_concepts.hpp>
 #include <unifex/single_thread_context.hpp>
 #include <unifex/sync_wait.hpp>
 #include <unifex/then.hpp>
-#include <unifex/scheduler_concepts.hpp>
 
 #include <array>
 #include <cstdio>
@@ -30,8 +30,8 @@ int main() {
 
   auto thread = threadContext.get_scheduler();
 
-  sync_wait(allocate(then(
-      schedule(thread), [] { std::printf("hello libunifex!\n"); })));
+  sync_wait(allocate(
+      then(schedule(thread), [] { std::printf("hello libunifex!\n"); })));
 
   return 0;
 }
diff --git a/examples/let.cpp b/examples/let.cpp
index f98b0e13..e61bfe7e 100644
--- a/examples/let.cpp
+++ b/examples/let.cpp
@@ -18,8 +18,8 @@
 #include <unifex/let_value_with.hpp>
 #include <unifex/scheduler_concepts.hpp>
 #include <unifex/sync_wait.hpp>
-#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/then.hpp>
+#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/when_all.hpp>
 
 #include <chrono>
@@ -34,8 +34,7 @@ int main() {
 
   auto async = [&](auto&& func) {
     return then(
-        schedule_after(context.get_scheduler(), 100ms),
-        (decltype(func))func);
+        schedule_after(context.get_scheduler(), 100ms), (decltype(func))func);
   };
 
   // Simple usage of 'let_value()'
@@ -63,7 +62,8 @@ int main() {
 
   sync_wait(then(
       when_all(
-          let_value(asyncVector(),
+          let_value(
+              asyncVector(),
               [&](std::vector<int>& v) {
                 return async([&] {
                   std::cout << "printing vector" << std::endl;
@@ -73,7 +73,8 @@ int main() {
                   std::cout << std::endl;
                 });
               }),
-          let_value(just(42),
+          let_value(
+              just(42),
               [&](int& x) {
                 return let_value(async([&] { return x / 2; }), [&](int& y) {
                   return async([&] { return x + y; });
@@ -89,8 +90,9 @@ int main() {
   // Simple usage of 'let_value_with()'
   // - defines an async scope in which the result of a passed invocable
   //   is in-scope for the duration of an operation.
-  std::optional<int> let_with_result =
-      sync_wait(let_value_with([] { return 42; }, [&](int& x) {
+  std::optional<int> let_with_result = sync_wait(let_value_with(
+      [] { return 42; },
+      [&](int& x) {
         printf("addressof x = %p, val = %i\n", (void*)&x, x);
         return async([&]() -> int {
           printf("successor tranform\n");
@@ -101,23 +103,23 @@ int main() {
 
   std::cout << "let_value_with done " << *let_with_result << "\n";
 
-   // let_value_with example showing use with a non-moveable type and
-   // in-place construction.
-  std::optional<int> let_with_atomic_result =
-      sync_wait(let_value_with([] { return std::atomic<int>{42}; },
-        [&](std::atomic<int>& x) {
+  // let_value_with example showing use with a non-moveable type and
+  // in-place construction.
+  std::optional<int> let_with_atomic_result = sync_wait(let_value_with(
+      [] { return std::atomic<int>{42}; },
+      [&](std::atomic<int>& x) {
+        ++x;
+        printf("addressof x = %p, val = %i\n", (void*)&x, x.load());
+        return async([&]() -> int {
           ++x;
+          printf("successor tranform\n");
           printf("addressof x = %p, val = %i\n", (void*)&x, x.load());
-          return async([&]() -> int {
-            ++x;
-            printf("successor tranform\n");
-            printf("addressof x = %p, val = %i\n", (void*)&x, x.load());
-            return x.load();
-          });
+          return x.load();
+        });
       }));
 
-  std::cout <<
-    "let_value_with on atomic type " << *let_with_atomic_result << "\n";
+  std::cout << "let_value_with on atomic type " << *let_with_atomic_result
+            << "\n";
 
   return 0;
 }
diff --git a/examples/linux/io_epoll_test.cpp b/examples/linux/io_epoll_test.cpp
index 9335fc82..94435e32 100644
--- a/examples/linux/io_epoll_test.cpp
+++ b/examples/linux/io_epoll_test.cpp
@@ -24,37 +24,37 @@
 #include <unifex/config.hpp>
 #if !UNIFEX_NO_EPOLL
 
-#include <unifex/inplace_stop_token.hpp>
-#include <unifex/just.hpp>
-#include <unifex/linux/io_epoll_context.hpp>
-#include <unifex/scheduler_concepts.hpp>
-#include <unifex/scope_guard.hpp>
-#include <unifex/sequence.hpp>
-#include <unifex/sync_wait.hpp>
-#include <unifex/then.hpp>
-#include <unifex/when_all.hpp>
-#include <unifex/repeat_effect_until.hpp>
-#include <unifex/via.hpp>
-#include <unifex/with_query_value.hpp>
-#include <unifex/let_done.hpp>
-#include <unifex/stop_when.hpp>
-#include <unifex/defer.hpp>
-#include <unifex/just_from.hpp>
-
-#include <iostream>
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
+#  include <unifex/defer.hpp>
+#  include <unifex/inplace_stop_token.hpp>
+#  include <unifex/just.hpp>
+#  include <unifex/just_from.hpp>
+#  include <unifex/let_done.hpp>
+#  include <unifex/linux/io_epoll_context.hpp>
+#  include <unifex/repeat_effect_until.hpp>
+#  include <unifex/scheduler_concepts.hpp>
+#  include <unifex/scope_guard.hpp>
+#  include <unifex/sequence.hpp>
+#  include <unifex/stop_when.hpp>
+#  include <unifex/sync_wait.hpp>
+#  include <unifex/then.hpp>
+#  include <unifex/via.hpp>
+#  include <unifex/when_all.hpp>
+#  include <unifex/with_query_value.hpp>
+
+#  include <chrono>
+#  include <cstdio>
+#  include <iostream>
+#  include <string>
+#  include <thread>
+#  include <vector>
 
 using namespace unifex;
 using namespace unifex::linuxos;
 using namespace std::chrono_literals;
 
-template<typename S>
+template <typename S>
 auto discard_value(S&& s) {
-  return then((S&&)s, [](auto&&...) noexcept {});
+  return then((S &&) s, [](auto&&...) noexcept {});
 }
 
 //! Seconds to warmup the benchmark
@@ -69,7 +69,9 @@ int main() {
   io_epoll_context ctx;
 
   inplace_stop_source stopSource;
-  std::thread t{[&] { ctx.run(stopSource.get_token()); }};
+  std::thread t{[&] {
+    ctx.run(stopSource.get_token());
+  }};
   scope_guard stopOnExit = [&]() noexcept {
     stopSource.request_stop();
     t.join();
@@ -81,13 +83,14 @@ int main() {
       auto startTime = std::chrono::steady_clock::now();
       inplace_stop_source timerStopSource;
       auto task = when_all(
-          schedule_at(scheduler, now(scheduler) + 1s)
-            | then([] { std::printf("timer 1 completed (1s)\n"); }),
-          schedule_at(scheduler, now(scheduler) + 2s)
-            | then([] { std::printf("timer 2 completed (2s)\n"); }))
-        | stop_when(
-          schedule_at(scheduler, now(scheduler) + 1500ms)
-            | then([] { std::printf("timer 3 completed (1.5s) cancelling\n"); }));
+                      schedule_at(scheduler, now(scheduler) + 1s) |
+                          then([] { std::printf("timer 1 completed (1s)\n"); }),
+                      schedule_at(scheduler, now(scheduler) + 2s) | then([] {
+                        std::printf("timer 2 completed (2s)\n");
+                      })) |
+          stop_when(schedule_at(scheduler, now(scheduler) + 1500ms) | then([] {
+                      std::printf("timer 3 completed (1.5s) cancelling\n");
+                    }));
       sync_wait(std::move(task));
       auto endTime = std::chrono::steady_clock::now();
 
@@ -101,40 +104,50 @@ int main() {
     std::printf("error: %s\n", ex.what());
   }
 
-  auto pipe_bench = [](auto& rPipeRef, auto& buffer, auto scheduler, int seconds,
-                       [[maybe_unused]] auto& data, auto& reps, [[maybe_unused]] auto& offset) {
+  auto pipe_bench = [](auto& rPipeRef,
+                       auto& buffer,
+                       auto scheduler,
+                       int seconds,
+                       [[maybe_unused]] auto& data,
+                       auto& reps,
+                       [[maybe_unused]] auto& offset) {
     return defer([&, scheduler, seconds] {
       return defer([&] {
-        return
-          // do read:
-          async_read_some(rPipeRef, as_writable_bytes(span{buffer.data() + 0, 1}))
-          | then([&](auto&&...) {
-              UNIFEX_ASSERT(data[(reps + offset) % sizeof(data)] == buffer[0]);
-              ++reps;
-            });
-      })
-        | via(scheduler)
+               return
+                   // do read:
+                   async_read_some(
+                       rPipeRef,
+                       as_writable_bytes(span{buffer.data() + 0, 1})) |
+                   then([&](auto&&...) {
+                     UNIFEX_ASSERT(
+                         data[(reps + offset) % sizeof(data)] == buffer[0]);
+                     ++reps;
+                   });
+             }) |
+          via(scheduler)
           // Repeat the reads:
-        | repeat_effect()
+          | repeat_effect()
           // stop reads after requested time
-        | stop_when(schedule_at(scheduler, now(scheduler) + std::chrono::seconds(seconds)))
+          | stop_when(schedule_at(
+                scheduler, now(scheduler) + std::chrono::seconds(seconds)))
           // complete with void when requested time expires
-        | let_done([]{return just();});
+          | let_done([] { return just(); });
     });
   };
 
-  auto pipe_write = [](auto& wPipeRef, auto databuffer, auto scheduler, auto stopToken) {
-    return
-      // write the data to one end of the pipe
-      sequence(
-        just_from([&]{ printf("writes starting!\n"); }),
-        defer([&, databuffer] { return discard_value(async_write_some(wPipeRef, databuffer)); })
-          | via(scheduler)
-          | repeat_effect()
-          | let_done([]{return just();})
-          | with_query_value(get_stop_token, stopToken),
-        just_from([&]{ printf("writes stopped!\n"); }));
-  };
+  auto pipe_write =
+      [](auto& wPipeRef, auto databuffer, auto scheduler, auto stopToken) {
+        return
+            // write the data to one end of the pipe
+            sequence(
+                just_from([&] { printf("writes starting!\n"); }),
+                defer([&, databuffer] {
+                  return discard_value(async_write_some(wPipeRef, databuffer));
+                }) | via(scheduler) |
+                    repeat_effect() | let_done([] { return just(); }) |
+                    with_query_value(get_stop_token, stopToken),
+                just_from([&] { printf("writes stopped!\n"); }));
+      };
   auto [rPipe, wPipe] = open_pipe(scheduler);
 
   auto startTime = std::chrono::high_resolution_clock::now();
@@ -147,61 +160,64 @@ int main() {
   buffer.resize(1);
   try {
     auto task = when_all(
-      // write chunk of data into one end repeatedly
-      pipe_write(wPipe, databuffer, scheduler, stopWrite.get_token()),
-      // read the data 1 byte at a time from the other end
-      sequence(
-        // read for some time before starting measurement
-        // this is done to reduce startup effects
-        pipe_bench(rPipe, buffer, scheduler, WARMUP_DURATION, data, reps, offset),
-        // reset measurements to exclude warmup
-        just_from([&] {
-          // restart reps and keep offset in data
-          offset = reps%sizeof(data);
-          reps = 0;
-          printf("warmup completed!\n");
-          // exclude the warmup time
-          startTime = endTime = std::chrono::high_resolution_clock::now();
-        }),
-        // do more reads and measure how many reads occur
-        pipe_bench(rPipe, buffer, scheduler, BENCHMARK_DURATION, data, reps, offset),
-        // report results
-        just_from([&] {
-          endTime = std::chrono::high_resolution_clock::now();
-          printf("benchmark completed!\n");
-          auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                  endTime - startTime)
-                  .count();
-          auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
-                  endTime - startTime)
-                  .count();
-          double reads = 1000000000.0 * reps / ns;
-          std::cout
-              << "completed in "
-              << ms << " ms, "
-              << ns << "ns, "
-              << reps << "ops\n";
-          std::cout
-              << "stats - "
-              << reads << "reads, "
-              << ns/reps << "ns-per-op, "
-              << reps/ms << "ops-per-ms\n";
-          stopWrite.request_stop();
-        })
-      )
-    );
+        // write chunk of data into one end repeatedly
+        pipe_write(wPipe, databuffer, scheduler, stopWrite.get_token()),
+        // read the data 1 byte at a time from the other end
+        sequence(
+            // read for some time before starting measurement
+            // this is done to reduce startup effects
+            pipe_bench(
+                rPipe, buffer, scheduler, WARMUP_DURATION, data, reps, offset),
+            // reset measurements to exclude warmup
+            just_from([&] {
+              // restart reps and keep offset in data
+              offset = reps % sizeof(data);
+              reps = 0;
+              printf("warmup completed!\n");
+              // exclude the warmup time
+              startTime = endTime = std::chrono::high_resolution_clock::now();
+            }),
+            // do more reads and measure how many reads occur
+            pipe_bench(
+                rPipe,
+                buffer,
+                scheduler,
+                BENCHMARK_DURATION,
+                data,
+                reps,
+                offset),
+            // report results
+            just_from([&] {
+              endTime = std::chrono::high_resolution_clock::now();
+              printf("benchmark completed!\n");
+              auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                            endTime - startTime)
+                            .count();
+              auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                            endTime - startTime)
+                            .count();
+              double reads = 1000000000.0 * reps / ns;
+              std::cout << "completed in " << ms << " ms, " << ns << "ns, "
+                        << reps << "ops\n";
+              std::cout << "stats - " << reads << "reads, " << ns / reps
+                        << "ns-per-op, " << reps / ms << "ops-per-ms\n";
+              stopWrite.request_stop();
+            })));
     sync_wait(std::move(task));
   } catch (const std::system_error& se) {
-    std::printf("async_read_some system_error: [%s], [%s]\n", se.code().message().c_str(), se.what());
+    std::printf(
+        "async_read_some system_error: [%s], [%s]\n",
+        se.code().message().c_str(),
+        se.what());
   } catch (const std::exception& ex) {
     std::printf("async_read_some exception: %s\n", ex.what());
   }
   return 0;
 }
 
-#else // !UNIFEX_NO_EPOLL
-#include <cstdio>
+#else  // !UNIFEX_NO_EPOLL
+#  include <cstdio>
 int main() {
   printf("epoll support not found\n");
 }
-#endif // !UNIFEX_NO_EPOLL
+#endif  // !UNIFEX_NO_EPOLL
diff --git a/examples/linux/io_uring_test.cpp b/examples/linux/io_uring_test.cpp
index dc103fd8..4ca7e76a 100644
--- a/examples/linux/io_uring_test.cpp
+++ b/examples/linux/io_uring_test.cpp
@@ -18,32 +18,32 @@
 
 #if !UNIFEX_NO_LIBURING
 
-#include <unifex/inplace_stop_token.hpp>
-#include <unifex/just.hpp>
-#include <unifex/let_value_with.hpp>
-#include <unifex/linux/io_uring_context.hpp>
-#include <unifex/scheduler_concepts.hpp>
-#include <unifex/scope_guard.hpp>
-#include <unifex/sequence.hpp>
-#include <unifex/sync_wait.hpp>
-#include <unifex/then.hpp>
-#include <unifex/when_all.hpp>
-#include <unifex/with_query_value.hpp>
-#include <unifex/just_from.hpp>
-
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
+#  include <unifex/inplace_stop_token.hpp>
+#  include <unifex/just.hpp>
+#  include <unifex/just_from.hpp>
+#  include <unifex/let_value_with.hpp>
+#  include <unifex/linux/io_uring_context.hpp>
+#  include <unifex/scheduler_concepts.hpp>
+#  include <unifex/scope_guard.hpp>
+#  include <unifex/sequence.hpp>
+#  include <unifex/sync_wait.hpp>
+#  include <unifex/then.hpp>
+#  include <unifex/when_all.hpp>
+#  include <unifex/with_query_value.hpp>
+
+#  include <chrono>
+#  include <cstdio>
+#  include <string>
+#  include <thread>
+#  include <vector>
 
 using namespace unifex;
 using namespace unifex::linuxos;
 using namespace std::chrono_literals;
 
-template<typename S>
+template <typename S>
 auto discard_value(S&& s) {
-  return then((S&&)s, [](auto&&...) noexcept {});
+  return then((S &&) s, [](auto&&...) noexcept {});
 }
 
 static constexpr unsigned char data[6] = {'h', 'e', 'l', 'l', 'o', '\n'};
@@ -97,7 +97,9 @@ int main() {
   io_uring_context ctx;
 
   inplace_stop_source stopSource;
-  std::thread t{[&] { ctx.run(stopSource.get_token()); }};
+  std::thread t{[&] {
+    ctx.run(stopSource.get_token());
+  }};
   scope_guard stopOnExit = [&]() noexcept {
     stopSource.request_stop();
     t.join();
@@ -109,8 +111,7 @@ int main() {
     {
       auto startTime = std::chrono::steady_clock::now();
       inplace_stop_source timerStopSource;
-      sync_wait(
-        with_query_value(
+      sync_wait(with_query_value(
           when_all(
               then(
                   schedule_at(scheduler, now(scheduler) + 1s),
@@ -153,12 +154,12 @@ int main() {
   return 0;
 }
 
-#else // UNIFEX_NO_LIBURING
+#else  // UNIFEX_NO_LIBURING
 
-#include <cstdio>
+#  include <cstdio>
 int main() {
   printf("liburing support not found\n");
   return 0;
 }
 
-#endif // UNIFEX_NO_LIBURING
+#endif  // UNIFEX_NO_LIBURING
diff --git a/examples/materialize.cpp b/examples/materialize.cpp
index 271f8d2d..ef42b7c9 100644
--- a/examples/materialize.cpp
+++ b/examples/materialize.cpp
@@ -14,28 +14,24 @@
  * limitations under the License.
  */
 
-#include <unifex/when_all.hpp>
-#include <unifex/materialize.hpp>
 #include <unifex/dematerialize.hpp>
-#include <unifex/then.hpp>
-#include <unifex/sync_wait.hpp>
-#include <unifex/single_thread_context.hpp>
+#include <unifex/materialize.hpp>
 #include <unifex/scheduler_concepts.hpp>
+#include <unifex/single_thread_context.hpp>
+#include <unifex/sync_wait.hpp>
+#include <unifex/then.hpp>
+#include <unifex/when_all.hpp>
 
 #include <optional>
 
 using namespace unifex;
 
 int main() {
-    single_thread_context ctx;
+  single_thread_context ctx;
 
-    [[maybe_unused]] std::optional<int> result = sync_wait(
-        dematerialize(
-            materialize(
-                then(
-                    schedule(ctx.get_scheduler()),
-                    []() { return 42; }))));
-    UNIFEX_ASSERT(result.value() == 42);
+  [[maybe_unused]] std::optional<int> result = sync_wait(dematerialize(
+      materialize(then(schedule(ctx.get_scheduler()), []() { return 42; }))));
+  UNIFEX_ASSERT(result.value() == 42);
 
-    return 0;
+  return 0;
 }
diff --git a/examples/never_stream_cancellation.cpp b/examples/never_stream_cancellation.cpp
index e620f3ae..efc7f828 100644
--- a/examples/never_stream_cancellation.cpp
+++ b/examples/never_stream_cancellation.cpp
@@ -17,11 +17,11 @@
 #include <unifex/for_each.hpp>
 #include <unifex/inplace_stop_token.hpp>
 #include <unifex/never.hpp>
-#include <unifex/sync_wait.hpp>
+#include <unifex/scheduler_concepts.hpp>
 #include <unifex/stop_when.hpp>
+#include <unifex/sync_wait.hpp>
 #include <unifex/then.hpp>
 #include <unifex/timed_single_thread_context.hpp>
-#include <unifex/scheduler_concepts.hpp>
 
 #include <chrono>
 #include <cstdio>
@@ -34,17 +34,16 @@ using namespace unifex;
 int main() {
   timed_single_thread_context context;
 
-  std::optional<unit> result = sync_wait(
-    stop_when(
+  std::optional<unit> result = sync_wait(stop_when(
       for_each(
           never_stream{},
           [](auto) {
             std::printf("got value");
             std::fflush(stdout);
           }),
-      then(
-        schedule_after(context.get_scheduler(), 100ms),
-        [] { std::printf("trigger completing, about to request stop\n"); })));
+      then(schedule_after(context.get_scheduler(), 100ms), [] {
+        std::printf("trigger completing, about to request stop\n");
+      })));
 
   std::printf("completed with %s\n", result ? "unit" : "nullopt");
 
diff --git a/examples/new_thread_context.cpp b/examples/new_thread_context.cpp
index b522252e..1282381e 100644
--- a/examples/new_thread_context.cpp
+++ b/examples/new_thread_context.cpp
@@ -27,22 +27,22 @@
 #include <thread>
 
 struct trace_construction_destruction {
-    static std::atomic<int> instanceCount; 
+  static std::atomic<int> instanceCount;
 
-    trace_construction_destruction() {
-        ++instanceCount;
-        std::stringstream s;
-        s << "thread_local at address " << (void*)this
-          << " constructing on thread " << std::this_thread::get_id() << "\n";
-        std::cout << s.str();
-    }
-    ~trace_construction_destruction() {
-        --instanceCount;
-        std::stringstream s;
-        s << "thread_local at address " << (void*)this
-          << " destructing on thread " << std::this_thread::get_id() << "\n";
-        std::cout << s.str();
-    }
+  trace_construction_destruction() {
+    ++instanceCount;
+    std::stringstream s;
+    s << "thread_local at address " << (void*)this << " constructing on thread "
+      << std::this_thread::get_id() << "\n";
+    std::cout << s.str();
+  }
+  ~trace_construction_destruction() {
+    --instanceCount;
+    std::stringstream s;
+    s << "thread_local at address " << (void*)this << " destructing on thread "
+      << std::this_thread::get_id() << "\n";
+    std::cout << s.str();
+  }
 };
 
 std::atomic<int> trace_construction_destruction::instanceCount = 0;
@@ -52,24 +52,21 @@ int main() {
     unifex::new_thread_context ctx;
 
     auto makeThreadTask = [&](int i) {
-        return unifex::then(
-            unifex::schedule(ctx.get_scheduler()),
-            [i] {
-                std::stringstream s;
-                s << "Task " << i << " running on thread " << std::this_thread::get_id()
-                  << "\n";
-                std::cout << s.str();
+      return unifex::then(unifex::schedule(ctx.get_scheduler()), [i] {
+        std::stringstream s;
+        s << "Task " << i << " running on thread " << std::this_thread::get_id()
+          << "\n";
+        std::cout << s.str();
 
-                thread_local trace_construction_destruction t;
-            });
+        thread_local trace_construction_destruction t;
+      });
     };
 
-    unifex::sync_wait(
-        unifex::when_all(
-            makeThreadTask(1),
-            makeThreadTask(2),
-            makeThreadTask(3),
-            makeThreadTask(4)));
+    unifex::sync_wait(unifex::when_all(
+        makeThreadTask(1),
+        makeThreadTask(2),
+        makeThreadTask(3),
+        makeThreadTask(4)));
 
     std::cout << "shutting down new_thread_context\n";
   }
diff --git a/examples/p1897.cpp b/examples/p1897.cpp
index abaf83d1..51bd5ebd 100644
--- a/examples/p1897.cpp
+++ b/examples/p1897.cpp
@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <unifex/indexed_for.hpp>
 #include <unifex/just.hpp>
 #include <unifex/let_value.hpp>
-#include <unifex/then.hpp>
 #include <unifex/scheduler_concepts.hpp>
 #include <unifex/sync_wait.hpp>
+#include <unifex/then.hpp>
 #include <unifex/timed_single_thread_context.hpp>
-#include <unifex/indexed_for.hpp>
 #include <unifex/when_all.hpp>
 
 #include <chrono>
@@ -31,10 +31,10 @@ using namespace std::chrono_literals;
 
 namespace execution {
 class sequenced_policy {};
-class parallel_policy{};
+class parallel_policy {};
 inline constexpr sequenced_policy seq{};
 inline constexpr parallel_policy par{};
-}
+}  // namespace execution
 
 namespace ranges {
 struct int_iterator {
@@ -48,9 +48,7 @@ struct int_iterator {
     return base_ + static_cast<int>(offset);
   }
 
-  int operator*() const {
-    return base_;
-  }
+  int operator*() const { return base_; }
 
   int_iterator operator++() {
     ++base_;
@@ -63,9 +61,7 @@ struct int_iterator {
     return cur;
   }
 
-  bool operator!=(const int_iterator& rhs) const {
-    return base_ != rhs.base_;
-  }
+  bool operator!=(const int_iterator& rhs) const { return base_ != rhs.base_; }
 
   int base_;
 };
@@ -74,56 +70,46 @@ struct iota_view {
   int size_;
   using iterator = int_iterator;
 
-  int_iterator begin() {
-    return int_iterator{0};
-  }
+  int_iterator begin() { return int_iterator{0}; }
 
-  int_iterator end() {
-    return int_iterator{size_};
-  }
+  int_iterator end() { return int_iterator{size_}; }
 
-  size_t size() const {
-    return size_;
-  }
+  size_t size() const { return size_; }
 };
-} // namespace ranges
+}  // namespace ranges
 
 int main() {
   // use seq, which supports a forward range
   auto result = sync_wait(indexed_for(
-      just(42),
-      execution::seq,
-      ranges::iota_view{10},
-      [](int idx, int& x) {
+      just(42), execution::seq, ranges::iota_view{10}, [](int idx, int& x) {
         x = x + idx;
       }));
 
   std::cout << "all done " << *result << "\n";
 
   // indexed_for example from P1897R2:
-  auto  just_sender =
-    just(std::vector<int>{3, 4, 5}, 10);
+  auto just_sender = just(std::vector<int>{3, 4, 5}, 10);
 
   // Use par which requires range to be random access
-  auto indexed_for_sender =
-    indexed_for(
+  auto indexed_for_sender = indexed_for(
       std::move(just_sender),
       execution::par,
       ranges::iota_view{3},
-      [](int idx, std::vector<int>& vec, const int& i){
+      [](int idx, std::vector<int>& vec, const int& i) {
         vec[idx] = vec[idx] + i + idx;
       });
 
-  auto transform_sender = then(
-    std::move(indexed_for_sender), [](std::vector<int> vec, int /*i*/){return vec;});
+  auto transform_sender =
+      then(std::move(indexed_for_sender), [](std::vector<int> vec, int /*i*/) {
+        return vec;
+      });
 
-  // Slight difference from p1897R2 because unifex's sync_wait returns an optional
-  // to account for cancellation
-  std::vector<int> vector_result =
-    *sync_wait(std::move(transform_sender));
+  // Slight difference from p1897R2 because unifex's sync_wait returns an
+  // optional to account for cancellation
+  std::vector<int> vector_result = *sync_wait(std::move(transform_sender));
 
   std::cout << "vector result:\n";
-  for(auto v : vector_result) {
+  for (auto v : vector_result) {
     std::cout << "\t" << v << "\n";
   }
 
diff --git a/examples/reduce_synchronous.cpp b/examples/reduce_synchronous.cpp
index 332305f0..4b8f1503 100644
--- a/examples/reduce_synchronous.cpp
+++ b/examples/reduce_synchronous.cpp
@@ -13,24 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <unifex/sync_wait.hpp>
-#include <unifex/transform_stream.hpp>
+#include <unifex/range_stream.hpp>
 #include <unifex/reduce_stream.hpp>
+#include <unifex/sync_wait.hpp>
 #include <unifex/then.hpp>
-#include <unifex/range_stream.hpp>
+#include <unifex/transform_stream.hpp>
 
 #include <cstdio>
 
 using namespace unifex;
 
 int main() {
-
   int finalResult;
   sync_wait(then(
       reduce_stream(
           transform_stream(
-              range_stream{0, 10},
-              [](int value) { return value * value; }),
+              range_stream{0, 10}, [](int value) { return value * value; }),
           0,
           [](int state, int value) { return state + value; }),
       [&](int result) { finalResult = result; }));
diff --git a/examples/reduce_with_trampoline.cpp b/examples/reduce_with_trampoline.cpp
index 797ba8ae..cff623ca 100644
--- a/examples/reduce_with_trampoline.cpp
+++ b/examples/reduce_with_trampoline.cpp
@@ -16,8 +16,8 @@
 #include <unifex/range_stream.hpp>
 #include <unifex/reduce_stream.hpp>
 #include <unifex/sync_wait.hpp>
-#include <unifex/trampoline_scheduler.hpp>
 #include <unifex/then.hpp>
+#include <unifex/trampoline_scheduler.hpp>
 #include <unifex/transform_stream.hpp>
 #include <unifex/via_stream.hpp>
 
diff --git a/examples/schedule_with_subscheduler.cpp b/examples/schedule_with_subscheduler.cpp
index 2277e01a..ad246353 100644
--- a/examples/schedule_with_subscheduler.cpp
+++ b/examples/schedule_with_subscheduler.cpp
@@ -15,8 +15,8 @@
  */
 #include <unifex/schedule_with_subscheduler.hpp>
 #include <unifex/sync_wait.hpp>
-#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/then.hpp>
+#include <unifex/timed_single_thread_context.hpp>
 
 using namespace unifex;
 
@@ -24,9 +24,10 @@ int main() {
   timed_single_thread_context context;
   auto schedr = context.get_scheduler();
 
-  std::optional<bool> result = sync_wait(then(
-      schedule_with_subscheduler(schedr),
-      [&](auto subScheduler) noexcept { return subScheduler == schedr; }));
+  std::optional<bool> result = sync_wait(
+      then(schedule_with_subscheduler(schedr), [&](auto subScheduler) noexcept {
+        return subScheduler == schedr;
+      }));
 
   if (result.has_value() && result.value()) {
     // Success
diff --git a/examples/stop_immediately.cpp b/examples/stop_immediately.cpp
index bc787c00..97b27469 100644
--- a/examples/stop_immediately.cpp
+++ b/examples/stop_immediately.cpp
@@ -36,16 +36,15 @@ int main() {
 
   auto startTime = steady_clock::now();
 
-  [[maybe_unused]] std::optional<unit> result =
-      eventLoop.sync_wait(for_each(
-          take_until(
-              stop_immediately<int>(
-                  delay(range_stream{0, 100}, eventLoop.get_scheduler(), 50ms)),
-              single(schedule_after(eventLoop.get_scheduler(), 500ms))),
-          [startTime](int value) {
-            auto ms = duration_cast<milliseconds>(steady_clock::now() - startTime);
-            std::printf("[%i ms] %i\n", (int)ms.count(), value);
-          }));
+  [[maybe_unused]] std::optional<unit> result = eventLoop.sync_wait(for_each(
+      take_until(
+          stop_immediately<int>(
+              delay(range_stream{0, 100}, eventLoop.get_scheduler(), 50ms)),
+          single(schedule_after(eventLoop.get_scheduler(), 500ms))),
+      [startTime](int value) {
+        auto ms = duration_cast<milliseconds>(steady_clock::now() - startTime);
+        std::printf("[%i ms] %i\n", (int)ms.count(), value);
+      }));
 
   return 0;
 }
diff --git a/examples/stream_cancellation.cpp b/examples/stream_cancellation.cpp
index 8bf2ba20..12e90956 100644
--- a/examples/stream_cancellation.cpp
+++ b/examples/stream_cancellation.cpp
@@ -19,9 +19,9 @@
 #include <unifex/on_stream.hpp>
 #include <unifex/range_stream.hpp>
 #include <unifex/scheduler_concepts.hpp>
-#include <unifex/timed_single_thread_context.hpp>
-#include <unifex/sync_wait.hpp>
 #include <unifex/stop_when.hpp>
+#include <unifex/sync_wait.hpp>
+#include <unifex/timed_single_thread_context.hpp>
 
 #include <chrono>
 #include <cstdio>
@@ -37,17 +37,18 @@ int main() {
 
   auto startTime = steady_clock::now();
 
-  auto op = on_stream(current_scheduler, range_stream{0, 20})
-    | for_each([](int value) {
-        // Simulate some work
-        std::printf("processing %i\n", value);
-        std::this_thread::sleep_for(10ms);
-      })
-    | stop_when(schedule_after(100ms));
+  auto op = on_stream(current_scheduler, range_stream{0, 20}) |
+      for_each([](int value) {
+              // Simulate some work
+              std::printf("processing %i\n", value);
+              std::this_thread::sleep_for(10ms);
+            }) |
+      stop_when(schedule_after(100ms));
   sync_wait(on(context.get_scheduler(), std::move(op)));
 
   auto endTime = steady_clock::now();
 
   std::printf(
-      "took %i ms\n", (int)duration_cast<milliseconds>(endTime - startTime).count());
+      "took %i ms\n",
+      (int)duration_cast<milliseconds>(endTime - startTime).count());
 }
diff --git a/examples/type_erased_stream.cpp b/examples/type_erased_stream.cpp
index e8d54145..a551b697 100644
--- a/examples/type_erased_stream.cpp
+++ b/examples/type_erased_stream.cpp
@@ -17,10 +17,10 @@
 #include <unifex/on_stream.hpp>
 #include <unifex/range_stream.hpp>
 #include <unifex/single_thread_context.hpp>
-#include <unifex/type_erased_stream.hpp>
 #include <unifex/sync_wait.hpp>
 #include <unifex/then.hpp>
 #include <unifex/transform_stream.hpp>
+#include <unifex/type_erased_stream.hpp>
 #include <unifex/via_stream.hpp>
 
 #include <cstdio>
@@ -33,14 +33,13 @@ int main() {
 
   sync_wait(then(
       for_each(
-            type_erase<int>(
-                via_stream(
-                    context1.get_scheduler(),
-                    on_stream(
-                        context2.get_scheduler(),
-                        transform_stream(
-                            range_stream{0, 10},
-                            [](int value) { return value * value; })))),
+          type_erase<int>(via_stream(
+              context1.get_scheduler(),
+              on_stream(
+                  context2.get_scheduler(),
+                  transform_stream(
+                      range_stream{0, 10},
+                      [](int value) { return value * value; })))),
           [](int value) { std::printf("got %i\n", value); }),
       []() { std::printf("done\n"); }));
 
diff --git a/examples/when_all.cpp b/examples/when_all.cpp
index ebc37b36..864ee240 100644
--- a/examples/when_all.cpp
+++ b/examples/when_all.cpp
@@ -15,8 +15,8 @@
  */
 #include <unifex/scheduler_concepts.hpp>
 #include <unifex/sync_wait.hpp>
-#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/then.hpp>
+#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/when_all.hpp>
 
 #include <chrono>
diff --git a/examples/when_all_2.cpp b/examples/when_all_2.cpp
index b773dd8b..99159dcb 100644
--- a/examples/when_all_2.cpp
+++ b/examples/when_all_2.cpp
@@ -15,8 +15,8 @@
  */
 #include <unifex/scheduler_concepts.hpp>
 #include <unifex/sync_wait.hpp>
-#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/then.hpp>
+#include <unifex/timed_single_thread_context.hpp>
 #include <unifex/when_all.hpp>
 
 #include <chrono>