feat universal: use concepts

Improves compile times up to 10% for cases of heavy concepts usage (postgres, logging, ...). Before the change:
```
[1065 ms] [CC] userver/universal/src/utils/meta_test.cpp [started: 0 (1775733436077), finished: 1065 (1775733437142)]
```
After:
```
[933 ms] [CC] userver/universal/src/utils/meta_test.cpp [started: 0 (1775733324601), finished: 933 (1775733325534)]
```

Tests: протестировано CI
commit_hash:283402cab3c4130d0ee8ac7b4e9549eda3cd067b

Author: apolukhin

universal/include/userver/utils/meta.hpp

@@ -4,6 +4,7 @@
 /// @brief Metaprogramming, template variables and concepts
 /// @ingroup userver_universal
 
+#include <concepts>
 #include <iosfwd>
 #include <iterator>
 #include <optional>
@@ -34,39 +35,21 @@ using IsRange =
 template <typename T>
 using IteratorType = std::enable_if_t<IsDetected<IsRange, T>, decltype(begin(std::declval<T&>()))>;
 
-template <typename T, typename = void>
-struct IsIterator : std::false_type {};
-
-template <typename T>
-struct IsIterator<T, std::void_t<typename std::iterator_traits<T>::iterator_category>> : std::true_type {};
-
 template <typename T>
 using RangeValueType = typename std::iterator_traits<DetectedType<IteratorType, T>>::value_type;
 
 template <typename T>
 using OstreamWriteResult = decltype(std::declval<std::ostream&>() << std::declval<const std::remove_reference_t<T>&>());
 
-template <typename T, typename U>
-using EqualityComparisonResult = decltype(std::declval<const T&>() == std::declval<const U&>());
-
 template <typename T>
 using StdHashResult = decltype(std::hash<T>{}(std::declval<const T&>()));
 
-template <typename T>
-using IsSizable = decltype(std::size(std::declval<T>()));
-
-template <typename T>
-using ReserveResult = decltype(std::declval<T&>().reserve(1));
-
 template <typename T>
 using AtResult = decltype(std::declval<const T&>().at(std::declval<typename T::key_type>()));
 
 template <typename T>
 using SubscriptOperatorResult = decltype(std::declval<T>()[std::declval<typename T::key_type>()]);
 
-template <typename T>
-using PushBackResult = decltype(std::declval<T&>().push_back({}));
-
 template <typename T>
 struct IsFixedSizeContainer : std::false_type {};
 
@@ -85,20 +68,21 @@ constexpr bool IsSingleRange() {
 
 }  // namespace impl
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 template <typename T>
-inline constexpr bool kIsVector = kIsInstantiationOf<std::vector, T>;
+concept kIsVector = kIsInstantiationOf<std::vector, T>;
 
 template <typename T>
-inline constexpr bool kIsRange = IsDetected<impl::IsRange, T>;
+concept kIsRange = IsDetected<impl::IsRange, T>;
 
 /// Returns true if T is an ordered or unordered map or multimap
 template <typename T>
-inline constexpr bool
-    kIsMap = IsDetected<impl::IsRange, T> && IsDetected<impl::KeyType, T> && IsDetected<impl::MappedType, T>;
+concept kIsMap = IsDetected<impl::IsRange, T> && IsDetected<impl::KeyType, T> && IsDetected<impl::MappedType, T>;
 
 /// Returns true if T is a map (but not a multimap!)
 template <typename T>
-inline constexpr bool kIsUniqueMap =
+concept kIsUniqueMap =
     kIsMap<T> &&
     IsDetected<
         impl::SubscriptOperatorResult,
@@ -114,39 +98,38 @@ template <typename T>
 using RangeValueType = DetectedType<impl::RangeValueType, T>;
 
 template <typename T>
-inline constexpr bool kIsRecursiveRange = std::is_same_v<DetectedType<impl::RangeValueType, T>, T>;
+concept kIsRecursiveRange = std::is_same_v<DetectedType<impl::RangeValueType, T>, T>;
 
 template <typename T>
-inline constexpr bool kIsIterator = impl::IsIterator<T>::value;
+concept kIsIterator = requires { typename std::iterator_traits<T>::iterator_category; };
 
 template <typename T>
-inline constexpr bool kIsOptional = kIsInstantiationOf<std::optional, T>;
+concept kIsOptional = kIsInstantiationOf<std::optional, T>;
 
 template <typename T>
-inline constexpr bool kIsOstreamWritable = std::is_same_v<DetectedType<impl::OstreamWriteResult, T>, std::ostream&>;
+concept kIsOstreamWritable = std::is_same_v<DetectedType<impl::OstreamWriteResult, T>, std::ostream&>;
 
 template <typename T, typename U = T>
