feat userver: use concepts to work with formats and StrongTypedef

Has no noticeable impact on compile times. Before the change:
```
[1258 ms] [CC]: userver/universal/src/utils/strong_typedef_serialization_test.cpp [started: 1775811100181, finished: 1775811101439]
[1282 ms] [CC]: userver/universal/src/utils/strong_typedef_serialization_test.cpp [started: 0 (1775811111417), finished: 1282 (1775811112699)]
[2414 ms] [CC]: userver/universal/src/formats/json/value_test.cpp [started: 1775810503597, finished: 1775810506011]
[1319 ms] [CC]: userver/universal/src/formats/json/value_builder_test.cpp [started: 1775810503591, finished: 1775810504910]

```
After:
```
[1253 ms] [CC]: userver/universal/src/utils/strong_typedef_serialization_test.cpp [started: 0 (1775811253816), finished: 1253 (1775811255069)]
[1253 ms] [CC]: userver/universal/src/utils/strong_typedef_serialization_test.cpp [started: 1775811227027, finished: 1775811228280]
[2400 ms] [CC]: userver/universal/src/formats/json/value_test.cpp [started: 1775810366280, finished: 1775810368680]
[1319 ms] [CC]: userver/universal/src/formats/json/value_builder_test.cpp [started: 1775810366279, finished: 1775810367598]
```

Tests: протестировано CI
commit_hash:9f49f6f04299baa030bb7d09f8e959f8f5c00be7

Author: apolukhin

chaotic/integration_tests/tests/render/yaml_config.cpp

