[libc++] Implement `std::expected` P0323R12

[huixie90]

Summary

Implement std::expected https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0323r12.html

Added tests

[huixie90]

libcxx/include/__expected/expected.h

311

clang 14 does not support multiple destructors

613–617

I tried several examples and I could not find an example that the order of these two member affects the size of the class.

[jwakely]

libcxx/include/__expected/expected.h

109

@jwakely Since you co-authored this paper, do you have any insight for me here? I assume I need to be taught something about C++, cause I'm certain there is a reason for this constraint.

The pattern comes from optional's converting ctors, see http://wg21.link/optional.ctor#27 and was added by https://wg21.link/lwg2756 which was originally done for experimental::optional in https://wg21.link/lwg2451 which links to the "Odd" example at https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4064.html#perfect_init as rationale.

IIRC it's there to prevent the ctor being a candidate for such odd types where direct-init would fail but copy-init would succeed.

311

clang 14 does not support multiple destructors

And __cpp_concepts >= 202002L is the correct check for that, as specified by https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2493r0.html

libcxx/include/__expected/unexpected.h

71

I think this here is fine. However, I would like to request that we add a new macro to clearly mark that this is an extension. We could call it _LIBCPP_NOEXCEPT_EXT. That will simply make it clear that it's an extension so we can grep for those.

IIRC MSVC just adds a comment saying // strengthened where they've added a non-required noexcept. That seems much lower overhead than a macro. Why use a macro if you never want it to be defined to anything except noexcept?

Libstdc++ doesn't bother, we just add it where it makes sense. It's just good QoI.

And if the standard says "*Throws*: Nothing." then that means it's required to never throw, so adding it is the right thing to do.

N.B. LEWG have decided to stop following the Lakos Rule, although that direction hasn't been approved at plenary yet. It's the right direction IMHO.

[huixie90]

libcxx/include/__expected/expected.h

631–634

@jwakely Hi Jon, I have noticed that in libstdc++, there is a place holder type as the first type in the union
https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/std/expected#L893

I am trying to understand the purpose of that type. At the first glance, I thought it is for the case where T is not default constructible and we need that type in case we cannot initialise T directly in the expected's constructor's initializer lists.
It turns out that I was wrong and it is possible to have the union uninitialised even if T is not default constructible.
https://godbolt.org/z/9xePvrE4x

So I believe libstdc++ has that dummy type for other reasons. Could you please shed some lights on this?

libcxx/test/std/utilities/expected/expected.expected/ctor/ctor.u.pass.cpp

116–126

@jwakely Hi Jon, thank you very much for commenting on this patch and they are really helpful. While you are here, what do you think about this test case? If I switch bool to int,

std::expected<int, BaseError> e1(5);
std::expected<int, DerivedError> e2(e1);

the other ctor overload

expected(const expected<U, G>&)

will be selected and the int value 5 will be copied.

But for bool, as T (bool) is constructible from the expected, the other overload will be disabled and this overload will be selected

expected(U&&);

so instead of copying the bool (false), it uses operator bool, which is true this case.

Do you think this behaviour is confusing and not very consistent

[jwakely]

libcxx/include/__expected/expected.h

631–634

So I believe libstdc++ has that dummy type for other reasons. Could you please shed some lights on this?

I think it was necessary with older versions of GCC, but isn't needed now. It could be removed.

[EricWF]

Please add a link to the paper in the change description. As well as a meaningful description for the change.
Consider including any information you would want a reader in 5 years to have when they're puzzling over your code.

Also there's no reason to split this up into multiple headers. There are no deps we can cut from other headers by doing so, nor any circular dependency issues we're working around.

Another improvement that can be made is reducing the number of instantiations we perform in a lot of the metaprogramming. _And, _Not, and _Or should only be used when short circuiting is needed. In most cases here it isn't. Every single instantiation performed in expected is carried around by the compiler and in the AST for the entire translation unit. That's costly, lets avoid that cost.

libcxx/include/__expected/bad_expected_access.h

40

Why are we hiding this from the ABI? It's a vtable function, so I don't see how that's even possible?

libcxx/include/__expected/expected.h

70

This needs to be hidden from the ABI. Perhaps always inlined or internal linkage.

76–90

I agree. The short circuiting in the static assert doesn't provide value.

Either it evaluates to the end, or it fails early and the program stops compiling.

So many unnecessary instantiations.

105

Just de morgan this entire thing?

120

Doesn't this have linkage?

223

Shouldn't other.__has_val_ be

594

Is there a reason to not just write the member access into the union? It would save function calls and instantiations, no?

601

Is there a reason to write this using the ternary operator? My spidey senses think that it's easier to read if you don't need to guess at the common type of the operator, and validate that it isn't something weird.

613–617

So the difference is where the padding goes. If the bool comes first the padding goes between the between the bool and the values, potentially causing the type to span over two cache lines or multiple registers.

Whereas if the bool is second, the padding will come after the bool at the end of the type. Which is significantly preferable.

755

I don't think we can do this as it potentially changes the ABI of the type, no?

And that'll be ABI breaking between the two preprocessor branches.

libcxx/include/__expected/unexpected.h

52

Don't write these metaprograms like this.

It's significantly less expensive in terms of compile time, and compiler memory to just turn the results into bools and operate on them that way.

These traits can't blow up when evaluated, so there's no reason to make them lazy.

In fact, we can do away with the entire class like `template <class T> using __valid_unexpected = bool_constant<is_object_v<_Tp> && !is_array<_Tp>...>;`

libcxx/include/__type_traits/is_member_pointer.h

16

What's up with this change?

libcxx/include/__type_traits/is_scalar.h

16

Are these just merge conflicts / weird rebases? Because I don't understand this at all.

libcxx/include/__type_traits/is_void.h

17

What?

libcxx/include/expected

12

Why not define the things that are in this header, in this header?

Is there any reason to split them up? Like dependencies or the like?

Because every additional header comes at a cost, and so it needs to provide value to pay that cost.

libcxx/test/std/utilities/expected/expected.void/ctor/ctor.unexpect_init_list.pass.cpp

56

Is this requires clause necessary for the correctness of the test?

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

34

What does this test?

59

We're missing test coverage on the const&& and & overloads of value().

[EricWF]

libcxx/include/__expected/expected.h

928

Oh god, we can compare error types for equality that don't produce a boolean output. That's terrifying. I assume that's what the standard wants, but that's terrifying.

934

You can avoid the function calls by touching the members directly. That'll save in non-optimized build size.

938

Reverse the order of these members please.

[EricWF]

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

59

Is the deleted constructor not on one of the user-provided types?

66

How do we know any of these diagnostics are triggered by the code above them? You need to add a check that at least some diagnostic is emitted from this line.

[EricWF]

libcxx/include/__expected/expected.h

223

Ignore me. I had a dumb thought, but forgot to delete the comment.

[huixie90]

libcxx/include/__expected/expected.h

76–90

I agree. The short circuiting in the static assert doesn't provide value.

Either it evaluates to the end, or it fails early and the program stops compiling.

So many unnecessary instantiations.

76–90

I agree. The short circuiting in the static assert doesn't provide value.

Either it evaluates to the end, or it fails early and the program stops compiling.

So many unnecessary instantiations.

76–90

I agree. The short circuiting in the static assert doesn't provide value.

Either it evaluates to the end, or it fails early and the program stops compiling.

So many unnecessary instantiations.

