[pairs] - C++17 → C++20

Files changed (1) hide show

tmp/tmpixptdx7d/{from.md → to.md} +162 -145

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

@@ -20,122 +20,157 @@ namespace std {
     T1 first;
     T2 second;
     pair(const pair&) = default;
     pair(pair&&) = default;
-      \EXPLICIT constexpr pair();
-      \EXPLICIT constexpr pair(const T1& x, const T2& y);
- template<class U1, class U2> \EXPLICIT constexpr pair(U1&& x, U2&& y);
- template<class U1, class U2> \EXPLICIT constexpr pair(const pair<U1, U2>& p);
- template<class U1, class U2> \EXPLICIT constexpr pair(pair<U1, U2>&& p);
     template<class... Args1, class... Args2>
- pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args);
- pair& operator=(const pair& p);
- template<class U1, class U2> pair& operator=(const pair<U1, U2>& p);
-      pair& operator=(pair&& p) noexcept(see below);
-      template<class U1, class U2> pair& operator=(pair<U1, U2>&& p);
- void swap(pair& p) noexcept(see below);
   };
   template<class T1, class T2>
     pair(T1, T2) -> pair<T1, T2>;
 }
 ```
-Constructors and member functions of `pair` shall not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
-The defaulted move and copy constructor, respectively, of `pair` shall
-be a constexpr function if and only if all required element-wise
-initializations for copy and move, respectively, would satisfy the
-requirements for a constexpr function. The destructor of `pair` shall be
-a trivial destructor if
 `(is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>)`
-is `true`.
 ``` cpp
-\EXPLICIT constexpr pair();
 ```
 *Effects:* Value-initializes `first` and `second`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_default_constructible_v<first_type>` is `true` and
-`is_default_constructible_v<second_type>` is `true`.
-[*Note 1*: This behavior can be implemented by a constructor template
-with default template arguments. — *end note*]
-The constructor is explicit if and only if either `first_type` or
-`second_type` is not implicitly default-constructible.
-[*Note 2*: This behavior can be implemented with a trait that checks
 whether a `const first_type&` or a `const second_type&` can be
 initialized with `{}`. — *end note*]
 ``` cpp
-\EXPLICIT constexpr pair(const T1& x, const T2& y);
 ```
 *Effects:* Initializes `first` with `x` and `second` with `y`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_copy_constructible_v<first_type>` is `true` and
-`is_copy_constructible_v<second_type>` is `true`. The constructor is
-explicit if and only if
-`is_convertible_v<const first_type&, first_type>` is `false` or
-`is_convertible_v<const second_type&, second_type>` is `false`.
 ``` cpp
-template<class U1, class U2> \EXPLICIT constexpr pair(U1&& x, U2&& y);
 ```
 *Effects:* Initializes `first` with `std::forward<U1>(x)` and `second`
 with `std::forward<U2>(y)`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_constructible_v<first_type, U1&&>` is `true` and
-`is_constructible_v<second_type, U2&&>` is `true`. The constructor is
-explicit if and only if `is_convertible_v<U1&&, first_type>` is `false`
-or `is_convertible_v<U2&&, second_type>` is `false`.
 ``` cpp
-template<class U1, class U2> \EXPLICIT constexpr pair(const pair<U1, U2>& p);
 ```
 *Effects:* Initializes members from the corresponding members of the
 argument.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_constructible_v<first_type, const U1&>` is `true` and
-`is_constructible_v<second_type, const U2&>` is `true`. The constructor
-is explicit if and only if `is_convertible_v<const U1&, first_type>` is
-`false` or `is_convertible_v<const U2&, second_type>` is `false`.
 ``` cpp
-template<class U1, class U2> \EXPLICIT constexpr pair(pair<U1, U2>&& p);
 ```
 *Effects:* Initializes `first` with `std::forward<U1>(p.first)` and
 `second` with `std::forward<U2>(p.second)`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_constructible_v<first_type, U1&&>` is `true` and
