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

Files changed (1) hide show

tmp/tmp76wkpqab/{from.md → to.md} +102 -80

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

@@ -19,11 +19,11 @@ namespace std {
   // [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
@@ -102,11 +102,11 @@ namespace std {
   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.bad.access], class bad_variant_access
   class bad_variant_access;
   // [variant.hash], hash support
@@ -116,10 +116,12 @@ namespace std {
 }
 ```
 ### Class template `variant` <a id="variant.variant">[[variant.variant]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
   class variant {
   public:
@@ -140,47 +142,46 @@ namespace std {
       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>
-      T& emplace(Args&&...);
     template<class T, class U, class... Args>
-      T& emplace(initializer_list<U>, Args&&...);
     template<size_t I, class... Args>
-      variant_alternative_t<I, variant<Types...>>& emplace(Args&&...);
     template<size_t I, class U, class... Args>
-      variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U>, Args&&...);
     // [variant.status], value status
     constexpr bool valueless_by_exception() const noexcept;
     constexpr size_t index() const noexcept;
     // [variant.swap], swap
-    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. 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
@@ -203,13 +204,13 @@ 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);
@@ -239,12 +240,12 @@ 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);
@@ -272,19 +273,19 @@ which is the type of the contained value after construction.
   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);
@@ -293,13 +294,12 @@ template<class T, class... Args> constexpr explicit variant(in_place_type_t<T>,
 *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`.
@@ -315,13 +315,12 @@ template<class T, class U, class... 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`.
@@ -336,13 +335,12 @@ template<size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>
 *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`.
@@ -359,23 +357,22 @@ template<size_t I, class U, class... Args>
 - `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.
@@ -400,14 +397,14 @@ Let j be `rhs.index()`.
 - 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
@@ -434,23 +431,23 @@ Let j be `rhs.index()`.
 *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`.
@@ -478,18 +475,18 @@ which is the type of the contained value after assignment.
 - 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>
 ```
@@ -497,16 +494,16 @@ is_nothrow_assignable_v<Tⱼ&, T> && is_nothrow_constructible_v<Tⱼ, T>
   `std::forward<T>(t)` to the value contained in `*this`, the state of
   the contained value and `t` are as defined by the exception safety
   guarantee of the assignment expression; `valueless_by_exception()`
   will be `false`.
 - If an exception is thrown during the initialization of the contained
-  value, the `variant` object might not hold a value.
 #### Modifiers <a id="variant.mod">[[variant.mod]]</a>
 ``` 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`.
@@ -517,11 +514,12 @@ 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`.
@@ -533,56 +531,57 @@ 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
 constexpr bool valueless_by_exception() const noexcept;
@@ -590,14 +589,14 @@ constexpr bool valueless_by_exception() const noexcept;
 *Effects:* Returns `false` if and only if the `variant` holds a value.
 [*Note 1*:
-A `variant` might not hold a value if an exception is thrown during a
-type-changing assignment or emplacement. The latter means that even a
-`variant<float, int>` can become `valueless_by_exception()`, for
-instance by
 ``` cpp
 struct S { operator int() { throw 42; }};
 variant<float, int> v{12.f};
 v.emplace<1>(S());
@@ -614,17 +613,17 @@ constexpr size_t index() const noexcept;
 alternative of the contained value.
 #### Swap <a id="variant.swap">[[variant.swap]]</a>
 ``` 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.
@@ -642,11 +641,11 @@ 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>
@@ -657,11 +656,11 @@ 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
@@ -671,11 +670,11 @@ requirements [[meta.rqmts]] with a base characteristic of
 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
@@ -864,41 +863,62 @@ 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
 struct monostate{};
@@ -920,30 +940,32 @@ always compare equal. — *end note*]
 ### Specialized algorithms <a id="variant.specalg">[[variant.specalg]]</a>
 ``` 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.

   // [variant.helper], variant helper classes
   template<class T> struct variant_size;                        // not defined
   template<class T> struct variant_size<const T>;
   template<class T>
+    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
   constexpr bool operator==(monostate, monostate) noexcept;
   constexpr strong_ordering operator<=>(monostate, monostate) noexcept;
   // [variant.specalg], specialized algorithms
   template<class... Types>
+ constexpr void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
   // [variant.bad.access], class bad_variant_access
   class bad_variant_access;
   // [variant.hash], hash support
 }
 ```
 ### Class template `variant` <a id="variant.variant">[[variant.variant]]</a>
+#### General <a id="variant.variant.general">[[variant.variant.general]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
   class variant {
   public:
       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
+ constexpr ~variant();
     // [variant.assign], assignment
     constexpr variant& operator=(const variant&);
     constexpr variant& operator=(variant&&) noexcept(see below);
+    template<class T> constexpr variant& operator=(T&&) noexcept(see below);
     // [variant.mod], modifiers
     template<class T, class... Args>
+ constexpr T& emplace(Args&&...);
     template<class T, class U, class... Args>
+ constexpr T& emplace(initializer_list<U>, Args&&...);
     template<size_t I, class... Args>
+ constexpr variant_alternative_t<I, variant<Types...>>& emplace(Args&&...);
     template<size_t I, class U, class... Args>
+ constexpr variant_alternative_t<I, variant<Types...>>&
+        emplace(initializer_list<U>, Args&&...);
     // [variant.status], value status
     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
 *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 be
+constexpr-suitable [[dcl.constexpr]]. The exception specification is
+equivalent to `is_nothrow_default_constructible_v<``T₀``>`.
 [*Note 1*: See also class `monostate`. — *end note*]
 ``` cpp
 constexpr variant(const variant& w);
 `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
 `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);
   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-non-list-initializes the contained value 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 exception specification 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:* Direct-non-list-initializes the contained value of type `T`
+with `std::forward<Args>(args)...`.
 *Ensures:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
 *Constraints:*
 - There is exactly one occurrence of `T` in `Types...` and
 - `is_constructible_v<T, initializer_list<U>&, Args...>` is `true`.
+*Effects:* Direct-non-list-initializes the contained value of type `T`
+with `il, std::forward<Args>(args)...`.
 *Ensures:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
 *Constraints:*
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, Args...>` is `true`.
+*Effects:* Direct-non-list-initializes the contained value of type `T_I`
+with `std::forward<Args>(args)...`.
 *Ensures:* `index()` is `I`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T_I`.
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
   `true`.
+*Effects:* Direct-non-list-initializes the contained value of type `T_I`
+with `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
+constexpr ~variant();
 ```
 *Effects:* If `valueless_by_exception()` is `false`, destroys the
 currently contained value.
 - 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`.
 *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
 *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 exception specification 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> constexpr 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`.
 - 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 `emplace<`j`>(``Tⱼ``(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 exception specification is equivalent to:
 ``` cpp
 is_nothrow_assignable_v<Tⱼ&, T> && is_nothrow_constructible_v<Tⱼ, T>
 ```
   `std::forward<T>(t)` to the value contained in `*this`, the state of
   the contained value and `t` are as defined by the exception safety
   guarantee of the assignment expression; `valueless_by_exception()`
   will be `false`.
 - If an exception is thrown during the initialization of the contained
+  value, the `variant` object is permitted to not hold a value.
 #### Modifiers <a id="variant.mod">[[variant.mod]]</a>
 ``` cpp
+template<class T, class... Args> constexpr T& emplace(Args&&... args);
 ```
 *Constraints:* `is_constructible_v<T, Args...>` is `true`, and `T`
 occurs exactly once in `Types`.
 ```
 where I is the zero-based index of `T` in `Types`.
 ``` cpp
+template<class T, class U, class... Args>
+  constexpr 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`.
 where I is the zero-based index of `T` in `Types`.
 ``` cpp
 template<size_t I, class... Args>
+ constexpr 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 direct-non-list-initializes
+the contained 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` is permitted to not hold a value.
 ``` cpp
 template<size_t I, class U, class... Args>
+ constexpr 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 direct-non-list-initializes
+the contained value of type `T_I` with
+`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` is permitted to not hold a value.
 #### Value status <a id="variant.status">[[variant.status]]</a>
 ``` cpp
 constexpr bool valueless_by_exception() const noexcept;
 *Effects:* Returns `false` if and only if the `variant` holds a value.
 [*Note 1*:
+It is possible for a `variant` to hold no value if an exception is
+thrown during a type-changing assignment or emplacement. The latter
+means that even a `variant<float, int>` can become
+`valueless_by_exception()`, for instance by
 ``` cpp
 struct S { operator int() { throw 42; }};
 variant<float, int> v{12.f};
 v.emplace<1>(S());
 alternative of the contained value.
 #### Swap <a id="variant.swap">[[variant.swap]]</a>
 ``` cpp
+constexpr void swap(variant& rhs) noexcept(see below);
 ```
 *Mandates:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
+*Preconditions:* Each `Tᵢ` meets the *Cpp17Swappable*
+requirements [[swappable.requirements]].
 *Effects:*
 - If `valueless_by_exception() && rhs.valueless_by_exception()` no
   effect.
 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>
 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> struct 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
 template<class... Types>
   struct variant_size<variant<Types...>> : integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
+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
   constexpr see below visit(Visitor&& vis, Variants&&... vars);
 template<class R, class Visitor, class... Variants>
   constexpr R visit(Visitor&& vis, Variants&&... vars);
 ```
+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ᵢ``)``))`.
+*Constraints:* `Vᵢ` is a valid type for all 0 ≤ i < n.
+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
+expressions are of the same type and value category.
+*Returns:* e(m), where m is the pack for which mᵢ is
+*`as-variant`*`(vars`ᵢ`).index()` for all 0 ≤ i < n. The return type is
+`decltype(`e(m)`)` for the first form.
+*Throws:* `bad_variant_access` if
+`(`*`as-variant`*`(vars).valueless_by_exception() || ...)` is `true`.
 *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{};
 ### Specialized algorithms <a id="variant.specalg">[[variant.specalg]]</a>
 ``` cpp
 template<class... Types>
+ constexpr 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 exception specification is equivalent to
 `noexcept(v.swap(w))`.
 ### Class `bad_variant_access` <a id="variant.bad.access">[[variant.bad.access]]</a>
 ``` 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.

Diff to HTML by rtfpessoa