\begin{itemdecl}

template<class T>

inlineconstexpr bool @\exposid{is-default-initializable}@ = @\seebelow@; //\expos

constexpr bool @\exposid{is-default-initializable}@ = @\seebelow@; //\expos

template<class T>

concept @\deflibconcept{default_initializable}@ = @\libconcept{constructible_from}@<T> &&

//\ref{syserr}, system error support

template<class T>

inlineconstexpr bool is_error_code_enum_v = is_error_code_enum<T>::value;

constexpr bool is_error_code_enum_v = is_error_code_enum<T>::value;

template<class T>

inlineconstexpr bool is_error_condition_enum_v = is_error_condition_enum<T>::value;

constexpr bool is_error_condition_enum_v = is_error_condition_enum<T>::value;

}

\end{codeblock}

\begin{codeblock}

namespace std {

template<class T> struct is_pod;

template<class T>inlineconstexpr bool is_pod_v = is_pod<T>::value;

template<class T> constexpr bool is_pod_v = is_pod<T>::value;

template<size_t Len, size_t Align = @\exposid{default-alignment}@> //\seebelow

struct aligned_storage;

template<size_t Len, size_t Align = @\exposid{default-alignment}@> //\seebelow

//\ref{iterator.concept.sizedsentinel}, concept\libconcept{sized_sentinel_for}

template<class S, class I>

inlineconstexpr bool disable_sized_sentinel_for = false; // freestanding

constexpr bool disable_sized_sentinel_for = false; // freestanding

template<class S, class I>

concept sized_sentinel_for = @\seebelow@; // freestanding

template<class Iterator1, class Iterator2>

requires (!@\libconcept{sized_sentinel_for}@<Iterator1, Iterator2>)

inlineconstexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>, // freestanding

constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>, // freestanding

reverse_iterator<Iterator2>> = true;

//\ref{insert.iterators}, insert iterators

\begin{codeblock}

template<class T>

inlineconstexpr bool @\exposid{is-integer-like}@ = @\seebelow@; @\itcorr[-2]@ //\expos

constexpr bool @\exposid{is-integer-like}@ = @\seebelow@; @\itcorr[-2]@ //\expos

template<class T>

inlineconstexpr bool @\exposid{is-signed-integer-like}@ = @\seebelow@; @\itcorr[-2]@ //\expos

constexpr bool @\exposid{is-signed-integer-like}@ = @\seebelow@; @\itcorr[-2]@ //\expos

template<class I>

concept @\deflibconcept{weakly_incrementable}@ =

\indexlibraryglobal{disable_sized_sentinel_for}%

\begin{itemdecl}

template<class S, class I>

inlineconstexpr bool disable_sized_sentinel_for = false;

constexpr bool disable_sized_sentinel_for = false;

\end{itemdecl}

\begin{itemdescr}

\indexheader{numbers}%

\begin{codeblock}

namespace std::numbers {

template<class T>inlineconstexpr T e_v = @\unspec@;

template<class T>inlineconstexpr T log2e_v = @\unspec@;

template<class T>inlineconstexpr T log10e_v = @\unspec@;

template<class T>inlineconstexpr T pi_v = @\unspec@;

template<class T>inlineconstexpr T inv_pi_v = @\unspec@;

template<class T>inlineconstexpr T inv_sqrtpi_v = @\unspec@;

template<class T>inlineconstexpr T ln2_v = @\unspec@;

template<class T>inlineconstexpr T ln10_v = @\unspec@;

template<class T>inlineconstexpr T sqrt2_v = @\unspec@;

template<class T>inlineconstexpr T sqrt3_v = @\unspec@;

template<class T>inlineconstexpr T inv_sqrt3_v = @\unspec@;

template<class T>inlineconstexpr T egamma_v = @\unspec@;

template<class T>inlineconstexpr T phi_v = @\unspec@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T e_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T log2e_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T log10e_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T pi_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T inv_pi_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T inv_sqrtpi_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T ln2_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T ln10_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T sqrt2_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T sqrt3_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T inv_sqrt3_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T egamma_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T>inlineconstexpr T phi_v<T> = @\seebelow@;

template<class T> constexpr T e_v = @\unspec@;

template<class T> constexpr T log2e_v = @\unspec@;

template<class T> constexpr T log10e_v = @\unspec@;

template<class T> constexpr T pi_v = @\unspec@;

template<class T> constexpr T inv_pi_v = @\unspec@;

template<class T> constexpr T inv_sqrtpi_v = @\unspec@;

template<class T> constexpr T ln2_v = @\unspec@;

template<class T> constexpr T ln10_v = @\unspec@;

template<class T> constexpr T sqrt2_v = @\unspec@;

template<class T> constexpr T sqrt3_v = @\unspec@;

template<class T> constexpr T inv_sqrt3_v = @\unspec@;

template<class T> constexpr T egamma_v = @\unspec@;

template<class T> constexpr T phi_v = @\unspec@;

template<@\libconcept{floating_point}@ T> constexpr T e_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T log2e_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T log10e_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T pi_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T inv_pi_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T inv_sqrtpi_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T ln2_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T ln10_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T sqrt2_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T sqrt3_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T inv_sqrt3_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T egamma_v<T> = @\seebelow@;

template<@\libconcept{floating_point}@ T> constexpr T phi_v<T> = @\seebelow@;

inline constexpr double e = e_v<double>;

inline constexpr double log2e = log2e_v<double>;

concept range = @\seebelow@; // freestanding

template<class T>

inlineconstexpr bool enable_borrowed_range = false; // freestanding

constexpr bool enable_borrowed_range = false; // freestanding

template<class T>

concept borrowed_range = @\seebelow@; // freestanding

// \ref{range.sized}, sized ranges

template<class>

inlineconstexpr bool disable_sized_range = false; // freestanding

constexpr bool disable_sized_range = false; // freestanding

template<class T>

concept sized_range = @\seebelow@; // freestanding

// \ref{range.view}, views

template<class T>

inlineconstexpr bool enable_view = @\seebelow@; // freestanding

constexpr bool enable_view = @\seebelow@; // freestanding

struct view_base {}; // freestanding

class subrange; // freestanding

template<class I, class S, subrange_kind K>

inlineconstexpr bool enable_borrowed_range<subrange<I, S, K>> = true; // freestanding

constexpr bool enable_borrowed_range<subrange<I, S, K>> = true; // freestanding

template<size_t N, class I, class S, subrange_kind K>

requires ((N == 0 && @\libconcept{copyable}@<I>) || N == 1)

namespace views {

template<class T>

inlineconstexpr empty_view<T> @\libmember{empty}{views}@{}; // freestanding

constexpr empty_view<T> @\libmember{empty}{views}@{}; // freestanding

}

// \ref{range.single}, single view

class iota_view; // freestanding

template<class W, class Bound>

inlineconstexpr bool enable_borrowed_range<iota_view<W, Bound>> = true; // freestanding

constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true; // freestanding

namespace views { inline constexpr @\unspecnc@ iota = @\unspecnc@; } // freestanding

class ref_view; // freestanding

template<class T>

inlineconstexpr bool enable_borrowed_range<ref_view<T>> = true; // freestanding

constexpr bool enable_borrowed_range<ref_view<T>> = true; // freestanding

// \ref{range.owning.view}, owning view

template<@\libconcept{range}@ R>

template<@\libconcept{view}@> class take_view; // freestanding

template<class T>

inlineconstexpr bool enable_borrowed_range<take_view<T>> = // freestanding

constexpr bool enable_borrowed_range<take_view<T>> = // freestanding

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ take = @\unspecnc@; } // freestanding

class drop_view; // freestanding

template<class T>

inlineconstexpr bool enable_borrowed_range<drop_view<T>> = // freestanding

constexpr bool enable_borrowed_range<drop_view<T>> = // freestanding

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ drop = @\unspecnc@; } // freestanding

