Implement execution::just factory

Author: miscco

stl/inc/execution

@@ -5403,6 +5403,64 @@ namespace execution {
         template <_One_of<set_value_t, set_error_t, set_done_t> _Target>
         inline constexpr _Get_completion_scheduler::_Cpo<_Target> get_completion_scheduler;
     }
+
+    // TRANSITION: Specialize for 1 argument
+    template <class... _Types>
+    struct _Just_sender {
+        tuple<_Types...> _Values;
+
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<_Tuple<_Types...>>;
+
+        template <template <class...> class _Variant>
+        using error_types = _Variant<exception_ptr>;
+
+        static const constexpr auto sends_done = false;
+
+        template <receiver _Receiver>
+        struct operation_state {
+            tuple<_Types...> _Values;
+            _Receiver _Rec;
+
+            friend constexpr void tag_invoke(start_t, operation_state& _State) noexcept {
+                _TRY_BEGIN
+                apply(
+                    [&_State](_Types&... _Values) { //
+                        _EXEC set_value(_STD move(_State._Rec), _STD move(_Values)...);
+                    },
+                    _State._Values);
+                _CATCH_ALL
+                _EXEC set_error(_STD move(_State._Rec), _STD current_exception());
+                _CATCH_END
+            }
+        };
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires (receiver_of<_Receiver, _Types...> && (copyable<_Types> && ...))
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, const _Just_sender& _Sender, _Receiver&& _Rec) noexcept(
+            (is_nothrow_copy_constructible_v<_Types> && ...) //
+            && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<_Receiver>{_Sender._Values, _STD forward<_Receiver>(_Rec)};
+        }
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires receiver_of<_Receiver, _Types...>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, _Just_sender&& _Sender, _Receiver&& _Rec) noexcept(
+            (is_nothrow_move_constructible_v<_Types> && ...)
+            && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<_Receiver>{_STD move(_Sender._Values), _STD forward<_Receiver>(_Rec)};
+        }
+    };
+
+    template <_Movable_value... _Types>
+    _NODISCARD constexpr _Just_sender<remove_cvref_t<_Types>...> just(_Types&&... _Values) noexcept(
+        (is_nothrow_constructible_v<remove_cvref_t<_Types>, _Types> && ...)) {
+        return {_STD make_tuple(_STD forward<_Types>(_Values)...)};
+    }
 } // namespace execution
 #endif // __cpp_lib_executors
 _STD_END

tests/std/test.lst

@@ -452,6 +452,7 @@ tests\P1951R1_default_arguments_pair_forward_ctor
 tests\P2136R3_invoke_r
 tests\P2162R2_std_visit_for_derived_classes_from_variant
 tests\P2231R1_complete_constexpr_optional_variant
+tests\P2300R2_executors_factories
 tests\P2300R2_executors_receiver
 tests\P2300R2_executors_scheduler
 tests\P2300R2_executors_sender

tests/std/tests/P2300R2_executors_factories/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst

tests/std/tests/P2300R2_executors_factories/test.cpp

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <concepts>
+#include <execution>
+#include <tuple>
+using namespace std;
+using execution::connect, execution::operation_state, execution::receiver_of, execution::sender_of, execution::start,
+    execution::typed_sender;
+
+struct Tracker {
+    bool set_values_called = false;
+    bool set_error_called  = false;
+    bool set_done_called   = false;
+};
+struct Dummy {};
+struct CustomError {};
+
+enum class DoesThrowOnSetValue : bool { No, Yes };
+template <DoesThrowOnSetValue ThrowOnSetValue, class... Types>
+struct test_receiver {
+    constexpr test_receiver(Tracker& tracker) noexcept : _tracker(tracker) {}
+    friend constexpr auto tag_invoke(execution::set_done_t, test_receiver rec) noexcept {
+        rec._tracker.set_done_called = true;
+    }
+    friend auto tag_invoke(execution::set_error_t, test_receiver rec, exception_ptr) noexcept {
+        rec._tracker.set_error_called = true;
+    }
+    friend constexpr auto tag_invoke(execution::set_error_t, test_receiver rec, CustomError) noexcept {
+        rec._tracker.set_error_called = true;
+    }
+    friend constexpr auto tag_invoke(execution::set_value_t, test_receiver rec, Types...) noexcept(
+        ThrowOnSetValue == DoesThrowOnSetValue::No) {
+        rec._tracker.set_values_called = true;
+        if constexpr (ThrowOnSetValue == DoesThrowOnSetValue::Yes) {
+            throw 42;
+        }
+    }
+
+    struct fake_operation_state {
+        friend constexpr void tag_invoke(execution::start_t, fake_operation_state&) noexcept {}
+    };
+
+    Tracker& _tracker;
+};
+template <class... Types>
+using nothrow_receiver = test_receiver<DoesThrowOnSetValue::No, Types...>;
+template <class... Types>
+using throws_on_set_values_receiver = test_receiver<DoesThrowOnSetValue::Yes, Types...>;
+
+static_assert(receiver_of<nothrow_receiver<int>, int>);
+static_assert(operation_state<nothrow_receiver<int>::fake_operation_state>);
+static_assert(receiver_of<throws_on_set_values_receiver<int>, int>);
+static_assert(operation_state<throws_on_set_values_receiver<int>::fake_operation_state>);
+
+constexpr bool test_just() {
+    {
+        Tracker tracker;
+        const sender_of<int> auto sender = execution::just(5);
+        operation_state auto state       = connect(sender, nothrow_receiver<int>{tracker});
+        assert(!tracker.set_values_called);
+        start(state);
+        assert(tracker.set_values_called);
+
+        static_assert(!invocable<execution::connect_t, decltype(sender), nothrow_receiver<Dummy>>);
+    }
+
+    {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just(5), nothrow_receiver<int>{tracker});
+        assert(!tracker.set_values_called);
+        start(state);
+        assert(tracker.set_values_called);
+    }
+
+    {
+        Tracker tracker;
+        const sender_of<int, Dummy> auto sender = execution::just(5, Dummy{});
+        operation_state auto state              = connect(sender, nothrow_receiver<int, Dummy>{tracker});
+        assert(!tracker.set_values_called);
+        start(state);
+        assert(tracker.set_values_called);
+
+        static_assert(!invocable<execution::connect_t, decltype(sender), nothrow_receiver<Dummy, int>>);
+    }
+
+    if (!is_constant_evaluated()) {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just(5), throws_on_set_values_receiver<int>{tracker});
+        assert(!tracker.set_values_called);
+        assert(!tracker.set_error_called);
+        start(state);
+        assert(tracker.set_values_called);
+        assert(tracker.set_error_called);
+    }
+
+    return true;
+}
+
+int main() {
+    test_just();
+    static_assert(test_just());
+}