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

Files changed (1) hide show

tmp/tmpq_16yexh/{from.md → to.md} +58 -59

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

@@ -1,7 +1,9 @@
 ### Class template `variant` <a id="variant.variant">[[variant.variant]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
   class variant {
   public:
@@ -22,47 +24,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
@@ -85,13 +86,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);
@@ -121,12 +122,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);
@@ -154,19 +155,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);
@@ -175,13 +176,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`.
@@ -197,13 +197,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`.
@@ -218,13 +217,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`.
@@ -241,23 +239,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.
@@ -282,14 +279,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
@@ -316,23 +313,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`.
@@ -360,18 +357,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>
 ```
@@ -379,16 +376,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`.
@@ -399,11 +396,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`.
@@ -415,56 +413,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;
@@ -472,14 +471,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());
@@ -496,17 +495,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.
@@ -524,9 +523,9 @@ 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.

 ### 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.

Diff to HTML by rtfpessoa