-inline constexpr bool kIsEqualityComparable = std::is_same_v<DetectedType<impl::EqualityComparisonResult, T, U>, bool>;
+concept kIsEqualityComparable = std::equality_comparable_with<T, U>;
 
 template <typename T>
-inline constexpr bool
-    kIsStdHashable = std::is_same_v<DetectedType<impl::StdHashResult, T>, std::size_t> && kIsEqualityComparable<T>;
+concept kIsStdHashable = std::is_same_v<DetectedType<impl::StdHashResult, T>, std::size_t> && kIsEqualityComparable<T>;
 
 /// @brief  Check if std::size is applicable to container
 template <typename T>
-inline constexpr bool kIsSizable = IsDetected<impl::IsSizable, T>;
+concept kIsSizable = requires(T value) { std::size(value); };
 
 /// @brief Check if a container has `reserve`
 template <typename T>
-inline constexpr bool kIsReservable = IsDetected<impl::ReserveResult, T>;
+concept kIsReservable = requires(T value) { value.reserve(1); };
 
 /// @brief Check if a container has 'push_back'
 template <typename T>
-inline constexpr bool kIsPushBackable = IsDetected<impl::PushBackResult, T>;
+concept kIsPushBackable = requires(T value) { value.push_back({}); };
 
 /// @brief Check if a container has fixed size (e.g. std::array)
 template <typename T>
-inline constexpr bool kIsFixedSizeContainer = impl::IsFixedSizeContainer<T>::value;
+concept kIsFixedSizeContainer = impl::IsFixedSizeContainer<T>::value;
 
 /// @brief Returns default inserter for a container
 template <typename T>
@@ -160,6 +143,8 @@ auto Inserter(T& container) {
     }
 }
 
+// NOLINTEND(readability-identifier-naming)
+
 }  // namespace meta
 
 USERVER_NAMESPACE_END

universal/include/userver/utils/meta_light.hpp

@@ -39,7 +39,7 @@ struct IsInstantiationOf<Template, Template<Args...>> : std::true_type {};
 /// @see utils::meta::IsDetected
 struct NotDetected {};
 
-#if defined(__cpp_concepts) || defined(DOXYGEN)
+// NOLINTBEGIN(readability-identifier-naming)
 
 /// @brief Checks whether a trait is correct for the given template args
 ///
@@ -58,13 +58,6 @@ struct NotDetected {};
 template <template <typename...> typename Trait, typename... Args>
 concept IsDetected = requires { typename Trait<Args...>; };
 
-#else
-
-template <template <typename...> typename Trait, typename... Args>
-inline constexpr bool IsDetected = impl::Detector<NotDetected, void, Trait, Args...>::value_t::value;
-
-#endif
-
 /// @brief Produces the result type of a trait, or utils::meta::NotDetected if
 /// it's incorrect for the given template args
 /// @see utils::meta::IsDetected
@@ -83,22 +76,24 @@ using ExpectSame = std::enable_if_t<std::is_same_v<T, U>>;
 
 /// Returns `true` if the type is an instantiation of the specified template.
 template <template <typename...> typename Template, typename T>
-inline constexpr bool kIsInstantiationOf = impl::IsInstantiationOf<Template, T>::value;
+concept kIsInstantiationOf = impl::IsInstantiationOf<Template, T>::value;
 
 /// Returns `true` if the type (with remove cv-qualifiers) is an instantiation of the specified template.
 template <template <typename...> typename Template, typename T>
-inline constexpr bool kIsCvInstantiationOf = kIsInstantiationOf<Template, std::remove_cv_t<T>>;
+concept kIsCvInstantiationOf = kIsInstantiationOf<Template, std::remove_cv_t<T>>;
 
 /// Returns `true` if the type is a fundamental character type.
 /// `signed char` and `unsigned char` are not character types.
 template <typename T>
-inline constexpr bool kIsCharacter =
+concept kIsCharacter =
     std::is_same_v<T, char> || std::is_same_v<T, wchar_t> || std::is_same_v<T, char16_t> || std::is_same_v<T, char32_t>;
 
 /// Returns `true` if the type is a true integer type (not `*char*` or `bool`)
 /// `signed char` and `unsigned char` are integer types
 template <typename T>
-inline constexpr bool kIsInteger = std::is_integral_v<T> && !kIsCharacter<T> && !std::is_same_v<T, bool>;
+concept kIsInteger = std::is_integral_v<T> && !kIsCharacter<T> && !std::is_same_v<T, bool>;
+
+// NOLINTEND(readability-identifier-naming)
 
 }  // namespace meta