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

Files changed (1) hide show

tmp/tmpy4ltest6/{from.md → to.md} +76 -102

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

@@ -1,210 +1,184 @@
 #### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
-`sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types...`.
 ``` cpp
 constexpr variant() noexcept(see below);
 ```
 *Effects:* Constructs a `variant` holding a value-initialized value of
 type `T₀`.
-*Postconditions:* `valueless_by_exception()` is `false` and `index()` is
-`0`.
 *Throws:* Any exception thrown by the value-initialization of `T₀`.
-*Remarks:* This function shall be `constexpr` if and only if the
 value-initialization of the alternative type `T₀` would satisfy the
 requirements for a constexpr function. The expression inside `noexcept`
-is equivalent to `is_nothrow_default_constructible_v<``T₀``>`. This
-function shall not participate in overload resolution unless
-`is_default_constructible_v<``T₀``>` is `true`.
 [*Note 1*: See also class `monostate`. — *end note*]
 ``` cpp
-variant(const variant& w);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
 `variant` to not hold a value.
 *Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
 i.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_copy_constructible_v<``Tᵢ``>` is `true` for all i.
 ``` cpp
-variant(variant&& w) noexcept(see below);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(std::move(w))`, where `j` is `w.index()`. Otherwise, initializes
 the `variant` to not hold a value.
 *Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
-AND of `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. This
-function shall not participate in overload resolution unless
-`is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 ``` cpp
 template<class T> constexpr variant(T&& t) noexcept(see below);
 ```
 Let `Tⱼ` be a type that is determined as follows: build an imaginary
-function *FUN*(Tᵢ) for each alternative type `Tᵢ`. The overload
-*FUN*(Tⱼ) selected by overload resolution for the expression
-*FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ` which is the
-type of the contained value after construction.
 *Effects:* Initializes `*this` to hold the alternative type `Tⱼ` and
 direct-initializes the contained value as if
 direct-non-list-initializing it with `std::forward<T>(t)`.
-*Postconditions:* `holds_alternative<``Tⱼ``>(*this)` is `true`.
 *Throws:* Any exception thrown by the initialization of the selected
 alternative `Tⱼ`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_same_v<decay_t<T>, variant>` is `false`, unless `decay_t<T>`
-is neither a specialization of `in_place_type_t` nor a specialization of
-`in_place_index_t`, unless `is_constructible_v<``Tⱼ``, T>` is `true`,
-and unless the expression *FUN*(`std::forward<T>(t))` (with *FUN* being
-the above-mentioned set of imaginary functions) is well formed.
-[*Note 2*:
-``` cpp
-variant<string, string> v("abc");
-```
-is ill-formed, as both alternative types have an equally viable
-constructor for the argument.
-— *end note*]
-The expression inside `noexcept` is equivalent to
 `is_nothrow_constructible_v<``Tⱼ``, T>`. If `Tⱼ`’s selected constructor
-is a constexpr constructor, this constructor shall be a constexpr
-constructor.
 ``` cpp
 template<class T, class... Args> constexpr explicit variant(in_place_type_t<T>, Args&&... args);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `std::forward<Args>(args)...`.
-*Postconditions:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
-*Remarks:* This function shall not participate in overload resolution
-unless there is exactly one occurrence of `T` in `Types...` and
-`is_constructible_v<T, Args...>` is `true`. If `T`’s selected
-constructor is a constexpr constructor, this constructor shall be a
-constexpr constructor.
 ``` cpp
 template<class T, class U, class... Args>
   constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `il, std::forward<Args>(args)...`.
-*Postconditions:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
-*Remarks:* This function shall not participate in overload resolution
-unless there is exactly one occurrence of `T` in `Types...` and
-`is_constructible_v<T, initializer_list<U>&, Args...>` is `true`. If
-`T`’s selected constructor is a constexpr constructor, this constructor
-shall be a constexpr constructor.
 ``` cpp
 template<size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>, Args&&... args);
 ```
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T_I` with the arguments
-`std::forward<Args>(args)...`.
-*Postconditions:* `index()` is `I`.
-*Throws:* Any exception thrown by calling the selected constructor of
-`T_I`.
-*Remarks:* This function shall not participate in overload resolution
-unless
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, Args...>` is `true`.
-If `T_I`’s selected constructor is a constexpr constructor, this
-constructor shall be a constexpr constructor.
 ``` cpp
 template<size_t I, class U, class... Args>
   constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&... args);
 ```
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T_I` with the arguments
-`il, std::forward<Args>(args)...`.
-*Postconditions:* `index()` is `I`.
-*Remarks:* This function shall not participate in overload resolution
-unless
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
   `true`.
-If `T_I`’s selected constructor is a constexpr constructor, this
-constructor shall be a constexpr constructor.
-``` cpp
-// allocator-extended constructors
-template <class Alloc>
-  variant(allocator_arg_t, const Alloc& a);
-template <class Alloc>
-  variant(allocator_arg_t, const Alloc& a, const variant& v);
-template <class Alloc>
-  variant(allocator_arg_t, const Alloc& a, variant&& v);
-template <class Alloc, class T>
-  variant(allocator_arg_t, const Alloc& a, T&& t);
-template <class Alloc, class T, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>, Args&&... args);
-template <class Alloc, class T, class U, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>,
-          initializer_list<U> il, Args&&... args);
-template <class Alloc, size_t I, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>, Args&&... args);
-template <class Alloc, size_t I, class U, class... Args>
-  variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>,
-          initializer_list<U> il, Args&&... args);
-```
-*Requires:* `Alloc` shall meet the requirements for an
-Allocator ([[allocator.requirements]]).
-*Effects:* Equivalent to the preceding constructors except that the
-contained value is constructed with uses-allocator
-construction ([[allocator.uses.construction]]).

 #### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
+`sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types`.
 ``` cpp
 constexpr variant() noexcept(see below);
 ```
+*Constraints:* `is_default_constructible_v<``T₀``>` is `true`.
 *Effects:* Constructs a `variant` holding a value-initialized value of
 type `T₀`.
+*Ensures:* `valueless_by_exception()` is `false` and `index()` is `0`.
 *Throws:* Any exception thrown by the value-initialization of `T₀`.
+*Remarks:* This function is `constexpr` if and only if the
 value-initialization of the alternative type `T₀` would satisfy the
 requirements for a constexpr function. The expression inside `noexcept`
+is equivalent to `is_nothrow_default_constructible_v<``T₀``>`.
 [*Note 1*: See also class `monostate`. — *end note*]
 ``` cpp
