GeezerVison

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

var
    suit: (clubs, diamonds, hearts, spades);

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 pred 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. Extended Pascal offers this functionality via an extended succ function. Some other Pascal dialects allow it via type-casts. Some modern descendants of Pascal, such as Modula-3, provide a special conversion syntax using a method called VAL; Modula-3 also treats BOOLEAN and CHAR as special pre-defined enumerated types and uses ORD and VAL for standard ASCII decoding and encoding.

Pascal style languages also allow enumeration to be used as array index:

  var
    suitcount: array [cardsuit] of integer;

In Ada, the definition of enumerated types is similar to Pascal, replacing the use of "=" with "is":

type Cardsuit is (clubs, diamonds, hearts, spades);

In addition to Pred, Succ, Val and Pos, Ada also supports simple string conversions via Image and Value.

Similar to C-style languages, Ada allows the internal representation of the enumeration to be specified:

for Cardsuit use
  (clubs => 1, diamonds => 2, hearts => 4, spades => 8);

Ada also allows the number of bits of the enumeration to be specified in a straightforward manner, unlike C-style languages which have inconsistent support often leading to subtle miscompilation errors:^[1]

for Cardsuit'Size use 4;  -- 4 bits

Additionally, one can use enumerations as indexes for arrays, like in Pascal, but there are attributes defined for enumerations:

   Shuffle : constant array(Cardsuit) of Cardsuit :=
     (Clubs => Cardsuit'Succ(Clubs), -- see attributes of enumerations 'First, 'Last, 'Succ, 'Pred
      Diamonds => Hearts, --an explicit value
      Hearts => Cardsuit'Last, --first enumeration value of type Cardsuit e.g., clubs
      Spades => Cardsuit'First --last enumeration value of type Cardsuit e.g., spades
      );

Like Modula-3, Ada treats Boolean and Character as special pre-defined (in package "Standard") enumerated types. Unlike Modula-3 one can also define own character types:

type Cards is ('7', '8', '9', 'X', 'J', 'Q', 'K', 'A');

Neither the original PL/I nor ANSI ANSI X3.53–1976 has enumerations, but the IBM Enterprise PL/I^[2] has ordinal types.

An ordinal variable cannot be used directly as a subscript or as a DO TO limit. However,

1. The type functions first and last, and the builtin functions binaryvalue, ordinalpred and ordinalsucc, allow it indirectly.
2. DO UPTHRU and DO DOWNTO support ordinals.

define ordinal foo (green,with,envy);
declare ix ordinal foo,
        bar(first(:foo:):last(:foo:)) fixed bin;
do i = first(:foo:) to last(:foo:);
   bar(i)=13;
   end;   
do ix=first(:foo:) upthru last(:foo:);
   i = binaryvalue(ix);
   bar(i) = bar(i) + 1;
   end;
do ix=first(:foo:) repeat ordinalsucc(ix) until (ix=first(:foo:)) /* stop on wrap around. */;
   i = binaryvalue(ix);
   display (bar(i) || ' at ' || ix);
   end;

The original K&R dialect of the programming language C had no enumerated types.^[3] In C, enumerations are created by explicit definitions (the enum keyword by itself does not cause allocation of storage) which use the enum keyword and are reminiscent of struct and union definitions:

typedef enum {
    CLUBS,
    DIAMONDS,
    HEARTS,
    SPADES,
} CardSuit;

typedef struct {
    CardSuit suit;
    short value;
} Card;

Card hand[13];
CardSuit trump;

C exposes the 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 specification, 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 they are stored in a variable of that type.

C also allows the programmer to choose the values of the enumeration constants explicitly, even without type. The following could be used to define a type that allows mathematical sets of suits to be represented as an enum CardSuit via bitwise logic operations, by representing each suit as a power of two:

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

Since C23, the underlying type of an enumeration can be specified by the programmer, with the same syntax as C++.^[4] This allows programmers to make optimized enums by choosing a more suitable underlying type.

enum CardSuit : char {
    CLUBS = 1,
    DIAMONDS = 2,
    HEARTS = 4,
    SPADES = 8,
};

