Deduce function signature for sender to ensure proper completion

Author: Andres-Salamanca

include/beman/execution/detail/bulk.hpp

@@ -87,30 +87,107 @@ struct print_type {
     static_assert(sizeof(T) == 0, "Debugging type...");
 };
 
-/*template <typename, typename, typename, typename,typename>
-struct fixed_completions_helper;
-template <typename F, typename Shape,typename Sender,typename Env, typename... Args>
-struct fixed_completions_helper<F, Shape,Sender, Env, completion_signatures<Args...>> {
-    using completions = ::beman::execution::value_types_of_t<Sender,Env>;
-    static_assert(std::is_invocable_v<F,  completions>,"Error: The function is not callable with the given arguments.");
-    using type = std::conditional_t<::beman::execution::detail::nothrow_callable<F, Args ...>,
-                                    completion_signatures<Args...>,
-                                    completion_signatures<Args..., set_error_t(std::exception_ptr)>>;
+template <typename T>
+concept function_constraint = std::is_function_v<T>;
+
+template <typename T, typename... Args>
+struct function_type;
+
+template <typename T, typename... Args>
+using function_type_t = typename function_type<T, Args...>::type;
+
+template <typename>
+struct function_type_basis {};
+
+template <typename T, typename...>
+struct function_type : function_type_basis<std::remove_cv_t<T>> {};
+
+template <function_constraint T>
+struct function_type_basis<T> {
+    using type = T;
 };
 
-template <typename F, typename Shape, typename Sender , typename Env, typename completions>
-using fixed_completions = typename fixed_completions_helper<F, Shape, Sender , Env, completions>::type;*/
+template <function_constraint T>
+struct function_type_basis<T*> {
+    using type = T;
+};
 
+template <function_constraint T>
+struct function_type_basis<T&> {
+    using type = T;
+};
 
+template <function_constraint T>
+struct function_type_basis<T&&> {
+    using type = T;
+};
 
+template <function_constraint T, typename C>
+struct function_type_basis<T C::*> {
+    using type = T;
+};
+
+template <typename, typename...>
+struct function_object_type {};
+
+template <typename C, typename... Args>
+    requires(bool(&C::operator()))
+struct function_object_type<C, Args...> : function_type_basis<decltype(&C::operator())> {};
+
+template <typename F, typename... Args>
+    requires std::is_class<std::remove_cvref_t<F>>::value
+struct function_type<F, Args...> : function_object_type<F, Args...> {};
+
+template <typename>
+struct function_traits;
+
+// Specialization for function types
+template <typename R, typename... Args, bool NoExcept>
+struct function_traits<R(Args...) noexcept(NoExcept)> {
+    // The return type
+    using return_type = R;
+    // A tuple containing all argument types
+    using argument_types = std::tuple<Args...>;
+
+    // The number of arguments
+    static constexpr std::size_t arity = sizeof...(Args);
+};
+
+template <typename R, typename... Args, bool NoExcept>
+struct function_traits<R(Args...) const noexcept(NoExcept)> {
+    // The return type
+    using return_type = R;
+    // A tuple containing all argument types
+    using argument_types = std::tuple<Args...>;
+    // The number of arguments
+    static constexpr std::size_t arity = sizeof...(Args);
+};
+
+template <typename F, typename FunctionType>
+struct is_invocable_with; 
+
+template <typename F, typename... Args>
+struct is_invocable_with<F, std::tuple<Args...>> {
+    static constexpr bool is_invocable = std::is_invocable_v<F, Args...>;
+    static constexpr bool is_no_throw  = ::beman::execution::detail::nothrow_callable<F, Args...>;
+};
 
 template <typename, typename, typename>
 struct fixed_completions_helper;
 
 template <typename F, typename Shape, typename... Args>
 struct fixed_completions_helper<F, Shape, completion_signatures<Args...>> {
-    //static_assert(std::is_invocable_v<F, Shape, Args...>,"Error: The function is not callable with the given arguments.");
-    using type = std::conditional_t<::beman::execution::detail::nothrow_callable<F, Args ...>,
+    // get function signature
+    using signature = function_type_t<F>;
+    // break apart return type and args types
+    using signature_helper = function_traits<signature>;
+    // get arg types
+    using function_args_type = signature_helper::argument_types;
+    // print_type<function_args_type> debug;
+    // check if function is well form
+    static_assert(is_invocable_with<F, function_args_type>::is_invocable,
+                  "Error: The function is not callable with the given arguments.");
+    using type = std::conditional_t<is_invocable_with<F, function_args_type>::is_no_throw,
                                     completion_signatures<Args...>,
                                     completion_signatures<Args..., set_error_t(std::exception_ptr)>>;
 };
@@ -123,11 +200,10 @@ struct completion_signatures_for_impl<
     ::beman::execution::detail::
         basic_sender<::beman::execution::detail::bulk_t, ::beman::execution::detail::product_type<Shape, F>, Sender>,
     Env> {
-    
 
     using completions = decltype(get_completion_signatures(std::declval<Sender>(), std::declval<Env>()));
     using type        = fixed_completions<F, Shape, completions>;
-    //print_type<type> debug;
+    // print_type<F> debug;
 };
 
 } // namespace beman::execution::detail

tests/beman/execution/exec-bulk.test.cpp

@@ -43,7 +43,7 @@ auto test_bulk() {
     std::vector<int> results(a.size(), 0);
 
     auto b2 = test_std::bulk(test_std::just(a), a.size(), [&](std::size_t index, const std::vector<int>& vec) {
-        results[index] = vec[index] * b[index]; 
+        results[index] = vec[index] * b[index];
     });
     static_assert(test_std::sender<decltype(b2)>);
     auto b2_env         = test_std::get_env(b2);
@@ -58,20 +58,18 @@ auto test_bulk() {
     // Expected results: element-wise multiplication of a and b
     std::vector<int> expected{9, 20, 33, 52, 70, 90, 112, 136};
 
-    
     for (size_t i = 0; i < results.size(); ++i) {
         ASSERT(results[i] == expected[i]);
     }
 }
 
 auto test_bulk_noexept() {
-    auto b0 = test_std::bulk(test_std::just(), 1, [](int) noexcept {});
+    auto b0             = test_std::bulk(test_std::just(), 1, [](int) noexcept {});
     auto b0_env         = test_std::get_env(b0);
     auto b0_completions = test_std::get_completion_signatures(b0, b0_env);
-    /*static_assert(
-        std::is_same_v<decltype(b0_completions),
-                       beman::execution::completion_signatures<beman::execution::set_value_t()> >,
-        "Completion signatures do not match!");*/
+    static_assert(std::is_same_v<decltype(b0_completions),
+                                 beman::execution::completion_signatures<beman::execution::set_value_t()> >,
+                  "Completion signatures do not match!");
     static_assert(test_std::sender<decltype(b0)>);
 }