From c3e1d76d4a79f09a5ca1acdee2162d5405e0000f Mon Sep 17 00:00:00 2001 From: Eric Niebler Date: Fri, 19 Jan 2024 15:59:23 -0800 Subject: [PATCH] make internal environment utilities more streamlined and consistent accommodate clang-12 quirk --- examples/benchmark/common.hpp | 5 +- examples/benchmark/fibonacci.cpp | 8 +- examples/benchmark/static_thread_pool_old.hpp | 20 +- include/exec/__detail/__bwos_lifo_queue.hpp | 2 +- include/exec/__detail/__numa.hpp | 71 ++-- include/exec/any_sender_of.hpp | 8 +- include/exec/async_scope.hpp | 40 +-- include/exec/env.hpp | 38 ++- include/exec/finally.hpp | 2 +- include/exec/repeat_effect_until.hpp | 4 +- include/exec/repeat_n.hpp | 7 +- include/exec/sequence/ignore_all_values.hpp | 20 +- include/exec/static_thread_pool.hpp | 26 +- include/exec/when_any.hpp | 6 +- include/nvexec/stream/common.cuh | 8 +- include/nvexec/stream/ensure_started.cuh | 2 +- include/nvexec/stream/split.cuh | 2 +- include/nvexec/stream/when_all.cuh | 2 +- include/stdexec/__detail/__basic_sender.hpp | 86 ++--- include/stdexec/__detail/__env.hpp | 308 ++++++++++-------- include/stdexec/__detail/__execution_fwd.hpp | 3 +- include/stdexec/__detail/__meta.hpp | 19 +- include/stdexec/__detail/__utility.hpp | 9 +- include/stdexec/execution.hpp | 125 ++++--- test/exec/test_repeat_effect_until_fail.cpp | 2 +- test/exec/test_repeat_n.cpp | 49 ++- test/stdexec/algos/adaptors/test_bulk.cpp | 10 +- .../stdexec/algos/adaptors/test_let_fail1.cpp | 2 +- .../algos/consumers/test_sync_wait.cpp | 8 +- test/stdexec/concepts/test_awaitables.cpp | 6 +- 30 files changed, 487 insertions(+), 411 deletions(-) diff --git a/examples/benchmark/common.hpp b/examples/benchmark/common.hpp index 5065f72fb..814aab3fb 100644 --- a/examples/benchmark/common.hpp +++ b/examples/benchmark/common.hpp @@ -92,6 +92,7 @@ statistics_all compute_perf( struct numa_deleter { std::size_t size_; exec::numa_allocator allocator_; + void operator()(char* ptr) noexcept { allocator_.deallocate(ptr, size_); } @@ -120,7 +121,9 @@ void my_main(int argc, char** argv, exec::numa_policy* policy = exec::get_numa_p std::size_t buffer_size = 2000 << 20; for (std::size_t i = 0; i < static_cast(nthreads); ++i) { exec::numa_allocator alloc(policy->thread_index_to_node(i)); - buffers.push_back(std::unique_ptr{alloc.allocate(buffer_size), numa_deleter{buffer_size, alloc}}); + buffers.push_back(std::unique_ptr{ + alloc.allocate(buffer_size), numa_deleter{buffer_size, alloc} + }); } #endif for (std::size_t i = 0; i < static_cast(nthreads); ++i) { diff --git a/examples/benchmark/fibonacci.cpp b/examples/benchmark/fibonacci.cpp index 0c344e140..b4680aa8f 100644 --- a/examples/benchmark/fibonacci.cpp +++ b/examples/benchmark/fibonacci.cpp @@ -50,7 +50,7 @@ struct fib_s { friend void tag_invoke(stdexec::start_t, operation& self) noexcept { if (self.n < self.cutoff) { - stdexec::set_value((Receiver &&) self.rcvr_, serial_fib(self.n)); + stdexec::set_value((Receiver&&) self.rcvr_, serial_fib(self.n)); } else { auto mkchild = [&](long n) { return stdexec::on(self.sched, fib_sender(fib_s{self.cutoff, n, self.sched})); @@ -58,8 +58,8 @@ struct fib_s { stdexec::start_detached( stdexec::when_all(mkchild(self.n - 1), mkchild(self.n - 2)) - | stdexec::then([rcvr = (Receiver &&) self.rcvr_](long a, long b) { - stdexec::set_value((Receiver &&) rcvr, a + b); + | stdexec::then([rcvr = (Receiver&&) self.rcvr_](long a, long b) { + stdexec::set_value((Receiver&&) rcvr, a + b); })); } } @@ -67,7 +67,7 @@ struct fib_s { template Receiver> friend operation tag_invoke(stdexec::connect_t, fib_s self, Receiver rcvr) { - return {(Receiver &&) rcvr, self.cutoff, self.n, self.sched}; + return {(Receiver&&) rcvr, self.cutoff, self.n, self.sched}; } }; diff --git a/examples/benchmark/static_thread_pool_old.hpp b/examples/benchmark/static_thread_pool_old.hpp index f462a324b..cbb33fa6f 100644 --- a/examples/benchmark/static_thread_pool_old.hpp +++ b/examples/benchmark/static_thread_pool_old.hpp @@ -74,10 +74,7 @@ namespace exec_old { template using bulk_sender_t = // - bulk_sender< - stdexec::__id>, - Shape, - Fun>; + bulk_sender< stdexec::__id>, Shape, Fun>; #if STDEXEC_MSVC() // MSVCBUG https://developercommunity.visualstudio.com/t/Alias-template-with-pack-expansion-in-no/10437850 @@ -472,16 +469,12 @@ namespace exec_old { template using bulk_op_state_t = // - bulk_op_state< - stdexec::__cvref_id, - stdexec::__id, - Shape, - Fun>; + bulk_op_state< stdexec::__cvref_id, stdexec::__id, Shape, Fun>; template Self, stdexec::receiver Receiver> requires stdexec:: receiver_of>> - friend bulk_op_state_t // + friend bulk_op_state_t // tag_invoke(stdexec::connect_t, Self&& self, Receiver rcvr) // noexcept(stdexec::__nothrow_constructible_from< bulk_op_state_t, @@ -685,7 +678,12 @@ namespace exec_old { stdexec::start(op.inner_op_); } - bulk_op_state(static_thread_pool& pool, Shape shape, Fun fn, CvrefSender&& sender, Receiver receiver) + bulk_op_state( + static_thread_pool& pool, + Shape shape, + Fun fn, + CvrefSender&& sender, + Receiver receiver) : shared_state_(pool, (Receiver&&) receiver, shape, fn) , inner_op_{stdexec::connect((CvrefSender&&) sender, bulk_rcvr{shared_state_})} { } diff --git a/include/exec/__detail/__bwos_lifo_queue.hpp b/include/exec/__detail/__bwos_lifo_queue.hpp index f04bfc950..1c924609f 100644 --- a/include/exec/__detail/__bwos_lifo_queue.hpp +++ b/include/exec/__detail/__bwos_lifo_queue.hpp @@ -340,7 +340,7 @@ namespace exec::bwos { template lifo_queue::block_type::block_type(const block_type &other) - : ring_buffer_(other.ring_buffer_) { + : ring_buffer_(other.ring_buffer_) { head_.store(other.head_.load(std::memory_order_relaxed), std::memory_order_relaxed); tail_.store(other.tail_.load(std::memory_order_relaxed), std::memory_order_relaxed); steal_tail_.store(other.steal_tail_.load(std::memory_order_relaxed), std::memory_order_relaxed); diff --git a/include/exec/__detail/__numa.hpp b/include/exec/__detail/__numa.hpp index 2fc06af9a..55044c2b3 100644 --- a/include/exec/__detail/__numa.hpp +++ b/include/exec/__detail/__numa.hpp @@ -35,18 +35,32 @@ namespace exec { class no_numa_policy : public numa_policy { public: no_numa_policy() noexcept = default; - std::size_t num_nodes() override { return 1; } - std::size_t num_cpus(int node) override { return std::thread::hardware_concurrency(); } - int bind_to_node(int node) override { return 0; } - int thread_index_to_node(std::size_t index) override { return 0; } + + std::size_t num_nodes() override { + return 1; + } + + std::size_t num_cpus(int node) override { + return std::thread::hardware_concurrency(); + } + + int bind_to_node(int node) override { + return 0; + } + + int thread_index_to_node(std::size_t index) override { + return 0; + } }; } #if STDEXEC_ENABLE_NUMA #include + namespace exec { struct default_numa_policy : numa_policy { - default_numa_policy() : node_to_thread_index_(::numa_num_task_nodes()) { + default_numa_policy() + : node_to_thread_index_(::numa_num_task_nodes()) { std::size_t total_cpus = 0; std::size_t n_nodes = num_nodes(); for (std::size_t node = 0; node < n_nodes; ++node) { @@ -55,14 +69,18 @@ namespace exec { } } - std::size_t num_nodes() override { return node_to_thread_index_.size(); } - - std::size_t num_cpus(int node) override { + std::size_t num_nodes() override { + return node_to_thread_index_.size(); + } + + std::size_t num_cpus(int node) override { struct ::bitmask* cpus = ::numa_allocate_cpumask(); if (!cpus) { return 0; } - scope_guard sg{[&]() noexcept { ::numa_free_cpumask(cpus); }}; + scope_guard sg{[&]() noexcept { + ::numa_free_cpumask(cpus); + }}; int rc = ::numa_node_to_cpus(node, cpus); if (rc < 0) { return 0; @@ -71,12 +89,14 @@ namespace exec { return num_cpus; } - int bind_to_node(int node) override { + int bind_to_node(int node) override { struct ::bitmask* nodes = ::numa_allocate_nodemask(); if (!nodes) { return -1; } - scope_guard sg{[&]() noexcept { ::numa_free_nodemask(nodes); }}; + scope_guard sg{[&]() noexcept { + ::numa_free_nodemask(nodes); + }}; ::numa_bitmask_setbit(nodes, node); ::numa_bind(nodes); return 0; @@ -107,10 +127,14 @@ namespace exec { using const_pointer = const T*; using value_type = T; - explicit numa_allocator(int node) noexcept : node_(node) {} + explicit numa_allocator(int node) noexcept + : node_(node) { + } template - explicit numa_allocator(const numa_allocator& other) noexcept : node_(other.node_) {} + explicit numa_allocator(const numa_allocator& other) noexcept + : node_(other.node_) { + } int node_; @@ -139,12 +163,11 @@ namespace exec { ::copy_bitmask_to_nodemask(::numa_all_nodes_ptr, &mask.mask_); return mask; } - - public: - nodemask() noexcept - : mask_{} - { + + public: + nodemask() noexcept + : mask_{} { ::copy_bitmask_to_nodemask(::numa_no_nodes_ptr, &mask_); } @@ -184,7 +207,7 @@ namespace exec { return ::numa_bitmask_equal(&lhs_mask, &rhs_mask); } - private: + private: ::nodemask_t mask_; }; } @@ -203,10 +226,12 @@ namespace exec { using const_pointer = const T*; using value_type = T; - explicit numa_allocator(int) noexcept {} + explicit numa_allocator(int) noexcept { + } template - explicit numa_allocator(const numa_allocator&) noexcept {} + explicit numa_allocator(const numa_allocator&) noexcept { + } T* allocate(std::size_t n) { std::allocator alloc{}; @@ -228,7 +253,7 @@ namespace exec { return mask; } - public: + public: nodemask() noexcept = default; static const nodemask& any() noexcept { @@ -248,7 +273,7 @@ namespace exec { return lhs.mask_ == rhs.mask_; } - private: + private: bool mask_{false}; }; } diff --git a/include/exec/any_sender_of.hpp b/include/exec/any_sender_of.hpp index 0e7c82cf8..ba84d4112 100644 --- a/include/exec/any_sender_of.hpp +++ b/include/exec/any_sender_of.hpp @@ -787,7 +787,7 @@ namespace exec { }; template - using __env_t = __make_env_t<_Env, __with>; + using __env_t = __env::__join_t<__env::__with, _Env>; template struct __stoppable_receiver { @@ -828,9 +828,9 @@ namespace exec { template _GetEnv, same_as<__t> _Self> friend __env_t> tag_invoke(_GetEnv, const _Self& __self) noexcept { - return __make_env( - get_env(__self.__op_->__rcvr_), - __mkprop(__self.__op_->__stop_source_.get_token(), get_stop_token)); + return __env::__join( + __env::__with(__self.__op_->__stop_source_.get_token(), get_stop_token), + get_env(__self.__op_->__rcvr_)); } }; }; diff --git a/include/exec/async_scope.hpp b/include/exec/async_scope.hpp index 9dc87bc49..d8a6302fd 100644 --- a/include/exec/async_scope.hpp +++ b/include/exec/async_scope.hpp @@ -65,7 +65,7 @@ namespace exec { , __op_(stdexec::connect((_Constrained&&) __sndr, (_Receiver&&) __rcvr)) { } - private: + private: static void __notify_waiter(__task* __self) noexcept { start(static_cast<__t*>(__self)->__op_); } @@ -172,8 +172,7 @@ namespace exec { __complete(__scope); } - friend __env_t> - tag_invoke(get_env_t, const __t& __self) noexcept { + friend __env_t> tag_invoke(get_env_t, const __t& __self) noexcept { return make_env( get_env(__self.__op_->__rcvr_), with(get_stop_token, __self.__op_->__scope_->__stop_source_.get_token())); @@ -196,7 +195,7 @@ namespace exec { : __nest_op_base<_ReceiverId>{{}, __scope, (_Rcvr&&) __rcvr} , __op_(stdexec::connect((_Sender&&) __c, __nest_rcvr_t{this})) { } - private: + private: void __start_() noexcept { STDEXEC_ASSERT(this->__scope_); std::unique_lock __guard{this->__scope_->__lock_}; @@ -215,6 +214,7 @@ namespace exec { template struct __nest_sender { using _Constrained = stdexec::__t<_ConstrainedId>; + struct __t { using __id = __nest_sender; using sender_concept = stdexec::sender_t; @@ -223,7 +223,8 @@ namespace exec { STDEXEC_ATTRIBUTE((no_unique_address)) _Constrained __c_; template - using __nest_operation_t = stdexec::__t<__nest_op<_ConstrainedId, stdexec::__id<_Receiver>>>; + using __nest_operation_t = + stdexec::__t<__nest_op<_ConstrainedId, stdexec::__id<_Receiver>>>; template using __nest_receiver_t = stdexec::__t<__nest_rcvr>>; @@ -302,7 +303,8 @@ namespace exec { std::unique_lock __guard{__state->__mutex_}; // either the future is still in use or it has passed ownership to __state->__no_future_ if ( - __state->__no_future_.get() != nullptr || __state->__step_ != __future_step::__future) { + __state->__no_future_.get() != nullptr + || __state->__step_ != __future_step::__future) { // invalid state - there is a code bug in the state machine std::terminate(); } else if (get_stop_token(get_env(__rcvr_)).stop_requested()) { @@ -351,7 +353,7 @@ namespace exec { std::unique_ptr<__future_state<_Sender, _Env>> __state_; STDEXEC_ATTRIBUTE((no_unique_address)) __forward_consumer __forward_consumer_; - public: + public: using __id = __future_op; ~__t() noexcept { @@ -583,13 +585,14 @@ namespace exec { __guard, __future_step::__future, __future_step::__no_future); } } - private: + private: friend struct async_scope; template using __completions_t = __future_completions_t<__mfront<_Sender, _Self>, _Env>; template - using __future_op_t = stdexec::__t<__future_op<_SenderId, _EnvId, stdexec::__id<_Receiver>>>; + using __future_op_t = + stdexec::__t<__future_op<_SenderId, _EnvId, stdexec::__id<_Receiver>>>; explicit __t(std::unique_ptr<__future_state<_Sender, _Env>> __state) noexcept : __state_(std::move(__state)) { @@ -618,16 +621,16 @@ namespace exec { }; template - using __future_t = stdexec::__t<__future<__id<__nest_sender_t<_Sender>>, __id<__decay_t<_Env>>>>; + using __future_t = + stdexec::__t<__future<__id<__nest_sender_t<_Sender>>, __id<__decay_t<_Env>>>>; //////////////////////////////////////////////////////////////////////////// // async_scope::spawn implementation template - using __spawn_env_t = __result_of< - __join_env, + using __spawn_env_t = __env::__join_t< _Env, - __env::__prop, - __env::__prop<__inln::__scheduler(get_scheduler_t)>>; + __env::__with, + __env::__with<__inln::__scheduler, get_scheduler_t>>; template struct __spawn_op_base { @@ -652,8 +655,7 @@ namespace exec { // BUGBUG NOT TO SPEC spawn shouldn't accept senders that can fail. template _Tag> - [[noreturn]] friend void - tag_invoke(_Tag, __t&&, const std::exception_ptr&) noexcept { + [[noreturn]] friend void tag_invoke(_Tag, __t&&, const std::exception_ptr&) noexcept { std::terminate(); } @@ -674,9 +676,9 @@ namespace exec { struct __t : __spawn_op_base<_EnvId> { template <__decays_to<_Sender> _Sndr> __t(_Sndr&& __sndr, _Env __env, const __impl* __scope) - : __spawn_op_base<_EnvId>{__join_env((_Env&&) __env, - __mkprop(__scope->__stop_source_.get_token(), get_stop_token), - __mkprop(__inln::__scheduler{}, get_scheduler)), + : __spawn_op_base<_EnvId>{__env::__join((_Env&&) __env, + __env::__with(__scope->__stop_source_.get_token(), get_stop_token), + __env::__with(__inln::__scheduler{}, get_scheduler)), [](__spawn_op_base<_EnvId>* __op) { delete static_cast<__t*>(__op); }} diff --git a/include/exec/env.hpp b/include/exec/env.hpp index 02956e85e..e8312dc06 100644 --- a/include/exec/env.hpp +++ b/include/exec/env.hpp @@ -22,28 +22,48 @@ STDEXEC_PRAGMA_IGNORE_EDG(1302) namespace exec { template - using with_t = stdexec::__with<_Tag, _Value>; + using with_t = stdexec::__if_c< + stdexec::same_as<_Value, void>, + stdexec::__env::__without<_Tag>, + stdexec::__env::__with<_Value, _Tag>>; namespace __detail { struct __with_t { template - with_t<_Tag, stdexec::__decay_t<_Value>> operator()(_Tag, _Value&& __val) const { - return stdexec::__mkprop((_Value&&) __val, _Tag()); + auto operator()(_Tag, _Value&& __val) const { + return stdexec::__env::__with((_Value&&) __val, _Tag()); } template - with_t<_Tag> operator()(_Tag) const { - return stdexec::__mkprop(_Tag()); + auto operator()(_Tag) const { + return stdexec::__env::__without(_Tag()); + } + }; + + // For making an environment from key/value pairs and optionally + // another environment. + struct __make_env_t { + template < + stdexec::__nothrow_move_constructible _Base, + stdexec::__nothrow_move_constructible _Env> + auto operator()(_Base&& __base, _Env&& __env) const noexcept + -> stdexec::__env::__join_t<_Env, _Base> { + return stdexec::__env::__join((_Env&&) __env, (_Base&&) __base); + } + + template + _Env operator()(_Env&& __env) const noexcept { + return (_Env&&) __env; } }; } // namespace __detail inline constexpr __detail::__with_t with{}; - inline constexpr stdexec::__env::__make_env_t make_env{}; + inline constexpr __detail::__make_env_t make_env{}; template - using make_env_t = stdexec::__make_env_t<_Ts...>; + using make_env_t = stdexec::__result_of; namespace __read_with_default { using namespace stdexec; @@ -77,9 +97,7 @@ namespace exec { }; template - using __operation_t = - __t<__operation<_Tag, __id<_Default>, __id<_Receiver>>>; - + using __operation_t = __t<__operation<_Tag, __id<_Default>, __id<_Receiver>>>; template struct __sender { diff --git a/include/exec/finally.hpp b/include/exec/finally.hpp index 77cc1823f..b34331ff4 100644 --- a/include/exec/finally.hpp +++ b/include/exec/finally.hpp @@ -64,7 +64,7 @@ namespace exec { }; template - using __as_rvalues = completion_signatures && ...)>; + using __as_rvalues = completion_signatures&&...)>; template using __completion_signatures_t = make_completion_signatures< diff --git a/include/exec/repeat_effect_until.hpp b/include/exec/repeat_effect_until.hpp index ab4bd8cdd..b443d8c0f 100644 --- a/include/exec/repeat_effect_until.hpp +++ b/include/exec/repeat_effect_until.hpp @@ -94,8 +94,8 @@ namespace exec { } void __start() noexcept { - const bool __already_started [[maybe_unused]] = - __started_.test_and_set(std::memory_order_relaxed); + const bool __already_started + [[maybe_unused]] = __started_.test_and_set(std::memory_order_relaxed); STDEXEC_ASSERT(!__already_started); stdexec::start(__child_op_.__get()); } diff --git a/include/exec/repeat_n.hpp b/include/exec/repeat_n.hpp index 00ef1a85e..1044d541e 100644 --- a/include/exec/repeat_n.hpp +++ b/include/exec/repeat_n.hpp @@ -108,8 +108,8 @@ namespace exec { if (__pair_.__count_ == 0) { stdexec::set_value((_Receiver &&) this->__receiver()); } else { - const bool __already_started [[maybe_unused]] = - __started_.test_and_set(std::memory_order_relaxed); + const bool __already_started + [[maybe_unused]] = __started_.test_and_set(std::memory_order_relaxed); STDEXEC_ASSERT(!__already_started); stdexec::start(__child_op_.__get()); } @@ -210,6 +210,5 @@ namespace exec { namespace stdexec { template <> - struct __sexpr_impl - : exec::__repeat_n::__repeat_n_impl { }; + struct __sexpr_impl : exec::__repeat_n::__repeat_n_impl { }; } diff --git a/include/exec/sequence/ignore_all_values.hpp b/include/exec/sequence/ignore_all_values.hpp index 24e861098..f2a7110d5 100644 --- a/include/exec/sequence/ignore_all_values.hpp +++ b/include/exec/sequence/ignore_all_values.hpp @@ -293,10 +293,10 @@ namespace exec { static constexpr auto get_completion_signatures = // [](_Sender&& __sndr, _Env&&) - -> __completion_sigs<__child_of<_Sender>, _Env> { - static_assert(sender_expr_for<_Sender, ignore_all_values_t>); - return {}; - }; + -> __completion_sigs<__child_of<_Sender>, _Env> { + static_assert(sender_expr_for<_Sender, ignore_all_values_t>); + return {}; + }; template using _ResultVariant = __result_variant_t<_Child, env_of_t<_Receiver>>; @@ -305,14 +305,15 @@ namespace exec { using __receiver_t = __t<__receiver<__id<_Receiver>, _ResultVariant<_Child, _Receiver>>>; static constexpr auto connect = // - [](_Sender&& __sndr, _Receiver __rcvr) noexcept( - __nothrow_callable<__sexpr_apply_t, _Sender, __connect_fn<_Receiver>>) + [](_Sender && __sndr, _Receiver __rcvr) noexcept( + __nothrow_callable<__sexpr_apply_t, _Sender, __connect_fn<_Receiver>>) -> __call_result_t<__sexpr_apply_t, _Sender, __connect_fn<_Receiver>> requires receiver_of<_Receiver, __completion_sigs<__child_of<_Sender>, env_of_t<_Receiver>>> && sequence_sender_to< __child_of<_Sender>, - __receiver_t<__child_of<_Sender>, _Receiver>> { - static_assert(sender_expr_for<_Sender, ignore_all_values_t>); + __receiver_t<__child_of<_Sender>, _Receiver>> + { + static_assert(sender_expr_for<_Sender, ignore_all_values_t>); return __sexpr_apply((_Sender&&) __sndr, __connect_fn<_Receiver>{__rcvr}); }; }; @@ -324,5 +325,6 @@ namespace exec { namespace stdexec { template <> - struct __sexpr_impl : exec::__ignore_all_values::__ignore_all_values_impl {}; + struct __sexpr_impl + : exec::__ignore_all_values::__ignore_all_values_impl { }; } \ No newline at end of file diff --git a/include/exec/static_thread_pool.hpp b/include/exec/static_thread_pool.hpp index 31a72b583..e34fa0dc1 100644 --- a/include/exec/static_thread_pool.hpp +++ b/include/exec/static_thread_pool.hpp @@ -217,8 +217,8 @@ namespace exec { }; template - using bulk_receiver_t = __t< - bulk_receiver< __cvref_id, __id, Shape, Fun, MayThrow>>; + using bulk_receiver_t = + __t< bulk_receiver< __cvref_id, __id, Shape, Fun, MayThrow>>; template struct bulk_op_state { @@ -329,14 +329,16 @@ namespace exec { using __t = sender; using __id = sender; using sender_concept = sender_t; - using completion_signatures = stdexec::completion_signatures< set_value_t(), set_stopped_t()>; + using completion_signatures = + stdexec::completion_signatures< set_value_t(), set_stopped_t()>; private: template using operation_t = stdexec::__t>>; template auto make_operation_(Receiver rcvr) const -> operation_t { - return operation_t{pool_, queue_, (Receiver&&) rcvr, threadIndex_, constraints_}; + return operation_t{ + pool_, queue_, (Receiver&&) rcvr, threadIndex_, constraints_}; } template @@ -727,7 +729,8 @@ namespace exec { } inline std::size_t static_thread_pool_::num_threads(nodemask constraints) const noexcept { - const std::size_t nNodes = static_cast(threadIndexByNumaNode_.back().numa_node + 1); + const std::size_t nNodes = static_cast( + threadIndexByNumaNode_.back().numa_node + 1); std::size_t nThreads = 0; for (std::size_t nodeIndex = 0; nodeIndex < nNodes; ++nodeIndex) { if (!constraints[nodeIndex]) { @@ -1070,7 +1073,7 @@ namespace exec { template <__decays_to<__t> Self, receiver Receiver> requires receiver_of>> - friend bulk_op_state_t // + friend bulk_op_state_t // tag_invoke(connect_t, Self&& self, Receiver rcvr) // noexcept(__nothrow_constructible_from< bulk_op_state_t, @@ -1437,8 +1440,7 @@ namespace exec { while (i0 + chunkSize < size) { for (std::size_t i = i0; i < i0 + chunkSize; ++i) { op.items_[i].__construct_with([&] { - return connect( - set_next(op.rcvr_, ItemSender{&op, it + i}), NextReceiver{&op}); + return connect(set_next(op.rcvr_, ItemSender{&op, it + i}), NextReceiver{&op}); }); start(op.items_[i].__get()); } @@ -1465,9 +1467,7 @@ namespace exec { : operation_base_with_receiver< Range, Receiver>{std::move(range), pool, static_cast(rcvr)} - , items_( - std::ranges::size(this->range_), - ItemAllocator(get_allocator(this->rcvr_))) { + , items_(std::ranges::size(this->range_), ItemAllocator(get_allocator(this->rcvr_))) { } ~__t() { @@ -1492,8 +1492,8 @@ namespace exec { using sender_concept = sequence_sender_t; - using completion_signatures = - stdexec::completion_signatures< set_value_t(), set_error_t(std::exception_ptr), set_stopped_t()>; + using completion_signatures = stdexec:: + completion_signatures< set_value_t(), set_error_t(std::exception_ptr), set_stopped_t()>; using item_types = exec::item_types>>; diff --git a/include/exec/when_any.hpp b/include/exec/when_any.hpp index 47e953b88..be74de113 100644 --- a/include/exec/when_any.hpp +++ b/include/exec/when_any.hpp @@ -31,7 +31,7 @@ namespace exec { }; template - using __env_t = __make_env_t<_BaseEnv, __with>; + using __env_t = __env::__join_t<__env::__with, _BaseEnv>; template __decayed_tuple<_Ret, _Args...> __signature_to_tuple_(_Ret (*)(_Args...)); @@ -172,8 +172,8 @@ namespace exec { } friend __env_t> tag_invoke(get_env_t, const __t& __self) noexcept { - auto __token = __mkprop(__self.__op_->__stop_source_.get_token(), get_stop_token); - return __make_env(get_env(__self.__op_->__receiver_), std::move(__token)); + auto __token = __env::__with(__self.__op_->__stop_source_.get_token(), get_stop_token); + return __env::__join(std::move(__token), get_env(__self.__op_->__receiver_)); } }; }; diff --git a/include/nvexec/stream/common.cuh b/include/nvexec/stream/common.cuh index dda76f2ac..9379f52bd 100644 --- a/include/nvexec/stream/common.cuh +++ b/include/nvexec/stream/common.cuh @@ -327,7 +327,7 @@ namespace nvexec { template auto make_stream_env(BaseEnv&& base_env, stream_provider_t* stream_provider) noexcept { - return __join_env(__mkprop(stream_provider, get_stream_provider), (BaseEnv&&) base_env); + return __env::__join(__env::__with(stream_provider, get_stream_provider), (BaseEnv&&) base_env); } template @@ -343,11 +343,7 @@ namespace nvexec { template auto make_terminal_stream_env(BaseEnv&& base_env, stream_provider_t* stream_provider) noexcept { - return __join_env( - __env::__env_fn{[stream_provider](get_stream_provider_t) noexcept { - return stream_provider; - }}, - (BaseEnv&&) base_env); + return __env::__join(__env::__with(stream_provider, get_stream_provider), (BaseEnv&&) base_env); } template using terminal_stream_env = decltype(STDEXEC_STREAM_DETAIL_NS::make_terminal_stream_env( diff --git a/include/nvexec/stream/ensure_started.cuh b/include/nvexec/stream/ensure_started.cuh index ff6a532c8..551c4bf11 100644 --- a/include/nvexec/stream/ensure_started.cuh +++ b/include/nvexec/stream/ensure_started.cuh @@ -34,7 +34,7 @@ namespace nvexec::STDEXEC_STREAM_DETAIL_NS { const in_place_stop_source& stop_source, stream_provider_t* stream_provider) noexcept { return make_stream_env( - __env::__env_fn{[&](get_stop_token_t) noexcept { + __env::__from{[&](get_stop_token_t) noexcept { return stop_source.get_token(); }}, stream_provider); diff --git a/include/nvexec/stream/split.cuh b/include/nvexec/stream/split.cuh index f051518e3..d79d913be 100644 --- a/include/nvexec/stream/split.cuh +++ b/include/nvexec/stream/split.cuh @@ -29,7 +29,7 @@ namespace nvexec::STDEXEC_STREAM_DETAIL_NS { const in_place_stop_source& stop_source, stream_provider_t* stream_provider) noexcept { return make_stream_env( - __env::__env_fn{[&](get_stop_token_t) noexcept { + __env::__from{[&](get_stop_token_t) noexcept { return stop_source.get_token(); }}, stream_provider); diff --git a/include/nvexec/stream/when_all.cuh b/include/nvexec/stream/when_all.cuh index f7f2bbb72..9ab96717b 100644 --- a/include/nvexec/stream/when_all.cuh +++ b/include/nvexec/stream/when_all.cuh @@ -205,7 +205,7 @@ namespace nvexec::STDEXEC_STREAM_DETAIL_NS { auto env = make_terminal_stream_env( exec::make_env( stdexec::get_env(base()), - __mkprop(op_state_->stop_source_.get_token(), get_stop_token)), + __env::__with(op_state_->stop_source_.get_token(), get_stop_token)), &const_cast(op_state_->stream_providers_[Index])); return env; diff --git a/include/stdexec/__detail/__basic_sender.hpp b/include/stdexec/__detail/__basic_sender.hpp index 513e4ec84..765e9e702 100644 --- a/include/stdexec/__detail/__basic_sender.hpp +++ b/include/stdexec/__detail/__basic_sender.hpp @@ -135,12 +135,15 @@ namespace stdexec { struct __connect_fn; template - using __state_type_t = __decay_t<__result_of< - __sexpr_impl<_Tag>::get_state, _Sexpr, _Receiver&>>; + using __state_type_t = + __decay_t<__result_of< __sexpr_impl<_Tag>::get_state, _Sexpr, _Receiver&>>; template using __env_type_t = __result_of< - __sexpr_impl<_Tag>::get_env, _Index, __state_type_t<_Tag, _Sexpr, _Receiver>&, _Receiver&>; + __sexpr_impl<_Tag>::get_env, + _Index, + __state_type_t<_Tag, _Sexpr, _Receiver>&, + _Receiver&>; template concept __connectable = @@ -158,43 +161,51 @@ namespace stdexec { inline constexpr auto __get_attrs = // [](__ignore, const auto&... __child) noexcept -> decltype(auto) { - if constexpr (sizeof...(__child) == 1) { - return stdexec::get_env(__child...); // BUGBUG: should be only the forwarding queries - } else { - return empty_env(); - } - STDEXEC_UNREACHABLE(); - }; + if constexpr (sizeof...(__child) == 1) { + return stdexec::get_env(__child...); // BUGBUG: should be only the forwarding queries + } else { + return empty_env(); + } + STDEXEC_UNREACHABLE(); + }; inline constexpr auto __get_env = // [](__ignore, __ignore, const _Receiver& __rcvr) noexcept - -> env_of_t { - return stdexec::get_env(__rcvr); - }; + -> env_of_t { + return stdexec::get_env(__rcvr); + }; inline constexpr auto __get_state = // [](_Sender&& __sndr, __ignore) noexcept -> decltype(auto) { - return STDEXEC_CALL_EXPLICIT_THIS_MEMFN((_Sender&&) __sndr, apply)(__get_data()); - }; + return STDEXEC_CALL_EXPLICIT_THIS_MEMFN((_Sender&&) __sndr, apply)(__get_data()); + }; inline constexpr auto __connect = // - [](_Sender&& __sndr, _Receiver __rcvr) - -> __op_state<_Sender, _Receiver> - requires __connectable<_Sender, _Receiver> { - return __op_state<_Sender, _Receiver>{(_Sender&&) __sndr, (_Receiver&&) __rcvr}; - }; + [](_Sender && __sndr, _Receiver __rcvr) + -> __op_state<_Sender, _Receiver> + requires __connectable<_Sender, _Receiver> + { + return __op_state<_Sender, _Receiver>{(_Sender&&) __sndr, (_Receiver&&) __rcvr}; + }; inline constexpr auto __start = // - [](__ignore, __ignore, _ChildOps&... __ops) noexcept { - (_StartTag()(__ops), ...); - }; + []( + __ignore, + __ignore, + _ChildOps&... __ops) noexcept { + (_StartTag()(__ops), ...); + }; inline constexpr auto __complete = // []( - _Index, __ignore, _Receiver& __rcvr, _SetTag, _Args&&... __args) noexcept { - static_assert(__v<_Index> == 0, "I don't know how to complete this operation."); - _SetTag()(std::move(__rcvr), (_Args&&) __args...); - }; + _Index, + __ignore, + _Receiver& __rcvr, + _SetTag, + _Args&&... __args) noexcept { + static_assert(__v<_Index> == 0, "I don't know how to complete this operation."); + _SetTag()(std::move(__rcvr), (_Args&&) __args...); + }; inline constexpr auto __get_completion_signagures = // [](__ignore, __ignore) noexcept { @@ -384,11 +395,11 @@ namespace stdexec { inline constexpr auto __drop_front = // [](_Fn __fn) noexcept { - return [__fn = std::move(__fn)](auto&&, _Rest&&... __rest) - noexcept(__nothrow_callable) - -> __call_result_t { - return __fn((_Rest&&) __rest...); - }; + return + [__fn = std::move(__fn)](auto&&, _Rest&&... __rest) noexcept( + __nothrow_callable) -> __call_result_t { + return __fn((_Rest&&) __rest...); + }; }; } // namespace __detail @@ -402,8 +413,8 @@ namespace stdexec { static constexpr auto get_completion_signagures = __detail::__get_completion_signagures; }; - template - struct __sexpr_impl : __sexpr_defaults {}; + template + struct __sexpr_impl : __sexpr_defaults { }; using __detail::__enable_receiver_from_this; @@ -468,10 +479,9 @@ namespace stdexec { same_as _Tag, __decays_to<__sexpr> _Self, /*receiver*/ class _Receiver> - STDEXEC_ATTRIBUTE((always_inline)) // - friend auto tag_invoke(_Tag, _Self&& __self, _Receiver&& __rcvr) // - noexcept(noexcept( - __impl<_Tag>::connect((_Self&&) __self, (_Receiver&&) __rcvr))) // + STDEXEC_ATTRIBUTE((always_inline)) // + friend auto tag_invoke(_Tag, _Self&& __self, _Receiver&& __rcvr) // + noexcept(noexcept(__impl<_Tag>::connect((_Self&&) __self, (_Receiver&&) __rcvr))) // -> __msecond< __if_c && __decays_to<_Self, __sexpr>>, __result_of<__impl<_Tag>::connect, _Self, _Receiver>> { diff --git a/include/stdexec/__detail/__env.hpp b/include/stdexec/__detail/__env.hpp index beff615bd..94df46e56 100644 --- a/include/stdexec/__detail/__env.hpp +++ b/include/stdexec/__detail/__env.hpp @@ -266,74 +266,95 @@ namespace stdexec { using __query_result_or_t = __call_result_t; ///////////////////////////////////////////////////////////////////////////// - // env_of namespace __env { - template - struct __prop; - - template - struct __prop<_Value(_Tags...)> { - using __t = __prop; - using __id = __prop; - _Value __value_; + // For getting an execution environment from a receiver, + // or the attributes from a sender. + struct get_env_t { + template + requires tag_invocable + STDEXEC_ATTRIBUTE((always_inline)) // + constexpr auto + operator()(const _EnvProvider& __env_provider) const noexcept + -> tag_invoke_result_t { + static_assert(queryable >); + static_assert(nothrow_tag_invocable); + return tag_invoke(*this, __env_provider); + } - template <__one_of<_Tags...> _Key> - friend auto tag_invoke(_Key, const __prop& __self) // - noexcept(__nothrow_decay_copyable<_Value>) -> _Value { - return __self.__value_; + template + constexpr empty_env operator()(const _EnvProvider&) const noexcept { + return {}; } }; - template - struct __prop { - using __t = __prop; - using __id = __prop; + // To be kept in sync with the promise type used in __connect_awaitable + template + struct __promise { + template + _Ty&& await_transform(_Ty&& __value) noexcept { + return (_Ty&&) __value; + } - template <__one_of<_Tags...> _Key, class _Self> - requires(std::is_base_of_v<__prop, __decay_t<_Self>>) - friend auto tag_invoke(_Key, _Self&&) noexcept = delete; + template + requires tag_invocable + auto await_transform(_Ty&& __value) // + noexcept(nothrow_tag_invocable) + -> tag_invoke_result_t { + return tag_invoke(as_awaitable, (_Ty&&) __value, *this); + } + + template _Tag> + friend auto tag_invoke(_Tag, const __promise&) noexcept -> const _Env& { + std::terminate(); + } }; - struct __mkprop_t { - template - auto operator()(_Value&& __value, _Tag, _Tags...) const - noexcept(__nothrow_decay_copyable<_Value>) -> __prop<__decay_t<_Value>(_Tag, _Tags...)> { - return {(_Value&&) __value}; + template + struct __with { + using __t = __with; + using __id = __with; + _Value __value_; + + constexpr __with(_Value __value) noexcept(__nothrow_decay_copyable<_Value>) + : __value_((_Value&&) __value) { } - template - auto operator()(_Tag) const -> __prop { - return {}; + constexpr explicit __with(_Value __value, _Tag, _Tags...) noexcept( + __nothrow_decay_copyable<_Value>) + : __value_((_Value&&) __value) { + } + + template <__one_of<_Tag, _Tags...> _Key> + friend auto tag_invoke(_Key, const __with& __self) // + noexcept(__nothrow_decay_copyable<_Value>) -> _Value { + return __self.__value_; } }; - template <__nothrow_move_constructible _Fun> - struct __env_fn { - using __t = __env_fn; - using __id = __env_fn; - STDEXEC_ATTRIBUTE((no_unique_address)) _Fun __fun_; + template + __with(_Value, _Tag, _Tags...) -> __with<_Value, _Tag, _Tags...>; - template - requires __callable - friend auto tag_invoke(_Tag, const __env_fn& __self) // - noexcept(__nothrow_callable) -> __call_result_t { - return __self.__fun_(_Tag()); + template + struct __without { + using __t = __without; + using __id = __without; + + __without() = default; + + constexpr explicit __without(_Tag, _Tags...) noexcept { } }; - template - __env_fn(_Fun) -> __env_fn<_Fun>; - template - struct __env_fwd { + struct __fwd { static_assert(__nothrow_move_constructible<_Env>); - using __t = __env_fwd; - using __id = __env_fwd; + using __t = __fwd; + using __id = __fwd; STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_; template <__forwarding_query _Tag> requires tag_invocable<_Tag, const _Env&> - friend auto tag_invoke(_Tag, const __env_fwd& __self) // + friend auto tag_invoke(_Tag, const __fwd& __self) // noexcept(nothrow_tag_invocable<_Tag, const _Env&>) -> tag_invoke_result_t<_Tag, const _Env&> { return _Tag()(__self.__env_); @@ -341,142 +362,147 @@ namespace stdexec { }; template - __env_fwd(_Env&&) -> __env_fwd<_Env>; + __fwd(_Env&&) -> __fwd<_Env>; - template - struct __joined_env : __env_fwd<_Base> { - static_assert(__nothrow_move_constructible<_Env>); - using __t = __joined_env; - using __id = __joined_env; - STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_; + template + struct __joined : _Second { + static_assert(__nothrow_move_constructible<_First>); + static_assert(__nothrow_move_constructible<_Second>); + using __t = __joined; + using __id = __joined; - const _Base& base() const noexcept { - return this->__env_fwd<_Base>::__env_; - } + STDEXEC_ATTRIBUTE((no_unique_address)) _First __env_; template - requires tag_invocable<_Tag, const _Env&> - friend auto tag_invoke(_Tag, const __joined_env& __self) // - noexcept(nothrow_tag_invocable<_Tag, const _Env&>) - -> tag_invoke_result_t<_Tag, const _Env&> { + requires tag_invocable<_Tag, const _First&> + friend auto tag_invoke(_Tag, const __joined& __self) // + noexcept(nothrow_tag_invocable<_Tag, const _First&>) + -> tag_invoke_result_t<_Tag, const _First&> { return _Tag()(__self.__env_); } }; - template - struct __joined_env<__prop, _Base> : __env_fwd<_Base> { - using __t = __joined_env; - using __id = __joined_env; - STDEXEC_ATTRIBUTE((no_unique_address)) __prop __env_; + template + struct __joined<_Second, __without<_Tag, _Tags...>> + : _Second + , __without<_Tag, _Tags...> { + using __t = __joined; + using __id = __joined; - friend void tag_invoke(_Tag, const __joined_env&) noexcept = delete; + template <__one_of<_Tag, _Tags...> _Key, class _Self> + requires(std::is_base_of_v<__joined, __decay_t<_Self>>) + friend auto tag_invoke(_Key, _Self&&) noexcept = delete; }; - struct __join_env_t { - template - _Env operator()(_Env&& __env) const noexcept { - return (_Env&&) __env; + template + __joined(_Second&&, _First&&) -> __joined<_Second, _First>; + + template <__nothrow_move_constructible _Fun> + struct __from { + using __t = __from; + using __id = __from; + STDEXEC_ATTRIBUTE((no_unique_address)) _Fun __fun_; + + template + requires __callable + friend auto tag_invoke(_Tag, const __from& __self) // + noexcept(__nothrow_callable) -> __call_result_t { + return __self.__fun_(_Tag()); } + }; - template - decltype(auto) operator()(_Env&& __env, _Base&& __base) const noexcept { - using __env_t = __decay_t<_Env>; - using __base_t = __decay_t<_Base>; - if constexpr (__same_as<__env_t, empty_env>) { - return _Base((_Base&&) __base); - } else if constexpr (__same_as<__base_t, empty_env>) { - return _Env((_Env&&) __env); - } else { - return __joined_env<_Env, _Base>{{(_Base&&) __base}, (_Env&&) __env}; - } + template + __from(_Fun) -> __from<_Fun>; + + struct __fwd_fn { + template + auto operator()(Env&& env) const { + return __fwd{(Env&&) env}; + } + + empty_env operator()(empty_env) const { + return {}; } - template - decltype(auto) operator()(_Env0&& __env0, _Env1&& __env1, _Env2&& __env2, _Envs&&... __envs) - const noexcept { - const auto& __join_env = *this; - return __join_env( - (_Env0&&) __env0, - __join_env((_Env1&&) __env1, __join_env((_Env2&&) __env2, (_Envs&&) __envs...))); + template + __without<_Tag, _Tags...> operator()(__without<_Tag, _Tags...>) const { + return {}; } }; - template - using __env_join_t = __call_result_t<__join_env_t, _Envs...>; + struct __join_fn { + empty_env operator()() const { + return {}; + } - // To be kept in sync with the promise type used in __connect_awaitable - template - struct __env_promise { - template - _Ty&& await_transform(_Ty&& __value) noexcept { - return (_Ty&&) __value; + template + _Env operator()(_Env&& __env) const { + return (_Env&&) __env; } - template - requires tag_invocable - auto await_transform(_Ty&& __value) // - noexcept(nothrow_tag_invocable) - -> tag_invoke_result_t { - return tag_invoke(as_awaitable, (_Ty&&) __value, *this); + empty_env operator()(empty_env) const { + return {}; } - template _Tag> - friend auto tag_invoke(_Tag, const __env_promise&) noexcept -> const _Env& { - std::terminate(); + template + empty_env operator()(__without<_Tag, _Tags...>) const { + return {}; } - }; - // For making an environment from key/value pairs and optionally - // another environment. - struct __make_env_t { - template <__nothrow_move_constructible _Base, __nothrow_move_constructible _Env> - auto operator()(_Base&& __base, _Env&& __env) const noexcept -> __env_join_t<_Env, _Base> { - return __join_env_t()((_Env&&) __env, (_Base&&) __base); + template + _Env operator()(_Env&& __env, empty_env) const { + return (_Env&&) __env; } - template <__nothrow_move_constructible _Env> - _Env operator()(_Env&& __env) const noexcept { + template + _Env operator()(_Env&& __env, __without<_Tag, _Tags...>) const { return (_Env&&) __env; } - }; - // For getting an evaluation environment from a receiver - struct get_env_t { - template - requires tag_invocable - STDEXEC_ATTRIBUTE((always_inline)) // - constexpr auto - operator()(const _EnvProvider& __with_env) const noexcept - -> tag_invoke_result_t { - static_assert(queryable >); - static_assert(nothrow_tag_invocable); - return tag_invoke(*this, __with_env); + empty_env operator()(empty_env, empty_env) const { + return {}; } - template - constexpr empty_env operator()(const _EnvProvider&) const noexcept { + template + empty_env operator()(empty_env, __without<_Tag, _Tags...>) const { return {}; } - }; - } // namespace __env - using __env::empty_env; - using __empty_env [[deprecated("Please use stdexec::empty_env now.")]] = empty_env; + template + empty_env operator()(__without<_Tag, _Tags...>, empty_env) const { + return {}; + } - using __env::__env_promise; + template + empty_env operator()(__without<_Tag, _Tags...>, __without<_Tag2, _Tags2...>) const { + return {}; + } - inline constexpr __env::__make_env_t __make_env{}; - inline constexpr __env::__join_env_t __join_env{}; - inline constexpr __env::get_env_t get_env{}; + template + decltype(auto) operator()(empty_env, Rest&&... rest) const { + return __fwd_fn()(__join_fn()((Rest&&) rest...)); + } - // for making an environment from a single key/value pair - inline constexpr __env::__mkprop_t __mkprop{}; + template + decltype(auto) operator()(__without<_Tag, _Tags...>, Rest&&... rest) const { + return __joined{__fwd_fn()(__join_fn()((Rest&&) rest...)), __without<_Tag, _Tags...>()}; + } - template - using __with = __env::__prop<_Value(_Tag)>; + template + decltype(auto) operator()(First&& first, Rest&&... rest) const { + return __joined{__fwd_fn()(__join_fn()((Rest&&) rest...)), (First&&) first}; + } + }; - template - using __make_env_t = __call_result_t<__env::__make_env_t, _Ts...>; + inline constexpr __join_fn __join{}; + + template + using __join_t = __result_of<__join, _Envs...>; + } // namespace __env + + using __env::get_env_t; + using __env::empty_env; + inline constexpr get_env_t get_env{}; template concept environment_provider = // diff --git a/include/stdexec/__detail/__execution_fwd.hpp b/include/stdexec/__detail/__execution_fwd.hpp index e2eac2653..09b151ac0 100644 --- a/include/stdexec/__detail/__execution_fwd.hpp +++ b/include/stdexec/__detail/__execution_fwd.hpp @@ -227,7 +227,8 @@ namespace stdexec { } template -[[deprecated]] void print() {} +[[deprecated]] void print() { +} template struct undef; diff --git a/include/stdexec/__detail/__meta.hpp b/include/stdexec/__detail/__meta.hpp index 1ce45b568..8fd9e0d03 100644 --- a/include/stdexec/__detail/__meta.hpp +++ b/include/stdexec/__detail/__meta.hpp @@ -159,16 +159,17 @@ namespace stdexec { char const __what_[_Len]; }; -STDEXEC_PRAGMA_PUSH() -STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals") + STDEXEC_PRAGMA_PUSH() + STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals") #if STDEXEC_NVHPC() && (__EDG_VERSION__ < 604) // Use a non-standard extension for older nvc++ releases template <__mchar _Char, _Char... _Str> - [[deprecated("Use _mstr instead")]] - constexpr __mstring operator""__csz() noexcept { + [[deprecated("Use _mstr instead")]] constexpr __mstring + operator""__csz() noexcept { return {_Str...}; } + // Use a non-standard extension for older nvc++ releases template <__mchar _Char, _Char... _Str> constexpr __mstring operator""_mstr() noexcept { @@ -177,10 +178,10 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals") #elif STDEXEC_NVHPC() && (__EDG_VERSION__ < 605) // This is to work around an unfiled (by me) EDG bug that fixed in build 605 template <__mstring _Str> - [[deprecated("Use _mstr instead")]] - constexpr __mtypeof<_Str> const operator""__csz() noexcept { + [[deprecated("Use _mstr instead")]] constexpr __mtypeof<_Str> const operator""__csz() noexcept { return _Str; } + // This is to work around an unfiled (by me) EDG bug that fixed in build 605 template <__mstring _Str> constexpr __mtypeof<_Str> const operator""_mstr() noexcept { @@ -189,10 +190,10 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals") #else // Use a standard user-defined string literal template template <__mstring _Str> - [[deprecated("Use _mstr instead")]] - constexpr __mtypeof<_Str> operator""__csz() noexcept { + [[deprecated("Use _mstr instead")]] constexpr __mtypeof<_Str> operator""__csz() noexcept { return _Str; } + // Use a standard user-defined string literal template template <__mstring _Str> constexpr __mtypeof<_Str> operator""_mstr() noexcept { @@ -200,7 +201,7 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals") } #endif -STDEXEC_PRAGMA_POP() + STDEXEC_PRAGMA_POP() using __msuccess = int; diff --git a/include/stdexec/__detail/__utility.hpp b/include/stdexec/__detail/__utility.hpp index bfa14abab..9ac16b89b 100644 --- a/include/stdexec/__detail/__utility.hpp +++ b/include/stdexec/__detail/__utility.hpp @@ -23,12 +23,11 @@ namespace stdexec { namespace __detail { template - inline constexpr auto __forward_like = - [](_Uy&& __uy) noexcept -> auto&& { - return static_cast>>(__uy); - }; + inline constexpr auto __forward_like = [](_Uy&& __uy) noexcept -> auto&& { + return static_cast>>(__uy); + }; } template - inline constexpr auto const &__forward_like = __detail::__forward_like<__copy_cvref_fn<_Ty&&>>; + inline constexpr auto const & __forward_like = __detail::__forward_like<__copy_cvref_fn<_Ty&&>>; } diff --git a/include/stdexec/execution.hpp b/include/stdexec/execution.hpp index 42b739a04..95677cdcd 100644 --- a/include/stdexec/execution.hpp +++ b/include/stdexec/execution.hpp @@ -363,7 +363,7 @@ namespace stdexec { -> tag_invoke_result_t<__is_debug_env_t, const _Env&>; }; template - using __debug_env_t = __make_env_t<_Env, __with<__is_debug_env_t, bool>>; + using __debug_env_t = __env::__join_t<__env::__with, _Env>; template concept __is_debug_env = tag_invocable<__debug::__is_debug_env_t, _Env>; @@ -743,8 +743,8 @@ namespace stdexec { } else if constexpr (__with_member_alias<_Sender, _Env>) { using _Result = __member_alias_t<_Sender, _Env>; return (_Result(*)()) nullptr; - } else if constexpr (__awaitable<_Sender, __env_promise<_Env>>) { - using _Result = __await_result_t<_Sender, __env_promise<_Env>>; + } else if constexpr (__awaitable<_Sender, __env::__promise<_Env>>) { + using _Result = __await_result_t<_Sender, __env::__promise<_Env>>; return (completion_signatures< // set_value_t() or set_value_t(T) __minvoke<__remove>, _Result>, @@ -789,7 +789,7 @@ namespace stdexec { concept __enable_sender = // derived_from || requires { typename _Sender::is_sender; } // NOT TO SPEC back compat - || __awaitable<_Sender, __env_promise>; + || __awaitable<_Sender, __env::__promise>; } // namespace __detail template @@ -892,7 +892,7 @@ namespace stdexec { template < // class _Sender, // - class _Env = empty_env, // + class _Env = empty_env, // class _Tuple = __q<__decayed_tuple>, // class _Variant = __q<__variant>> using __try_value_types_of_t = // @@ -900,7 +900,7 @@ namespace stdexec { template < // class _Sender, // - class _Env = empty_env, // + class _Env = empty_env, // class _Tuple = __q<__decayed_tuple>, // class _Variant = __q<__variant>> requires sender_in<_Sender, _Env> @@ -917,7 +917,7 @@ namespace stdexec { template < // class _Sender, // - class _Env = empty_env, // + class _Env = empty_env, // template class _Tuple = __decayed_tuple, // template class _Variant = __variant> requires sender_in<_Sender, _Env> @@ -1000,7 +1000,7 @@ namespace stdexec { template < // class _Sender, // - class _Env = empty_env, // + class _Env = empty_env, // class _Sigs = completion_signatures<>, // class _SetValue = __q<__default_set_value>, // class _SetError = __q<__default_set_error>, // @@ -1078,7 +1078,7 @@ namespace stdexec { // SendsStopped>` is an alias for an empty struct template < // class _Sender, // - class _Env = empty_env, // + class _Env = empty_env, // __valid_completion_signatures _Sigs = completion_signatures<>, // template class _SetValue = __compl_sigs::__default_set_value, // template class _SetError = __compl_sigs::__default_set_error, // @@ -1939,8 +1939,8 @@ namespace stdexec { struct __sexpr_impl<__inln::__schedule_t> : __sexpr_defaults { static constexpr auto get_attrs = // [](__ignore) noexcept - -> __env::__prop<__inln::__scheduler(get_completion_scheduler_t)> { - return __mkprop(__inln::__scheduler{}, get_completion_scheduler); + -> __env::__with<__inln::__scheduler, get_completion_scheduler_t> { + return __env::__with(__inln::__scheduler{}, get_completion_scheduler); }; static constexpr auto get_completion_signatures = // @@ -2880,9 +2880,9 @@ namespace stdexec { namespace __shared { template using __env_t = // - __make_env_t< - _BaseEnv, // BUGBUG NOT TO SPEC - __with>; + __env::__join_t< + __env::__with, + _BaseEnv>; // BUGBUG NOT TO SPEC struct __on_stop_request { in_place_stop_source& __stop_source_; @@ -3031,7 +3031,8 @@ namespace stdexec { connect_result_t<_CvrefSender, __receiver_t> __op_state2_; explicit __shared_state(_CvrefSender&& __sndr, _Env __env) - : __env_(__make_env((_Env&&) __env, __mkprop(__stop_source_.get_token(), get_stop_token))) + : __env_( + __env::__join(__env::__with(__stop_source_.get_token(), get_stop_token), (_Env&&) __env)) , __op_state2_(connect((_CvrefSender&&) __sndr, __receiver_t{this})) { } @@ -3339,8 +3340,7 @@ namespace stdexec { struct __receiver_with<_ReceiverPtr, _EnvFns...> { struct __t : receiver_adaptor<__t> { using __id = __receiver_with; - using __env_t = - __env::__env_join_t<__result_of<_EnvFns, _Operation*>..., env_of_t<_Receiver>>; + using __env_t = __env::__join_t<__result_of<_EnvFns, _Operation*>..., env_of_t<_Receiver>>; _Operation* __op_state_; @@ -3349,7 +3349,8 @@ namespace stdexec { } __env_t get_env() const noexcept { - return __join_env(_EnvFns(__op_state_)..., stdexec::get_env(__op_state_->*_ReceiverPtr)); + return __env::__join( + _EnvFns(__op_state_)..., stdexec::get_env(__op_state_->*_ReceiverPtr)); } }; }; @@ -3364,15 +3365,14 @@ namespace stdexec { struct __let_t; template - inline constexpr __mstring __in_which_let_msg { - "In stdexec::let_value(Sender, Function)..."}; + inline constexpr __mstring __in_which_let_msg{"In stdexec::let_value(Sender, Function)..."}; template <> - inline constexpr __mstring __in_which_let_msg { + inline constexpr __mstring __in_which_let_msg{ "In stdexec::let_error(Sender, Function)..."}; template <> - inline constexpr __mstring __in_which_let_msg { + inline constexpr __mstring __in_which_let_msg{ "In stdexec::let_stopped(Sender, Function)..."}; template @@ -3396,8 +3396,10 @@ namespace stdexec { template _Tag> friend auto tag_invoke(_Tag, const __receiver_with_sched& __self) noexcept { - return __join_env( - __mkprop(__self.__sched_, get_scheduler), __mkprop(get_domain), get_env(__self.__rcvr_)); + return __env::__join( + __env::__with(__self.__sched_, get_scheduler), + __env::__without(get_domain), + get_env(__self.__rcvr_)); } }; @@ -3410,16 +3412,14 @@ namespace stdexec { using __result_env_t = __if_c< __unknown_context<_Scheduler>, _Env, - __env::__env_join_t< - __env::__prop<_Scheduler(get_scheduler_t)>, - __env::__prop, - _Env>>; + __env:: + __join_t< __env::__with<_Scheduler, get_scheduler_t>, __env::__without, _Env>>; template using __decay_ref = __decay_t<_Tp>&; template <__mstring _Where, __mstring _What> - struct _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_ {}; + struct _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_ { }; #if STDEXEC_NVHPC() template @@ -3435,13 +3435,12 @@ namespace stdexec { using __bad_result_sender = __t<__bad_result_sender_<_Sender, _Env, _Set>>; #else template - using __bad_result_sender = - __mexception< - _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_< - __in_which_let_msg<_Set>, - "The function must return a valid sender for the current environment"_mstr>, - _WITH_SENDER_<_Sender>, - _WITH_ENVIRONMENT_<_Env>>; + using __bad_result_sender = __mexception< + _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_< + __in_which_let_msg<_Set>, + "The function must return a valid sender for the current environment"_mstr>, + _WITH_SENDER_<_Sender>, + _WITH_ENVIRONMENT_<_Env>>; #endif template @@ -3513,7 +3512,7 @@ namespace stdexec { __completion_signatures_of_t<_CvrefSender, _Env>>; template <__mstring _Where, __mstring _What> - struct _NO_COMMON_DOMAIN_ {}; + struct _NO_COMMON_DOMAIN_ { }; template using __no_common_domain_t = // @@ -3540,8 +3539,7 @@ namespace stdexec { template auto __mk_transform_env_fn(const _Env& __env) noexcept { using _Set = __t<_LetTag>; - return [&]( - __ignore, _Fun&&, _Child&& __child) -> decltype(auto) { + return [&](__ignore, _Fun&&, _Child&& __child) -> decltype(auto) { using __completions_t = __completion_signatures_of_t<_Child, _Env>; if constexpr (__merror<__completions_t>) { return __completions_t(); @@ -3550,9 +3548,10 @@ namespace stdexec { if constexpr (__unknown_context<_Scheduler>) { return (__env); } else { - return __join_env( - __mkprop(get_completion_scheduler<_Set>(stdexec::get_env(__child)), get_scheduler), - __mkprop(get_domain), + return __env::__join( + __env::__with( + get_completion_scheduler<_Set>(stdexec::get_env(__child)), get_scheduler), + __env::__without(get_domain), __env); } } @@ -3653,7 +3652,7 @@ namespace stdexec { struct __let_impl : __sexpr_defaults { static constexpr auto get_attrs = // [](__ignore, const _Child& __child) noexcept { - return __join_env(__mkprop(_Domain(), get_domain), stdexec::get_env(__child)); + return __env::__join(__env::__with(_Domain(), get_domain), stdexec::get_env(__child)); }; static constexpr auto get_completion_signatures = // @@ -4089,9 +4088,10 @@ namespace stdexec { template struct __environ { struct __t - : __env::__prop( + : __env::__with< + stdexec::__t<_SchedulerId>, get_completion_scheduler_t, - get_completion_scheduler_t)> { + get_completion_scheduler_t> { using __id = __environ; template _Key> @@ -4182,7 +4182,7 @@ namespace stdexec { static constexpr auto get_attrs = // [](const _Data& __data, const _Child& __child) noexcept { - return __join_env(__data, stdexec::get_env(__child)); + return __env::__join(__data, stdexec::get_env(__child)); }; static constexpr auto get_completion_signatures = // @@ -4291,7 +4291,7 @@ namespace stdexec { static constexpr auto get_attrs = // [](const _Data& __data, const _Child& __child) noexcept -> decltype(auto) { - return __join_env(__data, stdexec::get_env(__child)); + return __env::__join(__data, stdexec::get_env(__child)); }; }; } // namespace __transfer @@ -4348,7 +4348,7 @@ namespace stdexec { inline auto __make_env_fn() noexcept { return [](const _Scheduler& __sched, const auto&...) noexcept { using _Env = __t<__schedule_from::__environ<__id<_Scheduler>>>; - return _Env{{__sched}}; + return _Env{__sched}; }; } @@ -4372,7 +4372,7 @@ namespace stdexec { struct __write_t { template auto operator()(_Sender&& __sndr, _Envs... __envs) const { - return __make_sexpr<__write_t>(__join_env(std::move(__envs)...), (_Sender&&) __sndr); + return __make_sexpr<__write_t>(__env::__join(std::move(__envs)...), (_Sender&&) __sndr); } template @@ -4385,7 +4385,7 @@ namespace stdexec { STDEXEC_ATTRIBUTE((always_inline)) static auto __transform_env_fn(_Env&& __env) noexcept { return [&](__ignore, const auto& __state, __ignore) noexcept { - return __join_env(__state, (_Env&&) __env); + return __env::__join(__state, (_Env&&) __env); }; } @@ -4398,14 +4398,14 @@ namespace stdexec { struct __write_impl : __sexpr_defaults { static constexpr auto get_env = // [](__ignore, const auto& __state, const auto& __rcvr) noexcept { - return __join_env(__state, stdexec::get_env(__rcvr)); + return __env::__join(__state, stdexec::get_env(__rcvr)); }; static constexpr auto get_completion_signatures = // [](_Self&&, _Env&&) noexcept -> stdexec::__completion_signatures_of_t< __child_of<_Self>, - __env::__env_join_t>&, _Env>> { + __env::__join_t>&, _Env>> { static_assert(sender_expr_for<_Self, __write_t>); return {}; }; @@ -4422,7 +4422,8 @@ namespace stdexec { template STDEXEC_ATTRIBUTE((always_inline)) auto __mkenv_sched(_Scheduler __sched) { - auto __env = __join_env(__mkprop(__sched, get_scheduler), __mkprop(get_domain)); + auto __env = __env::__join( + __env::__with(__sched, get_scheduler), __env::__without(get_domain)); struct __env_t : decltype(__env) { }; @@ -4461,7 +4462,7 @@ namespace stdexec { STDEXEC_ATTRIBUTE((always_inline)) static auto __transform_env_fn(_Env&& __env) noexcept { return [&](__ignore, auto __sched, __ignore) noexcept { - return __join_env(__detail::__mkenv_sched(__sched), (_Env&&) __env); + return __env::__join(__detail::__mkenv_sched(__sched), (_Env&&) __env); }; } @@ -4582,7 +4583,8 @@ namespace stdexec { template auto __mkenv(_Env&& __env, in_place_stop_source& __stop_source) noexcept { - return __join_env(__mkprop(__stop_source.get_token(), get_stop_token), (_Env&&) __env); + return __env::__join( + __env::__with(__stop_source.get_token(), get_stop_token), (_Env&&) __env); } template @@ -4816,7 +4818,7 @@ namespace stdexec { if constexpr (same_as<_Domain, default_domain>) { return empty_env(); } else { - return __mkprop(_Domain(), get_domain); + return __env::__with(_Domain(), get_domain); } STDEXEC_UNREACHABLE(); }; @@ -4954,7 +4956,7 @@ namespace stdexec { if constexpr (same_as<_Domain, default_domain>) { return empty_env(); } else { - return __mkprop(_Domain(), get_domain); + return __env::__with(_Domain(), get_domain); } STDEXEC_UNREACHABLE(); }; @@ -5265,7 +5267,7 @@ namespace stdexec { STDEXEC_ATTRIBUTE((always_inline)) static auto __transform_env_fn(_Env&& __env) noexcept { return [&](__ignore, auto __sched, __ignore) noexcept { - return __join_env(__detail::__mkenv_sched(__sched), (_Env&&) __env); + return __env::__join(__detail::__mkenv_sched(__sched), (_Env&&) __env); }; } @@ -5354,16 +5356,13 @@ namespace stdexec { // [execution.senders.consumers.sync_wait_with_variant] namespace __sync_wait { inline auto __make_env(run_loop& __loop) noexcept { - return __env::__env_fn{ - [&](__one_of auto) noexcept { - return __loop.get_scheduler(); - }}; + return __env::__with(__loop.get_scheduler(), get_scheduler, get_delegatee_scheduler); } struct __env : __result_of<__make_env, run_loop&> { __env(); - __env(run_loop& __loop) noexcept + explicit __env(run_loop& __loop) noexcept : __result_of<__make_env, run_loop&>{__sync_wait::__make_env(__loop)} { } }; diff --git a/test/exec/test_repeat_effect_until_fail.cpp b/test/exec/test_repeat_effect_until_fail.cpp index 25fd74fb0..ff2093b90 100644 --- a/test/exec/test_repeat_effect_until_fail.cpp +++ b/test/exec/test_repeat_effect_until_fail.cpp @@ -19,7 +19,7 @@ namespace ex = stdexec; -struct not_a_bool {}; +struct not_a_bool { }; int main() { ex::sender auto snd = ex::just(not_a_bool()) | exec::repeat_effect_until(); diff --git a/test/exec/test_repeat_n.cpp b/test/exec/test_repeat_n.cpp index 7a67ce3f9..59c71563b 100644 --- a/test/exec/test_repeat_n.cpp +++ b/test/exec/test_repeat_n.cpp @@ -36,23 +36,19 @@ using namespace stdexec; namespace { TEST_CASE("repeat_n returns a sender", "[adaptors][repeat_n]") { - auto snd = exec::repeat_n(ex::just() | then([] { }), 10); + auto snd = exec::repeat_n(ex::just() | then([] {}), 10); static_assert(ex::sender); (void) snd; } - TEST_CASE( - "repeat_n with environment returns a sender", - "[adaptors][repeat_n]") { - auto snd = exec::repeat_n(just() | then([] { }), 10); + TEST_CASE("repeat_n with environment returns a sender", "[adaptors][repeat_n]") { + auto snd = exec::repeat_n(just() | then([] {}), 10); static_assert(ex::sender_in); (void) snd; } - TEST_CASE( - "repeat_n produces void value to downstream receiver", - "[adaptors][repeat_n]") { - sender auto source = just(1) | then([](int n) { }); + TEST_CASE("repeat_n produces void value to downstream receiver", "[adaptors][repeat_n]") { + sender auto source = just(1) | then([](int n) {}); sender auto snd = exec::repeat_n(std::move(source), 10); // The receiver checks if we receive the void value auto op = stdexec::connect(std::move(snd), expect_void_receiver{}); @@ -67,9 +63,7 @@ namespace { TEST_CASE("repeat_n works with with zero repetitions", "[adaptors][repeat_n]") { std::size_t count = 0; ex::sender auto snd = just() // - | then([&count] { ++count; }) - | exec::repeat_n(0) - | then([] { return 1; }); + | then([&count] { ++count; }) | exec::repeat_n(0) | then([] { return 1; }); wait_for_value(std::move(snd), 1); CHECK(count == 0); } @@ -77,9 +71,7 @@ namespace { TEST_CASE("repeat_n works with a single repetition", "[adaptors][repeat_n]") { std::size_t count = 0; ex::sender auto snd = just() // - | then([&count] { ++count; }) - | exec::repeat_n(1) - | then([] { return 1; }); + | then([&count] { ++count; }) | exec::repeat_n(1) | then([] { return 1; }); wait_for_value(std::move(snd), 1); CHECK(count == 1); } @@ -87,18 +79,19 @@ namespace { TEST_CASE("repeat_n works with multiple repetitions", "[adaptors][repeat_n]") { std::size_t count = 0; ex::sender auto snd = just() // - | then([&count] { ++count; }) - | exec::repeat_n(3) - | then([] { return 1; }); + | then([&count] { ++count; }) | exec::repeat_n(3) | then([] { return 1; }); wait_for_value(std::move(snd), 1); CHECK(count == 3); } - TEST_CASE( - "repeat_n forwards set_error calls of other types", - "[adaptors][repeat_n]") { + TEST_CASE("repeat_n forwards set_error calls of other types", "[adaptors][repeat_n]") { int count = 0; - auto snd = let_value(just(), [&] { ++count; return just_error(std::string("error")); }) + auto snd = let_value( + just(), + [&] { + ++count; + return just_error(std::string("error")); + }) | exec::repeat_n(10); auto op = ex::connect(std::move(snd), expect_error_receiver{std::string("error")}); start(op); @@ -107,7 +100,12 @@ namespace { TEST_CASE("repeat_n forwards set_stopped calls", "[adaptors][repeat_n]") { int count = 0; - auto snd = let_value(just(), [&] { ++count; return just_stopped(); }) + auto snd = let_value( + just(), + [&] { + ++count; + return just_stopped(); + }) | exec::repeat_n(10); auto op = ex::connect(std::move(snd), expect_stopped_receiver{}); start(op); @@ -129,10 +127,7 @@ namespace { sender auto snd = exec::on( pool.get_scheduler(), // ex::just() // - | ex::then([&] { - called = true; - }) - | exec::repeat_n(10)); + | ex::then([&] { called = true; }) | exec::repeat_n(10)); stdexec::sync_wait(std::move(snd)); REQUIRE(called); } diff --git a/test/stdexec/algos/adaptors/test_bulk.cpp b/test/stdexec/algos/adaptors/test_bulk.cpp index aa7a3ded2..75c94a7de 100644 --- a/test/stdexec/algos/adaptors/test_bulk.cpp +++ b/test/stdexec/algos/adaptors/test_bulk.cpp @@ -204,7 +204,8 @@ namespace { for (std::size_t n = 0; n < 9u; n++) { std::vector counter(n, 42); - auto snd = ex::transfer_just(sch) | ex::bulk(n, [&counter](std::size_t idx) { counter[idx] = 0; }) + auto snd = ex::transfer_just(sch) + | ex::bulk(n, [&counter](std::size_t idx) { counter[idx] = 0; }) | ex::bulk(n, [&counter](std::size_t idx) { counter[idx]++; }); stdexec::sync_wait(std::move(snd)); @@ -249,9 +250,10 @@ namespace { std::vector vals_expected(n); std::iota(vals_expected.begin(), vals_expected.end(), 1); - auto snd = ex::transfer_just(sch, std::move(vals)) - | ex::bulk(n, [](std::size_t idx, std::vector& vals) { vals[idx] = (int) idx; }) - | ex::bulk(n, [](std::size_t idx, std::vector& vals) { ++vals[idx]; }); + auto snd = + ex::transfer_just(sch, std::move(vals)) + | ex::bulk(n, [](std::size_t idx, std::vector& vals) { vals[idx] = (int) idx; }) + | ex::bulk(n, [](std::size_t idx, std::vector& vals) { ++vals[idx]; }); auto [vals_actual] = stdexec::sync_wait(std::move(snd)).value(); CHECK(vals_actual == vals_expected); diff --git a/test/stdexec/algos/adaptors/test_let_fail1.cpp b/test/stdexec/algos/adaptors/test_let_fail1.cpp index 87677c6dc..36aa3e52b 100644 --- a/test/stdexec/algos/adaptors/test_let_fail1.cpp +++ b/test/stdexec/algos/adaptors/test_let_fail1.cpp @@ -19,7 +19,7 @@ namespace ex = stdexec; int main() { - ex::sender auto snd = ex::just(42) | ex::let_value([](int) { }); + ex::sender auto snd = ex::just(42) | ex::let_value([](int) {}); // build error: _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_ stdexec::sync_wait(std::move(snd)); } diff --git a/test/stdexec/algos/consumers/test_sync_wait.cpp b/test/stdexec/algos/consumers/test_sync_wait.cpp index fa05b07ad..63ae4f982 100644 --- a/test/stdexec/algos/consumers/test_sync_wait.cpp +++ b/test/stdexec/algos/consumers/test_sync_wait.cpp @@ -302,8 +302,8 @@ namespace { // The customization will return a different value auto snd = ex::transfer(my_multi_value_sender_t{"hello_multi"}, inline_scheduler{}); auto snd2 = ex::transfer_just(inline_scheduler{}, std::string{"hello"}); - optional, std::tuple>> res = - sync_wait_with_variant(std::move(snd)); + optional, std::tuple>> res = sync_wait_with_variant( + std::move(snd)); CHECK(res.has_value()); CHECK(std::get<0>(std::get<0>(res.value())) == std::string{"hallo_multi"}); } @@ -313,8 +313,8 @@ namespace { "[consumers][sync_wait_with_variant]") { // The customization will return a different value my_multi_value_sender_t snd{std::string{"hello_multi"}}; - optional, std::tuple>> res = - sync_wait_with_variant(std::move(snd)); + optional, std::tuple>> res = sync_wait_with_variant( + std::move(snd)); CHECK(res.has_value()); CHECK(std::get<0>(std::get<0>(res.value())) == std::string{"ciao_multi"}); } diff --git a/test/stdexec/concepts/test_awaitables.cpp b/test/stdexec/concepts/test_awaitables.cpp index cdc285c52..081a90212 100644 --- a/test/stdexec/concepts/test_awaitables.cpp +++ b/test/stdexec/concepts/test_awaitables.cpp @@ -177,7 +177,7 @@ namespace { static_assert(ex::__awaiter); static_assert(!ex::__awaitable); static_assert(ex::__awaitable>); - static_assert(ex::__awaitable>); + static_assert(ex::__awaitable>); static_assert( !ex::__get_completion_signatures::__with_member_alias); @@ -201,7 +201,7 @@ namespace { static_assert(ex::__awaiter); static_assert(!ex::__awaitable); static_assert(ex::__awaitable>); - static_assert(ex::__awaitable>); + static_assert(ex::__awaitable>); static_assert( !ex::__get_completion_signatures::__with_member_alias); @@ -260,7 +260,7 @@ namespace { ex::sender auto snd = ex::when_all(ex::then(ex::schedule(sch), []() {})); using _Awaitable = decltype(snd); - using _Promise = ex::__env_promise; + using _Promise = ex::__env::__promise; static_assert(!ex::__awaitable<_Awaitable, _Promise>); } }