Hcfyk

Is it possible to declare a new type (an empty struct , or a struct without an implementation) on the fly?

E.g.

constexpr auto make_new_type() -> ???;

using A = decltype(make_new_type());
using B = decltype(make_new_type());
using C = decltype(make_new_type());

static_assert(!std::is_same<A, B>::value, "");
static_assert(!std::is_same<B, C>::value, "");
static_assert(!std::is_same<A, C>::value, "");

A "manual" solution is

template <class> struct Tag;

using A = Tag<struct TagA>;
using B = Tag<struct TagB>;
using C = Tag<struct TagC>;

or even

struct A;
struct B;
struct C;

but for templating / meta some magic make_new_type() function would be nice.

Can something like that be possible now that stateful metaprogramming is ill-formed?

In C++20:

using A = decltype([]); // an idiom
using B = decltype([]);
...

This is idiomatic code: that’s how one writes “give me a unique type” in C++20.

In C++11, the clearest and simplest approach uses __LINE__:

namespace 
 template <int> class new_type ;


using A = new_type<__LINE__>; // an idiom - pretty much
using B = new_type<__LINE__>;

The anonymous namespace is the most important bit. It is a serious mistake not to put the new_type class in the anonymous namespace: the types then won't be unique anymore across translation units. All sorts of hilarity will ensue 15 minutes before you plan to ship :)

This extends to C++98:

namespace 
 template <int> class new_type ;


typedef new_type<__LINE__> A; // an idiom - pretty much
typedef new_type<__LINE__> B;

Another approach would be to manually chain the types, and have the compiler statically validate that the chaining was done correctly, and bomb out with an error if you don’t. So it’d not be brittle (assuming the magic works out).

Something like:

namespace 
 struct base_
 using discr = std::integral_type<int, 0>;
 ;

 template <class Prev> class new_type 
 [magic here]
 using discr = std::integral_type<int, Prev::discr+1>;
 ;


using A = new_type<base_>;
using A2 = new_type<base_>;
using B = new_type<A>;
using C = new_type<B>;
using C2 = new_type<B>;

It takes only a small bit of magic to ensure that the lines with types A2 and C2 don’t compile. Whether that magic is possible in C++11 is another story.

You can almost get the syntax you want using

template <size_t>
constexpr auto make_new_type() return [](); 

using A = decltype(make_new_type<__LINE__>());
using B = decltype(make_new_type<__LINE__>());
using C = decltype(make_new_type<__LINE__>());

This works since every lambda expression results in a unique type. So for each unique value in <> you get a different function which returns a different closure.

If you introduce a macro you can get rid of having to type __LINE__ like

template <size_t>
constexpr auto new_type() return [](); 

#define make_new_type new_type<__LINE__>()

using A = decltype(make_new_type);
using B = decltype(make_new_type);
using C = decltype(make_new_type);

I know... they are distilled evil... but seems to me that this is a works for an old C-style macro

#include <type_traits>

#define newType(x) 
struct type_##x ; 
using x = type_##x;

newType(A)
newType(B)
newType(C)

int main ()
 
 static_assert(!std::is_same<A, B>::value, "");
 static_assert(!std::is_same<B, C>::value, "");
 static_assert(!std::is_same<A, C>::value, "");