Enums in C are not scoped or qualified, because C lacks namespacing features. Prior to the introduction of the constexpr keyword in C23, enums were often used to declare compile-time, type-safe constants without use of the C preprocessor:

enum {
    WINDOW_WIDTH = 600,
    WINDOW_HEIGHT = 400,
};

Enumerated types in the C# programming language preserve most of the "small integer" semantics of C's enums. In C#, all enums are classes which extend System.Enum.^[5] Some arithmetic operations are not defined for enums, but an enum value can be explicitly converted to an integer (and vice-versa), and an enum variable can have values that were not declared by the enum definition. For example, in the below code:

enum CardSuit
{
    Clubs,
    Diamonds,
    Spades,
    Hearts,
}

the expressions CardSuit.Diamonds + 1 and CardSuit.Hearts - CardSuit.Clubs are allowed directly (as it may make sense to step through the sequence of values or ask how many steps there are between two values), but CardSuit.Hearts * CardSuit.Spades is deemed to make less sense and is only allowed if the values are first explicitly converted to integers.

C# also provides the C-like feature of being able to define specific integer values for enumerations. Through this, it is possible to perform binary operations on enumerations, thus treating enumeration values as sets of flags. These flags can be tested using binary operations or with the enum type's builtin HasFlag() method.^[6]

The enumeration definition defines names for the selected integer values and is syntactic sugar, as it is possible to assign to an enum variable other integer values that are not in the scope of the enum definition.^[7][8][9]

C++ has enumeration types that are directly inherited from C's and work mostly like these, except that an enumeration is a real type in C++, giving added compile-time checking. As with structs, the C++ enum keyword is combined with a typedef, so instead of referring to the type as enum MyEnum, one can simply refer to it as MyEnum. This can be simulated in C using a typedef: typedef enum { VALUE_1, VALUE_2 } MyEnum;

C++11 also provides a second kind of enumeration, called a scoped enumeration. These are type-safe: the enumerators are not implicitly converted to an integer type. Among other things, this allows I/O streaming to be defined for the enumeration type. Another feature of scoped enumerations is that the enumerators must be qualified by the enum name, so usage requires prefixing with the name of the enumeration (e.g., Color::RED for the first enumerator in the example below), unless a using enum declaration (introduced in C++20) has been used to bring the enumerators into the current scope. A scoped enumeration is specified by the keywords enum class (or enum struct, they are identical).^[10] For example:

// C-style unscoped enum
enum CardSuit {
    CLUBS,
    DIAMONDS,
    SPADES,
    HEARTS,
};

// C++11-style scoped enum
enum class Color {
    RED,
    GREEN,
    BLUE,
};

int main(int argc, char* argv[]) {
    // Scoped enum
    Color color = Color::RED;

    // Unscoped C-style enum
    CardSuit card1 = CLUBS;
    CardSuit card2 = CardSuit::SPADES; // Can explicitly be scoped

    // Implicit integer conversion
    int suitValue = card1; // implicitly converts to int
    // int colorValue = color; // fails, no implicit conversion
    int colorValue = static_cast<int>(color); // explicit casts required
}

The underlying type of an enumeration is an implementation-defined integral type that is large enough to hold all enumerated values; it does not have to be the smallest possible type. The underlying type can be specified directly.

// Must fit in size and memory layout of the type 'long'
enum class Color : long {
    RED, 
    GREEN, 
    BLUE,
};

C++11 also allows forward declarations in which the enum values are not defined at the same time at the enum type itself. This is only possible if the underlying type is known before knowing of the enumerators. If an underlying type of a scoped enum is not defined, it defaults to int. If later the enumerators do not fit within this type, an error will arise.

// No explicit underlying type for enum class, so int
enum class Color;
// Explicit underlying type
enum class Status : unsigned char;
// Unscoped so underlying type is required
enum Legacy : int;

// Unscoped with no underlying type; error
// enum Broken;

// Forward declarations
void paint(Color c);
Status* getStatus();

// Later definitions
enum class Color {
    RED,
    GREEN,
    BLUE,
};

