[utility.syn]

# 22 General utilities library [[utilities]](./#utilities)

## 22.2 Utility components [[utility]](utility#syn)

### 22.2.1 Header <utility> synopsis [utility.syn]

[1](#1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L29)

The header <utility> contains some basic function and class templates that are used
throughout the rest of the library[.](#1.sentence-1)

// all freestanding#include <compare> // see [[compare.syn]](compare.syn "17.12.1 Header <compare> synopsis")#include <initializer_list> // see [[initializer.list.syn]](initializer.list.syn "17.11.2 Header <initializer_­list> synopsis")namespace std {// [[utility.swap]](utility.swap "22.2.2 swap"), swaptemplate<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]](utility.exchange "22.2.3 exchange"), exchangetemplate<class T, class U = T>constexpr T exchange(T& obj, U&& new_val) noexcept(*see below*); // [[forward]](forward "22.2.4 Forward/move helpers"), forward/movetemplate<class T>constexpr T&& forward(remove_reference_t<T>& t) noexcept; template<class T>constexpr T&& forward(remove_reference_t<T>&& t) noexcept; template<class T, class U>constexpr auto forward_like(U&& x) noexcept -> *see below*; template<class T>constexpr remove_reference_t<T>&& move(T&&) noexcept; 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]](utility.as.const "22.2.5 Function template as_­const"), as_consttemplate<class T>constexpr add_const_t<T>& as_const(T& t) noexcept; template<class T>void as_const(const T&&) = delete; // [[declval]](declval "22.2.6 Function template declval"), declvaltemplate<class T> add_rvalue_reference_t<T> declval() noexcept; // as unevaluated operand// [[utility.intcmp]](utility.intcmp "22.2.7 Integer comparison functions"), integer comparison functionstemplate<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; // [[utility.underlying]](utility.underlying "22.2.8 Function template to_­underlying"), to_underlyingtemplate<class T>constexpr underlying_type_t<T> to_underlying(T value) noexcept; // [[utility.undefined]](utility.undefined "22.2.9 Undefined behavior"), undefined behavior[[noreturn]] void unreachable(); void observable_checkpoint() noexcept; // [[intseq]](intseq "21.2 Compile-time integer sequences"), compile-time integer sequencestemplate<class T, T...>struct integer_sequence; template<size_t... I>using [index_sequence](#lib:index_sequence "22.2.1 Header <utility> synopsis [utility.syn]") = integer_sequence<size_t, I...>; template<class T, T N>using make_integer_sequence = integer_sequence<T, *see below*>; template<size_t N>using [make_index_sequence](#lib:make_index_sequence "22.2.1 Header <utility> synopsis [utility.syn]") = make_integer_sequence<size_t, N>; template<class... T>using [index_sequence_for](#lib:index_sequence_for "22.2.1 Header <utility> synopsis [utility.syn]") = make_index_sequence<sizeof...(T)>; // [[pairs]](pairs "22.3 Pairs"), class template pairtemplate<class T1, class T2>struct pair; template<class T1, class T2, class U1, class U2, template<class> class TQual, template<class> class UQual>requires requires { typename pair<common_reference_t<TQual<T1>, UQual<U1>>,
 common_reference_t<TQual<T2>, UQual<U2>>>; }struct basic_common_reference<pair<T1, T2>, pair<U1, U2>, TQual, UQual> {using type = pair<common_reference_t<TQual<T1>, UQual<U1>>,
 common_reference_t<TQual<T2>, UQual<U2>>>; }; template<class T1, class T2, class U1, class U2>requires requires { typename pair<common_type_t<T1, U1>, common_type_t<T2, U2>>; }struct common_type<pair<T1, T2>, pair<U1, U2>> {using type = pair<common_type_t<T1, U1>, common_type_t<T2, U2>>; }; // [[pairs.spec]](pairs.spec "22.3.3 Specialized algorithms"), pair specialized algorithmstemplate<class T1, class T2, class U1, class U2>constexpr bool operator==(const pair<T1, T2>&, const pair<U1, U2>&); 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>&, const pair<U1, U2>&); 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))); template<class T1, class T2>constexpr *see below* make_pair(T1&&, T2&&); // [[pair.astuple]](pair.astuple "22.3.4 Tuple-like access to pair"), tuple-like access to pairtemplate<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; template<size_t I, class T1, class T2>constexpr const tuple_element_t<I, pair<T1, T2>>& get(const pair<T1, T2>&) noexcept; template<size_t I, class T1, class T2>constexpr const tuple_element_t<I, pair<T1, T2>>&& get(const pair<T1, T2>&&) 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; 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; 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; 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; // [[pair.piecewise]](pair.piecewise "22.3.5 Piecewise construction"), pair piecewise constructionstruct 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#header:%3ctuple%3e "22.4.2 Header <tuple> synopsis [tuple.syn]")// in-place constructionstruct 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> 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> constexpr in_place_index_t<I> in_place_index{}; // nontype argument tagtemplate<auto V>struct nontype_t {explicit nontype_t() = default; }; template<auto V> constexpr nontype_t<V> nontype{}; // [[variant.monostate]](variant.monostate "22.6.8 Class monostate"), class monostatestruct monostate; // [[variant.monostate.relops]](variant.monostate.relops "22.6.9 monostate relational operators"), monostate relational operatorsconstexpr bool operator==(monostate, monostate) noexcept; constexpr strong_ordering operator<=>(monostate, monostate) noexcept; // [[variant.hash]](variant.hash "22.6.12 Hash support"), hash supporttemplate<class T> struct hash; template<> struct hash<monostate>;}