-`is_constructible_v<second_type, U2&&>` is `true`. The constructor is
-explicit if and only if `is_convertible_v<U1&&, first_type>` is `false`
-or `is_convertible_v<U2&&, second_type>` is `false`.
 ``` cpp
 template<class... Args1, class... Args2>
-  pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
-*Requires:* `is_constructible_v<first_type, Args1&&...>` is `true` and
-`is_constructible_v<second_type, Args2&&...>` is `true`.
 *Effects:* Initializes `first` with arguments of types `Args1...`
 obtained by forwarding the elements of `first_args` and initializes
 `second` with arguments of types `Args2...` obtained by forwarding the
 elements of `second_args`. (Here, forwarding an element `x` of type `U`
@@ -143,74 +178,76 @@ within a `tuple` object means calling `std::forward<U>(x)`.) This form
 of construction, whereby constructor arguments for `first` and `second`
 are each provided in a separate `tuple` object, is called *piecewise
 construction*.
 ``` cpp
-pair& operator=(const pair& p);
 ```
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
-*Remarks:* This operator shall be defined as deleted unless
 `is_copy_assignable_v<first_type>` is `true` and
 `is_copy_assignable_v<second_type>` is `true`.
 *Returns:* `*this`.
 ``` cpp
-template<class U1, class U2> pair& operator=(const pair<U1, U2>& p);
 ```
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `is_assignable_v<first_type&, const U1&>` is `true` and
-`is_assignable_v<second_type&, const U2&>` is `true`.
 *Returns:* `*this`.
 ``` cpp
-pair& operator=(pair&& p) noexcept(see below);
 ```
 *Effects:* Assigns to `first` with `std::forward<first_type>(p.first)`
 and to `second` with
 `std::forward<second_type>(p.second)`.
-*Remarks:* This operator shall be defined as deleted unless
-`is_move_assignable_v<first_type>` is `true` and
-`is_move_assignable_v<second_type>` is `true`.
 *Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_move_assignable_v<T1> && is_nothrow_move_assignable_v<T2>
 ```
-*Returns:* `*this`.
 ``` cpp
-template<class U1, class U2> pair& operator=(pair<U1, U2>&& p);
 ```
-*Effects:* Assigns to `first` with `std::forward<U>(p.first)` and to
 `second` with
-`std::forward<V>(p.second)`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `is_assignable_v<first_type&, U1&&>` is `true` and
-`is_assignable_v<second_type&, U2&&>` is `true`.
 *Returns:* `*this`.
 ``` cpp
-void swap(pair& p) noexcept(see below);
 ```
-*Requires:* `first` shall be swappable
-with ([[swappable.requirements]]) `p.first` and `second` shall be
-swappable with `p.second`.
 *Effects:* Swaps `first` with `p.first` and `second` with `p.second`.
 *Remarks:* The expression inside `noexcept` is equivalent to:
@@ -227,65 +264,44 @@ template <class T1, class T2>
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template<class T1, class T2>
-  constexpr bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:*
-`x.first < y.first || (!(y.first < x.first) && x.second < y.second)`.
 ``` cpp
-template <class T1, class T2>
-  constexpr bool operator!=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
-*Returns:* `!(x == y)`.
-``` cpp
-template <class T1, class T2>
-  constexpr bool operator>(const pair<T1, T2>& x, const pair<T1, T2>& y);
-```
-*Returns:* `y < x`.
-``` cpp
-template <class T1, class T2>
-  constexpr bool operator>=(const pair<T1, T2>& x, const pair<T1, T2>& y);
-```
-*Returns:* `!(x < y)`.
-``` cpp
-template <class T1, class T2>
-  constexpr bool operator<=(const pair<T1, T2>& x, const pair<T1, T2>& y);
-```
-*Returns:* `!(y < x)`.
-``` cpp
-template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y)
-  noexcept(noexcept(x.swap(y)));
-```
-*Effects:* As if by `x.swap(y)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_swappable_v<T1>` is `true` and `is_swappable_v<T2>` is
-`true`.
-``` cpp
-template <class T1, class T2>
-  constexpr pair<V1, V2> make_pair(T1&& x, T2&& y);
-```
-*Returns:* `pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))`,
-where `V1` and `V2` are determined as follows: Let `Ui` be `decay_t<Ti>`
-for each `Ti`. If `Ui` is a specialization of `reference_wrapper`, then
-`Vi` is `Ui::type&`, otherwise `Vi` is `Ui`.
 [*Example 1*:
 In place of:
 ``` cpp
@@ -306,20 +322,19 @@ a C++program may contain:
 template<class T1, class T2>
   struct tuple_size<pair<T1, T2>> : integral_constant<size_t, 2> { };
 ```
 ``` cpp