enum class Status : unsigned char {
    OK,
    ERROR,
};

enum Legacy : int {
    A,
    B,
};

void paint(Color c) { /* ... */ }

Go uses the iota identifier to create enumerated constants:^[11][12]

type ByteSize int

const (
    _           = iota // ignore first value by assigning to blank identifier; 0
    KB ByteSize = 1 << (10 * iota) // 1 << (10 * 1) == 1 << 10 == 1024; in binary 10000000000
    MB // 1 << (10 * 2) == 1048576;                                     in binary 100000000000000000000
    GB // 1 << (10 * 3) == 1073741824;                                  in binary 1000000000000000000000000000000
)

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

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

CardSuit trump;

The Java type system, however, does not allow intermixing of enum and integer values. All enum types implicitly extend the java.lang.Enum abstract class, so an enum cannot extend anything else, although it may implement any number of interfaces. The class java.lang.Enum<E> is constrained as Enum<E extends Enum<E>>, so enums can be self-referential. An enum type cannot be instantiated explicitly.^[13]

Internally, an enum type becomes a special compiler-generated class rather than an arithmetic type, and enum values behave as global pre-generated instances of that class. Each enum value contains an integer called an ordinal, corresponding to the order in which they are declared in the source code, starting from 0. Enums implement java.lang.Comparable and can be sorted with this ordinal. This internal value cannot be overridden, but it may be read with the ordinal() method (and the list of values through values()). To set an explicit order for the enum's members without rearranging them, one can implement overloaded constructors that assign an explicit value that acts as an order number. Since Enum.compareTo() is final, it cannot be overridden. Instead, a getter can be defined that returns this other number, which other programmers must explicitly use instead of the built-in comparison method. It is discouraged to treat enums as integers and vice versa.^[14]

The Java standard library provides utility classes to use with enumerations. The java.util.EnumSet class implements a java.util.Set<E> of enum values; it is implemented as a bit array, which makes it very compact and as efficient as explicit bit manipulation, but safer. The java.util.EnumMap class implements a java.util.Map<K, V> where the enum's values are keys. It is implemented as an array, with the ordinal of the enum serving as the index.

Unlike C++, Java enums are first-class citizens like any other class and can have methods, constructors, and fields. Enum members may even override select methods, allowing members to be given specific method implementations. Abstract methods must be overridden by all members.

public enum Planet {
    // Each member can call its own constructor (here, mass and radius)
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6) {
        // Members may override methods
        @Override
        String touchdown() {
            return "Home sweet home!";
        }
        // Abstract methods declared in an enum must be implemented by all members, however
    },
    MARS(6.421e+23, 3.3972e6),
    JUPITER(1.9e+27, 7.1492e7),
    SATURN(5.688e+26, 6.0268e7),
    URANUS(8.686e+25, 2.5559e7),
    NEPTUNE(1.024e+26, 2.4746e7);

    // Enums may have static fields
    public static final double G = 6.67300E-11;

    // and fields specific to each member
    public final double mass;
    public final double radius;

    // Constructors must not be public or protected
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double surfaceGravity() {
        return Planet.G * this.mass / (this.radius * this.radius);
    }

    public double surfaceWeight(double otherMass) {
        return otherMass * this.surfaceGravity();
    }
    
    public String touchdown() {
        return "Woosh!";
    } 

    // Entry methods are even allowed
    public static void main(String[] args) {
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight / EARTH.surfaceGravity();
        for (Planet p : Planet.values()) {
            System.out.printf(
                "Your weight on %s is %.6f. %s%n",
                p, p.surfaceWeight(mass), p.touchdown()
            );
        }
    }
}

Dynamically typed languages in the syntactic tradition of C (e.g., Perl or JavaScript) do not, in general, provide enumerations. But in Perl programming the same result can be obtained with the shorthand strings list and hashes (possibly slices):

my @enum = qw(Clubs Diamonds Hearts Spades);
my( %set1, %set2 );
@set1{@enum} = ();          # all cleared
@set2{@enum} = (1) x @enum; # all set to 1
$set1{Clubs} ...            # false
$set2{Diamonds} ...         # true

