• JR (29/52) Nov 02 2013 Quoth Dmitry Olshansky in my thread on ctRegex and GC pressure[1]:
• =?UTF-8?B?QWxpIMOHZWhyZWxp?= (24/43) Nov 14 2013 I think it is more like because its value is known at compile time. If
• bearophile (5/8) Nov 14 2013 When you can or want to compute something at compile-time, when
• Timothee Cour (6/14) Nov 15 2013 but you can *can* do that with static const /const/immutable variables t...

"JR" <zorael gmail.com> writes:

(TL;DR: when to avoid enum?)

 From the dlang.org page on enums;
 Enum declarations are used to define a group of constants. They 
 come in these forms:
 
 Named enums, which have an EnumTag.
 Anonymous enums, which do not have an EnumTag.
 Manifest constants.

Quoth Dmitry Olshansky in my thread on ctRegex and GC pressure[1]:
 The problem is that ctRegex returns you a pack of 
 datastructures (=arrays).
 Using them with enum makes it behave as if you pasted them as 
 array literals and these do allocate each time.
 
 TL;DR: use static and/or auto with ctRegex not enum.

1. I see the use and convenience of multi-member enums, be they 
anonymous or named.
2. I understand it's the preferred way of forcing something to be 
evaluated at compile-time. The language page does not mention 
this, but I believe TDPL did?
3. I understand that enums are used to define the value of 
eponymous template instantiations. (But my snowflake self finds 
it an unintuitive and ad-hoc way of declaration.)
4. I gather that you should think of enum contents as being 
copy/pasted to wherever they are used.
5. I understand there's a hidden gotcha with (4) and types that 
allocate.
6. I understand that, given a string, instantiating any number of 
other string variables with the value of the first will simply 
alias them to the same immutable char array. (string abc = "def"; 
string ghi = abc;)

But in Andrei's thread on tristates[2] he lists this code excerpt:
 struct Tristate
 {
     private static Tristate make(ubyte b)
     {
         Tristate r = void;
         r.value = b;
         return r;
     }
 
     enum no = make(0), yes = make(1), unknown = make(4);  // 
 <---

Is it okay to use enum there? If so, is it because (whatwith 
being a struct) it's not on the heap? What if it were a class? A 
string? A string instantiated with the value of another string, 
which would normally simply create an alias?

When is an enum *better* than a normal (static const/immutable) 
constant?


[1]: http://forum.dlang.org/post/l2456h$18jk$1 digitalmars.com
[2]: http://forum.dlang.org/post/l4gnrc$2glg$1 digitalmars.com


TFMIU. ;>

=?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:

On 11/02/2013 02:14 PM, JR wrote:

 But in Andrei's thread on tristates[2] he lists this code excerpt:
 struct Tristate
 {
     private static Tristate make(ubyte b)
     {
         Tristate r = void;
         r.value = b;
         return r;
     }

     enum no = make(0), yes = make(1), unknown = make(4);  // <---

 Is it okay to use enum there? If so, is it because (whatwith being a
 struct) it's not on the heap?

I think it is more like because its value is known at compile time. If 
Tristate were a class, then the class variable r would not have any 
class object that it pointed to.

 What if it were a class?

I tried changing struct to class:

class Tristate
{
     ubyte value;

     private static Tristate make(ubyte b)
     {
         Tristate r = new Tristate();
         r.value = b;
         return r;
     }

     enum no = make(0), yes = make(1), unknown = make(4);
}

Error: variable deneme.Tristate.no : Unable to initialize enum with 
class or pointer to struct. Use static const variable instead.

So, class can't work.

 A string?

That would be ok. A compile-time string is known to the compiler and can 
appear in the program binary to be referenced from multiple places.

 A
 string instantiated with the value of another string, which would
 normally simply create an alias?

Would work.

 When is an enum *better* than a normal (static const/immutable) constant?

Good question. :)

Ali

"bearophile" <bearophileHUGS lycos.com> writes:

Ali Çehreli:

 When is an enum *better* than a normal (static

 const/immutable) constant?

 Good question. :)

When you can or want to compute something at compile-time, when 
you need values to feed to templates, etc.

Bye,
bearophile

Timothee Cour <thelastmammoth gmail.com> writes:

On Thu, Nov 14, 2013 at 5:02 PM, bearophile <bearophileHUGS lycos.com>wrote=
:

 Ali =C7ehreli:


  > When is an enum *better* than a normal (static
 const/immutable) constant?

 Good question. :)

 When you can or want to compute something at compile-time, when you need
 values to feed to templates, etc.

but you can *can* do that with static const /const/immutable variables too:

auto fun2(int a)(int b){...}
immutable a=3Dfun(2);//static const /const/immutable/enum
auto b=3Dfun2!a(3);