Tipo enumerado

En programación informática , un tipo enumerado (también llamado enumeración , enumeración o factor en el lenguaje de programación R , y variable categórica en estadística) es un tipo de datos que consiste en un conjunto de valores nombrados llamados elementos , miembros , enumeral o enumeradores del tipo. Los nombres de los enumeradores suelen ser identificadores que se comportan como constantes en el lenguaje. Un tipo enumerado puede verse como una unión etiquetada degenerada de un tipo de unidad . A una variable que se ha declarado como que tiene un tipo enumerado se le puede asignar cualquiera de los enumeradores como valor. En otras palabras, un tipo enumerado tiene valores que son diferentes entre sí, y que se pueden comparar y asignar, pero que el programador no especifica que tengan una representación concreta particular en la memoria de la computadora; los compiladores e intérpretes pueden representarlos arbitrariamente.

Por ejemplo, los cuatro palos de una baraja de cartas pueden ser cuatro enumeradores llamados Trébol , Diamante , Corazón y Pica , que pertenecen a un tipo enumerado llamado palo . Si se declara una variable V que tiene como tipo de datos el palo , se le puede asignar cualquiera de esos cuatro valores.

Aunque los enumeradores suelen ser distintos, algunos lenguajes pueden permitir que el mismo enumerador se incluya dos veces en la declaración del tipo. Los nombres de los enumeradores no necesitan ser semánticamente completos o compatibles en ningún sentido. Por ejemplo, un tipo enumerado llamado color puede definirse para que conste de los enumeradores Red , Green , Zebra , Missing y Bacon . En algunos lenguajes, la declaración de un tipo enumerado también define intencionalmente un orden de sus miembros ( prioridades High , Medium y Low ); en otros, los enumeradores no están ordenados ( idiomas admitidos en inglés , francés , alemán y español ); en otros más, surge un orden implícito del compilador que representa concretamente a los enumeradores como números enteros.

Algunos tipos de enumeradores pueden estar integrados en el lenguaje. El tipo booleano , por ejemplo, suele ser una enumeración predefinida de los valores False y True . También se puede definir un tipo de unidad que consista en un único valor para representar null . Muchos lenguajes permiten a los usuarios definir nuevos tipos enumerados.

Los valores y las variables de un tipo enumerado se implementan generalmente con algún tipo entero como representación subyacente. Algunos lenguajes, especialmente los lenguajes de programación de sistemas , permiten al usuario especificar la combinación de bits que se utilizará para cada enumerador, lo que puede ser útil para representar de manera eficiente conjuntos de enumeradores como cadenas de bits de longitud fija. En la teoría de tipos , los tipos enumerados a menudo se consideran uniones etiquetadas de tipos de unidad . Dado que dichos tipos tienen la forma , también se pueden escribir como números naturales.${\displaystyle 1+1+\cpuntos +1}$

Algunos de los primeros lenguajes de programación no tenían originalmente tipos enumerados. Si un programador quería que una variable, por ejemplo myColor , tuviera un valor de rojo, se declaraba la variable red y se le asignaba un valor arbitrario, normalmente una constante entera. La variable red se asignaba entonces a myColor . Otras técnicas asignaban valores arbitrarios a cadenas que contenían los nombres de los enumeradores.

A estos valores arbitrarios se los denominaba a veces números mágicos, ya que no se explicaba con frecuencia cómo se obtenían o si sus valores reales eran significativos. Estos números mágicos podían dificultar la comprensión y el mantenimiento del código fuente por parte de otros usuarios.

Los tipos enumerados, por otro lado, hacen que el código sea más autodocumentado. Dependiendo del lenguaje, el compilador podría asignar automáticamente valores predeterminados a los enumeradores, ocultando así detalles innecesarios al programador. Estos valores pueden incluso no ser visibles para el programador (ver información sobre ocultación ). Los tipos enumerados también pueden evitar que un programador escriba código ilógico, como realizar operaciones matemáticas con los valores de los enumeradores. Si se tuviera que imprimir el valor de una variable a la que se le asignó un enumerador, algunos lenguajes de programación también podrían imprimir el nombre del enumerador en lugar de su valor numérico subyacente. Una ventaja adicional es que los tipos enumerados pueden permitir a los compiladores imponer la corrección semántica. Por ejemplo: myColor = TRIANGLE puede prohibirse, mientras que myColor = REDse acepta, incluso si TRIANGLE y RED se representan internamente como 1 .

