[variant] - C++17 → C++20

Files changed (1) hide show

tmp/tmpst1yz97h/{from.md → to.md} +276 -319

tmp/tmpst1yz97h/{from.md → to.md} RENAMED Viewed

@@ -2,36 +2,34 @@
 ### In general <a id="variant.general">[[variant.general]]</a>
 A variant object holds and manages the lifetime of a value. If the
 `variant` holds a value, that value’s type has to be one of the template
-argument types given to variant. These template arguments are called
 alternatives.
 ### Header `<variant>` synopsis <a id="variant.syn">[[variant.syn]]</a>
 ``` cpp
 namespace std {
   // [variant.variant], class template variant
   template<class... Types>
     class variant;
   // [variant.helper], variant helper classes
   template<class T> struct variant_size;                        // not defined
   template<class T> struct variant_size<const T>;
-  template <class T> struct variant_size<volatile T>;
-  template <class T> struct variant_size<const volatile T>;
   template<class T>
     inline constexpr size_t variant_size_v = variant_size<T>::value;
   template<class... Types>
     struct variant_size<variant<Types...>>;
   template<size_t I, class T> struct variant_alternative;       // not defined
   template<size_t I, class T> struct variant_alternative<I, const T>;
-  template <size_t I, class T> struct variant_alternative<I, volatile T>;
-  template <size_t I, class T> struct variant_alternative<I, const volatile T>;
   template<size_t I, class T>
     using variant_alternative_t = typename variant_alternative<I, T>::type;
   template<size_t I, class... Types>
     struct variant_alternative<I, variant<Types...>>;
@@ -85,25 +83,26 @@ namespace std {
     constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
   template<class... Types>
     constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
   template<class... Types>
     constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
   // [variant.visit], visitation
   template<class Visitor, class... Variants>
     constexpr see below visit(Visitor&&, Variants&&...);
   // [variant.monostate], class monostate
   struct monostate;
   // [variant.monostate.relops], monostate relational operators
-  constexpr bool operator<(monostate, monostate) noexcept;
-  constexpr bool operator>(monostate, monostate) noexcept;
-  constexpr bool operator<=(monostate, monostate) noexcept;
-  constexpr bool operator>=(monostate, monostate) noexcept;
   constexpr bool operator==(monostate, monostate) noexcept;
-  constexpr bool operator!=(monostate, monostate) noexcept;
   // [variant.specalg], specialized algorithms
   template<class... Types>
     void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
@@ -112,14 +111,10 @@ namespace std {
   // [variant.hash], hash support
   template<class T> struct hash;
   template<class... Types> struct hash<variant<Types...>>;
   template<> struct hash<monostate>;
-  // [variant.traits], allocator-related traits
-  template <class T, class Alloc> struct uses_allocator;
-  template <class... Types, class Alloc> struct uses_allocator<variant<Types...>, Alloc>;
 }
 ```
 ### Class template `variant` <a id="variant.variant">[[variant.variant]]</a>
@@ -128,12 +123,12 @@ namespace std {
   template<class... Types>
   class variant {
   public:
     // [variant.ctor], constructors
     constexpr variant() noexcept(see below);
- variant(const variant&);
- variant(variant&&) noexcept(see below);
     template<class T>
       constexpr variant(T&&) noexcept(see below);
     template<class T, class... Args>
@@ -144,36 +139,16 @@ namespace std {
     template<size_t I, class... Args>
       constexpr explicit variant(in_place_index_t<I>, Args&&...);
     template<size_t I, class U, class... Args>
       constexpr explicit variant(in_place_index_t<I>, initializer_list<U>, Args&&...);
-      // allocator-extended constructors
-      template <class Alloc>
-        variant(allocator_arg_t, const Alloc&);
-      template <class Alloc>
-        variant(allocator_arg_t, const Alloc&, const variant&);
-      template <class Alloc>
-        variant(allocator_arg_t, const Alloc&, variant&&);
-      template <class Alloc, class T>
-        variant(allocator_arg_t, const Alloc&, T&&);
-      template <class Alloc, class T, class... Args>
-        variant(allocator_arg_t, const Alloc&, in_place_type_t<T>, Args&&...);
-      template <class Alloc, class T, class U, class... Args>
-        variant(allocator_arg_t, const Alloc&, in_place_type_t<T>,
-                initializer_list<U>, Args&&...);
-      template <class Alloc, size_t I, class... Args>
-        variant(allocator_arg_t, const Alloc&, in_place_index_t<I>, Args&&...);
-      template <class Alloc, size_t I, class U, class... Args>
-        variant(allocator_arg_t, const Alloc&, in_place_index_t<I>,
-                initializer_list<U>, Args&&...);
     // [variant.dtor], destructor
     ~variant();
     // [variant.assign], assignment
- variant& operator=(const variant&);
- variant& operator=(variant&&) noexcept(see below);
     template<class T> variant& operator=(T&&) noexcept(see below);
     // [variant.mod], modifiers
     template<class T, class... Args>
@@ -194,352 +169,327 @@ namespace std {
   };
 }
 ```
 Any instance of `variant` at any given time either holds a value of one
-of its alternative types, or it holds no value. When an instance of
 `variant` holds a value of alternative type `T`, it means that a value
 of type `T`, referred to as the `variant` object’s *contained value*, is
 allocated within the storage of the `variant` object. Implementations
 are not permitted to use additional storage, such as dynamic memory, to
 allocate the contained value. The contained value shall be allocated in
 a region of the `variant` storage suitably aligned for all types in
-`Types...`. It is *implementation-defined* whether over-aligned types
-are supported.
-All types in `Types...` shall be (possibly cv-qualified) object types
-that are not arrays.
 A program that instantiates the definition of `variant` with no template
 arguments is ill-formed.
 #### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
-`sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types...`.
 ``` cpp
 constexpr variant() noexcept(see below);
 ```
 *Effects:* Constructs a `variant` holding a value-initialized value of
 type `T₀`.
-*Postconditions:* `valueless_by_exception()` is `false` and `index()` is
-`0`.
 *Throws:* Any exception thrown by the value-initialization of `T₀`.
-*Remarks:* This function shall be `constexpr` if and only if the
 value-initialization of the alternative type `T₀` would satisfy the
 requirements for a constexpr function. The expression inside `noexcept`
-is equivalent to `is_nothrow_default_constructible_v<``T₀``>`. This
-function shall not participate in overload resolution unless
-`is_default_constructible_v<``T₀``>` is `true`.
 [*Note 1*: See also class `monostate`. — *end note*]
 ``` cpp
-variant(const variant& w);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
 `variant` to not hold a value.
 *Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
 i.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_copy_constructible_v<``Tᵢ``>` is `true` for all i.
 ``` cpp
-variant(variant&& w) noexcept(see below);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(std::move(w))`, where `j` is `w.index()`. Otherwise, initializes
 the `variant` to not hold a value.
 *Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
-AND of `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. This
-function shall not participate in overload resolution unless
-`is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 ``` cpp
 template<class T> constexpr variant(T&& t) noexcept(see below);
 ```
 Let `Tⱼ` be a type that is determined as follows: build an imaginary
-function *FUN*(Tᵢ) for each alternative type `Tᵢ`. The overload
-*FUN*(Tⱼ) selected by overload resolution for the expression
-*FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ` which is the
-type of the contained value after construction.
 *Effects:* Initializes `*this` to hold the alternative type `Tⱼ` and
 direct-initializes the contained value as if
 direct-non-list-initializing it with `std::forward<T>(t)`.
-*Postconditions:* `holds_alternative<``Tⱼ``>(*this)` is `true`.
 *Throws:* Any exception thrown by the initialization of the selected
 alternative `Tⱼ`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_same_v<decay_t<T>, variant>` is `false`, unless `decay_t<T>`
-is neither a specialization of `in_place_type_t` nor a specialization of
-`in_place_index_t`, unless `is_constructible_v<``Tⱼ``, T>` is `true`,
-and unless the expression *FUN*(`std::forward<T>(t))` (with *FUN* being
-the above-mentioned set of imaginary functions) is well formed.
-[*Note 2*:
-``` cpp
-variant<string, string> v("abc");
-```
-is ill-formed, as both alternative types have an equally viable
-constructor for the argument.
-— *end note*]
-The expression inside `noexcept` is equivalent to
 `is_nothrow_constructible_v<``Tⱼ``, T>`. If `Tⱼ`’s selected constructor
-is a constexpr constructor, this constructor shall be a constexpr
-constructor.
 ``` cpp
 template<class T, class... Args> constexpr explicit variant(in_place_type_t<T>, Args&&... args);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `std::forward<Args>(args)...`.
-*Postconditions:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
-*Remarks:* This function shall not participate in overload resolution
-unless there is exactly one occurrence of `T` in `Types...` and
-`is_constructible_v<T, Args...>` is `true`. If `T`’s selected
-constructor is a constexpr constructor, this constructor shall be a
-constexpr constructor.
 ``` cpp
 template<class T, class U, class... Args>
   constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `il, std::forward<Args>(args)...`.
-*Postconditions:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
-*Remarks:* This function shall not participate in overload resolution
-unless there is exactly one occurrence of `T` in `Types...` and
-`is_constructible_v<T, initializer_list<U>&, Args...>` is `true`. If
-`T`’s selected constructor is a constexpr constructor, this constructor
-shall be a constexpr constructor.
 ``` cpp
 template<size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>, Args&&... args);
 ```
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T_I` with the arguments
-`std::forward<Args>(args)...`.
-*Postconditions:* `index()` is `I`.
-*Throws:* Any exception thrown by calling the selected constructor of
-`T_I`.
-*Remarks:* This function shall not participate in overload resolution
-unless
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, Args...>` is `true`.
-If `T_I`’s selected constructor is a constexpr constructor, this
-constructor shall be a constexpr constructor.
 ``` cpp
 template<size_t I, class U, class... Args>
   constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&... args);
 ```
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T_I` with the arguments
-`il, std::forward<Args>(args)...`.
-*Postconditions:* `index()` is `I`.
-*Remarks:* This function shall not participate in overload resolution
-unless
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
   `true`.