This particular thread is not about static_assert. Sorry for the confusion as the code has been rearranged since the beginning of the thread. This thread was about the __can_convert, which has lots of boolean conditions with && and ||. It is not used in static_assert, but used in lots of constructors' constraints.
I do believe shorting circuiting is worth it (see Louis's comment above)

105

could you please clarify? The code has been rearranged since Louis's comment above and it is not clear what line this comment was about

594

The standard spec uses function calls. I did try to change it to direct access but I missed some while copy-pasting from the spec

601

This is how it is specified in the spec. I guess if I wrote in a different way, then it requires the reader to figure out if the way I wrote is equivalent to what is in the spec (the ternary operator)

libcxx/include/__type_traits/is_member_pointer.h

16

clearly, the if condition is not correct. it should be

#if !__has_builtin(__is_member_pointer)

The expected uses this header and I get failures when doing the modular build. This file uses __libcpp_is_member_pointer on line38, but without including the header <__type_traits/is_member_function_pointer.h> that defines it.

libcxx/include/__type_traits/is_scalar.h

16

I believe it was the modular build error message suggested to include this header. I think the actual missing include is

#include <__type_traits/is_null_pointer.h>

libcxx/include/__type_traits/is_void.h

17

yes . this should be

#if !__has_builtin(__is_void)

But the #include <__type_traits/is_same.h> is indeed needed as it is used on line 38.

I am wondering how come I am the only one had issues with these missing includes

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

59

I think the error message contains some implementation detail code that looks like

call to deleted constructor of <some templates> {aka <user defined type>}

I think I can add some regex to include the user defined type

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

34

Yes in this case std::expected<void, T>::value is just returning void without doing anything useful. But we still need to test it to make sure

1. it is implemented (not just declared)
2. it does not throw (as supposed to the error state where it does throw)

[huixie90]

libcxx/test/libcxx/utilities/expected/expected.expected/assert.arrow.pass.cpp

12

It turns out that after removing this, the test does fail on the Apple systems

https://reviews.llvm.org/harbormaster/unit/view/5402162/

[huixie90]

• address feedback

[huixie90]

In D124516#3900680, @EricWF wrote:

Another improvement that can be made is reducing the number of instantiations we perform in a lot of the metaprogramming. _And, _Not, and _Or should only be used when short circuiting is needed. In most cases here it isn't. Every single instantiation performed in expected is carried around by the compiler and in the AST for the entire translation unit. That's costly, lets avoid that cost.

I've removed short circuiting for the static_assert cases. but most meta programming in this patch can benefit from short-circuiting as they are used in the constructors' constraints. (the most complicated one in this patch is the __can_convert @ldionne had some comments explaining why they are needed. (in the early revisions of this patch, there was no short-circuiting)

That being said, I wrote sine simple tests that benchmark the compilation times.

The first one is the case where short circuiting happens

// The 3rd requirement of `__can_convert`
// _Not<is_constructible<_Tp, expected<_Up, _Gp>&>>
// fails and short circuits
template <std::size_t N>
struct Foo {
  Foo() {}

  template <std::size_t M>
  Foo(Foo<M>) {}

  template <std::size_t M, class E>
  Foo(std::expected<Foo<M>, E>) {}
};

template <std::size_t N>
void callCtor() {
  std::expected<Foo<N>, int> e1;
  [[maybe_unused]] std::expected<Foo<N + 1>, int> e2(e1);
}

template <std::size_t... Ns>
void generateTest(std::index_sequence<Ns...>) {
  (callCtor<Ns>(), ...);
}

int main() { generateTest(std::make_index_sequence<1000>{}); }

• With the _And/_Or version, it took *8.9s* to compile.
• With the _BoolConstant<is_xxx_v && ...> version, it took *10.0s* to compile

So we see some benefits of short circuiting (out weighs the instantiation cost)

Then I have another test case where all boolean requirements pass so no short circuiting happening

// All requirements of `__can_convert` pass
// short circuiting has no benefit
template <std::size_t N>
struct Foo {
  Foo() {}

  template <std::size_t M>
  Foo(Foo<M>) {}
};

template <std::size_t N>
void callCtor() {
  std::expected<Foo<N>, int> e1;
  [[maybe_unused]] std::expected<Foo<N + 1>, int> e2(e1);
}

template <std::size_t... Ns>
void generateTest(std::index_sequence<Ns...>) {
  (callCtor<Ns>(), ...);
}

int main() { generateTest(std::make_index_sequence<1000>{}); }

• With the _And/_Or version, it took *8.5s* to compile.
• With the _BoolConstant<is_xxx_v && ...> version, it took *7.3s* to compile

So we know that short circuiting doesn't help because all booleans are true. And the instantiation costs make it slower.

The first case we gain 1.1s and the second case we lost 1.2s. So I am on the boarder line of whether or not to do short circuiting on these constructor constraints. I think in the real case, it is likely that those booleans are all true because if the user calls these converting constructors, it is likely to succeed instead of falling back to the constructor that takes U&&. That means in real user code, the short circuiting might never happen.

[EricWF]

In D124516#3903536, @huixie90 wrote:

In D124516#3900680, @EricWF wrote:

Another improvement that can be made is reducing the number of instantiations we perform in a lot of the metaprogramming. _And, _Not, and _Or should only be used when short circuiting is needed. In most cases here it isn't. Every single instantiation performed in expected is carried around by the compiler and in the AST for the entire translation unit. That's costly, lets avoid that cost.

I've removed short circuiting for the static_assert cases. but most meta programming in this patch can benefit from short-circuiting as they are used in the constructors' constraints. (the most complicated one in this patch is the __can_convert @ldionne had some comments explaining why they are needed. (in the early revisions of this patch, there was no short-circuiting)

That being said, I wrote sine simple tests that benchmark the compilation times.

The first one is the case where short circuiting happens

// The 3rd requirement of `__can_convert`
// _Not<is_constructible<_Tp, expected<_Up, _Gp>&>>
// fails and short circuits
template <std::size_t N>
struct Foo {
  Foo() {}

  template <std::size_t M>
  Foo(Foo<M>) {}

  template <std::size_t M, class E>
  Foo(std::expected<Foo<M>, E>) {}
};

template <std::size_t N>
void callCtor() {
  std::expected<Foo<N>, int> e1;
  [[maybe_unused]] std::expected<Foo<N + 1>, int> e2(e1);
}

template <std::size_t... Ns>
void generateTest(std::index_sequence<Ns...>) {
  (callCtor<Ns>(), ...);
}

int main() { generateTest(std::make_index_sequence<1000>{}); }

• With the _And/_Or version, it took *8.9s* to compile.
• With the _BoolConstant<is_xxx_v && ...> version, it took *10.0s* to compile

So we see some benefits of short circuiting (out weighs the instantiation cost)

Then I have another test case where all boolean requirements pass so no short circuiting happening

// All requirements of `__can_convert` pass
// short circuiting has no benefit
template <std::size_t N>
struct Foo {
  Foo() {}

  template <std::size_t M>
  Foo(Foo<M>) {}
};

template <std::size_t N>
void callCtor() {
  std::expected<Foo<N>, int> e1;
  [[maybe_unused]] std::expected<Foo<N + 1>, int> e2(e1);
}

template <std::size_t... Ns>
void generateTest(std::index_sequence<Ns...>) {
  (callCtor<Ns>(), ...);
}

int main() { generateTest(std::make_index_sequence<1000>{}); }

• With the _And/_Or version, it took *8.5s* to compile.
• With the _BoolConstant<is_xxx_v && ...> version, it took *7.3s* to compile

So we know that short circuiting doesn't help because all booleans are true. And the instantiation costs make it slower.

The first case we gain 1.1s and the second case we lost 1.2s. So I am on the boarder line of whether or not to do short circuiting on these constructor constraints. I think in the real case, it is likely that those booleans are all true because if the user calls these converting constructors, it is likely to succeed instead of falling back to the constructor that takes U&&. That means in real user code, the short circuiting might never happen.

Thank you for looking into this so thoroughly. I should have better specified that my concerns were with meta-programming in static_asserts and other places where all of the conditions were likely to get evaluated. For constraints, I think the opposite is true, and lazy metaprogramming is the way to go.

libcxx/include/__expected/expected.h

76–90

Sorry, it looked like it was attached to the static assert on my end.

For constraints I'm all for lazy evaluation (and think it may even be needed).
But for anything that's going to get evaluated fully anyway, then just do it eagerly.

[ldionne]

libcxx/include/__expected/bad_expected_access.h

40

We played around with it a bit: https://godbolt.org/z/fczzo8q5d

It seems like it doesn't make any difference. The compiler will still emit a virtual call whether it has the attribute always-inline (GCC) or abi-tag (Clang). However, since this method is in the vtable, it arguably can't change in any way it wants, so I think that using _LIBCPP_HIDE_FROM_ABI is misleading in that case. I think we should remove it from what() and from ~bad_expected_access().

I *think* we want to make it visibility=hidden, however, because we don't want people's shared libraries to start exporting this symbol.

Also, as a side note, the actual mangled name of this function doesn't matter too much, because it's almost always accessed as an index into the vtable of bad_expected_access<void>.

libcxx/include/__expected/expected.h

311

We don't often use feature-test macros to check for the availability of stuff. Instead, we check for compiler versions, which allows us to get rid of workarounds as the codebase evolves and we drop support for older compilers.

Yes, I know that's partly why feature-test macros were designed, but I think they provide more value to users than to us given our compiler support policy.

755

I think this is a valid concern, and I seem to have missed that in my review. Thanks a lot for bringing this up.

IMO this means that we can only support compilers where __cpp_concepts >= 202002. If that means that std::expected doesn't work on Clang <= 15, I think that's fine. It'll be a bit annoying to add XFAIL annotations to the expected tests, but concretely it won't change anything for users because we release a matching Clang and libc++. And those XFAIL annotations will be cleaned up as our support window moves.

libcxx/include/expected

12

Speaking with @huixie90 , he split them off originally to aid readability and because they are logically separated classes. That makes sense to me, and IMO the code is easier to understand in its current layout than if we put everything in the same 1300+ lines header.

We often split up much more granularly than this, so I'm not sure the cost of this split here is really meaningful.

27

The synopsis usually comes before all the sub-headers (see for example <optional>).

libcxx/test/libcxx/utilities/expected/expected.expected/assert.arrow.pass.cpp

12

This looks like a bug (in the test suite) to me. We should be defining _LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED whenever we override __libcpp_verbose_abort in the test suite, but we don't.

I think many existing tests are incorrectly using XFAIL.

You can either fix this in a prior patch, or re-add the XFAIL and we can fix all of them in a follow-up patch. I think this is the most reasonable approach to avoid blocking this review on a pre-existing issue.

[huixie90]

• address comment

[huixie90]

rebase

[huixie90]

temporily reverted modules_includes.sh.cpp and headers_declara_verbose_abort.sh.cpp

[huixie90]

rebase

[huixie90]

CI

[ldionne]

libcxx/include/__expected/expected.h

288

434

I would consider moving this to a local lambda of swap too, but it may end up being too nasty since this one is much more complicated than the void case. I'll let you judge.

446

630–631

This feels simpler to me. Also consider rewording the one for non-void T above.

636–643

692–694

Here and to the other overloads below too.

744

This needs to go too!

769–770

Please ensure you have a test for this under libcxx/test/std since this is not an extension (extension noexcepts should be tested too, though). I guess what I mean is "please test all the noexcepts, whether they are extensions or not".

800–801

I am going to be suuuuper pedantic and request a test that we're doing things in the right order here. Basically, if the construction of unex throws, we must not have engaged *this, and the spec is explicit about this because they describe this operation as

construct_at(addressof(unex), std::move(rhs.unex));
has_val = false;

This is a bit nitpicky, but I think it would be nice to have a test that fails if we reorder these two statements. This also applies to the const& overload above and to the converting overloads below. If there's a uniform way of testing that requirement, feel free to jam all the test cases for this property into the same file to reduce duplication.

818–819

Also here, a test for the order of statements.

830–831

Same, order of statements.

846

I would suggest doing this instead:

... decl ... {
  auto __swap_impl = [](auto& __with_val, auto& __with_err) {
    std::construct_at(std::addressof(__with_val.__unex_), std::move(__with_err.__unex_));
    std::destroy_at(std::addressof(__with_err.__unex_));
    __with_val.__has_val_ = false;
    __with_err.__has_val_ = true;
  };

  if (__has_val_) {
      if (!__rhs.__has_val_) {
        __swap_impl(*this, __rhs);
    }
  }
}

And then you can get rid of __swap_val_unex_impl. If you don't get rid of it, at least please move it close so we can see the definition.

850

Can you make sure you have a test where you swap and the error throws when being moved out-of, and ensure that:

1. We have not changed the has_value() for either of the expecteds
2. And also that the expected that contained an Err before still does, and that the Err has not been destroyed. An implementation failing this would be silly overcomplicated, but let's still check this.

864

Please make sure you have tests that check that this is "equivalent to" the member swap, i.e. that the same constraints apply. This should be SFINAE friendly if the member swap can't be used, basically.

libcxx/include/__expected/unexpected.h

71

IIRC MSVC just adds a comment saying // strengthened where they've added a non-required noexcept.

I'd be fine with that too. I just want a visual cue that something is an extension.

libcxx/test/libcxx/utilities/expected/expected.expected/assert.arrow.pass.cpp

2

Not attached to a line: I think this should fix your CI issues:

// Older Clangs do not support the C++20 feature to constrain destructors
// XFAIL: clang-14, apple-clang-14

[ldionne]

libcxx/include/__expected/expected.h

55–57

IMO the simplicity of always having the same set of transitive includes outweighs the additional <cstdlib> include, especially since I think most users will end up including that header anyway. I would just include this header unconditionally.

620–621

Can we use [[no_unique_address]] here? Can you investigate how that attribute interacts with unions? Also, does it make sense to put it on the union itself?

870

Please make sure you check that this is explicit, i.e. an implicit conversion to bool should fail.

884

927–930

Let's match the order of members in the non-void case.

929

Same comment for no_unique_address.

libcxx/include/__expected/unexpected.h

71

Can you please add a test for this default template argument? See Jonathan's comment above explaining where this comes from.

120–121

Please ensure you have tests for this deduction guide.

libcxx/include/__type_traits/is_member_pointer.h

16–18

Likewise here, I wouldn't bother with the conditional include. We'll eventually be able to remove it anyway once all supported compilers implement the builtin.

libcxx/include/__type_traits/is_nothrow_constructible.h

15–18 ↗

(On Diff #477004)

Same

libcxx/include/__type_traits/is_void.h

17–20

Same

libcxx/include/expected

54

[jwakely]

libcxx/include/__expected/expected.h

55–57

Another option would be to use __builtin_abort() which requires no header.

[huixie90]

more CI

[huixie90]

CI

[huixie90]

libcxx/include/__expected/expected.h

620–621

Here is my finding.

For anonymous union (which is the case in the expected, I can't find a way to make [[no_unique_address]] to have any effect
https://godbolt.org/z/zebh4E94d

For a named union, if we apply [[no_unique_address]] on the union itself plus all the members of the union, we can save some space.
https://godbolt.org/z/rGoa7c47d

So I think we don't need to do anything here

[huixie90]

more CI

[huixie90]

address comments

[huixie90]

libcxx/include/__expected/expected.h

864

noexcept does not seem to do SFINAE here. I need to constrain it with requires
https://godbolt.org/z/E15jK4Ter

[huixie90]

CI

[huixie90]

next try

[huixie90]

next try CI

[ldionne]

I'm still going to request changes because of the no_unique_address thing, but this basically LGTM.

Thanks a lot for the great patch and the great collaboration on this review. I'm extremely happy with the patch and in particular with the fact that we carefully considered the testing coverage during our review of the class itself (e.g. order of operations in assignment, etc.).

libcxx/include/__expected/expected.h

55–57

That's interesting, I never thought of doing that. For this review, I think we should use std::abort to be consistent with what we do everywhere else. And then we should review all places in the library where we use std::abort (which is all the potentially-exception-throwing functions) and see whether we can/should use __builtin_abort instead.

620–621

I would suggest using a named union instead so that we can apply [[no_unique_address]] to the member.

For unnamed unions, it looks like the compiler is applying the attribute to the union type declaration (not the member declaration). Since [[no_unique_address]] applies only to member declarations, the attribute ends up being ignored when used on an unnamed union.

Also, once that's implemented, let's add a libcxx-specific test that this optimization kicks in as intended.

864

I stand corrected. I was *certain* noexcept was an immediate context that you could SFINAE on. TIL.

I think what you have now with requires requires is right. It's OK if it fails with clang-15, let's just add the appropriate XFAILs and we'll remove them when we drop support for 15.

libcxx/test/libcxx/utilities/expected/expected.expected/noexcept.extension.compile.pass.cpp

19

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

50

To get rid of these spurious errors, I would look into this:

// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error

See for example libcxx/test/libcxx/atomics/atomics.syn/incompatible_with_stdatomic.verify.cpp.

66

@huixie90 I would suggest moving this to the same line that you're expecting the error (i.e. current line 65) and dropping *:*, which tells clang that the error can be on any line of any file (file:line`). Like this:

std::move(f1).value_or(5); // expected-error-re {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to value_type}}

That will make for a long line, but it does exactly what I think you want.

libcxx/test/std/utilities/expected/expected.expected/assign/assign.copy.pass.cpp

284

libcxx/test/std/utilities/expected/expected.expected/assign/emplace.pass.cpp

52

Do we not need exceptions-related tests here to make sure we perform operations in the right order?

Please go through all the operations of both the void and the non-void specializations. This is a very high bar, but I think it's worth doing it.

libcxx/test/std/utilities/expected/expected.expected/ctor/ctor.u.pass.cpp

116–126

This seems surprising to me. It seems like this might not have been the design intent. @jfb perhaps you can comment on this?

Is this worth a LWG issue?

libcxx/test/std/utilities/expected/expected.unexpected/class_mandates/const.compile.fail.cpp

1 ↗

(On Diff #478095)

Please make this into a verify.cpp. We're trying to move away from compile.fail.cpp tests because it's too easy to write a test that fails for an unrelated reason.

Applies to all.

[huixie90]

named union and no_unique_address

[huixie90]

tidy up

[huixie90]

tidy up

[jwakely]

libcxx/include/__expected/expected.h

864

I stand corrected. I was *certain* noexcept was an immediate context that you could SFINAE on. TIL.

No, [temp.deduct.general] p7 is very explicit about that. noexcept doesn't participate in overload resolution, and doesn't even need to be instantiated unless checked ([temp.inst] p14).

libcxx/test/std/utilities/expected/expected.expected/ctor/ctor.u.pass.cpp

116–126

The rules are supposed to allow initialization of a result type that can be constructed from expected, but because expected<T,U> is always contextually convertible to bool, that kicks in here. This reminds me of https://wg21.link/p0608 where we also needed to exclude bool from being greedy. It shouldn't be a problem for anything other than bool.

Please do file a library issue, thanks.

[huixie90]

CI

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

66

For some reason, this does not work and the compiler thinks the error was emitted from expected.h instead of this particular line in the test

error: 'error' diagnostics expected but not seen: 
  File /Users/huixie/repos/libc++/llvm-project/libcxx/test/libcxx/utilities/expected/expected.expected/value_or.mandates.verify.cpp Line 38: {{(static_assert|static assertion)}} failed {{.*}}value_type has to be copy constructible
error: 'error' diagnostics seen but not expected: 
  File /Users/huixie/repos/libc++/llvm-project/build/include/c++/v1/__expected/expected.h Line 595: static assertion failed due to requirement 'is_copy_constructible_v<NonCopyable>': value_type has to be copy constructible

[huixie90]

address remaining comments

libcxx/test/std/utilities/expected/expected.expected/assign/emplace.pass.cpp

52

turns out that the emplace function requires is_nothrow_constructible_v so we don't need a runtime tests. (there are compile time tests above to test that if it can throw , there will be no emplace function)

[huixie90]

CI

[ldionne]

@huixie90 Thank you so much for this great patch. It's not an easy one but I'm extremely happy with the state it has reached now, and I think we've addressed everyone's comments. I'm excited to ship this in LLVM 16!

I still left a few comments for minor nits, but feel free to ship this once they are addressed.

Thank you, and thanks to other folks who chimed in on the review!

libcxx/include/__expected/expected.h

643–645

864

Thanks for the ref and for schooling me :-).

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

66

I actually think that's expected, in retrospect. This is what happens for all of our static_assert tests. I think what you've got right now is fine, but if you wanted, you could also pin this down a bit more by:

1. Using //expected-error-re@expected.h:* to make sure that the static_assert doesn't come from e.g. <vector> (not sure how useful that is, but you could)
2. Adding //expected-note {{in instantiation}} (you might have to figure out the right content inside {{}}) on the line of the std::move(...).value_or(...) call. That would ensure that Clang did indeed generate *some* diagnostic starting on that line. I think that would be way sufficient.

FWIW, I'm happy with the test as-is too.

libcxx/test/std/utilities/expected/expected.expected/ctor/ctor.u.pass.cpp

116–126

Thanks for confirming. @huixie90 Can you please add a link to the LWG issue in the comment above?

[huixie90]

rebase

[huixie90]

CI

[huixie90]

CI

libcxx/include/__expected/bad_expected_access.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
+#define _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
+
+#include <__config>
+#include <__utility/move.h>
+
+#include <exception>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Err>
+class bad_expected_access;
+
+template <>
+class bad_expected_access<void> : public exception {
+protected:
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access() noexcept                             = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access(const bad_expected_access&)            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access(bad_expected_access&&)                 = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(const bad_expected_access&) = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(bad_expected_access&&)      = default;
+  ~bad_expected_access() override                                                  = default;
+
+public:
+  // The way this has been designed (by using a class template below) means that we'll already
+  // have a profusion of these vtables in TUs, and the dynamic linker will already have a bunch
+  // of work to do. So it is not worth hiding the <void> specialization in the dylib, given that
+  // it adds deployment target restrictions.
+  const char* what() const noexcept override { return "bad access to std::expected"; }
+};
+
+template <class _Err>
+class bad_expected_access : public bad_expected_access<void> {
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit bad_expected_access(_Err __e) : __unex_(std::move(__e)) {}
+
+  _LIBCPP_HIDE_FROM_ABI _Err& error() & noexcept { return __unex_; }
+  _LIBCPP_HIDE_FROM_ABI const _Err& error() const& noexcept { return __unex_; }
+  _LIBCPP_HIDE_FROM_ABI _Err&& error() && noexcept { return std::move(__unex_); }
+  _LIBCPP_HIDE_FROM_ABI const _Err&& error() const&& noexcept { return std::move(__unex_); }
+
+private:
+  _Err __unex_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H

libcxx/include/__expected/expected.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_EXPECTED_H
+#define _LIBCPP___EXPECTED_EXPECTED_H
+
+#include <__assert>
+#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/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/is_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_copy_assignable.h>
+#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/is_void.h>
+#include <__type_traits/lazy.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 <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
+
+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));
+#  else
+  (void)__arg;
+  std::abort();
+#  endif
+}
+
+} // 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
+    requires is_default_constructible_v<_Tp>
+      : __has_val_(true) {
+    std::construct_at(std::addressof(__union_.__val_));
+  }
+
+  _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_);
+    } else {
+      std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__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_));
+    } else {
+      std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__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_);
+    } else {
+      std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__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_));
+    } else {
+      std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__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));
+  }
+
+
+  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());
+  }
+
+  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()));
+  }
+
+  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)...);
+  }
+
+  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)...);
+  }
+
+  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)...);
+  }
+
+  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)...);
+  }
+
+  // [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_));
+    } else {
+      std::destroy_at(std::addressof(__union_.__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)...);
+    } 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));
+    } 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)...);
+      __trans.__complete();
+    }
+  }
+
+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_;
+    } else if (__has_val_) {
+      __reinit_expected(__union_.__unex_, __union_.__val_, __rhs.__union_.__unex_);
+    } else if (__rhs.__has_val_) {
+      __reinit_expected(__union_.__val_, __union_.__unex_, __rhs.__union_.__val_);
+    } else {
+      __union_.__unex_ = __rhs.__union_.__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_);
+    } else if (__has_val_) {
+      __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__rhs.__union_.__unex_));
+    } else if (__rhs.__has_val_) {
+      __reinit_expected(__union_.__val_, __union_.__unex_, std::move(__rhs.__union_.__val_));
+    } else {
+      __union_.__unex_ = std::move(__rhs.__union_.__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);
+    } else {
+      __reinit_expected(__union_.__val_, __union_.__unex_, std::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());
+      __has_val_ = false;
+    } else {
+      __union_.__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()));
+      __has_val_ = false;
+    } else {
+      __union_.__unex_ = std::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_));
+    } else {
+      std::destroy_at(std::addressof(__union_.__unex_));
+      __has_val_ = true;
+    }
+    return *std::construct_at(std::addressof(__union_.__val_), std::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_));
+    } else {
+      std::destroy_at(std::addressof(__union_.__unex_));
+      __has_val_ = true;
+    }
+    return *std::construct_at(std::addressof(__union_.__val_), __il, std::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_));
+        __transaction __trans([&] {
+          std::construct_at(std::addressof(__with_err.__union_.__unex_), std::move(__tmp));
+        });
+        std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__with_val.__union_.__val_));
+        __trans.__complete();
+        std::destroy_at(std::addressof(__with_val.__union_.__val_));
+        std::construct_at(std::addressof(__with_val.__union_.__unex_), std::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_));
+        __trans.__complete();
+        std::destroy_at(std::addressof(__with_err.__union_.__unex_));
+        std::construct_at(std::addressof(__with_err.__union_.__val_), std::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_);
+      } 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_);
+      }
+    }
+  }
+
+  _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_);
+  }
+
+  _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_);
+  }
+
+  _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_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept {
+    _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+    return __union_.__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_);
+  }
+
+  _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_);
+  }
+
+  _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_);
+    }
+    return __union_.__val_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & {
+    if (!__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+    }
+    return __union_.__val_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& value() const&& {
+    if (!__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+    }
+    return std::move(__union_.__val_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && {
+    if (!__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+    }
+    return std::move(__union_.__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_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
+    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+    return __union_.__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_);
+  }
+
+  _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_);
+  }
+
+  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));
+  }
+
+  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));
+  }
+
+  // [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_;
+      } else {
+        return __x.__union_.__unex_ == __y.__union_.__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);
+  }
+
+  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());
+  }
+
+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_;
+
+  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>>>>;
+
+public:
+  using value_type      = _Tp;
+  using error_type      = _Err;
+  using unexpected_type = unexpected<_Err>;
+
+  template <class _Up>
+  using rebind = expected<_Up, error_type>;
+
+  // [expected.void.ctor], constructors
+  _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __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<_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_);
+    }
+  }
+
+  _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_));
+    }
+  }
+
+  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_);
+    }
+  }
+
+  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_));
+    }
+  }
+
+  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());
+  }
+
+  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()));
+  }
+
+  _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)...);
+  }
+
+  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)...);
+  }
+
+  // [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_));
+    }
+  }
+
+  // [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_);
+        __has_val_ = false;
+      }
+    } else {
+      if (__rhs.__has_val_) {
+        std::destroy_at(std::addressof(__union_.__unex_));
+        __has_val_ = true;
+      } else {
+        __union_.__unex_ = __rhs.__union_.__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_));
+        __has_val_ = false;
+      }
+    } else {
+      if (__rhs.__has_val_) {
+        std::destroy_at(std::addressof(__union_.__unex_));
+        __has_val_ = true;
+      } else {
+        __union_.__unex_ = std::move(__rhs.__union_.__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());
+      __has_val_ = false;
+    } else {
+      __union_.__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()));
+      __has_val_ = false;
+    } else {
+      __union_.__unex_ = std::move(__un.error());
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept {
+    if (!__has_val_) {
+      std::destroy_at(std::addressof(__union_.__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_));
+      __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_);
+      }
+    }
+  }
+
+  _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_);
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void value() && {
+    if (!__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__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_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
+    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+    return __union_.__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_);
+  }
+
+  _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_);
+  }
+
+  // [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_);
+    }
+  }
+
+  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());
+  }
+
+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_;
+
+  bool __has_val_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_EXPECTED_H

