[variant] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpjj1lp8ab/{from.md → to.md} +129 -61

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

@@ -1,17 +1,21 @@
 ## Variants <a id="variant">[[variant]]</a>
-### 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>
@@ -27,11 +31,11 @@ namespace std {
     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...>>;
   inline constexpr size_t variant_npos = -1;
@@ -39,26 +43,30 @@ namespace std {
   // [variant.get], value access
   template<class T, class... Types>
     constexpr bool holds_alternative(const variant<Types...>&) noexcept;
   template<size_t I, class... Types>
-    constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>&);
   template<size_t I, class... Types>
-    constexpr variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&&);
   template<size_t I, class... Types>
-    constexpr const variant_alternative_t<I, variant<Types...>>& get(const variant<Types...>&);
   template<size_t I, class... Types>
-    constexpr const variant_alternative_t<I, variant<Types...>>&& get(const variant<Types...>&&);
   template<class T, class... Types>
-    constexpr T& get(variant<Types...>&);
   template<class T, class... Types>
-    constexpr T&& get(variant<Types...>&&);
   template<class T, class... Types>
-    constexpr const T& get(const variant<Types...>&);
   template<class T, class... Types>
-    constexpr const T&& get(const variant<Types...>&&);
   template<size_t I, class... Types>
     constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
       get_if(variant<Types...>*) noexcept;
   template<size_t I, class... Types>
@@ -167,28 +175,35 @@ namespace std {
     constexpr bool valueless_by_exception() const noexcept;
     constexpr size_t index() const noexcept;
     // [variant.swap], swap
     constexpr void swap(variant&) noexcept(see below);
   };
 }
 ```
 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.
 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`.
@@ -216,11 +231,11 @@ equivalent to `is_nothrow_default_constructible_v<``T₀``>`.
 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.
@@ -235,12 +250,12 @@ 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 exception specification is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. If
@@ -394,11 +409,11 @@ Let j be `rhs.index()`.
   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))`.
 *Ensures:* `index() == rhs.index()`.
 *Returns:* `*this`.
@@ -422,13 +437,14 @@ 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:* If `is_trivially_move_constructible_v<``Tᵢ``> &&`
 `is_trivially_move_assignable_v<``Tᵢ``> &&`
@@ -626,26 +642,27 @@ requirements [[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()`.
 *Remarks:* If an exception is thrown during the call to function
-`swap(get<`i`>(*this), get<`i`>(rhs))`, the states of the contained
-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
-exception specification 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>
@@ -676,19 +693,19 @@ template<size_t I, class T> struct 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>
@@ -698,10 +715,31 @@ template<class T, class... Types>
 *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 variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&& v);
@@ -762,81 +800,83 @@ zero-based index of `T` in `Types`.
 ``` 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
 `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()`, `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>...>
@@ -849,11 +889,11 @@ template<class... Types> requires (three_way_comparable<Types> && ...)
 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>
@@ -868,17 +908,17 @@ template<class R, class Visitor, class... Variants>
 Let *as-variant* denote the following exposition-only function
 templates:
 ``` cpp
 template<class... Ts>
-  auto&& as-variant(variant<Ts...>& var) { return var; }
 template<class... Ts>
-  auto&& as-variant(const variant<Ts...>& var) { return var; }
 template<class... Ts>
-  auto&& as-variant(variant<Ts...>&& var) { return std::move(var); }
 template<class... Ts>
-  auto&& as-variant(const variant<Ts...>&& var) { return std::move(var); }
 ```
 Let n be `sizeof...(Variants)`. For each 0 ≤ i < n, let `Vᵢ` denote the
 type
 `decltype(`*`as-variant`*`(``std::forward<``Variantsᵢ``>(``varsᵢ``)``))`.