Raku (formerly known as Perl 6) supports enumerations. There are multiple ways to declare enumerations in Raku, all creating a back-end Map.

enum Cat <sphynx siamese bengal shorthair other>; # Using "quote-words"

enum Cat ('sphynx', 'siamese', 'bengal', 'shorthair', 'other'); # Using a list

enum Cat (sphynx => 0, siamese => 1, bengal => 2, shorthair => 3, other => 4); # Using Pair constructors

enum Cat (:sphynx(0), :siamese(1), :bengal(2), shorthair(3), :other(4)); # Another way of using Pairs, you can also use `:0sphynx`

Enums were added in PHP version 8.1.

enum CardSuit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;
}

Enumerators may be backed by string or integer values to aid serialization:

enum CardSuit: string
{
    case Hearts = 'H';
    case Diamonds = 'D';
    case Clubs = 'C';
    case Spades = 'S';
}

The Enum's interface exposes a method that gives a collection of its enumerators and their names. String/integer-backed Enums also expose the backing value and methods to (attempt) deserialization. Users may add further methods.

Though Rust uses the enum keyword like C, its enums are tagged unions, of which enums can be considered a degenerate form. Rust's enums are therefore much more flexible and its members can describe different data.

enum Message {
    Quit,
    Move { x: i32, y: i32 }, // struct
    Write(String), // single-element tuple
    ChangeColor(i32, i32, i32), // three-element tuple
}

Like C, Rust also supports specifying the values of each variant,

pub enum Weekday {
    Sunday = 1,
    Monday = 2,
    Tuesday = 4,
    Wednesday = 8,
    Thursday = 16,
    Friday = 32,
    Saturday = 64,
}

In Swift, enumerations do not need to provide a value for each member. If a value (termed a raw value) is explicitly provided for each enumeration case, the value can be a string, a character, or any integer or floating-point.

Alternatively, enumeration cases can specify associated values of any type to be stored along with each different case value, much as unions or variants do in other languages. One can define a common set of related cases as part of one enumeration, each of which has a different set of values of appropriate types associated with it.

In Swift, enumerations are a first-class type. They adopt many features traditionally supported only by classes, such as computed properties to provide additional information about the enumeration's current value, and instance methods to provide functionality related to the values the enumeration represents. Enumerations can also define initializers to provide an initial case value and can be extended to expand their functionality beyond their original implementation; and can conform to protocols to provide standard functionality.

enum CardSuit {
    case clubs
    case diamonds
    case hearts
    case spades
}

Unlike C and Objective-C, Swift enumeration cases are not assigned a default integer value when they are created. In the CardSuit example above, clubs, diamonds, hearts, and spades do not implicitly equal 0, 1, 2 and 3. Instead, the different enumeration cases are fully-fledged values in their own right, with an explicitly defined type of CardSuit.

Multiple cases can appear on a single line, separated by commas:

enum CardSuit {
    case clubs, diamonds, hearts, spades
}

When working with enumerations that store integer or string raw values, one doesn't need to explicitly assign a raw value for each case because Swift will automatically assign the values.

For instance, when integers are used for raw values, the implicit value for each case is one more than the previous case. If the first case doesn't have a value set, its value is 0. For the CardSuit example, suits can be numbered starting from 1 by writing:

enum CardSuit {
    case clubs = 1, diamonds, hearts, spades
}

TypeScript adds an enum data type to JavaScript.

enum CardSuit {
    Clubs, 
    Diamonds, 
    Hearts, 
    Spades
};

let c: CardSuit = CardSuit.Diamonds;

By default, enums number members starting at 0; this can be overridden by setting the value of the first member:

enum CardSuit {
    Clubs = 1, 
    Diamonds, 
    Hearts, 
    Spades
};

let c: CardSuit = CardSuit.Diamonds;

Each number may also be set:

enum CardSuit {
    Clubs = 1, 
    Diamonds = 2, 
    Hearts = 4, 
    Spades = 8
};

let c: CardSuit = CardSuit.Diamonds;

