[libc++] Implement P2505R5(Monadic operations for std::expected).

[yronglin]

Summary

Implement P2505R5(https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2505r5.html)

[philnik]

In D140911#4036801, @yronglin wrote:

Can someone tell me how to fix this clang_query.sh.cpp failure? Should I need to update any other files, I'm very confused, many thanks!

This failure wasn't your fault. I've committed a fix, so it should be fixed with a rebase.

[yronglin]

In D140911#4036871, @philnik wrote:

In D140911#4036801, @yronglin wrote:

Can someone tell me how to fix this clang_query.sh.cpp failure? Should I need to update any other files, I'm very confused, many thanks!

This failure wasn't your fault. I've committed a fix, so it should be fixed with a rebase.

Thank you for your reply @philnik !

[yronglin]

Rebase

[yronglin]

try fix test

[yronglin]

try fix test

[Mordante]

Thanks for working on this! I didn't do a real review, mainly glanced over it and I have a few remarks.

libcxx/docs/Status/Cxx2bPapers.csv

103

103

Can you update libcxx/docs/ReleaseNotes.rst too?

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

164

We don't require clang-format, so I have a slight preference to remove this.

[yronglin]

In D140911#4040099, @Mordante wrote:

Thanks for working on this! I didn't do a real review, mainly glanced over it and I have a few remarks.

Thanks for your comments @Mordante ,I'll try to update this patch

[philnik]

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

164

I'd keep it, since it allows you to clang-format the file if you change anything. I actually do this for the files which look formatted regularly.

[yronglin]

Update ReleaseNotes
Remove clang-format comments in test

[yronglin]

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

164

Yes, this was added in the past to facilitate formatting files, otherwise the format here will be disrupted by clang-format, I can keep these if you guys agree

[yronglin]

Keep clang-format in test

[yronglin]

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

164

If we remove // clang-format off ......// clang-format on.... , the code here will be formatted in a very strange format(I've used vscode Format Document)

[yronglin]

Rebase

[yronglin]

Update libcxx/docs/Status/Cxx2bPapers.csv

[yronglin]

ping~

[philnik]

libcxx/include/__expected/expected.h

67

I would remove the namespace then. It doesn't really improve the readability in any way, since every single member has expected already in it's name. We also don't have these kinds of detail namespaces normally.

libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp

10 ↗

(On Diff #488054)

This seems weird. Why should we ignore errors?

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

80

155

Same for the others.

170–173

libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp

94

Why is this only static_asserted?

[yronglin]

Many thanks for your comments @philnik !

libcxx/include/__expected/expected.h

67

If we decided to remove expected namespace, I think unexpected namespace in unexpected.h also should be removed, What do you think?

libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp

10 ↗

(On Diff #488054)

This used to ignore errors like type '_Up' (aka 'int') cannot be used prior to '::' because it has no members, no matching constructor for initialization of '_Up' (aka 'std::expected<int, NotSameAsInt>'), and so on, I think we don't need to check errors like that, what do you think?

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

2–7

+1

18

+1

libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp

94

Could you please clarify?

[yronglin]

libcxx/include/__expected/expected.h

67

If we decided to remove __expected namespace, I think __unexpected namespace in unexpected.h also should be removed, What do you think?

[yronglin]

Update

[yronglin]

libcxx/include/__expected/expected.h

67

Seems this namespace used to avoid ADL lookup?

$ ":" "RUN: at line 15"
note: command had no output on stdout or stderr
$ "clang-tidy-16" "/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/libcxx/test/libcxx/clang_tidy.sh.cpp" "--warnings-as-errors=*" "-header-filter=.*" "--checks=-*,libcpp-*" "--load=/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/libcxx/test/tools/clang_tidy_checks/libcxx-tidy.plugin" "--" "-nostdinc++" "-I" "/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1" "-I" "/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1" "-I" "/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/libcxx/test/support" "-std=c++2b" "-Werror" "-Wall" "-Wctad-maybe-unsupported" "-Wextra" "-Wshadow" "-Wundef" "-Wno-unused-command-line-argument" "-Wno-attributes" "-Wno-pessimizing-move" "-Wno-c++11-extensions" "-Wno-noexcept-type" "-Wno-atomic-alignment" "-Wno-user-defined-literals" "-Wno-tautological-compare" "-Wsign-compare" "-Wunused-variable" "-Wunused-parameter" "-Wunreachable-code" "-Wno-unused-local-typedef" "-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER" "-D_LIBCPP_ENABLE_EXPERIMENTAL" "-D_LIBCPP_DISABLE_AVAILABILITY" "-fcoroutines-ts" "-Werror=thread-safety" "-Wuser-defined-warnings" "-fno-modules"
# command output:
/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/__expected/expected.h:552:7: error: ADL lookup [libcpp-robust-against-adl,-warnings-as-errors]
      __throw_bad_expected_access<_Err>(__union_.__unex_);
      ^
/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/__expected/expected.h:559:7: error: ADL lookup [libcpp-robust-against-adl,-warnings-as-errors]
      __throw_bad_expected_access<_Err>(__union_.__unex_);
      ^
/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/__expected/expected.h:566:7: error: ADL lookup [libcpp-robust-against-adl,-warnings-as-errors]
      __throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
      ^
/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/__expected/expected.h:573:7: error: ADL lookup [libcpp-robust-against-adl,-warnings-as-errors]
      __throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
      ^
/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/__expected/expected.h:1167:7: error: ADL lookup [libcpp-robust-against-adl,-warnings-as-errors]
      __throw_bad_expected_access<_Err>(__union_.__unex_);
      ^
/home/libcxx-builder/.buildkite-agent/builds/8ae0e84df61e-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/__expected/expected.h:1173:7: error: ADL lookup [libcpp-robust-against-adl,-warnings-as-errors]
      __throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
      ^

# command stderr:
6 warnings generated.
Suppressed 48 warnings (48 NOLINT).
6 warnings treated as errors

error: command failed with exit status: 1

[yronglin]

CI

[yronglin]

CI

[philnik]

libcxx/include/__expected/expected.h

67

Yes, I think we should also remove __unexpected, but let's do that in another patch. You have to add std:: then calling __throw_bad_expected_access now to avoid the ADL lookup.

libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp

10 ↗

(On Diff #488054)

I'm not super happy with just ignoring errors, since we might miss it if they change in a relevant way. OTOH having a lot of other errors littered in between also seems like a not-so-great thing. IDK, does anybody else have thoughts here?

libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp

94

I thought in the diff I looked at test_default_template_arg() was never called at runtime. Ignore my comment.

[yronglin]

Remove __expected namespace

[yronglin]

libcxx/include/__expected/expected.h

67

+1

[yronglin]

Rebase

[tcanens]

libcxx/include/__expected/expected.h

867–871

Guaranteed elision into a potentially-overlapping subobject is unsettled (and it's not clear that it's implementable, given that the function is allowed to clobber the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.

[yronglin]

libcxx/include/__expected/expected.h

867–871

Many Thanks for your reminder @tcanens ! Learned from this discussion, C++ standard still requires do direct initialization, but that impossible in current ABI, so, gcc says this code ( https://godbolt.org/z/K6edrdTG5) is ill-formed, but if we remove [[no_unique_address]], that works again. For the usability and robustness of std::expected, I think should we remove [[no_unique_address]] attribute until CWG2403 resolved this issue? Of course this will loses the benefit of [[no_unique_address]], and I don't have a strong opinion either way. I believe you have more experience than me. what do you all think?

[philnik]

libcxx/include/__expected/expected.h

867–871

We can't just apply [[no_unique_address]] later, since it would be an ABI break. We could do something like

union __union_t requires (is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>) {
  _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
  _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
  ...
};

union __union_t {
  _Tp __val_;
  _Err __unex_;
  ...
};

_LIBCPP_NO_UNIQUE_ADDRESS __union_t __union_;

That shouldn't be observable. @ldionne @huixie90 WDYT?

[yronglin]

rebase

[yronglin]

ping~

[yronglin]

ping

[yronglin]

Rebase and use [[no_unique_address]] if is_trivially_move_constructible_v<T> && is_trivially_move_constructible_v<E>

[yronglin]

Fix CI

[yronglin]

Try fix CI.

[yronglin]

libcxx/include/__expected/expected.h

867–871

@philnik @ldionne @huixie90 WDYT?

 struct __empty_t {};

 template <class _ValueType, class _ErrorType>
 union __union_t {
   constexpr __union_t() : __empty_() {}

   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
       std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
       : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}

   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
       std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
       : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}

   _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
     requires(is_trivially_destructible_v<_ValueType> && is_trivially_destructible_v<_ErrorType>)
   = default;

   // the expected's destructor handles this
   _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
     requires(!is_trivially_destructible_v<_ValueType> || !is_trivially_destructible_v<_ErrorType>)
   {}

   __empty_t __empty_;
   _ValueType __val_;
   _ErrorType __unex_;
 };

 // use named union because [[no_unique_address]] cannot be applied to an unnamed union, 
 // also guaranteed elision into a potentially-overlapping subobject is unsettled (and 
 // it's not clear that it's implementable, given that the function is allowed to clobber 
 // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.
 template <class _ValueType, class _ErrorType>
   requires(is_trivially_move_constructible_v<_ValueType> && is_trivially_move_constructible_v<_ErrorType>)
union __union_t<_ValueType, _ErrorType> {
   _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}

   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
       std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
       : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}

   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
       std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
       : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}

   _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
     requires(is_trivially_destructible_v<_ValueType> && is_trivially_destructible_v<_ErrorType>)
   = default;

   // the expected's destructor handles this
   _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
     requires(!is_trivially_destructible_v<_ValueType> || !is_trivially_destructible_v<_ErrorType>)
   {}

   _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
   _LIBCPP_NO_UNIQUE_ADDRESS _ValueType __val_;
   _LIBCPP_NO_UNIQUE_ADDRESS _ErrorType __unex_;
 };

 _LIBCPP_NO_UNIQUE_ADDRESS __union_t<_Tp, _Err> __union_;
 bool __has_val_;

[yronglin]

Try to fix issue https://github.com/itanium-cxx-abi/cxx-abi/issues/107

[yronglin]

Update

