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

Files changed (1) hide show

tmp/tmph31zx98l/{from.md → to.md} +133 -294

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

@@ -1,33 +1,26 @@
 ## Utility components <a id="utility">[[utility]]</a>
-This subclause contains some basic function and class templates that are
-used throughout the rest of the library.
 ### Header `<utility>` synopsis <a id="utility.syn">[[utility.syn]]</a>
 ``` cpp
-#include <initializer_list> // see [initializer_list.syn]
 namespace std {
-  // [operators], operators
-  namespace rel_ops {
-    template<class T> bool operator!=(const T&, const T&);
-    template<class T> bool operator> (const T&, const T&);
-    template<class T> bool operator<=(const T&, const T&);
-    template<class T> bool operator>=(const T&, const T&);
-  }
   // [utility.swap], swap
   template<class T>
-    void swap(T& a, T& b) noexcept(see below);
   template<class T, size_t N>
-    void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v<T>);
   // [utility.exchange], exchange
   template<class T, class U = T>
-    T exchange(T& obj, U&& new_val);
   // [forward], forward/move
   template<class T>
     constexpr T&& forward(remove_reference_t<T>& t) noexcept;
   template<class T>
@@ -37,22 +30,42 @@ namespace std {
   template<class T>
     constexpr conditional_t<
         !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&>
       move_if_noexcept(T& x) noexcept;
-  // [utility.as_const], as_const
   template<class T>
     constexpr add_const_t<T>& as_const(T& t) noexcept;
   template<class T>
     void as_const(const T&&) = delete;
   // [declval], declval
   template<class T>
     add_rvalue_reference_t<T> declval() noexcept;   // as unevaluated operand
 %
-  // [intseq], Compile-time integer sequences
   template<class T, T...>
     struct integer_sequence;
   template<size_t... I>
     using index_sequence = integer_sequence<size_t, I...>;
@@ -70,33 +83,26 @@ namespace std {
   // [pairs.spec], pair specialized algorithms
   template<class T1, class T2>
     constexpr bool operator==(const pair<T1, T2>&, const pair<T1, T2>&);
   template<class T1, class T2>
-    constexpr bool operator< (const pair<T1, T2>&, const pair<T1, T2>&);
-  template <class T1, class T2>
-    constexpr bool operator!=(const pair<T1, T2>&, const pair<T1, T2>&);
-  template <class T1, class T2>
-    constexpr bool operator> (const pair<T1, T2>&, const pair<T1, T2>&);
-  template <class T1, class T2>
-    constexpr bool operator>=(const pair<T1, T2>&, const pair<T1, T2>&);
-  template <class T1, class T2>
-    constexpr bool operator<=(const pair<T1, T2>&, const pair<T1, T2>&);
   template<class T1, class T2>
-    void swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
   template<class T1, class T2>
     constexpr see below make_pair(T1&&, T2&&);
   // [pair.astuple], tuple-like access to pair
-  template <class T> class tuple_size;
-  template <size_t I, class T> class tuple_element;
   template<class T1, class T2> struct tuple_size<pair<T1, T2>>;
-  template <class T1, class T2> struct tuple_element<0, pair<T1, T2>>;
-  template <class T1, class T2> struct tuple_element<1, pair<T1, T2>>;
   template<size_t I, class T1, class T2>
     constexpr tuple_element_t<I, pair<T1, T2>>& get(pair<T1, T2>&) noexcept;
   template<size_t I, class T1, class T2>
     constexpr tuple_element_t<I, pair<T1, T2>>&& get(pair<T1, T2>&&) noexcept;
@@ -124,178 +130,79 @@ namespace std {
   // [pair.piecewise], pair piecewise construction
   struct piecewise_construct_t {
     explicit piecewise_construct_t() = default;
   };
   inline constexpr piecewise_construct_t piecewise_construct{};
-  template <class... Types> class tuple; // defined in <tuple> ([tuple.syn])
-  // in-place construction
   struct in_place_t {
     explicit in_place_t() = default;
   };
   inline constexpr in_place_t in_place{};
   template<class T>
     struct in_place_type_t {
       explicit in_place_type_t() = default;
     };
   template<class T> inline constexpr in_place_type_t<T> in_place_type{};
   template<size_t I>
     struct in_place_index_t {
       explicit in_place_index_t() = default;
     };
   template<size_t I> inline constexpr in_place_index_t<I> in_place_index{};
-{chars_format{chars_format{chars_format{chars_format
-  // floating-point format for primitive numerical conversion
-  enum class chars_format {
-    scientific = unspecified,
-    fixed = unspecified,
-    hex = unspecified,
-    general = fixed | scientific
-  };
-{to_chars_result{to_chars_result}
-  // [utility.to.chars], primitive numerical output conversion
-  struct to_chars_result {
-    char* ptr;
-    error_code ec;
-  };
-  to_chars_result to_chars(char* first, char* last, see below value, int base = 10);
-  to_chars_result to_chars(char* first, char* last, float value);
-  to_chars_result to_chars(char* first, char* last, double value);
-  to_chars_result to_chars(char* first, char* last, long double value);
-  to_chars_result to_chars(char* first, char* last, float value,
-                           chars_format fmt);
-  to_chars_result to_chars(char* first, char* last, double value,
-                           chars_format fmt);
-  to_chars_result to_chars(char* first, char* last, long double value,
-                           chars_format fmt);
-  to_chars_result to_chars(char* first, char* last, float value,
-                           chars_format fmt, int precision);
-  to_chars_result to_chars(char* first, char* last, double value,
-                           chars_format fmt, int precision);
-  to_chars_result to_chars(char* first, char* last, long double value,
-                           chars_format fmt, int precision);
-{from_chars_result{from_chars_result}
-  // [utility.from.chars], primitive numerical input conversion
-  struct from_chars_result {
-    const char* ptr;
-    error_code ec;
-  };
-  from_chars_result from_chars(const char* first, const char* last,
-                               see below& value, int base = 10);
-  from_chars_result from_chars(const char* first, const char* last, float& value,
-                               chars_format fmt = chars_format::general);
-  from_chars_result from_chars(const char* first, const char* last, double& value,
-                               chars_format fmt = chars_format::general);
-  from_chars_result from_chars(const char* first, const char* last, long double& value,
-                               chars_format fmt = chars_format::general);
 }
 ```
