I have a struct template that takes an alias parameter and I'm
trying to distinguish between type parameters and enum values.
std.traits.isType works for this except for one edge case:
```
import std.traits;
import std.stdio;
struct S{}
enum x;
enum y = 5;
struct Wrap(alias T) {
static if(isType!T){
T value; //When t == x this doesn't work because `x` is
opaque and has no default initializer
}
}
void main()
{
pragma(msg, isType!x); //true
pragma(msg, isType!y); //false
Wrap!S ws; //OK
Wrap!x wx; //error instantiating
Wrap!y wy; //OK, because we the static if condition is false
}
```
x is a "type" as far as isType is concerned (which makes sense to
me), but I don't think you can ever declare a variable of that
type since there's no way to initialize it... Is there a trait
that can tell if you can initialize a variable of a certain type?
The best I can think of is __traits(compiles, "T x;"), but it
seems like it should be possible to do better?