@@ -890,17 +930,17 @@ Let `V` denote the pack of types `Vᵢ`.
 Let m be a pack of n values of type `size_t`. Such a pack is valid if
 0 ≤ mᵢ < `variant_size_v<remove_reference_t<Vᵢ``>>` 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<V>(vars))...)  // see [func.require]
 ```
 for the first form and
 ``` cpp
-INVOKE<R>(std::forward<Visitor>(vis), get<m>(std::forward<V>(vars))...)  // see [func.require]
 ```
 for the second form.
 *Mandates:* For each valid pack m, e(m) is a valid expression. All such
@@ -916,10 +956,37 @@ expressions are of the same type and value category.
 *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 `V₀`. For n > 1, the invocation of the
 callable object has no complexity requirements.
 ### Class `monostate` <a id="variant.monostate">[[variant.monostate]]</a>
 ``` cpp
 struct monostate{};
 ```
@@ -959,23 +1026,24 @@ for all i.
 ``` cpp
 namespace std {
   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.
 ### Hash support <a id="variant.hash">[[variant.hash]]</a>
 ``` cpp
 template<class... Types> struct hash<variant<Types...>>;

 ## Variants <a id="variant">[[variant]]</a>
+### 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.
+In [[variant]], *`GET`* denotes a set of exposition-only function
+templates [[variant.get]].
 ### Header `<variant>` synopsis <a id="variant.syn">[[variant.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [variant.variant], class template variant
   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 = variant_alternative<I, T>::type;
   template<size_t I, class... Types>
     struct variant_alternative<I, variant<Types...>>;
   inline constexpr size_t variant_npos = -1;
   // [variant.get], value access
   template<class T, class... Types>
     constexpr bool holds_alternative(const variant<Types...>&) noexcept;
   template<size_t I, class... Types>
+    constexpr variant_alternative_t<I, variant<Types...>>&
+      get(variant<Types...>&);                                          // freestanding-deleted
   template<size_t I, class... Types>
+    constexpr variant_alternative_t<I, variant<Types...>>&&
+      get(variant<Types...>&&);                                         // freestanding-deleted
   template<size_t I, class... Types>
+    constexpr const variant_alternative_t<I, variant<Types...>>&
+      get(const variant<Types...>&);                                    // freestanding-deleted
   template<size_t I, class... Types>
+    constexpr const variant_alternative_t<I, variant<Types...>>&&
+      get(const variant<Types...>&&);                                   // freestanding-deleted
   template<class T, class... Types>
+    constexpr T& get(variant<Types...>&);                               // freestanding-deleted
   template<class T, class... Types>
+    constexpr T&& get(variant<Types...>&&);                             // freestanding-deleted
   template<class T, class... Types>
+    constexpr const T& get(const variant<Types...>&);                   // freestanding-deleted
   template<class T, class... Types>
+    constexpr const T&& get(const variant<Types...>&&);                 // freestanding-deleted
   template<size_t I, class... Types>
     constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
       get_if(variant<Types...>*) noexcept;
   template<size_t I, class... Types>
     constexpr bool valueless_by_exception() const noexcept;
     constexpr size_t index() const noexcept;
     // [variant.swap], swap
     constexpr void swap(variant&) noexcept(see below);
+    // [variant.visit], visitation
+    template<class Self, class Visitor>
+      constexpr decltype(auto) visit(this Self&&, Visitor&&);
+    template<class R, class Self, class Visitor>
+      constexpr R visit(this Self&&, Visitor&&);
   };
 }
 ```
 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
+nested within [[intro.object]] the `variant` object.
 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.
+If a program declares an explicit or partial specialization of
+`variant`, the program is ill-formed, no diagnostic required.
 #### 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`.
 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.
 *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 exception specification is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. If
   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))`.
 *Ensures:* `index() == rhs.index()`.
 *Returns:* `*this`.
 *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ᵢ``> &&`
 *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()`.
 *Remarks:* If an exception is thrown during the call to function
+`swap(`*`GET`*`<`i`>(*this), `*`GET`*`<`i`>(rhs))`, the states of the
+contained 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 exception specification 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>
 ```
 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 `const VA::type`.
 ``` cpp
 variant_alternative<I, variant<Types...>>::type
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
+*Result:* The type `T_I`.
 ### Value access <a id="variant.get">[[variant.get]]</a>
 ``` cpp
 template<class T, class... Types>
 *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);                                  // exposition only
