{
  "id": "enwiki-001375672046",
  "slug": "enumerated-type",
  "title": "Enumerated type",
  "qid": "",
  "lead": "In computer programming, an enumerated type is a data type consisting of a set of named values called elements, members, enumeral, or enumerators of the type. The enumerator names are usually identifiers that behave as constants in the language. An enumerated type can be seen as a degenerate tagged union of unit type. A variable that has been declared as having an enumerated type can be assigned any of the enumerators as a value. In other words, an enumerated type defines a set of discrete, mutually exclusive constants that are not generally written to a concrete representation in the computer's memory; compilers and interpreters can represent them arbitrarily without specification from the programmer.",
  "body": "In computer programming, an enumerated type is a data type consisting of a set of named values called elements, members, enumeral, or enumerators of the type. The enumerator names are usually identifiers that behave as constants in the language. An enumerated type can be seen as a degenerate tagged union of unit type. A variable that has been declared as having an enumerated type can be assigned any of the enumerators as a value. In other words, an enumerated type defines a set of discrete, mutually exclusive constants that are not generally written to a concrete representation in the computer's memory; compilers and interpreters can represent them arbitrarily without specification from the programmer. ==Rationale== Some early programming languages did not originally have enumerated types. If a programmer wanted a variable, for example , to have a value of RED , the constant RED would be declared and assigned some arbitrary value, usually an integer constant. The constant RED would then be assigned to . Other techniques assigned arbitrary values to strings containing the names of the enumerators. These arbitrary values were sometimes referred to as magic numbers since there often was no explanation as to how the numbers were obtained or whether their actual values were significant. These magic numbers could make the source code harder for others to understand and maintain. Enumerated types, on the other hand, make the code more self-documenting. Depending on the language, the compiler could automatically assign default values to the enumerators, thereby hiding unnecessary detail from the programmer. These values may not even be visible to the programmer (see information hiding). Enumerated types can also prevent a programmer from writing illogical code such as performing mathematical operations on the values of the enumerators. If the value of a variable that was assigned an enumerator were to be printed, some programming languages could also print the name of the enumerator rather than its underlying numerical value. A further advantage is that enumerated types can allow compilers to enforce semantic correctness: myColor = TRIANGLE can be forbidden, while myColor = RED should be accepted, even if and are both internally represented with the value . Conceptually, an enumerated type is similar to a list of nominals (numeric codes), since each possible value of the type is assigned a distinctive natural number. A given enumerated type is thus a concrete implementation of this notion. When order is meaningful and/or used for comparison, then an enumerated type becomes an ordinal type. 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: 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'); 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; 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++. 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, }; ====C#==== 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 . 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. 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. 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 , 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 : 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). For example: // C-style unscoped enum enum CardSuit { CLUBS, DIAMONDS, SPADES, HEARTS, }; // C++11-style scoped enum enum class Color { RED, GREEN, BLUE, }; // C++11-style scoped enum enum struct Direction { NORTH, SOUTH, EAST, WEST, }; int main(int argc, char* argv[]) { // Scoped enum Color color = Color::RED; // Enum struct/class Direction dir = Direction::NORTH; // 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 (c); // explicit casts required int dirValue = static_cast (d); } 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 . 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==== Go uses the iota identifier to create enumerated constants: type ByteSize int const ( _ = iota // ignore first value by assigning to blank identifier; 0 KB ByteSize = 1 ====Java==== 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 abstract class, so an enum cannot extend anything else, although it may implement any number of interfaces. The class java.lang.Enum is constrained as Enum > , so enums can be self-referential. An enum type cannot be instantiated explicitly. 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 and can be sorted with this ordinal. This internal value cannot be overridden, but it may be read with the 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 is , 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. The Java standard library provides utility classes to use with enumerations. The class implements a java.util.Set 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 class implements a java.util.Map 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() ); } } } 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 enum Cat ; # 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` 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. 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, } 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==== TypeScript adds an 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 ====Python==== 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==== 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, the switch operator did not guarantee the completeness of the cases. So, if you omit one case, the compiler will not raise an error. ====COBOL==== 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==== 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 ====Microsoft Visual Basic family==== ====Lisp==== 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. datatype cardsuit = Clubs | Diamonds | Hearts | Spades type card = { suit: cardsuit; value: int } val hand : card list val trump : cardsuit In these languages, the integer representation is completely hidden from the programmer, if the language employs it. However, Haskell has the Enum type class, which a type can derive or implement to get a mapping between the type and Int . Some databases support enumerated types directly. MySQL provides an enumerated type ENUM with allowable values specified as strings when a table is created. The values are stored as numeric indices with the empty string stored as 0, the first string value stored as 1, the second string value stored as 2, etc. Values can be stored and retrieved as numeric indexes or string values. CREATE TABLE shirts ( name VARCHAR(40), size ENUM('x-small', 'small', 'medium', 'large', 'x-large') ); { \"$schema\": \"https://json-schema.org/draft/2020-12/schema\", \"type\": \"object\", \"properties\": { \"cardsuit\": { \"type\": \"string\", \"enum\": [\"Clubs\", \"Diamonds\", \"Hearts\", \"Spades\"] } }, \"required\": [\"cardsuit\"] }",
  "categories": [
    "10639558",
    "10639794",
    "107076669",
    "129826521",
    "20282650",
    "23118434",
    "23603337",
    "24623845",
    "25257581",
    "29176688",
    "63697623"
  ],
  "license": "CC BY-SA 4.0",
  "source_uri": "https://en.wikipedia.org/w/index.php?oldid=1375672046",
  "content_hash": "",
  "created_at": null,
  "updated_at": 1789794856.0,
  "claims": [],
  "contradictions": [],
  "confidence": 0.6,
  "csl": {
    "id": "enwiki-001375672046",
    "type": "webpage",
    "title": "Enumerated type",
    "author": [
      {
        "family": "Anticloud FZ LLE",
        "literal": "Anticloud FZ LLE"
      }
    ],
    "container-title": "encyclopegia.org",
    "publisher": "Anticloud FZ LLE",
    "publisher-place": "Dubai, United Arab Emirates",
    "URL": "https://encyclopegia.org/a/enumerated-type",
    "issued": {
      "date-parts": [
        [
          2026,
          11,
          17
        ]
      ]
    },
    "accessed": {
      "date-parts": [
        [
          2026,
          11,
          17
        ]
      ]
    },
    "license": "CC BY-SA 4.0",
    "DOI": "eo1:enwiki-001375672046",
    "isBasedOn": "https://en.wikipedia.org/w/index.php?oldid=1375672046",
    "note": "Immutable snapshot enwiki-001375672046"
  }
}