From 713b6f195ee59eef3e0634c26b7110bbe8e60b42 Mon Sep 17 00:00:00 2001 From: dietmarkuehl Date: Tue, 14 Jan 2025 00:49:23 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20@=20bemanpro?= =?UTF-8?q?ject/execution26@b52f28c2f3b6fbb5d132d9e122366f19d3598ad9=20?= =?UTF-8?q?=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- basic__sender_8hpp_source.html | 153 ++++++++++++++--------------- connect__all_8hpp_source.html | 123 +++++++++++++++-------- default__impls_8hpp_source.html | 50 ++++++---- product__type_8hpp_source.html | 48 +++++---- sender__decompose_8hpp_source.html | 99 +++++++++---------- 5 files changed, 263 insertions(+), 210 deletions(-) diff --git a/basic__sender_8hpp_source.html b/basic__sender_8hpp_source.html index 64f121c5..c290dfce 100644 --- a/basic__sender_8hpp_source.html +++ b/basic__sender_8hpp_source.html @@ -108,83 +108,82 @@
33 using indices_for = ::std::index_sequence_for<Child...>;
34
35 auto get_env() const noexcept -> decltype(auto) {
-
36 auto data{::beman::execution26::detail::get_sender_data(*this)};
-
37 return ::std::apply(
-
38 [&data](auto&&... c) { return ::beman::execution26::detail::impls_for<Tag>::get_attrs(data.data, c...); },
-
39 data.children);
-
40 }
-
41
-
42 template <typename Receiver>
-
43 requires(not::beman::execution26::receiver<Receiver>)
-
44 auto connect(Receiver receiver) = BEMAN_EXECUTION26_DELETE("the passed receiver doesn't model receiver");
-
45
-
46 private:
-
47#if __cpp_explicit_this_parameter < 302110L //-dk:TODO need to figure out how to use explicit this with forwarding
-
48 template <::beman::execution26::receiver Receiver>
-
49 auto connect(Receiver receiver) & noexcept(
-
50 noexcept(::beman::execution26::detail::basic_operation<basic_sender&, Receiver>{*this, ::std::move(receiver)}))
-
51 -> ::beman::execution26::detail::basic_operation<basic_sender&, Receiver> {
-
52 return {*this, ::std::move(receiver)};
-
53 }
-
54 template <::beman::execution26::receiver Receiver>
-
55 auto connect(Receiver receiver) const& noexcept(noexcept(
-
56 ::beman::execution26::detail::basic_operation<const basic_sender&, Receiver>{*this, ::std::move(receiver)}))
-
57 -> ::beman::execution26::detail::basic_operation<const basic_sender&, Receiver> {
-
58 return {*this, ::std::move(receiver)};
-
59 }
-
60 template <::beman::execution26::receiver Receiver>
-
61 auto connect(Receiver receiver) && noexcept(
-
62 noexcept(::beman::execution26::detail::basic_operation<basic_sender, Receiver>{::std::move(*this),
-
63 ::std::move(receiver)}))
-
64 -> ::beman::execution26::detail::basic_operation<basic_sender, Receiver> {
-
65 return {::std::move(*this), ::std::move(receiver)};
-
66 }
-
67#else
-
68 template <::beman::execution26::detail::decays_to<basic_sender> Self, ::beman::execution26::receiver Receiver>
-
69 auto
-
70 connect(this Self&& self,
-
71 Receiver receiver) noexcept(noexcept(::beman::execution26::detail::basic_operation<basic_sender, Receiver>{
-
72 ::std::forward<Self>(self), ::std::move(receiver)}))
-
73 -> ::beman::execution26::detail::basic_operation<Self, Receiver> {
-
74 return {::std::forward<Self>(self), ::std::move(receiver)};
-
75 }
-
76#endif
-
77#if __cpp_explicit_this_parameter < 302110L
-
78 template <typename Env>
-
79 auto
-
80 get_completion_signatures(Env&&) && -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env> {
-
81 return {};
-
82 }
-
83 template <typename Env>
-
84 auto get_completion_signatures(
-
85 Env&&) const&& -> ::beman::execution26::detail::completion_signatures_for<const basic_sender, Env> {
-
86 return {};
-
87 }
-
88 template <typename Env>
-
89 auto
-
90 get_completion_signatures(Env&&) & -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env> {
-
91 return {};
-
92 }
-
93 template <typename Env>
-
94 auto get_completion_signatures(
-
95 Env&&) const& -> ::beman::execution26::detail::completion_signatures_for<const basic_sender, Env> {
-
96 return {};
-
97 }
-
98#else
-
99 template <::beman::execution26::detail::decays_to<basic_sender> Self, typename Env>
-
100 auto get_completion_signatures(this Self&&, Env&&) noexcept
-
101 -> ::beman::execution26::detail::completion_signatures_for<Self, Env> {
-
102 return {};
-
103 }
-
104#endif
-
105};
-
106} // namespace beman::execution26::detail
-
107
-
108// ----------------------------------------------------------------------------
-
109
-
110#include <beman/execution26/detail/suppress_pop.hpp>
-
111
-
112#endif
+
36 auto&& d{this->template get<1>()};
+
37 return sub_apply<2>(
+
38 [&d](auto&&... c) { return ::beman::execution26::detail::impls_for<Tag>::get_attrs(d, c...); }, *this);
+
39 }
+
40
+
41 template <typename Receiver>
+
42 requires(not::beman::execution26::receiver<Receiver>)
+
43 auto connect(Receiver receiver) = BEMAN_EXECUTION26_DELETE("the passed receiver doesn't model receiver");
+
44
+
45 private:
+
46#if __cpp_explicit_this_parameter < 302110L //-dk:TODO need to figure out how to use explicit this with forwarding
+
47 template <::beman::execution26::receiver Receiver>
+
48 auto connect(Receiver receiver) & noexcept(
+
49 noexcept(::beman::execution26::detail::basic_operation<basic_sender&, Receiver>{*this, ::std::move(receiver)}))
+
50 -> ::beman::execution26::detail::basic_operation<basic_sender&, Receiver> {
+
51 return {*this, ::std::move(receiver)};
+
52 }
+
53 template <::beman::execution26::receiver Receiver>
+
54 auto connect(Receiver receiver) const& noexcept(noexcept(
+
55 ::beman::execution26::detail::basic_operation<const basic_sender&, Receiver>{*this, ::std::move(receiver)}))
+
56 -> ::beman::execution26::detail::basic_operation<const basic_sender&, Receiver> {
+
57 return {*this, ::std::move(receiver)};
+
58 }
+
59 template <::beman::execution26::receiver Receiver>
+
60 auto connect(Receiver receiver) && noexcept(
+
61 noexcept(::beman::execution26::detail::basic_operation<basic_sender, Receiver>{::std::move(*this),
+
62 ::std::move(receiver)}))
+
63 -> ::beman::execution26::detail::basic_operation<basic_sender, Receiver> {
+
64 return {::std::move(*this), ::std::move(receiver)};
+
65 }
+
66#else
+
67 template <::beman::execution26::detail::decays_to<basic_sender> Self, ::beman::execution26::receiver Receiver>
+
68 auto
+
69 connect(this Self&& self,
+
70 Receiver receiver) noexcept(noexcept(::beman::execution26::detail::basic_operation<basic_sender, Receiver>{
+
71 ::std::forward<Self>(self), ::std::move(receiver)}))
+
72 -> ::beman::execution26::detail::basic_operation<Self, Receiver> {
+
73 return {::std::forward<Self>(self), ::std::move(receiver)};
+
74 }
+
75#endif
+
76#if __cpp_explicit_this_parameter < 302110L
+
77 template <typename Env>
+
78 auto
+
79 get_completion_signatures(Env&&) && -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env> {
+
80 return {};
+
81 }
+
82 template <typename Env>
+
83 auto get_completion_signatures(
+
84 Env&&) const&& -> ::beman::execution26::detail::completion_signatures_for<const basic_sender, Env> {
+
85 return {};
+
86 }
+
87 template <typename Env>
+
88 auto
+
89 get_completion_signatures(Env&&) & -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env> {
+
90 return {};
+
91 }
+
92 template <typename Env>
+
93 auto get_completion_signatures(
+
94 Env&&) const& -> ::beman::execution26::detail::completion_signatures_for<const basic_sender, Env> {
+
95 return {};
+
96 }
+
97#else
+
98 template <::beman::execution26::detail::decays_to<basic_sender> Self, typename Env>
+
99 auto get_completion_signatures(this Self&&, Env&&) noexcept
+
100 -> ::beman::execution26::detail::completion_signatures_for<Self, Env> {
+
101 return {};
+
102 }
+
103#endif
+
104};
+
105} // namespace beman::execution26::detail
+
106
+
107// ----------------------------------------------------------------------------
+
108
+
109#include <beman/execution26/detail/suppress_pop.hpp>
+
110
+
111#endif
beman::execution26::connect
constexpr connect_t connect
Customization point object used to connect a sender and a receiver.
Definition: connect.hpp:93
beman
Namespace for Beman projects http://github.com/bemanproject/beman.
Definition: allocator_aware_move.hpp:16
beman::execution26::sender_t
Definition: sender.hpp:18
diff --git a/connect__all_8hpp_source.html b/connect__all_8hpp_source.html index 6706be23..de2303ac 100644 --- a/connect__all_8hpp_source.html +++ b/connect__all_8hpp_source.html @@ -119,48 +119,87 @@
44 ::std::forward<Tuple>(tuple));
45 }
46
-
47 template <typename Sender, typename Receiver>
-
48 struct connect_helper {
-
49 ::beman::execution26::detail::basic_state<Sender, Receiver>* op;
-
50
-
51 template <::std::size_t... J, typename... C>
-
52 auto operator()(::std::index_sequence<J...>, C&&... c) noexcept(
-
53 (noexcept(::beman::execution26::connect(
-
54 ::beman::execution26::detail::forward_like<Sender>(c),
-
55 ::beman::execution26::detail::basic_receiver<Sender, Receiver, ::std::integral_constant<::size_t, J>>{
-
56 this->op})) &&
-
57 ... && true)) -> decltype(auto) {
-
58 return ::beman::execution26::detail::product_type{::beman::execution26::connect(
-
59 ::beman::execution26::detail::forward_like<Sender>(c),
-
60 ::beman::execution26::detail::basic_receiver<Sender, Receiver, ::std::integral_constant<::size_t, J>>{
-
61 this->op})...};
-
62 }
-
63 };
-
64
-
65 static auto use(auto&&...) {}
-
66
-
67 public:
-
68 //-dk:TODO is the S parameter deviating from the spec?
-
69 template <typename Sender, typename S, typename Receiver, ::std::size_t... I>
-
70 auto operator()(::beman::execution26::detail::basic_state<Sender, Receiver>* op,
-
71 S&& sender,
-
72 ::std::index_sequence<I...>) const
-
73 noexcept(noexcept(apply_with_index(
-
74 connect_helper<Sender, Receiver>{op},
-
75 ::beman::execution26::detail::get_sender_data(::std::forward<S>(sender)).children))) -> decltype(auto) {
-
76 return apply_with_index(connect_helper<Sender, Receiver>{op},
-
77 ::beman::execution26::detail::get_sender_data(::std::forward<S>(sender)).children);
-
78 }
-
79};
-
80
-
86inline constexpr connect_all_t connect_all{};
-
87} // namespace beman::execution26::detail
-
88
-
89#include <beman/execution26/detail/suppress_pop.hpp>
-
90
-
91// ----------------------------------------------------------------------------
-
92
-
93#endif
+
47 template <::std::size_t Start, typename Fun, typename Tuple, ::std::size_t... I>
+
48 static auto sub_apply_with_index_helper(::std::index_sequence<I...> seq, Fun&& fun, Tuple&& tuple) noexcept(
+
49 noexcept(::std::forward<Fun>(fun)(
+
50 seq, ::beman::execution26::detail::forward_like<Tuple>(tuple.template get<I + Start>())...)))
+
51 -> decltype(auto) {
+
52 return ::std::forward<Fun>(fun)(
+
53 seq, ::beman::execution26::detail::forward_like<Tuple>(tuple.template get<I + Start>())...);
+
54 }
+
55 template <::std::size_t Start, typename Fun, typename Tuple>
+
56 requires requires { ::std::declval<Tuple>().size(); }
+
57 static auto sub_apply_with_index(Fun&& fun, Tuple&& tuple) noexcept(noexcept(sub_apply_with_index_helper<Start>(
+
58 ::std::make_index_sequence<::std::tuple_size_v<::std::decay_t<Tuple>> - Start>{},
+
59 ::std::forward<Fun>(fun),
+
60 ::std::forward<Tuple>(tuple)))) -> decltype(auto) {
+
61 return sub_apply_with_index_helper<Start>(
+
62 ::std::make_index_sequence<::std::tuple_size_v<::std::decay_t<Tuple>> - Start>{},
+
63 ::std::forward<Fun>(fun),
+
64 ::std::forward<Tuple>(tuple));
+
65 }
+
66 template <::std::size_t Start, typename Fun, typename Tuple>
+
67 requires(not requires { ::std::declval<Tuple>().size(); })
+
68 static auto
+
69 sub_apply_with_index(Fun&& fun,
+
70 Tuple&&) noexcept(noexcept(::std::forward<Fun>(fun)(::std::make_index_sequence<0u>{}))) {
+
71 return ::std::forward<Fun>(fun)(::std::make_index_sequence<0u>{});
+
72 }
+
73
+
74 template <typename Sender, typename Receiver>
+
75 struct connect_helper {
+
76 ::beman::execution26::detail::basic_state<Sender, Receiver>* op;
+
77
+
78 template <::std::size_t... J, typename... C>
+
79 auto operator()(::std::index_sequence<J...>, C&&... c) noexcept(
+
80 (noexcept(::beman::execution26::connect(
+
81 ::beman::execution26::detail::forward_like<Sender>(c),
+
82 ::beman::execution26::detail::basic_receiver<Sender, Receiver, ::std::integral_constant<::size_t, J>>{
+
83 this->op})) &&
+
84 ... && true)) -> decltype(auto) {
+
85 return ::beman::execution26::detail::product_type{::beman::execution26::connect(
+
86 ::beman::execution26::detail::forward_like<Sender>(c),
+
87 ::beman::execution26::detail::basic_receiver<Sender, Receiver, ::std::integral_constant<::size_t, J>>{
+
88 this->op})...};
+
89 }
+
90 };
+
91
+
92 static auto use(auto&&...) {}
+
93
+
94 public:
+
95 //-dk:TODO is the S parameter deviating from the spec?
+
96 template <typename Sender, typename S, typename Receiver, ::std::size_t... I>
+
97 requires requires(Sender&& s) {
+
98 s.size();
+
99 s.template get<0>();
+
100 }
+
101 auto operator()(::beman::execution26::detail::basic_state<Sender, Receiver>* op,
+
102 S&& sender,
+
103 ::std::index_sequence<I...>) const
+
104 noexcept(noexcept(sub_apply_with_index<2>(connect_helper<Sender, Receiver>{op}, ::std::forward<S>(sender))))
+
105 -> decltype(auto) {
+
106 return sub_apply_with_index<2>(connect_helper<Sender, Receiver>{op}, ::std::forward<S>(sender));
+
107 }
+
108 template <typename Sender, typename S, typename Receiver, ::std::size_t... I>
+
109 auto operator()(::beman::execution26::detail::basic_state<Sender, Receiver>* op,
+
110 S&& sender,
+
111 ::std::index_sequence<I...>) const
+
112 noexcept(noexcept(apply_with_index(
+
113 connect_helper<Sender, Receiver>{op},
+
114 ::beman::execution26::detail::get_sender_data(::std::forward<S>(sender)).children))) -> decltype(auto) {
+
115 return apply_with_index(connect_helper<Sender, Receiver>{op},
+
116 ::beman::execution26::detail::get_sender_data(::std::forward<S>(sender)).children);
+
117 }
+
118};
+
119
+
125inline constexpr connect_all_t connect_all{};
+
126} // namespace beman::execution26::detail
+
127
+
128#include <beman/execution26/detail/suppress_pop.hpp>
+
129
+
130// ----------------------------------------------------------------------------
+
131
+
132#endif
beman::execution26::connect
constexpr connect_t connect
Customization point object used to connect a sender and a receiver.
Definition: connect.hpp:93
diff --git a/default__impls_8hpp_source.html b/default__impls_8hpp_source.html index d9d79d0d..fd051896 100644 --- a/default__impls_8hpp_source.html +++ b/default__impls_8hpp_source.html @@ -112,27 +112,35 @@
37 };
38 static constexpr auto get_state =
39 []<typename Sender, typename Receiver>(Sender&& sender, Receiver& receiver) noexcept -> decltype(auto) {
-
40 auto&& decompose = ::beman::execution26::detail::get_sender_data(::std::forward<Sender>(sender));
-
41
-
42 return ::beman::execution26::detail::allocator_aware_move(
-
43 ::beman::execution26::detail::forward_like<Sender>(decompose.data), receiver);
-
44 };
-
45 static constexpr auto start = [](auto&, auto&, auto&... ops) noexcept -> void {
-
46 (::beman::execution26::start(ops), ...);
-
47 };
-
48 static constexpr auto complete = []<typename Index, typename Receiver, typename Tag, typename... Args>(
-
49 Index, auto&, Receiver& receiver, Tag, Args&&... args) noexcept -> void
-
50 requires ::beman::execution26::detail::callable<Tag, Receiver, Args...>
-
51 {
-
52 static_assert(Index::value == 0);
-
53 Tag()(::std::move(receiver), ::std::forward<Args>(args)...);
-
54 };
-
55};
-
56} // namespace beman::execution26::detail
-
57
-
58// ----------------------------------------------------------------------------
-
59
-
60#endif
+
40 auto&& data{[&sender]() -> decltype(auto) {
+
41 if constexpr (requires {
+
42 sender.size();
+
43 sender.template get<1>();
+
44 })
+
45 return sender.template get<1>();
+
46 else
+
47 return ::beman::execution26::detail::get_sender_data(::std::forward<Sender>(sender)).data;
+
48 }()};
+
49
+
50 return ::beman::execution26::detail::allocator_aware_move(
+
51 ::beman::execution26::detail::forward_like<Sender>(data), receiver);
+
52 };
+
53 static constexpr auto start = [](auto&, auto&, auto&... ops) noexcept -> void {
+
54 (::beman::execution26::start(ops), ...);
+
55 };
+
56 static constexpr auto complete = []<typename Index, typename Receiver, typename Tag, typename... Args>(
+
57 Index, auto&, Receiver& receiver, Tag, Args&&... args) noexcept -> void
+
58 requires ::beman::execution26::detail::callable<Tag, Receiver, Args...>
+
59 {
+
60 static_assert(Index::value == 0);
+
61 Tag()(::std::move(receiver), ::std::forward<Args>(args)...);
+
62 };
+
63};
+
64} // namespace beman::execution26::detail
+
65
+
66// ----------------------------------------------------------------------------
+
67
+
68#endif
diff --git a/product__type_8hpp_source.html b/product__type_8hpp_source.html index 334292d8..377c8ab4 100644 --- a/product__type_8hpp_source.html +++ b/product__type_8hpp_source.html @@ -192,25 +192,39 @@
112constexpr auto is_product_type(const ::beman::execution26::detail::product_type<T...>&) -> ::std::true_type {
113 return {};
114}
-
115} // namespace beman::execution26::detail
-
116
-
117namespace std {
-
118template <typename T>
-
119 requires ::beman::execution26::detail::is_product_type_c<T>
-
120struct tuple_size<T> : ::std::integral_constant<std::size_t, T::size()> {};
-
121
-
122template <::std::size_t I, typename T>
-
123 requires ::beman::execution26::detail::is_product_type_c<T>
-
124struct tuple_element<I, T> {
-
125 using type = ::std::decay_t<decltype(::std::declval<T>().template get<I>())>;
-
126};
-
127} // namespace std
+
115
+
116template <::std::size_t Start, typename Fun, typename Tuple, ::std::size_t... I>
+
117constexpr auto sub_apply_helper(Fun&& fun, Tuple&& tuple, ::std::index_sequence<I...>) -> decltype(auto) {
+
118 return ::std::forward<Fun>(fun)(::std::forward<Tuple>(tuple).template get<I + Start>()...);
+
119}
+
120
+
121template <::std::size_t Start, typename Fun, typename Tuple>
+
122constexpr auto sub_apply(Fun&& fun, Tuple&& tuple) -> decltype(auto) {
+
123 static constexpr ::std::size_t TSize{::std::tuple_size_v<::std::remove_cvref_t<Tuple>>};
+
124 static_assert(Start <= TSize);
+
125 return sub_apply_helper<Start>(
+
126 ::std::forward<Fun>(fun), ::std::forward<Tuple>(tuple), ::std::make_index_sequence<TSize - Start>());
+
127}
128
-
129// ----------------------------------------------------------------------------
+
129} // namespace beman::execution26::detail
130
-
131#include <beman/execution26/detail/suppress_pop.hpp>
-
132
-
133#endif
+
131namespace std {
+
132template <typename T>
+
133 requires ::beman::execution26::detail::is_product_type_c<T>
+
134struct tuple_size<T> : ::std::integral_constant<std::size_t, T::size()> {};
+
135
+
136template <::std::size_t I, typename T>
+
137 requires ::beman::execution26::detail::is_product_type_c<T>
+
138struct tuple_element<I, T> {
+
139 using type = ::std::decay_t<decltype(::std::declval<T>().template get<I>())>;
+
140};
+
141} // namespace std
+
142
+
143// ----------------------------------------------------------------------------
+
144
+
145#include <beman/execution26/detail/suppress_pop.hpp>
+
146
+
147#endif
diff --git a/sender__decompose_8hpp_source.html b/sender__decompose_8hpp_source.html index dd95b03b..12c177a1 100644 --- a/sender__decompose_8hpp_source.html +++ b/sender__decompose_8hpp_source.html @@ -113,64 +113,57 @@
33 Data& data;
34 Children children;
35};
-
36
-
37template <typename Sender>
-
38auto get_sender_data(Sender&& sender) {
-
39#if 0
-
40 //-dk:TODO should use a dynamic/language approach:
-
41 auto&& [tag, data, ... children] = sender;
-
42 return sender_meta<decltype(tag), decltype(data), ::std::tuple<decltype(children)...>>;
-
43#endif
-
44 using sender_type = ::std::remove_cvref_t<Sender>;
-
45 static constexpr ::beman::execution26::detail::sender_convert_to_any_t at{};
-
46
-
47 if constexpr (requires {
-
48 sender.template get<0>();
-
49 sender.size();
-
50 })
-
51 return [&sender]<::std::size_t... I>(::std::index_sequence<I...>) {
-
52 return ::beman::execution26::detail::sender_data<decltype(sender.template get<0>()),
-
53 decltype(sender.template get<1>()),
-
54 decltype(::std::tie(sender.template get<2 + I>()...))>{
+
36template <typename Tag, typename Data, typename Children>
+
37sender_data(Tag&&, Data&, Children&&) -> sender_data<Tag, Data, Children>;
+
38
+
39template <typename Sender>
+
40auto get_sender_data(Sender&& sender) {
+
41#if 0
+
42 //-dk:TODO should use a dynamic/language approach:
+
43 auto&& [tag, data, ... children] = sender;
+
44 return sender_meta<decltype(tag), decltype(data), ::std::tuple<decltype(children)...>>;
+
45#endif
+
46 using sender_type = ::std::remove_cvref_t<Sender>;
+
47 static constexpr ::beman::execution26::detail::sender_convert_to_any_t at{};
+
48
+
49 if constexpr (requires {
+
50 sender.template get<0>();
+
51 sender.size();
+
52 })
+
53 return [&sender]<::std::size_t... I>(::std::index_sequence<I...>) {
+
54 return ::beman::execution26::detail::sender_data{
55 sender.template get<0>(), sender.template get<1>(), ::std::tie(sender.template get<2 + I>()...)};
56 }(::std::make_index_sequence<::std::decay_t<decltype(sender)>::size() - 2u>{});
57 else if constexpr (requires { sender_type{at, at, at, at, at, at}; }) {
58 auto&& [tag, data, c0, c1, c2, c3] = sender;
-
59 return ::beman::execution26::detail::
-
60 sender_data<decltype(tag), decltype(data), decltype(::std::tie(c0, c1, c2, c3))>{
-
61 tag, data, ::std::tie(c0, c1, c2, c3)};
-
62 } else if constexpr (requires { sender_type{at, at, at, at, at}; }) {
-
63 auto&& [tag, data, c0, c1, c2] = sender;
-
64 return ::beman::execution26::detail::
-
65 sender_data<decltype(tag), decltype(data), decltype(::std::tie(c0, c1, c2))>{
-
66 tag, data, ::std::tie(c0, c1, c2)};
-
67 } else if constexpr (requires { sender_type{at, at, at, at}; }) {
-
68 auto&& [tag, data, c0, c1] = sender;
-
69 return ::beman::execution26::detail::sender_data<decltype(tag), decltype(data), decltype(::std::tie(c0, c1))>{
-
70 tag, data, ::std::tie(c0, c1)};
-
71 } else if constexpr (requires { sender_type{at, at, at}; }) {
-
72 auto&& [tag, data, c0] = sender;
-
73 return ::beman::execution26::detail::sender_data<decltype(tag), decltype(data), decltype(::std::tie(c0))>{
-
74 tag, data, ::std::tie(c0)};
-
75 } else if constexpr (requires { sender_type{at, at}; }) {
-
76 auto&& [tag, data] = sender;
-
77 return ::beman::execution26::detail::sender_data<decltype(tag), decltype(data), ::std::tuple<>>{
-
78 tag, data, ::std::tuple<>()};
-
79 } else {
-
80 return ::beman::execution26::detail::sender_meta<void, void, void>{};
-
81 }
-
82}
+
59 return ::beman::execution26::detail::sender_data{tag, data, ::std::tie(c0, c1, c2, c3)};
+
60 } else if constexpr (requires { sender_type{at, at, at, at, at}; }) {
+
61 auto&& [tag, data, c0, c1, c2] = sender;
+
62 return ::beman::execution26::detail::sender_data{tag, data, ::std::tie(c0, c1, c2)};
+
63 } else if constexpr (requires { sender_type{at, at, at, at}; }) {
+
64 auto&& [tag, data, c0, c1] = sender;
+
65 return ::beman::execution26::detail::sender_data{tag, data, ::std::tie(c0, c1)};
+
66 } else if constexpr (requires { sender_type{at, at, at}; }) {
+
67 auto&& [tag, data, c0] = sender;
+
68 return ::beman::execution26::detail::sender_data{tag, data, ::std::tie(c0)};
+
69 } else if constexpr (requires { sender_type{at, at}; }) {
+
70 auto&& [tag, data] = sender;
+
71 return ::beman::execution26::detail::sender_data{tag, data, ::std::tuple<>()};
+
72 } else {
+
73 return ::beman::execution26::detail::sender_meta<void, void, void>{};
+
74 }
+
75}
+
76
+
77template <typename Sender>
+
78auto get_sender_meta(Sender&& sender) {
+
79 using type = decltype(get_sender_data(sender));
+
80 return sender_meta<typename type::tag_type, typename type::data_type, typename type::children_type>{};
+
81}
+
82} // namespace beman::execution26::detail
83
-
84template <typename Sender>
-
85auto get_sender_meta(Sender&& sender) {
-
86 using type = decltype(get_sender_data(sender));
-
87 return sender_meta<typename type::tag_type, typename type::data_type, typename type::children_type>{};
-
88}
-
89} // namespace beman::execution26::detail
-
90
-
91// ----------------------------------------------------------------------------
-
92
-
93#endif
+
84// ----------------------------------------------------------------------------
+
85
+
86#endif