libcxx/include/__expected/unexpected.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_UNEXPECTED_H
+#define _LIBCPP___EXPECTED_UNEXPECTED_H
+
+#include <__config>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/negation.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 <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 _Err>
+class unexpected;
+
+namespace __unexpected {
+
+template <class _Tp>
+struct __is_unexpected : false_type {};
+
+template <class _Err>
+struct __is_unexpected<unexpected<_Err>> : true_type {};
+
+template <class _Tp>
+using __valid_unexpected = _BoolConstant< //
+    is_object_v<_Tp> &&                   //
+    !is_array_v<_Tp> &&                   //
+    !__is_unexpected<_Tp>::value &&       //
+    !is_const_v<_Tp> &&                   //
+    !is_volatile_v<_Tp>                   //
+    >;
+
+} // namespace __unexpected
+
+template <class _Err>
+class unexpected {
+  static_assert(__unexpected::__valid_unexpected<_Err>::value,
+                "[expected.un.general] states a program that instantiates std::unexpected for a non-object type, an "
+                "array type, a specialization of unexpected, or a cv-qualified type is ill-formed.");
+
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected(const unexpected&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected(unexpected&&)      = default;
+
+  template <class _Error = _Err>
+    requires(!is_same_v<remove_cvref_t<_Error>, unexpected> && //
+             !is_same_v<remove_cvref_t<_Error>, in_place_t> && //
+             is_constructible_v<_Err, _Error>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(_Error&& __error) //
+      noexcept(is_nothrow_constructible_v<_Err, _Error>)                // strengthened
+      : __unex_(std::forward<_Error>(__error)) {}
+
+  template <class... _Args>
+    requires is_constructible_v<_Err, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, _Args&&... __args) //
+      noexcept(is_nothrow_constructible_v<_Err, _Args...>)                           // strengthened
+      : __unex_(std::forward<_Args>(__args)...) {}
+
+  template <class _Up, class... _Args>
+    requires is_constructible_v<_Err, initializer_list<_Up>&, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) //
+      noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
+      : __unex_(__il, std::forward<_Args>(__args)...) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(const unexpected&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(unexpected&&)      = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { return __unex_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { return __unex_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { return std::move(__unex_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { return std::move(__unex_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Err>) {
+    static_assert(is_swappable_v<_Err>, "unexpected::swap requires is_swappable_v<E> to be true");
+    using std::swap;
+    swap(__unex_, __other.__unex_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(unexpected& __x, unexpected& __y) noexcept(noexcept(__x.swap(__y)))
+    requires is_swappable_v<_Err>
+  {
+    __x.swap(__y);
+  }
+
+  template <class _Err2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const unexpected& __x, const unexpected<_Err2>& __y) {
+    return __x.__unex_ == __y.__unex_;
+  }
+
+private:
+  _Err __unex_;
+};
+
+template <class _Err>
+unexpected(_Err) -> unexpected<_Err>;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_UNEXPECTED_H

libcxx/include/__type_traits/is_member_pointer.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H
 #define _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
+#include <__type_traits/is_member_function_pointer.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_member_pointer)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
 

libcxx/include/__type_traits/is_scalar.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_SCALAR_H
 #define _LIBCPP___TYPE_TRAITS_IS_SCALAR_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_arithmetic.h>
 #include <__type_traits/is_enum.h>
 #include <__type_traits/is_member_pointer.h>
+#include <__type_traits/is_null_pointer.h>
 #include <__type_traits/is_pointer.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__type_traits/is_void.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_VOID_H
 #define _LIBCPP___TYPE_TRAITS_IS_VOID_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_void)
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { };
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/expected

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPECTED
+#define _LIBCPP_EXPECTED
+
+/*
+  Header <expected> synopsis
+
+namespace std {
+  // [expected.unexpected], class template unexpected
+  template<class E> class unexpected;
+
+  // [expected.bad], class template bad_expected_access
+  template<class E> class bad_expected_access;
+
+  // [expected.bad.void], specialization for void
+  template<> class bad_expected_access<void>;
+
+  // in-place construction of unexpected values
+  struct unexpect_t {
+    explicit unexpect_t() = default;
+  };
+  inline constexpr unexpect_t unexpect{};
+
+  // [expected.expected], class template expected
+  template<class T, class E> class expected;
+
+  // [expected.void], partial specialization of expected for void types
+  template<class T, class E> requires is_void_v<T> class expected<T, E>;
+}
+
+*/
+
+#include <__assert> // all public C++ headers provide the assertion handler
+#include <__config>
+#include <__expected/bad_expected_access.h>
+#include <__expected/expected.h>
+#include <__expected/unexpect.h>
+#include <__expected/unexpected.h>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#endif // _LIBCPP_EXPECTED
+

libcxx/test/libcxx/utilities/expected/expected.expected/assert.arrow.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// constexpr const T* operator->() const noexcept;
+// constexpr T* operator->() noexcept;
+//
+// Preconditions: has_value() is true.
+
+#include <expected>
+#include <utility>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  std::expected<int, int> e{std::unexpect, 5};
+  TEST_LIBCPP_ASSERT_FAILURE(e.operator->(), "expected::operator-> requires the expected to contain a value");
+  TEST_LIBCPP_ASSERT_FAILURE(std::as_const(e).operator->(), "expected::operator-> requires the expected to contain a value");
+
+  return 0;
+}

libcxx/test/libcxx/utilities/expected/expected.expected/noexcept.extension.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
+
+// test libc++ noexcept extensions on operations of std::expected<T, E>
+
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "../types.h"
+
+// expected();
+static_assert(std::is_nothrow_default_constructible_v<std::expected<int, int>>);
+static_assert(!std::is_nothrow_default_constructible_v<std::expected<DefaultMayThrow, int>>);
+
+// expected(const expected&)
+static_assert(std::is_nothrow_copy_constructible_v<std::expected<int, int>>);
+static_assert(!std::is_nothrow_copy_constructible_v<std::expected<CopyMayThrow, int>>);
+static_assert(!std::is_nothrow_copy_constructible_v<std::expected<int, CopyMayThrow>>);
+
+// expected(const expected<OtherT, OtherE>&)
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<long, long>,
+              const std::expected<int, int>&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<ConvertFromCopyIntMayThrow, long>,
+              const std::expected<int, int>&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<long, ConvertFromCopyIntMayThrow>,
+              const std::expected<int, int>&>);
+static_assert(!std::is_nothrow_constructible_v<                                      //
+              std::expected<ConvertFromCopyIntMayThrow, ConvertFromCopyIntMayThrow>, //
+              const std::expected<int, int>&>);
+
+// expected(expected<OtherT, OtherE>&&)
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<long, long>,
+              std::expected<int, int>&&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<ConvertFromMoveIntMayThrow, long>,
+              std::expected<int, int>&&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<long, ConvertFromMoveIntMayThrow>,
+              std::expected<int, int>&&>);
+static_assert(!std::is_nothrow_constructible_v<                                      //
+              std::expected<ConvertFromMoveIntMayThrow, ConvertFromMoveIntMayThrow>, //
+              std::expected<int, int>&&>);
+
+// expected(U&&)
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<int, int>,
+              const int&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<ConvertFromCopyIntMayThrow, int>,
+              const int&>);
+
+// expected(const unexpected<OtherE>&)
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<int, long>,
+              const std::unexpected<int>&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<int, ConvertFromCopyIntMayThrow>,
+              const std::unexpected<int>&>);
+
+// expected(unexpected<OtherE>&&)
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<int, long>,
+              std::unexpected<int>&&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<int, ConvertFromMoveIntMayThrow>,
+              std::unexpected<int>&&>);
+
+// expected(in_place_t, _Args&&...);
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<int, int>,
+              std::in_place_t,
+              const int&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<ConvertFromCopyIntMayThrow, int>,
+              std::in_place_t,
+              const int&>);
+
+// expected(in_place_t, initializer_list<U>, _Args&&...);
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<ConvertFromInitializerListNoexcept, int>,
+              std::in_place_t,
+              std::initializer_list<int>>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<ConvertFromInitializerListMayThrow, int>,
+              std::in_place_t,
+              std::initializer_list<int>>);
+
+// expected(unexpect_t, _Args&&...);
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<int, int>,
+              std::unexpect_t,
+              const int&>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<int, ConvertFromCopyIntMayThrow>,
+              std::unexpect_t,
+              const int&>);
+
+// expected(unexpect_t, initializer_list<U>, _Args&&...);
+static_assert(std::is_nothrow_constructible_v< //
+              std::expected<int, ConvertFromInitializerListNoexcept>,
+              std::unexpect_t,
+              std::initializer_list<int>>);
+static_assert(!std::is_nothrow_constructible_v< //
+              std::expected<int, ConvertFromInitializerListMayThrow>,
+              std::unexpect_t,
+              std::initializer_list<int>>);
+
+// expected& operator=(const expected&)
+static_assert(std::is_nothrow_copy_assignable_v<std::expected<int, int>>);
+static_assert(!std::is_nothrow_copy_assignable_v<std::expected<CopyConstructMayThrow, int>>);
+static_assert(!std::is_nothrow_copy_assignable_v<std::expected<CopyAssignMayThrow, int>>);
+static_assert(!std::is_nothrow_copy_assignable_v<std::expected<int, CopyConstructMayThrow>>);
+static_assert(!std::is_nothrow_copy_assignable_v<std::expected<int, CopyAssignMayThrow>>);

