some progress on basic_sender

include/beman/execution26/detail/basic_sender.hpp

@@ -4,6 +4,8 @@
 #ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_BASIC_SENDER
 #define INCLUDED_BEMAN_EXECUTION26_DETAIL_BASIC_SENDER
 
+#include <beman/execution26/detail/decays_to.hpp>
+#include <beman/execution26/detail/completion_signatures_for.hpp>
 #include <beman/execution26/detail/sender.hpp>
 
 // ----------------------------------------------------------------------------
@@ -14,6 +16,41 @@ namespace beman::execution26::detail
     struct basic_sender
     {
         using sender_concept = ::beman::execution26::sender_t;
+
+#if __cpp_explicit_this_parameter < 302110L
+        template <typename Env>
+        auto get_completion_signatures(Env&&) && noexcept
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender&&, Env>
+        {
+            return {};
+        }
+        template <typename Env>
+        auto get_completion_signatures(Env&&) const&& noexcept
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender const&&, Env>
+        {
+            return {};
+        }
+        template <typename Env>
+        auto get_completion_signatures(Env&&) & noexcept
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender&, Env>
+        {
+            return {};
+        }
+        template <typename Env>
+        auto get_completion_signatures(Env&&) const& noexcept
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender const&, Env>
+        {
+            return {};
+        }
+#else
+        template <::beman::execution26::detail::decays_to<basic_sender> Self,
+                  typename Env>
+        auto get_completion_signatures(this Self&&, Env&&) noexcept
+            -> ::beman::execution26::detail::completion_signatures_for<Self, Env>
+        {
+            return {};
+        }
+#endif
     };
 }
 

include/beman/execution26/detail/product_type.hpp

@@ -73,6 +73,19 @@ namespace beman::execution26::detail
         T4 value4;
         T5 value5;
     };
+
+    template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+    struct product_type<T1, T2, T3, T4, T5, T6>
+    {
+        static constexpr ::std::size_t size{6u};
+        auto operator== (product_type const&) const -> bool = default;
+        T1 value1;
+        T2 value2;
+        T3 value3;
+        T4 value4;
+        T5 value5;
+        T6 value6;
+    };
 }
 
 // ----------------------------------------------------------------------------

include/beman/execution26/detail/sender_decompose.hpp

@@ -43,27 +43,42 @@ namespace beman::execution26::detail
         #endif
         using sender_type = ::std::remove_cvref_t<Sender>;
         static constexpr ::beman::execution26::detail::sender_any_t at{};
-        if constexpr (requires(){ sender_type{ at, at, at, at, at, at }; })
+        if constexpr (
+            requires(){ sender_type{ at, at, at, at, at, at }; }
+            || requires(){ sender_type{ { at, at, at, at, at, at } }; }
+            )
         {
             auto&& [tag, data, c0, c1, c2, c3] = sender;
             return ::beman::execution26::detail::sender_meta<decltype(tag), decltype(data), ::std::tuple<decltype(c0), decltype(c1), decltype(c2), decltype(c3)>>{};
         }
-        else if constexpr (requires(){ sender_type{ at, at, at, at, at }; })
+        else if constexpr (
+                requires(){ sender_type{ at, at, at, at, at }; }
+                || requires(){ sender_type{ { at, at, at, at, at } }; }
+                )
         {
             auto&& [tag, data, c0, c1, c2] = sender;
             return ::beman::execution26::detail::sender_meta<decltype(tag), decltype(data), ::std::tuple<decltype(c0), decltype(c1), decltype(c2)>>{};
         }
-        else if constexpr (requires(){ sender_type{ at, at, at, at }; })
+        else if constexpr (
+                requires(){ sender_type{ at, at, at, at }; }
+                || requires(){ sender_type{ { at, at, at, at } }; }
+                )
         {
             auto&& [tag, data, c0, c1] = sender;
             return ::beman::execution26::detail::sender_meta<decltype(tag), decltype(data), ::std::tuple<decltype(c0), decltype(c1)>>{};
         }
-        else if constexpr (requires(){ sender_type{ at, at, at }; })
+        else if constexpr (
+            requires(){ sender_type{ at, at, at }; }
+            || requires(){ sender_type{ { at, at, at } }; }
+            )
         {
             auto&& [tag, data, c0] = sender;
             return ::beman::execution26::detail::sender_meta<decltype(tag), decltype(data), ::std::tuple<decltype(c0)>>{};
         }
