<concepts>

Заголовок <concepts> — набор готовых concepts на самые частые ограничения шаблонных параметров, сгруппированных по смыслу: базовые отношения между типами, сравнения, арифметические категории, объектные свойства (копируемость, движимость, регулярность) и вызываемость. Все они — обычные библиотечные concepts, объявленные через тот же механизм concept/requires, что описан в concepts — синтаксисе языка — никакой отдельной магии компилятора для них нет.The <concepts> header is a set of ready-made concepts for the most common template-parameter constraints, grouped by meaning: basic relationships between types, comparisons, arithmetic categories, object properties (copyability, movability, regularity), and callability. All of them are ordinary library concepts, declared with the same concept/requires machinery covered in concepts — language syntax — there's no separate compiler magic behind them.

Сам язык мог дать только механизм concept/requires — но без стандартного набора готовых concepts каждый проект заново изобретал бы одни и те же ограничения:The language itself could only provide the concept/requires mechanism — but without a standard set of ready-made concepts, every project would keep reinventing the same constraints:

Большинство concepts из <concepts> — это тонкие обёртки над type traits из <type_traits>: например, std::integral<T> по сути равносилен std::is_integral_v<T>, только выражен как concept, а не как булева переменная-шаблон. Более сложные concepts комбинируют требования через requires-выражения и через ссылки на другие, более мелкие concepts — composable concepts, собранные логическим "и".Most concepts in <concepts> are thin wrappers over type traits from <type_traits> — for instance, std::integral<T> is effectively equivalent to std::is_integral_v<T>, just expressed as a concept rather than a boolean variable template. More elaborate concepts combine requirements through requires-expressions and by referencing other, smaller concepts — composable concepts assembled with logical AND.

// приблизительно так выглядит std::integral изнутри стандартной библиотеки// roughly what std::integral looks like inside the standard library
template <class T>
concept integral = std::is_integral_v<T>;

// composable concept: собран из более мелких concepts через &&// a composable concept: assembled from smaller concepts with &&
template <class T>
concept Regular = std::copyable<T>
    && std::default_initializable<T>
    && std::equality_comparable<T>;

// использование — ничем не отличается от самописного concept// usage — no different from a hand-rolled concept
template <std::invocable<int> F>
void apply(F f) { f(42); }

Это и есть std::regular в упрощённом виде — стандартная библиотека определяет его именно как комбинацию copyable + default_initializable + equality_comparable, а не как отдельную сущность со своей проверкой с нуля.This is effectively a simplified std::regular — the standard library defines it exactly as a combination of copyable + default_initializable + equality_comparable, not as a separate entity with its own from-scratch check.

Готовые concepts свободно комбинируются между собой через && прямо в requires-предложении — не обязательно заводить для этого отдельный именованный concept, если комбинация используется один раз. Тот же приём применим и к concepts высшего порядка вроде std::invocable/std::predicate, которые проверяют не свойство типа, а то, что объект можно вызвать с конкретным набором аргументов и получить ожидаемый результат.Ready-made concepts combine freely with && directly in a requires clause — there's no need to introduce a separate named concept for a combination used only once. The same trick applies to higher-order concepts like std::invocable/std::predicate, which check not a property of a type but that an object can be called with a specific set of arguments and produce the expected result.

// комбинация двух готовых concepts прямо в requires — без отдельного именованного concept// combining two ready-made concepts directly in requires — no separate named concept
template <class T>
requires std::integral<T> && std::signed_integral<T>
T abs_diff(T a, T b) {
    return a > b ? a - b : b - a;    // корректно только для знаковых целых// correct only for signed integers
}

// std::predicate — вызываемый объект, возвращающий нечто, приводимое к bool// std::predicate — a callable that returns something convertible to bool
template <class T, std::predicate<T> Pred>
std::size_t count_matching(std::vector<T>const& items, Pred pred) {
    std::size_t n = 0;
    for (const auto& item : items) if (pred(item)) ++n;
    return n;                       // вызов не int-специфичен: Pred может быть любым вызываемым для T// the call isn't int-specific: Pred can be anything callable on T
}

• cppreference — Standard library concepts
• WG21 P0898 — Standard library concepts