Implement P2505R5 Monadic Functions For std::expected

[TartanLlama]

Implements P2505R5 Monadic Functions for std::expected
Fixes #3210

Open question: The transform and transform_error specifications have Mandates clauses similar to:

Mandates: U is a valid value type for expected. If is_void_v<U> is false, the declaration U u(invoke(std::forward<F>(f), value())); is well-formed.

Do we want static_asserts for these?

[AlexGuteniev]

One question from me (regarding all occurrences, not just this one)

[cpplearner]

At least we could extract the common parts into a helper function template. Currently the definition of transform takes 72 lines in the primary class template, and will only take 42 lines if the function bodies are shared.

the 42-line implementation that I was thinking of

    template <class _SelfType, class _Fn>
    static constexpr auto _Transform_expected(_SelfType&& _Self, _Fn&& _Func) {
        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_SelfType>, expected>);

        using _Uty = remove_cv_t<invoke_result_t<_Fn, decltype(*_STD declval<_SelfType>())>>;

        if (_Self._Has_value) {
            if constexpr (is_void_v<_Uty>) {
                _STD invoke(_STD forward<_Fn>(_Func), _STD forward_like<_SelfType>(_Self._Value));
                return expected<_Uty, _Err>();
            } else {
                return expected<_Uty, _Err>(_Construct_expected_from_invoke_result_tag{},
                    _STD forward<_Fn>(_Func), _STD forward_like<_SelfType>(_Self._Value));
            }
        } else {
            return expected<_Uty, _Err>(unexpect, _STD forward_like<_SelfType>(_Self._Unexpected));
        }
    }

    template <class _Fn>
        requires is_copy_constructible_v<_Err>
    constexpr auto transform(_Fn&& _Func) & {
        return _Transform_expected(*this, _STD forward<_Fn>(_Func));
    }

    template <class _Fn>
        requires is_copy_constructible_v<_Err>
    constexpr auto transform(_Fn&& _Func) const& {
        return _Transform_expected(*this, _STD forward<_Fn>(_Func));
    }

    template <class _Fn>
        requires is_move_constructible_v<_Err>
    constexpr auto transform(_Fn&& _Func) && {
        return _Transform_expected(_STD move(*this), _STD forward<_Fn>(_Func));
    }

    template <class _Fn>
        requires is_move_constructible_v<_Err>
    constexpr auto transform(_Fn&& _Func) const&& {
        return _Transform_expected(_STD move(*this), _STD forward<_Fn>(_Func));
    }

[AlexGuteniev]

Some nitpicking

[CaseyCarter]

Just a few nitpicky things that I'll push fixes for.

[StephanTLavavej]

Thanks! Note to self: I reviewed the product code up to the void specialization and still need to review the new test file.

[StephanTLavavej]

Thanks! I finished reviewing and pushed changes for the remaining issues I found (the most notable being missing mandate enforcement), followed by a conflict-free merge with main. With that I think we're ready to go! 😸

[StephanTLavavej]

I'm mirroring this to the MSVC-internal repo - please notify me if any further changes are pushed.

[StephanTLavavej]

Thanks for implementing this C++23 feature - it's expected to be an awesome Standard! 😹 😻 🚀