This curiosity was part of my CppCon Open Content talk in 2024, “Another Grab-bag of C++ Oddments”. The session highlighted C++ oddities, in the spirit of discovery through play.<\/p>\n\n\n\n
For reasons (TM), I want to be able to do this:<\/p>\n\n\n\n
auto x = VALUE(42); \/\/ 42\nauto y = VALUE(\"hello\"sv); \/\/ std::string_view{\"hello\"}\nauto z = VALUE(int); \/\/ std::type_identity<int>{}<\/code><\/pre>\n\n\n\nOf note here:<\/p>\n\n\n\n
\nx<\/code> uses a value that can<\/em> be used as a template argument<\/li>\n\n\n\ny<\/code> uses a value that is not<\/em> admissible as a template argument (std::string_view<\/code> is not a structural type<\/a>)<\/li>\n\n\n\nz<\/code> uses a type “as if it were a value”<\/li>\n\n\n\n- for my use cases, the “values” here are known at compile time and are almost always literals<\/li>\n<\/ul>\n\n\n\n
Some use cases I have in mind are things like logging, where I want to be able to say things like…<\/p>\n\n\n\n
LOG(\"{} {}\", VALUE(42), VALUE(int));<\/code><\/pre>\n\n\n\n…and have the logging library do the right thing. (If given a type, we might typically do the old __PRETTY_FUNCTION__ <\/code>trick to recover its name.)<\/p>\n\n\n\nWell, it seems fairly obvious that this is going to have to be a macro. Here’s the skeleton.<\/p>\n\n\n\n
#define VALUE(...)\n [] {\n if constexpr(\/* detect *\/) {\n \/\/ __VA_ARGS__ is a type\n } else {\n \/\/ __VA_ARGS__ is a value\n }\n }()<\/code><\/pre>\n\n\n\nI’m omitting the backslashes at the end of lines for clarity. And I’m using a variadic macro to allow it to handle arguments with commas in them (like types which are template specializations, for example).<\/p>\n\n\n\n
OK, the first thing we need is a way to determine whether we have a type or a value. The only way I know to do that is with an overload set.<\/p>\n\n\n\n
template <auto> \nconstexpr auto is_type() -> std::false_type;\n\ntemplate <typename>\nconstexpr auto is_type() -> std::true_type;\n\n\/\/ then use the expression\ndecltype(is_type<__VA_ARGS__>())::value<\/code><\/pre>\n\n\n\nThis works for 42<\/code> and int<\/code>, but not for a string_view<\/code>, because it’s a hard compilation error to attempt to pass it as a template argument. So let’s make a type that we can<\/em> pass.<\/p>\n\n\n\nstruct from_any {\n template <typename... Ts>\n constexpr from_any(Ts const &...) {}\n\n constexpr operator int() const { return 0; }\n};\n\n\/\/ then use the expression\ndecltype(is_type<from_any(__VA_ARGS__)>())::value;<\/code><\/pre>\n\n\n\nfrom_any<\/code> is a class that is implicitly constructible from any argument(s). from_any<\/code> is a structural type, so we could pass it as a template argument (from C++20 onwards), but giving it an implicit conversion to int<\/code> also means this works pre-C++20. We’ll just change the overload set to be friendly:<\/p>\n\n\n\ntemplate <int> \/\/ was auto\nconstexpr auto is_type() -> std::false_type;\n\ntemplate <typename>\nconstexpr auto is_type() -> std::true_type;<\/code><\/pre>\n\n\n\nWait, how does the expression work? Well, consider the cases:<\/p>\n\n\n\n
\/\/ this is a value of type from_any\n\/\/ constructed from 42\nfrom_any(42)\n\n\/\/ this is a value of type from_any\n\/\/ constructed from a string_view\nfrom_any(\"hello\"sv)\n\n\/\/ this is a type - it's the type of\n\/\/ a function taking int and returning from_any\nfrom_any(int)<\/code><\/pre>\n\n\n\n(Raised eyebrows and murmurs from the audience.) It’s not common to see “bare” function types like this, but they are well-formed. So this gives us what we need to differentiate types and values (including non-structural values).<\/p>\n\n\n\n
template <int>\nconstexpr auto is_type() -> std::false_type;\ntemplate <typename>\nconstexpr auto is_type() -> std::true_type;\n\nis_type<from_any(42)>() \/\/ false_type\nis_type<from_any(\"hello\"sv)>() \/\/ false_type\nis_type<from_any(int)>() \/\/ true_type<\/code><\/pre>\n\n\n\nNow the detection part of the skeleton is fleshed out.<\/p>\n\n\n\n
#define VALUE(...)\n [] {\n if constexpr(decltype(is_type<from_any(__VA_ARGS__)>())::value) {\n \/\/ __VA_ARGS__ is a type\n } else {\n \/\/ __VA_ARGS__ is a value\n }\n }()<\/code><\/pre>\n\n\n\nThe next thing to do is to figure out what to put in the first half of the if constexpr<\/code> block.<\/p>\n\n\n\nAlthough only one side at a time will actually be used, both sides have to be syntactically well-formed for both types and values. So we can’t<\/em> just assume that we have a type, and pass it to a template. But we can<\/em> use a similar trick to is_type<\/code> to recover the type in the top half and then put it into a type_identity<\/code>. (Strictly if we want this to continue working before C++20, we need to provide our own type_identity<\/code> class template, but that is easily done, so I’ll omit it here.)<\/p>\n\n\n\ntemplate <typename> struct typer;\ntemplate <typename T>\nstruct typer<from_any(T)> {\n using type = T;\n};\n\ntemplate <int>\nconstexpr auto type_of() -> void;\ntemplate <typename T>\nconstexpr auto type_of()\n -> typename typer<T>::type;\n\n\/\/ and then\nusing actual_type = \n decltype(type_of<from_any(__VA_ARGS__)>());<\/code><\/pre>\n\n\n\ntype_of<\/code> is using the same overloading form that is_type<\/code> uses, and this time we’re using a typer<\/code> helper to recover the T<\/code> from the function type (from_any(T)<\/code>). If a value went through this machinery, it would just spit out void<\/code>, but still be good syntax-wise.<\/p>\n\n\n\nWe’re more than halfway done now:<\/p>\n\n\n\n
#define VALUE(...)\n [] {\n if constexpr(decltype(is_type<from_any(__VA_ARGS__)>())::value) {\n using actual_type = decltype(type_of<from_any(__VA_ARGS__)>());\n return std::type_identity<actual_type>{};\n } else {\n \/\/ __VA_ARGS__ is a value\n }\n }()<\/code><\/pre>\n\n\n\nJust the other half of the if constexpr<\/code> to go.<\/p>\n\n\n\nAt this point in the Open Content session, the fire alarm went off! The session was adjourned and rescheduled for lunchtime, opposite Jason Turner’s session. So if you left here, and went to see Jason at lunch, I don’t blame you. But you did miss this next bit, which was perhaps the most funny\/surprising moment of the talk…<\/p>\n\n\n\n
Now we need another construct that is syntactically well-formed when given either a value or a type, but this time we just need it to produce the value.<\/p>\n\n\n\n
Consider the following syntax:<\/p>\n\n\n\n
\/\/ special is a type we'll write\n(__VA_ARGS__) + special{};<\/code><\/pre>\n\n\n\nWhen __VA_ARGS__<\/code> is a value<\/em>, this is a binary plus expression. When __VA_ARGS__<\/code> is a type<\/em>, this is a C-style cast of a unary plus expression. This construction works for both types and values! (Outbursts of “WHAT” from the audience.) All we have to do is define special<\/code> appropriately.<\/p>\n\n\n\nstruct special {\n template <typename T>\n friend constexpr auto operator+(T&& t, special) {\n return t;\n }\n\n friend constexpr auto operator+(special) -> special;\n template <typename T> constexpr operator T() const;\n};<\/code><\/pre>\n\n\n\nGiven the if constexpr<\/code>, we’re only ever going to exercise this code with a value, so the unary plus interpretation will never actually be used. We don’t need to define<\/em> the unary operator+<\/code> and the conversion operator – they only need to be declared<\/em> so that the type interpretation is syntactically well-formed.<\/p>\n\n\n\n(Side note: we could have used operator*<\/code> here too, since it’s also an overloadable operator with both unary and binary forms. Either plus or multiply works.)<\/p>\n\n\n\nNow we are done.<\/p>\n\n\n\n
#define VALUE(...)\n [] {\n if constexpr(decltype(is_type<from_any(__VA_ARGS__)>())::value) {\n using actual_type = decltype(type_of<from_any(__VA_ARGS__)>());\n return std::type_identity<actual_type>{};\n } else {\n return (__VA_ARGS__) + special{};\n }\n }()<\/code><\/pre>\n\n\n\nThis does the job we originally wanted. Is it useful? Maybe. It is fun and educational to write and present at CppCon Open Content? Definitely.<\/p>\n\n\n\n
Thanks to everyone who came to my open content. See you at the next conference hallway track. And if you can’t come to a conference, maybe you can spare a couple of hours a month to go to a meetup. If you don’t have a local one (or even if you do), you are welcome at the Denver C++ meetup<\/a>. We meet on-site and remotely on the first Thursday of every month. It’s always fun.<\/p>\n\n\n\n<\/p>\n","protected":false},"excerpt":{"rendered":"
This curiosity was part of my CppCon Open Content talk in 2024, “Another Grab-bag of C++ Oddments”. The session highlighted C++ oddities, in the spirit of discovery through play. For reasons (TM), I want to be able to do this: Of note here: Some use cases I have in mind…<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[22],"tags":[],"class_list":["post-1771","post","type-post","status-publish","format-standard","hentry","category-cpp"],"_links":{"self":[{"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1771","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1771"}],"version-history":[{"count":6,"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1771\/revisions"}],"predecessor-version":[{"id":1779,"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1771\/revisions\/1779"}],"wp:attachment":[{"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1771"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1771"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.elbeno.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1771"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}