format

Author: ericniebler

include/exec/sequence_senders.hpp

@@ -124,7 +124,7 @@ namespace experimental::execution
   {
     template <class _Receiver, class _Item>
     concept __has_set_next_member = requires(_Receiver& __rcvr, _Item&& __item) {
-      __rcvr.set_next(static_cast<_Item&&>(__item));
+      __rcvr.set_next(static_cast<_Item &&>(__item));
     };
 
     // This is a sequence-receiver CPO that is used to apply algorithms on an input sender and it
@@ -428,8 +428,8 @@ namespace experimental::execution
   template <class _Sequence, class... _Env>
   concept has_sequence_item_types = STDEXEC::sender_in<_Sequence, _Env...>  //
                                  && requires(_Sequence&& __sequence, _Env&&... __env) {
-                                      get_item_types(static_cast<_Sequence&&>(__sequence),
-                                                     static_cast<_Env&&>(__env)...);
+                                      get_item_types(static_cast<_Sequence &&>(__sequence),
+                                                     static_cast<_Env &&>(__env)...);
                                     };
 
   template <class _Sequence, class... _Env>
@@ -520,8 +520,8 @@ namespace experimental::execution
   concept sequence_sender_in = sequence_sender<_Sequence, _Env...>
                             && requires(_Sequence&& __sequence, _Env&&... __env) {
                                  {
-                                   get_item_types(static_cast<_Sequence&&>(__sequence),
-                                                  static_cast<_Env&&>(__env)...)
+                                   get_item_types(static_cast<_Sequence &&>(__sequence),
+                                                  static_cast<_Env &&>(__env)...)
                                  } -> __well_formed_item_types<_Sequence>;
                                };
 
@@ -821,7 +821,8 @@ namespace experimental::execution
         }
         else
         {
-          using __result_t [[maybe_unused]] = decltype(__declval<__tfx_seq_t>().subscribe(__declval<_Receiver>()));
+          using __result_t
+            [[maybe_unused]] = decltype(__declval<__tfx_seq_t>().subscribe(__declval<_Receiver>()));
           // static_assert(__subscribable_with_static_member<__tfx_seq_t, _Receiver>,
           //               STDEXEC_ERROR_CANNOT_SUBSCRIBE_SEQUENCE_TO_RECEIVER);
           return _NO_USABLE_SUBSCRIBE_CUSTOMIZATION_FOUND_();
@@ -932,8 +933,8 @@ namespace experimental::execution
   template <class _Sequence, class _Receiver>
   concept sequence_sender_to = sequence_receiver_from<_Receiver, _Sequence>
                             && requires(_Sequence&& __sequence, _Receiver&& __rcvr) {
-                                 subscribe(static_cast<_Sequence&&>(__sequence),
-                                           static_cast<_Receiver&&>(__rcvr));
+                                 subscribe(static_cast<_Sequence &&>(__sequence),
+                                           static_cast<_Receiver &&>(__rcvr));
                                };
 
   template <class _Receiver>

include/stdexec/__detail/__connect.hpp

@@ -232,8 +232,8 @@ namespace STDEXEC
     constexpr auto operator()(_Sender&& __sndr, _Receiver&& __rcvr) const
       noexcept(__nothrow_callable<_DeclFn>) -> __call_result_t<_DeclFn>
     {
-      decltype(auto) __new_sndr  = transform_sender(static_cast<_Sender&&>(__sndr), get_env(__rcvr));
-      using __new_sndr_t = decltype(__new_sndr);
+      decltype(auto) __new_sndr = transform_sender(static_cast<_Sender&&>(__sndr), get_env(__rcvr));
+      using __new_sndr_t        = decltype(__new_sndr);
 
       if constexpr (__connect::__with_static_member<__new_sndr_t, _Receiver>)
       {

include/stdexec/__detail/__diagnostics.hpp

@@ -219,7 +219,8 @@ namespace STDEXEC
   struct dependent_sender_error : __compile_time_error<dependent_sender_error>
   {
     constexpr dependent_sender_error() noexcept
-      : what_("This sender needs to know its execution environment before it can know how it will complete.")
+      : what_("This sender needs to know its execution environment before it can know how it will "
+              "complete.")
     {}
 
     constexpr explicit dependent_sender_error(char const *what) noexcept

include/stdexec/__detail/__receiver_ref.hpp

@@ -30,10 +30,10 @@ namespace STDEXEC
   namespace __detail
   {
     template <class _Rcvr, class _Item>
-    concept __has_set_next = requires(_Rcvr &__rcvr, __declfn_t<_Item&&> __item) {
+    concept __has_set_next = requires(_Rcvr& __rcvr, __declfn_t<_Item&&> __item) {
       __rcvr.set_next(__item());
     };
-  } // namespace __detail
+  }  // namespace __detail
 
   template <class _RcvrPtr, class _Env = env_of_t<decltype(*_RcvrPtr())>>
   struct __pointer_receiver

test/exec/test_any_sender.cpp

@@ -543,8 +543,8 @@ namespace
   template <class... Queries>
   using stoppable_scheduler =
     exec::any_scheduler<exec::any_sender<exec::any_receiver<
-                            ex::completion_signatures<ex::set_value_t(), ex::set_stopped_t()>>>,
-                          exec::queries<Queries...>>;
+                          ex::completion_signatures<ex::set_value_t(), ex::set_stopped_t()>>>,
+                        exec::queries<Queries...>>;
 
   TEST_CASE("any scheduler with static_thread_pool", "[types][any_sender]")
   {
@@ -817,11 +817,11 @@ namespace
     auto         op    = ex::connect(std::move(sndr), sink<completions_t>{});
     ex::start(op);
 
-    using inline_completions_t                       = ex::completion_signatures<ex::set_value_t()>;
-    using inline_any_receiver_t                      = exec::any_receiver<inline_completions_t>;
-    using inline_any_sender_t                        = exec::any_sender<inline_any_receiver_t>;
+    using inline_completions_t                     = ex::completion_signatures<ex::set_value_t()>;
+    using inline_any_receiver_t                    = exec::any_receiver<inline_completions_t>;
+    using inline_any_sender_t                      = exec::any_sender<inline_any_receiver_t>;
     exec::any_scheduler<inline_any_sender_t> sch   = ex::inline_scheduler{};
-    auto                                       sndr2 = ex::schedule(sch);
+    auto                                     sndr2 = ex::schedule(sch);
     auto op2 = ex::connect(std::move(sndr2), sink<inline_completions_t>{});
     ex::start(op2);
   }