+template<size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>>&&
+    GET(variant<Types...>&& v);                                 // exposition only
+template<size_t I, class... Types>
+  constexpr const variant_alternative_t<I, variant<Types...>>&
+    GET(const variant<Types...>& v);                            // exposition only
+template<size_t I, class... Types>
+  constexpr const variant_alternative_t<I, variant<Types...>>&&
+    GET(const variant<Types...>&& v);                           // exposition only
+```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Preconditions:* `v.index()` is `I`.
+*Returns:* A reference to the object stored in the `variant`.
 ``` 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 variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&& v);
 ``` cpp
 template<class... Types>
   constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`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);
 ```
+*Constraints:* *`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);
 ```
+*Constraints:* *`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);
 ```
+*Constraints:* *`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);
 ```
+*Constraints:* *`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
 `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`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>...>
 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>
 Let *as-variant* denote the following exposition-only function
 templates:
 ``` cpp
 template<class... Ts>
+ constexpr auto&& as-variant(variant<Ts...>& var) { return var; }
 template<class... Ts>
+ constexpr auto&& as-variant(const variant<Ts...>& var) { return var; }
 template<class... Ts>
+ constexpr auto&& as-variant(variant<Ts...>&& var) { return std::move(var); }
 template<class... Ts>
+ constexpr auto&& as-variant(const variant<Ts...>&& var) { return std::move(var); }
 ```
 Let n be `sizeof...(Variants)`. For each 0 ≤ i < n, let `Vᵢ` denote the
 type
 `decltype(`*`as-variant`*`(``std::forward<``Variantsᵢ``>(``varsᵢ``)``))`.
 Let m be a pack of n values of type `size_t`. Such a pack is valid if
 0 ≤ mᵢ < `variant_size_v<remove_reference_t<Vᵢ``>>` 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<V>(vars))...)  // see [func.require]
 ```
 for the first form and
 ``` cpp
+INVOKE<R>(std::forward<Visitor>(vis), GET<m>(std::forward<V>(vars))...)  // see [func.require]
 ```
 for the second form.
 *Mandates:* For each valid pack m, e(m) is a valid expression. All such
 *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 `V₀`. For n > 1, the invocation of the
 callable object has no complexity requirements.
+``` cpp
+template<class Self, class Visitor>
+  constexpr decltype(auto) visit(this Self&& self, Visitor&& vis);
+```
+Let `V` be
+*`OVERRIDE_REF`*`(Self&&, `*`COPY_CONST`*`(remove_reference_t<Self>, variant))`
+[[forward]].
+*Constraints:* The call to `visit` does not use an explicit
+*template-argument-list* that begins with a type *template-argument*.
+*Effects:* Equivalent to:
+`return std::visit(std::forward<Visitor>(vis), (V)self);`
+``` cpp
+template<class R, class Self, class Visitor>
+  constexpr R visit(this Self&& self, Visitor&& vis);
+```
+Let `V` be
+*`OVERRIDE_REF`*`(Self&&, `*`COPY_CONST`*`(remove_reference_t<Self>, variant))`
+[[forward]].
+*Effects:* Equivalent to:
+`return std::visit<R>(std::forward<Visitor>(vis), (V)self);`
 ### Class `monostate` <a id="variant.monostate">[[variant.monostate]]</a>
 ``` cpp
 struct monostate{};
 ```
 ``` cpp
 namespace std {
   class bad_variant_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr 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
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Hash support <a id="variant.hash">[[variant.hash]]</a>
 ``` cpp
 template<class... Types> struct hash<variant<Types...>>;

Diff to HTML by rtfpessoa