-The header `<utility>` defines several types and function templates that
-are described in this Clause. It also defines the template `pair` and
-various function templates that operate on `pair` objects.
-The type `chars_format` is a bitmask type ([[bitmask.types]]) with
-elements `scientific`, `fixed`, and `hex`.
-### Operators <a id="operators">[[operators]]</a>
-To avoid redundant definitions of `operator!=` out of `operator==` and
-operators `>`, `<=`, and `>=` out of `operator<`, the library provides
-the following:
-``` cpp
-template <class T> bool operator!=(const T& x, const T& y);
-```
-*Requires:* Type `T` is `EqualityComparable`
-(Table  [[tab:equalitycomparable]]).
-*Returns:* `!(x == y)`.
-``` cpp
-template <class T> bool operator>(const T& x, const T& y);
-```
-*Requires:* Type `T` is `LessThanComparable`
-(Table  [[tab:lessthancomparable]]).
-*Returns:* `y < x`.
-``` cpp
-template <class T> bool operator<=(const T& x, const T& y);
-```
-*Requires:* Type `T` is `LessThanComparable`
-(Table  [[tab:lessthancomparable]]).
-*Returns:* `!(y < x)`.
-``` cpp
-template <class T> bool operator>=(const T& x, const T& y);
-```
-*Requires:* Type `T` is `LessThanComparable`
-(Table  [[tab:lessthancomparable]]).
-*Returns:* `!(x < y)`.
-In this library, whenever a declaration is provided for an `operator!=`,
-`operator>`, `operator>=`, or `operator<=`, and requirements and
-semantics are not explicitly provided, the requirements and semantics
-are as specified in this Clause.
 ### `swap` <a id="utility.swap">[[utility.swap]]</a>
 ``` cpp
 template<class T>
-  void swap(T& a, T& b) noexcept(see below);
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_move_constructible_v<T>` is `true` and
-`is_move_assignable_v<T>` is `true`. The expression inside `noexcept` is
-equivalent to:
-``` cpp
-is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>
-```
-*Requires:* Type `T` shall be `MoveConstructible`
-(Table  [[tab:moveconstructible]]) and `MoveAssignable`
-(Table  [[tab:moveassignable]]).
 *Effects:* Exchanges values stored in two locations.
 ``` cpp
 template<class T, size_t N>
-  void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v<T>);
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_swappable_v<T>` is `true`.
-*Requires:* `a[i]` shall be swappable with ([[swappable.requirements]])
 `b[i]` for all `i` in the range \[`0`, `N`).
 *Effects:* As if by `swap_ranges(a, a + N, b)`.
 ### `exchange` <a id="utility.exchange">[[utility.exchange]]</a>
 ``` cpp
-template <class T, class U = T> T exchange(T& obj, U&& new_val);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -307,22 +214,22 @@ return old_val;
 ### Forward/move helpers <a id="forward">[[forward]]</a>
 The library provides templated helper functions to simplify applying
 move semantics to an lvalue and to simplify the implementation of
 forwarding functions. All functions specified in this subclause are
-signal-safe ([[csignal.syn]]).
 ``` cpp
 template<class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept;
 template<class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept;
 ```
 *Returns:* `static_cast<T&&>(t)`.
-*Remarks:* If the second form is instantiated with an lvalue reference
-type, the program is ill-formed.
 [*Example 1*:
 ``` cpp
 template<class T, class A1, class A2>
 shared_ptr<T> factory(A1&& a1, A2&& a2) {
@@ -390,30 +297,29 @@ template <class T> constexpr conditional_t<
   move_if_noexcept(T& x) noexcept;
 ```
 *Returns:* `std::move(x)`.
-### Function template `as_const` <a id="utility.as_const">[[utility.as_const]]</a>
 ``` cpp
 template<class T> constexpr add_const_t<T>& as_const(T& t) noexcept;
 ```
 *Returns:* `t`.
 ### Function template `declval` <a id="declval">[[declval]]</a>
 The library provides the function template `declval` to simplify the
-definition of expressions which occur as unevaluated operands (Clause
-[[expr]]).
 ``` cpp
 template<class T> add_rvalue_reference_t<T> declval() noexcept;    // as unevaluated operand
 ```
-*Remarks:* If this function is odr-used ([[basic.def.odr]]), the
-program is ill-formed.
 *Remarks:* The template parameter `T` of `declval` may be an incomplete
 type.
 [*Example 1*:
@@ -422,168 +328,101 @@ type.
 template<class To, class From> decltype(static_cast<To>(declval<From>())) convert(From&&);
 ```
 declares a function template `convert` which only participates in
 overloading if the type `From` can be explicitly converted to type `To`.
-For another example see class template `common_type` (
-[[meta.trans.other]]).
 — *end example*]
