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

Files changed (1) hide show

tmp/tmpz1ul3z1w/{from.md → to.md} +197 -66

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

@@ -22,28 +22,45 @@ namespace std {
     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>;
 }
@@ -53,12 +70,12 @@ 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.
@@ -72,135 +89,168 @@ template-argument-equivalent [[temp.type]] if and only if `p1.first` and
 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`
 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
 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`.
@@ -208,69 +258,144 @@ template<class U1, class U2> constexpr pair& operator=(const pair<U1, U2>& p);
 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:
-``` cpp
-is_nothrow_swappable_v<first_type> && is_nothrow_swappable_v<second_type>
-```
 ### Specialized algorithms <a id="pairs.spec">[[pairs.spec]]</a>
 ``` cpp
-template<class T1, class T2>
-  constexpr bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *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
@@ -279,14 +404,20 @@ 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>

     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 = T1, class U2 = T2>
       constexpr explicit(see below) pair(U1&& x, U2&& y);
+    template<class U1, class U2>
+      constexpr explicit(see below) pair(pair<U1, U2>& p);
     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 U1, class U2>
+      constexpr explicit(see below) pair(const pair<U1, U2>&& p);
+    template<pair-like P>
+      constexpr explicit(see below) pair(P&& 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);
+    constexpr const pair& operator=(const pair& p) const;
     template<class U1, class U2>
       constexpr pair& operator=(const pair<U1, U2>& p);
+    template<class U1, class U2>
+      constexpr const pair& operator=(const pair<U1, U2>& p) const;
     constexpr pair& operator=(pair&& p) noexcept(see below);
+    constexpr const pair& operator=(pair&& p) const;
     template<class U1, class U2>
       constexpr pair& operator=(pair<U1, U2>&& p);
+    template<class U1, class U2>
+      constexpr const pair& operator=(pair<U1, U2>&& p) const;
+    template<pair-like P>
+      constexpr pair& operator=(P&& p);
+    template<pair-like P>
+      constexpr const pair& operator=(P&& p) const;
     constexpr void swap(pair& p) noexcept(see below);
+    constexpr void swap(const pair& p) const noexcept(see below);
   };
   template<class T1, class T2>
     pair(T1, T2) -> pair<T1, T2>;
 }
 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 be
+constexpr-suitable [[dcl.constexpr]].
 If
 `(is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>)`
 is `true`, then the destructor of `pair` is trivial.
 constexpr explicit(see below) pair();
 ```
 *Constraints:*
+- `is_default_constructible_v<T1>` is `true` and
+- `is_default_constructible_v<T2>` is `true`.
 *Effects:* Value-initializes `first` and `second`.
 *Remarks:* The expression inside `explicit` evaluates to `true` if and
+only if either `T1` or `T2` is not implicitly default-constructible.
 [*Note 1*: This behavior can be implemented with a trait that checks
+whether a `const T1&` or a `const T2&` can be initialized with
+`{}`. — *end note*]
 ``` cpp
 constexpr explicit(see below) pair(const T1& x, const T2& y);
 ```
 *Constraints:*
+- `is_copy_constructible_v<T1>` is `true` and
+- `is_copy_constructible_v<T2>` is `true`.
 *Effects:* Initializes `first` with `x` and `second` with `y`.
 *Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!is_convertible_v<const T1&, T1> || !is_convertible_v<const T2&, T2>
 ```
 ``` cpp
+template<class U1 = T1, class U2 = T2> constexpr explicit(see below) pair(U1&& x, U2&& y);
 ```
 *Constraints:*
+- `is_constructible_v<T1, U1>` is `true` and
+- `is_constructible_v<T2, 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, T1> || !is_convertible_v<U2, T2>
 ```
+This constructor is defined as deleted if
+`reference_constructs_from_temporary_v<first_type, U1&&>` is `true` or
+`reference_constructs_from_temporary_v<second_type, U2&&>` is `true`.
 ``` cpp