-tuple_element<0, pair<T1, T2>>::type
 ```
-*Value:* The type `T1`.
-``` cpp
-tuple_element<1, pair<T1, T2>>::type
-```
-*Value:* The type T2.
 ``` cpp
 template<size_t I, class T1, class T2>
   constexpr tuple_element_t<I, pair<T1, T2>>& get(pair<T1, T2>& p) noexcept;
 template<size_t I, class T1, class T2>
@@ -328,12 +343,16 @@ template<size_t I, class T1, class T2>
   constexpr tuple_element_t<I, pair<T1, T2>>&& get(pair<T1, T2>&& p) noexcept;
 template<size_t I, class T1, class T2>
   constexpr const tuple_element_t<I, pair<T1, T2>>&& get(const pair<T1, T2>&& p) noexcept;
 ```
-*Returns:* If `I == 0` returns a reference to `p.first`; if `I == 1`
-returns a reference to `p.second`; otherwise the program is ill-formed.
 ``` cpp
 template<class T1, class T2>
   constexpr T1& get(pair<T1, T2>& p) noexcept;
 template<class T1, class T2>
@@ -342,12 +361,11 @@ template <class T1, class T2>
   constexpr T1&& get(pair<T1, T2>&& p) noexcept;
 template<class T1, class T2>
   constexpr const T1&& get(const pair<T1, T2>&& p) noexcept;
 ```
-*Requires:* `T1` and `T2` are distinct types. Otherwise, the program is
-ill-formed.
 *Returns:* A reference to `p.first`.
 ``` cpp
 template<class T2, class T1>
@@ -358,12 +376,11 @@ template <class T2, class T1>
   constexpr T2&& get(pair<T1, T2>&& p) noexcept;
 template<class T2, class T1>
   constexpr const T2&& get(const pair<T1, T2>&& p) noexcept;
 ```
-*Requires:* `T1` and `T2` are distinct types. Otherwise, the program is
-ill-formed.
 *Returns:* A reference to `p.second`.
 ### Piecewise construction <a id="pair.piecewise">[[pair.piecewise]]</a>
@@ -372,12 +389,12 @@ struct piecewise_construct_t {
   explicit piecewise_construct_t() = default;
 };
 inline constexpr piecewise_construct_t piecewise_construct{};
 ```
-The `struct` `piecewise_construct_t` is an empty structure type used as
-a unique type to disambiguate constructor and function overloading.
 Specifically, `pair` has a constructor with `piecewise_construct_t` as
-the first argument, immediately followed by two `tuple` ([[tuple]])
 arguments used for piecewise construction of the elements of the `pair`
 object.

     T1 first;
     T2 second;
     pair(const pair&) = default;
     pair(pair&&) = default;
+ constexpr explicit(see below) pair();
+ constexpr explicit(see below) pair(const T1& x, const T2& y);
+ template<class U1, class U2>
+      constexpr explicit(see below) pair(U1&& x, U2&& y);
+ template<class U1, class U2>
+      constexpr explicit(see below) pair(const pair<U1, U2>& p);
+    template<class U1, class U2>
+      constexpr explicit(see below) pair(pair<U1, U2>&& p);
     template<class... Args1, class... Args2>
+      constexpr pair(piecewise_construct_t,
+                     tuple<Args1...> first_args, tuple<Args2...> second_args);
+    constexpr pair& operator=(const pair& p);
+ template<class U1, class U2>
+ constexpr pair& operator=(const pair<U1, U2>& p);
+    constexpr pair& operator=(pair&& p) noexcept(see below);
+    template<class U1, class U2>
+      constexpr pair& operator=(pair<U1, U2>&& p);
+    constexpr void swap(pair& p) noexcept(see below);
   };
   template<class T1, class T2>
     pair(T1, T2) -> pair<T1, T2>;
 }
 ```
+Constructors and member functions of `pair` do not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
+The defaulted move and copy constructor, respectively, of `pair` is a
+constexpr function if and only if all required element-wise
+initializations for move and copy, respectively, would satisfy the
+requirements for a constexpr function.
+If
 `(is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>)`
+is `true`, then the destructor of `pair` is trivial.
+`pair<T, U>` is a structural type [[temp.param]] if `T` and `U` are both
+structural types. Two values `p1` and `p2` of type `pair<T, U>` are
+template-argument-equivalent [[temp.type]] if and only if `p1.first` and
+`p2.first` are template-argument-equivalent and `p1.second` and
+`p2.second` are template-argument-equivalent.
 ``` cpp