En términos conceptuales, un tipo enumerado es similar a una lista de nominales (códigos numéricos), ya que a cada valor posible del tipo se le asigna un número natural distintivo. Un tipo enumerado dado es, por lo tanto, una implementación concreta de esta noción. Cuando el orden tiene sentido y/o se utiliza para la comparación, entonces un tipo enumerado se convierte en un tipo ordinal .

Los lenguajes de programación suelen tener sus propios estilos de programación y convenciones de nombres , a menudo múltiples . La variable asignada a una enumeración suele ser un sustantivo en forma singular y, con frecuencia, sigue una convención de PascalCase o mayúsculas , mientras que las minúsculas y otras se ven con menos frecuencia.

En Pascal , un tipo enumerado se puede declarar implícitamente enumerando los valores en una lista entre paréntesis:

 var palo : ( tréboles , diamantes , corazones , espadas ) ;     

La declaración a menudo aparecerá en una declaración de sinónimo de tipo, de modo que pueda usarse para múltiples variables:

 tipo palo de cartas = ( tréboles , diamantes , corazones , picas ) ; carta = registro palo : palo de cartas ; valor : 1 .. 13 ; fin ; var mano : matriz [ 1 .. 13 ] de carta ; triunfo : palo de cartas ;                            

El orden en el que se dan los valores de enumeración es importante. Un tipo enumerado es un tipo ordinal, y las funciones predy succdarán el valor anterior o siguiente de la enumeración, y ordpueden convertir los valores de enumeración a su representación entera. Sin embargo, el Pascal estándar no ofrece una conversión de tipos aritméticos a enumeraciones. El Pascal extendido ofrece esta funcionalidad a través de una succfunción extendida. Algunos otros dialectos de Pascal lo permiten a través de conversiones de tipos. Algunos descendientes modernos de Pascal, como Modula-3 , proporcionan una sintaxis de conversión especial utilizando un método llamado VAL; Modula-3 también trata BOOLEANa y CHARcomo tipos enumerados predefinidos especiales y utiliza ORDy VALpara la decodificación y codificación ASCII estándar.

Los lenguajes de estilo Pascal también permiten utilizar la enumeración como índice de matriz:

 var suitcount : matriz [ cardsuit ] de enteros ;     

En Ada , el uso de "=" fue reemplazado por "es", dejando la definición bastante similar:

El tipo  de palo de cartas  es  ( tréboles ,  diamantes ,  corazones ,  espadas );

Además de Pred, Succ, Valy PosAda también admite conversiones de cadenas simples a través de Imagey Value.

De manera similar a los lenguajes de estilo C, Ada permite especificar la representación interna de la enumeración:

para  uso de Cardsuit  ( tréboles => 1 , diamantes => 2 , corazones => 4 , picas => 8 );            

A diferencia de los lenguajes de estilo C, Ada también permite especificar la cantidad de bits de la enumeración:

Para  Cardsuit , tamaño:  use  4 ;  - 4 bits