TypeScript supports mapping the numeric value to its name. For example, this finds the name of the value 2:

enum CardSuit {
    Clubs = 1, 
    Diamonds, 
    Hearts, 
    Spades
};

let suitName: string = CardSuit[2];

alert(suitName); // Diamonds

An enum module was added to the Python standard library in version 3.4. It introduces the class Enum which can be extended for defining enumerated types.

from enum import Enum

class CardSuit(Enum):
    CLUBS: int = 1
    DIAMONDS: int = 2
    HEARTS: int = 3
    SPADES: int = 4

There is also a functional API for creating enumerations with automatically generated indices (starting with 1):

Cards: Enum = Enum("Cards", "CLUBS DIAMONDS HEARTS SPADES")

Python enumerations do not enforce semantic correctness (a meaningless comparison to an incompatible enumeration always returns False rather than raising a TypeError):

Color: Enum = Enum("Color", "RED GREEN BLUE")
Shape: Enum = Enum("Shape", ["CIRCLE", "TRIANGLE", "SQUARE", "HEXAGON"])

def has_vertices(shape: Enum) -> bool:
    return shape != Shape.CIRCLE

if __name__ == "__main__":
    has_vertices(Color.GREEN)
    # outputs "True"

Dart has a support for the most basic form of enums, with a familiar syntax:

enum CardSuit {
  Clubs,
  Diamonds,
  Hearts,
  Spades
}

void main() {
  CardSuit card = CardSuit.Clubs;

  // Dart uses the "switch" operator to match the value of an enum with the desired output.
  switch (card) {
    case CardSuit.Clubs: {
      print("Clubs");
    }
    break;

    case CardSuit.Diamonds: {
      print("Diamonds");
    }
    break;

    case CardSuit.Hearts: {
      print("Hearts");
    }
    break;

    case CardSuit.Spades: {
      print("Spades");
    }
    break;

    default: {
      print("Unknown");
    }
    break;
  }
}

Note that before Dart 3,^[15] the switch operator did not guarantee the completeness of the cases. So, if you omit one case, the compiler will not raise an error.

In COBOL, a condition-variable is a normal variable with subordinate level-88 fields, known as condition-names. Each condition-name must have a VALUE clause. The VALUE clause for a condition clause may specify either a single value or a list of values.

Fortran 2003 introduced enumerators for interoperability with C; hence, the semantics is similar to C and, as in C, the enum values are just integers and no further type check is done. The C example from above can be written in Fortran as

enum, bind( C )
  enumerator :: CLUBS = 1, DIAMONDS = 2, HEARTS = 4, SPADES = 8
end enum

Fortran 2023 introduced a true enumeration type. Values are ordered sequentially as specified. Intrinsic functions int and huge support enumerations. The functions next and previous are also available.

enumeration type :: days_of_week
  enumerator :: monday, tuesday, wednesday, thursday, friday
  enumerator :: saturday, sunday
end enumeration type

type (days_of_week) :: dow
:
if (dow == wednesday) then
  print *, 'hump day'
end if
:
select case (dow)
  case (monday:friday)
    print *, 'weekday'
  case (saturday, sunday)
    print *, 'weekend'
end select

Common Lisp uses the member type specifier:

(deftype cardsuit ()
  '(member club diamond heart spade))

This states that object is of type cardsuit if it is #'eql to club, diamond, heart, or spade. The member type specifier is not valid as a Common Lisp Object System (CLOS) parameter specializer, however. Instead, (eql atom), which is the equivalent to (member atom) may be used (that is, only one member of the set may be specified with an eql type specifier, although it may be used as a CLOS parameter specializer). In other words, to define methods to cover an enumerated type, a method must be defined for each specific element of that type.

Additionally,

(deftype finite-element-set-type (&rest elements)
   `(member ,@elements))

may be used to define arbitrary enumerated types at runtime. For instance,

(finite-element-set-type club diamond heart spade)

would refer to a type equivalent to the prior definition of cardsuit, as of course would simply have been using

(member club diamond heart spade)

but may be less confusing with the function #'member for stylistic reasons.