-### Primitive numeric output conversion <a id="utility.to.chars">[[utility.to.chars]]</a>
-All functions named `to_chars` convert `value` into a character string
-by successively filling the range \[`first`, `last`), where \[`first`,
-`last`) is required to be a valid range. If the member `ec` of the
-return value is such that the value, when converted to `bool`, is
-`false`, the conversion was successful and the member `ptr` is the
-one-past-the-end pointer of the characters written. Otherwise, the
-member `ec` has the value `errc::value_too_large`, the member `ptr` has
-the value `last`, and the contents of the range \[`first`, `last`) are
-unspecified.
-The functions that take a floating-point `value` but not a `precision`
-parameter ensure that the string representation consists of the smallest
-number of characters such that there is at least one digit before the
-radix point (if present) and parsing the representation using the
-corresponding `from_chars` function recovers `value` exactly.
-[*Note 1*: This guarantee applies only if `to_chars` and `from_chars`
-are executed on the same implementation. — *end note*]
-The functions taking a `chars_format` parameter determine the conversion
-specifier for `printf` as follows: The conversion specifier is `f` if
-`fmt` is `chars_format::fixed`, `e` if `fmt` is
-`chars_format::scientific`, `a` (without leading `"0x"` in the result)
-if `fmt` is `chars_format::hex`, and `g` if `fmt` is
-`chars_format::general`.
 ``` cpp
-to_chars_result to_chars(char* first, char* last, see below value, int base = 10);
 ```