[philnik]

libcxx/include/__expected/expected.h

867–871

Looks good from my side, but @ldionne and @huixie90 should also take a look.

[yronglin]

Rebase

[yronglin]

Remove GCC XFAIL in transform/transform_error tests, because we have a workaround to avoid this issue.

[yronglin]

ping~ @ldionne @huixie90

[yronglin]

ping~

[Mordante]

Sorry sometimes patches get a bit lost in the review queue.
There are some things @ldionne should look at, I've asked him to have a look.

[yronglin]

In D140911#4325192, @Mordante wrote:

Sorry sometimes patches get a bit lost in the review queue.
There are some things @ldionne should look at, I've asked him to have a look.

Many thanks!

[ldionne]

In D140911#4326750, @yronglin wrote:

In D140911#4325192, @Mordante wrote:

Sorry sometimes patches get a bit lost in the review queue.
There are some things @ldionne should look at, I've asked him to have a look.

Many thanks!

Thanks for the ping on Discord Mark. @yronglin Sorry for not seeing your pings, notifications on Phab don't allow subscribing to direct mentions so I don't see them, they get lost in other review traffic. Next time, don't hesitate to ping me on Discord (yeah I know it's a pain).

This almost LGTM but I have a question about constraints.

libcxx/include/__expected/expected.h

860

I don't quite understand why https://eel.is/c++draft/expected#object.monadic-2 says is_constructible_v<E, decltype(error())> but we're using is_copy_constructible_v<_Err>. I don't think those are equivalent, right? For example error() will return a non-const reference for this &-qualified function, but we're checking that is_constructible_v<E, E const&> instead of is_constructible_v<E, E&>? This is subtle, but if I'm right, we should add a test for this and then correct all the overloads below.

863–864

Here and below, qualification for this isn't required. We qualify function calls to avoid ADL, but this is not a function call.

libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp

13

libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp

13

libcxx/test/std/utilities/expected/expected.void/monadic/transform_error.pass.cpp

13

[yronglin]

Thanks for your review @ldionne !

libcxx/include/__expected/expected.h

860

Wow, good catch! Seems this change maked by https://cplusplus.github.io/LWG/issue3877 , I'will apply this change.
https://github.com/cplusplus/draft/commit/1e278301ff6a1fe940aa72f6691f9dc79e06fb19

863–864

Thanks, I'll remove that.

[yronglin]

1. Address review comments
2. Apply https://cplusplus.github.io/LWG/issue3877
3. Apply https://cplusplus.github.io/LWG/lwg-defects.html#3866
4. Add test for LWG 3877 and LWG 3866

[ldionne]

LGTM w/ a few comments. Feel free to ship once those have been addressed, assuming the other reviewer's comments have been satisfied.

libcxx/docs/Status/Cxx2bPapers.csv

87

Can we mark the new LWG issues as resolved in libcxx/docs/Status/Cxx2bIssues.csv?

libcxx/include/__expected/expected.h

1410

Here too and a few below. I think you can grep for std::__is_expected!

[ldionne]

Oh, and please make sure the CI is green.

Thanks a lot for the patch and sorry it went unnoticed for a while!

[yronglin]

Fix tests

[yronglin]

Many thanks for your comments @ldionne !

libcxx/docs/Status/Cxx2bPapers.csv

87

+1

libcxx/include/__expected/expected.h

1063

So sorry, this code looks very ugly, it used to simplify the compile error diagnostic message(useful when I write the test case to check the static_assert message for LWG3866), do you have more good ideas for this?

before:

In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:1433:19: error: static assertion failed due to requirement 'integral_constant<bool, false>::value': The result of f(error()) must be a valid template argument for unexpected
    static_assert(__valid_std_unexpected<_Gp>::value,
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:50:7: note: in instantiation of function template specialization 'std::expected<void, int>::transform_error<std::unexpected<int> (&)(int &)>' requested here
    e.transform_error(return_unexpected); 
      ^
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:954:17: error: static assertion failed due to requirement 'integral_constant<bool, false>::value': [expected.void.general] A program that instantiates expected<T, E> with a E that is not a valid argument for unexpected<E> is ill-formed
  static_assert(__valid_std_unexpected<_Err>::value,
                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:1436:14: note: in instantiation of template class 'std::expected<void, std::unexpected<int>>' requested here
      return expected<_Tp, _Gp>();
             ^
/Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:50:7: note: in instantiation of function template specialization 'std::expected<void, int>::transform_error<std::unexpected<int> (&)(int &)>' requested here
    e.transform_error(return_unexpected); 
      ^
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:1438:12: error: excess elements in struct initializer
    return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
           ^                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:50:7: note: in instantiation of function template specialization 'std::expected<void, int>::transform_error<std::unexpected<int> (&)(int &)>' requested here
    e.transform_error(return_unexpected); 
      ^
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:

after:

In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:814:19: error: static assertion failed due to requirement 'integral_constant<bool, false>::value': The result of f(error()) must be a valid template argument for unexpected
    static_assert(__valid_std_unexpected<_Gp>::value,
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp:45:7: note: in instantiation of function template specialization 'std::expected<int, int>::transform_error<std::unexpected<int> (&)(int)>' requested here
    e.transform_error(return_unexpected<int&>); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}} The result of {{.*}} must be a valid template argument for unexpected}}
      ^
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:814:19: error: static assertion failed due to requirement 'integral_constant<bool, false>::value': The result of f(error()) must be a valid template argument for unexpected
    static_assert(__valid_std_unexpected<_Gp>::value,
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp:46:7: note: in instantiation of function template specialization 'std::expected<int, int>::transform_error<int &(&)(int)>' requested here
    e.transform_error(return_no_object<int&>); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}} The result of {{.*}} must be a valid template argument for unexpected}}
      ^
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp:29:
In file included from /Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/expected:44:
/Users/yrong/Developer/Toolchain/llvm/trunk/rel/include/c++/v1/__expected/expected.h:829:19: error: static assertion failed due to requirement 'integral_constant<bool, false>::value': The result of f(error()) must be a valid template argument for unexpected
    static_assert(__valid_std_unexpected<_Gp>::value,
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/yrong/Developer/Toolchain/llvm/trunk/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp:52:7: note: in instantiation of function template specialization 'std::expected<int, int>::transform_error<std::unexpected<int> (&)(int)>' requested here
    e.transform_error(return_unexpected<const int &>); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}} The result of {{.*}} must be a valid template argument for unexpected}}
      ^

[yronglin]

libcxx/include/__expected/expected.h

1410

Sorry, I have missed that in previous commit, the qualifier removed now

[ldionne]

libcxx/include/__expected/expected.h

1063

I'm not sure I see how the "after" is better than the "before"? They look very similar, don't they?

[yronglin]

libcxx/include/__expected/expected.h

1063

The "before" 1 case emit 3 errors, but "after" 1 case only emit 1 static assertion error.

[yronglin]

libcxx/include/__expected/expected.h

1070

Redundant error diagnostic messages was generated by static_assert at the front of expected

static_assert(
      !is_reference_v<_Tp> &&
          !is_function_v<_Tp> &&
          !is_same_v<remove_cv_t<_Tp>, in_place_t> &&
          !is_same_v<remove_cv_t<_Tp>, unexpect_t> &&
          !__is_std_unexpected<remove_cv_t<_Tp>>::value &&
          __valid_std_unexpected<_Err>::value
      ,
      "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
      "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
      "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
      "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
      "template argument for unexpected is ill-formed.");

[ldionne]

libcxx/include/__expected/expected.h

1063

IMO either way is acceptable. The real culprit is that Clang tries to keep compiling and that's really hard to work around that. For example with your current approach, the function will now return void and that could lead to other diagnostics.

[yronglin]

Remove if constexpr in transform_error.

[yronglin]

libcxx/include/__expected/expected.h

1063

Thanks for your tips, I finally remove this approach.

[ldionne]

Nice, let's ship this once CI is green!

[yronglin]

Fix docs ci.

[yronglin]

Fix CI

[yronglin]

Try fix transform_error.mandates.verify.cpp

[yronglin]

Fix CI

[yronglin]

Could I land this patch now? all CIs are green, but the status of this differential still is NeedsReview @ldionne

[ldionne]

@philnik @huixie90 Please let @yronglin know if you still have outstanding comments, but I think everything has been resolved.

@yronglin Please feel free to merge this in ~48h if no answer.

[yronglin]

In D140911#4346458, @ldionne wrote:

@philnik @huixie90 Please let @yronglin know if you still have outstanding comments, but I think everything has been resolved.

@yronglin Please feel free to merge this in ~48h if no answer.

Thanks!

[philnik]

LGTM % comments.

libcxx/include/__expected/expected.h

1418

This shouldn't be required, since the requires clause causes the = defaulted to be preferred.

libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp

10 ↗

