www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Templated Enums?

reply "Era Scarecrow" <rtcvb32 yahoo.com> writes:
  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
}
Jun 06 2012
next sibling parent reply Johannes Pfau <nospam example.com> writes:
Am Wed, 06 Jun 2012 21:01:21 +0200
schrieb "Era Scarecrow" <rtcvb32 yahoo.com>:

   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
 

According to http://dlang.org/template.html something like this: --------------- class Bar(T) { T member; } --------------- is actually only syntactic sugar for this: --------------- template Bar(T) { class Bar { T member; } } --------------- So instead of --------------- enum(T) X { bitsPerT = T.sizeof * 8, } --------------- it should be possible to do this: --------------- template X(T) { enum X { bitsPerT = T.sizeof * 8, } } ---------------
Jun 06 2012
parent =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 06/06/2012 05:33 PM, Era Scarecrow wrote:
 On Wednesday, 6 June 2012 at 20:52:14 UTC, bearophile wrote:
 That seems correct, this works:

 template Foo(T) {
 enum Foo {
 bitsPerT = T.sizeof * 8,
 }
 }
 void main() {
 pragma(msg, Foo!int.bitsPerT);
 }


 So if template Foo(T){enum Foo{}} works, then I think it should also
 work the enum Foo(T){} syntax.

 So far I don't think I have had to use templated enums, but if other
 people have such need, than this thread and this post have enough
 material for a little enhancement request.

Well if it was only 1-2 value I wouldn't probably have bothered. However when there are several flags enums and values that are calculated based on eachother and used together; I wouldn't want to write enums manually for each type. Seems I'm being thrown now into the deep end of templates and constraints and traits and trying to fully understand it enough to use it all. What an exciting time to be alive :)

As far as I understand, this is all you need: template bitsPer(T) { static if (is (T ClassType == class)) { enum bitsPer = __traits(classInstanceSize, ClassType) * 8; } else { enum bitsPer = T.sizeof * 8; } } class C { int[10] a; } void main() { static assert(bitsPer!byte == 8); static assert(bitsPer!int == 32); static assert(bitsPer!C == 448); } Other specializations of bitsPer may be needed. Ali -- D Programming Language Tutorial: http://ddili.org/ders/d.en/index.html
Jun 06 2012
prev sibling next sibling parent "Era Scarecrow" <rtcvb32 yahoo.com> writes:
On Wednesday, 6 June 2012 at 19:27:25 UTC, Johannes Pfau wrote:
 Am Wed, 06 Jun 2012 21:01:21 +0200
 schrieb "Era Scarecrow" <rtcvb32 yahoo.com>:
 According to http://dlang.org/template.html
 something like this:
 ---------------
 class Bar(T) { T member; }
 ---------------

 is actually only syntactic sugar for this:
 ---------------
 template Bar(T) { class Bar { T member; } }
 ---------------

 So instead of
 ---------------
 enum(T) X
 {
      bitsPerT = T.sizeof * 8,
 }
 ---------------

 it should be possible to do this:
 ---------------
 template X(T)
 {
     enum X
     {
         bitsPerT = T.sizeof * 8,
     }
 }
 ---------------

Interesting... I was wondering that as well, however I don't fully understand templates; those and tuples. I'm sure I'll grok it all eventually.
Jun 06 2012
prev sibling next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
Johannes Pfau:

 it should be possible to do this:
 ---------------
 template X(T)
 {
     enum X
     {
         bitsPerT = T.sizeof * 8,
     }
 }

That seems correct, this works: template Foo(T) { enum Foo { bitsPerT = T.sizeof * 8, } } void main() { pragma(msg, Foo!int.bitsPerT); } So if template Foo(T){enum Foo{}} works, then I think it should also work the enum Foo(T){} syntax. So far I don't think I have had to use templated enums, but if other people have such need, than this thread and this post have enough material for a little enhancement request. Bye, bearophile
Jun 06 2012
prev sibling parent "Era Scarecrow" <rtcvb32 yahoo.com> writes:
On Wednesday, 6 June 2012 at 20:52:14 UTC, bearophile wrote:
 That seems correct, this works:

 template Foo(T) {
    enum Foo {
        bitsPerT = T.sizeof * 8,
    }
 }
 void main() {
     pragma(msg, Foo!int.bitsPerT);
 }


 So if template Foo(T){enum Foo{}} works, then I think it should 
 also work the enum Foo(T){} syntax.

 So far I don't think I have had to use templated enums, but if 
 other people have such need, than this thread and this post 
 have enough material for a little enhancement request.

Well if it was only 1-2 value I wouldn't probably have bothered. However when there are several flags enums and values that are calculated based on eachother and used together; I wouldn't want to write enums manually for each type. Seems I'm being thrown now into the deep end of templates and constraints and traits and trying to fully understand it enough to use it all. What an exciting time to be alive :)
Jun 06 2012