Templated Enums?

[Era Scarecrow]

  I've come across an interesting problem. You can template quite 
a few items, but not enums? Some thoughts from the experts would 
likely be nice. Consider...

enum(T) X{ //syntax error
     bitsPerT = T.sizeof * 8,
     //further calculation types can follow
}

assert(X!(byte).bitsPerT == 8);

The compile complains outright you can't do this, but enclosing 
it in a struct makes that problem go away with the same results.

struct(T) X {
     enum {
         bitsPerT = T.sizeof * 8,
     }
}

assert(X!(byte).bitsPerT == 8); //compiles and works

Now obviously X!(byte).bitsPerT is a mouthful, and although alias 
can condense the code, using different inner members require 
unique names, With does a simpler job in a smaller more compact 
scope.

alias X!(byte) bitsPerByte; //unique name unless small scope

assert(bitsPerByte == 8);

with(X!(int)) {
   assert(bitsPerT == 32);
}

  Unfortunately properties (static functions) don't work with this.

struct(T) X {
     @property static T plusOne(T i) {return i + 1;}
}

with(X!int) {
     int x;
     writeln(x.plusOne);  //error: plusOne function/template not 
defined...
     writeln(plusOne(x)); //works
}