Enumerations: Difference between revisions

Create an enumeration of constants with and without explicit values.

<br><br>

 

=={{header|ACL2}}==

ACL2 doesn't have built-in enumerated types, but these macros add some basic support:

 

(intern (concatenate 'string "*" (symbol-name sym) "*")

"ACL2"))

 

(defmacro enum (&rest symbols)

 

=={{header|Ada}}==

Ada enumeration types have three distinct attributes, the enumeration literal, the enumeration position, and the representation value. The position value (starting with 0) is implied from the order of specification of the enumeration literals in the type declaration; it provides the ordering for the enumeration values. In the example below, apple (position 0) is less than banana (position 1) which is less than cherry (position 3) due to their positions, not due to their enumeration literal. An enumeration representation, when given, must not violate the order.

Ada enumeration types are non-numeric discrete types. They can be used to index arrays, but there are no arithmetic operators for enumeration types; instead, there are predecessor and successor operations. Characters are implemented as an enumeration type in Ada.

 

compatible with INT and so FRUITS inherit/share all INT's operators

and procedures.

MODE FRUIT = INT;

FRUIT apple = 1, banana = 2, cherry = 4;

SKIP # other values #

ESAC

{{out}}

<pre>

least REPR (or ABS for INT type) must be defined if anything other then a

'''case''' conditional clause is required.

MODE ENUM = [0]CHAR; # something with minimal size #

MODE APPLE = STRUCT(ENUM apple), BANANA = STRUCT(ENUM banana), CHERRY = STRUCT(ENUM cherry);

SKIP # uninitialised FRUIT #

ESAC

{{out}}

<pre>

 

=={{header|AmigaE}}==

 

PROC main()

ForAll({x}, [APPLE, BANANA, CHERRY],

`WriteF('\d\n', x))

 

writes 0, 1, 2 to the console.

=={{header|AutoHotkey}}==

AutoHotkey doesn't really enforce types. <br>

However you can simulate types like enumeration with associative arrays:

fruit_%banana% = 1

 

=={{header|AWK}}==

In awk we can use an array, for mapping both ways, or initialize variables:

fruit[1]="apple"; fruit[2]="banana"; fruit[3]="cherry"

 

=={{header|BASIC}}==

 

{{works with|PB|7.1}}

OPTION BASE 1

DIM SHARED fruitsName$(1 to 3)

apple% = 1

banana% = 2

 

==={{header|BaCon}}===

BaCon includes an ENUM statement, with or without fixed values. If no value is given, enumerations start at zero and increase by integer 1.

 

' Start at zero

ENUM

sunday=7, monday=1, tuesday, wednesday, thursday, friday, saturday

END ENUM

 

{{out}}

'Create a collection of constants that is a complete, ordered listing of all of the constants in that collection, with and without explicit values.'

In Bracmat, each expression is a constant and can be used in situations where one would use an enum in other languages. All expressions have an ordering in sums and products. In the case of non-numeric strings the ordering is alphabetic. It is not possible in Bracmat to have a constant without an explicit value, because the constant is nothing but the value, so only half of the task can be solved.

 

=={{header|C}}==

 

 

However, if defined like the above, in C you must use the type as <code>enum fruits</code>, not just <code>fruits</code>. A common practice in C (same with <code>struct</code>s) is to instead typedef the enum so you can refer to the type as a bare name:

 

 

 

=={{header|C++}}==

 

Note that, unlike in C, you can refer to the type here as <code>fruits</code>.

 

{{works with|C++11}}

C++11 introduced "strongly typed enumerations", enumerations that cannot be implicitly converted to/from integers:

 

 

These enumeration constants must be referred to as <code>fruits::apple</code>, not just <code>apple</code>.

 

You can explicitly specify an underlying type for the enum; the default is <code>int</code>:

 

You can also explicitly specify an underlying type for old-style enums:

 

=={{header|Clojure}}==

In Clojure you will typically use keywords when you would use enums in other languages. Keywords are symbols that start with a colon and evaluate to themselves. For example:

(def fruits #{:apple :banana :cherry})

 

 

(println (fruit? :apple))

=={{header|Common Lisp}}==

Values:

 

(defconstant +apple+ 0)

(defconstant +banana+ 1)

;; number to symbol

(defun index-fruit (i)

Of course, the two definitions above can be produced by a single macro, if desired.

 

Defining a type for documentation or checking purposes:

 

 

=={{header|D}}==

// Named enumeration (commonly used enum in D).

// The underlying type is a 32 bit int.

// Use the & operator between BitFlags for intersection.

assert (flagsGreen == (flagsRedGreen & flagsBlueGreen));

 

=={{header|Delphi}}==

 

 

 

 

=={{header|DWScript}}==

 

 

=={{header|E}}==

Simple group of object definitions (value methods could be left out if appropriate):

 

def banana { to value() { return 1 } }

With a guard for type checks:

def apple implements FruitStamp {}

def banana implements FruitStamp {}

def cherry implements FruitStamp {}

 

With and without values, using a hypothetical enumeration library:

 

def [Fruit, [=> apple, => banana, => cherry]] :=

 

=={{header|EGL}}==

{{works with|EDT}}

enumeration FruitsKind

APPLE,

end

 

{{works with|EDT}}

-and-

{{works with|RBD}}

library FruitsKind type BasicLibrary {}

const APPLE int = 0;

end

 

=={{header|Elixir}}==

It is possible to use a atom if the value is unrelated.

fruits = ~w(apple banana cherry)a # Above-mentioned different notation

val = :banana

Enum.member?(fruits, val) #=> true

 

If they have to have a specific value

fruits = [apple: 1, banana: 2, cherry: 3] # Above-mentioned different notation

fruits[:apple] #=> 1

fruits[:apple] #=> 1

fruits.apple #=> 1 (Only When the key is Atom)

 

To give a number in turn, there is the following method.

fruits = ~w(apple banana cherry)a |> Enum.with_index

#=> [apple: 0, banana: 1, cherry: 2]

# Map

fruits = ~w(apple banana cherry)a |> Enum.with_index |> Map.new

 

=={{header|Erlang}}==

For the unspecific value enum use case, Erlang has atoms. You can use apple, banana, orange directly in the code.

If they have to have a specific value they could be grouped like this: {apple, 1}, {banana, 3}, {orange, 8}

 

=={{header|Factor}}==

 

Enumerations are essentially association lists with values (keys) assigned sequentially from constants (values) provided by an initial sequence.

 

--- Data stack:

--- Data stack:

"mon"

Factor also provides C-like enumerations in its C library interface. These enumerations may have explicit values.

IN: scratchpad ENUM: day sun mon { tue 42 } wed thur fri sat ;

IN: scratchpad 1 <day>

--- Data stack:

mon

 

=={{header|Fantom}}==

Enumerations with named constants:

 

// create an enumeration with named constants

enum class Fruits { apple, banana, orange }

 

A private constructor can be added to initialise internal fields, which must be constant.

 

// create an enumeration with explicit values

enum class Fruits_

private new make (Int value) { this.value = value }

}

 

=={{header|Forth}}==

Forth has no types, and therefore no enumeration type. To define sequential constants, a programmer might write code like this:

 

1 CONSTANT banana

2 CONSTANT cherry

However, a common idiom in forth is to define a defining word, such as:

This word defines a new constant of the value specified and returns the next value in sequence.

It would be used like this:

 

 

Or you can use CONSTANT to capture the "end" value instead of dropping it:

 

 

A variation of this idea is the "stepped enumeration" that increases the value by more than 1, such as:

 

 

A programmer could combine these enum definers in any way desired:

 

CELL-ENUM SECOND \ value = 1

ENUM THIRD \ value = 5

3 SIZED-ENUM FOURTH \ value = 6

ENUM FIFTH \ value = 9

 

Note that a similar technique is often used to implement structures in Forth.

 

For a simple zero-based sequence of constants, one could use a loop in the defining word:

 

\ resistor digit colors

=={{header|Fortran}}==

{{works with|Fortran|2003}}

enumerator :: one=1, two, three, four, five

enumerator :: six, seven, nine=9

 

The syntax

 

enumerator :: one=1, two, three

 

does not work with gfortran; it is used in some [http://docs.cray.com/books/S-3692-51/html-S-3692-51/z970507905n9123.html Cray docs] about Fortran, but the syntax shown at [http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=/com.ibm.xlf101a.doc/xlflr/enum.htm IBM] is the one gfortran can understand. (Cray's docs refer to Fortran 2003 draft, IBM docs refers to Fortran 2003 standard, but read the brief [http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/topic/com.ibm.xlf101a.doc/xlflr/languagestandards.htm#wq17 Fortran 2003 Standard] section to understand why differences may exist...)

 

=={{header|FreeBASIC}}==

 

Enum Animals

Print Cat, Dog, Zebra

Print Bulldog, Terrier, WolfHound

 

{{out}}

1 2 4

</pre>

 

=={{header|FutureBasic}}==

 

begin enum 1

end enum

 

print

 

Output

=={{header|Go}}==

Go's enumeration-like feature is called iota. It generates sequential integer constants.

apple = iota

banana

cherry

The above is equivalent to,

apple = 0

banana = 1

cherry = 2

Constants in Go are not typed they way variables are, they are typed when used just like literal constants.

Here is an example of a type safe enumeration:

 

const (

banana

cherry

And using explicit values (note each constant must be individual typed here unlike with iota):

 

const (

banana fruit = 1

cherry fruit = 2

 

=={{header|Groovy}}==

Enumerations:

 

enum ValuedFruit {

 

println Fruit.values()

 

{{out}}

 

=={{header|Haskell}}==

 

=={{header|Huginn}}==

APPLE,

BANANA,

CHERRY

 

=={{header|Inform 7}}==

 

Inform 7 doesn't have conversions between enumerated values and numbers, but you can assign properties to enumerated values:

Fruit is a kind of value. The fruits are apple, banana, and cherry.

A fruit has a number called numeric value.

The numeric value of apple is 1.

The numeric value of banana is 2.

Fruit is a kind of value. The fruits are defined by the Table of Fruits.

 

apple 1

banana 2

 

=={{header|J}}==

 

J's typing system is fixed, and so extensions occur at the application level. For example, one could create an object

( (;:'apple banana cherry') ,L:0 '__enum' ) =: i. 3

cherry__enum

 

But this is more akin to a "methodless class or object" than an enum in other languages.

 

That said, note that the "natural way", in J, of dealing with issues treated in other languages through enums is to use an array of names.

 

Now you can get the name associated with an index:

 

+------+

|cherry|

 

And you can get the index associated with a name:

 

 

And you can define an arithmetic with the enum for its domain and range. Here, for example, is 2=1+1:

 

+------+

|cherry|

 

 

 

=={{header|Java}}==

{{works with|Java|1.5+}}

APPLE, BANANA, CHERRY

Or:

APPLE(0), BANANA(1), CHERRY(2)

private final int value;

fruits(int value) { this.value = value; }

public int value() { return value; }

Conventionally, enums have the same case rules as classes, while enum values are in all caps (like other constants). All cases are allowed for both names, though, as long as they don't conflict with other classes in the same package.

 

In javascript, usually used for this a strings.

 

// enum fruits { apple, banana, cherry }

 

f = "banana";

}

 

=={{header|jq}}==

 

def fruits: {apple, banana, cherry}; # i.e. {"apple" : null, "banana": null, "cherry": null }

 

=={{header|JScript.NET}}==

 

=={{header|Julia}}==

@enum Fruits APPLE BANANA CHERRY

 

{{out}}

 

=={{header|Kotlin}}==

 

enum class Animals {

println()

for (value in Dogs.values()) println("${value.name.padEnd(9)} : ${value.id}")

 

{{out}}

Lingo neither knows the concept of enumerations nor of constants. But an enumeration-like hash (property list) that is immutable concerning standard list methods and operators can be created by sub-classing a property list and overwriting list/property list access methods (which also overwrites bracket access operators on the fly):

 

 

property ancestor

on addProp (me)

-- do nothing

 

 

put enumeration["BANANA"]

enumeration.addProp("FOO", 666)

put enumeration["FOO"]

 

=={{header|Lua}}==

An explicit enum can be formed by mapping strings to numbers

 

local fruit = {apple = 0, banana = 1, cherry = 2}

 

or simply by local variables.

 

local apple, banana, cherry = 0,1,2

 

Although since Lua strings are interned, there is as much benefit to simply using strings.

 

=={{header|M4}}==

`define(`$2',$1)`'ifelse(eval($#>2),1,`enums(incr($1),shift(shift($@)))')')

define(`enum',

`enums(1,$@)')

enum(a,b,c,d)

 

{{out}}

</pre>

 

Enumerations are not very useful in a symbolic language like Mathematica. If desired, an 'enum' function could be defined :

->{{1}, {2}, {3}, {4}}

 

 

G

 

=={{header|MATLAB}} / {{header|Octave}}==

Enumeration is done by creating a cell array (a.k.a set) of objects, where the numeral of the object is its index in the 1-based cell array. The cell array structure can contain any type of data structure including other cell arrays, and all members don't have to be the same data type.

 

Example:

 

stuff =

 

 

=={{header|Metafont}}==

Metafont has no an enumeration type. However we can define an useful macro to simulate an enumeration. E.g.

save ?; ? := first;

forsuffixes e := t: e := ?; ?:=?+1; endfor

 

Usage example:

 

enum(5, Orange, Pineapple, Qfruit);

show Apple, Banana, Cherry, Orange, Pineapple, Qfruit;

 

=={{header|Modula-3}}==

The values are accessed by qualifying their names.

You can get an element's position in the enumeration by using <code>ORD</code> and get the element given the position by using <code>VAL</code>.

 

=={{header|Nemerle}}==

|apple

|banana

|summer = 3

|autumn = 4

 

=={{header|Nim}}==

 

 

 

 

=={{header|Objeck}}==

enum Color := -3 {

Red,

Terrier

}

 

=={{header|Objective-C}}==

With iOS 6+ SDK / Mac OS X 10.8+ SDK:

 

 

=={{header|OCaml}}==

| Apple

| Banana

 

=={{header|Oforth}}==

Symbols begin with $. If the symbol does not exists yet, it is created.

 

 

=={{header|Oz}}==

Most of the time you will just use atoms where you would use enums in C. Atoms start with a lower-case letter and are just symbols that evaluate to themselves. For example:

fun {IsFruit A}

{Member A [apple banana cherry]}

end

in

 

If you need constants with increasing values, you could just enumerate them manually:

Apple = 1

Banana = 2

 

Or you could write a procedure that does the job automatically:

proc {Enumeration Xs}

Xs = {List.number 1 {Length Xs} 1}

[Apple Banana Cherry] = {Enumeration}

in

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

my @fruits = qw(apple banana cherry);

 

# Using a hash

 

=={{header|Phix}}==

 

=={{header|PHP}}==

$fruits = array( "apple", "banana", "cherry" );

$fruits = array( "apple" => 0, "banana" => 1, "cherry" => 2 );

define("FRUIT_APPLE", 0);

define("FRUIT_BANANA", 1);

 

=={{header|PicoLisp}}==

Enumerations are not very useful in a symbolic language like PicoLisp. If

desired, an 'enum' function could be defined:

And used in this way:

<pre>: A

-> 1

 

=={{header|PL/I}}==

define ordinal animal (frog, gnu, elephant, snake);

 

define ordinal color (red value (1), green value (3), blue value (5));

 

=={{header|PowerShell}}==

Without explicit values.

{{works with|PowerShell|5}}

Enum fruits {

Apple

[fruits]::Apple + 1

[fruits]::Banana + 1

<b>Output:</b>

<pre>

With explicit values.

{{works with|PowerShell|5}}

Enum fruits {

Apple = 10

[fruits]::Apple + 1

[fruits]::Banana + 1

<pre>

Apple

16

</pre>

 

=={{header|PureBasic}}==

Basic Enumeration is defined as

#Apple

#Banana

#Cherry

This can also be adjusted to the form

#Constant1 ; 10200

#Constant2 ; 10212

#Constant4 = 10117 ; 10117

#Constant5 ; 10229

The system constant "#PB_Compiler_EnumerationValue" holds last defined value and can be used to chain to a previously started series.

 

E.g. in combination with the code above;

#Constant_A ; 10241

#Constant_B ; 10242

 

Enumeration groups can also be named to allow continuation where a previous named group left off.

Enumeration NamedGroup 5

#Green ; 5

#Yellow ; 7

#Red ; 8

 

=={{header|Python}}==

Note: [http://www.python.org/dev/peps/pep-0435/ enumerations have come to Python version 3.4].

 

>>> Contact = Enum('Contact', 'FIRST_NAME, LAST_NAME, PHONE')

>>> Contact.__members__

>>> Contact2.__members__

mappingproxy(OrderedDict([('FIRST_NAME', <Contact2.FIRST_NAME: 1>), ('LAST_NAME', <Contact2.LAST_NAME: 2>), ('PHONE', <Contact2.PHONE: 3>)]))

 

===Python: Pre version 3.4===

{{works with|Python|2.5}}

There is no special syntax, typically global variables are used with range:

Alternately, the above variables can be enumerated from a list with no predetermined length.

 

=={{header|R}}==

R does not have an enumeration type, though factors provide a similar functionality.

# [1] apple banana cherry

[http://tolstoy.newcastle.edu.au/R/help/04/07/0368.html This thread] in the R mail archive contains code for an enum-like class for traffic light colours.

 

=={{header|Racket}}==

 

#lang racket

 

((ctype-c->scheme _fruits) 4) ; -> '(CHERRY)

((ctype-c->scheme _fruits) 5) ; -> '(APPLE CHERRY)

 

=={{header|Raven}}==

 

=={{header|Retro}}==

Retro has a library named '''enum'''' for creation of enumerated values.

 

 

 

=={{header|REXX}}==

<br>This REXX entry was kinda modeled after the '''BASIC''', '''Forth''', and

'''VBA''' [which does its own enumeration, as does REXX below (as an inventory count)].

fruit.=0 /*the default for all possible "FRUITS." (zero). */

fruit.apple = 65

end /*j*/

end /*p*/

'''output'''

<pre>

 

=={{header|Ring}}==

apple = 0

banana = 1

see "banana : " + banana + nl

see "cherry : " + cherry + nl

 

=={{header|Ruby}}==

There are plenty of ways to represent '''enum''' in Ruby. Here it is just one example:

APPLE = 0

BANANA = 1

FRUITS = [:apple, :banana, :cherry]

val = :banana

To give a number in turn, there is the following method.

# constants

SUITS = %i(Clubs Hearts Spades Diamonds)

# PIP_VALUE = Hash[ PIPS.each.with_index(2).to_a ] # before it

#=> {:"2"=>2, :"3"=>3, :"4"=>4, :"5"=>5, :"6"=>6, :"7"=>7, :"8"=>8, :"9"=>9, :"10"=>10, :Jack=>11, :Queen=>12, :King=>13, :Ace=>14}

 

=={{header|Rust}}==

Apple,

Banana,

// Access to numerical value by conversion

println!("{}", FruitsWithNumbers::Pear as u8);

 

=={{header|Scala}}==

'''1. Using Algebraic Data Types:'''

case object Apple extends Fruit

case object Banana extends Fruit

case object Cherry extends Fruit

'''2. Using scala.Enumeration:'''

val Apple, Banana, Cherry = Value

}

=={{header|Scheme}}==

(define banana 1)

(define cherry 2)

(or (equal? 'apple atom)

(equal? 'banana atom)

(This section needs attention from someone familiar with Scheme idioms.)

=={{header|Seed7}}==

apple, banana, cherry

=={{header|Shen}}==

 

(datatype fruit

if (element? Fruit [apple banana cherry])

_____________

 

=={{header|Sidef}}==

Implicit:

Explicit:

Apple=3,

Banana, # gets the value 4

Cherry="a",

Orange, # gets the value "b"

 

=={{header|Slate}}==

As just unique objects:

Fruit traits define: #Apple -> Fruit clone.

Fruit traits define: #Banana -> Fruit clone.

 

As labels for primitive values:

define: #Banana -> 2.

 

As a namespace:

 

Using a dictionary:

=={{header|Standard ML}}==

Apple

| Banana

 

=={{header|Swift}}==

case Apple

case Banana

case Summer = 3

case Autumn = 4

 

=={{header|Tcl}}==

It is normal in Tcl to use strings from a set directly rather than treating them as an enumeration, but enumerations can be simulated easily. The following elegant example comes straight from the [[http://wiki.tcl.tk/1308 Tcl wiki:]]

 

interp alias {} $name: {} lsearch $values

interp alias {} $name@ {} lindex $values

 

it would be used like this:

 

fruit: date

# ==> prints "3"

fruit@ 2

 

=={{header|Toka}}==

This library function takes a starting value and a list of names as shown in the example below.

 

0 enum| apple banana carrot |

 

=={{header|VBA}}==

Like Visual Basic .NET, actually:

'this enumerates from 0

Enum fruits

Debug.Print "cherry plus kiwi plus pineapple equals "; cherry + kiwi + pineapple

End Sub

{{out}}

<pre>

 

=={{header|Visual Basic .NET}}==

Enum fruits

apple

banana = 1

cherry = 2

 

=={{header|XPL0}}==

def Apple=1, Banana=2, Cherry=4;

 

=={{header|zkl}}==

Enums as thing or type is not supported but they can be simulated by running code at parse time (ie modify the AST before the compiler compiles it).

const RED =0xf00;

const BLUE=0x0f0, GREEN = 0x00f;

const CYAN=BLUE + GREEN; // → 0x0ff

}

{{out}}

<pre>240</pre>

 

const A=N,B=N,C=N; // --> 1,2,3

const{ _n=-1; } // reset Enum, this should be a const space function

Since const space runs at a different time [vs compile space], you need to really careful if you mix the two [spaces]:

z:=N; // -->2 NOT 1 as it is set AFTER Y (compile time vs parse time)

 

=={{header|zonnon}}==

module Enumerations;

type

end

end Enumerations.

{{Out}}

<pre>