(On Diff #488054)

I think I'd rather have a few more errors here than missing something important.

libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp

11 ↗

(On Diff #521294)

notes should normally be ignored. No need to specify this here.

[yronglin]

Address comments.

[yronglin]

Thanks for your comments! @philnik

libcxx/include/__expected/expected.h

886

Also removed required here.

1418

+1, removed.

libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp

10 ↗

(On Diff #488054)

Remove -verify-ignore-unexpected=error and checked more errors.

libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp

11 ↗

(On Diff #521294)

Remove -verify-ignore-unexpected=note

[yronglin]

libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp

11 ↗

(On Diff #521294)

When I remove this flag, the command returned an error:

ld: file too small (length=0) file '/var/folders/pv/yzhm_ln121n085_jxzz652y80000gn/T/transform_error-b24073.o' for architecture arm64
clang++: error: linker command failed with exit code 1 (use -v to see invocation)

[philnik]

libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp

11 ↗

(On Diff #521294)

This line shouldn't be required at all. The .verify already lets clang run in verify mode. It's probably confused because of the extra arguments.

[yronglin]

Remove extra -Xclang -verify in tests

[yronglin]

libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp

11 ↗

(On Diff #521294)

Thanks, removed!

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2467R1 <https://wg21.link/P2467R1>`__","LWG","Support exclusive mode for ``fstreams``","July 2022","",""
 "`P2474R2 <https://wg21.link/P2474R2>`__","LWG","``views::repeat``","July 2022","","","|ranges|"
 "`P2494R2 <https://wg21.link/P2494R2>`__","LWG","Relaxing range adaptors to allow for move only types","July 2022","","","|ranges|"
 "`P2499R0 <https://wg21.link/P2499R0>`__","LWG","``string_view`` range constructor should be ``explicit``","July 2022","|Complete|","16.0","|ranges|"
 "`P2502R2 <https://wg21.link/P2502R2>`__","LWG","``std::generator``: Synchronous Coroutine Generator for Ranges","July 2022","","","|ranges|"
 "`P2508R1 <https://wg21.link/P2508R1>`__","LWG","Exposing ``std::basic-format-string``","July 2022","|Complete|","15.0"
 "`P2513R4 <https://wg21.link/P2513R4>`__","LWG","``char8_t`` Compatibility and Portability Fixes","July 2022","",""
 "`P2517R1 <https://wg21.link/P2517R1>`__","LWG","Add a conditional ``noexcept`` specification to ``std::apply``","July 2022","",""
 "`P2520R0 <https://wg21.link/P2520R0>`__","LWG","``move_iterator`` should be a random access iterator","July 2022","","","|ranges|"
 "`P2540R1 <https://wg21.link/P2540R1>`__","LWG","Empty Product for certain Views","July 2022","","","|ranges|"
 "`P2549R1 <https://wg21.link/P2549R1>`__","LWG","``std::unexpected`` should have ``error()`` as member accessor","July 2022","|Complete|","16.0"
 "`P2553R1 <https://wg21.link/P2553R1>`__","LWG","Make ``mdspan`` ``size_type`` controllable","July 2022","",""
 "`P2554R0 <https://wg21.link/P2554R0>`__","LWG","C-Array Interoperability of MDSpan","July 2022","",""
 "`P2585R0 <https://wg21.link/P2585R0>`__","LWG","Improving default container formatting","July 2022","",""
 "`P2590R2 <https://wg21.link/P2590R2>`__","LWG","Explicit lifetime management","July 2022","",""
 "`P2599R2 <https://wg21.link/P2599R2>`__","LWG","``mdspan::size_type`` should be ``index_type``","July 2022","",""
 "`P2604R0 <https://wg21.link/P2604R0>`__","LWG","mdspan: rename pointer and contiguous","July 2022","",""
 "`P2613R1 <https://wg21.link/P2613R1>`__","LWG","Add the missing ``empty`` to ``mdspan``","July 2022","",""
 "","","","","",""
 "`P1202R5 <https://wg21.link/P1202R5>`__","LWG", "Asymmetric Fences", "November 2022","","","|concurrency TS|"
 "`P1264R2 <https://wg21.link/P1264R2>`__","LWG", "Revising the wording of ``stream`` input operations", "November 2022","|Complete|","9.0",""
 "`P1478R8 <https://wg21.link/P1478R8>`__","LWG", "``Byte-wise`` ``atomic`` ``memcpy``", "November 2022","","","|concurrency TS|"
 "`P2167R3 <https://wg21.link/P2167R3>`__","LWG", "Improved Proposed Wording for LWG 2114", "November 2022","","",""
 "`P2396R1 <https://wg21.link/P2396R1>`__","LWG", "Concurrency TS 2 fixes ", "November 2022","","","|concurrency TS|"
-"`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","","",""
+"`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","July 2022","|Complete|","16.0"
 "`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","","","|format|"
 "`P2602R2 <https://wg21.link/P2602R2>`__","LWG", "Poison Pills are Too Toxic", "November 2022","","","|ranges|"
 "`P2708R1 <https://wg21.link/P2708R1>`__","LWG", "No Further Fundamentals TSes", "November 2022","|Nothing to do|","",""
 "","","","","",""

libcxx/include/__expected/expected.h

 #include <__config>
 #include <__expected/bad_expected_access.h>
 #include <__expected/unexpect.h>
 #include <__expected/unexpected.h>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/disjunction.h>
+#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_copy_assignable.h>
 #include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_move_assignable.h>

 #include <__type_traits/negation.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/transaction.h>
+#include <__functional/invoke.h>
 #include <cstdlib> // for std::abort
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <class _Tp, class _Err> class expected;
+
 namespace __expected {
 
 template <class _Err, class _Arg>
 _LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) {
 #  ifndef _LIBCPP_NO_EXCEPTIONS
-  throw bad_expected_access<_Err>(std::forward<_Arg>(__arg));
+  throw bad_expected_access<_Err>(_VSTD::forward<_Arg>(__arg));
 #  else
   (void)__arg;
-  std::abort();
+  _VSTD::abort();
 #  endif
 }
 
+template <class _Tp>
+struct __is_expected : false_type {};
+template <class _Tp, class _Err>
+struct __is_expected<expected<_Tp, _Err>> : true_type {};
+
+struct __expected_construct_in_place_from_invoke_tag {};
+struct __expected_construct_unexpected_from_invoke_tag {};
 } // namespace __expected
 
 template <class _Tp, class _Err>
 class expected {
   static_assert(
       !is_reference_v<_Tp> &&
           !is_function_v<_Tp> &&
           !is_same_v<remove_cv_t<_Tp>, in_place_t> &&
           !is_same_v<remove_cv_t<_Tp>, unexpect_t> &&
           !__unexpected::__is_unexpected<remove_cv_t<_Tp>>::value &&
           __unexpected::__valid_unexpected<_Err>::value
       ,
       "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
       "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
       "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
       "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
       "template argument for unexpected is ill-formed.");
 
   template <class _Up, class _OtherErr>
   friend class expected;
 
 public:
   using value_type      = _Tp;
   using error_type      = _Err;
   using unexpected_type = unexpected<_Err>;
 
   template <class _Up>
   using rebind = expected<_Up, error_type>;
 
   // [expected.object.ctor], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr expected()
-    noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened
+  _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened
     requires is_default_constructible_v<_Tp>
-      : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_));
-  }
+      : __val_(), __has_val_(true) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&)
     requires(is_copy_constructible_v<_Tp> &&
              is_copy_constructible_v<_Err> &&
              is_trivially_copy_constructible_v<_Tp> &&
              is_trivially_copy_constructible_v<_Err>)
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __other)
     noexcept(is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> &&
              !(is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>))
       : __has_val_(__other.__has_val_) {
     if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), __other.__union_.__val_);
+      _VSTD::construct_at(_VSTD::addressof(__val_), __other.__val_);
     } else {
-      std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__unex_);
+      _VSTD::construct_at(_VSTD::addressof(__unex_), __other.__unex_);
     }
   }
 
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&)
     requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err>
               && is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __other)
     noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_constructible_v<_Err>)
     requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> &&
              !(is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>))
       : __has_val_(__other.__has_val_) {
     if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
+      _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::move(__other.__val_));
     } else {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
+      _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__other.__unex_));
     }
   }
 
 private:
   template <class _Up, class _OtherErr, class _UfQual, class _OtherErrQual>
   using __can_convert =
       _And< is_constructible<_Tp, _UfQual>,
             is_constructible<_Err, _OtherErrQual>,
             _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>,
             _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>,
             _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>,
             _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>,
             _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>,
             _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>,
             _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>> >;
 
 
 public:
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Up&, _Tp> ||
                                            !is_convertible_v<const _OtherErr&, _Err>)
   expected(const expected<_Up, _OtherErr>& __other)
     noexcept(is_nothrow_constructible_v<_Tp, const _Up&> &&
              is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
       : __has_val_(__other.__has_val_) {
     if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), __other.__union_.__val_);
+      _VSTD::construct_at(_VSTD::addressof(__val_), __other.__val_);
     } else {
-      std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__unex_);
+      _VSTD::construct_at(_VSTD::addressof(__unex_), __other.__unex_);
     }
   }
 
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp> || !is_convertible_v<_OtherErr, _Err>)
   expected(expected<_Up, _OtherErr>&& __other)
     noexcept(is_nothrow_constructible_v<_Tp, _Up> && is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
       : __has_val_(__other.__has_val_) {
     if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
+      _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::move(__other.__val_));
     } else {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
+      _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__other.__unex_));
     }
   }
 
   template <class _Up = _Tp>
     requires(!is_same_v<remove_cvref_t<_Up>, in_place_t> && !is_same_v<expected, remove_cvref_t<_Up>> &&
              !__unexpected::__is_unexpected<remove_cvref_t<_Up>>::value && is_constructible_v<_Tp, _Up>)
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp>)
   expected(_Up&& __u)
     noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
       : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_), std::forward<_Up>(__u));
+    _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::forward<_Up>(__u));
   }
 
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, const _OtherErr&>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
   expected(const unexpected<_OtherErr>& __unex)
     noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __unex.error());
+    _VSTD::construct_at(_VSTD::addressof(__unex_), __unex.error());
   }
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, _OtherErr>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
   expected(unexpected<_OtherErr>&& __unex)
     noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::move(__unex.error()));
+    _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__unex.error()));
   }
 
   template <class... _Args>
     requires is_constructible_v<_Tp, _Args...>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args)
     noexcept(is_nothrow_constructible_v<_Tp, _Args...>) // strengthened
       : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...);
+    _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::forward<_Args>(__args)...);
   }
 
   template <class _Up, class... _Args>
     requires is_constructible_v< _Tp, initializer_list<_Up>&, _Args... >
   _LIBCPP_HIDE_FROM_ABI constexpr explicit
   expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
     noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) // strengthened
       : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...);
+    _VSTD::construct_at(_VSTD::addressof(__val_), __il, _VSTD::forward<_Args>(__args)...);
   }
 
   template <class... _Args>
     requires is_constructible_v<_Err, _Args...>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
     noexcept(is_nothrow_constructible_v<_Err, _Args...>)  // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::forward<_Args>(__args)...);
+    _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::forward<_Args>(__args)...);
   }
 
   template <class _Up, class... _Args>
     requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... >
   _LIBCPP_HIDE_FROM_ABI constexpr explicit
   expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
     noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
