Enumerated type

In computer programming, an enumerated type is a data type whose set of values is a finite list of identifiers chosen by the programmer. Typically the compiler will select a small integer to represent each enumeration value at run-time, but this representation is not always visible to the programmer.

In some languages, the boolean type of truth values is considered a predeclared enumerated type of two values.

Pascal

In Pascal, an enumerated type can be implicitly declared by listing the values in a parenthesised list:

 var
   suit: (clubs, diamonds, hearts, spades);
   value: 1 .. 13;

The declaration will often appear in a type synonym declaration, such that it can be used for multiple variables:

 type
   cardsuit = (clubs, diamonds, hearts, spades);
   card = record
            suit: cardsuit;
            value: 1 .. 13;
          end;
 var
   hand: array [ 1 .. 13 ] of card;
   trump: cardsuit;

The order in which the enumeration values are given matters. An enumerated type is an ordinal type, and the prec and succ functions will give the prior or next value of the enumeration, and ord can convert enumeration values to their integer representation. Standard Pascal does not offer a conversion from arithmetic types to enumerations, however.

C and syntactically similar languages

The original K&R dialect of the C programming language did not have enumerated types, but they were added in the ANSI standard for C, which became C89. In C, enumerations are created by explicit definitions, which use the enum keyword and are reminiscent of struct and union definitions:

 enum cardsuit {
   CLUBS,
   DIAMONDS,
   HEARTS,
   SPADES
 };
 struct card {
   enum cardsuit suit;
   short int value;
 } hand[13];
 enum cardsuit trump;

C exposes the small-integer representation of enumeration values directly to the programmer. Integers and enum values can be mixed freely, and all arithmetic operations on enum values are permitted. It is even possible for an enum variable to hold an integer that does not represent any of the enumeration values. In fact, according to the language definition, the above code will define CLUBS, DIAMONDS, HEARTS, and SPADES as constants of type int, which will only be converted (silently) to enum cardsuit if and when they are stored in a variable of that type.

C also allows the programmer to choose the values of the enumeration constants explicitly. For example,

 enum cardsuit {
   CLUBS    = 1,
   DIAMONDS = 2,
   HEARTS   = 4,
   SPADES   = 8
 };

could be used to define an type that allows mathematical sets of suits to be represented as an enum cardsuit by bitwise logic operations.

Typeless languages in the syntactic tradition of C (e.g. perl or JavaScript) do not in general provide enumerations.

C++

C++ has enumeration types that are directly inherited from C's and work mostly like these.

Java

The J2SE version of the Java programming language added enumerated types whose declaration syntax is similar to that of C's:

 enum Cardsuit { Clubs, Diamonds, Spades, Hearts }
 ...
 Cardsuit trump ;

The Java type system, however, treats enumerations as a type separate from integers, and intermixing of enum and integer values is not allowed. An enum type in Java behaves more like a class (computer science) than an aritmetic; it can even have instance methods (which can be specified to be different for each enumeration value).

C#

Enumerated types in the C# programming language preserve most of the "small integer" semantics of C's enums. Some arithmetic operations are not defined for enums, but an enum value can be explicitly converted to an integer and back again, and an enum variable can store values that were not declared by the enum definition. For example, given

 enum cardsuit { CLUBS, DIAMONDS, SPADES, HEARTS };

the expressions DIAMONDS+1 and HEARTS-CLUBS are allowed directly (because it makes sense to step through the sequence of values or ask how many steps there are between two values), but HEARTS*SPADES is deemed to make less sense and is only allowed if the values are first converted to integers.

Algebraic data type in functional programming

In functional programming languages in the ML lineage (e.g., SML, OCaml and Haskell), an algebraic data type with only nullary constructors can be used to implement an enumerated type. For example (in the syntax of SML signatures):

  datatype cardsuit = Clubs | Diamonds | Hearts | Spades
  type card = { suit: cardsuit; value: int }
  val hand : card list
  val trump : cardsuit

In these languages the small-integer representation is completely hidden from the programmer, if indeed such a representation is employed by the implementation. However, Haskell has the Enum type class which a type can derive or implement to get a mapping between the type and Int.

Java

JDK 1.5 added enumerated types to its primitive types. The Java version of enumerated types are very similar to C's and C's descendants. It allows multiple uses, including a use for switch and case statements, as in:

enum Dirs { N, NE, E, SE, S, SW, W, NW }

direction = "[Input from user]";

switch (direction) {

    case N: System.out.println("N"); break;
    case NE: System.out.println("NE"); break;
    case E: System.out.println("E"); break;
    case SE: System.out.println("SE"); break;
    case S: System.out.println("S"); break;
    case SW: System.out.println("SW"); break;
    case W: System.out.println("W"); break;
    case NW: System.out.println("NW"); break;

}