class drop_while_view; // freestanding

template<class T, class Pred>

inlineconstexpr bool enable_borrowed_range<drop_while_view<T, Pred>> = // freestanding

constexpr bool enable_borrowed_range<drop_while_view<T, Pred>> = // freestanding

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ drop_while = @\unspecnc@; } // freestanding

class common_view; // freestanding

template<class T>

inlineconstexpr bool enable_borrowed_range<common_view<T>> = // freestanding

constexpr bool enable_borrowed_range<common_view<T>> = // freestanding

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ common = @\unspecnc@; } // freestanding

class as_const_view; // freestanding

template<class T>

inlineconstexpr bool enable_borrowed_range<as_const_view<T>> = // freestanding

constexpr bool enable_borrowed_range<as_const_view<T>> = // freestanding

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ as_const = @\unspecnc@; } // freestanding

class elements_view; // freestanding

template<class T, size_t N>

inlineconstexpr bool enable_borrowed_range<elements_view<T, N>> = // freestanding

constexpr bool enable_borrowed_range<elements_view<T, N>> = // freestanding

enable_borrowed_range<T>;

template<class R>

namespace views {

template<size_t N>

inlineconstexpr @\unspecnc@ elements = @\unspecnc@; // freestanding

constexpr @\unspecnc@ elements = @\unspecnc@; // freestanding

inline constexpr auto @\libmember{keys}{views}@ = elements<0>; // freestanding

inline constexpr auto @\libmember{values}{views}@ = elements<1>; // freestanding

}