-If `T_I`’s selected constructor is a constexpr constructor, this
-constructor shall be a constexpr constructor.
-``` cpp
-// allocator-extended constructors
-template <class Alloc>
-  variant(allocator_arg_t, const Alloc& a);
-template <class Alloc>
-  variant(allocator_arg_t, const Alloc& a, const variant& v);
-template <class Alloc>
-  variant(allocator_arg_t, const Alloc& a, variant&& v);
-template <class Alloc, class T>
-  variant(allocator_arg_t, const Alloc& a, T&& t);
-template <class Alloc, class T, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>, Args&&... args);
-template <class Alloc, class T, class U, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>,
-          initializer_list<U> il, Args&&... args);
-template <class Alloc, size_t I, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>, Args&&... args);
-template <class Alloc, size_t I, class U, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>,
-          initializer_list<U> il, Args&&... args);
-```
-*Requires:* `Alloc` shall meet the requirements for an
-Allocator ([[allocator.requirements]]).
-*Effects:* Equivalent to the preceding constructors except that the
-contained value is constructed with uses-allocator
-construction ([[allocator.uses.construction]]).
 #### Destructor <a id="variant.dtor">[[variant.dtor]]</a>
 ``` cpp
 ~variant();
 ```
 *Effects:* If `valueless_by_exception()` is `false`, destroys the
 currently contained value.
-*Remarks:* If `is_trivially_destructible_v<``Tᵢ``> == true` for all `Tᵢ`
-then this destructor shall be a trivial destructor.
 #### Assignment <a id="variant.assign">[[variant.assign]]</a>
 ``` cpp
-variant& operator=(const variant& rhs);
 ```
 Let j be `rhs.index()`.
 *Effects:*
 - If neither `*this` nor `rhs` holds a value, there is no effect.
- Otherwise,
-- if `*this` holds a value but `rhs` does not, destroys the value
-  contained in `*this` and sets `*this` to not hold a value. Otherwise,
-- if `index() == `j, assigns the value contained in `rhs` to the value
-  contained in `*this`. Otherwise,
-- if either `is_nothrow_copy_constructible_v<``Tⱼ``>` or
-  `!is_nothrow_move_constructible_v<``Tⱼ``>` is `true`, equivalent to
- `emplace<`j`>(get<`j`>(rhs))`. Otherwise,
-- equivalent to `operator=(variant(rhs))`.
 *Returns:* `*this`.
-*Postconditions:* `index() == rhs.index()`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_copy_constructible_v<``Tᵢ``> &&`
-`is_copy_assignable_v<``Tᵢ``>` is `true` for all i.
 ``` cpp
-variant& operator=(variant&& rhs) noexcept(see below);
 ```
 Let j be `rhs.index()`.
 *Effects:*
 - If neither `*this` nor `rhs` holds a value, there is no effect.
- Otherwise,
-- if `*this` holds a value but `rhs` does not, destroys the value
-  contained in `*this` and sets `*this` to not hold a value. Otherwise,
-- if `index() == `j, assigns `get<`j`>(std::move(rhs))` to the value
-  contained in `*this`. Otherwise,
-- equivalent to `emplace<`j`>(get<`j`>(std::move(rhs)))`.
 *Returns:* `*this`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_move_constructible_v<``Tᵢ``> && is_move_assignable_v<``Tᵢ``>`
-is `true` for all i. The expression inside `noexcept` is equivalent to:
 `is_nothrow_move_constructible_v<``Tᵢ``> && is_nothrow_move_assignable_v<``Tᵢ``>`
 for all i.
 - If an exception is thrown during the call to `Tⱼ`’s move construction