libcxx/test/libcxx/utilities/expected/expected.expected/value_or.mandates.verify.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
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
+
+// Test the mandates
+// template<class U> constexpr T value_or(U&& v) const &;
+// Mandates: is_copy_constructible_v<T> is true and is_convertible_v<U, T> is true.
+
+// template<class U> constexpr T value_or(U&& v) &&;
+// Mandates: is_move_constructible_v<T> is true and is_convertible_v<U, T> is true.
+
+#include <expected>
+#include <utility>
+
+struct NonCopyable {
+  NonCopyable(int) {}
+  NonCopyable(const NonCopyable&) = delete;
+};
+
+struct NonMovable {
+  NonMovable(int) {}
+  NonMovable(NonMovable&&) = delete;
+};
+
+struct NotConvertibleFromInt {};
+
+void test() {
+  // const & overload
+  // !is_copy_constructible_v<T>,
+  {
+    const std::expected<NonCopyable, int> f1{5};
+    f1.value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected<NonCopyable, int>::value_or<int>' requested here}}
+    // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}value_type has to be copy constructible}}
+  }
+
+  // const & overload
+  // !is_convertible_v<U, T>
+  {
+    const std::expected<NotConvertibleFromInt, int> f1{std::in_place};
+    f1.value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected<NotConvertibleFromInt, int>::value_or<int>' requested here}}
+    //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to value_type}}
+  }
+
+  // && overload
+  // !is_move_constructible_v<T>,
+  {
+    std::expected<NonMovable, int> f1{5};
+    std::move(f1).value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected<NonMovable, int>::value_or<int>' requested here}}
+    //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}value_type has to be move constructible}}
+  }
+
+  // && overload
+  // !is_convertible_v<U, T>
+  {
+    std::expected<NotConvertibleFromInt, int> f1{std::in_place};
+    std::move(f1).value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected<NotConvertibleFromInt, int>::value_or<int>' requested here}}
+    //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to value_type}}
+  }
+}