-*Requires:* `base` has a value between 2 and 36 (inclusive).
-*Effects:* The value of `value` is converted to a string of digits in
-the given base (with no redundant leading zeroes). Digits in the range
-10..35 (inclusive) are represented as lowercase characters `a`..`z`. If
-`value` is less than zero, the representation starts with a minus sign.
-*Throws:* Nothing.
-*Remarks:* The implementation shall provide overloads for all signed and
-unsigned integer types and `char` as the type of the parameter `value`.
 ``` cpp
-to_chars_result to_chars(char* first, char* last, float value);
-to_chars_result to_chars(char* first, char* last, double value);
-to_chars_result to_chars(char* first, char* last, long double value);
 ```
-*Effects:* `value` is converted to a string in the style of `printf` in
-the `"C"` locale. The conversion specifier is `f` or `e`, chosen
-according to the requirement for a shortest representation (see above);
-a tie is resolved in favor of `f`.
-*Throws:* Nothing.
 ``` cpp
-to_chars_result to_chars(char* first, char* last, float value, chars_format fmt);
-to_chars_result to_chars(char* first, char* last, double value, chars_format fmt);
-to_chars_result to_chars(char* first, char* last, long double value, chars_format fmt);
 ```
-*Requires:* `fmt` has the value of one of the enumerators of
-`chars_format`.
-*Effects:* `value` is converted to a string in the style of `printf` in
-the `"C"` locale.
-*Throws:* Nothing.
 ``` cpp
-to_chars_result to_chars(char* first, char* last, float value,
-                         chars_format fmt, int precision);
-to_chars_result to_chars(char* first, char* last, double value,
-                         chars_format fmt, int precision);
-to_chars_result to_chars(char* first, char* last, long double value,
-                         chars_format fmt, int precision);
 ```
-*Requires:* `fmt` has the value of one of the enumerators of
-`chars_format`.
-*Effects:* `value` is converted to a string in the style of `printf` in
-the `"C"` locale with the given precision.
-*Throws:* Nothing.
-ISO C 7.21.6.1.
-### Primitive numeric input conversion <a id="utility.from.chars">[[utility.from.chars]]</a>
-All functions named `from_chars` analyze the string \[`first`, `last`)
-for a pattern, where \[`first`, `last`) is required to be a valid range.
-If no characters match the pattern, `value` is unmodified, the member
-`ptr` of the return value is `first` and the member `ec` is equal to
-`errc::invalid_argument`. Otherwise, the characters matching the pattern
-are interpreted as a representation of a value of the type of `value`.
-The member `ptr` of the return value points to the first character not
-matching the pattern, or has the value `last` if all characters match.
-If the parsed value is not in the range representable by the type of
-`value`, `value` is unmodified and the member `ec` of the return value
-is equal to `errc::result_out_of_range`. Otherwise, `value` is set to
-the parsed value and the member `ec` is set such that the conversion to
-`bool` yields `false`.
 ``` cpp
-from_chars_result from_chars(const char* first, const char* last,
-                             see below& value, int base = 10);
 ```