-        else if constexpr (requires(){ sender_type{ at, at }; })
+        else if constexpr (
+            requires(){ sender_type{ at, at }; }
+            || requires(){ sender_type{ { at, at } }; }
+            )
         {
             auto&& [tag, data] = sender;
             return ::beman::execution26::detail::sender_meta<decltype(tag), decltype(data), ::std::tuple<>>{};

src/beman/execution26/tests/exec-snd-concepts.pass.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include <beman/execution26/detail/sender_for.hpp>
+#include <beman/execution26/detail/product_type.hpp>
 #include <beman/execution26/detail/sender_decompose.hpp>
 #include <beman/execution26/detail/sender.hpp>
 #include <beman/execution26/detail/sender_in.hpp>
@@ -61,6 +62,31 @@ namespace
         int   child3;
         int   child4;
     };
+    struct product_sender0
+        : test_detail::product_type<tag_t, int>
+    {
+        using sender_concept = test_std::sender_t;
+    };
+    struct product_sender1
+        : test_detail::product_type<tag_t, int, int>
+    {
+        using sender_concept = test_std::sender_t;
+    };
+    struct product_sender2
+        : test_detail::product_type<tag_t, int, int, int>
+    {
+        using sender_concept = test_std::sender_t;
+    };
+    struct product_sender3
+        : test_detail::product_type<tag_t, int, int, int, int>
+    {
+        using sender_concept = test_std::sender_t;
+    };
+    struct product_sender4
+        : test_detail::product_type<tag_t, int, int, int, int, int>
+    {
+        using sender_concept = test_std::sender_t;
+    };
 
     // -------------------------------------------------------------------------
 
@@ -133,6 +159,12 @@ namespace
         static_assert(std::same_as<tag_t, test_std::tag_of_t<tagged_sender2>>);
         static_assert(std::same_as<tag_t, test_std::tag_of_t<tagged_sender3>>);
         static_assert(std::same_as<tag_t, test_std::tag_of_t<tagged_sender4>>);
+
+        static_assert(std::same_as<tag_t, test_std::tag_of_t<product_sender0>>);
+        static_assert(std::same_as<tag_t, test_std::tag_of_t<product_sender1>>);
+        static_assert(std::same_as<tag_t, test_std::tag_of_t<product_sender2>>);
+        static_assert(std::same_as<tag_t, test_std::tag_of_t<product_sender3>>);
+        static_assert(std::same_as<tag_t, test_std::tag_of_t<product_sender4>>);
     }
 
     auto test_sender_for() -> void

src/beman/execution26/tests/exec-snd-expos.pass.cpp

@@ -1063,15 +1063,49 @@ namespace
             test_detail::no_completion_signatures_defined_in_sender
         >);
     }
+
+    struct basic_sender_tag
+    {
+        struct sender
+        {
+            using sender_concept = test_std::sender_t;
+            using completion_signatures = test_std::completion_signatures<>;
+        };
+        auto transform_sender(auto&&...) noexcept { return sender{}; }
+    };
     auto test_basic_sender() -> void
     {
-        struct tag {};
         struct data {};
         struct env {};
+        struct tagged_sender
+            : test_detail::product_type<basic_sender_tag, data, sender0>
+        {
+            using sender_concept = test_std::sender_t;
+        };
+
+#if 1
+        auto&&[a, b, c] = tagged_sender{basic_sender_tag{}, data{}, sender0{}};
+        use(a);
+        use(b);
+        use(c);
+#endif
+
+        static_assert(test_std::sender<basic_sender_tag::sender>);
+        static_assert(test_std::sender_in<basic_sender_tag::sender>);
+        static_assert(test_std::sender_in<basic_sender_tag::sender, env>);
+        static_assert(test_std::sender<tagged_sender>);
+        static_assert(std::same_as<
+            basic_sender_tag,
+            test_std::tag_of_t<tagged_sender>
+        >);
+        //static_assert(std::same_as<
+        //    basic_sender_tag::sender,
+        //    decltype(test_std::transform_sender(test_std::default_domain{}, tagged_sender{}, env{}))
+        //>);
 
-        using basic_sender = test_detail::basic_sender<tag, data, sender0>;
+        using basic_sender = test_detail::basic_sender<basic_sender_tag, data, sender0>;
         static_assert(test_std::sender<basic_sender>);
-        //-dk:TODO static_assert(test_std::sender_in<basic_sender>);
+        //static_assert(test_std::sender_in<basic_sender>);
     }
 }