libcxx/test/std/utilities/expected/expected.expected/assign/assign.copy.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
+
+// Older Clangs do not support the C++20 feature to constrain destructors
+// XFAIL: clang-14, apple-clang-14
+
+// constexpr expected& operator=(const expected& rhs);
+//
+// Effects:
+// - If this->has_value() && rhs.has_value() is true, equivalent to val = *rhs.
+// - Otherwise, if this->has_value() is true, equivalent to:
+//  reinit-expected(unex, val, rhs.error())
+// - Otherwise, if rhs.has_value() is true, equivalent to:
+//  reinit-expected(val, unex, *rhs)
+// - Otherwise, equivalent to unex = rhs.error().
+//
+// - Then, if no exception was thrown, equivalent to: has_val = rhs.has_value(); return *this;
+//
+// Returns: *this.
+//
+// Remarks: This operator is defined as deleted unless:
+// - is_copy_assignable_v<T> is true and
+// - is_copy_constructible_v<T> is true and
+// - is_copy_assignable_v<E> is true and
+// - is_copy_constructible_v<E> is true and
+// - is_nothrow_move_constructible_v<T> || is_nothrow_move_constructible_v<E> is true.
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "../../types.h"
+#include "test_macros.h"
+
+struct NotCopyConstructible {
+  NotCopyConstructible(const NotCopyConstructible&)            = delete;
+  NotCopyConstructible& operator=(const NotCopyConstructible&) = default;
+};
+
+struct NotCopyAssignable {
+  NotCopyAssignable(const NotCopyAssignable&)            = default;
+  NotCopyAssignable& operator=(const NotCopyAssignable&) = delete;
+};
+
+struct MoveMayThrow {
+  MoveMayThrow(MoveMayThrow const&)            = default;
+  MoveMayThrow& operator=(const MoveMayThrow&) = default;
+  MoveMayThrow(MoveMayThrow&&) noexcept(false) {}
+  MoveMayThrow& operator=(MoveMayThrow&&) noexcept(false) { return *this; }
+};
+
+// Test constraints
+static_assert(std::is_copy_assignable_v<std::expected<int, int>>);
+
+// !is_copy_assignable_v<T>
+static_assert(!std::is_copy_assignable_v<std::expected<NotCopyAssignable, int>>);
+
+// !is_copy_constructible_v<T>
+static_assert(!std::is_copy_assignable_v<std::expected<NotCopyConstructible, int>>);
+
+// !is_copy_assignable_v<E>
+static_assert(!std::is_copy_assignable_v<std::expected<int, NotCopyAssignable>>);
+
+// !is_copy_constructible_v<E>
+static_assert(!std::is_copy_assignable_v<std::expected<int, NotCopyConstructible>>);
+
+// !is_nothrow_move_constructible_v<T> && is_nothrow_move_constructible_v<E>
+static_assert(std::is_copy_assignable_v<std::expected<MoveMayThrow, int>>);
+
+// is_nothrow_move_constructible_v<T> && !is_nothrow_move_constructible_v<E>
+static_assert(std::is_copy_assignable_v<std::expected<int, MoveMayThrow>>);
+
+// !is_nothrow_move_constructible_v<T> && !is_nothrow_move_constructible_v<E>
+static_assert(!std::is_copy_assignable_v<std::expected<MoveMayThrow, MoveMayThrow>>);
+
+constexpr bool test() {
+  // If this->has_value() && rhs.has_value() is true, equivalent to val = *rhs.
+  {
+    Traced::state oldState{};
+    Traced::state newState{};
+    std::expected<Traced, int> e1(std::in_place, oldState, 5);
+    const std::expected<Traced, int> e2(std::in_place, newState, 10);
+    decltype(auto) x = (e1 = e2);
+    static_assert(std::same_as<decltype(x), std::expected<Traced, int>&>);
+    assert(&x == &e1);
+
+    assert(e1.has_value());
+    assert(e1.value().data_ == 10);
+    assert(oldState.copyAssignCalled);
+  }
+
+  // - Otherwise, if this->has_value() is true, equivalent to:
+  // reinit-expected(unex, val, rhs.error())
+  //  E move is not noexcept
+  //  In this case, it should call the branch
+  //
+  //  U tmp(std::move(oldval));
+  //  destroy_at(addressof(oldval));
+  //  try {
+  //    construct_at(addressof(newval), std::forward<Args>(args)...);
+  //  } catch (...) {
+  //    construct_at(addressof(oldval), std::move(tmp));
+  //    throw;
+  //  }
+  //
+  {
+    TracedNoexcept::state oldState{};
+    Traced::state newState{};
+    std::expected<TracedNoexcept, Traced> e1(std::in_place, oldState, 5);
+    const std::expected<TracedNoexcept, Traced> e2(std::unexpect, newState, 10);
+
+    decltype(auto) x = (e1 = e2);
+    static_assert(std::same_as<decltype(x), std::expected<TracedNoexcept, Traced>&>);
+    assert(&x == &e1);
+
+    assert(!e1.has_value());
+    assert(e1.error().data_ == 10);
+
+    assert(!oldState.copyAssignCalled);
+    assert(oldState.moveCtorCalled);
+    assert(oldState.dtorCalled);
+    assert(!oldState.copyCtorCalled);
+    assert(newState.copyCtorCalled);
+    assert(!newState.moveCtorCalled);
+    assert(!newState.dtorCalled);
+  }
+
+  // - Otherwise, if this->has_value() is true, equivalent to:
+  // reinit-expected(unex, val, rhs.error())
+  //  E move is noexcept
+  //  In this case, it should call the branch
+  //
+  //  destroy_at(addressof(oldval));
+  //  construct_at(addressof(newval), std::forward<Args>(args)...);
+  //
+  {
+    Traced::state oldState{};
+    TracedNoexcept::state newState{};
+    std::expected<Traced, TracedNoexcept> e1(std::in_place, oldState, 5);
+    const std::expected<Traced, TracedNoexcept> e2(std::unexpect, newState, 10);
+
+    decltype(auto) x = (e1 = e2);
+    static_assert(std::same_as<decltype(x), std::expected<Traced, TracedNoexcept>&>);
+    assert(&x == &e1);
+
+    assert(!e1.has_value());
+    assert(e1.error().data_ == 10);
+
+    assert(!oldState.copyAssignCalled);
+    assert(!oldState.moveCtorCalled);
+    assert(oldState.dtorCalled);
+    assert(!oldState.copyCtorCalled);
+    assert(newState.copyCtorCalled);
+    assert(!newState.moveCtorCalled);
+    assert(!newState.dtorCalled);
+  }
+
+  // - Otherwise, if rhs.has_value() is true, equivalent to:
+  // reinit-expected(val, unex, *rhs)
+  //  T move is not noexcept
+  //  In this case, it should call the branch
+  //
+  //  U tmp(std::move(oldval));
+  //  destroy_at(addressof(oldval));
+  //  try {
+  //    construct_at(addressof(newval), std::forward<Args>(args)...);
+  //  } catch (...) {
+  //    construct_at(addressof(oldval), std::move(tmp));
+  //    throw;
+  //  }
+  //
+  {
+    TracedNoexcept::state oldState{};
+    Traced::state newState{};
+    std::expected<Traced, TracedNoexcept> e1(std::unexpect, oldState, 5);
+    const std::expected<Traced, TracedNoexcept> e2(std::in_place, newState, 10);
+
+    decltype(auto) x = (e1 = e2);
+    static_assert(std::same_as<decltype(x), std::expected<Traced, TracedNoexcept>&>);
+    assert(&x == &e1);
+
+    assert(e1.has_value());
+    assert(e1.value().data_ == 10);
+
+    assert(!oldState.copyAssignCalled);
+    assert(oldState.moveCtorCalled);
+    assert(oldState.dtorCalled);
+    assert(!oldState.copyCtorCalled);
+    assert(newState.copyCtorCalled);
+    assert(!newState.moveCtorCalled);
+    assert(!newState.dtorCalled);
+  }
+
+  // - Otherwise, if rhs.has_value() is true, equivalent to:
+  // reinit-expected(val, unex, *rhs)
+  //  T move is noexcept
+  //  In this case, it should call the branch
+  //
+  //  destroy_at(addressof(oldval));
+  //  construct_at(addressof(newval), std::forward<Args>(args)...);
+  //
+  {
+    Traced::state oldState{};
+    TracedNoexcept::state newState{};
+    std::expected<TracedNoexcept, Traced> e1(std::unexpect, oldState, 5);
+    const std::expected<TracedNoexcept, Traced> e2(std::in_place, newState, 10);
+
+    decltype(auto) x = (e1 = e2);
+    static_assert(std::same_as<decltype(x), std::expected<TracedNoexcept, Traced>&>);
+    assert(&x == &e1);
+
+    assert(e1.has_value());
+    assert(e1.value().data_ == 10);
+
+    assert(!oldState.copyAssignCalled);
+    assert(!oldState.moveCtorCalled);
+    assert(oldState.dtorCalled);
+    assert(!oldState.copyCtorCalled);
+    assert(newState.copyCtorCalled);
+    assert(!newState.moveCtorCalled);
+    assert(!newState.dtorCalled);
+  }
+
+  // Otherwise, equivalent to unex = rhs.error().
+  {
+    Traced::state oldState{};
+    Traced::state newState{};
+    std::expected<int, Traced> e1(std::unexpect, oldState, 5);
+    const std::expected<int, Traced> e2(std::unexpect, newState, 10);
+    decltype(auto) x = (e1 = e2);
+    static_assert(std::same_as<decltype(x), std::expected<int, Traced>&>);
+    assert(&x == &e1);
+
+    assert(!e1.has_value());
+    assert(e1.error().data_ == 10);
+    assert(oldState.copyAssignCalled);
+  }
+  return true;
+}
+
+void testException() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  struct ThrowOnCopyMoveMayThrow {
+    ThrowOnCopyMoveMayThrow() = default;
+    ThrowOnCopyMoveMayThrow(const ThrowOnCopyMoveMayThrow&) { throw Except{}; };
+    ThrowOnCopyMoveMayThrow& operator=(const ThrowOnCopyMoveMayThrow&) = default;
+    ThrowOnCopyMoveMayThrow(ThrowOnCopyMoveMayThrow&&) noexcept(false) {}
+  };
+
+  // assign value throw on copy
+  {
+    std::expected<ThrowOnCopyMoveMayThrow, int> e1(std::unexpect, 5);
+    const std::expected<ThrowOnCopyMoveMayThrow, int> e2(std::in_place);
+    try {
+      e1 = e2;
+      assert(false);
+    } catch (Except) {
+      assert(!e1.has_value());
+      assert(e1.error() == 5);
+    }
+  }
+
+  // assign error throw on copy
+  {
+    std::expected<int, ThrowOnCopyMoveMayThrow> e1(5);
+    const std::expected<int, ThrowOnCopyMoveMayThrow> e2(std::unexpect);
+    try {
+      e1 = e2;
+      assert(false);
+    } catch (Except) {
+      assert(e1.has_value());
+      assert(e1.value() == 5);
+    }
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  testException();
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.expected/assign/emplace.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
+
+// Older Clangs do not support the C++20 feature to constrain destructors
+// XFAIL: clang-14, apple-clang-14
+
+// template<class... Args>
+//   constexpr T& emplace(Args&&... args) noexcept;
+// Constraints: is_nothrow_constructible_v<T, Args...> is true.
+//
+// Effects: Equivalent to:
+// if (has_value()) {
+//   destroy_at(addressof(val));
+// } else {
+//   destroy_at(addressof(unex));
+//   has_val = true;
+// }
+// return *construct_at(addressof(val), std::forward<Args>(args)...);
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "../../types.h"
+#include "test_macros.h"
+
+template <class T, class... Args>
+concept CanEmplace = requires(T t, Args&&... args) { t.emplace(std::forward<Args>(args)...); };
+
+static_assert(CanEmplace<std::expected<int, int>, int>);
+
+template <bool Noexcept>
+struct CtorFromInt {
+  CtorFromInt(int) noexcept(Noexcept);
+  CtorFromInt(int, int) noexcept(Noexcept);
+};
+
+static_assert(CanEmplace<std::expected<CtorFromInt<true>, int>, int>);
+static_assert(CanEmplace<std::expected<CtorFromInt<true>, int>, int, int>);
+static_assert(!CanEmplace<std::expected<CtorFromInt<false>, int>, int>);
+static_assert(!CanEmplace<std::expected<CtorFromInt<false>, int>, int, int>);
+
+constexpr bool test() {
+  // has_value
+  {
+    BothNoexcept::state oldState{};
+    BothNoexcept::state newState{};
+    std::expected<BothNoexcept, int> e(std::in_place, oldState, 5);
+    decltype(auto) x = e.emplace(newState, 10);
+    static_assert(std::same_as<decltype(x), BothNoexcept&>);
+    assert(&x == &(*e));
+
+    assert(oldState.dtorCalled);
+    assert(e.has_value());
+    assert(e.value().data_ == 10);
+  }
+
+  // !has_value
+  {
+    BothMayThrow::state oldState{};
+    std::expected<int, BothMayThrow> e(std::unexpect, oldState, 5);
+    decltype(auto) x = e.emplace(10);
+    static_assert(std::same_as<decltype(x), int&>);
+    assert(&x == &(*e));
+
+    assert(oldState.dtorCalled);
+    assert(e.has_value());
+    assert(e.value() == 10);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.expected/ctor/ctor.u.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 U = T>
+//   constexpr explicit(!is_convertible_v<U, T>) expected(U&& v);
+//
+// Constraints:
+// - is_same_v<remove_cvref_t<U>, in_place_t> is false; and
+// - is_same_v<expected, remove_cvref_t<U>> is false; and
+// - remove_cvref_t<U> is not a specialization of unexpected; and
+// - is_constructible_v<T, U> is true.
+//
+// Effects: Direct-non-list-initializes val with std::forward<U>(v).
+//
+// Postconditions: has_value() is true.
+//
+// Throws: Any exception thrown by the initialization of val.
+
+#include <cassert>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+// Test Constraints:
+static_assert(std::is_constructible_v<std::expected<int, int>, int>);
+
+// is_same_v<remove_cvref_t<U>, in_place_t>
+struct FromJustInplace {
+  FromJustInplace(std::in_place_t);
+};
+static_assert(!std::is_constructible_v<std::expected<FromJustInplace, int>, std::in_place_t>);
+static_assert(!std::is_constructible_v<std::expected<FromJustInplace, int>, std::in_place_t const&>);
+
+// is_same_v<expected, remove_cvref_t<U>>
+// Note that result is true because it is covered by the constructors that take expected
+static_assert(std::is_constructible_v<std::expected<int, int>, std::expected<int, int>&>);
+
+// remove_cvref_t<U> is a specialization of unexpected
+// Note that result is true because it is covered by the constructors that take unexpected
+static_assert(std::is_constructible_v<std::expected<int, int>, std::unexpected<int>&>);
+
+// !is_constructible_v<T, U>
+struct foo {};
+static_assert(!std::is_constructible_v<std::expected<int, int>, foo>);
+
+// test explicit(!is_convertible_v<U, T>)
+struct NotConvertible {
+  explicit NotConvertible(int);
+};
+static_assert(std::is_convertible_v<int, std::expected<int, int>>);
+static_assert(!std::is_convertible_v<int, std::expected<NotConvertible, int>>);
+
+struct CopyOnly {
+  int i;
+  constexpr CopyOnly(int ii) : i(ii) {}
+  CopyOnly(const CopyOnly&) = default;
+  CopyOnly(CopyOnly&&)      = delete;
+  friend constexpr bool operator==(const CopyOnly& mi, int ii) { return mi.i == ii; }
+};
+
+template <class T>
+constexpr void testInt() {
+  std::expected<T, int> e(5);
+  assert(e.has_value());
+  assert(e.value() == 5);
+}
+
+template <class T>
+constexpr void testLValue() {
+  T t(5);
+  std::expected<T, int> e(t);
+  assert(e.has_value());
+  assert(e.value() == 5);
+}
+
+template <class T>
+constexpr void testRValue() {
+  std::expected<T, int> e(T(5));
+  assert(e.has_value());
+  assert(e.value() == 5);
+}
+
+constexpr bool test() {
+  testInt<int>();
+  testInt<CopyOnly>();
+  testInt<MoveOnly>();
+  testLValue<int>();
+  testLValue<CopyOnly>();
+  testRValue<int>();
+  testRValue<MoveOnly>();
+
+  // Test default template argument.
+  // Without it, the template parameter cannot be deduced from an initializer list
+  {
+    struct Bar {
+      int i;
+      int j;
+      constexpr Bar(int ii, int jj) : i(ii), j(jj) {}
+    };
+
+    std::expected<Bar, int> e({5, 6});
+    assert(e.value().i == 5);
+    assert(e.value().j == 6);
+  }
+
+  // this is a confusing example, but the behaviour
+  // is exactly what is specified in the spec
+  // see https://cplusplus.github.io/LWG/issue3836
+  {
+    struct BaseError {};
+    struct DerivedError : BaseError {};
+
+    std::expected<bool, DerivedError> e1(false);
+    std::expected<bool, BaseError> e2(e1);
+    assert(e2.has_value());
+    assert(e2.value()); // yes, e2 holds "true"
+  }
+  return true;
+}
+
+void testException() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  struct Except {};
+
+  struct Throwing {
+    Throwing(int) { throw Except{}; };
+  };
+
+  try {
+    std::expected<Throwing, int> u(5);
+    assert(false);
+  } catch (Except) {
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  testException();
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.void/ctor/ctor.unexpect_init_list.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
+// Older Clangs do not support the C++20 feature to constrain destructors
+// XFAIL: clang-14, apple-clang-14
+
+// template<class U, class... Args>
+//   constexpr explicit expected(unexpect_t, initializer_list<U> il, Args&&... args);
+//
+// Constraints: is_constructible_v<E, initializer_list<U>&, Args...> is true.
+//
+// Effects: Direct-non-list-initializes unex with il, std::forward<Args>(args)....
+//
+// Postconditions: has_value() is false.
+//
+// Throws: Any exception thrown by the initialization of unex.
+
+#include <algorithm>
+#include <cassert>
+#include <expected>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+// Test Constraints:
+static_assert(
+    std::is_constructible_v<std::expected<void, std::vector<int>>, std::unexpect_t, std::initializer_list<int>>);
+
+// !is_constructible_v<T, initializer_list<U>&, Args...>
+static_assert(!std::is_constructible_v<std::expected<void, int>, std::unexpect_t, std::initializer_list<int>>);
+
+// test explicit
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test<T>({std::forward<Args>(args)...}); };
+static_assert(ImplicitlyConstructible<int, int>);
+
+static_assert(
+    !ImplicitlyConstructible<std::expected<void, std::vector<int>>, std::unexpect_t, std::initializer_list<int>>);
+
+template <class... Ts>
+struct Data {
+  std::vector<int> vec_;
+  std::tuple<Ts...> tuple_;
+
+  template <class... Us>
+  constexpr Data(std::initializer_list<int> il, Us&&... us) : vec_(il), tuple_(std::forward<Us>(us)...) {}
+};
+
+constexpr bool test() {
+  // no arg
+  {
+    std::expected<void, Data<>> e(std::unexpect, {1, 2, 3});
+    assert(!e.has_value());
+    auto expectedList = {1, 2, 3};
+    assert(std::ranges::equal(e.error().vec_, expectedList));
+  }
+
+  // one arg
+  {
+    std::expected<void, Data<MoveOnly>> e(std::unexpect, {4, 5, 6}, MoveOnly(5));
+    assert(!e.has_value());
+    auto expectedList = {4, 5, 6};
+    assert((std::ranges::equal(e.error().vec_, expectedList)));
+    assert(std::get<0>(e.error().tuple_) == 5);
+  }
+
+  // multi args
+  {
+    int i = 5;
+    int j = 6;
+    MoveOnly m(7);
+    std::expected<void, Data<int&, int&&, MoveOnly>> e(std::unexpect, {1, 2}, i, std::move(j), std::move(m));
+    assert(!e.has_value());
+    auto expectedList = {1, 2};
+    assert((std::ranges::equal(e.error().vec_, expectedList)));
+    assert(&std::get<0>(e.error().tuple_) == &i);
+    assert(&std::get<1>(e.error().tuple_) == &j);
+    assert(std::get<2>(e.error().tuple_) == 7);
+    assert(m.get() == 0);
+  }
+
+  return true;
+}
+
+void testException() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  struct Except {};
+
+  struct Throwing {
+    Throwing(std::initializer_list<int>, int) { throw Except{}; };
+  };
+
+  try {
+    std::expected<void, Throwing> u(std::unexpect, {1, 2}, 5);
+    assert(false);
+  } catch (Except) {
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  testException();
+  return 0;
+}

libcxx/test/std/utilities/expected/expected.void/observers/value.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
+
+// constexpr void value() const &;
+// constexpr void value() &&;
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+constexpr bool test() {
+  // const &
+  {
+    const std::expected<void, int> e;
+    e.value();
+    static_assert(std::is_same_v<decltype(e.value()), void>);
+  }
+
+  // &
+  {
+    std::expected<void, int> e;
+    e.value();
+    static_assert(std::is_same_v<decltype(e.value()), void>);
+  }
+
+  // &&
+  {
+    std::expected<void, int> e;
+    std::move(e).value();
+    static_assert(std::is_same_v<decltype(std::move(e).value()), void>);
+  }
+
+  // const &&
+  {
+    const std::expected<void, int> e;
+    std::move(e).value();
+    static_assert(std::is_same_v<decltype(std::move(e).value()), void>);
+  }
+
+  return true;
+}
+
+void testException() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+
+  // int
+  {
+    const std::expected<void, int> e(std::unexpect, 5);
+    try {
+      e.value();
+      assert(false);
+    } catch (const std::bad_expected_access<int>& ex) {
+      assert(ex.error() == 5);
+    }
+  }
+
+  // MoveOnly
+  {
+    std::expected<void, MoveOnly> e(std::unexpect, 5);
+    try {
+      std::move(e).value();
+      assert(false);
+    } catch (const std::bad_expected_access<MoveOnly>& ex) {
+      assert(ex.error() == 5);
+    }
+  }
+
+#endif // TEST_HAS_NO_EXCEPTIONS
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  testException();
+  return 0;
+}