-*Requires:* `base` has a value between 2 and 36 (inclusive).
-*Effects:* The pattern is the expected form of the subject sequence in
-the `"C"` locale for the given nonzero base, as described for `strtol`,
-except that no `"0x"` or `"0X"` prefix shall appear if the value of
-`base` is 16, and except that a minus sign is the only sign that may
-appear, and only if `value` has a signed type.
-*Throws:* Nothing.
-*Remarks:* The implementation shall provide overloads for all signed and
-unsigned integer types and `char` as the referenced type of the
-parameter `value`.
 ``` cpp
-from_chars_result from_chars(const char* first, const char* last, float& value,
-                             chars_format fmt = chars_format::general);
-from_chars_result from_chars(const char* first, const char* last, double& value,
-                             chars_format fmt = chars_format::general);
-from_chars_result from_chars(const char* first, const char* last, long double& value,
-                             chars_format fmt = chars_format::general);
 ```
-*Requires:* `fmt` has the value of one of the enumerators of
-`chars_format`.
-*Effects:* The pattern is the expected form of the subject sequence in
-the `"C"` locale, as described for `strtod`, except that
-- the only sign that may appear is a minus sign;
-- if `fmt` has `chars_format::scientific` set but not
-  `chars_format::fixed`, the otherwise optional exponent part shall
-  appear;
-- if `fmt` has `chars_format::fixed` set but not
-  `chars_format::scientific`, the optional exponent part shall not
-  appear; and
-- if `fmt` is `chars_format::hex`, the prefix `"0x"` or `"0X"` is
-  assumed. \[*Example 1*: The string `0x123` is parsed to have the value
-  `0` with remaining characters `x123`. — *end example*]
-In any case, the resulting `value` is one of at most two floating-point
-values closest to the value of the string matching the pattern.
-*Throws:* Nothing.
-ISO C 7.22.1.3, ISO C 7.22.1.4.

 ## Utility components <a id="utility">[[utility]]</a>
 ### Header `<utility>` synopsis <a id="utility.syn">[[utility.syn]]</a>