+constexpr explicit(see below) pair();
 ```
+*Constraints:*
+- `is_default_constructible_v<first_type>` is `true` and
+- `is_default_constructible_v<second_type>` is `true`.
 *Effects:* Value-initializes `first` and `second`.
+*Remarks:* The expression inside `explicit` evaluates to `true` if and
+only if either `first_type` or `second_type` is not implicitly
+default-constructible.
+[*Note 1*: This behavior can be implemented with a trait that checks
 whether a `const first_type&` or a `const second_type&` can be
 initialized with `{}`. — *end note*]
 ``` cpp
+constexpr explicit(see below) pair(const T1& x, const T2& y);
 ```
+*Constraints:*
+- `is_copy_constructible_v<first_type>` is `true` and
+- `is_copy_constructible_v<second_type>` is `true`.
 *Effects:* Initializes `first` with `x` and `second` with `y`.
+*Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!is_convertible_v<const first_type&, first_type> ||
+  !is_convertible_v<const second_type&, second_type>
 ```
+``` cpp
+template<class U1, class U2> constexpr explicit(see below) pair(U1&& x, U2&& y);
+```
+*Constraints:*
+- `is_constructible_v<first_type, U1>` is `true` and
+- `is_constructible_v<second_type, U2>` is `true`.
 *Effects:* Initializes `first` with `std::forward<U1>(x)` and `second`
 with `std::forward<U2>(y)`.
+*Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!is_convertible_v<U1, first_type> || !is_convertible_v<U2, second_type>
 ```
+``` cpp
+template<class U1, class U2> constexpr explicit(see below) pair(const pair<U1, U2>& p);
+```
+*Constraints:*
+- `is_constructible_v<first_type, const U1&>` is `true` and
+- `is_constructible_v<second_type, const U2&>` is `true`.
 *Effects:* Initializes members from the corresponding members of the
 argument.
+*Remarks:* The expression inside explicit is equivalent to:
 ``` cpp
+!is_convertible_v<const U1&, first_type> || !is_convertible_v<const U2&, second_type>
 ```
+``` cpp
+template<class U1, class U2> constexpr explicit(see below) pair(pair<U1, U2>&& p);
+```
+*Constraints:*
+- `is_constructible_v<first_type, U1>` is `true` and
+- `is_constructible_v<second_type, U2>` is `true`.
 *Effects:* Initializes `first` with `std::forward<U1>(p.first)` and
 `second` with `std::forward<U2>(p.second)`.
+*Remarks:* The expression inside explicit is equivalent to:
+``` cpp
+!is_convertible_v<U1, first_type> || !is_convertible_v<U2, second_type>
+```
 ``` cpp
 template<class... Args1, class... Args2>
