std::expected::swap(3)

NAME
std::expected::swap - std::expected::swap

Synopsis
   constexpr void swap( expected& other ) noexcept(/*see below*/); (since C++23)
   Swaps the contents with those of other.
     * If both this->has_value() and other.has_value() are true:
     * If T is (possibly cv-qualified) void, no effects.
     * Otherwise, equivalent to using std::swap; swap(**this, *other);.
     * If both this->has_value() and other.has_value() are false, equivalent to
       using std::swap; swap(this->error(), other.error());.
     * If this->has_value() is false and other.has_value() is true, calls
       other.swap(*this).
     * If this->has_value() is true and other.has_value() is false,
     * If T is (possibly cv-qualified) void, let unex be the member that represents the
       unexpected value, equivalent to:
 std::construct_at(std::addressof(unex), std::move(other.unex));
 std::destroy_at(std::addressof(other.unex));
     * Otherwise, let val be the member that represents the expected value and unex be
       the member that represents the unexpected value, equivalent to:
 if constexpr (std::is_nothrow_move_constructible_v<E>) {
     E temp(std::move(other.unex));
     std::destroy_at(std::addressof(other.unex));
     try {
         std::construct_at(std::addressof(other.val), std::move(val));
         std::destroy_at(std::addressof(val));
         std::construct_at(std::addressof(unex), std::move(temp));
     } catch(...) {
         std::construct_at(std::addressof(other.unex), std::move(temp));
         throw;
     }
 } else {
     T temp(std::move(val));
     std::destroy_at(std::addressof(val));
     try {
         std::construct_at(std::addressof(unex), std::move(other.unex));
         std::destroy_at(std::addressof(other.unex));
         std::construct_at(std::addressof(other.val), std::move(temp));
     } catch(...) {
         std::construct_at(std::addressof(val), std::move(temp));
         throw;
     }
 }
     * In either case, if no exception was thrown, after swap, this->has_value() is
       false, and other.has_value() is true.
   This function participates in overload resolution only if
     * either T is (possibly cv-qualified) void, or std::is_swappable_v<T> is true, and
     * std::is_swappable_v<E> is true, and
     * either T is (possibly cv-qualified) void, or std::is_move_constructible_v<T> is
       true, and
     * std::is_move_constructible_v<E> is true, and
     * at least one of the following is true:
          * T is (possibly cv-qualified) void
          * std::is_nothrow_move_constructible_v<T>
          * std::is_nothrow_move_constructible_v<E>

Parameters
   other - the optional object to exchange the contents with

Return value
   (none)

Exceptions
   If T is (possibly cv-qualified) void,
   noexcept specification:
   noexcept(
       std::is_nothrow_move_constructible_v<E> && std::is_nothrow_swappable_v<E>
   )
   Otherwise,
   noexcept specification:
   noexcept(
       std::is_nothrow_move_constructible_v<T> && std::is_nothrow_swappable_v<T> &&
       std::is_nothrow_move_constructible_v<E> && std::is_nothrow_swappable_v<E>
   )
   In the case of thrown exception, the states of the contained values of *this and
   other are determined by the exception safety guarantees of swap or T's and E's move
   constructor, whichever is called. For both *this and other, if the object contained
   an expected value, it is left containing an expected value, and the other way round.

Example
    This section is incomplete
    Reason: no example

See also
   swap(std::expected) specializes the std::swap algorithm
   (C++23) (function)

Categories:
     * conditionally noexcept
     * Todo no example