Enumerations: Difference between revisions

{{task|Basic language learning}}

 

Create an enumeration of constants with and without explicit values.

 

=={{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

<pre>

It is a cherry # +4

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

<pre>

It is a Cherry

 

=={{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|Bracmat}}==

'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 sharp|C#}}==

 

enum fruits { apple = 0, banana = 1, cherry = 2 }

 

[FlagsAttribute]

 

Placing FlagsAttribute before an enum allows you to perform bitwise operations on the value.

Note: All enums have a value of 0 defined, even if not specified in the set values.

 

=={{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}}==

 

 

 

 

 

=={{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|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|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|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

 

const (

banana fruit = 1

cherry fruit = 2

 

=={{header|Groovy}}==

Enumerations:

 

enum ValuedFruit {

 

println Fruit.values()

 

<pre>[apple, banana, cherry]

[apple(1), banana(2), cherry(3)]</pre>

 

=={{header|Haskell}}==

 

=={{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.

 

=={{header|JavaScript}}==

 

 

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

 

 

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)

 

<pre>

c=3

</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|Objeck}}==

enum Color := -3 {

Red,

Terrier

}

 

=={{header|OCaml}}==

| Apple

| Banana

 

=={{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|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|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

 

=={{header|Python}}==

{{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)].

 

say

Yes! We have no bananas today.

 

fruit quantity

watermelon 0.5

</pre>

 

=={{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

 

=={{header|Rust}}==

Apple,

Banana,

Cherry

 

=={{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|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

<pre>

test

 

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

Enum fruits

apple

banana = 1

cherry = 2

 

=={{header|XPL0}}==

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

 

{{omit from|PARI/GP}}

{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have user-defined data structures. -->

{{omit from|ZX Spectrum Basic}} <!-- It is not worthwhile enumerating, because variable names are single letters -->