\indexlibraryglobal{enable_borrowed_range}%

\begin{itemdecl}

template<class>

inlineconstexpr bool enable_borrowed_range = false;

constexpr bool enable_borrowed_range = false;

\end{itemdecl}

\begin{itemdescr}

\indexlibraryglobal{disable_sized_range}%

\begin{itemdecl}

template<class>

inlineconstexpr bool disable_sized_range = false;

constexpr bool disable_sized_range = false;

\end{itemdecl}

\begin{itemdescr}

\indexlibraryglobal{enable_view}%

\begin{itemdecl}

template<class T>

inlineconstexpr bool @\exposidnc{is-derived-from-view-interface}@ = @\seebelownc@; // \expos

constexpr bool @\exposidnc{is-derived-from-view-interface}@ = @\seebelownc@; // \expos

template<class T>

inlineconstexpr bool enable_view =

constexpr bool enable_view =

@\libconcept{derived_from}@<T, view_base> || @\exposid{is-derived-from-view-interface}@<T>;

\end{itemdecl}

class basic_string_view;

template<class charT, class traits>

inlineconstexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;

constexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;

template<class charT, class traits>

inlineconstexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true;

constexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true;

//\ref{string.view.comparison}, non-member comparison functions

template<class charT, class traits>

//\ref{time.traits}, customization traits

template<class Rep> struct treat_as_floating_point;

template<class Rep>

inlineconstexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;

constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;

template<class Rep> struct duration_values;

template<class T> struct is_clock;

template<class T>inlineconstexpr bool is_clock_v = is_clock<T>::value;

template<class T> constexpr bool is_clock_v = is_clock<T>::value;

//\ref{time.duration.nonmember},\tcode{duration} arithmetic

template<class Rep1, class Period1, class Rep2, class Period2>

struct in_place_type_t {

explicit in_place_type_t() = default;

};

template<class T>inlineconstexpr in_place_type_t<T> in_place_type{};

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>inlineconstexpr in_place_index_t<I> in_place_index{};

template<size_t I> constexpr in_place_index_t<I> in_place_index{};

}

\end{codeblock}

// \ref{tuple.helper}, tuple helper classes

template<class T>

inlineconstexpr size_t @\libglobal{tuple_size_v}@ = tuple_size<T>::value;

constexpr size_t @\libglobal{tuple_size_v}@ = tuple_size<T>::value;

}

\end{codeblock}

template<class T> struct variant_size; // \notdef

template<class T> struct variant_size<const T>;

template<class T>

inlineconstexpr size_t @\libglobal{variant_size_v}@ = variant_size<T>::value;

constexpr size_t @\libglobal{variant_size_v}@ = variant_size<T>::value;

template<class... Types>

struct variant_size<variant<Types...>>;