+    _VSTD::construct_at(_VSTD::addressof(__unex_), __il, _VSTD::forward<_Args>(__args)...);
   }
 
   // [expected.object.dtor], destructor
 
   _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
     requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
     requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
   {
     if (__has_val_) {
-      std::destroy_at(std::addressof(__union_.__val_));
+      _VSTD::destroy_at(_VSTD::addressof(__val_));
     } else {
-      std::destroy_at(std::addressof(__union_.__unex_));
+      _VSTD::destroy_at(_VSTD::addressof(__unex_));
     }
   }
 
 private:
   template <class _T1, class _T2, class... _Args>
   _LIBCPP_HIDE_FROM_ABI static constexpr void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) {
     if constexpr (is_nothrow_constructible_v<_T1, _Args...>) {
-      std::destroy_at(std::addressof(__oldval));
-      std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+      _VSTD::destroy_at(_VSTD::addressof(__oldval));
+      _VSTD::construct_at(_VSTD::addressof(__newval), _VSTD::forward<_Args>(__args)...);
     } else if constexpr (is_nothrow_move_constructible_v<_T1>) {
-      _T1 __tmp(std::forward<_Args>(__args)...);
-      std::destroy_at(std::addressof(__oldval));
-      std::construct_at(std::addressof(__newval), std::move(__tmp));
+      _T1 __tmp(_VSTD::forward<_Args>(__args)...);
+      _VSTD::destroy_at(_VSTD::addressof(__oldval));
+      _VSTD::construct_at(_VSTD::addressof(__newval), _VSTD::move(__tmp));
     } else {
       static_assert(
           is_nothrow_move_constructible_v<_T2>,
           "To provide strong exception guarantee, T2 has to satisfy `is_nothrow_move_constructible_v` so that it can "
           "be reverted to the previous state in case an exception is thrown during the assignment.");
-      _T2 __tmp(std::move(__oldval));
-      std::destroy_at(std::addressof(__oldval));
-      __transaction __trans([&] { std::construct_at(std::addressof(__oldval), std::move(__tmp)); });
-      std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+      _T2 __tmp(_VSTD::move(__oldval));
+      _VSTD::destroy_at(_VSTD::addressof(__oldval));
+      __transaction __trans([&] { _VSTD::construct_at(_VSTD::addressof(__oldval), _VSTD::move(__tmp)); });
+      _VSTD::construct_at(_VSTD::addressof(__newval), _VSTD::forward<_Args>(__args)...);
       __trans.__complete();
     }
   }
 
+  template <class _Func, class... _Args>
+  constexpr explicit expected(__expected::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
+      : __val_(_VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::forward<_Args>(__args)...)), __has_val_(true) {}
+
+  template <class _Func, class... _Args>
+  constexpr explicit expected(
+      __expected::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
+      : __unex_(_VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::forward<_Args>(__args)...)), __has_val_(false) {}
+
 public:
   // [expected.object.assign], assignment
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
     noexcept(is_nothrow_copy_assignable_v<_Tp> &&
              is_nothrow_copy_constructible_v<_Tp> &&
              is_nothrow_copy_assignable_v<_Err> &&
              is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_assignable_v<_Tp> &&
              is_copy_constructible_v<_Tp> &&
              is_copy_assignable_v<_Err> &&
              is_copy_constructible_v<_Err> &&
              (is_nothrow_move_constructible_v<_Tp> ||
               is_nothrow_move_constructible_v<_Err>))
   {
     if (__has_val_ && __rhs.__has_val_) {
-      __union_.__val_ = __rhs.__union_.__val_;
+      __val_ = __rhs.__val_;
     } else if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, __rhs.__union_.__unex_);
+      __reinit_expected(__unex_, __val_, __rhs.__unex_);
     } else if (__rhs.__has_val_) {
-      __reinit_expected(__union_.__val_, __union_.__unex_, __rhs.__union_.__val_);
+      __reinit_expected(__val_, __unex_, __rhs.__val_);
     } else {
-      __union_.__unex_ = __rhs.__union_.__unex_;
+      __unex_ = __rhs.__unex_;
     }
     // note: only reached if no exception+rollback was done inside __reinit_expected
     __has_val_ = __rhs.__has_val_;
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
     noexcept(is_nothrow_move_assignable_v<_Tp> &&
              is_nothrow_move_constructible_v<_Tp> &&
              is_nothrow_move_assignable_v<_Err> &&
              is_nothrow_move_constructible_v<_Err>)
     requires(is_move_constructible_v<_Tp> &&
              is_move_assignable_v<_Tp> &&
              is_move_constructible_v<_Err> &&
              is_move_assignable_v<_Err> &&
              (is_nothrow_move_constructible_v<_Tp> ||
               is_nothrow_move_constructible_v<_Err>))
   {
     if (__has_val_ && __rhs.__has_val_) {
-      __union_.__val_ = std::move(__rhs.__union_.__val_);
+      __val_ = _VSTD::move(__rhs.__val_);
     } else if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__rhs.__union_.__unex_));
+      __reinit_expected(__unex_, __val_, _VSTD::move(__rhs.__unex_));
     } else if (__rhs.__has_val_) {
-      __reinit_expected(__union_.__val_, __union_.__unex_, std::move(__rhs.__union_.__val_));
+      __reinit_expected(__val_, __unex_, _VSTD::move(__rhs.__val_));
     } else {
-      __union_.__unex_ = std::move(__rhs.__union_.__unex_);
+      __unex_ = _VSTD::move(__rhs.__unex_);
     }
     // note: only reached if no exception+rollback was done inside __reinit_expected
     __has_val_ = __rhs.__has_val_;
     return *this;
   }
 
   template <class _Up = _Tp>
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Up&& __v)
     requires(!is_same_v<expected, remove_cvref_t<_Up>> &&
              !__unexpected::__is_unexpected<remove_cvref_t<_Up>>::value &&
              is_constructible_v<_Tp, _Up> &&
              is_assignable_v<_Tp&, _Up> &&
              (is_nothrow_constructible_v<_Tp, _Up> ||
               is_nothrow_move_constructible_v<_Tp> ||
               is_nothrow_move_constructible_v<_Err>))
   {
     if (__has_val_) {
-      __union_.__val_ = std::forward<_Up>(__v);
+      __val_ = _VSTD::forward<_Up>(__v);
     } else {
-      __reinit_expected(__union_.__val_, __union_.__unex_, std::forward<_Up>(__v));
+      __reinit_expected(__val_, __unex_, _VSTD::forward<_Up>(__v));
       __has_val_ = true;
     }
     return *this;
   }
 
 private:
   template <class _OtherErrQual>
   static constexpr bool __can_assign_from_unexpected =
       _And< is_constructible<_Err, _OtherErrQual>,
             is_assignable<_Err&, _OtherErrQual>,
             _Lazy<_Or,
                   is_nothrow_constructible<_Err, _OtherErrQual>,
                   is_nothrow_move_constructible<_Tp>,
                   is_nothrow_move_constructible<_Err>> >::value;
 
 public:
   template <class _OtherErr>
     requires(__can_assign_from_unexpected<const _OtherErr&>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) {
     if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, __un.error());
+      __reinit_expected(__unex_, __val_, __un.error());
       __has_val_ = false;
     } else {
-      __union_.__unex_ = __un.error();
+      __unex_ = __un.error();
     }
     return *this;
   }
 
   template <class _OtherErr>
     requires(__can_assign_from_unexpected<_OtherErr>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) {
     if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__un.error()));
+      __reinit_expected(__unex_, __val_, _VSTD::move(__un.error()));
       __has_val_ = false;
     } else {
-      __union_.__unex_ = std::move(__un.error());
+      __unex_ = _VSTD::move(__un.error());
     }
     return *this;
   }
 
   template <class... _Args>
     requires is_nothrow_constructible_v<_Tp, _Args...>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(_Args&&... __args) noexcept {
     if (__has_val_) {
-      std::destroy_at(std::addressof(__union_.__val_));
+      _VSTD::destroy_at(_VSTD::addressof(__val_));
     } else {
-      std::destroy_at(std::addressof(__union_.__unex_));
+      _VSTD::destroy_at(_VSTD::addressof(__unex_));
       __has_val_ = true;
     }
-    return *std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...);
+    return *_VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::forward<_Args>(__args)...);
   }
 
   template <class _Up, class... _Args>
     requires is_nothrow_constructible_v< _Tp, initializer_list<_Up>&, _Args... >
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept {
     if (__has_val_) {
-      std::destroy_at(std::addressof(__union_.__val_));
+      _VSTD::destroy_at(_VSTD::addressof(__val_));
     } else {
-      std::destroy_at(std::addressof(__union_.__unex_));
+      _VSTD::destroy_at(_VSTD::addressof(__unex_));
       __has_val_ = true;
     }
-    return *std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...);
+    return *_VSTD::construct_at(_VSTD::addressof(__val_), __il, _VSTD::forward<_Args>(__args)...);
   }
 
 
 public:
   // [expected.object.swap], swap
   _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
     noexcept(is_nothrow_move_constructible_v<_Tp> &&
              is_nothrow_swappable_v<_Tp> &&
              is_nothrow_move_constructible_v<_Err> &&
              is_nothrow_swappable_v<_Err>)
     requires(is_swappable_v<_Tp> &&
              is_swappable_v<_Err> &&
              is_move_constructible_v<_Tp> &&
              is_move_constructible_v<_Err> &&
              (is_nothrow_move_constructible_v<_Tp> ||
               is_nothrow_move_constructible_v<_Err>))
   {
     auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) {
       if constexpr (is_nothrow_move_constructible_v<_Err>) {
-        _Err __tmp(std::move(__with_err.__union_.__unex_));
-        std::destroy_at(std::addressof(__with_err.__union_.__unex_));
+        _Err __tmp(_VSTD::move(__with_err.__unex_));
+        _VSTD::destroy_at(_VSTD::addressof(__with_err.__unex_));
         __transaction __trans([&] {
-          std::construct_at(std::addressof(__with_err.__union_.__unex_), std::move(__tmp));
+          _VSTD::construct_at(_VSTD::addressof(__with_err.__unex_), _VSTD::move(__tmp));
         });
-        std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__with_val.__union_.__val_));
+        _VSTD::construct_at(_VSTD::addressof(__with_err.__val_), _VSTD::move(__with_val.__val_));
         __trans.__complete();