+constexpr variant(const variant& w);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
 `variant` to not hold a value.
 *Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
 i.
+*Remarks:* This constructor is defined as deleted unless
+`is_copy_constructible_v<``Tᵢ``>` is `true` for all i. If
+`is_trivially_copy_constructible_v<``Tᵢ``>` is `true` for all i, this
+constructor is trivial.
 ``` cpp
+constexpr variant(variant&& w) noexcept(see below);
 ```
+*Constraints:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
 `get<j>(std::move(w))`, where `j` is `w.index()`. Otherwise, initializes
 the `variant` to not hold a value.
 *Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
+of `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. If
+`is_trivially_move_constructible_v<``Tᵢ``>` is `true` for all i, this
+constructor is trivial.
 ``` cpp
 template<class T> constexpr variant(T&& t) noexcept(see below);
 ```
 Let `Tⱼ` be a type that is determined as follows: build an imaginary
+function *FUN*(Tᵢ) for each alternative type `Tᵢ` for which `Tᵢ`` x[] =`
+`{std::forward<T>(t)};` is well-formed for some invented variable `x`.
+The overload *FUN*(Tⱼ) selected by overload resolution for the
+expression *FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ`
+which is the type of the contained value after construction.
+*Constraints:*
+- `sizeof...(Types)` is nonzero,
+- `is_same_v<remove_cvref_t<T>, variant>` is `false`,
+- `remove_cvref_t<T>` is neither a specialization of `in_place_type_t`
+  nor a specialization of `in_place_index_t`,
+- `is_constructible_v<``Tⱼ``, T>` is `true`, and
+- the expression *FUN*(`std::forward<T>(t))` (with *FUN* being the
+  above-mentioned set of imaginary functions) is well-formed.
+  \[*Note 1*:
+      variant<string, string> v("abc");
+  is ill-formed, as both alternative types have an equally viable
+  constructor for the argument.
+  — *end note*]
 *Effects:* Initializes `*this` to hold the alternative type `Tⱼ` and
 direct-initializes the contained value as if
 direct-non-list-initializing it with `std::forward<T>(t)`.
+*Ensures:* `holds_alternative<``Tⱼ``>(*this)` is `true`.
 *Throws:* Any exception thrown by the initialization of the selected
 alternative `Tⱼ`.
+*Remarks:* The expression inside `noexcept` is equivalent to
 `is_nothrow_constructible_v<``Tⱼ``, T>`. If `Tⱼ`’s selected constructor
+is a constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
 template<class T, class... Args> constexpr explicit variant(in_place_type_t<T>, Args&&... args);
 ```
+*Constraints:*
+- There is exactly one occurrence of `T` in `Types...` and
+- `is_constructible_v<T, Args...>` is `true`.
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `std::forward<Args>(args)...`.
+*Ensures:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
+*Remarks:* If `T`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 ``` cpp
 template<class T, class U, class... Args>
   constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
 ```
+*Constraints:*
+- There is exactly one occurrence of `T` in `Types...` and
+- `is_constructible_v<T, initializer_list<U>&, Args...>` is `true`.
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `il, std::forward<Args>(args)...`.
+*Ensures:* `holds_alternative<T>(*this)` is `true`.
 *Throws:* Any exception thrown by calling the selected constructor of
 `T`.
+*Remarks:* If `T`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 ``` cpp
 template<size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>, Args&&... args);
 ```
+*Constraints:*
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, Args...>` is `true`.
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T_I` with the arguments
+`std::forward<Args>(args)...`.
+*Ensures:* `index()` is `I`.
+*Throws:* Any exception thrown by calling the selected constructor of
+`T_I`.
+*Remarks:* If `T_I`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.
 ``` cpp
 template<size_t I, class U, class... Args>
   constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&... args);
 ```
+*Constraints:*
 - `I` is less than `sizeof...(Types)` and
 - `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
   `true`.
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T_I` with the arguments
+`il, std::forward<Args>(args)...`.
+*Ensures:* `index()` is `I`.
+*Remarks:* If `T_I`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor.

Diff to HTML by rtfpessoa