-  (with j being `rhs.index())`, the `variant` will hold no value.
 - If an exception is thrown during the call to `Tⱼ`’s move assignment,
   the state of the contained value is as defined by the exception safety
   guarantee of `Tⱼ`’s move assignment; `index()` will be j.
 ``` cpp
 template<class T> variant& operator=(T&& t) noexcept(see below);
 ```
 Let `Tⱼ` be a type that is determined as follows: build an imaginary
-function *FUN*(Tᵢ) for each alternative type `Tᵢ`. The overload
-*FUN*(Tⱼ) selected by overload resolution for the expression
-*FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ` which is the
-type of the contained value after assignment.
-*Effects:*
-- If `*this` holds a `Tⱼ`, assigns `std::forward<T>(t)` to the value
-  contained in `*this`. Otherwise,
-- if `is_nothrow_constructible_v<``Tⱼ``, T> ||`
-  `!is_nothrow_move_constructible_v<``Tⱼ``>` is `true`, equivalent to
-  `emplace<`j`>(std::forward<T>(t))`. Otherwise,
-- equivalent to `operator=(variant(std::forward<T>(t)))`.
-*Postconditions:* `holds_alternative<``Tⱼ``>(*this)` is `true`, with
-`Tⱼ` selected by the imaginary function overload resolution described
-above.
-*Returns:* `*this`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_same_v<decay_t<T>, variant>` is `false`, unless
-`is_assignable_v<``Tⱼ``&, T> && is_constructible_v<``Tⱼ``, T>` is
-`true`, and unless the expression *FUN*(std::forward\<T\>(t)) (with
-*FUN* being the above-mentioned set of imaginary functions) is well
-formed.
-[*Note 1*:
-``` cpp
       variant<string, string> v;
       v = "abc";
-```
   is ill-formed, as both alternative types have an equally viable
   constructor for the argument.
   — *end note*]
-The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_assignable_v<Tⱼ&, T> && is_nothrow_constructible_v<Tⱼ, T>
 ```
@@ -555,78 +505,83 @@ is_nothrow_assignable_v<Tⱼ&, T> && is_nothrow_constructible_v<Tⱼ, T>
 ``` cpp
 template<class T, class... Args> T& emplace(Args&&... args);
 ```
-Let I be the zero-based index of `T` in `Types...`.
 *Effects:* Equivalent to:
-`return emplace<`I`>(std::forward<Args>(args)...);`
-*Remarks:* This function shall not participate in overload resolution
-unless `is_constructible_v<T, Args...>` is `true`, and `T` occurs
-exactly once in `Types...`.
 ``` cpp
 template<class T, class U, class... Args> T& emplace(initializer_list<U> il, Args&&... args);
 ```
-Let I be the zero-based index of `T` in `Types...`.
 *Effects:* Equivalent to:
-`return emplace<`I`>(il, std::forward<Args>(args)...);`
-*Remarks:* This function shall not participate in overload resolution
-unless `is_constructible_v<T, initializer_list<U>&, Args...>` is `true`,
-and `T` occurs exactly once in `Types...`.
 ``` cpp
 template<size_t I, class... Args>
   variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
 ```
-*Requires:* `I < sizeof...(Types)`.
 *Effects:* Destroys the currently contained value if
 `valueless_by_exception()` is `false`. Then initializes the contained
 value as if direct-non-list-initializing a value of type `T_I` with the
 arguments `std::forward<Args>(args)...`.
-*Postconditions:* `index()` is `I`.
 *Returns:* A reference to the new contained value.
 *Throws:* Any exception thrown during the initialization of the
 contained value.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_constructible_v<``T_I``, Args...>` is `true`. If an exception
-is thrown during the initialization of the contained value, the
-`variant` might not hold a value.
 ``` cpp
 template<size_t I, class U, class... Args>
   variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il, Args&&... args);
 ```
-*Requires:* `I < sizeof...(Types)`.
 *Effects:* Destroys the currently contained value if
 `valueless_by_exception()` is `false`. Then initializes the contained
 value as if direct-non-list-initializing a value of type `T_I` with the
 arguments `il, std::forward<Args>(args)...`.
-*Postconditions:* `index()` is `I`.
 *Returns:* A reference to the new contained value.
 *Throws:* Any exception thrown during the initialization of the
 contained value.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
-`true`. If an exception is thrown during the initialization of the
 contained value, the `variant` might not hold a value.
 #### Value status <a id="variant.status">[[variant.status]]</a>
 ``` cpp
@@ -662,22 +617,22 @@ alternative of the contained value.
 ``` cpp
 void swap(variant& rhs) noexcept(see below);
 ```
-*Requires:* Lvalues of type `Tᵢ` shall be
-swappable ([[swappable.requirements]]) and
-`is_move_constructible_v<``Tᵢ``>` shall be `true` for all i.
 *Effects:*
-- if `valueless_by_exception() && rhs.valueless_by_exception()` no
-  effect. Otherwise,
-- if `index() == rhs.index()`, calls
   `swap(get<`i`>(*this), get<`i`>(rhs))` where i is `index()`.
- Otherwise,
-- exchanges values of `rhs` and `*this`.
 *Throws:* If `index() == rhs.index()`, any exception thrown by
 `swap(get<`i`>(*this), get<`i`>(rhs))` with i being `index()`.
 Otherwise, any exception thrown by the move constructor of `Tᵢ` or `Tⱼ`
 with i being `index()` and j being `rhs.index()`.
@@ -687,75 +642,66 @@ with i being `index()` and j being `rhs.index()`.
 values of `*this` and of `rhs` are determined by the exception safety
 guarantee of `swap` for lvalues of `Tᵢ` with i being `index()`. If an
 exception is thrown during the exchange of the values of `*this` and
 `rhs`, the states of the values of `*this` and of `rhs` are determined
 by the exception safety guarantee of `variant`’s move constructor. The
-expression inside `noexcept` is equivalent to the logical AND of
 `is_nothrow_move_constructible_v<``Tᵢ``> && is_nothrow_swappable_v<``Tᵢ``>`
 for all i.
 ### `variant` helper classes <a id="variant.helper">[[variant.helper]]</a>
 ``` cpp
 template<class T> struct variant_size;
 ```
-*Remarks:* All specializations of `variant_size` shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]) with a base
-characteristic of `integral_constant<size_t, N>` for some `N`.
 ``` cpp
 template<class T> class variant_size<const T>;
-template <class T> class variant_size<volatile T>;
-template <class T> class variant_size<const volatile T>;
 ```
 Let `VS` denote `variant_size<T>` of the cv-unqualified type `T`. Then
-each of the three templates shall meet the `UnaryTypeTrait`
-requirements ([[meta.rqmts]]) with a base characteristic of
 `integral_constant<size_t, VS::value>`.
 ``` cpp
 template<class... Types>
   struct variant_size<variant<Types...>> : integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
 template<size_t I, class T> class variant_alternative<I, const T>;
-template <size_t I, class T> class variant_alternative<I, volatile T>;
-template <size_t I, class T> class variant_alternative<I, const volatile T>;
 ```
 Let `VA` denote `variant_alternative<I, T>` of the cv-unqualified type
-`T`. Then each of the three templates shall meet the
-`TransformationTrait` requirements ([[meta.rqmts]]) with a member
-typedef `type` that names the following type:
-- for the first specialization, `add_const_t<VA::type>`,
-- for the second specialization, `add_volatile_t<VA::type>`, and
-- for the third specialization, `add_cv_t<VA::type>`.
 ``` cpp
 variant_alternative<I, variant<Types...>>::type
 ```
-*Requires:* `I < sizeof...(Types)`.
-*Value:* The type `T_I`.
 ### Value access <a id="variant.get">[[variant.get]]</a>
 ``` cpp
 template<class T, class... Types>
   constexpr bool holds_alternative(const variant<Types...>& v) noexcept;
 ```
-*Requires:* The type `T` occurs exactly once in `Types...`. Otherwise,
-the program is ill-formed.
 *Returns:* `true` if `index()` is equal to the zero-based index of `T`
-in `Types...`.
 ``` cpp
 template<size_t I, class... Types>
   constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>& v);
 template<size_t I, class... Types>