-        std::destroy_at(std::addressof(__with_val.__union_.__val_));
-        std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__tmp));
+        _VSTD::destroy_at(_VSTD::addressof(__with_val.__val_));
+        _VSTD::construct_at(_VSTD::addressof(__with_val.__unex_), _VSTD::move(__tmp));
       } else {
         static_assert(is_nothrow_move_constructible_v<_Tp>,
                       "To provide strong exception guarantee, Tp has to satisfy `is_nothrow_move_constructible_v` so "
                       "that it can be reverted to the previous state in case an exception is thrown during swap.");
-        _Tp __tmp(std::move(__with_val.__union_.__val_));
-        std::destroy_at(std::addressof(__with_val.__union_.__val_));
-        __transaction __trans([&] { std::construct_at(std::addressof(__with_val.__union_.__val_), std::move(__tmp)); });
-        std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_));
+        _Tp __tmp(_VSTD::move(__with_val.__val_));
+        _VSTD::destroy_at(_VSTD::addressof(__with_val.__val_));
+        __transaction __trans([&] { _VSTD::construct_at(_VSTD::addressof(__with_val.__val_), _VSTD::move(__tmp)); });
+        _VSTD::construct_at(_VSTD::addressof(__with_val.__unex_), _VSTD::move(__with_err.__unex_));
         __trans.__complete();
-        std::destroy_at(std::addressof(__with_err.__union_.__unex_));
-        std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__tmp));
+        _VSTD::destroy_at(_VSTD::addressof(__with_err.__unex_));
+        _VSTD::construct_at(_VSTD::addressof(__with_err.__val_), _VSTD::move(__tmp));
       }
       __with_val.__has_val_ = false;
       __with_err.__has_val_ = true;
     };
 
     if (__has_val_) {
       if (__rhs.__has_val_) {
-        using std::swap;
-        swap(__union_.__val_, __rhs.__union_.__val_);
+        using _VSTD::swap;
+        swap(__val_, __rhs.__val_);
       } else {
         __swap_val_unex_impl(*this, __rhs);
       }
     } else {
       if (__rhs.__has_val_) {
         __swap_val_unex_impl(__rhs, *this);
       } else {
-        using std::swap;
-        swap(__union_.__unex_, __rhs.__union_.__unex_);
+        using _VSTD::swap;
+        swap(__unex_, __rhs.__unex_);
       }
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y)
     noexcept(noexcept(__x.swap(__y)))
     requires requires { __x.swap(__y); }
   {
     __x.swap(__y);
   }
 
   // [expected.object.obs], observers
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator-> requires the expected to contain a value");
-    return std::addressof(__union_.__val_);
+    return _VSTD::addressof(__val_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator-> requires the expected to contain a value");
-    return std::addressof(__union_.__val_);
+    return _VSTD::addressof(__val_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return __union_.__val_;
+    return __val_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return __union_.__val_;
+    return __val_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return std::move(__union_.__val_);
+    return _VSTD::move(__val_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return std::move(__union_.__val_);
+    return _VSTD::move(__val_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& value() const& {
     if (!__has_val_) {
-      __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+      __expected::__throw_bad_expected_access<_Err>(__unex_);
     }
-    return __union_.__val_;
+    return __val_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & {
     if (!__has_val_) {
-      __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+      __expected::__throw_bad_expected_access<_Err>(__unex_);
     }
-    return __union_.__val_;
+    return __val_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& value() const&& {
     if (!__has_val_) {
-      __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+      __expected::__throw_bad_expected_access<_Err>(_VSTD::move(__unex_));
     }
-    return std::move(__union_.__val_);
+    return _VSTD::move(__val_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && {
     if (!__has_val_) {
-      __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+      __expected::__throw_bad_expected_access<_Err>(_VSTD::move(__unex_));
     }
-    return std::move(__union_.__val_);
+    return _VSTD::move(__val_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    return __unex_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    return __unex_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    return _VSTD::move(__unex_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    return _VSTD::move(__unex_);
   }
 
   template <class _Up>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
     static_assert(is_copy_constructible_v<_Tp>, "value_type has to be copy constructible");
     static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type");
-    return __has_val_ ? __union_.__val_ : static_cast<_Tp>(std::forward<_Up>(__v));
+    return __has_val_ ? __val_ : static_cast<_Tp>(_VSTD::forward<_Up>(__v));
   }
 
   template <class _Up>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
     static_assert(is_move_constructible_v<_Tp>, "value_type has to be move constructible");
     static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type");
-    return __has_val_ ? std::move(__union_.__val_) : static_cast<_Tp>(std::forward<_Up>(__v));
+    return __has_val_ ? _VSTD::move(__val_) : static_cast<_Tp>(_VSTD::forward<_Up>(__v));
+  }
+
+  template <class _Up = _Err>
+    requires(is_copy_constructible_v<_Err> && is_convertible_v<_Up, _Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) const& {
+    return has_value() ? _VSTD::forward<_Up>(__v) : error();
+  }
+
+  template <class _Up = _Err>
+    requires(is_move_constructible_v<_Err> && is_convertible_v<_Up, _Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) && {
+    return has_value() ? _VSTD::forward<_Up>(__v) : _VSTD::move(error());
+  }
+
+  // [expected.void.monadic], monadic
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(value()) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(value()) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(std::move(value())) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
+    }
+    return _Up(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(std::move(value())) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
+    }
+    return _Up(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(error()) should be the same type as this expected");
+    if (has_value()) {
+      return _Up(in_place, value());
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(error()) should be the same type as this expected");
+    if (has_value()) {
+      return _Up(in_place, value());
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(std::move(error())) should be the same type as this expected");
+    if (has_value()) {
+      return _Up(in_place, _VSTD::move(value()));
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(std::move(error())) should be the same type as this expected");
+    if (has_value()) {
+      return _Up(in_place, _VSTD::move(value()));
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value());
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value());
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{},
+            _VSTD::forward<_Func>(__f),
+            _VSTD::move(value()));
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{},
+            _VSTD::forward<_Func>(__f),
+            _VSTD::move(value()));
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, value());
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, _VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, value());
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, _VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, _VSTD::move(value()));
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{},
+        _VSTD::forward<_Func>(__f),
+        _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, _VSTD::move(value()));
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{},
+        _VSTD::forward<_Func>(__f),
+        _VSTD::move(error()));
   }
 
   // [expected.object.eq], equality operators
   template <class _T2, class _E2>
     requires(!is_void_v<_T2>)
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
     if (__x.__has_val_ != __y.__has_val_) {
       return false;
     } else {
       if (__x.__has_val_) {
-        return __x.__union_.__val_ == __y.__union_.__val_;
+        return __x.__val_ == __y.__val_;
       } else {
-        return __x.__union_.__unex_ == __y.__union_.__unex_;
+        return __x.__unex_ == __y.__unex_;
       }
     }
   }
 
   template <class _T2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const _T2& __v) {
-    return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
+    return __x.__has_val_ && static_cast<bool>(__x.__val_ == __v);
   }
 
   template <class _E2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __e) {
-    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __e.error());
+    return !__x.__has_val_ && static_cast<bool>(__x.__unex_ == __e.error());
   }
 
 private:
   struct __empty_t {};
-  // use named union because [[no_unique_address]] cannot be applied to an unnamed union
-  _LIBCPP_NO_UNIQUE_ADDRESS union __union_t {
-    _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
-
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
-    = default;
-
-    // the expected's destructor handles this
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
-    {}
-
-    _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
-  } __union_;
+   union {
+     __empty_t __empty_;
+     _Tp __val_;
+     _Err __unex_;
+  };
 
   bool __has_val_;
 };
 
 template <class _Tp, class _Err>
   requires is_void_v<_Tp>
 class expected<_Tp, _Err> {
   static_assert(__unexpected::__valid_unexpected<_Err>::value,
                 "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a "
                 "valid argument for unexpected<E> is ill-formed");
 
   template <class, class>
   friend class expected;
 
   template <class _Up, class _OtherErr, class _OtherErrQual>
   using __can_convert =
       _And< is_void<_Up>,
             is_constructible<_Err, _OtherErrQual>,
             _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>>>;
 
_LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&)
     requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>)
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __rhs)
     noexcept(is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_constructible_v<_Err> && !is_trivially_copy_constructible_v<_Err>)
       : __has_val_(__rhs.__has_val_) {
     if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
+      _VSTD::construct_at(_VSTD::addressof(__unex_), __rhs.__unex_);
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&)
     requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>)
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __rhs)
     noexcept(is_nothrow_move_constructible_v<_Err>)
     requires(is_move_constructible_v<_Err> && !is_trivially_move_constructible_v<_Err>)
       : __has_val_(__rhs.__has_val_) {
     if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
+      _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__rhs.__unex_));
     }
   }
 
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, const _OtherErr&>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
   expected(const expected<_Up, _OtherErr>& __rhs)
     noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
       : __has_val_(__rhs.__has_val_) {
     if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
+      _VSTD::construct_at(_VSTD::addressof(__unex_), __rhs.__unex_);
     }
   }
 
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, _OtherErr>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
   expected(expected<_Up, _OtherErr>&& __rhs)
     noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
       : __has_val_(__rhs.__has_val_) {
     if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
+      _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__rhs.__unex_));
     }
   }
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, const _OtherErr&>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
   expected(const unexpected<_OtherErr>& __unex)
     noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __unex.error());
+    _VSTD::construct_at(_VSTD::addressof(__unex_), __unex.error());
   }
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, _OtherErr>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
   expected(unexpected<_OtherErr>&& __unex)
     noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::move(__unex.error()));
+    _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__unex.error()));
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __has_val_(true) {}
 
   template <class... _Args>
     requires is_constructible_v<_Err, _Args...>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
     noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::forward<_Args>(__args)...);
+    _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::forward<_Args>(__args)...);
   }
 
   template <class _Up, class... _Args>
     requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... >
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
     noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
       : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
+    _VSTD::construct_at(_VSTD::addressof(__unex_), __il, _VSTD::forward<_Args>(__args)...);
   }
 
   // [expected.void.dtor], destructor
 
   _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
     requires is_trivially_destructible_v<_Err>
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
     requires(!is_trivially_destructible_v<_Err>)
   {
     if (!__has_val_) {
-      std::destroy_at(std::addressof(__union_.__unex_));
+      _VSTD::destroy_at(_VSTD::addressof(__unex_));
     }
   }
 