+The header `<utility>` contains some basic function and class templates
+that are used throughout the rest of the library.
 ``` cpp
+#include <compare> // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [utility.swap], swap
   template<class T>
+ constexpr void swap(T& a, T& b) noexcept(see below);
   template<class T, size_t N>
+ constexpr void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v<T>);
   // [utility.exchange], exchange
   template<class T, class U = T>
+ constexpr T exchange(T& obj, U&& new_val);
   // [forward], forward/move
   template<class T>
     constexpr T&& forward(remove_reference_t<T>& t) noexcept;
   template<class T>
   template<class T>
     constexpr conditional_t<
         !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&>
       move_if_noexcept(T& x) noexcept;
+  // [utility.as.const], as_const
   template<class T>
     constexpr add_const_t<T>& as_const(T& t) noexcept;
   template<class T>
     void as_const(const T&&) = delete;
   // [declval], declval
   template<class T>
     add_rvalue_reference_t<T> declval() noexcept;   // as unevaluated operand
+  // [utility.intcmp], integer comparison functions
+  template<class T, class U>
+    constexpr bool cmp_equal(T t, U u) noexcept;
+  template<class T, class U>
+    constexpr bool cmp_not_equal(T t, U u) noexcept;
+  template<class T, class U>
+    constexpr bool cmp_less(T t, U u) noexcept;
+  template<class T, class U>
+    constexpr bool cmp_greater(T t, U u) noexcept;
+  template<class T, class U>
+    constexpr bool cmp_less_equal(T t, U u) noexcept;
+  template<class T, class U>
+    constexpr bool cmp_greater_equal(T t, U u) noexcept;
+  template<class R, class T>
+    constexpr bool in_range(T t) noexcept;
+  // [intseq], compile-time integer sequences%
+%
 %
   template<class T, T...>
     struct integer_sequence;
   template<size_t... I>
     using index_sequence = integer_sequence<size_t, I...>;
   // [pairs.spec], pair specialized algorithms
   template<class T1, class T2>
     constexpr bool operator==(const pair<T1, T2>&, const pair<T1, T2>&);
   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>&, const pair<T1, T2>&);
   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 see below make_pair(T1&&, T2&&);
   // [pair.astuple], tuple-like access to pair
+  template<class T> struct tuple_size;
+  template<size_t I, class T> struct tuple_element;
   template<class T1, class T2> struct tuple_size<pair<T1, T2>>;
+  template<size_t I, class T1, class T2> struct tuple_element<I, pair<T1, T2>>;
   template<size_t I, class T1, class T2>
     constexpr tuple_element_t<I, pair<T1, T2>>& get(pair<T1, T2>&) noexcept;
   template<size_t I, class T1, class T2>
     constexpr tuple_element_t<I, pair<T1, T2>>&& get(pair<T1, T2>&&) noexcept;
   // [pair.piecewise], pair piecewise construction
   struct piecewise_construct_t {
     explicit piecewise_construct_t() = default;
   };
   inline constexpr piecewise_construct_t piecewise_construct{};
+  template<class... Types> class tuple; // defined in <tuple>
+  // in-place construction%
+%
+%
+%
+%
+%
   struct in_place_t {
     explicit in_place_t() = default;
   };
   inline constexpr in_place_t in_place{};
   template<class T>
     struct in_place_type_t {
       explicit in_place_type_t() = default;
     };
   template<class T> inline constexpr in_place_type_t<T> in_place_type{};
   template<size_t I>
     struct in_place_index_t {
       explicit in_place_index_t() = default;
     };
   template<size_t I> inline constexpr in_place_index_t<I> in_place_index{};
 }
 ```
 ### `swap` <a id="utility.swap">[[utility.swap]]</a>
 ``` cpp
 template<class T>
+ constexpr void swap(T& a, T& b) noexcept(see below);
 ```
+*Constraints:* `is_move_constructible_v<T>` is `true` and
+`is_move_assignable_v<T>` is `true`.
+*Preconditions:* Type `T` meets the *Cpp17MoveConstructible*
+([[cpp17.moveconstructible]]) and *Cpp17MoveAssignable*
+([[cpp17.moveassignable]]) requirements.
 *Effects:* Exchanges values stored in two locations.
+*Remarks:* This function is a designated customization
+point [[namespace.std]]. The expression inside `noexcept` is equivalent
+to:
+``` cpp
+is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>
+```
 ``` cpp
 template<class T, size_t N>
+ constexpr void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v<T>);
 ```
