Why no non-integral enums?

Question

Why is it that non-integral enums cannot be created? I want to know if this is a language design decision, or if there are issues with implementing this in the compiler.

In other words, is it feasible to implement non-integral enums into the language, but there just isn't a justifiable need? Or if it isn't feasible but is justifiable, what impediment are in the way?

Someone give me the skinny on what the reason or rationale is for not having this available in C#, pretty please.

Answer 1

There's no technical reason why it couldn't be done, but then, we are really more talking about a set of constants (perhaps within a common namespace, if they're related).

In an enum, the numerical value is generally secondary.

In the following:

enum Fruit {
  Apple,
  Orange,
  Pear,
  Peach
}

we are only describing a set of named constants. We are saying that a variable of type Fruit can take one of these four values. What the integer value of each one is, is really not relevant. As long as I only refer to them by name, it doesn't matter if the value representing Apple is 0, 1, 32, -53 or 0.002534f.

Most languages do allow you to specify the value that should represent each, but that's really secondary. It's sometimes useful, but it's not part of the core purpose with enums. They are simply there to give you a set of related named constants without having to specify an integer ID for each.

Further, enums are often used to specify optional flags that can be combined with bitwise operations. That is trivial to implement if each value is represented by an integer (then you just have to pick an integer that uses the bit pattern you want). Floating-point values wouldn't be useful in this context. (bit-wise and/or operations don't make much sense on floating-point values)

Answer 2

I think enums were made this way because, as opposed to what you want to do, enumerations weren't meant to hold any meaningful numerical representation.

For example, enums are perfect for describing the ff:

enum Color
{
   Black,
   White,
   Red,
   Yellow,
   Blue,
   //everything else in between
}

(admittedly color can be represented by complex types numerically, but indulge me for the moment). How about mood?

enum Mood
{
    Happy,
    Giddy,
    Angry,
    Depressed,
    Sad
}

or taste?

enum Taste
{
    Bitter,
    Salty,
    Sweet,
    Spicy
}

I think you get the point. Bottomline is: enumerations were meant to represent objects or object characteristics that are difficult to represent numerically, or do not have meaningful or practical numerical representations -- and thus the arbitrary assignment to an integer which is the most convenient data type for such.

This is as opposed to things like holidays, which are numerically meaningful.