Using Ada code examples below:

On Monday, 7 April 2014 at 16:25:45 UTC, Regan Heath wrote:
On Mon, 07 Apr 2014 16:15:41 +0100, Paulo Pinto <> wrote:

Am 07.04.2014 12:07, schrieb Regan Heath:
On Mon, 07 Apr 2014 00:17:45 +0100, Andrei Alexandrescu
<> wrote:

On 4/6/14, 10:52 AM, Walter Bright wrote:
On 4/6/2014 3:31 AM, Leandro Lucarella wrote:
What I mean is the current semantics of enum are as they are for historical reasons, not because they make (more) sense (than other possibilities). You showed a lot of examples that makes sense only because you are used to the current semantics, not because they are the
only option or the option that makes the most sense.

I use enums a lot in D. I find they work very satisfactorily. The way they work was deliberately designed, not a historical accident.

Sorry, I think they ought to have been better. -- Andrei

Got a DIP/spec/design to share?


How they work in languages like Ada.

Ok, brief look at those shows me enums can be converted to a "Pos" index but otherwise you cannot associate a numberic value with them, right?

So if we had that in D, Walters examples would look like..


  enum Index { A, B, C }
  T[Index.C.pos + 1] array; // perhaps?

type Index is (A, B, C);

d_array: array Index'Length of T;

  array[Index.B.pos] = t;   // yes?

d_array(Index'Pos(B)) := t;


  array[Index.A.pos + 1] = t; // yes?

d_array(Index'Succ(A)) := t;


  enum Mask { A=1,B=4 } // not possible?

  Mask m = A | B;   // Error: incompatible operator | for enum

type Mask is (A, B);
for Mask use (A => 1, B => 4);

m : Mask := Mask'Pos(A) or Mask'Pos(B);

Have I got that right?

For a proposal like this to even be considered I would imagine it would have to be backward compatible with existing uses, so you would have to be proposing a new keyword or syntax on "enum" to trigger typesafe enums, perhaps "typesafe" is a good keyword, e.g.

typesafe enum Index { A, B, C } // requires use of .pos to convert to int 0, 1, or 2.
enum Index { A, B, C }          // existing pragmatic behaviour


This is the C++ approach with enum class for strong typed enums.

Reply via email to