+private:
+  template <class _Func>
+  constexpr explicit expected(__expected::__expected_construct_in_place_from_invoke_tag, _Func&& __f)
+      : __has_val_(true) {
+    _VSTD::forward<_Func>(__f)();
+  }
+
+  template <class _Func, class... _Args>
+  constexpr explicit expected(
+      __expected::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
+      : __unex_(_VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::forward<_Args>(__args)...)), __has_val_(false) {}
+
+public:
   // [expected.void.assign], assignment
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
     noexcept(is_nothrow_copy_assignable_v<_Err> && is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>)
   {
     if (__has_val_) {
       if (!__rhs.__has_val_) {
-        std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
+        _VSTD::construct_at(_VSTD::addressof(__unex_), __rhs.__unex_);
         __has_val_ = false;
       }
     } else {
       if (__rhs.__has_val_) {
-        std::destroy_at(std::addressof(__union_.__unex_));
+        _VSTD::destroy_at(_VSTD::addressof(__unex_));
         __has_val_ = true;
       } else {
-        __union_.__unex_ = __rhs.__union_.__unex_;
+        __unex_ = __rhs.__unex_;
       }
     }
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
     noexcept(is_nothrow_move_assignable_v<_Err> &&
              is_nothrow_move_constructible_v<_Err>)
     requires(is_move_assignable_v<_Err> &&
              is_move_constructible_v<_Err>)
   {
     if (__has_val_) {
       if (!__rhs.__has_val_) {
-        std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
+        _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__rhs.__unex_));
         __has_val_ = false;
       }
     } else {
       if (__rhs.__has_val_) {
-        std::destroy_at(std::addressof(__union_.__unex_));
+        _VSTD::destroy_at(_VSTD::addressof(__unex_));
         __has_val_ = true;
       } else {
-        __union_.__unex_ = std::move(__rhs.__union_.__unex_);
+        __unex_ = _VSTD::move(__rhs.__unex_);
       }
     }
     return *this;
   }
 
   template <class _OtherErr>
     requires(is_constructible_v<_Err, const _OtherErr&> && is_assignable_v<_Err&, const _OtherErr&>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) {
     if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), __un.error());
+      _VSTD::construct_at(_VSTD::addressof(__unex_), __un.error());
       __has_val_ = false;
     } else {
-      __union_.__unex_ = __un.error();
+      __unex_ = __un.error();
     }
     return *this;
   }
 
   template <class _OtherErr>
     requires(is_constructible_v<_Err, _OtherErr> && is_assignable_v<_Err&, _OtherErr>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) {
     if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__un.error()));
+      _VSTD::construct_at(_VSTD::addressof(__unex_), _VSTD::move(__un.error()));
       __has_val_ = false;
     } else {
-      __union_.__unex_ = std::move(__un.error());
+      __unex_ = _VSTD::move(__un.error());
     }
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept {
     if (!__has_val_) {
-      std::destroy_at(std::addressof(__union_.__unex_));
+      _VSTD::destroy_at(_VSTD::addressof(__unex_));
       __has_val_ = true;
     }
   }
 
   // [expected.void.swap], swap
   _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
     noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
     requires(is_swappable_v<_Err> && is_move_constructible_v<_Err>)
   {
     auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) {
-      std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_));
-      std::destroy_at(std::addressof(__with_err.__union_.__unex_));
+      _VSTD::construct_at(_VSTD::addressof(__with_val.__unex_), _VSTD::move(__with_err.__unex_));
+      _VSTD::destroy_at(_VSTD::addressof(__with_err.__unex_));
       __with_val.__has_val_ = false;
       __with_err.__has_val_ = true;
     };
 
     if (__has_val_) {
       if (!__rhs.__has_val_) {
         __swap_val_unex_impl(*this, __rhs);
       }
     } else {
       if (__rhs.__has_val_) {
         __swap_val_unex_impl(__rhs, *this);
       } else {
-        using std::swap;
-        swap(__union_.__unex_, __rhs.__union_.__unex_);
+        using _VSTD::swap;
+        swap(__unex_, __rhs.__unex_);
       }
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y)
     noexcept(noexcept(__x.swap(__y)))
     requires requires { __x.swap(__y); }
   {
     __x.swap(__y);
   }
 
   // [expected.void.obs], observers
   _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void operator*() const noexcept {
     _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void value() const& {
     if (!__has_val_) {
-      __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+      __expected::__throw_bad_expected_access<_Err>(__unex_);
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void value() && {
     if (!__has_val_) {
-      __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+      __expected::__throw_bad_expected_access<_Err>(_VSTD::move(__unex_));
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    return __unex_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    return __unex_;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    return _VSTD::move(__unex_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept {
     _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    return _VSTD::move(__unex_);
+  }
+
+  template <class _Up = _Err>
+    requires(is_copy_constructible_v<_Err> && is_convertible_v<_Up, _Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) const& {
+    return has_value() ? _VSTD::forward<_Up>(__v) : error();
+  }
+
+  template <class _Up = _Err>
+    requires(is_move_constructible_v<_Err> && is_convertible_v<_Up, _Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) && {
+    return has_value() ? _VSTD::forward<_Up>(__v) : _VSTD::move(error());
+  }
+
+  // [expected.void.monadic], monadic
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(value()) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f));
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(value()) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f));
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(std::move(value())) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f));
+    }
+    return _Up(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::error_type, _Err>,
+                  "Result of f(std::move(value())) must be a specialization of std::expected");
+    if (has_value()) {
+      return _VSTD::invoke(_VSTD::forward<_Func>(__f));
+    }
+    return _Up(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(error()) should be the same type as this expected");
+    if (has_value()) {
+      return _Up();
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(error()) should be the same type as this expected");
+    if (has_value()) {
+      return _Up();
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(std::move(error())) should be the same type as this expected");
+    if (has_value()) {
+      return _Up();
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value && is_same_v<typename _Up::value_type, _Tp>,
+                  "Result of f(std::move(error())) should be the same type as this expected");
+    if (has_value()) {
+      return _Up();
+    }
+    return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, _VSTD::forward<_Func>(__f));
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_copy_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, _VSTD::forward<_Func>(__f));
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, _VSTD::forward<_Func>(__f));
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+    requires is_move_constructible_v<_Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, _VSTD::forward<_Func>(__f));
+      } else {
+        _VSTD::invoke(_VSTD::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, _VSTD::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>();
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, _VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>();
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, _VSTD::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>();
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{},
+        _VSTD::forward<_Func>(__f),
+        _VSTD::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place);
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{},
+        _VSTD::forward<_Func>(__f),
+        _VSTD::move(error()));
   }
 
   // [expected.void.eq], equality operators
   template <class _T2, class _E2>
     requires is_void_v<_T2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
     if (__x.__has_val_ != __y.__has_val_) {
       return false;
     } else {
-      return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ == __y.__union_.__unex_);
+      return __x.__has_val_ || static_cast<bool>(__x.__unex_ == __y.__unex_);
     }
   }
 
   template <class _E2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __y) {
-    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __y.error());
+    return !__x.__has_val_ && static_cast<bool>(__x.__unex_ == __y.error());
   }
 
 private:
   struct __empty_t {};
-  // use named union because [[no_unique_address]] cannot be applied to an unnamed union
-  _LIBCPP_NO_UNIQUE_ADDRESS union __union_t {
-    _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
-
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(is_trivially_destructible_v<_Err>)
-    = default;
-
-    // the expected's destructor handles this
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(!is_trivially_destructible_v<_Err>)
-    {}
-
-    _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
-  } __union_;
+  union {
+    __empty_t __empty_;
+    _Err __unex_;
+  };
 
   bool __has_val_;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
 #endif // _LIBCPP___EXPECTED_EXPECTED_H

libcxx/test/libcxx/utilities/expected/expected.expected/no_unique_address.compile.pass.cpp

-//===----------------------------------------------------------------------===//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// clang-cl and cl currently don't support [[no_unique_address]]
-// XFAIL: msvc
-
-// test [[no_unique_address]] is applied to the union
-
-#include <expected>
-
-struct Empty {};
-
-static_assert(sizeof(std::expected<Empty, Empty>) == sizeof(bool));

libcxx/test/libcxx/utilities/expected/expected.void/no_unique_address.compile.pass.cpp