Además, se pueden utilizar enumeraciones como índices para matrices, como en Pascal, pero hay atributos definidos para enumeraciones.

 Shuffle  :  matriz constante  ( Palo de cartas ) de Palo de cartas := ( Tréboles => Palo de cartas ' Succ ( Tréboles ), -- ver atributos de enumeraciones 'Primero, 'Último, 'Succ, 'Pred Diamantes => Corazones , --un valor explícito Corazones => Palo de cartas ' Último , --primer valor de enumeración de tipo Palo de cartas, p. ej., tréboles Picas => Palo de cartas ' Primero --último valor de enumeración de tipo Palo de cartas, p. ej., picas );                    

Al igual que Modula-3, Ada trata Booleanlos tipos enumerados Charactercomo predefinidos especiales (en el paquete " Standard"). A diferencia de Modula-3, también se pueden definir tipos de caracteres propios:

El tipo de  cartas  es  (' 7 ',  ' 8 ',  ' 9 ',  ' J ',  ' Q ',  ' K ',  ' A ');

El dialecto K&R original del lenguaje de programación C no tenía tipos enumerados. ^[1] En C, las enumeraciones se crean mediante definiciones explícitas (la enumpalabra clave por sí sola no causa la asignación de almacenamiento) que utilizan la enumpalabra clave y recuerdan a las definiciones de estructura y unión :

enum cardsuit { Tréboles , Diamantes , Corazones , Picas };      struct card { enum cardsuit suit ; short int value ; } hand [ 13 ];         enumeración del palo de cartas triunfo ;  

C expone la representación entera de los valores de enumeración directamente al programador. Los valores enteros y de enumeración se pueden mezclar libremente, y se permiten todas las operaciones aritméticas sobre valores de enumeración. Incluso es posible que una variable de enumeración contenga un entero que no represente ninguno de los valores de enumeración. De hecho, según la definición del lenguaje, el código anterior definirá Clubs, Diamonds, Hearts, y Spadescomo constantes de tipo int, que solo se convertirán (silenciosamente) a enum cardsuitsi se almacenan en una variable de ese tipo.

C también permite al programador elegir los valores de las constantes de enumeración explícitamente, incluso sin tipo. Por ejemplo,

enum cardsuit { Tréboles = 1 , Diamantes = 2 , Corazones = 4 , Picas = 8 };              

Podría usarse para definir un tipo que permita representar conjuntos matemáticos de palos mediante enum cardsuitoperaciones lógicas bit a bit.

Desde C23 , el programador puede especificar el tipo subyacente de una enumeración: ^[2]

enum cardsuit : char { Tréboles = 1 , Diamantes = 2 , Corazones = 4 , Picas = 8 };                

Los tipos enumerados en el lenguaje de programación C# conservan la mayor parte de la semántica de "enteros pequeños" de las enumeraciones de C. Algunas operaciones aritméticas no están definidas para las enumeraciones, pero un valor de enumeración se puede convertir explícitamente en un entero y viceversa, y una variable de enumeración puede tener valores que no fueron declarados por la definición de enumeración. Por ejemplo, dado

enum Cardsuit { Tréboles , Diamantes , Picas , Corazones }     

Las expresiones CardSuit.Diamonds + 1y CardSuit.Hearts - CardSuit.Clubsse permiten directamente (porque puede tener sentido recorrer la secuencia de valores o preguntar cuántos pasos hay entre dos valores), pero CardSuit.Hearts * CardSuit.Spadesse considera que tiene menos sentido y solo se permite si los valores se convierten primero en números enteros.

C# también ofrece la característica similar a C de poder definir valores enteros específicos para enumeraciones. Al hacer esto, es posible realizar operaciones binarias en enumeraciones, tratando así los valores de enumeración como conjuntos de indicadores. Estos indicadores se pueden probar mediante operaciones binarias o con el método incorporado 'HasFlag' del tipo Enum.

La definición de enumeración define nombres para los valores enteros seleccionados y es una sintaxis muy sencilla , ya que es posible asignar a una variable de enumeración otros valores enteros que no están dentro del alcance de la definición de enumeración. ^{[3] [4] [5]}

C++ tiene tipos de enumeración que se heredan directamente de C y funcionan en su mayoría como estos, excepto que una enumeración es un tipo real en C++, lo que brinda una verificación adicional en tiempo de compilación. Además (como con las estructuras), la enumpalabra clave de C++ se combina con un typedef , de modo que en lugar de nombrar el tipo enum name, simplemente lo nombramos name. Esto se puede simular en C usando un typedef:typedef enum {Value1, Value2} name;

C++11 también proporciona un segundo tipo de enumeración, llamada enumeración con ámbito . Estas son seguras en cuanto a tipos: los enumeradores no se convierten implícitamente a un tipo entero. Entre otras cosas, esto permite que se defina la transmisión de E/S para el tipo de enumeración. Otra característica de las enumeraciones con ámbito es que los enumeradores no se filtran, por lo que su uso requiere prefijar con el nombre de la enumeración (por ejemplo, Color::Redpara el primer enumerador en el ejemplo siguiente), a menos que se haya utilizado una using enumdeclaración (introducida en C++20 ) para llevar los enumeradores al ámbito actual. Una enumeración con ámbito se especifica mediante la frase enum class(o enum struct). Por ejemplo:

enumeración clase Color { Rojo , Verde , Azul };     

El tipo subyacente de una enumeración es un tipo integral definido por la implementación que es lo suficientemente grande como para contener todos los valores enumerados; no tiene que ser el tipo más pequeño posible. El tipo subyacente se puede especificar directamente, lo que permite "declaraciones futuras" de enumeraciones:

enum class Color : long { Red , Green , Blue }; // debe caber en tamaño y diseño de memoria el tipo 'long' enum class Shapes : char ; // declaración adelantada. Si más adelante hay valores definidos que no caben en 'char' es un error.             

Go usa la iotapalabra clave para crear constantes enumeradas. ^[6]

tipo ByteSize float64  const ( _ = iota // ignora el primer valor asignándolo al identificador en blanco KB ByteSize = 1 << ( 10 * iota ) MB GB )               

enumeración Color { rojo ; verde ; azul ; rgb ( r : Int , g : Int , b : Int ); }    clase Colores { función estática toInt ( c : Color ): Int { retorno switch ( c ) { caso rojo : 0xFF0000 ; caso verde : 0x00FF00 ; caso azul : 0x0000FF ; caso rgb ( r , g , b ): ( r << 16 ) | ( g << 8 ) | b ; } }                          función estática validCalls ( ) { var redint = toInt ( Color.red ) ; var rgbint = toInt ( Color.rgb ( 100,100,100 ) ) ; } }​​​​           

enumeración Opción < T > { Alguna ( v : T ); Ninguna ; }    enumeración Either < L , R > { Izquierda ( v : L ); Derecha ( v : R ); }     

La versión 5.0 J2SE del lenguaje de programación Java agregó tipos enumerados cuya sintaxis de declaración es similar a la de C :

enum Cardsuit { CLUBS , DIAMANTES , PICAS , CORAZONES }; ... Cardsuit triunfo ;        

Sin embargo, el sistema de tipos de Java trata las enumeraciones como un tipo separado de los enteros, y no se permite la combinación de valores de enumeración y enteros. De hecho, un tipo de enumeración en Java es en realidad una clase especial generada por el compilador en lugar de un tipo aritmético, y los valores de enumeración se comportan como instancias globales pregeneradas de esa clase. Los tipos de enumeración pueden tener métodos de instancia y un constructor (cuyos argumentos se pueden especificar por separado para cada valor de enumeración). Todos los tipos de enumeración extienden implícitamente la Enumclase abstracta. Un tipo de enumeración no se puede instanciar directamente. ^[12]

Internamente, cada valor de enumeración contiene un entero, correspondiente al orden en el que se declaran en el código fuente, comenzando desde 0. El programador no puede establecer un entero personalizado para un valor de enumeración directamente, pero uno puede definir constructores sobrecargados que luego pueden asignar valores arbitrarios a miembros autodefinidos de la clase de enumeración. La definición de captadores permite entonces el acceso a esos miembros autodefinidos. El entero interno se puede obtener de un valor de enumeración usando el ordinal()método, y la lista de valores de enumeración de un tipo de enumeración se puede obtener en orden usando el values()método. Generalmente se desaconseja que los programadores conviertan enumeraciones en enteros y viceversa. ^[13] Los tipos enumerados son Comparable, usando el entero interno; como resultado, se pueden ordenar.

La biblioteca estándar de Java proporciona clases de utilidad para usar con enumeraciones. La EnumSetclase implementa una Setde valores de enumeración; se implementa como una matriz de bits , lo que la hace muy compacta y tan eficiente como la manipulación explícita de bits, pero más segura. La EnumMapclase implementa una Mapde valores de enumeración para objeto. Se implementa como una matriz, con el valor entero del valor de enumeración que sirve como índice.

Los lenguajes tipados dinámicamente en la tradición sintáctica de C (por ejemplo, Perl o JavaScript ) no proporcionan enumeraciones en general. Pero en la programación Perl se puede obtener el mismo resultado con las cadenas abreviadas list y hashes (posiblemente slices ):

mi @enum = qw(Tréboles Diamantes Corazones Picas) ; mi ( %set1 , %set2 ); @set1 { @enum } = (); # todo borrado @set2 { @enum } = ( 1 ) x @enum ; # todo establecido en 1 $set1 { Tréboles } ... # falso $set2 { Diamantes } ... # verdadero                  

Raku (antes conocido como Perl 6) admite enumeraciones. Existen múltiples formas de declarar enumeraciones en Raku, y todas ellas crean un mapa de back-end.

enum  Cat  <sphynx siamés bengalí pelo corto otro> ; # Uso de "palabras citadas"

enum  Cat ( 'sphynx' , 'siamés' , 'bengala' , 'pelo corto' , 'otro' ); # Uso de una lista

enum  Cat ( sphynx => 0 , siamese => 1 , bengal => 2 , shorthair => 3 , other => 4 ); # Uso de constructores de pares

enum  Cat (: sphynx ( 0 ), : siamese ( 1 ), : bengal ( 2 ), shorthair ( 3 ), : other ( 4 )); # Otra forma de usar pares, también puedes usar `:0sphynx`

Las enumeraciones se agregaron en la versión 8.1 de PHP.

enum  CardSuit {  caso  Corazones ;  caso  Diamantes ;  caso  Tréboles ;  caso  Picas ; }

Los enumeradores pueden estar respaldados por cadenas o valores enteros para facilitar la serialización:

enum  CardSuit :  string {  caso  Corazones  =  'H' ;  caso  Diamantes  =  'D' ;  caso  Tréboles  =  'C' ;  caso  Picas  =  'S' ; }

La interfaz de Enum expone un método que proporciona una colección de sus enumeradores y sus nombres. Los Enums respaldados por cadenas o enteros también exponen el valor de respaldo y los métodos para (intentar) la deserialización. Los usuarios pueden agregar métodos adicionales.

Aunque Rust utiliza la enumpalabra clave como C, la utiliza para describir uniones etiquetadas , de las que las enumeraciones pueden considerarse una forma degenerada. Por lo tanto, las enumeraciones de Rust son mucho más flexibles y pueden contener variantes de estructuras y tuplas.

enumeración  Mensaje { Salir , Mover { x : i32 , y : i32 }, // estructura Write ( String ), // tupla de un solo elemento ChangeColor ( i32 , i32 , 32 ), // tupla de tres elementos }              

Al igual que C, Rust también admite la especificación de los valores de cada variante,

#[allow(dead_code)] pub enum Día de la semana { Domingo = 1 , Lunes = 2 , Martes = 4 , Miércoles = 8 , Jueves = 16 , Viernes = 32 , Sábado = 64 , }                        

En C, las enumeraciones asignan nombres relacionados a un conjunto de valores enteros. En Swift , las enumeraciones son mucho más flexibles y no necesitan proporcionar un valor para cada caso de la enumeración. Si se proporciona un valor (denominado valor sin formato ) para cada caso de enumeración, el valor puede ser una cadena, un carácter o un valor de cualquier tipo entero o de punto flotante.

Como alternativa, los casos de enumeración pueden especificar valores asociados de cualquier tipo que se almacenarán junto con cada valor de caso diferente, de forma muy similar a como lo hacen las uniones o variantes en otros lenguajes. Se puede definir un conjunto común de casos relacionados como parte de una enumeración, cada uno de los cuales tiene un conjunto diferente de valores de tipos apropiados asociados.

En Swift, las enumeraciones son un tipo de primera clase. Adoptan muchas características que tradicionalmente solo admitían las clases, como propiedades calculadas para proporcionar información adicional sobre el valor actual de la enumeración y métodos de instancia para proporcionar funcionalidad relacionada con los valores que representa la enumeración. Las enumeraciones también pueden definir inicializadores para proporcionar un valor de caso inicial y se pueden extender para expandir su funcionalidad más allá de su implementación original; y pueden cumplir con protocolos para proporcionar una funcionalidad estándar.

enum  CardSuit  {  caso  tréboles  caso  diamantes  caso  corazones  caso  picas }

A diferencia de C y Objective-C , a los casos de enumeración de Swift no se les asigna un valor entero predeterminado cuando se crean. En el ejemplo de CardSuit anterior, los tréboles, diamantes, corazones y picas no son implícitamente iguales a 0, 1, 2 y 3. En cambio, los diferentes casos de enumeración son valores completos por derecho propio, con un tipo de CardSuit definido explícitamente.

Pueden aparecer varios casos en una sola línea, separados por comas:

enum  CardSuit  {  caso  tréboles ,  diamantes ,  corazones ,  picas }

Al trabajar con enumeraciones que almacenan valores enteros o de cadena sin procesar, no es necesario asignar explícitamente un valor sin procesar para cada caso porque Swift asignará los valores automáticamente.

Por ejemplo, cuando se utilizan números enteros para valores sin formato, el valor implícito para cada caso es uno más que el caso anterior. Si el primer caso no tiene un valor definido, su valor es 0. En el ejemplo de CardSuit, los palos se pueden numerar a partir del 1 escribiendo:

enum  CardSuit  {  caso  tréboles  =  1 ,  diamantes ,  corazones ,  espadas }

TypeScript agrega un tipo de datos 'enum' a JavaScript.

enum Cardsuit { Tréboles , Diamantes , Corazones , Picas }; var c : Cardsuit = Cardsuit . Diamantes ;         

De manera predeterminada, las enumeraciones numeran a los miembros a partir de 0; esto se puede anular configurando el valor del primero:

enum Cardsuit { Tréboles = 1 , Diamantes , Corazones , Picas }; var c : Cardsuit = Cardsuit . Diamantes ;           

Se pueden configurar todos los valores:

enum Cardsuit { Tréboles = 1 , Diamantes = 2 , Corazones = 4 , Picas = 8 } ; var c : Cardsuit = Cardsuit.Diamantes ;​                 

TypeScript permite asignar el valor numérico a su nombre. Por ejemplo, esto busca el nombre del valor 2:

enum Cardsuit { Tréboles = 1 , Diamantes , Corazones , Picas }; var suitName : string = Cardsuit [ 2 ];           alerta ( suitName );

Se agregó un módulo de enumeración a la biblioteca estándar de Python en la versión 3.4.

de  enum  importar  Enum clase  Cartas ( Enum ):  TRÉBOLES  =  1  DIAMANTES  =  2  CORAZONES  =  3  PICAS  =  4

También hay una API funcional para crear enumeraciones con índices generados automáticamente (comenzando con uno):

Cartas  =  Enum ( "Cartas" ,  "TRÉBOLES DIAMANTES CORAZONES PICAS" )

Las enumeraciones de Python no imponen la corrección semántica (una comparación sin sentido con una enumeración incompatible siempre devuelve False en lugar de generar un TypeError ):

>>> Color  =  Enum ( "Color" ,  "ROJO VERDE AZUL" ) >>> Forma  =  Enum ( "Forma" ,  [ "CÍRCULO" ,  "TRIÁNGULO" ,  " CUADRADO" ,  "HEXÁGONO" ] ) >>> def  tiene_vértices ( forma ) : ... return  forma  ! =  Forma.CÍRCULO ... >>> tiene_vértices ( Color.VERDE ) True

Fortran solo tiene tipos enumerados para la interoperabilidad con C; por lo tanto, la semántica es similar a C y, como en C, los valores de enumeración son simplemente números enteros y no se realiza ninguna comprobación de tipo adicional. El ejemplo de C anterior se puede escribir en Fortran como

enumeración , enlace ( C ) enumerador :: TRÉBOLES = 1 , DIAMANTES = 2 , CORAZONES = 4 , PICAS = 8 fin enumeración                 

A los tipos de datos enumerados en Visual Basic (hasta la versión 6) y VBA se les asigna automáticamente el Longtipo de datos " " y también se convierten en un tipo de datos:

' Enumeración basada en cero CartaPalo Tréboles Diamantes Corazones Picas Fin de enumeración      Sub EnumExample () Dim suit As CardSuit suit = Diamonds MsgBox suit End Sub           

Código de ejemplo en VB.NET

Enum CardSuit Tréboles Diamantes Corazones Picas Fin de Enum      Sub EnumExample ( ) Dim suit As CardSuit suit = CardSuit.Diamonds MessageBox.show ( suit ) End Sub​​​          

Common Lisp utiliza el especificador de tipo de miembro, por ejemplo,

( deftype cardsuit () ' ( miembro club diamante corazón pica ))       

que indica que el objeto es de tipo cardsuit si es #'eqlde trébol, diamante, corazón o pica. Sin embargo, el especificador de tipo de miembro no es válido como un especializador de parámetros del Common Lisp Object System (CLOS). En su lugar, se puede utilizar (eql atom), que es el equivalente a (member atom)(es decir, solo se puede especificar un miembro del conjunto con un especificador de tipo eql, sin embargo, se puede utilizar como un especializador de parámetros CLOS). En otras palabras, para definir métodos que cubran un tipo enumerado, se debe definir un método para cada elemento específico de ese tipo.

Además,

( deftype tipo-conjunto-de-elementos-finitos ( &resto elementos ) ` ( miembro ,@ elementos ))     

se puede utilizar para definir tipos enumerados arbitrarios en tiempo de ejecución. Por ejemplo

( trébol de cuatro puntas, diamante, corazón, pica , conjunto de elementos finitos )    

se referiría a un tipo equivalente a la definición anterior de cardsuit, ya que, por supuesto, simplemente se habría utilizado

( miembro del club diamante corazón espada )    

pero puede ser menos confuso con la función #'memberpor razones estilísticas.

Dart tiene soporte para la forma más básica de enumeraciones y tiene una sintaxis muy similar a la de otros lenguajes que admiten enumeraciones.

enumeración CardSuite {   Clubes , Diamantes , Corazones , Espadas}vacío principal () {   tarjeta CardSuite = CardSuite . Clubs ;    // Dart utiliza el operador "switch" para hacer coincidir el valor de una enumeración con la salida deseada. interruptor ( tarjeta ) {   caso CardSuite . Tréboles: {   imprimir ( "Clubes" ); } romper ; caso CardSuite . Diamantes: {   imprimir ( "Diamantes" ); } romper ; caso CardSuite . Corazones: {   imprimir ( "Corazones" ); } romper ; caso CardSuite . Picas: {   imprimir ( "Picas" ); } romper ; por defecto : {  imprimir ( "Desconocido" ); } romper ; }}

Tenga en cuenta que el operador switch no garantiza la integridad de los casos. Esto significa que si omite un caso, el compilador no generará un error.

En los lenguajes de programación funcional del linaje ML (por ejemplo, Standard ML (SML), OCaml y Haskell ), se puede usar un tipo de datos algebraicos con solo constructores nulos para implementar un tipo enumerado. Por ejemplo (en la sintaxis de las firmas SML):

tipo de datos  palo de cartas  =  Tréboles  |  Diamantes  |  Corazones  |  Picas tipo  carta  =  {  palo :  palo de cartas ;  valor :  int  } val  mano  :  lista de cartas  val triunfo : palo de cartas   

En estos lenguajes, la representación de números enteros pequeños está completamente oculta para el programador, si es que la implementación utiliza dicha representación. Sin embargo, Haskell tiene la Enum clase de tipo que un tipo puede derivar o implementar para obtener una correspondencia entre el tipo y Int.

Algunas bases de datos admiten directamente los tipos enumerados. MySQL proporciona un tipo enumerado ENUMcon valores permitidos especificados como cadenas cuando se crea una tabla. Los valores se almacenan como índices numéricos con la cadena vacía almacenada como 0, el primer valor de cadena almacenado como 1, el segundo valor de cadena almacenado como 2, etc. Los valores se pueden almacenar y recuperar como índices numéricos o valores de cadena. ^[14]

Ejemplo:

CREAR TABLA camisas ( nombre VARCHAR ( 40 ), talla ENUM ( 'x-small' , 'small' , 'medium' , 'large' , 'x-large' ) );           

El esquema XML admite tipos enumerados a través de la faceta de enumeración utilizada para restringir la mayoría de los tipos de datos primitivos, como las cadenas.

<xs:element name= "cardsuit" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:enumeration value= "Tréboles" /> <xs:enumeration value= "Diamantes" /> <xs:enumeration value= "Corazones" /> <xs:enumeration value= "Picas" /> </xs:restriction> </xs:simpleType> </xs:element>              

• Conjunto de contraste

El Wikilibro de Programación Ada tiene una página sobre el tema: Enumeración

• Tipos enumerados en C/C++
• Tipos enumerados en C#
• Tipos enumerados en Java
• Tipos enumerados en MySQL
• Tipos enumerados en Obix
• Tipos enumerados en PHP
• Tipos enumerados en Swift
• Tipos enumerados en XML
• Tipos enumerados en Visual Basic