+*Constraints:* `is_swappable_v<T>` is `true`.
+*Preconditions:* `a[i]` is swappable with [[swappable.requirements]]
 `b[i]` for all `i` in the range \[`0`, `N`).
 *Effects:* As if by `swap_ranges(a, a + N, b)`.
 ### `exchange` <a id="utility.exchange">[[utility.exchange]]</a>
 ``` cpp
+template<class T, class U = T>
+  constexpr T exchange(T& obj, U&& new_val);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ### Forward/move helpers <a id="forward">[[forward]]</a>
 The library provides templated helper functions to simplify applying
 move semantics to an lvalue and to simplify the implementation of
 forwarding functions. All functions specified in this subclause are
+signal-safe [[support.signal]].
 ``` cpp
 template<class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept;
 template<class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept;
 ```
+*Mandates:* For the second overload, `is_lvalue_reference_v<T>` is
+`false`.
 *Returns:* `static_cast<T&&>(t)`.
 [*Example 1*:
 ``` cpp
 template<class T, class A1, class A2>
 shared_ptr<T> factory(A1&& a1, A2&& a2) {
   move_if_noexcept(T& x) noexcept;
 ```
 *Returns:* `std::move(x)`.
+### Function template `as_const` <a id="utility.as.const">[[utility.as.const]]</a>
 ``` cpp
 template<class T> constexpr add_const_t<T>& as_const(T& t) noexcept;
 ```
 *Returns:* `t`.
 ### Function template `declval` <a id="declval">[[declval]]</a>
 The library provides the function template `declval` to simplify the
+definition of expressions which occur as unevaluated operands
+[[expr.prop]].
 ``` cpp
 template<class T> add_rvalue_reference_t<T> declval() noexcept;    // as unevaluated operand
 ```
+*Mandates:* This function is not odr-used [[basic.def.odr]].
 *Remarks:* The template parameter `T` of `declval` may be an incomplete
 type.
 [*Example 1*:
 template<class To, class From> decltype(static_cast<To>(declval<From>())) convert(From&&);
 ```
 declares a function template `convert` which only participates in
 overloading if the type `From` can be explicitly converted to type `To`.
+For another example see class template `common_type`
+[[meta.trans.other]].
 — *end example*]
+### Integer comparison functions <a id="utility.intcmp">[[utility.intcmp]]</a>
 ``` cpp
+template<class T, class U>
+  constexpr bool cmp_equal(T t, U u) noexcept;
 ```
+*Mandates:* Both `T` and `U` are standard integer types or extended
+integer types [[basic.fundamental]].
+*Effects:* Equivalent to:
 ``` cpp
+using UT = make_unsigned_t<T>;
+using UU = make_unsigned_t<U>;
+if constexpr (is_signed_v<T> == is_signed_v<U>)
+  return t == u;
+else if constexpr (is_signed_v<T>)
+  return t < 0 ? false : UT(t) == u;
+else
+  return u < 0 ? false : t == UU(u);
 ```
 ``` cpp
+template<class T, class U>
+  constexpr bool cmp_not_equal(T t, U u) noexcept;
 ```
+*Effects:* Equivalent to: `return !cmp_equal(t, u);`
 ``` cpp
+template<class T, class U>
+  constexpr bool cmp_less(T t, U u) noexcept;
 ```
+*Mandates:* Both `T` and `U` are standard integer types or extended
+integer types [[basic.fundamental]].
+*Effects:* Equivalent to:
 ``` cpp
+using UT = make_unsigned_t<T>;
+using UU = make_unsigned_t<U>;
+if constexpr (is_signed_v<T> == is_signed_v<U>)
+  return t < u;
+else if constexpr (is_signed_v<T>)
+  return t < 0 ? true : UT(t) < u;
+else
+  return u < 0 ? false : t < UU(u);
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool cmp_greater(T t, U u) noexcept;
+```
+*Effects:* Equivalent to: `return cmp_less(u, t);`
+``` cpp
+template<class T, class U>
+  constexpr bool cmp_less_equal(T t, U u) noexcept;
+```
+*Effects:* Equivalent to: `return !cmp_greater(t, u);`
 ``` cpp
+template<class T, class U>
+  constexpr bool cmp_greater_equal(T t, U u) noexcept;
 ```
+*Effects:* Equivalent to: `return !cmp_less(t, u);`
+``` cpp
+template<class R, class T>
+  constexpr bool in_range(T t) noexcept;
+```
+*Mandates:* Both `T` and `R` are standard integer types or extended
+integer types [[basic.fundamental]].
+*Effects:* Equivalent to:
+``` cpp
+return cmp_greater_equal(t, numeric_limits<R>::min()) &&
+       cmp_less_equal(t, numeric_limits<R>::max());
+```
+[*Note 1*: These function templates cannot be used to compare `byte`,
+`char`, `char8_t`, `char16_t`, `char32_t`, `wchar_t`, and
+`bool`. — *end note*]

Diff to HTML by rtfpessoa