Implement execution::just_error factory

Author: miscco

stl/inc/execution

@@ -5461,6 +5461,56 @@ namespace execution {
         (is_nothrow_constructible_v<remove_cvref_t<_Types>, _Types> && ...)) {
         return {_STD make_tuple(_STD forward<_Types>(_Values)...)};
     }
+
+    template <class _Error>
+    struct _Just_error_sender {
+        _Error _Err;
+
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<>;
+
+        template <template <class...> class _Variant>
+        using error_types = _Variant<_Error, exception_ptr>;
+
+        static const constexpr auto sends_done = false;
+
+        template <receiver _Receiver>
+            requires receiver<_Receiver, _Error>
+        struct operation_state {
+            _Error _Err;
+            _Receiver _Rec;
+
+            friend constexpr void tag_invoke(start_t, operation_state& _State) noexcept {
+                _EXEC set_error(_STD move(_State._Rec), _STD move(_State._Err));
+            }
+        };
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires receiver<_Receiver, _Error> && copyable<_Error>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, const _Just_error_sender& _Sender, _Receiver&& _Rec) //
+            noexcept(is_nothrow_copy_constructible_v<_Error> //
+                    && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<remove_cvref_t<_Receiver>>{_Sender._Err, _STD forward<_Receiver>(_Rec)};
+        }
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires receiver<_Receiver, _Error>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, _Just_error_sender&& _Sender, _Receiver&& _Rec) noexcept(
+            is_nothrow_move_constructible_v<_Error> //
+                && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<remove_cvref_t<_Receiver>>{_STD move(_Sender._Err), _STD forward<_Receiver>(_Rec)};
+        }
+    };
+
+    template <_Movable_value _Error>
+    _NODISCARD constexpr _Just_error_sender<remove_cvref_t<_Error>> just_error(_Error&& _Err) noexcept(
+        is_nothrow_constructible_v<remove_cvref_t<_Error>, _Error>) {
+        return {_STD forward<_Error>(_Err)};
+    }
 } // namespace execution
 #endif // __cpp_lib_executors
 _STD_END

tests/std/tests/P2300R2_executors_factories/test.cpp

@@ -98,7 +98,36 @@ constexpr bool test_just() {
     return true;
 }
 
+constexpr bool test_just_error() {
+    {
+        Tracker tracker;
+        typed_sender auto sender   = execution::just_error(CustomError{});
+        operation_state auto state = connect(sender, nothrow_receiver<>{tracker});
+        assert(!tracker.set_error_called);
+        start(state);
+        assert(tracker.set_error_called);
+    }
+
+    {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just_error(CustomError{}), nothrow_receiver<>{tracker});
+        assert(!tracker.set_error_called);
+        start(state);
+        assert(tracker.set_error_called);
+    }
+
+    { // Ensure that we cannot connect a receiver with the wrong error type
+        typed_sender auto sender = execution::just_error(Dummy{});
+        static_assert(!invocable<execution::connect_t, decltype(sender), nothrow_receiver<>>);
+    }
+
+    return true;
+}
+
 int main() {
     test_just();
     static_assert(test_just());
+
+    test_just_error();
+    static_assert(test_just_error());
 }