+ constexpr pair(piecewise_construct_t,
+                 tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
+*Mandates:*
+- `is_constructible_v<first_type, Args1...>` is `true` and
+- `is_constructible_v<second_type, Args2...>` is `true`.
 *Effects:* Initializes `first` with arguments of types `Args1...`
 obtained by forwarding the elements of `first_args` and initializes
 `second` with arguments of types `Args2...` obtained by forwarding the
 elements of `second_args`. (Here, forwarding an element `x` of type `U`
 of construction, whereby constructor arguments for `first` and `second`
 are each provided in a separate `tuple` object, is called *piecewise
 construction*.
 ``` cpp
+constexpr pair& operator=(const pair& p);
 ```
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
+*Remarks:* This operator is defined as deleted unless
 `is_copy_assignable_v<first_type>` is `true` and
 `is_copy_assignable_v<second_type>` is `true`.
 *Returns:* `*this`.
 ``` cpp
+template<class U1, class U2> constexpr pair& operator=(const pair<U1, U2>& p);
 ```
+*Constraints:*
+- `is_assignable_v<first_type&, const U1&>` is `true` and
+- `is_assignable_v<second_type&, const U2&>` is `true`.
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
 ``` cpp
+constexpr pair& operator=(pair&& p) noexcept(see below);
 ```
+*Constraints:*
+- `is_move_assignable_v<first_type>` is `true` and
+- `is_move_assignable_v<second_type>` is `true`.
 *Effects:* Assigns to `first` with `std::forward<first_type>(p.first)`
 and to `second` with
 `std::forward<second_type>(p.second)`.
+*Returns:* `*this`.
 *Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_move_assignable_v<T1> && is_nothrow_move_assignable_v<T2>
 ```
 ``` cpp
+template<class U1, class U2> constexpr pair& operator=(pair<U1, U2>&& p);
 ```
+*Constraints:*
+- `is_assignable_v<first_type&, U1>` is `true` and
+- `is_assignable_v<second_type&, U2>` is `true`.
+*Effects:* Assigns to `first` with `std::forward<U1>(p.first)` and to
 `second` with
+`std::forward<U2>(p.second)`.
 *Returns:* `*this`.
 ``` cpp
+constexpr void swap(pair& p) noexcept(see below);
 ```
+*Preconditions:* `first` is swappable with [[swappable.requirements]]
+`p.first` and `second` is swappable with `p.second`.
 *Effects:* Swaps `first` with `p.first` and `second` with `p.second`.
 *Remarks:* The expression inside `noexcept` is equivalent to:
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template<class T1, class T2>
+  constexpr common_comparison_category_t<synth-three-way-result<T1>,
+                                         synth-three-way-result<T2>>
+    operator<=>(const pair<T1, T2>& x, const pair<T1, T2>& y);
+```
+*Effects:* Equivalent to:
+``` cpp
+if (auto c = synth-three-way(x.first, y.first); c != 0) return c;
+return synth-three-way(x.second, y.second);
+```
+``` cpp
+template<class T1, class T2>
+  constexpr void swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
+```
+*Constraints:* `is_swappable_v<T1>` is `true` and `is_swappable_v<T2>`
+is `true`.
+*Effects:* Equivalent to `x.swap(y)`.
+``` cpp
+template<class T1, class T2>
+  constexpr pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>> make_pair(T1&& x, T2&& y);
 ```
 *Returns:*
 ``` cpp
+pair<unwrap_ref_decay_t<T1>,
+     unwrap_ref_decay_t<T2>>(std::forward<T1>(x), std::forward<T2>(y))
 ```
 [*Example 1*:
 In place of:
 ``` cpp
 template<class T1, class T2>
   struct tuple_size<pair<T1, T2>> : integral_constant<size_t, 2> { };
 ```
 ``` cpp
+template<size_t I, class T1, class T2>
+  struct tuple_element<I, pair<T1, T2>> {
+    using type = see below ;
+  };
 ```
+*Mandates:* `I` < 2.
+*Type:* The type `T1` if `I` is 0, otherwise the type `T2`.
 ``` cpp
 template<size_t I, class T1, class T2>
   constexpr tuple_element_t<I, pair<T1, T2>>& get(pair<T1, T2>& p) noexcept;
 template<size_t I, class T1, class T2>
   constexpr tuple_element_t<I, pair<T1, T2>>&& get(pair<T1, T2>&& p) noexcept;
 template<size_t I, class T1, class T2>
   constexpr const tuple_element_t<I, pair<T1, T2>>&& get(const pair<T1, T2>&& p) noexcept;
 ```
+*Mandates:* `I` < 2.
+*Returns:*
+- If `I` is 0, returns a reference to `p.first`.
+- If `I` is 1, returns a reference to `p.second`.
 ``` cpp
 template<class T1, class T2>
   constexpr T1& get(pair<T1, T2>& p) noexcept;
 template<class T1, class T2>
   constexpr T1&& get(pair<T1, T2>&& p) noexcept;
 template<class T1, class T2>
   constexpr const T1&& get(const pair<T1, T2>&& p) noexcept;
 ```
+*Mandates:* `T1` and `T2` are distinct types.
 *Returns:* A reference to `p.first`.
 ``` cpp
 template<class T2, class T1>
   constexpr T2&& get(pair<T1, T2>&& p) noexcept;
 template<class T2, class T1>
   constexpr const T2&& get(const pair<T1, T2>&& p) noexcept;
 ```
+*Mandates:* `T1` and `T2` are distinct types.
 *Returns:* A reference to `p.second`.
 ### Piecewise construction <a id="pair.piecewise">[[pair.piecewise]]</a>
   explicit piecewise_construct_t() = default;
 };
 inline constexpr piecewise_construct_t piecewise_construct{};
 ```
+The `struct` `piecewise_construct_t` is an empty class type used as a
+unique type to disambiguate constructor and function overloading.
 Specifically, `pair` has a constructor with `piecewise_construct_t` as
+the first argument, immediately followed by two `tuple` [[tuple]]
 arguments used for piecewise construction of the elements of the `pair`
 object.

Diff to HTML by rtfpessoa