@@ -764,11 +710,11 @@ template <size_t I, class... Types>
   constexpr const variant_alternative_t<I, variant<Types...>>& get(const variant<Types...>& v);
 template<size_t I, class... Types>
   constexpr const variant_alternative_t<I, variant<Types...>>&& get(const variant<Types...>&& v);
 ```
-*Requires:* `I < sizeof...(Types)`. Otherwise the program is ill-formed.
 *Effects:* If `v.index()` is `I`, returns a reference to the object
 stored in the `variant`. Otherwise, throws an exception of type
 `bad_variant_access`.
@@ -777,12 +723,11 @@ template <class T, class... Types> constexpr T& get(variant<Types...>& v);
 template<class T, class... Types> constexpr T&& get(variant<Types...>&& v);
 template<class T, class... Types> constexpr const T& get(const variant<Types...>& v);
 template<class T, class... Types> constexpr const T&& get(const variant<Types...>&& v);
 ```
-*Requires:* The type `T` occurs exactly once in `Types...`. Otherwise,
-the program is ill-formed.
 *Effects:* If `v` holds a value of type `T`, returns a reference to that
 value. Otherwise, throws an exception of type `bad_variant_access`.
 ``` cpp
@@ -792,11 +737,11 @@ template <size_t I, class... Types>
 template<size_t I, class... Types>
   constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
     get_if(const variant<Types...>* v) noexcept;
 ```
-*Requires:* `I < sizeof...(Types)`. Otherwise the program is ill-formed.
 *Returns:* A pointer to the value stored in the `variant`, if
 `v != nullptr` and `v->index() == I`. Otherwise, returns `nullptr`.
 ``` cpp
@@ -806,49 +751,48 @@ template <class T, class... Types>
 template<class T, class... Types>
   constexpr add_pointer_t<const T>
     get_if(const variant<Types...>* v) noexcept;
 ```
-*Requires:* The type `T` occurs exactly once in `Types...`. Otherwise,
-the program is ill-formed.
 *Effects:* Equivalent to: `return get_if<`i`>(v);` with i being the
