[pairs] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpi1ff049r/{from.md → to.md} +17 -17

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

@@ -1,8 +1,8 @@
 ## Pairs <a id="pairs">[[pairs]]</a>
-### In general <a id="pairs.general">[[pairs.general]]</a>
 The library provides a template for heterogeneous pairs of values. The
 library also provides a matching function template to simplify their
 construction and several templates that provide access to `pair` objects
 as if they were `tuple` objects (see  [[tuple.helper]] and
@@ -64,28 +64,28 @@ namespace std {
   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 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.
-`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();
 ```
@@ -261,12 +261,12 @@ 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:
@@ -295,13 +295,12 @@ 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);
@@ -382,12 +381,13 @@ constexpr void swap(const pair& p) const noexcept(see below);
 ``` 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>
@@ -461,11 +461,11 @@ template<size_t I, class T1, class T2>
   };
 ```
 *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>

 ## Pairs <a id="pairs">[[pairs]]</a>
+### General <a id="pairs.general">[[pairs.general]]</a>
 The library provides a template for heterogeneous pairs of values. The
 library also provides a matching function template to simplify their
 construction and several templates that provide access to `pair` objects
 as if they were `tuple` objects (see  [[tuple.helper]] and
   template<class T1, class T2>
     pair(T1, T2) -> pair<T1, T2>;
 }
 ```
+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 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.
+`pair<T, U>` is a structural type [[term.structural.type]] 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_move_assignable_v<T1>` is `true` and
 - `is_move_assignable_v<T2>` is `true`.
+*Effects:* Assigns `std::forward<T1>(p.first)` to `first` and
+`std::forward<T2>(p.second)` to `second`.
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to:
 *Constraints:*
 - `is_assignable_v<T1&, U1>` is `true` and
 - `is_assignable_v<T2&, U2>` is `true`.
+*Effects:* Assigns `std::forward<U1>(p.first)` `first` and
+`std::forward<U2>(p.second)` to `second`.
 *Returns:* `*this`.
 ``` cpp
 template<pair-like P> constexpr pair& operator=(P&& p);
 ``` cpp
 template<class T1, class T2, class U1, class U2>
   constexpr bool operator==(const pair<T1, T2>& x, const pair<U1, U2>& y);
 ```
+*Constraints:* `x.first == y.first` and `x.second == y.second` are valid
+expressions and 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>
   };
 ```
 *Mandates:* `I` < 2.
+*Result:* 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>

Diff to HTML by rtfpessoa