Enumerated type
Named set of data type values
- 44 min read
- 8 chapters
Related on Lably
Through Computer programming, Data type and Value (computer science)
Description
For example, the four suits in a deck of playing cards could be represented in an enum called CardSuit, containing four members named CLUBS, DIAMONDS, SPADES, and HEARTS. If a variable v is declared having CardSuit as its data type, one must assign one of those four values to it.
Although the enumerators are usually distinct, some languages may allow the same enumerator to be listed twice in the type's declaration. The names of enumerators are arbitrary and are up to the programmer; an enum named Color could contain the enumerators RED, GREEN, ZEBRA, MISSING, and BACON. In some languages, the declaration of an enumerated type also intentionally defines the total order of its members (e.g., HIGH, MEDIUM and LOW priorities); in others, the enumerators are unordered by default (e.g., ENGLISH, FRENCH, GERMAN and SPANISH supported languages); in others still, an implicit ordering arises from how the compiler chooses to internally represent the enumerators.
Some enumerator types may be built into the language. For example, the Boolean type is often a pre-defined enumeration of the two values false and true. A unit type consisting of a single value may also be defined to represent null. Many languages allow users to define new enumerated types.
Values and variables of an enumerated type are usually implemented with some integer type as the underlying representation. Some languages, especially system programming languages, allow the user to specify the bit combination to be used for each enumerator, which can be useful to efficiently represent sets of enumerators as fixed-length bit strings. In type theory, enumerated types are often regarded as tagged unions of unit types. Since such types are of the form , they may also be written as natural numbers.
Sign in to keep reading
7 more chapters are free with a Lably account.
Rationale
Some early programming languages did not originally have enumerated types. If a programmer wanted a variable, for example myColor, 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 myColor. 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 TRIANGLE and RED are both internally represented with the value 1.
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.
Conventions
Programming languages tend to have their own, oftentimes multiple, programming styles and naming conventions. The variable assigned to an enumeration is usually a noun in singular form, and frequently follows either a PascalCase or uppercase convention, while lowercase and others are seen less frequently.
Syntax by language
ALGOL 60 based languages
While ALGOL 60 itself has no enumeration type, several languages descended from it do. In particular, Pascal had a strong influence on the design of Ada.
Pascal
In Pascal, an enumerated type can be implicitly declared by listing the values in a parenthesised list:
<span id="mwcg"></span><span class="k" id="mwcw">var</span> <span class="w" id="mwdA"> </span><span class="n" id="mwdQ">suit</span><span class="o" id="mwdg">:</span><span class="w" id="mwdw"> </span><span class="p" id="mweA">(</span><span class="n" id="mweQ">clubs</span><span class="o" id="mweg">,</span><span class="w" id="mwew"> </span><span class="n" id="mwfA">diamonds</span><span class="o" id="mwfQ">,</span><span class="w" id="mwfg"> </span><span class="n" id="mwfw">hearts</span><span class="o" id="mwgA">,</span><span class="w" id="mwgQ"> </span><span class="n" id="mwgg">spades</span><span class="p" id="mwgw">)</span><span class="o" id="mwhA">;</span>
The declaration will often appear in a type synonym declaration, such that it can be used for multiple variables:
<span id="mwiA"></span><span class="w" id="mwiQ"> </span><span class="k" id="mwig">type</span> <span class="w" id="mwiw"> </span><span class="n" id="mwjA">cardsuit</span><span class="w" id="mwjQ"> </span><span class="o" id="mwjg">=</span><span class="w" id="mwjw"> </span><span class="p" id="mwkA">(</span><span class="n" id="mwkQ">clubs</span><span class="o" id="mwkg">,</span><span class="w" id="mwkw"> </span><span class="n" id="mwlA">diamonds</span><span class="o" id="mwlQ">,</span><span class="w" id="mwlg"> </span><span class="n" id="mwlw">hearts</span><span class="o" id="mwmA">,</span><span class="w" id="mwmQ"> </span><span class="n" id="mwmg">spades</span><span class="p" id="mwmw">)</span><span class="o" id="mwnA">;</span> <span class="w" id="mwnQ"> </span><span class="n" id="mwng">card</span><span class="w" id="mwnw"> </span><span class="o" id="mwoA">=</span><span class="w" id="mwoQ"> </span><span class="k" id="mwog">record</span> <span class="w" id="mwow"> </span><span class="n" id="mwpA">suit</span><span class="o" id="mwpQ">:</span><span class="w" id="mwpg"> </span><span class="n" id="mwpw">cardsuit</span><span class="o" id="mwqA">;</span> <span class="w" id="mwqQ"> </span><span class="n" id="mwqg">value</span><span class="o" id="mwqw">:</span><span class="w" id="mwrA"> </span><span class="mi" id="mwrQ">1</span><span class="w" id="mwrg"> </span><span class="o" id="mwrw">..</span><span class="w" id="mwsA"> </span><span class="mi" id="mwsQ">13</span><span class="o" id="mwsg">;</span> <span class="w" id="mwsw"> </span><span class="k" id="mwtA">end</span><span class="o" id="mwtQ">;</span> <span class="w" id="mwtg"> </span><span class="k" id="mwtw">var</span> <span class="w" id="mwuA"> </span><span class="n" id="mwuQ">hand</span><span class="o" id="mwug">:</span><span class="w" id="mwuw"> </span><span class="k" id="mwvA">array</span><span class="w" id="mwvQ"> </span><span class="p" id="mwvg">[</span><span class="w" id="mwvw"> </span><span class="mi" id="mwwA">1</span><span class="w" id="mwwQ"> </span><span class="o" id="mwwg">..</span><span class="w" id="mwww"> </span><span class="mi" id="mwxA">13</span><span class="w" id="mwxQ"> </span><span class="p" id="mwxg">]</span><span class="w" id="mwxw"> </span><span class="k" id="mwyA">of</span><span class="w" id="mwyQ"> </span><span class="n" id="mwyg">card</span><span class="o" id="mwyw">;</span> <span class="w" id="mwzA"> </span><span class="n" id="mwzQ">trump</span><span class="o" id="mwzg">:</span><span class="w" id="mwzw"> </span><span class="n" id="mw0A">cardsuit</span><span class="o" id="mw0Q">;</span>
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:
<span id="mw4A"></span><span class="w" id="mw4Q"> </span><span class="k" id="mw4g">var</span> <span class="w" id="mw4w"> </span><span class="n" id="mw5A">suitcount</span><span class="o" id="mw5Q">:</span><span class="w" id="mw5g"> </span><span class="k" id="mw5w">array</span><span class="w" id="mw6A"> </span><span class="p" id="mw6Q">[</span><span class="n" id="mw6g">cardsuit</span><span class="p" id="mw6w">]</span><span class="w" id="mw7A"> </span><span class="k" id="mw7Q">of</span><span class="w" id="mw7g"> </span><span class="kt" id="mw7w">integer</span><span class="o" id="mw8A">;</span>
Ada
In Ada, the definition of enumerated types is similar to Pascal, replacing the use of "=" with "is":
<span id="mw9g"></span><span class="kd" id="mw9w">type</span> <span class="kt" id="mw-A">Cardsuit</span> <span class="kr" id="mw-Q">is</span> <span class="p" id="mw-g">(</span><span class="nv" id="mw-w">clubs</span><span class="p" id="mw_A">,</span> <span class="nv" id="mw_Q">diamonds</span><span class="p" id="mw_g">,</span> <span class="nv" id="mw_w">hearts</span><span class="p" id="mwAQA">,</span> <span class="nv" id="mwAQE">spades</span><span class="p" id="mwAQI">);</span>
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:
<span id="mwAQ0"></span><span class="kr" id="mwAQ4">for</span> <span class="n" id="mwAQ8">Cardsuit</span> <span class="kn" id="mwARA">use</span> <span class="p" id="mwARE">(</span><span class="n" id="mwARI">clubs</span> <span class="p" id="mwARM">=></span> <span class="mi" id="mwARQ">1</span><span class="p" id="mwARU">,</span> <span class="n" id="mwARY">diamonds</span> <span class="p" id="mwARc">=></span> <span class="mi" id="mwARg">2</span><span class="p" id="mwARk">,</span> <span class="n" id="mwARo">hearts</span> <span class="p" id="mwARs">=></span> <span class="mi" id="mwARw">4</span><span class="p" id="mwAR0">,</span> <span class="n" id="mwAR4">spades</span> <span class="p" id="mwAR8">=></span> <span class="mi" id="mwASA">8</span><span class="p" id="mwASE">);</span>
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:
<span id="mwASo"></span><span class="kr" id="mwASs">for</span> <span class="n" id="mwASw">Cardsuit</span><span class="p" id="mwAS0">'</span><span class="na" id="mwAS4">Size</span> <span class="kn" id="mwAS8">use</span> <span class="n" id="mwATA">4</span><span class="p" id="mwATE">;</span> <span class="c1" id="mwATI">-- 4 bits</span>
Additionally, one can use enumerations as indexes for arrays, like in Pascal, but there are attributes defined for enumerations:
<span id="mwATY"></span> <span class="no" id="mwATc">Shuffle</span> <span class="p" id="mwATg">:</span> <span class="kr" id="mwATk">constant</span> <span class="kr" id="mwATo">array</span><span class="p" id="mwATs">(</span><span class="n" id="mwATw">Cardsuit</span><span class="p" id="mwAT0">)</span> <span class="kr" id="mwAT4">of</span> <span class="n" id="mwAT8">Cardsuit</span> <span class="p" id="mwAUA">:=</span> <span class="p" id="mwAUE">(</span><span class="n" id="mwAUI">Clubs</span> <span class="p" id="mwAUM">=></span> <span class="n" id="mwAUQ">Cardsuit</span><span class="p" id="mwAUU">'</span><span class="na" id="mwAUY">Succ</span><span class="p" id="mwAUc">(</span><span class="n" id="mwAUg">Clubs</span><span class="p" id="mwAUk">),</span> <span class="c1" id="mwAUo">-- see attributes of enumerations 'First, 'Last, 'Succ, 'Pred</span> <span class="n" id="mwAUs">Diamonds</span> <span class="p" id="mwAUw">=></span> <span class="n" id="mwAU0">Hearts</span><span class="p" id="mwAU4">,</span> <span class="c1" id="mwAU8">--an explicit value</span> <span class="n" id="mwAVA">Hearts</span> <span class="p" id="mwAVE">=></span> <span class="n" id="mwAVI">Cardsuit</span><span class="p" id="mwAVM">'</span><span class="na" id="mwAVQ">Last</span><span class="p" id="mwAVU">,</span> <span class="c1" id="mwAVY">--first enumeration value of type Cardsuit e.g., clubs</span> <span class="n" id="mwAVc">Spades</span> <span class="p" id="mwAVg">=></span> <span class="n" id="mwAVk">Cardsuit</span><span class="p" id="mwAVo">'</span><span class="na" id="mwAVs">First</span> <span class="c1" id="mwAVw">--last enumeration value of type Cardsuit e.g., spades</span> <span class="p" id="mwAV0">);</span>
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:
<span id="mwAWU"></span><span class="kd" id="mwAWY">type</span> <span class="kt" id="mwAWc">Cards</span> <span class="kr" id="mwAWg">is</span> <span class="p" id="mwAWk">('</span><span class="na" id="mwAWo">7</span><span class="p" id="mwAWs">',</span> <span class="p" id="mwAWw">'</span><span class="na" id="mwAW0">8</span><span class="p" id="mwAW4">',</span> <span class="p" id="mwAW8">'</span><span class="na" id="mwAXA">9</span><span class="p" id="mwAXE">',</span> <span class="p" id="mwAXI">'</span><span class="na" id="mwAXM">X</span><span class="p" id="mwAXQ">',</span> <span class="p" id="mwAXU">'</span><span class="na" id="mwAXY">J</span><span class="p" id="mwAXc">',</span> <span class="p" id="mwAXg">'</span><span class="na" id="mwAXk">Q</span><span class="p" id="mwAXo">',</span> <span class="p" id="mwAXs">'</span><span class="na" id="mwAXw">K</span><span class="p" id="mwAX0">',</span> <span class="p" id="mwAX4">'</span><span class="na" id="mwAX8">A</span><span class="p" id="mwAYA">');</span>PL/I
Neither the original PL/I nor ANSI ANSI X3.53–1976 has enumerations, but the IBM Enterprise PL/I has ordinal types.
An ordinal variable cannot be used directly as a subscript or as a DO TO limit. However,
- The type functions first and last, and the builtin functions binaryvalue, ordinalpred and ordinalsucc, allow it indirectly.
- DO UPTHRU and DO DOWNTO support ordinals.
<span id="mwAZY"></span>define<span class="w" id="mwAZc"> </span>ordinal<span class="w" id="mwAZg"> </span>foo<span class="w" id="mwAZk"> </span><span class="o" id="mwAZo">(</span>green<span class="o" id="mwAZs">,</span>with<span class="o" id="mwAZw">,</span>envy<span class="o" id="mwAZ0">)</span><span class="err" id="mwAZ4">;</span> declare<span class="w" id="mwAZ8"> </span>ix<span class="w" id="mwAaA"> </span>ordinal<span class="w" id="mwAaE"> </span>foo<span class="o" id="mwAaI">,</span> <span class="w" id="mwAaM"> </span>bar<span class="o" id="mwAaQ">(</span>first<span class="o" id="mwAaU">(</span><span class="err" id="mwAaY">:</span><span class="nl" id="mwAac">foo</span><span class="o" id="mwAag">:)</span><span class="err" id="mwAak">:</span>last<span class="o" id="mwAao">(</span><span class="err" id="mwAas">:</span><span class="nl" id="mwAaw">foo</span><span class="o" id="mwAa0">:))</span><span class="w" id="mwAa4"> </span>fixed<span class="w" id="mwAa8"> </span>bin<span class="err" id="mwAbA">;</span> <span class="kr" id="mwAbE">do</span><span class="w" id="mwAbI"> </span>i<span class="w" id="mwAbM"> </span><span class="o" id="mwAbQ">=</span><span class="w" id="mwAbU"> </span>first<span class="o" id="mwAbY">(</span><span class="err" id="mwAbc">:</span><span class="nl" id="mwAbg">foo</span><span class="o" id="mwAbk">:)</span><span class="w" id="mwAbo"> </span><span class="kr" id="mwAbs">to</span><span class="w" id="mwAbw"> </span>last<span class="o" id="mwAb0">(</span><span class="err" id="mwAb4">:</span><span class="nl" id="mwAb8">foo</span><span class="o" id="mwAcA">:)</span><span class="err" id="mwAcE">;</span> <span class="w" id="mwAcI"> </span>bar<span class="o" id="mwAcM">(</span>i<span class="o" id="mwAcQ">)=</span><span class="m" id="mwAcU">13</span><span class="err" id="mwAcY">;</span> <span class="w" id="mwAcc"> </span><span class="kr" id="mwAcg">end</span><span class="err" id="mwAck">;</span><span class="w" id="mwAco"> </span> <span class="kr" id="mwAcs">do</span><span class="w" id="mwAcw"> </span>ix<span class="o" id="mwAc0">=</span>first<span class="o" id="mwAc4">(</span><span class="err" id="mwAc8">:</span><span class="nl" id="mwAdA">foo</span><span class="o" id="mwAdE">:)</span><span class="w" id="mwAdI"> </span>upthru<span class="w" id="mwAdM"> </span>last<span class="o" id="mwAdQ">(</span><span class="err" id="mwAdU">:</span><span class="nl" id="mwAdY">foo</span><span class="o" id="mwAdc">:)</span><span class="err" id="mwAdg">;</span> <span class="w" id="mwAdk"> </span>i<span class="w" id="mwAdo"> </span><span class="o" id="mwAds">=</span><span class="w" id="mwAdw"> </span>binaryvalue<span class="o" id="mwAd0">(</span>ix<span class="o" id="mwAd4">)</span><span class="err" id="mwAd8">;</span> <span class="w" id="mwAeA"> </span>bar<span class="o" id="mwAeE">(</span>i<span class="o" id="mwAeI">)</span><span class="w" id="mwAeM"> </span><span class="o" id="mwAeQ">=</span><span class="w" id="mwAeU"> </span>bar<span class="o" id="mwAeY">(</span>i<span class="o" id="mwAec">)</span><span class="w" id="mwAeg"> </span><span class="o" id="mwAek">+</span><span class="w" id="mwAeo"> </span><span class="m" id="mwAes">1</span><span class="err" id="mwAew">;</span> <span class="w" id="mwAe0"> </span><span class="kr" id="mwAe4">end</span><span class="err" id="mwAe8">;</span> <span class="kr" id="mwAfA">do</span><span class="w" id="mwAfE"> </span>ix<span class="o" id="mwAfI">=</span>first<span class="o" id="mwAfM">(</span><span class="err" id="mwAfQ">:</span><span class="nl" id="mwAfU">foo</span><span class="o" id="mwAfY">:)</span><span class="w" id="mwAfc"> </span>repeat<span class="w" id="mwAfg"> </span>ordinalsucc<span class="o" id="mwAfk">(</span>ix<span class="o" id="mwAfo">)</span><span class="w" id="mwAfs"> </span><span class="kr" id="mwAfw">until</span><span class="w" id="mwAf0"> </span><span class="o" id="mwAf4">(</span>ix<span class="o" id="mwAf8">=</span>first<span class="o" id="mwAgA">(</span><span class="err" id="mwAgE">:</span><span class="nl" id="mwAgI">foo</span><span class="o" id="mwAgM">:))</span><span class="w" id="mwAgQ"> </span><span class="cm" id="mwAgU">/* stop on wrap around. */</span><span class="err" id="mwAgY">;</span> <span class="w" id="mwAgc"> </span>i<span class="w" id="mwAgg"> </span><span class="o" id="mwAgk">=</span><span class="w" id="mwAgo"> </span>binaryvalue<span class="o" id="mwAgs">(</span>ix<span class="o" id="mwAgw">)</span><span class="err" id="mwAg0">;</span> <span class="w" id="mwAg4"> </span>display<span class="w" id="mwAg8"> </span><span class="o" id="mwAhA">(</span>bar<span class="o" id="mwAhE">(</span>i<span class="o" id="mwAhI">)</span><span class="w" id="mwAhM"> </span><span class="o" id="mwAhQ">||</span><span class="w" id="mwAhU"> </span><span class="s" id="mwAhY">' at '</span><span class="w" id="mwAhc"> </span><span class="o" id="mwAhg">||</span><span class="w" id="mwAhk"> </span>ix<span class="o" id="mwAho">)</span><span class="err" id="mwAhs">;</span> <span class="w" id="mwAhw"> </span><span class="kr" id="mwAh0">end</span><span class="err" id="mwAh4">;</span>
C-family languages
C
The original K&R dialect of the programming language C had no enumerated types. 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:
<span id="mwAi4"></span><span class="k" id="mwAi8">typedef</span><span class="w" id="mwAjA"> </span><span class="k" id="mwAjE">enum</span><span class="w" id="mwAjI"> </span><span class="p" id="mwAjM">{</span> <span class="w" id="mwAjQ"> </span><span class="n" id="mwAjU">CLUBS</span><span class="p" id="mwAjY">,</span> <span class="w" id="mwAjc"> </span><span class="n" id="mwAjg">DIAMONDS</span><span class="p" id="mwAjk">,</span> <span class="w" id="mwAjo"> </span><span class="n" id="mwAjs">HEARTS</span><span class="p" id="mwAjw">,</span> <span class="w" id="mwAj0"> </span><span class="n" id="mwAj4">SPADES</span><span class="p" id="mwAj8">,</span> <span class="p" id="mwAkA">}</span><span class="w" id="mwAkE"> </span><span class="n" id="mwAkI">CardSuit</span><span class="p" id="mwAkM">;</span> <span class="k" id="mwAkQ">typedef</span><span class="w" id="mwAkU"> </span><span class="k" id="mwAkY">struct</span><span class="w" id="mwAkc"> </span><span class="p" id="mwAkg">{</span> <span class="w" id="mwAkk"> </span><span class="n" id="mwAko">CardSuit</span><span class="w" id="mwAks"> </span><span class="n" id="mwAkw">suit</span><span class="p" id="mwAk0">;</span> <span class="w" id="mwAk4"> </span><span class="kt" id="mwAk8">short</span><span class="w" id="mwAlA"> </span><span class="n" id="mwAlE">value</span><span class="p" id="mwAlI">;</span> <span class="p" id="mwAlM">}</span><span class="w" id="mwAlQ"> </span><span class="n" id="mwAlU">Card</span><span class="p" id="mwAlY">;</span> <span class="n" id="mwAlc">Card</span><span class="w" id="mwAlg"> </span><span class="n" id="mwAlk">hand</span><span class="p" id="mwAlo">[</span><span class="mi" id="mwAls">13</span><span class="p" id="mwAlw">];</span> <span class="n" id="mwAl0">CardSuit</span><span class="w" id="mwAl4"> </span><span class="n" id="mwAl8">trump</span><span class="p" id="mwAmA">;</span>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:
<span id="mwAm0"></span><span class="k" id="mwAm4">enum</span><span class="w" id="mwAm8"> </span><span class="n" id="mwAnA">CardSuit</span><span class="w" id="mwAnE"> </span><span class="p" id="mwAnI">{</span> <span class="w" id="mwAnM"> </span><span class="n" id="mwAnQ">CLUBS</span><span class="w" id="mwAnU"> </span><span class="o" id="mwAnY">=</span><span class="w" id="mwAnc"> </span><span class="mi" id="mwAng">1</span><span class="p" id="mwAnk">,</span> <span class="w" id="mwAno"> </span><span class="n" id="mwAns">DIAMONDS</span><span class="w" id="mwAnw"> </span><span class="o" id="mwAn0">=</span><span class="w" id="mwAn4"> </span><span class="mi" id="mwAn8">2</span><span class="p" id="mwAoA">,</span> <span class="w" id="mwAoE"> </span><span class="n" id="mwAoI">HEARTS</span><span class="w" id="mwAoM"> </span><span class="o" id="mwAoQ">=</span><span class="w" id="mwAoU"> </span><span class="mi" id="mwAoY">4</span><span class="p" id="mwAoc">,</span> <span class="w" id="mwAog"> </span><span class="n" id="mwAok">SPADES</span><span class="w" id="mwAoo"> </span><span class="o" id="mwAos">=</span><span class="w" id="mwAow"> </span><span class="mi" id="mwAo0">8</span><span class="p" id="mwAo4">,</span> <span class="p" id="mwAo8">};</span>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.
<span id="mwApg"></span><span class="k" id="mwApk">enum</span><span class="w" id="mwApo"> </span><span class="n" id="mwAps">CardSuit</span><span class="w" id="mwApw"> </span><span class="o" id="mwAp0">:</span><span class="w" id="mwAp4"> </span><span class="kt" id="mwAp8">char</span><span class="w" id="mwAqA"> </span><span class="p" id="mwAqE">{</span> <span class="w" id="mwAqI"> </span><span class="n" id="mwAqM">CLUBS</span><span class="w" id="mwAqQ"> </span><span class="o" id="mwAqU">=</span><span class="w" id="mwAqY"> </span><span class="mi" id="mwAqc">1</span><span class="p" id="mwAqg">,</span> <span class="w" id="mwAqk"> </span><span class="n" id="mwAqo">DIAMONDS</span><span class="w" id="mwAqs"> </span><span class="o" id="mwAqw">=</span><span class="w" id="mwAq0"> </span><span class="mi" id="mwAq4">2</span><span class="p" id="mwAq8">,</span> <span class="w" id="mwArA"> </span><span class="n" id="mwArE">HEARTS</span><span class="w" id="mwArI"> </span><span class="o" id="mwArM">=</span><span class="w" id="mwArQ"> </span><span class="mi" id="mwArU">4</span><span class="p" id="mwArY">,</span> <span class="w" id="mwArc"> </span><span class="n" id="mwArg">SPADES</span><span class="w" id="mwArk"> </span><span class="o" id="mwAro">=</span><span class="w" id="mwArs"> </span><span class="mi" id="mwArw">8</span><span class="p" id="mwAr0">,</span> <span class="p" id="mwAr4">};</span>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:
<span id="mwAsU"></span><span class="k" id="mwAsY">enum</span><span class="w" id="mwAsc"> </span><span class="p" id="mwAsg">{</span> <span class="w" id="mwAsk"> </span><span class="n" id="mwAso">WINDOW_WIDTH</span><span class="w" id="mwAss"> </span><span class="o" id="mwAsw">=</span><span class="w" id="mwAs0"> </span><span class="mi" id="mwAs4">600</span><span class="p" id="mwAs8">,</span> <span class="w" id="mwAtA"> </span><span class="n" id="mwAtE">WINDOW_HEIGHT</span><span class="w" id="mwAtI"> </span><span class="o" id="mwAtM">=</span><span class="w" id="mwAtQ"> </span><span class="mi" id="mwAtU">400</span><span class="p" id="mwAtY">,</span> <span class="p" id="mwAtc">};</span>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:
<span id="mwAuI"></span><span class="k" id="mwAuM">enum</span><span class="w" id="mwAuQ"> </span><span class="n" id="mwAuU">CardSuit</span> <span class="p" id="mwAuY">{</span> <span class="w" id="mwAuc"> </span><span class="n" id="mwAug">Clubs</span><span class="p" id="mwAuk">,</span> <span class="w" id="mwAuo"> </span><span class="n" id="mwAus">Diamonds</span><span class="p" id="mwAuw">,</span> <span class="w" id="mwAu0"> </span><span class="n" id="mwAu4">Spades</span><span class="p" id="mwAu8">,</span> <span class="w" id="mwAvA"> </span><span class="n" id="mwAvE">Hearts</span><span class="p" id="mwAvI">,</span> <span class="p" id="mwAvM">}</span>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++
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). For example:
<span id="mwA0E"></span><span class="c1" id="mwA0I">// C-style unscoped enum</span> <span class="k" id="mwA0M">enum</span><span class="w" id="mwA0Q"> </span><span class="nc" id="mwA0U">CardSuit</span><span class="w" id="mwA0Y"> </span><span class="p" id="mwA0c">{</span> <span class="w" id="mwA0g"> </span><span class="n" id="mwA0k">CLUBS</span><span class="p" id="mwA0o">,</span> <span class="w" id="mwA0s"> </span><span class="n" id="mwA0w">DIAMONDS</span><span class="p" id="mwA00">,</span> <span class="w" id="mwA04"> </span><span class="n" id="mwA08">SPADES</span><span class="p" id="mwA1A">,</span> <span class="w" id="mwA1E"> </span><span class="n" id="mwA1I">HEARTS</span><span class="p" id="mwA1M">,</span> <span class="p" id="mwA1Q">};</span> <span class="c1" id="mwA1U">// C++11-style scoped enum</span> <span class="k" id="mwA1Y">enum</span><span class="w" id="mwA1c"> </span><span class="k" id="mwA1g">class</span><span class="w" id="mwA1k"> </span><span class="nc" id="mwA1o">Color</span><span class="w" id="mwA1s"> </span><span class="p" id="mwA1w">{</span> <span class="w" id="mwA10"> </span><span class="n" id="mwA14">RED</span><span class="p" id="mwA18">,</span> <span class="w" id="mwA2A"> </span><span class="n" id="mwA2E">GREEN</span><span class="p" id="mwA2I">,</span> <span class="w" id="mwA2M"> </span><span class="n" id="mwA2Q">BLUE</span><span class="p" id="mwA2U">,</span> <span class="p" id="mwA2Y">};</span> <span class="c1" id="mwA2c">// C++11-style scoped enum</span> <span class="k" id="mwA2g">enum</span><span class="w" id="mwA2k"> </span><span class="k" id="mwA2o">struct</span><span class="w" id="mwA2s"> </span><span class="nc" id="mwA2w">Direction</span><span class="w" id="mwA20"> </span><span class="p" id="mwA24">{</span> <span class="w" id="mwA28"> </span><span class="n" id="mwA3A">NORTH</span><span class="p" id="mwA3E">,</span> <span class="w" id="mwA3I"> </span><span class="n" id="mwA3M">SOUTH</span><span class="p" id="mwA3Q">,</span> <span class="w" id="mwA3U"> </span><span class="n" id="mwA3Y">EAST</span><span class="p" id="mwA3c">,</span> <span class="w" id="mwA3g"> </span><span class="n" id="mwA3k">WEST</span><span class="p" id="mwA3o">,</span> <span class="p" id="mwA3s">};</span> <span class="kt" id="mwA3w">int</span><span class="w" id="mwA30"> </span><span class="nf" id="mwA34">main</span><span class="p" id="mwA38">(</span><span class="kt" id="mwA4A">int</span><span class="w" id="mwA4E"> </span><span class="n" id="mwA4I">argc</span><span class="p" id="mwA4M">,</span><span class="w" id="mwA4Q"> </span><span class="kt" id="mwA4U">char</span><span class="o" id="mwA4Y">*</span><span class="w" id="mwA4c"> </span><span class="n" id="mwA4g">argv</span><span class="p" id="mwA4k">[])</span><span class="w" id="mwA4o"> </span><span class="p" id="mwA4s">{</span> <span class="w" id="mwA4w"> </span><span class="c1" id="mwA40">// Scoped enum</span> <span class="w" id="mwA44"> </span><span class="n" id="mwA48">Color</span><span class="w" id="mwA5A"> </span><span class="n" id="mwA5E">color</span><span class="w" id="mwA5I"> </span><span class="o" id="mwA5M">=</span><span class="w" id="mwA5Q"> </span><span class="n" id="mwA5U">Color</span><span class="o" id="mwA5Y">::</span><span class="n" id="mwA5c">RED</span><span class="p" id="mwA5g">;</span> <span class="w" id="mwA5k"> </span><span class="c1" id="mwA5o">// Enum struct/class</span> <span class="w" id="mwA5s"> </span><span class="n" id="mwA5w">Direction</span><span class="w" id="mwA50"> </span><span class="n" id="mwA54">dir</span><span class="w" id="mwA58"> </span><span class="o" id="mwA6A">=</span><span class="w" id="mwA6E"> </span><span class="n" id="mwA6I">Direction</span><span class="o" id="mwA6M">::</span><span class="n" id="mwA6Q">NORTH</span><span class="p" id="mwA6U">;</span> <span class="w" id="mwA6Y"> </span><span class="c1" id="mwA6c">// Unscoped C-style enum</span> <span class="w" id="mwA6g"> </span><span class="n" id="mwA6k">CardSuit</span><span class="w" id="mwA6o"> </span><span class="n" id="mwA6s">card1</span><span class="w" id="mwA6w"> </span><span class="o" id="mwA60">=</span><span class="w" id="mwA64"> </span><span class="n" id="mwA68">CLUBS</span><span class="p" id="mwA7A">;</span> <span class="w" id="mwA7E"> </span><span class="n" id="mwA7I">CardSuit</span><span class="w" id="mwA7M"> </span><span class="n" id="mwA7Q">card2</span><span class="w" id="mwA7U"> </span><span class="o" id="mwA7Y">=</span><span class="w" id="mwA7c"> </span><span class="n" id="mwA7g">CardSuit</span><span class="o" id="mwA7k">::</span><span class="n" id="mwA7o">SPADES</span><span class="p" id="mwA7s">;</span><span class="w" id="mwA7w"> </span><span class="c1" id="mwA70">// Can explicitly be scoped</span> <span class="w" id="mwA74"> </span><span class="c1" id="mwA78">// Implicit integer conversion</span> <span class="w" id="mwA8A"> </span><span class="kt" id="mwA8E">int</span><span class="w" id="mwA8I"> </span><span class="n" id="mwA8M">suitValue</span><span class="w" id="mwA8Q"> </span><span class="o" id="mwA8U">=</span><span class="w" id="mwA8Y"> </span><span class="n" id="mwA8c">card1</span><span class="p" id="mwA8g">;</span><span class="w" id="mwA8k"> </span><span class="c1" id="mwA8o">// implicitly converts to int</span> <span class="w" id="mwA8s"> </span><span class="c1" id="mwA8w">// int colorValue = color; // fails, no implicit conversion</span> <span class="w" id="mwA80"> </span><span class="kt" id="mwA84">int</span><span class="w" id="mwA88"> </span><span class="n" id="mwA9A">colorValue</span><span class="w" id="mwA9E"> </span><span class="o" id="mwA9I">=</span><span class="w" id="mwA9M"> </span><span class="k" id="mwA9Q">static_cast</span><span class="o" id="mwA9U"><</span><span class="kt" id="mwA9Y">int</span><span class="o" id="mwA9c">></span><span class="p" id="mwA9g">(</span><span class="n" id="mwA9k">c</span><span class="p" id="mwA9o">);</span><span class="w" id="mwA9s"> </span><span class="c1" id="mwA9w">// explicit casts required</span> <span class="w" id="mwA90"> </span><span class="kt" id="mwA94">int</span><span class="w" id="mwA98"> </span><span class="n" id="mwA-A">dirValue</span><span class="w" id="mwA-E"> </span><span class="o" id="mwA-I">=</span><span class="w" id="mwA-M"> </span><span class="k" id="mwA-Q">static_cast</span><span class="o" id="mwA-U"><</span><span class="kt" id="mwA-Y">int</span><span class="o" id="mwA-c">></span><span class="p" id="mwA-g">(</span><span class="n" id="mwA-k">d</span><span class="p" id="mwA-o">);</span> <span class="p" id="mwA-s">}</span>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.
<span id="mwA_A"></span><span class="c1" id="mwA_E">// Must fit in size and memory layout of the type 'long'</span> <span class="k" id="mwA_I">enum</span><span class="w" id="mwA_M"> </span><span class="k" id="mwA_Q">class</span><span class="w" id="mwA_U"> </span><span class="nc" id="mwA_Y">Color</span><span class="w" id="mwA_c"> </span><span class="o" id="mwA_g">:</span><span class="w" id="mwA_k"> </span><span class="kt" id="mwA_o">long</span><span class="w" id="mwA_s"> </span><span class="p" id="mwA_w">{</span> <span class="w" id="mwA_0"> </span><span class="n" id="mwA_4">RED</span><span class="p" id="mwA_8">,</span><span class="w" id="mwBAA"> </span> <span class="w" id="mwBAE"> </span><span class="n" id="mwBAI">GREEN</span><span class="p" id="mwBAM">,</span><span class="w" id="mwBAQ"> </span> <span class="w" id="mwBAU"> </span><span class="n" id="mwBAY">BLUE</span><span class="p" id="mwBAc">,</span> <span class="p" id="mwBAg">};</span>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.
<span id="mwBA8"></span><span class="c1" id="mwBBA">// No explicit underlying type for enum class, so int</span> <span class="k" id="mwBBE">enum</span><span class="w" id="mwBBI"> </span><span class="k" id="mwBBM">class</span><span class="w" id="mwBBQ"> </span><span class="nc" id="mwBBU">Color</span><span class="p" id="mwBBY">;</span> <span class="c1" id="mwBBc">// Explicit underlying type</span> <span class="k" id="mwBBg">enum</span><span class="w" id="mwBBk"> </span><span class="k" id="mwBBo">class</span><span class="w" id="mwBBs"> </span><span class="nc" id="mwBBw">Status</span><span class="w" id="mwBB0"> </span><span class="o" id="mwBB4">:</span><span class="w" id="mwBB8"> </span><span class="kt" id="mwBCA">unsigned</span><span class="w" id="mwBCE"> </span><span class="kt" id="mwBCI">char</span><span class="p" id="mwBCM">;</span> <span class="c1" id="mwBCQ">// Unscoped so underlying type is required</span> <span class="k" id="mwBCU">enum</span><span class="w" id="mwBCY"> </span><span class="nc" id="mwBCc">Legacy</span><span class="w" id="mwBCg"> </span><span class="o" id="mwBCk">:</span><span class="w" id="mwBCo"> </span><span class="kt" id="mwBCs">int</span><span class="p" id="mwBCw">;</span> <span class="c1" id="mwBC0">// Unscoped with no underlying type; error</span> <span class="c1" id="mwBC4">// enum Broken;</span> <span class="c1" id="mwBC8">// Forward declarations</span> <span class="kt" id="mwBDA">void</span><span class="w" id="mwBDE"> </span><span class="nf" id="mwBDI">paint</span><span class="p" id="mwBDM">(</span><span class="n" id="mwBDQ">Color</span><span class="w" id="mwBDU"> </span><span class="n" id="mwBDY">c</span><span class="p" id="mwBDc">);</span> <span class="n" id="mwBDg">Status</span><span class="o" id="mwBDk">*</span><span class="w" id="mwBDo"> </span><span class="nf" id="mwBDs">getStatus</span><span class="p" id="mwBDw">();</span> <span class="c1" id="mwBD0">// Later definitions</span> <span class="k" id="mwBD4">enum</span><span class="w" id="mwBD8"> </span><span class="k" id="mwBEA">class</span><span class="w" id="mwBEE"> </span><span class="nc" id="mwBEI">Color</span><span class="w" id="mwBEM"> </span><span class="p" id="mwBEQ">{</span> <span class="w" id="mwBEU"> </span><span class="n" id="mwBEY">RED</span><span class="p" id="mwBEc">,</span> <span class="w" id="mwBEg"> </span><span class="n" id="mwBEk">GREEN</span><span class="p" id="mwBEo">,</span> <span class="w" id="mwBEs"> </span><span class="n" id="mwBEw">BLUE</span><span class="p" id="mwBE0">,</span> <span class="p" id="mwBE4">};</span> <span class="k" id="mwBE8">enum</span><span class="w" id="mwBFA"> </span><span class="k" id="mwBFE">class</span><span class="w" id="mwBFI"> </span><span class="nc" id="mwBFM">Status</span><span class="w" id="mwBFQ"> </span><span class="o" id="mwBFU">:</span><span class="w" id="mwBFY"> </span><span class="kt" id="mwBFc">unsigned</span><span class="w" id="mwBFg"> </span><span class="kt" id="mwBFk">char</span><span class="w" id="mwBFo"> </span><span class="p" id="mwBFs">{</span> <span class="w" id="mwBFw"> </span><span class="n" id="mwBF0">OK</span><span class="p" id="mwBF4">,</span> <span class="w" id="mwBF8"> </span><span class="n" id="mwBGA">ERROR</span><span class="p" id="mwBGE">,</span> <span class="p" id="mwBGI">};</span> <span class="k" id="mwBGM">enum</span><span class="w" id="mwBGQ"> </span><span class="nc" id="mwBGU">Legacy</span><span class="w" id="mwBGY"> </span><span class="o" id="mwBGc">:</span><span class="w" id="mwBGg"> </span><span class="kt" id="mwBGk">int</span><span class="w" id="mwBGo"> </span><span class="p" id="mwBGs">{</span> <span class="w" id="mwBGw"> </span><span class="n" id="mwBG0">A</span><span class="p" id="mwBG4">,</span> <span class="w" id="mwBG8"> </span><span class="n" id="mwBHA">B</span><span class="p" id="mwBHE">,</span> <span class="p" id="mwBHI">};</span> <span class="kt" id="mwBHM">void</span><span class="w" id="mwBHQ"> </span><span class="nf" id="mwBHU">paint</span><span class="p" id="mwBHY">(</span><span class="n" id="mwBHc">Color</span><span class="w" id="mwBHg"> </span><span class="n" id="mwBHk">c</span><span class="p" id="mwBHo">)</span><span class="w" id="mwBHs"> </span><span class="p" id="mwBHw">{</span><span class="w" id="mwBH0"> </span><span class="cm" id="mwBH4">/* ... */</span><span class="w" id="mwBH8"> </span><span class="p" id="mwBIA">}</span>Go
Go uses the iota identifier to create enumerated constants:
<span id="mwBI8"></span><span class="kd" id="mwBJA">type</span><span class="w" id="mwBJE"> </span><span class="nx" id="mwBJI">ByteSize</span><span class="w" id="mwBJM"> </span><span class="kt" id="mwBJQ">int</span> <span class="kd" id="mwBJU">const</span><span class="w" id="mwBJY"> </span><span class="p" id="mwBJc">(</span> <span class="w" id="mwBJg"> </span><span class="nx" id="mwBJk">_</span><span class="w" id="mwBJo"> </span><span class="o" id="mwBJs">=</span><span class="w" id="mwBJw"> </span><span class="kc" id="mwBJ0">iota</span><span class="w" id="mwBJ4"> </span><span class="c1" id="mwBJ8">// ignore first value by assigning to blank identifier; 0</span> <span class="w" id="mwBKA"> </span><span class="nx" id="mwBKE">KB</span><span class="w" id="mwBKI"> </span><span class="nx" id="mwBKM">ByteSize</span><span class="w" id="mwBKQ"> </span><span class="o" id="mwBKU">=</span><span class="w" id="mwBKY"> </span><span class="mi" id="mwBKc">1</span><span class="w" id="mwBKg"> </span><span class="o" id="mwBKk"><<</span><span class="w" id="mwBKo"> </span><span class="p" id="mwBKs">(</span><span class="mi" id="mwBKw">10</span><span class="w" id="mwBK0"> </span><span class="o" id="mwBK4">*</span><span class="w" id="mwBK8"> </span><span class="kc" id="mwBLA">iota</span><span class="p" id="mwBLE">)</span><span class="w" id="mwBLI"> </span><span class="c1" id="mwBLM">// 1 << (10 * 1) == 1 << 10 == 1024; in binary 10000000000</span> <span class="w" id="mwBLQ"> </span><span class="nx" id="mwBLU">MB</span><span class="w" id="mwBLY"> </span><span class="c1" id="mwBLc">// 1 << (10 * 2) == 1048576; in binary 100000000000000000000</span> <span class="w" id="mwBLg"> </span><span class="nx" id="mwBLk">GB</span><span class="w" id="mwBLo"> </span><span class="c1" id="mwBLs">// 1 << (10 * 3) == 1073741824; in binary 1000000000000000000000000000000</span> <span class="p" id="mwBLw">)</span>
Java
The J2SE version 5.0 of the Java programming language added enumerated types whose declaration syntax is similar to that of C:
<span id="mwBMM"></span><span class="kd" id="mwBMQ">enum</span><span class="w" id="mwBMU"> </span><span class="n" id="mwBMY">CardSuit</span><span class="w" id="mwBMc"> </span><span class="p" id="mwBMg">{</span><span class="w" id="mwBMk"> </span> <span class="w" id="mwBMo"> </span><span class="n" id="mwBMs">CLUBS</span><span class="p" id="mwBMw">,</span><span class="w" id="mwBM0"> </span> <span class="w" id="mwBM4"> </span><span class="n" id="mwBM8">DIAMONDS</span><span class="p" id="mwBNA">,</span><span class="w" id="mwBNE"> </span> <span class="w" id="mwBNI"> </span><span class="n" id="mwBNM">SPADES</span><span class="p" id="mwBNQ">,</span><span class="w" id="mwBNU"> </span> <span class="w" id="mwBNY"> </span><span class="n" id="mwBNc">HEARTS</span><span class="p" id="mwBNg">,</span> <span class="p" id="mwBNk">};</span> <span class="n" id="mwBNo">CardSuit</span><span class="w" id="mwBNs"> </span><span class="n" id="mwBNw">trump</span><span class="p" id="mwBN0">;</span>The Java type system, however, does not allow intermixing of enum and integer values. All enum types implicitly extend the 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.
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 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.
The Java standard library provides utility classes to use with enumerations. The 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 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.
<span id="mwBQg"></span><span class="kd" id="mwBQk">public</span><span class="w" id="mwBQo"> </span><span class="kd" id="mwBQs">enum</span><span class="w" id="mwBQw"> </span><span class="n" id="mwBQ0">Planet</span><span class="w" id="mwBQ4"> </span><span class="p" id="mwBQ8">{</span> <span class="w" id="mwBRA"> </span><span class="c1" id="mwBRE">// Each member can call its own constructor (here, mass and radius)</span> <span class="w" id="mwBRI"> </span><span class="n" id="mwBRM">MERCURY</span><span class="p" id="mwBRQ">(</span><span class="mf" id="mwBRU">3.303e+23</span><span class="p" id="mwBRY">,</span><span class="w" id="mwBRc"> </span><span class="mf" id="mwBRg">2.4397e6</span><span class="p" id="mwBRk">),</span> <span class="w" id="mwBRo"> </span><span class="n" id="mwBRs">VENUS</span><span class="p" id="mwBRw">(</span><span class="mf" id="mwBR0">4.869e+24</span><span class="p" id="mwBR4">,</span><span class="w" id="mwBR8"> </span><span class="mf" id="mwBSA">6.0518e6</span><span class="p" id="mwBSE">),</span> <span class="w" id="mwBSI"> </span><span class="n" id="mwBSM">EARTH</span><span class="p" id="mwBSQ">(</span><span class="mf" id="mwBSU">5.976e+24</span><span class="p" id="mwBSY">,</span><span class="w" id="mwBSc"> </span><span class="mf" id="mwBSg">6.37814e6</span><span class="p" id="mwBSk">)</span><span class="w" id="mwBSo"> </span><span class="p" id="mwBSs">{</span> <span class="w" id="mwBSw"> </span><span class="c1" id="mwBS0">// Members may override methods</span> <span class="w" id="mwBS4"> </span><span class="nd" id="mwBS8">@Override</span> <span class="w" id="mwBTA"> </span><span class="n" id="mwBTE">String</span><span class="w" id="mwBTI"> </span><span class="nf" id="mwBTM">touchdown</span><span class="p" id="mwBTQ">()</span><span class="w" id="mwBTU"> </span><span class="p" id="mwBTY">{</span> <span class="w" id="mwBTc"> </span><span class="k" id="mwBTg">return</span><span class="w" id="mwBTk"> </span><span class="s" id="mwBTo">"Home sweet home!"</span><span class="p" id="mwBTs">;</span> <span class="w" id="mwBTw"> </span><span class="p" id="mwBT0">}</span> <span class="w" id="mwBT4"> </span><span class="c1" id="mwBT8">// Abstract methods declared in an enum must be implemented by all members, however</span> <span class="w" id="mwBUA"> </span><span class="p" id="mwBUE">},</span> <span class="w" id="mwBUI"> </span><span class="n" id="mwBUM">MARS</span><span class="p" id="mwBUQ">(</span><span class="mf" id="mwBUU">6.421e+23</span><span class="p" id="mwBUY">,</span><span class="w" id="mwBUc"> </span><span class="mf" id="mwBUg">3.3972e6</span><span class="p" id="mwBUk">),</span> <span class="w" id="mwBUo"> </span><span class="n" id="mwBUs">JUPITER</span><span class="p" id="mwBUw">(</span><span class="mf" id="mwBU0">1.9e+27</span><span class="p" id="mwBU4">,</span><span class="w" id="mwBU8"> </span><span class="mf" id="mwBVA">7.1492e7</span><span class="p" id="mwBVE">),</span> <span class="w" id="mwBVI"> </span><span class="n" id="mwBVM">SATURN</span><span class="p" id="mwBVQ">(</span><span class="mf" id="mwBVU">5.688e+26</span><span class="p" id="mwBVY">,</span><span class="w" id="mwBVc"> </span><span class="mf" id="mwBVg">6.0268e7</span><span class="p" id="mwBVk">),</span> <span class="w" id="mwBVo"> </span><span class="n" id="mwBVs">URANUS</span><span class="p" id="mwBVw">(</span><span class="mf" id="mwBV0">8.686e+25</span><span class="p" id="mwBV4">,</span><span class="w" id="mwBV8"> </span><span class="mf" id="mwBWA">2.5559e7</span><span class="p" id="mwBWE">),</span> <span class="w" id="mwBWI"> </span><span class="n" id="mwBWM">NEPTUNE</span><span class="p" id="mwBWQ">(</span><span class="mf" id="mwBWU">1.024e+26</span><span class="p" id="mwBWY">,</span><span class="w" id="mwBWc"> </span><span class="mf" id="mwBWg">2.4746e7</span><span class="p" id="mwBWk">);</span> <span class="w" id="mwBWo"> </span><span class="c1" id="mwBWs">// Enums may have static fields</span> <span class="w" id="mwBWw"> </span><span class="kd" id="mwBW0">public</span><span class="w" id="mwBW4"> </span><span class="kd" id="mwBW8">static</span><span class="w" id="mwBXA"> </span><span class="kd" id="mwBXE">final</span><span class="w" id="mwBXI"> </span><span class="kt" id="mwBXM">double</span><span class="w" id="mwBXQ"> </span><span class="n" id="mwBXU">G</span><span class="w" id="mwBXY"> </span><span class="o" id="mwBXc">=</span><span class="w" id="mwBXg"> </span><span class="mf" id="mwBXk">6.67300E-11</span><span class="p" id="mwBXo">;</span> <span class="w" id="mwBXs"> </span><span class="c1" id="mwBXw">// and fields specific to each member</span> <span class="w" id="mwBX0"> </span><span class="kd" id="mwBX4">public</span><span class="w" id="mwBX8"> </span><span class="kd" id="mwBYA">final</span><span class="w" id="mwBYE"> </span><span class="kt" id="mwBYI">double</span><span class="w" id="mwBYM"> </span><span class="n" id="mwBYQ">mass</span><span class="p" id="mwBYU">;</span> <span class="w" id="mwBYY"> </span><span class="kd" id="mwBYc">public</span><span class="w" id="mwBYg"> </span><span class="kd" id="mwBYk">final</span><span class="w" id="mwBYo"> </span><span class="kt" id="mwBYs">double</span><span class="w" id="mwBYw"> </span><span class="n" id="mwBY0">radius</span><span class="p" id="mwBY4">;</span> <span class="w" id="mwBY8"> </span><span class="c1" id="mwBZA">// Constructors must not be public or protected</span> <span class="w" id="mwBZE"> </span><span class="n" id="mwBZI">Planet</span><span class="p" id="mwBZM">(</span><span class="kt" id="mwBZQ">double</span><span class="w" id="mwBZU"> </span><span class="n" id="mwBZY">mass</span><span class="p" id="mwBZc">,</span><span class="w" id="mwBZg"> </span><span class="kt" id="mwBZk">double</span><span class="w" id="mwBZo"> </span><span class="n" id="mwBZs">radius</span><span class="p" id="mwBZw">)</span><span class="w" id="mwBZ0"> </span><span class="p" id="mwBZ4">{</span> <span class="w" id="mwBZ8"> </span><span class="k" id="mwBaA">this</span><span class="p" id="mwBaE">.</span><span class="na" id="mwBaI">mass</span><span class="w" id="mwBaM"> </span><span class="o" id="mwBaQ">=</span><span class="w" id="mwBaU"> </span><span class="n" id="mwBaY">mass</span><span class="p" id="mwBac">;</span> <span class="w" id="mwBag"> </span><span class="k" id="mwBak">this</span><span class="p" id="mwBao">.</span><span class="na" id="mwBas">radius</span><span class="w" id="mwBaw"> </span><span class="o" id="mwBa0">=</span><span class="w" id="mwBa4"> </span><span class="n" id="mwBa8">radius</span><span class="p" id="mwBbA">;</span> <span class="w" id="mwBbE"> </span><span class="p" id="mwBbI">}</span> <span class="w" id="mwBbM"> </span><span class="kd" id="mwBbQ">public</span><span class="w" id="mwBbU"> </span><span class="kt" id="mwBbY">double</span><span class="w" id="mwBbc"> </span><span class="nf" id="mwBbg">surfaceGravity</span><span class="p" id="mwBbk">()</span><span class="w" id="mwBbo"> </span><span class="p" id="mwBbs">{</span> <span class="w" id="mwBbw"> </span><span class="k" id="mwBb0">return</span><span class="w" id="mwBb4"> </span><span class="n" id="mwBb8">Planet</span><span class="p" id="mwBcA">.</span><span class="na" id="mwBcE">G</span><span class="w" id="mwBcI"> </span><span class="o" id="mwBcM">*</span><span class="w" id="mwBcQ"> </span><span class="k" id="mwBcU">this</span><span class="p" id="mwBcY">.</span><span class="na" id="mwBcc">mass</span><span class="w" id="mwBcg"> </span><span class="o" id="mwBck">/</span><span class="w" id="mwBco"> </span><span class="p" id="mwBcs">(</span><span class="k" id="mwBcw">this</span><span class="p" id="mwBc0">.</span><span class="na" id="mwBc4">radius</span><span class="w" id="mwBc8"> </span><span class="o" id="mwBdA">*</span><span class="w" id="mwBdE"> </span><span class="k" id="mwBdI">this</span><span class="p" id="mwBdM">.</span><span class="na" id="mwBdQ">radius</span><span class="p" id="mwBdU">);</span> <span class="w" id="mwBdY"> </span><span class="p" id="mwBdc">}</span> <span class="w" id="mwBdg"> </span><span class="kd" id="mwBdk">public</span><span class="w" id="mwBdo"> </span><span class="kt" id="mwBds">double</span><span class="w" id="mwBdw"> </span><span class="nf" id="mwBd0">surfaceWeight</span><span class="p" id="mwBd4">(</span><span class="kt" id="mwBd8">double</span><span class="w" id="mwBeA"> </span><span class="n" id="mwBeE">otherMass</span><span class="p" id="mwBeI">)</span><span class="w" id="mwBeM"> </span><span class="p" id="mwBeQ">{</span> <span class="w" id="mwBeU"> </span><span class="k" id="mwBeY">return</span><span class="w" id="mwBec"> </span><span class="n" id="mwBeg">otherMass</span><span class="w" id="mwBek"> </span><span class="o" id="mwBeo">*</span><span class="w" id="mwBes"> </span><span class="k" id="mwBew">this</span><span class="p" id="mwBe0">.</span><span class="na" id="mwBe4">surfaceGravity</span><span class="p" id="mwBe8">();</span> <span class="w" id="mwBfA"> </span><span class="p" id="mwBfE">}</span> <span class="w" id="mwBfI"> </span> <span class="w" id="mwBfM"> </span><span class="kd" id="mwBfQ">public</span><span class="w" id="mwBfU"> </span><span class="n" id="mwBfY">String</span><span class="w" id="mwBfc"> </span><span class="nf" id="mwBfg">touchdown</span><span class="p" id="mwBfk">()</span><span class="w" id="mwBfo"> </span><span class="p" id="mwBfs">{</span> <span class="w" id="mwBfw"> </span><span class="k" id="mwBf0">return</span><span class="w" id="mwBf4"> </span><span class="s" id="mwBf8">"Woosh!"</span><span class="p" id="mwBgA">;</span> <span class="w" id="mwBgE"> </span><span class="p" id="mwBgI">}</span><span class="w" id="mwBgM"> </span> <span class="w" id="mwBgQ"> </span><span class="c1" id="mwBgU">// Entry methods are even allowed</span> <span class="w" id="mwBgY"> </span><span class="kd" id="mwBgc">public</span><span class="w" id="mwBgg"> </span><span class="kd" id="mwBgk">static</span><span class="w" id="mwBgo"> </span><span class="kt" id="mwBgs">void</span><span class="w" id="mwBgw"> </span><span class="nf" id="mwBg0">main</span><span class="p" id="mwBg4">(</span><span class="n" id="mwBg8">String</span><span class="o" id="mwBhA">[]</span><span class="w" id="mwBhE"> </span><span class="n" id="mwBhI">args</span><span class="p" id="mwBhM">)</span><span class="w" id="mwBhQ"> </span><span class="p" id="mwBhU">{</span> <span class="w" id="mwBhY"> </span><span class="kt" id="mwBhc">double</span><span class="w" id="mwBhg"> </span><span class="n" id="mwBhk">earthWeight</span><span class="w" id="mwBho"> </span><span class="o" id="mwBhs">=</span><span class="w" id="mwBhw"> </span><span class="n" id="mwBh0">Double</span><span class="p" id="mwBh4">.</span><span class="na" id="mwBh8">parseDouble</span><span class="p" id="mwBiA">(</span><span class="n" id="mwBiE">args</span><span class="o" id="mwBiI">[</span><span class="mi" id="mwBiM">0</span><span class="o" id="mwBiQ">]</span><span class="p" id="mwBiU">);</span> <span class="w" id="mwBiY"> </span><span class="kt" id="mwBic">double</span><span class="w" id="mwBig"> </span><span class="n" id="mwBik">mass</span><span class="w" id="mwBio"> </span><span class="o" id="mwBis">=</span><span class="w" id="mwBiw"> </span><span class="n" id="mwBi0">earthWeight</span><span class="w" id="mwBi4"> </span><span class="o" id="mwBi8">/</span><span class="w" id="mwBjA"> </span><span class="n" id="mwBjE">EARTH</span><span class="p" id="mwBjI">.</span><span class="na" id="mwBjM">surfaceGravity</span><span class="p" id="mwBjQ">();</span> <span class="w" id="mwBjU"> </span><span class="k" id="mwBjY">for</span><span class="w" id="mwBjc"> </span><span class="p" id="mwBjg">(</span><span class="n" id="mwBjk">Planet</span><span class="w" id="mwBjo"> </span><span class="n" id="mwBjs">p</span><span class="w" id="mwBjw"> </span><span class="p" id="mwBj0">:</span><span class="w" id="mwBj4"> </span><span class="n" id="mwBj8">Planet</span><span class="p" id="mwBkA">.</span><span class="na" id="mwBkE">values</span><span class="p" id="mwBkI">())</span><span class="w" id="mwBkM"> </span><span class="p" id="mwBkQ">{</span> <span class="w" id="mwBkU"> </span><span class="n" id="mwBkY">System</span><span class="p" id="mwBkc">.</span><span class="na" id="mwBkg">out</span><span class="p" id="mwBkk">.</span><span class="na" id="mwBko">printf</span><span class="p" id="mwBks">(</span> <span class="w" id="mwBkw"> </span><span class="s" id="mwBk0">"Your weight on %s is %.6f. %s%n"</span><span class="p" id="mwBk4">,</span> <span class="w" id="mwBk8"> </span><span class="n" id="mwBlA">p</span><span class="p" id="mwBlE">,</span><span class="w" id="mwBlI"> </span><span class="n" id="mwBlM">p</span><span class="p" id="mwBlQ">.</span><span class="na" id="mwBlU">surfaceWeight</span><span class="p" id="mwBlY">(</span><span class="n" id="mwBlc">mass</span><span class="p" id="mwBlg">),</span><span class="w" id="mwBlk"> </span><span class="n" id="mwBlo">p</span><span class="p" id="mwBls">.</span><span class="na" id="mwBlw">touchdown</span><span class="p" id="mwBl0">()</span> <span class="w" id="mwBl4"> </span><span class="p" id="mwBl8">);</span> <span class="w" id="mwBmA"> </span><span class="p" id="mwBmE">}</span> <span class="w" id="mwBmI"> </span><span class="p" id="mwBmM">}</span> <span class="p" id="mwBmQ">}</span>Perl
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):
<span id="mwBnA"></span><span class="k" id="mwBnE">my</span><span class="w" id="mwBnI"> </span><span class="nv" id="mwBnM">@enum</span><span class="w" id="mwBnQ"> </span><span class="o" id="mwBnU">=</span><span class="w" id="mwBnY"> </span><span class="sx" id="mwBnc">qw(Clubs Diamonds Hearts Spades)</span><span class="p" id="mwBng">;</span> <span class="k" id="mwBnk">my</span><span class="p" id="mwBno">(</span><span class="w" id="mwBns"> </span><span class="nv" id="mwBnw">%set1</span><span class="p" id="mwBn0">,</span><span class="w" id="mwBn4"> </span><span class="nv" id="mwBn8">%set2</span><span class="w" id="mwBoA"> </span><span class="p" id="mwBoE">);</span> <span class="nv" id="mwBoI">@set1</span><span class="p" id="mwBoM">{</span><span class="nv" id="mwBoQ">@enum</span><span class="p" id="mwBoU">}</span><span class="w" id="mwBoY"> </span><span class="o" id="mwBoc">=</span><span class="w" id="mwBog"> </span><span class="p" id="mwBok">();</span><span class="w" id="mwBoo"> </span><span class="c1" id="mwBos"># all cleared</span> <span class="nv" id="mwBow">@set2</span><span class="p" id="mwBo0">{</span><span class="nv" id="mwBo4">@enum</span><span class="p" id="mwBo8">}</span><span class="w" id="mwBpA"> </span><span class="o" id="mwBpE">=</span><span class="w" id="mwBpI"> </span><span class="p" id="mwBpM">(</span><span class="mi" id="mwBpQ">1</span><span class="p" id="mwBpU">)</span><span class="w" id="mwBpY"> </span><span class="n" id="mwBpc">x</span><span class="w" id="mwBpg"> </span><span class="nv" id="mwBpk">@enum</span><span class="p" id="mwBpo">;</span><span class="w" id="mwBps"> </span><span class="c1" id="mwBpw"># all set to 1</span> <span class="nv" id="mwBp0">$set1</span><span class="p" id="mwBp4">{</span><span class="n" id="mwBp8">Clubs</span><span class="p" id="mwBqA">}</span><span class="w" id="mwBqE"> </span><span class="o" id="mwBqI">...</span><span class="w" id="mwBqM"> </span><span class="c1" id="mwBqQ"># false</span> <span class="nv" id="mwBqU">$set2</span><span class="p" id="mwBqY">{</span><span class="n" id="mwBqc">Diamonds</span><span class="p" id="mwBqg">}</span><span class="w" id="mwBqk"> </span><span class="o" id="mwBqo">...</span><span class="w" id="mwBqs"> </span><span class="c1" id="mwBqw"># true</span>Raku
Raku (formerly known as Perl 6) supports enumerations. There are multiple ways to declare enumerations in Raku, all creating a back-end Map.
<span id="mwBrI"></span><span class="k" id="mwBrM">enum</span> <span class="n" id="mwBrQ">Cat</span> <span class="s" id="mwBrU"><sphynx siamese bengal shorthair other></span>; <span class="c1" id="mwBrY"># Using "quote-words"</span>
<span id="mwBrk"></span><span class="k" id="mwBro">enum</span> <span class="n" id="mwBrs">Cat</span> (<span class="s" id="mwBrw">'sphynx'</span>, <span class="s" id="mwBr0">'siamese'</span>, <span class="s" id="mwBr4">'bengal'</span>, <span class="s" id="mwBr8">'shorthair'</span>, <span class="s" id="mwBsA">'other'</span>); <span class="c1" id="mwBsE"># Using a list</span>
<span id="mwBsQ"></span><span class="k" id="mwBsU">enum</span> <span class="n" id="mwBsY">Cat</span> (<span class="n" id="mwBsc">sphynx</span> => <span class="mi" id="mwBsg">0</span>, <span class="n" id="mwBsk">siamese</span> => <span class="mi" id="mwBso">1</span>, <span class="n" id="mwBss">bengal</span> => <span class="mi" id="mwBsw">2</span>, <span class="n" id="mwBs0">shorthair</span> => <span class="mi" id="mwBs4">3</span>, <span class="n" id="mwBs8">other</span> => <span class="mi" id="mwBtA">4</span>); <span class="c1" id="mwBtE"># Using Pair constructors</span>
<span id="mwBtQ"></span><span class="k" id="mwBtU">enum</span> <span class="n" id="mwBtY">Cat</span> (:<span class="n" id="mwBtc">sphynx</span>(<span class="mi" id="mwBtg">0</span>), :<span class="n" id="mwBtk">siamese</span>(<span class="mi" id="mwBto">1</span>), :<span class="n" id="mwBts">bengal</span>(<span class="mi" id="mwBtw">2</span>), <span class="n" id="mwBt0">shorthair</span>(<span class="mi" id="mwBt4">3</span>), :<span class="n" id="mwBt8">other</span>(<span class="mi" id="mwBuA">4</span>)); <span class="c1" id="mwBuE"># Another way of using Pairs, you can also use `:0sphynx`</span>
PHP
Enums were added in PHP version 8.1.
<span id="mwBuY"></span><span class="kr" id="mwBuc">enum</span> <span class="nx" id="mwBug">CardSuit</span> <span class="p" id="mwBuk">{</span> <span class="k" id="mwBuo">case</span> <span class="nx" id="mwBus">Hearts</span><span class="p" id="mwBuw">;</span> <span class="k" id="mwBu0">case</span> <span class="nx" id="mwBu4">Diamonds</span><span class="p" id="mwBu8">;</span> <span class="k" id="mwBvA">case</span> <span class="nx" id="mwBvE">Clubs</span><span class="p" id="mwBvI">;</span> <span class="k" id="mwBvM">case</span> <span class="nx" id="mwBvQ">Spades</span><span class="p" id="mwBvU">;</span> <span class="p" id="mwBvY">}</span>Enumerators may be backed by string or integer values to aid serialization:
<span id="mwBvo"></span><span class="kr" id="mwBvs">enum</span> <span class="nx" id="mwBvw">CardSuit</span><span class="o" id="mwBv0">:</span> <span class="kr" id="mwBv4">string</span> <span class="p" id="mwBv8">{</span> <span class="k" id="mwBwA">case</span> <span class="nx" id="mwBwE">Hearts</span> <span class="o" id="mwBwI">=</span> <span class="s1" id="mwBwM">'H'</span><span class="p" id="mwBwQ">;</span> <span class="k" id="mwBwU">case</span> <span class="nx" id="mwBwY">Diamonds</span> <span class="o" id="mwBwc">=</span> <span class="s1" id="mwBwg">'D'</span><span class="p" id="mwBwk">;</span> <span class="k" id="mwBwo">case</span> <span class="nx" id="mwBws">Clubs</span> <span class="o" id="mwBww">=</span> <span class="s1" id="mwBw0">'C'</span><span class="p" id="mwBw4">;</span> <span class="k" id="mwBw8">case</span> <span class="nx" id="mwBxA">Spades</span> <span class="o" id="mwBxE">=</span> <span class="s1" id="mwBxI">'S'</span><span class="p" id="mwBxM">;</span> <span class="p" id="mwBxQ">}</span>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.
Rust
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.
<span id="mwBxw"></span><span class="k" id="mwBx0">enum</span><span class="w" id="mwBx4"> </span><span class="nc" id="mwBx8">Message</span><span class="w" id="mwByA"> </span><span class="p" id="mwByE">{</span> <span class="w" id="mwByI"> </span><span class="n" id="mwByM">Quit</span><span class="p" id="mwByQ">,</span> <span class="w" id="mwByU"> </span><span class="n" id="mwByY">Move</span><span class="w" id="mwByc"> </span><span class="p" id="mwByg">{</span><span class="w" id="mwByk"> </span><span class="n" id="mwByo">x</span><span class="p" id="mwBys">:</span><span class="w" id="mwByw"> </span><span class="kt" id="mwBy0">i32</span><span class="p" id="mwBy4">,</span><span class="w" id="mwBy8"> </span><span class="n" id="mwBzA">y</span><span class="p" id="mwBzE">:</span><span class="w" id="mwBzI"> </span><span class="kt" id="mwBzM">i32</span><span class="w" id="mwBzQ"> </span><span class="p" id="mwBzU">},</span><span class="w" id="mwBzY"> </span><span class="c1" id="mwBzc">// struct</span> <span class="w" id="mwBzg"> </span><span class="n" id="mwBzk">Write</span><span class="p" id="mwBzo">(</span><span class="nb" id="mwBzs">String</span><span class="p" id="mwBzw">),</span><span class="w" id="mwBz0"> </span><span class="c1" id="mwBz4">// single-element tuple</span> <span class="w" id="mwBz8"> </span><span class="n" id="mwB0A">ChangeColor</span><span class="p" id="mwB0E">(</span><span class="kt" id="mwB0I">i32</span><span class="p" id="mwB0M">,</span><span class="w" id="mwB0Q"> </span><span class="kt" id="mwB0U">i32</span><span class="p" id="mwB0Y">,</span><span class="w" id="mwB0c"> </span><span class="kt" id="mwB0g">i32</span><span class="p" id="mwB0k">),</span><span class="w" id="mwB0o"> </span><span class="c1" id="mwB0s">// three-element tuple</span> <span class="p" id="mwB0w">}</span>Like C, Rust also supports specifying the values of each variant,
<span id="mwB1A"></span><span class="k" id="mwB1E">pub</span><span class="w" id="mwB1I"> </span><span class="k" id="mwB1M">enum</span><span class="w" id="mwB1Q"> </span><span class="nc" id="mwB1U">Weekday</span><span class="w" id="mwB1Y"> </span><span class="p" id="mwB1c">{</span> <span class="w" id="mwB1g"> </span><span class="n" id="mwB1k">Sunday</span><span class="w" id="mwB1o"> </span><span class="o" id="mwB1s">=</span><span class="w" id="mwB1w"> </span><span class="mi" id="mwB10">1</span><span class="p" id="mwB14">,</span> <span class="w" id="mwB18"> </span><span class="n" id="mwB2A">Monday</span><span class="w" id="mwB2E"> </span><span class="o" id="mwB2I">=</span><span class="w" id="mwB2M"> </span><span class="mi" id="mwB2Q">2</span><span class="p" id="mwB2U">,</span> <span class="w" id="mwB2Y"> </span><span class="n" id="mwB2c">Tuesday</span><span class="w" id="mwB2g"> </span><span class="o" id="mwB2k">=</span><span class="w" id="mwB2o"> </span><span class="mi" id="mwB2s">4</span><span class="p" id="mwB2w">,</span> <span class="w" id="mwB20"> </span><span class="n" id="mwB24">Wednesday</span><span class="w" id="mwB28"> </span><span class="o" id="mwB3A">=</span><span class="w" id="mwB3E"> </span><span class="mi" id="mwB3I">8</span><span class="p" id="mwB3M">,</span> <span class="w" id="mwB3Q"> </span><span class="n" id="mwB3U">Thursday</span><span class="w" id="mwB3Y"> </span><span class="o" id="mwB3c">=</span><span class="w" id="mwB3g"> </span><span class="mi" id="mwB3k">16</span><span class="p" id="mwB3o">,</span> <span class="w" id="mwB3s"> </span><span class="n" id="mwB3w">Friday</span><span class="w" id="mwB30"> </span><span class="o" id="mwB34">=</span><span class="w" id="mwB38"> </span><span class="mi" id="mwB4A">32</span><span class="p" id="mwB4E">,</span> <span class="w" id="mwB4I"> </span><span class="n" id="mwB4M">Saturday</span><span class="w" id="mwB4Q"> </span><span class="o" id="mwB4U">=</span><span class="w" id="mwB4Y"> </span><span class="mi" id="mwB4c">64</span><span class="p" id="mwB4g">,</span> <span class="p" id="mwB4k">}</span>Swift
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.
<span id="mwB5I"></span><span class="kd" id="mwB5M">enum</span><span class="w" id="mwB5Q"> </span><span class="nc" id="mwB5U">CardSuit</span><span class="w" id="mwB5Y"> </span><span class="p" id="mwB5c">{</span> <span class="w" id="mwB5g"> </span><span class="k" id="mwB5k">case</span><span class="w" id="mwB5o"> </span><span class="n" id="mwB5s">clubs</span> <span class="w" id="mwB5w"> </span><span class="k" id="mwB50">case</span><span class="w" id="mwB54"> </span><span class="n" id="mwB58">diamonds</span> <span class="w" id="mwB6A"> </span><span class="k" id="mwB6E">case</span><span class="w" id="mwB6I"> </span><span class="n" id="mwB6M">hearts</span> <span class="w" id="mwB6Q"> </span><span class="k" id="mwB6U">case</span><span class="w" id="mwB6Y"> </span><span class="n" id="mwB6c">spades</span> <span class="p" id="mwB6g">}</span>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:
<span id="mwB64"></span><span class="kd" id="mwB68">enum</span><span class="w" id="mwB7A"> </span><span class="nc" id="mwB7E">CardSuit</span><span class="w" id="mwB7I"> </span><span class="p" id="mwB7M">{</span> <span class="w" id="mwB7Q"> </span><span class="k" id="mwB7U">case</span><span class="w" id="mwB7Y"> </span><span class="n" id="mwB7c">clubs</span><span class="p" id="mwB7g">,</span><span class="w" id="mwB7k"> </span><span class="n" id="mwB7o">diamonds</span><span class="p" id="mwB7s">,</span><span class="w" id="mwB7w"> </span><span class="n" id="mwB70">hearts</span><span class="p" id="mwB74">,</span><span class="w" id="mwB78"> </span><span class="n" id="mwB8A">spades</span> <span class="p" id="mwB8E">}</span>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:
<span id="mwB8Y"></span><span class="kd" id="mwB8c">enum</span><span class="w" id="mwB8g"> </span><span class="nc" id="mwB8k">CardSuit</span><span class="w" id="mwB8o"> </span><span class="p" id="mwB8s">{</span> <span class="w" id="mwB8w"> </span><span class="k" id="mwB80">case</span><span class="w" id="mwB84"> </span><span class="n" id="mwB88">clubs</span><span class="w" id="mwB9A"> </span><span class="p" id="mwB9E">=</span><span class="w" id="mwB9I"> </span><span class="mi" id="mwB9M">1</span><span class="p" id="mwB9Q">,</span><span class="w" id="mwB9U"> </span><span class="n" id="mwB9Y">diamonds</span><span class="p" id="mwB9c">,</span><span class="w" id="mwB9g"> </span><span class="n" id="mwB9k">hearts</span><span class="p" id="mwB9o">,</span><span class="w" id="mwB9s"> </span><span class="n" id="mwB9w">spades</span> <span class="p" id="mwB90">}</span>TypeScript
TypeScript adds an enum data type to JavaScript.
<span id="mwB-Q"></span><span class="kd" id="mwB-U">enum</span><span class="w" id="mwB-Y"> </span><span class="nx" id="mwB-c">CardSuit</span><span class="w" id="mwB-g"> </span><span class="p" id="mwB-k">{</span> <span class="w" id="mwB-o"> </span><span class="nx" id="mwB-s">Clubs</span><span class="p" id="mwB-w">,</span><span class="w" id="mwB-0"> </span> <span class="w" id="mwB-4"> </span><span class="nx" id="mwB-8">Diamonds</span><span class="p" id="mwB_A">,</span><span class="w" id="mwB_E"> </span> <span class="w" id="mwB_I"> </span><span class="nx" id="mwB_M">Hearts</span><span class="p" id="mwB_Q">,</span><span class="w" id="mwB_U"> </span> <span class="w" id="mwB_Y"> </span><span class="nx" id="mwB_c">Spades</span> <span class="p" id="mwB_g">};</span> <span class="kd" id="mwB_k">let</span><span class="w" id="mwB_o"> </span><span class="nx" id="mwB_s">c</span><span class="o" id="mwB_w">:</span><span class="w" id="mwB_0"> </span><span class="kt" id="mwB_4">CardSuit</span><span class="w" id="mwB_8"> </span><span class="o" id="mwCAA">=</span><span class="w" id="mwCAE"> </span><span class="nx" id="mwCAI">CardSuit</span><span class="p" id="mwCAM">.</span><span class="nx" id="mwCAQ">Diamonds</span><span class="p" id="mwCAU">;</span>By default, enums number members starting at 0; this can be overridden by setting the value of the first member:
<span id="mwCAk"></span><span class="kd" id="mwCAo">enum</span><span class="w" id="mwCAs"> </span><span class="nx" id="mwCAw">CardSuit</span><span class="w" id="mwCA0"> </span><span class="p" id="mwCA4">{</span> <span class="w" id="mwCA8"> </span><span class="nx" id="mwCBA">Clubs</span><span class="w" id="mwCBE"> </span><span class="o" id="mwCBI">=</span><span class="w" id="mwCBM"> </span><span class="mf" id="mwCBQ">1</span><span class="p" id="mwCBU">,</span><span class="w" id="mwCBY"> </span> <span class="w" id="mwCBc"> </span><span class="nx" id="mwCBg">Diamonds</span><span class="p" id="mwCBk">,</span><span class="w" id="mwCBo"> </span> <span class="w" id="mwCBs"> </span><span class="nx" id="mwCBw">Hearts</span><span class="p" id="mwCB0">,</span><span class="w" id="mwCB4"> </span> <span class="w" id="mwCB8"> </span><span class="nx" id="mwCCA">Spades</span> <span class="p" id="mwCCE">};</span> <span class="kd" id="mwCCI">let</span><span class="w" id="mwCCM"> </span><span class="nx" id="mwCCQ">c</span><span class="o" id="mwCCU">:</span><span class="w" id="mwCCY"> </span><span class="kt" id="mwCCc">CardSuit</span><span class="w" id="mwCCg"> </span><span class="o" id="mwCCk">=</span><span class="w" id="mwCCo"> </span><span class="nx" id="mwCCs">CardSuit</span><span class="p" id="mwCCw">.</span><span class="nx" id="mwCC0">Diamonds</span><span class="p" id="mwCC4">;</span>Each number may also be set:
<span id="mwCDI"></span><span class="kd" id="mwCDM">enum</span><span class="w" id="mwCDQ"> </span><span class="nx" id="mwCDU">CardSuit</span><span class="w" id="mwCDY"> </span><span class="p" id="mwCDc">{</span> <span class="w" id="mwCDg"> </span><span class="nx" id="mwCDk">Clubs</span><span class="w" id="mwCDo"> </span><span class="o" id="mwCDs">=</span><span class="w" id="mwCDw"> </span><span class="mf" id="mwCD0">1</span><span class="p" id="mwCD4">,</span><span class="w" id="mwCD8"> </span> <span class="w" id="mwCEA"> </span><span class="nx" id="mwCEE">Diamonds</span><span class="w" id="mwCEI"> </span><span class="o" id="mwCEM">=</span><span class="w" id="mwCEQ"> </span><span class="mf" id="mwCEU">2</span><span class="p" id="mwCEY">,</span><span class="w" id="mwCEc"> </span> <span class="w" id="mwCEg"> </span><span class="nx" id="mwCEk">Hearts</span><span class="w" id="mwCEo"> </span><span class="o" id="mwCEs">=</span><span class="w" id="mwCEw"> </span><span class="mf" id="mwCE0">4</span><span class="p" id="mwCE4">,</span><span class="w" id="mwCE8"> </span> <span class="w" id="mwCFA"> </span><span class="nx" id="mwCFE">Spades</span><span class="w" id="mwCFI"> </span><span class="o" id="mwCFM">=</span><span class="w" id="mwCFQ"> </span><span class="mf" id="mwCFU">8</span> <span class="p" id="mwCFY">};</span> <span class="kd" id="mwCFc">let</span><span class="w" id="mwCFg"> </span><span class="nx" id="mwCFk">c</span><span class="o" id="mwCFo">:</span><span class="w" id="mwCFs"> </span><span class="kt" id="mwCFw">CardSuit</span><span class="w" id="mwCF0"> </span><span class="o" id="mwCF4">=</span><span class="w" id="mwCF8"> </span><span class="nx" id="mwCGA">CardSuit</span><span class="p" id="mwCGE">.</span><span class="nx" id="mwCGI">Diamonds</span><span class="p" id="mwCGM">;</span>TypeScript supports mapping the numeric value to its name. For example, this finds the name of the value 2:
<span id="mwCGc"></span><span class="kd" id="mwCGg">enum</span><span class="w" id="mwCGk"> </span><span class="nx" id="mwCGo">CardSuit</span><span class="w" id="mwCGs"> </span><span class="p" id="mwCGw">{</span> <span class="w" id="mwCG0"> </span><span class="nx" id="mwCG4">Clubs</span><span class="w" id="mwCG8"> </span><span class="o" id="mwCHA">=</span><span class="w" id="mwCHE"> </span><span class="mf" id="mwCHI">1</span><span class="p" id="mwCHM">,</span><span class="w" id="mwCHQ"> </span> <span class="w" id="mwCHU"> </span><span class="nx" id="mwCHY">Diamonds</span><span class="p" id="mwCHc">,</span><span class="w" id="mwCHg"> </span> <span class="w" id="mwCHk"> </span><span class="nx" id="mwCHo">Hearts</span><span class="p" id="mwCHs">,</span><span class="w" id="mwCHw"> </span> <span class="w" id="mwCH0"> </span><span class="nx" id="mwCH4">Spades</span> <span class="p" id="mwCH8">};</span> <span class="kd" id="mwCIA">let</span><span class="w" id="mwCIE"> </span><span class="nx" id="mwCII">suitName</span><span class="o" id="mwCIM">:</span><span class="w" id="mwCIQ"> </span><span class="kt" id="mwCIU">string</span><span class="w" id="mwCIY"> </span><span class="o" id="mwCIc">=</span><span class="w" id="mwCIg"> </span><span class="nx" id="mwCIk">CardSuit</span><span class="p" id="mwCIo">[</span><span class="mf" id="mwCIs">2</span><span class="p" id="mwCIw">];</span> <span class="nx" id="mwCI0">alert</span><span class="p" id="mwCI4">(</span><span class="nx" id="mwCI8">suitName</span><span class="p" id="mwCJA">);</span><span class="w" id="mwCJE"> </span><span class="c1" id="mwCJI">// Diamonds</span>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.
<span id="mwCJo"></span><span class="kn" id="mwCJs">from</span><span class="w" id="mwCJw"> </span><span class="nn" id="mwCJ0">enum</span><span class="w" id="mwCJ4"> </span><span class="kn" id="mwCJ8">import</span> <span class="n" id="mwCKA">Enum</span> <span class="k" id="mwCKE">class</span><span class="w" id="mwCKI"> </span><span class="nc" id="mwCKM">CardSuit</span><span class="p" id="mwCKQ">(</span><span class="n" id="mwCKU">Enum</span><span class="p" id="mwCKY">):</span> <span class="n" id="mwCKc">CLUBS</span><span class="p" id="mwCKg">:</span> <span class="nb" id="mwCKk">int</span> <span class="o" id="mwCKo">=</span> <span class="mi" id="mwCKs">1</span> <span class="n" id="mwCKw">DIAMONDS</span><span class="p" id="mwCK0">:</span> <span class="nb" id="mwCK4">int</span> <span class="o" id="mwCK8">=</span> <span class="mi" id="mwCLA">2</span> <span class="n" id="mwCLE">HEARTS</span><span class="p" id="mwCLI">:</span> <span class="nb" id="mwCLM">int</span> <span class="o" id="mwCLQ">=</span> <span class="mi" id="mwCLU">3</span> <span class="n" id="mwCLY">SPADES</span><span class="p" id="mwCLc">:</span> <span class="nb" id="mwCLg">int</span> <span class="o" id="mwCLk">=</span> <span class="mi" id="mwCLo">4</span>
There is also a functional API for creating enumerations with automatically generated indices (starting with 1):
<span id="mwCL8"></span><span class="n" id="mwCMA">Cards</span><span class="p" id="mwCME">:</span> <span class="n" id="mwCMI">Enum</span> <span class="o" id="mwCMM">=</span> <span class="n" id="mwCMQ">Enum</span><span class="p" id="mwCMU">(</span><span class="s2" id="mwCMY">"Cards"</span><span class="p" id="mwCMc">,</span> <span class="s2" id="mwCMg">"CLUBS DIAMONDS HEARTS SPADES"</span><span class="p" id="mwCMk">)</span>
Python enumerations do not enforce semantic correctness (a meaningless comparison to an incompatible enumeration always returns False rather than raising a TypeError):
<span id="mwCM8"></span><span class="n" id="mwCNA">Color</span><span class="p" id="mwCNE">:</span> <span class="n" id="mwCNI">Enum</span> <span class="o" id="mwCNM">=</span> <span class="n" id="mwCNQ">Enum</span><span class="p" id="mwCNU">(</span><span class="s2" id="mwCNY">"Color"</span><span class="p" id="mwCNc">,</span> <span class="s2" id="mwCNg">"RED GREEN BLUE"</span><span class="p" id="mwCNk">)</span> <span class="n" id="mwCNo">Shape</span><span class="p" id="mwCNs">:</span> <span class="n" id="mwCNw">Enum</span> <span class="o" id="mwCN0">=</span> <span class="n" id="mwCN4">Enum</span><span class="p" id="mwCN8">(</span><span class="s2" id="mwCOA">"Shape"</span><span class="p" id="mwCOE">,</span> <span class="p" id="mwCOI">[</span><span class="s2" id="mwCOM">"CIRCLE"</span><span class="p" id="mwCOQ">,</span> <span class="s2" id="mwCOU">"TRIANGLE"</span><span class="p" id="mwCOY">,</span> <span class="s2" id="mwCOc">"SQUARE"</span><span class="p" id="mwCOg">,</span> <span class="s2" id="mwCOk">"HEXAGON"</span><span class="p" id="mwCOo">])</span> <span class="k" id="mwCOs">def</span><span class="w" id="mwCOw"> </span><span class="nf" id="mwCO0">has_vertices</span><span class="p" id="mwCO4">(</span><span class="n" id="mwCO8">shape</span><span class="p" id="mwCPA">:</span> <span class="n" id="mwCPE">Enum</span><span class="p" id="mwCPI">)</span> <span class="o" id="mwCPM">-></span> <span class="nb" id="mwCPQ">bool</span><span class="p" id="mwCPU">:</span> <span class="k" id="mwCPY">return</span> <span class="n" id="mwCPc">shape</span> <span class="o" id="mwCPg">!=</span> <span class="n" id="mwCPk">Shape</span><span class="o" id="mwCPo">.</span><span class="n" id="mwCPs">CIRCLE</span> <span class="k" id="mwCPw">if</span> <span class="vm" id="mwCP0">__name__</span> <span class="o" id="mwCP4">==</span> <span class="s2" id="mwCP8">"__main__"</span><span class="p" id="mwCQA">:</span> <span class="n" id="mwCQE">has_vertices</span><span class="p" id="mwCQI">(</span><span class="n" id="mwCQM">Color</span><span class="o" id="mwCQQ">.</span><span class="n" id="mwCQU">GREEN</span><span class="p" id="mwCQY">)</span> <span class="c1" id="mwCQc"># outputs "True"</span>
Dart
Dart has a support for the most basic form of enums, with a familiar syntax:
<span id="mwCQ0"></span><span class="hll" id="mwCQ4"><span class="linenos" data-line="1" id="mwCQ8"></span><span class="n" id="mwCRA">enum</span><span class="w" id="mwCRE"> </span><span class="n" id="mwCRI">CardSuit</span><span class="w" id="mwCRM"> </span><span class="p" id="mwCRQ">{</span> </span><span class="linenos" data-line="2" id="mwCRU"></span><span class="w" id="mwCRY"> </span><span class="n" id="mwCRc">Clubs</span><span class="p" id="mwCRg">,</span> <span class="linenos" data-line="3" id="mwCRk"></span><span class="w" id="mwCRo"> </span><span class="n" id="mwCRs">Diamonds</span><span class="p" id="mwCRw">,</span> <span class="linenos" data-line="4" id="mwCR0"></span><span class="w" id="mwCR4"> </span><span class="n" id="mwCR8">Hearts</span><span class="p" id="mwCSA">,</span> <span class="linenos" data-line="5" id="mwCSE"></span><span class="w" id="mwCSI"> </span><span class="n" id="mwCSM">Spades</span> <span class="linenos" data-line="6" id="mwCSQ"></span><span class="p" id="mwCSU">}</span> <span class="linenos" data-line="7" id="mwCSY"></span> <span class="linenos" data-line="8" id="mwCSc"></span><span class="kt" id="mwCSg">void</span><span class="w" id="mwCSk"> </span><span class="n" id="mwCSo">main</span><span class="p" id="mwCSs">()</span><span class="w" id="mwCSw"> </span><span class="p" id="mwCS0">{</span> <span class="linenos" data-line="9" id="mwCS4"></span><span class="w" id="mwCS8"> </span><span class="n" id="mwCTA">CardSuit</span><span class="w" id="mwCTE"> </span><span class="n" id="mwCTI">card</span><span class="w" id="mwCTM"> </span><span class="o" id="mwCTQ">=</span><span class="w" id="mwCTU"> </span><span class="n" id="mwCTY">CardSuit</span><span class="p" id="mwCTc">.</span><span class="n" id="mwCTg">Clubs</span><span class="p" id="mwCTk">;</span> <span class="linenos" data-line="10" id="mwCTo"></span> <span class="linenos" data-line="11" id="mwCTs"></span><span class="w" id="mwCTw"> </span><span class="c1" id="mwCT0">// Dart uses the "switch" operator to match the value of an enum with the desired output.</span> <span class="hll" id="mwCT4"><span class="linenos" data-line="12" id="mwCT8"></span><span class="w" id="mwCUA"> </span><span class="k" id="mwCUE">switch</span><span class="w" id="mwCUI"> </span><span class="p" id="mwCUM">(</span><span class="n" id="mwCUQ">card</span><span class="p" id="mwCUU">)</span><span class="w" id="mwCUY"> </span><span class="p" id="mwCUc">{</span> </span><span class="linenos" data-line="13" id="mwCUg"></span><span class="w" id="mwCUk"> </span><span class="k" id="mwCUo">case</span><span class="w" id="mwCUs"> </span><span class="n" id="mwCUw">CardSuit</span><span class="p" id="mwCU0">.</span><span class="nl" id="mwCU4">Clubs:</span><span class="w" id="mwCU8"> </span><span class="p" id="mwCVA">{</span> <span class="linenos" data-line="14" id="mwCVE"></span><span class="w" id="mwCVI"> </span><span class="n" id="mwCVM">print</span><span class="p" id="mwCVQ">(</span><span class="s2" id="mwCVU">"Clubs"</span><span class="p" id="mwCVY">);</span> <span class="linenos" data-line="15" id="mwCVc"></span><span class="w" id="mwCVg"> </span><span class="p" id="mwCVk">}</span> <span class="linenos" data-line="16" id="mwCVo"></span><span class="w" id="mwCVs"> </span><span class="k" id="mwCVw">break</span><span class="p" id="mwCV0">;</span> <span class="linenos" data-line="17" id="mwCV4"></span> <span class="linenos" data-line="18" id="mwCV8"></span><span class="w" id="mwCWA"> </span><span class="k" id="mwCWE">case</span><span class="w" id="mwCWI"> </span><span class="n" id="mwCWM">CardSuit</span><span class="p" id="mwCWQ">.</span><span class="nl" id="mwCWU">Diamonds:</span><span class="w" id="mwCWY"> </span><span class="p" id="mwCWc">{</span> <span class="linenos" data-line="19" id="mwCWg"></span><span class="w" id="mwCWk"> </span><span class="n" id="mwCWo">print</span><span class="p" id="mwCWs">(</span><span class="s2" id="mwCWw">"Diamonds"</span><span class="p" id="mwCW0">);</span> <span class="linenos" data-line="20" id="mwCW4"></span><span class="w" id="mwCW8"> </span><span class="p" id="mwCXA">}</span> <span class="linenos" data-line="21" id="mwCXE"></span><span class="w" id="mwCXI"> </span><span class="k" id="mwCXM">break</span><span class="p" id="mwCXQ">;</span> <span class="linenos" data-line="22" id="mwCXU"></span> <span class="linenos" data-line="23" id="mwCXY"></span><span class="w" id="mwCXc"> </span><span class="k" id="mwCXg">case</span><span class="w" id="mwCXk"> </span><span class="n" id="mwCXo">CardSuit</span><span class="p" id="mwCXs">.</span><span class="nl" id="mwCXw">Hearts:</span><span class="w" id="mwCX0"> </span><span class="p" id="mwCX4">{</span> <span class="linenos" data-line="24" id="mwCX8"></span><span class="w" id="mwCYA"> </span><span class="n" id="mwCYE">print</span><span class="p" id="mwCYI">(</span><span class="s2" id="mwCYM">"Hearts"</span><span class="p" id="mwCYQ">);</span> <span class="linenos" data-line="25" id="mwCYU"></span><span class="w" id="mwCYY"> </span><span class="p" id="mwCYc">}</span> <span class="linenos" data-line="26" id="mwCYg"></span><span class="w" id="mwCYk"> </span><span class="k" id="mwCYo">break</span><span class="p" id="mwCYs">;</span> <span class="linenos" data-line="27" id="mwCYw"></span> <span class="linenos" data-line="28" id="mwCY0"></span><span class="w" id="mwCY4"> </span><span class="k" id="mwCY8">case</span><span class="w" id="mwCZA"> </span><span class="n" id="mwCZE">CardSuit</span><span class="p" id="mwCZI">.</span><span class="nl" id="mwCZM">Spades:</span><span class="w" id="mwCZQ"> </span><span class="p" id="mwCZU">{</span> <span class="linenos" data-line="29" id="mwCZY"></span><span class="w" id="mwCZc"> </span><span class="n" id="mwCZg">print</span><span class="p" id="mwCZk">(</span><span class="s2" id="mwCZo">"Spades"</span><span class="p" id="mwCZs">);</span> <span class="linenos" data-line="30" id="mwCZw"></span><span class="w" id="mwCZ0"> </span><span class="p" id="mwCZ4">}</span> <span class="linenos" data-line="31" id="mwCZ8"></span><span class="w" id="mwCaA"> </span><span class="k" id="mwCaE">break</span><span class="p" id="mwCaI">;</span> <span class="linenos" data-line="32" id="mwCaM"></span> <span class="linenos" data-line="33" id="mwCaQ"></span><span class="w" id="mwCaU"> </span><span class="k" id="mwCaY">default</span><span class="o" id="mwCac">:</span><span class="w" id="mwCag"> </span><span class="p" id="mwCak">{</span> <span class="linenos" data-line="34" id="mwCao"></span><span class="w" id="mwCas"> </span><span class="n" id="mwCaw">print</span><span class="p" id="mwCa0">(</span><span class="s2" id="mwCa4">"Unknown"</span><span class="p" id="mwCa8">);</span> <span class="linenos" data-line="35" id="mwCbA"></span><span class="w" id="mwCbE"> </span><span class="p" id="mwCbI">}</span> <span class="linenos" data-line="36" id="mwCbM"></span><span class="w" id="mwCbQ"> </span><span class="k" id="mwCbU">break</span><span class="p" id="mwCbY">;</span> <span class="linenos" data-line="37" id="mwCbc"></span><span class="w" id="mwCbg"> </span><span class="p" id="mwCbk">}</span> <span class="linenos" data-line="38" id="mwCbo"></span><span class="p" id="mwCbs">}</span>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.
Other languages
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
<span id="mwCcs"></span><span class="k" id="mwCcw">enum</span><span class="p" id="mwCc0">,</span><span class="w" id="mwCc4"> </span><span class="k" id="mwCc8">bind</span><span class="p" id="mwCdA">(</span><span class="w" id="mwCdE"> </span><span class="n" id="mwCdI">C</span><span class="w" id="mwCdM"> </span><span class="p" id="mwCdQ">)</span> <span class="w" id="mwCdU"> </span><span class="k" id="mwCdY">enumerator</span><span class="w" id="mwCdc"> </span><span class="kd" id="mwCdg">::</span><span class="w" id="mwCdk"> </span><span class="n" id="mwCdo">CLUBS</span><span class="w" id="mwCds"> </span><span class="o" id="mwCdw">=</span><span class="w" id="mwCd0"> </span><span class="mi" id="mwCd4">1</span><span class="p" id="mwCd8">,</span><span class="w" id="mwCeA"> </span><span class="n" id="mwCeE">DIAMONDS</span><span class="w" id="mwCeI"> </span><span class="o" id="mwCeM">=</span><span class="w" id="mwCeQ"> </span><span class="mi" id="mwCeU">2</span><span class="p" id="mwCeY">,</span><span class="w" id="mwCec"> </span><span class="n" id="mwCeg">HEARTS</span><span class="w" id="mwCek"> </span><span class="o" id="mwCeo">=</span><span class="w" id="mwCes"> </span><span class="mi" id="mwCew">4</span><span class="p" id="mwCe0">,</span><span class="w" id="mwCe4"> </span><span class="n" id="mwCe8">SPADES</span><span class="w" id="mwCfA"> </span><span class="o" id="mwCfE">=</span><span class="w" id="mwCfI"> </span><span class="mi" id="mwCfM">8</span> <span class="k" id="mwCfQ">end enum</span>
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.
<span id="mwCfw"></span><span class="n" id="mwCf0">enumeration</span><span class="w" id="mwCf4"> </span><span class="k" id="mwCf8">type</span><span class="w" id="mwCgA"> </span><span class="kd" id="mwCgE">::</span><span class="w" id="mwCgI"> </span><span class="n" id="mwCgM">days_of_week</span> <span class="w" id="mwCgQ"> </span><span class="k" id="mwCgU">enumerator</span><span class="w" id="mwCgY"> </span><span class="kd" id="mwCgc">::</span><span class="w" id="mwCgg"> </span><span class="n" id="mwCgk">monday</span><span class="p" id="mwCgo">,</span><span class="w" id="mwCgs"> </span><span class="n" id="mwCgw">tuesday</span><span class="p" id="mwCg0">,</span><span class="w" id="mwCg4"> </span><span class="n" id="mwCg8">wednesday</span><span class="p" id="mwChA">,</span><span class="w" id="mwChE"> </span><span class="n" id="mwChI">thursday</span><span class="p" id="mwChM">,</span><span class="w" id="mwChQ"> </span><span class="n" id="mwChU">friday</span> <span class="w" id="mwChY"> </span><span class="k" id="mwChc">enumerator</span><span class="w" id="mwChg"> </span><span class="kd" id="mwChk">::</span><span class="w" id="mwCho"> </span><span class="n" id="mwChs">saturday</span><span class="p" id="mwChw">,</span><span class="w" id="mwCh0"> </span><span class="n" id="mwCh4">sunday</span> <span class="k" id="mwCh8">end </span><span class="n" id="mwCiA">enumeration</span><span class="w" id="mwCiE"> </span><span class="k" id="mwCiI">type</span> <span class="k" id="mwCiM">type</span><span class="w" id="mwCiQ"> </span><span class="p" id="mwCiU">(</span><span class="n" id="mwCiY">days_of_week</span><span class="p" id="mwCic">)</span><span class="w" id="mwCig"> </span><span class="kd" id="mwCik">::</span><span class="w" id="mwCio"> </span><span class="n" id="mwCis">dow</span> <span class="p" id="mwCiw">:</span> <span class="k" id="mwCi0">if</span><span class="w" id="mwCi4"> </span><span class="p" id="mwCi8">(</span><span class="n" id="mwCjA">dow</span><span class="w" id="mwCjE"> </span><span class="o" id="mwCjI">==</span><span class="w" id="mwCjM"> </span><span class="n" id="mwCjQ">wednesday</span><span class="p" id="mwCjU">)</span><span class="w" id="mwCjY"> </span><span class="k" id="mwCjc">then</span> <span class="k" id="mwCjg"> print</span><span class="w" id="mwCjk"> </span><span class="o" id="mwCjo">*</span><span class="p" id="mwCjs">,</span><span class="w" id="mwCjw"> </span><span class="s1" id="mwCj0">'hump day'</span> <span class="k" id="mwCj4">end if</span> <span class="p" id="mwCj8">:</span> <span class="k" id="mwCkA">select case</span><span class="w" id="mwCkE"> </span><span class="p" id="mwCkI">(</span><span class="n" id="mwCkM">dow</span><span class="p" id="mwCkQ">)</span> <span class="w" id="mwCkU"> </span><span class="k" id="mwCkY">case</span><span class="w" id="mwCkc"> </span><span class="p" id="mwCkg">(</span><span class="n" id="mwCkk">monday</span><span class="p" id="mwCko">:</span><span class="n" id="mwCks">friday</span><span class="p" id="mwCkw">)</span> <span class="w" id="mwCk0"> </span><span class="k" id="mwCk4">print</span><span class="w" id="mwCk8"> </span><span class="o" id="mwClA">*</span><span class="p" id="mwClE">,</span><span class="w" id="mwClI"> </span><span class="s1" id="mwClM">'weekday'</span> <span class="w" id="mwClQ"> </span><span class="k" id="mwClU">case</span><span class="w" id="mwClY"> </span><span class="p" id="mwClc">(</span><span class="n" id="mwClg">saturday</span><span class="p" id="mwClk">,</span><span class="w" id="mwClo"> </span><span class="n" id="mwCls">sunday</span><span class="p" id="mwClw">)</span> <span class="w" id="mwCl0"> </span><span class="k" id="mwCl4">print</span><span class="w" id="mwCl8"> </span><span class="o" id="mwCmA">*</span><span class="p" id="mwCmE">,</span><span class="w" id="mwCmI"> </span><span class="s1" id="mwCmM">'weekend'</span> <span class="k" id="mwCmQ">end select</span>
Microsoft Visual Basic family
Lisp
Common Lisp uses the member type specifier:
<span id="mwCtc"></span><span class="p" id="mwCtg">(</span><span class="nb" id="mwCtk">deftype</span><span class="w" id="mwCto"> </span><span class="nv" id="mwCts">cardsuit</span><span class="w" id="mwCtw"> </span><span class="p" id="mwCt0">()</span> <span class="w" id="mwCt4"> </span><span class="o" id="mwCt8">'</span><span class="p" id="mwCuA">(</span><span class="nb" id="mwCuE">member</span><span class="w" id="mwCuI"> </span><span class="nv" id="mwCuM">club</span><span class="w" id="mwCuQ"> </span><span class="nv" id="mwCuU">diamond</span><span class="w" id="mwCuY"> </span><span class="nv" id="mwCuc">heart</span><span class="w" id="mwCug"> </span><span class="nv" id="mwCuk">spade</span><span class="p" id="mwCuo">))</span>
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,
<span id="mwCvM"></span><span class="p" id="mwCvQ">(</span><span class="nb" id="mwCvU">deftype</span><span class="w" id="mwCvY"> </span><span class="nv" id="mwCvc">finite-element-set-type</span><span class="w" id="mwCvg"> </span><span class="p" id="mwCvk">(</span><span class="k" id="mwCvo">&rest</span><span class="w" id="mwCvs"> </span><span class="nv" id="mwCvw">elements</span><span class="p" id="mwCv0">)</span> <span class="w" id="mwCv4"> </span><span class="o" id="mwCv8">`</span><span class="p" id="mwCwA">(</span><span class="nb" id="mwCwE">member</span><span class="w" id="mwCwI"> </span><span class="o" id="mwCwM">,@</span><span class="nv" id="mwCwQ">elements</span><span class="p" id="mwCwU">))</span>
may be used to define arbitrary enumerated types at runtime. For instance,
<span id="mwCwk"></span><span class="p" id="mwCwo">(</span><span class="nv" id="mwCws">finite-element-set-type</span><span class="w" id="mwCww"> </span><span class="nv" id="mwCw0">club</span><span class="w" id="mwCw4"> </span><span class="nv" id="mwCw8">diamond</span><span class="w" id="mwCxA"> </span><span class="nv" id="mwCxE">heart</span><span class="w" id="mwCxI"> </span><span class="nv" id="mwCxM">spade</span><span class="p" id="mwCxQ">)</span>
would refer to a type equivalent to the prior definition of cardsuit, as of course would simply have been using
<span id="mwCxg"></span><span class="p" id="mwCxk">(</span><span class="nb" id="mwCxo">member</span><span class="w" id="mwCxs"> </span><span class="nv" id="mwCxw">club</span><span class="w" id="mwCx0"> </span><span class="nv" id="mwCx4">diamond</span><span class="w" id="mwCx8"> </span><span class="nv" id="mwCyA">heart</span><span class="w" id="mwCyE"> </span><span class="nv" id="mwCyI">spade</span><span class="p" id="mwCyM">)</span>
but may be less confusing with the function #'member for stylistic reasons.
In functional programming
In functional programming languages in the ML lineage (e.g., Standard ML (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):
<span id="mwCzE"></span><span class="kr" id="mwCzI">datatype</span> <span class="kt" id="mwCzM">cardsuit</span> <span class="p" id="mwCzQ">=</span> <span class="nc" id="mwCzU">Clubs</span> <span class="p" id="mwCzY">|</span> <span class="nc" id="mwCzc">Diamonds</span> <span class="p" id="mwCzg">|</span> <span class="nc" id="mwCzk">Hearts</span> <span class="p" id="mwCzo">|</span> <span class="nc" id="mwCzs">Spades</span> <span class="kr" id="mwCzw">type</span> <span class="kt" id="mwCz0">card</span> <span class="p" id="mwCz4">=</span> <span class="p" id="mwCz8">{</span> <span class="n" id="mwC0A">suit</span><span class="p" id="mwC0E">:</span> <span class="n" id="mwC0I">cardsuit</span><span class="p" id="mwC0M">;</span> <span class="n" id="mwC0Q">value</span><span class="p" id="mwC0U">:</span> <span class="n" id="mwC0Y">int</span> <span class="p" id="mwC0c">}</span> <span class="kr" id="mwC0g">val</span> <span class="nv" id="mwC0k">hand</span> <span class="p" id="mwC0o">:</span> <span class="n" id="mwC0s">card</span> <span class="n" id="mwC0w">list</span> <span class="kr" id="mwC00">val</span> <span class="nv" id="mwC04">trump</span> <span class="p" id="mwC08">:</span> <span class="n" id="mwC1A">cardsuit</span>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.
Databases
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.
<span id="mwC2A"></span><span class="k" id="mwC2E">CREATE</span><span class="w" id="mwC2I"> </span><span class="k" id="mwC2M">TABLE</span><span class="w" id="mwC2Q"> </span><span class="n" id="mwC2U">shirts</span><span class="w" id="mwC2Y"> </span><span class="p" id="mwC2c">(</span> <span class="w" id="mwC2g"> </span><span class="k" id="mwC2k">name</span><span class="w" id="mwC2o"> </span><span class="kt" id="mwC2s">VARCHAR</span><span class="p" id="mwC2w">(</span><span class="mi" id="mwC20">40</span><span class="p" id="mwC24">),</span> <span class="w" id="mwC28"> </span><span class="n" id="mwC3A">size</span><span class="w" id="mwC3E"> </span><span class="kt" id="mwC3I">ENUM</span><span class="p" id="mwC3M">(</span><span class="s1" id="mwC3Q">'x-small'</span><span class="p" id="mwC3U">,</span><span class="w" id="mwC3Y"> </span><span class="s1" id="mwC3c">'small'</span><span class="p" id="mwC3g">,</span><span class="w" id="mwC3k"> </span><span class="s1" id="mwC3o">'medium'</span><span class="p" id="mwC3s">,</span><span class="w" id="mwC3w"> </span><span class="s1" id="mwC30">'large'</span><span class="p" id="mwC34">,</span><span class="w" id="mwC38"> </span><span class="s1" id="mwC4A">'x-large'</span><span class="p" id="mwC4E">)</span> <span class="p" id="mwC4I">);</span>
JSON Schema
Can be defined in JSON schema using the "enum" key.
<span id="mwC4s"></span><span class="p" id="mwC4w">{</span> <span class="w" id="mwC40"> </span><span class="nt" id="mwC44">"$schema"</span><span class="p" id="mwC48">:</span><span class="w" id="mwC5A"> </span><span class="s2" id="mwC5E">"https://json-schema.org/draft/2020-12/schema"</span><span class="p" id="mwC5I">,</span> <span class="w" id="mwC5M"> </span><span class="nt" id="mwC5Q">"type"</span><span class="p" id="mwC5U">:</span><span class="w" id="mwC5Y"> </span><span class="s2" id="mwC5c">"object"</span><span class="p" id="mwC5g">,</span> <span class="w" id="mwC5k"> </span><span class="nt" id="mwC5o">"properties"</span><span class="p" id="mwC5s">:</span><span class="w" id="mwC5w"> </span><span class="p" id="mwC50">{</span> <span class="w" id="mwC54"> </span><span class="nt" id="mwC58">"cardsuit"</span><span class="p" id="mwC6A">:</span><span class="w" id="mwC6E"> </span><span class="p" id="mwC6I">{</span> <span class="w" id="mwC6M"> </span><span class="nt" id="mwC6Q">"type"</span><span class="p" id="mwC6U">:</span><span class="w" id="mwC6Y"> </span><span class="s2" id="mwC6c">"string"</span><span class="p" id="mwC6g">,</span> <span class="w" id="mwC6k"> </span><span class="nt" id="mwC6o">"enum"</span><span class="p" id="mwC6s">:</span><span class="w" id="mwC6w"> </span><span class="p" id="mwC60">[</span><span class="s2" id="mwC64">"Clubs"</span><span class="p" id="mwC68">,</span><span class="w" id="mwC7A"> </span><span class="s2" id="mwC7E">"Diamonds"</span><span class="p" id="mwC7I">,</span><span class="w" id="mwC7M"> </span><span class="s2" id="mwC7Q">"Hearts"</span><span class="p" id="mwC7U">,</span><span class="w" id="mwC7Y"> </span><span class="s2" id="mwC7c">"Spades"</span><span class="p" id="mwC7g">]</span> <span class="w" id="mwC7k"> </span><span class="p" id="mwC7o">}</span> <span class="w" id="mwC7s"> </span><span class="p" id="mwC7w">},</span> <span class="w" id="mwC70"> </span><span class="nt" id="mwC74">"required"</span><span class="p" id="mwC78">:</span><span class="w" id="mwC8A"> </span><span class="p" id="mwC8E">[</span><span class="s2" id="mwC8I">"cardsuit"</span><span class="p" id="mwC8M">]</span> <span class="p" id="mwC8Q">}</span>XML Schema
XML Schema supports enumerated types through the enumeration facet used for constraining most primitive datatypes such as strings.
<span id="mwC8o"></span><span class="nt" id="mwC8s"><xs:element</span><span class="w" id="mwC8w"> </span><span class="na" id="mwC80">name=</span><span class="s" id="mwC84">"cardsuit"</span><span class="nt" id="mwC88">></span> <span class="w" id="mwC9A"> </span><span class="nt" id="mwC9E"><xs:simpleType></span> <span class="w" id="mwC9I"> </span><span class="nt" id="mwC9M"><xs:restriction</span><span class="w" id="mwC9Q"> </span><span class="na" id="mwC9U">base=</span><span class="s" id="mwC9Y">"xs:string"</span><span class="nt" id="mwC9c">></span> <span class="w" id="mwC9g"> </span><span class="nt" id="mwC9k"><xs:enumeration</span><span class="w" id="mwC9o"> </span><span class="na" id="mwC9s">value=</span><span class="s" id="mwC9w">"Clubs"</span><span class="nt" id="mwC90">/></span> <span class="w" id="mwC94"> </span><span class="nt" id="mwC98"><xs:enumeration</span><span class="w" id="mwC-A"> </span><span class="na" id="mwC-E">value=</span><span class="s" id="mwC-I">"Diamonds"</span><span class="nt" id="mwC-M">/></span> <span class="w" id="mwC-Q"> </span><span class="nt" id="mwC-U"><xs:enumeration</span><span class="w" id="mwC-Y"> </span><span class="na" id="mwC-c">value=</span><span class="s" id="mwC-g">"Hearts"</span><span class="nt" id="mwC-k">/></span> <span class="w" id="mwC-o"> </span><span class="nt" id="mwC-s"><xs:enumeration</span><span class="w" id="mwC-w"> </span><span class="na" id="mwC-0">value=</span><span class="s" id="mwC-4">"Spades"</span><span class="nt" id="mwC-8">/></span> <span class="w" id="mwC_A"> </span><span class="nt" id="mwC_E"></xs:restriction></span> <span class="w" id="mwC_I"> </span><span class="nt" id="mwC_M"></xs:simpleType></span> <span class="nt" id="mwC_Q"></xs:element></span>