-zero-based index of `T` in `Types...`.
 ### Relational operators <a id="variant.relops">[[variant.relops]]</a>
 ``` cpp
 template<class... Types>
   constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Requires:* `get<`i`>(v) == get<`i`>(w)` is a valid expression returning
-a type that is convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise
 `get<`i`>(v) == get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator!=(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Requires:* `get<`i`>(v) != get<`i`>(w)` is a valid expression returning
-a type that is convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise
 `get<`i`>(v) != get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Requires:* `get<`i`>(v) < get<`i`>(w)` is a valid expression returning
-a type that is convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
 `false`; otherwise `get<`i`>(v) < get<`i`>(w)` with i being `v.index()`.
@@ -856,12 +800,12 @@ a type that is convertible to `bool`, for all i.
 ``` cpp
 template<class... Types>
   constexpr bool operator>(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Requires:* `get<`i`>(v) > get<`i`>(w)` is a valid expression returning
-a type that is convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `false`; otherwise if
 `w.valueless_by_exception()`, `true`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
 `false`; otherwise `get<`i`>(v) > get<`i`>(w)` with i being `v.index()`.
@@ -869,12 +813,12 @@ a type that is convertible to `bool`, for all i.
 ``` cpp
 template<class... Types>
   constexpr bool operator<=(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Requires:* `get<`i`>(v) <= get<`i`>(w)` is a valid expression returning
-a type that is convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `true`; otherwise if
 `w.valueless_by_exception()`, `false`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
 `false`; otherwise `get<`i`>(v) <= get<`i`>(w)` with i being
@@ -883,43 +827,77 @@ a type that is convertible to `bool`, for all i.
 ``` cpp
 template<class... Types>
   constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Requires:* `get<`i`>(v) >= get<`i`>(w)` is a valid expression returning
-a type that is convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
 `false`; otherwise `get<`i`>(v) >= get<`i`>(w)` with i being
 `v.index()`.
 ### Visitation <a id="variant.visit">[[variant.visit]]</a>
 ``` cpp
 template<class Visitor, class... Variants>
   constexpr see below visit(Visitor&& vis, Variants&&... vars);
 ```
-*Requires:* The expression in the *Effects:* element shall be a valid
-expression of the same type and value category, for all combinations of
-alternative types of all variants. Otherwise, the program is ill-formed.
-*Effects:* Let `is...` be `vars.index()...`. Returns
-*INVOKE*(forward\<Visitor\>(vis), get\<is\>(
-`forward<Variants>(vars))...);`.
-*Remarks:* The return type is the common type of all possible *`INVOKE`*
-expressions of the *Effects:* element.
 *Throws:* `bad_variant_access` if any `variant` in `vars` is
 `valueless_by_exception()`.
-*Complexity:* For `sizeof...(Variants) <= 1`, the invocation of the
-callable object is implemented in constant time, i.e. it does not depend
-on `sizeof...(Types).` For `sizeof...(Variants) > 1`, the invocation of
 the callable object has no complexity requirements.
 ### Class `monostate` <a id="variant.monostate">[[variant.monostate]]</a>
 ``` cpp
@@ -930,16 +908,13 @@ The class `monostate` can serve as a first alternative type for a
 `variant` to make the `variant` type default constructible.
 ### `monostate` relational operators <a id="variant.monostate.relops">[[variant.monostate.relops]]</a>
 ``` cpp
-constexpr bool operator<(monostate, monostate) noexcept { return false; }
-constexpr bool operator>(monostate, monostate) noexcept { return false; }
-constexpr bool operator<=(monostate, monostate) noexcept { return true; }
-constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 constexpr bool operator==(monostate, monostate) noexcept { return true; }
-constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 ```
 [*Note 1*: `monostate` objects have only a single state; they thus
 always compare equal. — *end note*]
@@ -948,36 +923,32 @@ always compare equal. — *end note*]
 ``` cpp
 template<class... Types>
   void swap(variant<Types...>& v, variant<Types...>& w) noexcept(see below);
 ```
 *Effects:* Equivalent to `v.swap(w)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_move_constructible_v<``Tᵢ``> && is_swappable_v<``Tᵢ``>` is
-`true` for all i. The expression inside `noexcept` is equivalent to
 `noexcept(v.swap(w))`.
 ### Class `bad_variant_access` <a id="variant.bad.access">[[variant.bad.access]]</a>
 ``` cpp
 class bad_variant_access : public exception {
 public:
- bad_variant_access() noexcept;
   const char* what() const noexcept override;
 };
 ```
 Objects of type `bad_variant_access` are thrown to report invalid
 accesses to the value of a `variant` object.
-``` cpp
-bad_variant_access() noexcept;
-```
-Constructs a `bad_variant_access` object.
 ``` cpp
 const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
@@ -986,29 +957,15 @@ const char* what() const noexcept override;
 ``` cpp
 template<class... Types> struct hash<variant<Types...>>;
 ```
-The specialization `hash<variant<Types...>>` is
-enabled ([[unord.hash]]) if and only if every specialization in
-`hash<remove_const_t<Types>>...` is enabled. The member functions are
-not guaranteed to be `noexcept`.
 ``` cpp
 template<> struct hash<monostate>;
 ```
-The specialization is enabled ([[unord.hash]]).
-### Allocator-related traits <a id="variant.traits">[[variant.traits]]</a>
-``` cpp
-template <class... Types, class Alloc>
-  struct uses_allocator<variant<Types...>, Alloc> : true_type { };
-```
-*Requires:* `Alloc` shall be an Allocator ([[allocator.requirements]]).
-[*Note 1*: Specialization of this trait informs other library
-components that variant can be constructed with an allocator, even
-though it does not have a nested `allocator_type`. — *end note*]

 ### In general <a id="variant.general">[[variant.general]]</a>
 A variant object holds and manages the lifetime of a value. If the
 `variant` holds a value, that value’s type has to be one of the template
+argument types given to `variant`. These template arguments are called
 alternatives.
 ### Header `<variant>` synopsis <a id="variant.syn">[[variant.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
 namespace std {
   // [variant.variant], class template variant
   template<class... Types>
     class variant;
   // [variant.helper], variant helper classes
   template<class T> struct variant_size;                        // not defined
   template<class T> struct variant_size<const T>;
   template<class T>
     inline constexpr size_t variant_size_v = variant_size<T>::value;
   template<class... Types>
     struct variant_size<variant<Types...>>;
   template<size_t I, class T> struct variant_alternative;       // not defined
   template<size_t I, class T> struct variant_alternative<I, const T>;
   template<size_t I, class T>
     using variant_alternative_t = typename variant_alternative<I, T>::type;
   template<size_t I, class... Types>
     struct variant_alternative<I, variant<Types...>>;
     constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
   template<class... Types>
     constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
   template<class... Types>
     constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
+  template<class... Types> requires (three_way_comparable<Types> && ...)
+    constexpr common_comparison_category_t<compare_three_way_result_t<Types>...>
+      operator<=>(const variant<Types...>&, const variant<Types...>&);
   // [variant.visit], visitation
   template<class Visitor, class... Variants>
     constexpr see below visit(Visitor&&, Variants&&...);
+  template<class R, class Visitor, class... Variants>
+    constexpr R visit(Visitor&&, Variants&&...);
   // [variant.monostate], class monostate
   struct monostate;
   // [variant.monostate.relops], monostate relational operators
   constexpr bool operator==(monostate, monostate) noexcept;
+  constexpr strong_ordering operator<=>(monostate, monostate) noexcept;
   // [variant.specalg], specialized algorithms
   template<class... Types>
     void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
   // [variant.hash], hash support
   template<class T> struct hash;
   template<class... Types> struct hash<variant<Types...>>;
   template<> struct hash<monostate>;
 }
 ```
 ### Class template `variant` <a id="variant.variant">[[variant.variant]]</a>
   template<class... Types>
   class variant {
   public:
     // [variant.ctor], constructors
     constexpr variant() noexcept(see below);
+    constexpr variant(const variant&);
+    constexpr variant(variant&&) noexcept(see below);
     template<class T>
       constexpr variant(T&&) noexcept(see below);
     template<class T, class... Args>
     template<size_t I, class... Args>
       constexpr explicit variant(in_place_index_t<I>, Args&&...);
     template<size_t I, class U, class... Args>
       constexpr explicit variant(in_place_index_t<I>, initializer_list<U>, Args&&...);
     // [variant.dtor], destructor
     ~variant();
     // [variant.assign], assignment
+    constexpr variant& operator=(const variant&);
+    constexpr variant& operator=(variant&&) noexcept(see below);
     template<class T> variant& operator=(T&&) noexcept(see below);
     // [variant.mod], modifiers
     template<class T, class... Args>
   };
 }
 ```
 Any instance of `variant` at any given time either holds a value of one
+of its alternative types or holds no value. When an instance of
 `variant` holds a value of alternative type `T`, it means that a value
 of type `T`, referred to as the `variant` object’s *contained value*, is
 allocated within the storage of the `variant` object. Implementations
 are not permitted to use additional storage, such as dynamic memory, to
 allocate the contained value. The contained value shall be allocated in
 a region of the `variant` storage suitably aligned for all types in
+`Types`.
+All types in `Types` shall meet the *Cpp17Destructible* requirements (
+[[cpp17.destructible]]).
 A program that instantiates the definition of `variant` with no template
 arguments is ill-formed.
 #### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
+`sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types`.
 ``` cpp
 constexpr variant() noexcept(see below);
 ```
+*Constraints:* `is_default_constructible_v<``T₀``>` is `true`.
 *Effects:* Constructs a `variant` holding a value-initialized value of
 type `T₀`.
+*Ensures:* `valueless_by_exception()` is `false` and `index()` is `0`.
 *Throws:* Any exception thrown by the value-initialization of `T₀`.
+*Remarks:* This function is `constexpr` if and only if the
 value-initialization of the alternative type `T₀` would satisfy the
 requirements for a constexpr function. The expression inside `noexcept`
+is equivalent to `is_nothrow_default_constructible_v<``T₀``>`.
 [*Note 1*: See also class `monostate`. — *end note*]
 ``` cpp
+constexpr variant(const variant& w);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
 `variant` to not hold a value.
 *Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
 i.
+*Remarks:* This constructor is defined as deleted unless
+`is_copy_constructible_v<``Tᵢ``>` is `true` for all i. If
+`is_trivially_copy_constructible_v<``Tᵢ``>` is `true` for all i, this
+constructor is trivial.
 ``` cpp
+constexpr variant(variant&& w) noexcept(see below);
 ```
+*Constraints:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(std::move(w))`, where `j` is `w.index()`. Otherwise, initializes
 the `variant` to not hold a value.
 *Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
+of `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. If
+`is_trivially_move_constructible_v<``Tᵢ``>` is `true` for all i, this
+constructor is trivial.
 ``` cpp
 template<class T> constexpr variant(T&& t) noexcept(see below);
 ```
 Let `Tⱼ` be a type that is determined as follows: build an imaginary
+function *FUN*(Tᵢ) for each alternative type `Tᵢ` for which `Tᵢ`` x[] =`
+`{std::forward<T>(t)};` is well-formed for some invented variable `x`.
+The overload *FUN*(Tⱼ) selected by overload resolution for the
+expression *FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ`
+which is the type of the contained value after construction.
+*Constraints:*
+- `sizeof...(Types)` is nonzero,
+- `is_same_v<remove_cvref_t<T>, variant>` is `false`,
+- `remove_cvref_t<T>` is neither a specialization of `in_place_type_t`
+  nor a specialization of `in_place_index_t`,
+- `is_constructible_v<``Tⱼ``, T>` is `true`, and
+- the expression *FUN*(`std::forward<T>(t))` (with *FUN* being the
+  above-mentioned set of imaginary functions) is well-formed.
+  \[*Note 1*:
+      variant<string, string> v("abc");
+  is ill-formed, as both alternative types have an equally viable
+  constructor for the argument.
+  — *end note*]
 *Effects:* Initializes `*this` to hold the alternative type `Tⱼ` and
 direct-initializes the contained value as if
 direct-non-list-initializing it with `std::forward<T>(t)`.
+*Ensures:* `holds_alternative<``Tⱼ``>(*this)` is `true`.
 *Throws:* Any exception thrown by the initialization of the selected
 alternative `Tⱼ`.
+*Remarks:* The expression inside `noexcept` is equivalent to
 `is_nothrow_constructible_v<``Tⱼ``, T>`. If `Tⱼ`’s selected constructor
+is a constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
 template<class T, class... Args> constexpr explicit variant(in_place_type_t<T>, Args&&... args);
 ```
+*Constraints:*
+- There is exactly one occurrence of `T` in `Types...` and
+- `is_constructible_v<T, Args...>` is `true`.
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `std::forward<Args>(args)...`.
+*Ensures:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
+*Remarks:* If `T`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 ``` cpp
 template<class T, class U, class... Args>
   constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
 ```
+*Constraints:*
+- There is exactly one occurrence of `T` in `Types...` and
+- `is_constructible_v<T, initializer_list<U>&, Args...>` is `true`.
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `il, std::forward<Args>(args)...`.
+*Ensures:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
+*Remarks:* If `T`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 ``` cpp
 template<size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>, Args&&... args);
 ```
+*Constraints:*
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, Args...>` is `true`.
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T_I` with the arguments
+`std::forward<Args>(args)...`.
+*Ensures:* `index()` is `I`.
+*Throws:* Any exception thrown by calling the selected constructor of
+`T_I`.
+*Remarks:* If `T_I`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 ``` cpp
 template<size_t I, class U, class... Args>
   constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&... args);
 ```
+*Constraints:*
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
   `true`.
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T_I` with the arguments
+`il, std::forward<Args>(args)...`.
+*Ensures:* `index()` is `I`.
+*Remarks:* If `T_I`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 #### Destructor <a id="variant.dtor">[[variant.dtor]]</a>
 ``` cpp
 ~variant();
 ```
 *Effects:* If `valueless_by_exception()` is `false`, destroys the
 currently contained value.
+*Remarks:* If `is_trivially_destructible_v<``Tᵢ``>` is `true` for all
+`Tᵢ`, then this destructor is trivial.
 #### Assignment <a id="variant.assign">[[variant.assign]]</a>
 ``` cpp
+constexpr variant& operator=(const variant& rhs);
 ```
 Let j be `rhs.index()`.
 *Effects:*
 - If neither `*this` nor `rhs` holds a value, there is no effect.
+- Otherwise, if `*this` holds a value but `rhs` does not, destroys the
+  value contained in `*this` and sets `*this` to not hold a value.
+- Otherwise, if `index() == `j, assigns the value contained in `rhs` to
+ the value contained in `*this`.
+- Otherwise, if either `is_nothrow_copy_constructible_v<``Tⱼ``>` is
+  `true` or `is_nothrow_move_constructible_v<``Tⱼ``>` is `false`,
+ equivalent to `emplace<`j`>(get<`j`>(rhs))`.
+- Otherwise, equivalent to `operator=(variant(rhs))`.
 *Returns:* `*this`.
+*Ensures:* `index() == rhs.index()`.
+*Remarks:* This operator is defined as deleted unless
+`is_copy_constructible_v<``Tᵢ``> &&` `is_copy_assignable_v<``Tᵢ``>` is
+`true` for all i. If `is_trivially_copy_constructible_v<``Tᵢ``> &&`
+`is_trivially_copy_assignable_v<``Tᵢ``> &&`
+`is_trivially_destructible_v<``Tᵢ``>` is `true` for all i, this
+assignment operator is trivial.
 ``` cpp
+constexpr variant& operator=(variant&& rhs) noexcept(see below);
 ```
 Let j be `rhs.index()`.
+*Constraints:* `is_move_constructible_v<``Tᵢ``> &&`
+`is_move_assignable_v<``Tᵢ``>` is `true` for all i.
 *Effects:*
 - If neither `*this` nor `rhs` holds a value, there is no effect.
+- Otherwise, if `*this` holds a value but `rhs` does not, destroys the
+  value contained in `*this` and sets `*this` to not hold a value.
+- Otherwise, if `index() == `j, assigns `get<`j`>(std::move(rhs))` to
+  the value contained in `*this`.
+- Otherwise, equivalent to `emplace<`j`>(get<`j`>(std::move(rhs)))`.
 *Returns:* `*this`.
+*Remarks:* If `is_trivially_move_constructible_v<``Tᵢ``> &&`
+`is_trivially_move_assignable_v<``Tᵢ``> &&`
+`is_trivially_destructible_v<``Tᵢ``>` is `true` for all i, this
+assignment operator is trivial. The expression inside `noexcept` is
+equivalent to:
 `is_nothrow_move_constructible_v<``Tᵢ``> && is_nothrow_move_assignable_v<``Tᵢ``>`
 for all i.
 - If an exception is thrown during the call to `Tⱼ`’s move construction
+  (with j being `rhs.index()`), the `variant` will hold no value.
 - If an exception is thrown during the call to `Tⱼ`’s move assignment,
   the state of the contained value is as defined by the exception safety
   guarantee of `Tⱼ`’s move assignment; `index()` will be j.
 ``` cpp
 template<class T> variant& operator=(T&& t) noexcept(see below);
 ```
 Let `Tⱼ` be a type that is determined as follows: build an imaginary
+function *FUN*(Tᵢ) for each alternative type `Tᵢ` for which `Tᵢ`` x[] =`
+`{std::forward<T>(t)};` is well-formed for some invented variable `x`.
+The overload *FUN*(Tⱼ) selected by overload resolution for the
+expression *FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ`
+which is the type of the contained value after assignment.
+*Constraints:*
+- `is_same_v<remove_cvref_t<T>, variant>` is `false`,
+- `is_assignable_v<``Tⱼ``&, T> && is_constructible_v<``Tⱼ``, T>` is
+  `true`, and
+- the expression *FUN*(std::forward\<T\>(t)) (with *FUN* being the
+  above-mentioned set of imaginary functions) is well-formed.
+  \[*Note 1*:
       variant<string, string> v;
       v = "abc";
   is ill-formed, as both alternative types have an equally viable
   constructor for the argument.
   — *end note*]
+*Effects:*
+- If `*this` holds a `Tⱼ`, assigns `std::forward<T>(t)` to the value
+  contained in `*this`.
+- Otherwise, if `is_nothrow_constructible_v<``Tⱼ``, T> ||`
+  `!is_nothrow_move_constructible_v<``Tⱼ``>` is `true`, equivalent to
+  `emplace<`j`>(std::forward<T>(t))`.
+- Otherwise, equivalent to `operator=(variant(std::forward<T>(t)))`.
+*Ensures:* `holds_alternative<``Tⱼ``>(*this)` is `true`, with `Tⱼ`
+selected by the imaginary function overload resolution described above.
+*Returns:* `*this`.
+*Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_assignable_v<Tⱼ&, T> && is_nothrow_constructible_v<Tⱼ, T>
 ```
 ``` cpp
 template<class T, class... Args> T& emplace(Args&&... args);
 ```
+*Constraints:* `is_constructible_v<T, Args...>` is `true`, and `T`
+occurs exactly once in `Types`.
 *Effects:* Equivalent to:
+``` cpp
+return emplace<I>(std::forward<Args>(args)...);
+```
+where I is the zero-based index of `T` in `Types`.
 ``` cpp
 template<class T, class U, class... Args> T& emplace(initializer_list<U> il, Args&&... args);
 ```
+*Constraints:* `is_constructible_v<T, initializer_list<U>&, Args...>` is
+`true`, and `T` occurs exactly once in `Types`.
 *Effects:* Equivalent to:
+``` cpp
+return emplace<I>(il, std::forward<Args>(args)...);
+```
+where I is the zero-based index of `T` in `Types`.
 ``` cpp
 template<size_t I, class... Args>
   variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Constraints:* `is_constructible_v<``T_I``, Args...>` is `true`.
 *Effects:* Destroys the currently contained value if
 `valueless_by_exception()` is `false`. Then initializes the contained
 value as if direct-non-list-initializing a value of type `T_I` with the
 arguments `std::forward<Args>(args)...`.
+*Ensures:* `index()` is `I`.
 *Returns:* A reference to the new contained value.
 *Throws:* Any exception thrown during the initialization of the
 contained value.
+*Remarks:* If an exception is thrown during the initialization of the
+contained value, the `variant` might not hold a value.
 ``` cpp
 template<size_t I, class U, class... Args>
   variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il, Args&&... args);
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Constraints:*
+`is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is `true`.
 *Effects:* Destroys the currently contained value if
 `valueless_by_exception()` is `false`. Then initializes the contained
 value as if direct-non-list-initializing a value of type `T_I` with the
 arguments `il, std::forward<Args>(args)...`.
+*Ensures:* `index()` is `I`.
 *Returns:* A reference to the new contained value.
 *Throws:* Any exception thrown during the initialization of the
 contained value.
+*Remarks:* If an exception is thrown during the initialization of the
 contained value, the `variant` might not hold a value.
 #### Value status <a id="variant.status">[[variant.status]]</a>
 ``` cpp
 ``` cpp
 void swap(variant& rhs) noexcept(see below);
 ```
+*Mandates:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
+*Preconditions:* Lvalues of type `Tᵢ` are
+swappable [[swappable.requirements]].
 *Effects:*
+- If `valueless_by_exception() && rhs.valueless_by_exception()` no
+  effect.
+- Otherwise, if `index() == rhs.index()`, calls
   `swap(get<`i`>(*this), get<`i`>(rhs))` where i is `index()`.
+- Otherwise, exchanges values of `rhs` and `*this`.
 *Throws:* If `index() == rhs.index()`, any exception thrown by
 `swap(get<`i`>(*this), get<`i`>(rhs))` with i being `index()`.
 Otherwise, any exception thrown by the move constructor of `Tᵢ` or `Tⱼ`
 with i being `index()` and j being `rhs.index()`.
 values of `*this` and of `rhs` are determined by the exception safety
 guarantee of `swap` for lvalues of `Tᵢ` with i being `index()`. If an
 exception is thrown during the exchange of the values of `*this` and
 `rhs`, the states of the values of `*this` and of `rhs` are determined
 by the exception safety guarantee of `variant`’s move constructor. The
+expression inside `noexcept` is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``> && is_nothrow_swappable_v<``Tᵢ``>`
 for all i.
 ### `variant` helper classes <a id="variant.helper">[[variant.helper]]</a>
 ``` cpp
 template<class T> struct variant_size;
 ```
+All specializations of `variant_size` meet the *Cpp17UnaryTypeTrait*
+requirements [[meta.rqmts]] with a base characteristic of
+`integral_constant<size_t, N>` for some `N`.
 ``` cpp
 template<class T> class variant_size<const T>;
 ```
 Let `VS` denote `variant_size<T>` of the cv-unqualified type `T`. Then
+each specialization of the template meets the *Cpp17UnaryTypeTrait*
+requirements [[meta.rqmts]] with a base characteristic of
 `integral_constant<size_t, VS::value>`.
 ``` cpp
 template<class... Types>
   struct variant_size<variant<Types...>> : integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
 template<size_t I, class T> class variant_alternative<I, const T>;
 ```
 Let `VA` denote `variant_alternative<I, T>` of the cv-unqualified type
+`T`. Then each specialization of the template meets the
+*Cpp17TransformationTrait* requirements [[meta.rqmts]] with a member
+typedef `type` that names the type `add_const_t<VA::type>`.
 ``` cpp
 variant_alternative<I, variant<Types...>>::type
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Type:* The type `T_I`.
 ### Value access <a id="variant.get">[[variant.get]]</a>
 ``` cpp
 template<class T, class... Types>
   constexpr bool holds_alternative(const variant<Types...>& v) noexcept;
 ```
+*Mandates:* The type `T` occurs exactly once in `Types`.
 *Returns:* `true` if `index()` is equal to the zero-based index of `T`
+in `Types`.
 ``` cpp
 template<size_t I, class... Types>
   constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>& v);
 template<size_t I, class... Types>
   constexpr const variant_alternative_t<I, variant<Types...>>& get(const variant<Types...>& v);
 template<size_t I, class... Types>
   constexpr const variant_alternative_t<I, variant<Types...>>&& get(const variant<Types...>&& v);
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
 *Effects:* If `v.index()` is `I`, returns a reference to the object
 stored in the `variant`. Otherwise, throws an exception of type
 `bad_variant_access`.
 template<class T, class... Types> constexpr T&& get(variant<Types...>&& v);
 template<class T, class... Types> constexpr const T& get(const variant<Types...>& v);
 template<class T, class... Types> constexpr const T&& get(const variant<Types...>&& v);
 ```
+*Mandates:* The type `T` occurs exactly once in `Types`.
 *Effects:* If `v` holds a value of type `T`, returns a reference to that
 value. Otherwise, throws an exception of type `bad_variant_access`.
 ``` cpp
 template<size_t I, class... Types>
   constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
     get_if(const variant<Types...>* v) noexcept;
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
 *Returns:* A pointer to the value stored in the `variant`, if
 `v != nullptr` and `v->index() == I`. Otherwise, returns `nullptr`.
 ``` cpp
 template<class T, class... Types>
   constexpr add_pointer_t<const T>
     get_if(const variant<Types...>* v) noexcept;
 ```
+*Mandates:* The type `T` occurs exactly once in `Types`.
 *Effects:* Equivalent to: `return get_if<`i`>(v);` with i being the
+zero-based index of `T` in `Types`.
 ### Relational operators <a id="variant.relops">[[variant.relops]]</a>
 ``` cpp
 template<class... Types>
   constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Mandates:* `get<`i`>(v) == get<`i`>(w)` is a valid expression that is
+convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise
 `get<`i`>(v) == get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator!=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Mandates:* `get<`i`>(v) != get<`i`>(w)` is a valid expression that is
+convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise
 `get<`i`>(v) != get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Mandates:* `get<`i`>(v) < get<`i`>(w)` is a valid expression that is
+convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
 `false`; otherwise `get<`i`>(v) < get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator>(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Mandates:* `get<`i`>(v) > get<`i`>(w)` is a valid expression that is
+convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `false`; otherwise if
 `w.valueless_by_exception()`, `true`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
 `false`; otherwise `get<`i`>(v) > get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Mandates:* `get<`i`>(v) <= get<`i`>(w)` is a valid expression that is
+convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `true`; otherwise if
 `w.valueless_by_exception()`, `false`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
 `false`; otherwise `get<`i`>(v) <= get<`i`>(w)` with i being
 ``` cpp
 template<class... Types>
   constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Mandates:* `get<`i`>(v) >= get<`i`>(w)` is a valid expression that is
+convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
 `false`; otherwise `get<`i`>(v) >= get<`i`>(w)` with i being
 `v.index()`.
+``` cpp
+template<class... Types> requires (three_way_comparable<Types> && ...)
+  constexpr common_comparison_category_t<compare_three_way_result_t<Types>...>
+    operator<=>(const variant<Types...>& v, const variant<Types...>& w);
+```
+*Effects:* Equivalent to:
+``` cpp
+if (v.valueless_by_exception() && w.valueless_by_exception())
+  return strong_ordering::equal;
+if (v.valueless_by_exception()) return strong_ordering::less;
+if (w.valueless_by_exception()) return strong_ordering::greater;
+if (auto c = v.index() <=> w.index(); c != 0) return c;
+return get<i>(v) <=> get<i>(w);
+```
+with i being `v.index()`.
 ### Visitation <a id="variant.visit">[[variant.visit]]</a>
 ``` cpp
 template<class Visitor, class... Variants>
   constexpr see below visit(Visitor&& vis, Variants&&... vars);
+template<class R, class Visitor, class... Variants>
+  constexpr R visit(Visitor&& vis, Variants&&... vars);
 ```
+Let n be `sizeof...(Variants)`. Let `m` be a pack of n values of type
+`size_t`. Such a pack is called valid if 0 ≤
+`mᵢ` < `variant_size_v<remove_reference_t<Variantsᵢ``>>` for all
+0 ≤ i < n. For each valid pack `m`, let e(`m`) denote the expression:
+``` cpp
+INVOKE(std::forward<Visitor>(vis), get<m>(std::forward<Variants>(vars))...) // see [func.require]
+```
+for the first form and
+``` cpp
+INVOKE<R>(std::forward<Visitor>(vis), get<m>(std::forward<Variants>(vars))...) // see [func.require]
+```
+for the second form.
+*Mandates:* For each valid pack `m`, e(`m`) is a valid expression. All
+such expressions are of the same type and value category.
+*Returns:* e(`m`), where `m` is the pack for which `mᵢ` is
+`vars`ᵢ`.index()` for all 0 ≤ i < n. The return type is
+`decltype(`e(`m`)`)` for the first form.
 *Throws:* `bad_variant_access` if any `variant` in `vars` is
 `valueless_by_exception()`.
+*Complexity:* For n ≤ 1, the invocation of the callable object is
+implemented in constant time, i.e., for n = 1, it does not depend on the
+number of alternative types of `Variants₀`. For n > 1, the invocation of
 the callable object has no complexity requirements.
 ### Class `monostate` <a id="variant.monostate">[[variant.monostate]]</a>
 ``` cpp
 `variant` to make the `variant` type default constructible.
 ### `monostate` relational operators <a id="variant.monostate.relops">[[variant.monostate.relops]]</a>
 ``` cpp
 constexpr bool operator==(monostate, monostate) noexcept { return true; }
+constexpr strong_ordering operator<=>(monostate, monostate) noexcept
+{ return strong_ordering::equal; }
 ```
 [*Note 1*: `monostate` objects have only a single state; they thus
 always compare equal. — *end note*]
 ``` cpp
 template<class... Types>
   void swap(variant<Types...>& v, variant<Types...>& w) noexcept(see below);
 ```
+*Constraints:*
+`is_move_constructible_v<``Tᵢ``> && is_swappable_v<``Tᵢ``>` is `true`
+for all i.
 *Effects:* Equivalent to `v.swap(w)`.
+*Remarks:* The expression inside `noexcept` is equivalent to
 `noexcept(v.swap(w))`.
 ### Class `bad_variant_access` <a id="variant.bad.access">[[variant.bad.access]]</a>
 ``` cpp
 class bad_variant_access : public exception {
 public:
+ // see [exception] for the specification of the special member functions
   const char* what() const noexcept override;
 };
 ```
 Objects of type `bad_variant_access` are thrown to report invalid
 accesses to the value of a `variant` object.
 ``` cpp
 const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ``` cpp
 template<class... Types> struct hash<variant<Types...>>;
 ```
+The specialization `hash<variant<Types...>>` is enabled [[unord.hash]]
+if and only if every specialization in `hash<remove_const_t<Types>>...`
+is enabled. The member functions are not guaranteed to be `noexcept`.
 ``` cpp
 template<> struct hash<monostate>;
 ```
+The specialization is enabled [[unord.hash]].

Diff to HTML by rtfpessoa