+template<class U1, class U2> constexpr explicit(see below) pair(pair<U1, U2>& p);
 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 U1, class U2> constexpr explicit(see below) pair(const pair<U1, U2>&& p);
+template<pair-like P> constexpr explicit(see below) pair(P&& p);
 ```
+Let *`FWD`*`(u)` be `static_cast<decltype(u)>(u)`.
 *Constraints:*
+- For the last overload, `remove_cvref_t<P>` is not a specialization of
+ `ranges::subrange`,
+- `is_constructible_v<T1, decltype(get<0>(`*`FWD`*`(p)))>` is `true`,
+  and
+- `is_constructible_v<T2, decltype(get<1>(`*`FWD`*`(p)))>` is `true`.
+*Effects:* Initializes `first` with `get<0>(`*`FWD`*`(p))` and `second`
+with `get<1>(`*`FWD`*`(p))`.
+*Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!is_convertible_v<decltype(get<0>(FWD(p))), T1> ||
+!is_convertible_v<decltype(get<1>(FWD(p))), T2>
 ```
+The constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<first_type, decltype(get<0>(FWD(p)))> ||
+reference_constructs_from_temporary_v<second_type, decltype(get<1>(FWD(p)))>
+```
+is `true`.
 ``` cpp
 template<class... Args1, class... Args2>
   constexpr pair(piecewise_construct_t,
                  tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
 *Mandates:*
+- `is_constructible_v<T1, Args1...>` is `true` and
+- `is_constructible_v<T2, 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`
 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*.
+[*Note 2*: If a data member of `pair` is of reference type and its
+initialization binds it to a temporary object, the program is
+ill-formed [[class.base.init]]. — *end note*]
 ``` cpp
 constexpr pair& operator=(const pair& p);
 ```
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
+*Returns:* `*this`.
 *Remarks:* This operator is defined as deleted unless
+`is_copy_assignable_v<T1>` is `true` and `is_copy_assignable_v<T2>` is
+`true`.
+``` cpp
+constexpr const pair& operator=(const pair& p) const;
+```
+*Constraints:*
+- `is_copy_assignable_v<const T1>` is `true` and
+- `is_copy_assignable_v<const T2>` is `true`.
+*Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
 ``` cpp
 template<class U1, class U2> constexpr pair& operator=(const pair<U1, U2>& p);
 ```
 *Constraints:*
+- `is_assignable_v<T1&, const U1&>` is `true` and
+- `is_assignable_v<T2&, const U2&>` is `true`.
+*Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
+*Returns:* `*this`.
+``` cpp
+template<class U1, class U2> constexpr const pair& operator=(const pair<U1, U2>& p) const;
+```
+*Constraints:*
+- `is_assignable_v<const T1&, const U1&>` is `true`, and
+- `is_assignable_v<const T2&, const U2&>` is `true`.
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
 constexpr pair& operator=(pair&& p) noexcept(see below);
 ```
 *Constraints:*
+- `is_move_assignable_v<T1>` is `true` and
+- `is_move_assignable_v<T2>` is `true`.
+*Effects:* Assigns to `first` with `std::forward<T1>(p.first)` and to
+`second` with `std::forward<T2>(p.second)`.
 *Returns:* `*this`.
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_move_assignable_v<T1> && is_nothrow_move_assignable_v<T2>
 ```
+``` cpp
+constexpr const pair& operator=(pair&& p) const;
+```
+*Constraints:*
+- `is_assignable_v<const T1&, T1>` is `true` and
+- `is_assignable_v<const T2&, T2>` is `true`.
+*Effects:* Assigns `std::forward<T1>(p.first)` to `first` and
+`std::forward<T2>(p.second)` to `second`.
+*Returns:* `*this`.
 ``` cpp
 template<class U1, class U2> constexpr pair& operator=(pair<U1, U2>&& p);
 ```
 *Constraints:*
+- `is_assignable_v<T1&, U1>` is `true` and
+- `is_assignable_v<T2&, 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
+template<pair-like P> constexpr pair& operator=(P&& p);
+```
+*Constraints:*
+- `different-from<P, pair>` [[range.utility.helpers]] is `true`,
+- `remove_cvref_t<P>` is not a specialization of `ranges::subrange`,
+- `is_assignable_v<T1&, decltype(get<0>(std::forward<P>(p)))>` is
+  `true`, and
+- `is_assignable_v<T2&, decltype(get<1>(std::forward<P>(p)))>` is
+  `true`.
+*Effects:* Assigns `get<0>(std::forward<P>(p))` to `first` and
+`get<1>(std::forward<P>(p))` to `second`.
+*Returns:* `*this`.
+``` cpp
+template<pair-like P> constexpr const pair& operator=(P&& p) const;
+```
+*Constraints:*
+- `different-from<P, pair>` [[range.utility.helpers]] is `true`,
+- `remove_cvref_t<P>` is not a specialization of `ranges::subrange`,
+- `is_assignable_v<const T1&, decltype(get<0>(std::forward<P>(p)))>` is
+  `true`, and
+- `is_assignable_v<const T2&, decltype(get<1>(std::forward<P>(p)))>` is
+  `true`.
+*Effects:* Assigns `get<0>(std::forward<P>(p))` to `first` and
+`get<1>(std::forward<P>(p))` to `second`.
+*Returns:* `*this`.
+``` cpp
+template<class U1, class U2> constexpr const pair& operator=(pair<U1, U2>&& p) const;
+```
+*Constraints:*
+- `is_assignable_v<const T1&, U1>` is `true`, and
+- `is_assignable_v<const T2&, U2>` is `true`.
+*Effects:* Assigns `std::forward<U1>(p.first)` to `first` and
+`std::forward<U2>(u.second)` to `second`.
+*Returns:* `*this`.
 ``` cpp
 constexpr void swap(pair& p) noexcept(see below);
+constexpr void swap(const pair& p) const noexcept(see below);
 ```
+*Mandates:*
+- For the first overload, `is_swappable_v<T1>` is `true` and
+  `is_swappable_v<T2>` is `true`.
+- For the second overload, `is_swappable_v<const T1>` is `true` and
+  `is_swappable_v<const T2>` is `true`.
 *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 exception specification is equivalent to:
+- `is_nothrow_swappable_v<T1> && is_nothrow_swappable_v<T2>` for the
+  first overload, and
+- `is_nothrow_swappable_v<const T1> && is_nothrow_swappable_v<const T2>`
+  for the second overload.
 ### Specialized algorithms <a id="pairs.spec">[[pairs.spec]]</a>
 ``` cpp
+template<class T1, class T2, class U1, class U2>
+  constexpr bool operator==(const pair<T1, T2>& x, const pair<U1, U2>& y);
 ```
+*Preconditions:* Each of `decltype(x.first == y.first)` and
+`decltype(x.second == y.second)` models `boolean-testable`.
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
+template<class T1, class T2, class U1, class U2>
+  constexpr common_comparison_category_t<synth-three-way-result<T1, U1>,
+                                         synth-three-way-result<T2, U2>>
+    operator<=>(const pair<T1, T2>& x, const pair<U1, U2>& y);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ```
 ``` cpp
 template<class T1, class T2>
   constexpr void swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
+template<class T1, class T2>
+  constexpr void swap(const pair<T1, T2>& x, const pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
 ```
+*Constraints:*
+- For the first overload, `is_swappable_v<T1>` is `true` and
+  `is_swappable_v<T2>` is `true`.
+- For the second overload, `is_swappable_v<const T1>` is `true` and
+  `is_swappable_v<const T2>` is `true`.
 *Effects:* Equivalent to `x.swap(y)`.
 ``` cpp
 template<class T1, class T2>

Diff to HTML by rtfpessoa