@@ -9,13 +9,13 @@
 USERVER_NAMESPACE_BEGIN
 
 TEST(YamlConfig, Presence) {
-    static_assert(formats::common::impl::kHasParse<USERVER_NAMESPACE::yaml_config::YamlConfig, ns::CustomStruct1>);
+    static_assert(formats::common::impl::HasParse<USERVER_NAMESPACE::yaml_config::YamlConfig, ns::CustomStruct1>);
 
     // JSON extra is convertible
-    static_assert(formats::common::impl::kHasParse<USERVER_NAMESPACE::yaml_config::YamlConfig, ns::CustomAllOf__P0>);
+    static_assert(formats::common::impl::HasParse<USERVER_NAMESPACE::yaml_config::YamlConfig, ns::CustomAllOf__P0>);
 
     // Transitively
-    static_assert(formats::common::impl::kHasParse<USERVER_NAMESPACE::yaml_config::YamlConfig, ns::CustomAllOf>);
+    static_assert(formats::common::impl::HasParse<USERVER_NAMESPACE::yaml_config::YamlConfig, ns::CustomAllOf>);
 }
 
 TEST(YamlConfig, Parse) {

core/include/userver/components/container.hpp

@@ -86,8 +86,8 @@ struct DependencyLocator {
 ///
 /// @snippet core/src/dynamic_config/storage/component.cpp LocateDependency example
 template <typename T>
-std::enable_if_t<formats::common::impl::kHasParse<yaml_config::YamlConfig, T> && std::is_class_v<T>, T>
-LocateDependency(WithType<T>, const ComponentConfig& config, const ComponentContext&)
+requires(formats::common::impl::HasParse<yaml_config::YamlConfig, T> && std::is_class_v<T>)
+T LocateDependency(WithType<T>, const ComponentConfig& config, const ComponentContext&)
 {
     return config.As<T>();
 }

libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp

@@ -11,31 +11,31 @@ USERVER_NAMESPACE_BEGIN
 
 namespace proto_structs::io {
 
-template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TEnable, typename TMessageField>
-utils::StrongTypedef<TTag, TStructField, Ops, TEnable> ReadProtoField(
+template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TMessageField>
+utils::StrongTypedef<TTag, TStructField, Ops> ReadProtoField(
     ReadContext& ctx,
-    To<utils::StrongTypedef<TTag, TStructField, Ops, TEnable>>,
+    To<utils::StrongTypedef<TTag, TStructField, Ops>>,
     int field_number,
     const TMessageField& message_field
 ) {
-    using Type = utils::StrongTypedef<TTag, TStructField, Ops, TEnable>;
+    using Type = utils::StrongTypedef<TTag, TStructField, Ops>;
     return Type{ctx.ReadField<TStructField>(field_number, message_field)};
 }
 
-template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TEnable, typename TMessageField>
+template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TMessageField>
 void WriteProtoField(
     WriteContext& ctx,
-    const utils::StrongTypedef<TTag, TStructField, Ops, TEnable>& struct_field,
+    const utils::StrongTypedef<TTag, TStructField, Ops>& struct_field,
     int field_number,
     TMessageField& message_field
 ) {
     ctx.WriteField(struct_field.GetUnderlying(), field_number, message_field);
 }
 
-template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TEnable, typename TMessageField>
+template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TMessageField>
 void WriteProtoField(
     WriteContext& ctx,
-    utils::StrongTypedef<TTag, TStructField, Ops, TEnable>&& struct_field,
+    utils::StrongTypedef<TTag, TStructField, Ops>&& struct_field,
     int field_number,
     TMessageField& message_field
 ) {

mongo/include/userver/formats/bson/value.hpp

@@ -171,7 +171,7 @@ class Value {
     template <typename T>
     auto As() const {
         static_assert(
-            formats::common::impl::kHasParse<Value, T>,
+            formats::common::impl::HasParse<Value, T>,
             "There is no `Parse(const Value&, formats::parse::To<T>)` in namespace "
             "of `T` or `formats::parse`. "
             "Probably you have not provided a `Parse` function overload."
@@ -204,16 +204,15 @@ class Value {
     /// For example, `true` may be converted to 1.0.
     template <typename T>
     T ConvertTo() const {
-        if constexpr (formats::common::impl::kHasConvert<Value, T>) {
+        if constexpr (formats::common::impl::HasConvert<Value, T>) {
             return Convert(*this, formats::parse::To<T>{});
-        } else if constexpr (formats::common::impl::kHasParse<Value, T>) {
+        } else if constexpr (formats::common::impl::HasParse<Value, T>) {
             return Parse(*this, formats::parse::To<T>{});
         } else {
             static_assert(
                 !sizeof(T),
-                "There is no `Convert(const Value&, formats::parse::To<T>)` or"
-                "`Parse(const Value&, formats::parse::To<T>)`"
-                "in namespace of `T` or `formats::parse`. "
+                "There is no `Convert(const Value&, formats::parse::To<T>)` or "
+                "`Parse(const Value&, formats::parse::To<T>)` in namespace of `T` or `formats::parse`. "
                 "Probably you have not provided a `Convert` function overload."
             );
         }

mongo/include/userver/formats/bson/value_builder.hpp

@@ -22,8 +22,6 @@ USERVER_NAMESPACE_BEGIN
 
 namespace formats::bson {
 
-// clang-format off
-
 /// @brief Builder for BSON.
 ///
 /// Class provides methods for building BSON. For read only access to the
@@ -38,9 +36,6 @@ namespace formats::bson {
 /// @snippet formats/bson/value_builder_test.cpp  Sample Customization formats::bson::ValueBuilder usage
 ///
 /// @see @ref scripts/docs/en/userver/formats.md
-
-// clang-format on
-
 class ValueBuilder {
 public:
     using iterator = Iterator<ValueBuilder>;
@@ -119,11 +114,11 @@ class ValueBuilder {
 
     /// @brief Access member by key for modification.
     /// @throw `TypeMismatchException` if not object or null value.
-    template <
-        typename Tag,
-        utils::StrongTypedefOps Ops,
-        typename Enable = std::enable_if_t<utils::IsStrongTypedefLoggable(Ops)>>
-    ValueBuilder operator[](const utils::StrongTypedef<Tag, std::string, Ops>& name);
+    template <typename Tag, utils::StrongTypedefOps Ops>
+    requires(utils::IsStrongTypedefLoggable(Ops))
+    ValueBuilder operator[](const utils::StrongTypedef<Tag, std::string, Ops>& name) {
+        return (*this)[name.GetUnderlying()];
+    }
 
     /// @brief Retrieves array element by index
     /// @throws TypeMismatchException if value is not an array or `null`
@@ -208,20 +203,14 @@ class ValueBuilder {
     impl::ValueImplPtr impl_;
 };
 
-template <typename Tag, utils::StrongTypedefOps Ops, typename Enable>
-ValueBuilder ValueBuilder::operator[](const utils::StrongTypedef<Tag, std::string, Ops>& name) {
-    return (*this)[name.GetUnderlying()];
-}
-
 template <typename T>
 Value ValueBuilder::DoSerialize(const T& t) {
     static_assert(
-        formats::common::impl::kHasSerialize<Value, T>,
+        formats::common::impl::HasSerialize<Value, T>,
         "There is no `Serialize(const T&, formats::serialize::To<bson::Value>)` "
         "in namespace of `T` or `formats::serialize`. "
         ""
-        "Probably you forgot to include the "
-        "<userver/formats/serialize/common_containers.hpp> or you "
+        "Probably you forgot to include the <userver/formats/serialize/common_containers.hpp> or you "
         "have not provided a `Serialize` function overload."
     );
 

postgresql/include/userver/storages/postgres/io/row_types.hpp

@@ -107,8 +107,8 @@ constexpr bool DetectIsSuitableRowType() {
 template <typename T>
 struct IsSuitableRowType : BoolConstant<detail::DetectIsSuitableRowType<T>()> {};
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct IsSuitableRowType<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> : IsSuitableRowType<T> {};
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct IsSuitableRowType<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> : IsSuitableRowType<T> {};
 
 template <typename T>
 inline constexpr bool kIsSuitableRowType = IsSuitableRowType<T>::value;
@@ -131,8 +131,8 @@ struct RowCategory
                   RowCategoryConstant<RowCategoryType::kAggregate>,
                   RowCategoryConstant<RowCategoryType::kNonRow>>>> {};
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct RowCategory<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> : RowCategory<T> {};
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct RowCategory<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> : RowCategory<T> {};
 
 template <typename T>
 inline constexpr RowCategoryType kRowCategory = RowCategory<T>::value;

postgresql/include/userver/storages/postgres/io/strong_typedef.hpp

@@ -41,33 +41,33 @@ namespace traits {
 
 // Helper to detect if the strong typedef mapping is explicitly defined,
 // e.g. TimePointTz
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
 inline constexpr bool kIsStrongTypedefDirectlyMapped =
     // NOLINTNEXTLINE(google-readability-casting)
-    kIsMappedToUserType<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> ||
+    kIsMappedToUserType<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> ||
     // NOLINTNEXTLINE(google-readability-casting)
-    kIsMappedToSystemType<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> ||
+    kIsMappedToSystemType<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> ||
     // NOLINTNEXTLINE(google-readability-casting)
-    kIsMappedToArray<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>;
+    kIsMappedToArray<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>;
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct IsMappedToPg<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct IsMappedToPg<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>
     // NOLINTNEXTLINE(google-readability-casting)
-    : BoolConstant<kIsStrongTypedefDirectlyMapped<Tag, T, Ops, Enable> || kIsMappedToPg<T>> {};
+    : BoolConstant<kIsStrongTypedefDirectlyMapped<Tag, T, Ops> || kIsMappedToPg<T>> {};
 
 // Mark that strong typedef mapping is a special case for disambiguating
 // specialization of CppToPg
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct IsSpecialMapping<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct IsSpecialMapping<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>
     // NOLINTNEXTLINE(google-readability-casting)
-    : BoolConstant<!kIsStrongTypedefDirectlyMapped<Tag, T, Ops, Enable> && kIsMappedToPg<T>> {};
+    : BoolConstant<!kIsStrongTypedefDirectlyMapped<Tag, T, Ops> && kIsMappedToPg<T>> {};
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct IsNullable<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> : IsNullable<T> {};
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct IsNullable<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> : IsNullable<T> {};
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct GetSetNull<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> {
-    using ValueType = USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>;
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct GetSetNull<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> {
+    using ValueType = USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>;
     using UnderlyingGetSet = GetSetNull<T>;
     inline static bool IsNull(const ValueType& v) { return UnderlyingGetSet::IsNull(v.GetUnderlying()); }
     inline static void SetNull(ValueType& v) { UnderlyingGetSet::SetNull(v.GetUnderlying()); }
@@ -108,10 +108,10 @@ using EnableIfCanUseEnumAsStrongTypedef = std::enable_if_t<impl::CheckCanUseEnum
 
 }  // namespace traits
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct BufferFormatter<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>
-    : detail::BufferFormatterBase<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>> {
-    using BaseType = detail::BufferFormatterBase<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>;
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct BufferFormatter<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>
+    : detail::BufferFormatterBase<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>> {
+    using BaseType = detail::BufferFormatterBase<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>;
     using BaseType::BaseType;
 
     template <typename Buffer>
@@ -149,28 +149,27 @@ struct StrongTypedefParser<StrongTypedef, true> : BufferParserBase<StrongTypedef
 
 }  // namespace detail
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct BufferParser<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct BufferParser<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>
     : detail::StrongTypedefParser<
-          USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>,
+          USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>,
           detail::kParserRequiresTypeCategories<T>> {
     using BaseType = detail::StrongTypedefParser<
-        USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>,
+        USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>,
         detail::kParserRequiresTypeCategories<T>>;
     using BaseType::BaseType;
 };
 
 // StrongTypedef template mapping specialization
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
 struct CppToPg<
-    USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>,
-    std::enable_if_t<!traits::kIsStrongTypedefDirectlyMapped<Tag, T, Ops, Enable> && traits::kIsMappedToPg<T>>>
-    : CppToPg<T> {};
+    USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>,
+    std::enable_if_t<!traits::kIsStrongTypedefDirectlyMapped<Tag, T, Ops> && traits::kIsMappedToPg<T>>> : CppToPg<T> {};
 
 namespace traits {
 
-template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops, typename Enable>
-struct ParserBufferCategory<BufferParser<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops, Enable>>>
+template <typename Tag, typename T, USERVER_NAMESPACE::utils::StrongTypedefOps Ops>
+struct ParserBufferCategory<BufferParser<USERVER_NAMESPACE::utils::StrongTypedef<Tag, T, Ops>>>
     : ParserBufferCategory<typename traits::IO<T>::ParserType> {};
 
 }  // namespace traits

universal/include/userver/formats/common/meta.hpp

@@ -21,33 +21,21 @@ namespace impl {
 /// `formats` doesn't support SFINAE, so e.g. `kHasParse` can return `true`
 /// while a usage of `Parse` will fail to compile.
 
-template <typename Value, typename T>
-using HasParse = decltype(Parse(std::declval<const Value&>(), parse::To<T>{}));
-
-template <typename Value, typename T>
-using HasSerialize = decltype(Serialize(std::declval<const T&>(), serialize::To<Value>{}));
-
-template <typename Value, typename T>
-using HasConvert = decltype(Convert(std::declval<const Value&>(), parse::To<T>{}));
-
-template <typename Value>
-using IsFormatValue = typename Value::ParseException;
-
 template <class Value, class T>
-constexpr inline bool kHasParse = meta::IsDetected<HasParse, Value, T>;
+concept HasParse = requires(const Value& value) { Parse(value, parse::To<T>{}); };
 
 template <class Value, class T>
-constexpr inline bool kHasSerialize = meta::IsDetected<HasSerialize, Value, T>;
+concept HasSerialize = requires(const T& x) { Serialize(x, serialize::To<Value>{}); };
 
 template <class Value, class T>
-constexpr inline bool kHasConvert = meta::IsDetected<HasConvert, Value, T>;
+concept HasConvert = requires(const Value& value) { Convert(value, parse::To<T>{}); };
 
 }  // namespace impl
 
 /// Used in `Parse` overloads that are templated on `Value`, avoids clashing
 /// with `Parse` from string
 template <class Value>
-constexpr inline bool kIsFormatValue = meta::IsDetected<impl::IsFormatValue, Value>;
+concept kIsFormatValue = requires { typename Value::ParseException; };  // NOLINT(readability-identifier-naming)
 
 // Unwraps a transient type - tag types, for which ADL-found `Parse` returns
 // another type, not the type specified in `formats::parse::To`. For example,

universal/include/userver/formats/common/utils.hpp

@@ -44,8 +44,8 @@ ValueBuilder GetAtPath(ValueBuilder& parent, std::vector<std::string>&& path, st
 /// @note For empty `path` this function returns `parent`.
 /// @throws TypeMismatchException if there is a non-object node in the middle of
 /// `path`
-template <typename Value>
-std::enable_if_t<common::kIsFormatValue<Value>, Value> GetAtPath(Value parent, const std::vector<std::string>& path) {
+template <common::kIsFormatValue Value>
+Value GetAtPath(Value parent, const std::vector<std::string>& path) {
     auto current_value = std::move(parent);
     for (const auto& current_key : path) {
         current_value = current_value[current_key];
@@ -58,10 +58,8 @@ std::enable_if_t<common::kIsFormatValue<Value>, Value> GetAtPath(Value parent, c
 /// @throws TypeMismatchException if there is a non-object node in the middle of
 /// `path`
 template <typename ValueBuilder>
-std::enable_if_t<!common::kIsFormatValue<ValueBuilder>, ValueBuilder> GetAtPath(
-    ValueBuilder& parent,
-    std::vector<std::string>&& path
-) {
+requires(!common::kIsFormatValue<ValueBuilder>)
+ValueBuilder GetAtPath(ValueBuilder& parent, std::vector<std::string>&& path) {
     return impl::GetAtPath(parent, std::move(path), path.size());
 }
 

universal/include/userver/formats/json/value.hpp

@@ -352,11 +352,9 @@ class Value {
 template <typename T>
 auto Value::As() const {
     static_assert(
-        formats::common::impl::kHasParse<Value, T>,
-        "There is no `Parse(const Value&, formats::parse::To<T>)` "
-        "in namespace of `T` or `formats::parse`. "
-        "Probably you forgot to include the "
-        "<userver/formats/parse/common_containers.hpp> or you "
+        formats::common::impl::HasParse<Value, T>,
+        "There is no `Parse(const Value&, formats::parse::To<T>)` in namespace of `T` or `formats::parse`. "
+        "Probably you forgot to include the <userver/formats/parse/common_containers.hpp> or you "
         "have not provided a `Parse` function overload."
     );
 
@@ -405,17 +403,15 @@ auto Value::As(Value::DefaultConstructed) const {
 
 template <typename T>
 T Value::ConvertTo() const {
-    if constexpr (formats::common::impl::kHasConvert<Value, T>) {
+    if constexpr (formats::common::impl::HasConvert<Value, T>) {
         return Convert(*this, formats::parse::To<T>{});
-    } else if constexpr (formats::common::impl::kHasParse<Value, T>) {
+    } else if constexpr (formats::common::impl::HasParse<Value, T>) {
         return Parse(*this, formats::parse::To<T>{});
     } else {
         static_assert(
             !sizeof(T),
-            "There is no `Convert(const Value&, formats::parse::To<T>)` or"
-            "`Parse(const Value&, formats::parse::To<T>)`"
-            "in namespace of `T` or `formats::parse`. "
-            "Probably you have not provided a `Convert` function overload."
+            "There is no `Convert(const Value&, formats::parse::To<T>)` or `Parse(const Value&, formats::parse::To<T>)`"
+            "in namespace of `T` or `formats::parse`. Probably you have not provided a `Convert` function overload."
         );
     }
 }