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

Files changed (1) hide show

tmp/tmprzmdeaq8/{from.md → to.md} +16 -20

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

@@ -15,13 +15,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);
@@ -51,12 +51,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);
@@ -84,19 +84,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);
@@ -105,13 +105,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`.
@@ -127,13 +126,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`.
@@ -148,13 +146,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`.
@@ -171,13 +168,12 @@ 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.

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

Diff to HTML by rtfpessoa