-//===----------------------------------------------------------------------===//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// clang-cl and cl currently don't support [[no_unique_address]]
-// XFAIL: msvc
-
-// test [[no_unique_address]] is applied to the union
-
-#include <expected>
-
-struct Empty {};
-
-static_assert(sizeof(std::expected<void, Empty>) == sizeof(bool));

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto and_then(F&& f) &;
+// template<class F> constexpr auto and_then(F&& f) const &;
+// template<class F> constexpr auto and_then(F&& f) &&;
+// template<class F> constexpr auto and_then(F&& f) const &&;
+
+#include <cassert>
+#include <expected>
+
+
+struct LVal {
+  constexpr std::expected<int, int> operator()(int&) { return 1; }
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&) = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  std::expected<int, int> operator()(int&) = delete;
+  constexpr std::expected<int, int> operator()(const int&) { return 1; }
+  std::expected<int, int> operator()(int&&) = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct RVal {
+  std::expected<int, int> operator()(int&) = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  constexpr std::expected<int, int> operator()(int&&) { return 1; }
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  std::expected<int, int> operator()(int&) = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&) = delete;
+  constexpr std::expected<int, int> operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr std::expected<int, int> operator()(int) & { return 1; }
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) && = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  constexpr std::expected<int, int> operator()(int) const& { return 1; }
+  std::expected<int, int> operator()(int) && = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  constexpr std::expected<int, int> operator()(int) && { return 1; }
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) && = delete;
+  constexpr std::expected<int, int> operator()(int) const&& { return 1; }
+};
+
+struct NOLVal {
+  constexpr std::expected<int, int> operator()(int&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&) = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct NOCLVal {
+  std::expected<int, int> operator()(int&) = delete;
+  constexpr std::expected<int, int> operator()(const int&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int&&) = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct NORVal {
+  std::expected<int, int> operator()(int&) = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  constexpr std::expected<int, int> operator()(int&&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct NOCRVal {
+  std::expected<int, int> operator()(int&) = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&) = delete;
+  constexpr std::expected<int, int> operator()(const int&&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+};
+
+struct NORefQual {
+  constexpr std::expected<int, int> operator()(int) & { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) && = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct NOCRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  constexpr std::expected<int, int> operator()(int) const& { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int) && = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct NORVRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  constexpr std::expected<int, int> operator()(int) && { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct NORVCRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) && = delete;
+  constexpr std::expected<int, int> operator()(int) const&& { return std::expected<int, int>(std::unexpected<int>(5)); }
+};
+
+struct NoCopy {
+  NoCopy() = default;
+  NoCopy(const NoCopy&) { assert(false); }
+  std::expected<int, int> operator()(const NoCopy&&) { return 1; }
+};
+
+struct NonConst {
+  std::expected<int, int> non_const() { return 1; }
+};
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without &qualifier on F'soperator()
+    {
+      std::expected<int, int> e{0};
+      assert(e.and_then(LVal{}).value() == 1);
+      assert(e.and_then(NOLVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e{0};
+      RefQual l{};
+      assert(e.and_then(l) == 1);
+      NORefQual nl{};
+      assert(e.and_then(nl).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(l)), std::expected<int, int>>);
+    } 
+  }
+
+  // Test const& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      assert(e.and_then(CLVal{}).value() == 1);
+      assert(e.and_then(NOCLVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      const CRefQual l{};
+      assert(e.and_then(l) == 1);
+      const NOCRefQual nl{};
+      assert(e.and_then(nl).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(l)), std::expected<int, int>>);
+    } 
+  }
+
+  // Test && overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e{0};
+      assert(std::move(e).and_then(RVal{}) == 1);
+      assert(std::move(e).and_then(NORVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(RVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e{0};
+      assert(e.and_then(RVRefQual{}) == 1);
+      assert(e.and_then(NORVRefQual{}).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      assert(std::move(e).and_then(CRVal{}) == 1);
+      assert(std::move(e).and_then(NOCRVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      const RVCRefQual l{};
+      assert(std::move(e).and_then(std::move(l)) == 1);
+      const NORVCRefQual nl{};
+      assert(std::move(e).and_then(std::move(nl)).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<NonConst, int> e(std::unexpected<int>(2));
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.and_then(l);
+  std::move(e).and_then(l);
+}
+
+constexpr bool test() {
+  test_sfinae();
+  test_val_types();
+
+  std::expected<int, int> e(std::unexpected<int>(1));
+  const auto &ce = e;
+
+  const auto never_called = [](int) {
+    assert(false);
+    return std::expected<int, int>();
+  };
+
+  e.and_then(never_called);
+  std::move(e).and_then(never_called);
+  ce.and_then(never_called);
+  std::move(ce).and_then(never_called);
+
+  std::expected<NoCopy, int> nc(std::unexpect, 0);
+  const auto &cnc = nc;
+  std::move(nc).and_then(NoCopy{});
+  std::move(cnc).and_then(NoCopy{});
+
+  return true;
+}
+
+int main(int, char **) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// template<class F> constexpr auto or_else(F&& f) &;
+// template<class F> constexpr auto or_else(F&& f) const &;
+// template<class F> constexpr auto or_else(F&& f) &&;
+// template<class F> constexpr auto or_else(F&& f) const &&;
+
+#include <cassert>
+#include <expected>
+
+struct LVal {
+  constexpr std::expected<int, int> operator()(int&) { return 1; }
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&) = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  std::expected<int, int> operator()(int&) = delete;
+  constexpr std::expected<int, int> operator()(const int&) { return 1; }
+  std::expected<int, int> operator()(int&&) = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct RVal {
+  std::expected<int, int> operator()(int&) = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  constexpr std::expected<int, int> operator()(int&&) { return 1; }
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  std::expected<int, int> operator()(int&) = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&) = delete;
+  constexpr std::expected<int, int> operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr std::expected<int, int> operator()(int) & { return 1; }
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) && = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  constexpr std::expected<int, int> operator()(int) const& { return 1; }
+  std::expected<int, int> operator()(int) && = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  constexpr std::expected<int, int> operator()(int) && { return 1; }
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) && = delete;
+  constexpr std::expected<int, int> operator()(int) const&& { return 1; }
+};
+
+struct NoCopy {
+  NoCopy() = default;
+  NoCopy(const NoCopy&) { assert(false); }
+  std::expected<int, int> operator()(const NoCopy&&) { return 1; }
+};
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.or_else(LVal{}) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      RefQual l{};
+      assert(e.or_else(l) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.or_else(CLVal{}) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const CRefQual l{};
+      assert(e.or_else(l) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test && overload
+  {
+    // Without && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).or_else(RVal{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(RVal{})), std::expected<int, int>>);
+    }
+
+    // With && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).or_else(RVRefQual{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).or_else(CRVal{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const RVCRefQual l{};
+      assert(std::move(e).or_else(std::move(l)) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+
+struct NonConst {
+  std::expected<int, int> non_const() {
+    return std::expected<int, int>(std::unexpect, 1);
+  }
+};
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<int, NonConst> e{1};
+  auto l = [](auto &&x) { return x.non_const(); };
+  e.or_else(l);
+  std::move(e).or_else(l);
+}
+
+constexpr bool test() {
+  test_sfinae();
+  test_val_types();
+
+  std::expected<int, int> e(1);
+  const auto &ce = e;
+
+  const auto never_called = [](int) {
+    assert(false);
+    return std::expected<int, int>();
+  };
+
+  e.or_else(never_called);
+  std::move(e).or_else(never_called);
+  ce.or_else(never_called);
+  std::move(ce).or_else(never_called);
+
+  std::expected<int, NoCopy> nc(0);
+  const auto &cnc = nc;
+  std::move(nc).or_else(NoCopy{});
+  std::move(cnc).or_else(NoCopy{});
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform(F&& f) &;
+// template<class F> constexpr auto transform(F&& f) const &;
+// template<class F> constexpr auto transform(F&& f) &&;
+// template<class F> constexpr auto transform(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+struct LVal {
+  constexpr int operator()(int&) { return 1; }
+  int operator()(const int&) = delete;
+  int operator()(int&&) = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  int operator()(int&) = delete;
+  constexpr int operator()(const int&) { return 1; }
+  int operator()(int&&) = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct RVal {
+  int operator()(int&) = delete;
+  int operator()(const int&) = delete;
+  constexpr int operator()(int&&) { return 1; }
+  int operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  int operator()(int&) = delete;
+  int operator()(const int&) = delete;
+  int operator()(int&&) = delete;
+  constexpr int operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr int operator()(int) & { return 1; }
+  int operator()(int) const& = delete;
+  int operator()(int) && = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  int operator()(int) & = delete;
+  constexpr int operator()(int) const& { return 1; }
+  int operator()(int) && = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  int operator()(int) & = delete;
+  int operator()(int) const& = delete;
+  constexpr int operator()(int) && { return 1; }
+  int operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  int operator()(int) & = delete;
+  int operator()(int) const& = delete;
+  int operator()(int) && = delete;
+  constexpr int operator()(int) const&& { return 1; }
+};
+
+struct NoCopy {
+  int value;
+  explicit NoCopy(int value) : value(value) {}
+  NoCopy(const NoCopy&) = delete;
+};
+
+struct NonConst {
+  int non_const() { return 1; }
+};
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without &qualifier on F'soperator()
+    {
+      std::expected<int, int> e(0);
+      assert(e.transform(LVal{}).value() == 1);
+      using A = decltype(e.transform(LVal{}));
+      using B = std::expected<int, int>;
+      static_assert(std::is_same_v<decltype(e.transform(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e(0);
+      RefQual l{};
+      assert(e.transform(l) == 1);
+      static_assert(std::is_same_v<decltype(e.transform(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      assert(e.transform(CLVal{}).value() == 1);
+      static_assert(std::is_same_v<decltype(e.transform(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      const CRefQual l{};
+      assert(e.transform(l).value() == 1);
+      static_assert(std::is_same_v<decltype(e.transform(l)), std::expected<int, int>>);
+    } 
+  }
+  
+  // Test && overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e(0);
+      assert(std::move(e).transform(RVal{}).value() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(RVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e(0);
+      assert(e.transform(RVRefQual{}).value() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      assert(std::move(e).transform(CRVal{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      const RVCRefQual l{};
+      assert(e.transform(std::move(l)) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+
+constexpr void test_take_val_return_void() {
+  std::expected<int, int> e(1);
+  int val = 0;
+  e.transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, int&>);
+    assert(val == 0);
+    val = 1;
+  });
+  assert(val == 1);
+  std::move(e).transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, int>);
+    assert(val == 1);
+    val = 2;
+  });
+
+  const auto &ce = e;
+  assert(val == 2);
+  ce.transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, const int&>);
+    assert(val == 2);
+    val = 3;
+  });
+  assert(val == 3);
+  std::move(ce).transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, const int>);
+    assert(val == 3);
+    val = 4;
+  });
+  assert(val == 4);
+}
+
+// check val member is direct-non-list-initialized with invoke(std!::!forward<F>(f), value())
+constexpr void test_xval() {
+  struct NonCopyable {
+    constexpr NonCopyable(int i) : i(i) {}
+    NonCopyable(const NonCopyable&) = delete;
+    int i;
+  };
+
+  auto xform = [](int i) { return NonCopyable(i); };
+  std::expected<int, int> e2(2);
+  std::expected<NonCopyable, int> n2 = e2.transform(xform);
+  assert(n2.value().i == 2);
+}
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<NonConst, int> e(std::unexpected<int>(2));
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.transform(l);
+  std::move(e).transform(l);
+
+  std::expected<int, int> e1(std::unexpected<int>(1));
+  const auto& ce1 = e1;
+  const auto never_called = [](int) {
+    assert(false);
+    return std::expected<int, int>();
+  };
+
+  e1.transform(never_called);
+  std::move(e1).transform(never_called);
+  ce1.and_then(never_called);
+  std::move(ce1).transform(never_called);
+}
+
+constexpr bool test() {
+  test_xval();
+  test_sfinae();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform_error(F&& f) &;
+// template<class F> constexpr auto transform_error(F&& f) const &;
+// template<class F> constexpr auto transform_error(F&& f) &&;
+// template<class F> constexpr auto transform_error(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <string_view>
+
+struct LVal {
+  constexpr int operator()(int&) { return 1; }
+  int operator()(const int&)  = delete;
+  int operator()(int&&)       = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  int operator()(int&) = delete;
+  constexpr int operator()(const int&) { return 1; }
+  int operator()(int&&)       = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct RVal {
+  int operator()(int&)       = delete;
+  int operator()(const int&) = delete;
+  constexpr int operator()(int&&) { return 1; }
+  int operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  int operator()(int&)       = delete;
+  int operator()(const int&) = delete;
+  int operator()(int&&)      = delete;
+  constexpr int operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr int operator()(int) & { return 1; }
+  int operator()(int) const&  = delete;
+  int operator()(int) &&      = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  int operator()(int) & = delete;
+  constexpr int operator()(int) const& { return 1; }
+  int operator()(int) &&      = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  int operator()(int) &      = delete;
+  int operator()(int) const& = delete;
+  constexpr int operator()(int) && { return 1; }
+  int operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  int operator()(int) &      = delete;
+  int operator()(int) const& = delete;
+  int operator()(int) &&     = delete;
+  constexpr int operator()(int) const&& { return 1; }
+};
+
+struct NoCopy {
+  int value;
+  explicit NoCopy(int value) : value(value) {}
+  NoCopy(const NoCopy&) = delete;
+};
+
+struct NonConst {
+  int non_const() { return 1; }
+};
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.transform_error(LVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      RefQual l{};
+      assert(e.transform_error(l).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.transform_error(CLVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const CRefQual l{};
+      assert(e.transform_error(l).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test && overload
+  {
+    // Without && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).transform_error(RVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(RVal{})), std::expected<int, int>>);
+    }
+
+    // With && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).transform_error(RVRefQual{}).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).transform_error(CRVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const RVCRefQual l{};
+      assert(std::move(e).transform_error(std::move(l)).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+
+// check val member is direct-non-list-initialized with invoke(std!::!forward<F>(f), value())
+constexpr void test_xval() {
+  struct NonCopyable {
+    constexpr NonCopyable(int i) : i(i) {}
+    NonCopyable(const NonCopyable&) = delete;
+    int i;
+  };
+
+  auto xform = [](int i) { return NonCopyable(i); };
+  std::expected<int, int> e2(std::unexpected<int>(2));
+  std::expected<int, NonCopyable> n2 = e2.transform_error(xform);
+  assert(n2.error().i == 2);
+}
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<int, NonConst> e(2);
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.transform_error(l);
+  std::move(e).transform_error(l);
+}
+
+constexpr void test_fail() {
+  std::expected<int, int> e1;
+  const auto& ce1 = e1;
+
+  const auto never_called = [](int) {
+    assert(false);
+    return 0;
+  };
+
+  e1.transform_error(never_called);
+  std::move(e1).transform_error(never_called);
+  ce1.transform_error(never_called);
+  std::move(ce1).transform_error(never_called);
+}
+
+constexpr bool test() {
+  test_xval();
+  test_fail();
+  test_sfinae();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.expected/observers/error_or.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<class G = E> constexpr E error_or(G&& e) const &;
+// template<class G = E> constexpr E error_or(G&& e) &&;
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+constexpr bool test() {
+  // const &, has_value()
+  {
+    const std::expected<int, int> e(5);
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 10);
+  }
+
+  // const &, !has_value()
+  {
+    const std::expected<int, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 5);
+  }
+
+  // &&, has_value()
+  {
+    std::expected<int, int> e(5);
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 10);
+  }
+
+  // &&, !has_value()
+  {
+    std::expected<int, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 5);
+  }
+
+  return true;
+}
+
+int main(int, char **) {
+  test();
+  static_assert(test());
+}

libcxx/test/std/utilities/expected/expected.void/monadic/and_then.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto and_then(F&& f) &;
+// template<class F> constexpr auto and_then(F&& f) const &;
+// template<class F> constexpr auto and_then(F&& f) &&;
+// template<class F> constexpr auto and_then(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+
+constexpr void test_val_types() {
+
+  // Test & overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    std::expected<void, int> v;
+    assert(v.and_then(l).value() == 2);
+  }
+
+  // Test const& overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    const std::expected<void, int> v;
+    assert(v.and_then(l).value() == 2);
+  }
+
+  // Test && overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    std::expected<void, int> v;
+    assert(std::move(v).and_then(l).value() == 2);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    const std::expected<void, int> v;
+    assert(std::move(v).and_then(l).value() == 2);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    std::expected<void, int> v(std::unexpected<int>(2));
+    assert(v.and_then(f).error() == 2);
+  }
+
+  // Test const& overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    const std::expected<void, int> v(std::unexpected<int>(2));
+    assert(v.and_then(f).error() == 2);
+  }
+
+  // Test && overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    std::expected<void, int> v(std::unexpected<int>(2));
+    assert(std::move(v).and_then(f).error() == 2);
+  }
+
+  // Test const&& overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    const std::expected<void, int> v(std::unexpected<int>(2));
+    assert(std::move(v).and_then(f).error() == 2);
+  }
+}
+
+constexpr bool test() {
+  test_fail();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.void/monadic/or_else.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto or_else(F&& f) &;
+// template<class F> constexpr auto or_else(F&& f) const &;
+// template<class F> constexpr auto or_else(F&& f) &&;
+// template<class F> constexpr auto or_else(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    std::expected<void, int> v(std::unexpected<int>(1));
+    assert(v.or_else(l).has_value());
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    const std::expected<void, int> v(std::unexpected<int>(1));
+    assert(v.or_else(l).has_value());
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    std::expected<void, int> v(std::unexpected<int>(1));
+    assert(std::move(v).or_else(l).has_value());
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    const std::expected<void, int> v(std::unexpected<int>(1));
+    assert(std::move(v).or_else(l).has_value());
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    std::expected<void, int> v;
+    assert(v.or_else(l).has_value());
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    const std::expected<void, int> v;
+    assert(v.or_else(l).has_value());
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).or_else(l).has_value());
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).or_else(l).has_value());
+  }
+}
+
+constexpr bool test() {
+  test_fail();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.void/monadic/transform.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform_error(F&& f) &;
+// template<class F> constexpr auto transform_error(F&& f) const &;
+// template<class F> constexpr auto transform_error(F&& f) &&;
+// template<class F> constexpr auto transform_error(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    std::expected<void, int> v(std::unexpected<int>(1));
+    assert(v.transform_error(l).error() == 1);
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    const std::expected<void, int> v(std::unexpected<int>(1));
+    assert(v.transform_error(l).error() == 1);
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    std::expected<void, int> v(std::unexpected<int>(1));
+    assert(std::move(v).transform_error(l).error() == 1);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    const std::expected<void, int> v(std::unexpected<int>(1));
+    assert(std::move(v).transform_error(l).error() == 1);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    std::expected<void, int> v;
+    assert(v.transform_error(l).has_value());
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    const std::expected<void, int> v;
+    assert(v.transform_error(l).has_value());
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).has_value());
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).has_value());
+  }
+}
+
+constexpr void test_xval() {
+  struct NonCopyable {
+    constexpr NonCopyable(int i) : i(i) { }
+    NonCopyable(const NonCopyable&) = delete;
+    int i;
+  };
+
+  auto x = [](int i) { return NonCopyable(i); };
+  std::expected<void, int> v(std::unexpected<int>(2));
+  std::expected<void, NonCopyable> nv = v.transform_error(x);
+  assert(nv.error().i == 2);
+}
+
+constexpr bool test() {
+  test_fail();
+  test_xval();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.void/monadic/transform_error.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform_error(F&& f) &;
+// template<class F> constexpr auto transform_error(F&& f) const &;
+// template<class F> constexpr auto transform_error(F&& f) &&;
+// template<class F> constexpr auto transform_error(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [](int) -> int { return 1; };
+    std::expected<void, int> v;
+    assert(v.transform_error(l).error() == 1);
+  }
+
+  // Test const& overload
+  {
+    auto l = [] -> int { return 1; };
+    const std::expected<void, int> v;
+    assert(v.transform_error(l).error() == 1);
+  }
+
+  // Test && overload
+  {
+    auto l = [] -> int { return 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).error() == 1);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [] -> int { return 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).error() == 1);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto l = [](int) -> int { throw 1; };
+    std::expected<void, int> v;
+    assert(v.transform_error(l).has_value());
+  }
+
+  // Test const& overload
+  {
+    auto l = [] -> int { throw 1; };
+    const std::expected<void, int> v;
+    assert(v.transform_error(l).has_value());
+  }
+
+  // Test && overload
+  {
+    auto l = [] -> int { throw 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).has_value());
+  }
+
+  // Test const&& overload
+  {
+    auto l = [] -> int { throw 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).has_value());
+  }
+}
+
+constexpr void test_xval() {
+  struct NonCopyable {
+    constexpr NonCopyable(int i) : i(i) { }
+    NonCopyable(const NonCopyable&) = delete;
+    int i;
+  };
+
+  auto x = [](int i) { return NonCopyable(1); };
+  std::expected<void, int> v(std::unexpected<int>(2));
+  std::expected<NonCopyable, int> nv = v.transform_error(x);
+  assert(nv.error().i == 2);
+}
+
+constexpr bool test() {
+  test_fail();
+  test_xval();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<class G = E> constexpr E error_or(G&& e) const &;
+// template<class G = E> constexpr E error_or(G&& e) &&;
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  // const &, has_value()
+  {
+    const std::expected<void, int> e;
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 10);
+  }
+
+  // const &, !has_value()
+  {
+    const std::expected<void, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 5);
+  }
+
+  // &&, has_value()
+  {
+    std::expected<void, int> e;
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 10);
+  }
+
+  // &&, !has_value()
+  {
+    std::expected<void, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 5);
+  }
+
+  return true;
+}
+
+int main(int, char **) {
+  test();
+  static_assert(test());
+}
+