Enumerations: Difference between revisions

 

=={{header|11l}}==

NAME

KEYWORD

CONSTANT

 

=={{header|6502 Assembly}}==

 

Keep in mind that these names do not exist at runtime and are just for the programmer's convenience. None of this "code" below actually takes up any space in the assembled program.

Monday equ 1

Tuesday equ 2

Thursday equ 4

Friday equ 5

 

Some assemblers have an actual <code>ENUM</code> directive, where only the 0th element needs a defined value and the rest follow sequentially. This is often used for allocating RAM locations rather than a [[C]]-style enumeration, however. <code>.DSB</code> is a directive that stands for "data storage byte" and is listed after the label so that the assembler knows how big the variable is. In the example below the variable <code>OBJECT_XPOS</code> begins at $0400 and <code>OBJECT_XPOS</code> begins at $0410:

OBJECT_XPOS .dsb 16 ;define 16 bytes for object X position

OBJECT_YPOS .dsb 16 ;define 16 bytes for object Y position

 

===Without Explicit Values===

A lookup table is the most common method of enumeration of actual data in assembly. Each element of the table can be accessed by an index, and the starting index is zero. (The index may need to be adjusted for data sizes larger than 1 byte, i.e. doubled for 16-bit data and quadrupled for 32-bit data.) Unlike the above example, these values do indeed take up memory. Using this method when the above enumeration would suffice is incredibly wasteful.

 

word Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday

 

LDY #0 ;clear Y

 

 

=={{header|68000 Assembly}}==

 

Keep in mind that these names do not exist at runtime and are just for the programmer's convenience. None of this "code" below actually takes up any space in the assembled program.

Monday equ 1

Tuesday equ 2

Thursday equ 4

Friday equ 5

 

 

Like in a [[C]]-style enumeration, Sunday would be 0, Monday 1, Tuesday 2, and so on. (Actually, Monday would be 4 and Tuesday would be 8 and so on, since these are 32-bit pointers.) It's a common practice to have the index live in RAM as a one-byte index, load it in a register, and then scale its register copy during the lookup process only. That way if multiple tables with different data sizes have a common index, the program doesn't need to remember which data type the index was last used to access.

 

DC.L Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday

 

LEA (A0,D0),A1 ;load table offset by D0 into A1

MOVE.L (A1),A1 ;dereference the pointer, now the address of "Thursday" is in A1.

 

=={{header|8086 Assembly}}==

===With Explicit Values===

Most assemblers allow the use of an <code>equ</code> directive or something similar, where you can assign a label to a number for later use. These do not take up space in your program.

Monday equ 1

Tuesday equ 2

Friday equ 5

Saturday equ 6

 

===Without Explicit Values===

A lookup table is often used to translate data according to a common index. The <code>XLAT</code> instruction can help us with this task, however that instruction only works with 8-bit data, which is not always what we're after. In this example, we're using numbers 0 through 7 to look up a table of pointers to strings. When declaring a table like this, these DO take up space in your program.

mov ds,ax

mov si,offset DaysOfTheWeek

 

DaysOfTheWeek word Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday

 

 

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

 

print "as a block of words:"

inspect.muted enum

]

print "\nas a dictionary:"

 

{{out}}

The wording of the task seems centered on C, where an '''enum''' is a notation for type '''int''', but it is true that the following type will be translated by the ATS compiler to C integers:

 

| value_a

| value_b

 

Within ATS itself, '''my_enum''' is a special case of recursive type definition. Similar facilities are available in ML dialects and other languages.

 

To "enumerate" with explicit integer values, I would simply define some constants, probably with '''#define''' (so I could use them in static expressions, etc.):

#define value_b 2

 

You could still restrict things so no other values were possible:

 

 

The value of a '''my_enum''' would be enforced ''at compile time''.

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

 

=={{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|Computer/zero Assembly}}==

Constants can be defined by simply storing their binary representation into memory. You've only got 32 bytes of RAM so don't waste them. This is the only way to use numeric values, as all instructions on the CPU take memory addresses as operands, not constants.

STP

NOP

NOP

The <code>NOP</code> and <code>STP</code> instructions ignore their operands, which means you can store arbitrary data inside those instructions that you can load from. This can save a little bit of memory.

 

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

In addition to [[#Pascal|standard Pascal]], one may explicitly specify an index:

fruit = (apple, banana, cherry);

Note, explicit indices ''have'' to be in ascending order.

You can also just specify explicit indices for ''some'' items.

 

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

=={{header|F_Sharp|F#}}==

Enumerations in F# always have explicit values:

| Apple = 0

| Banana = 1

 

let basket = [ Fruit.Apple ; Fruit.Banana ; Fruit.Cherry ]

 

If the initialization values are omitted, the resulting type is a discriminated union (algebraic data type) instead.

Simple discriminated unions can be used similarly to enumerations, but they are never convertible from and to integers, and their internal representation is quite different.

 

| Apple

| Banana

| Cherry

let basket = [ Apple ; Banana ; Cherry ]

 

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

 

=={{header|FutureBasic}}==

 

begin enum 1

print "_cherryExplicit = "; _cherryExplicit

 

 

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|Icon}} and {{header|Unicon}}==

Nether Icon nor Unicon has an explicit enumeration type; however, there are several approaches that can be used for this purpose:

 

fruits := set("apple", "banana", "cherry") # a set keeps unique data

fruits := table() # table keeps an unique data with values

fruits["apple"] := 1

fruits["banana"] := 2

 

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

 

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

 

=={{header|JSON}}==

 

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

Module Checkit {

\\ need revision 15, version 9.4

}

Checkit

 

=={{header|M4}}==

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

define(`enum',

`enums(1,$@)')

enum(a,b,c,d)

 

{{out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

 

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

type Fruits1 = enum aApple, aBanana, aCherry

 

Apple = (1, "apple")

Banana = 3 # implicit name is "Banana".

 

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

Ol enumerations is an builtin "ff"s as a simple fast dictionaries with number, constant or symbol keys and any typed values.

 

(define fruits '{

apple 0

(print (make-enumeration 'apple 'banana 'cherry))

; ==> '#ff((apple . 0) (banana . 1) (cherry . 2))

 

=={{header|OxygenBasic}}==

 

enum fruits

apple

' banana 15

' mango 16

 

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

An explicit index may not be specified, but [[#Delphi|Delphi]] and [[#Free Pascal|Free Pascal]] allow this.

However, it is guaranteed, that the <tt>ord</tt>inal value will correspond to the member’s position in the list (<tt>0</tt>-based).

 

=={{header|Perl}}==

my @fruits = qw(apple banana cherry);

 

# Using a hash

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">enum</span> <span style="color: #000000;">apple<span style="color: #0000FF;">,</span> <span style="color: #000000;">banana<span style="color: #0000FF;">,</span> <span style="color: #000000;">orange</span>

<span style="color: #008080;">enum</span> <span style="color: #000000;">apple<span style="color: #0000FF;">=<span style="color: #000000;">5<span style="color: #0000FF;">,</span> <span style="color: #000000;">banana<span style="color: #0000FF;">=<span style="color: #000000;">10<span style="color: #0000FF;">,</span> <span style="color: #000000;">orange<span style="color: #0000FF;">=

 

=={{header|PHP}}==

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

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

define("FRUIT_APPLE", 0);

define("FRUIT_BANANA", 1);

 

=={{header|Picat}}==

Picat doesn't have enumerations but they can be simulated by facts.

 

fruit(banana,2).

fruit(cherry,4).

print_fruit_name(N) :-

fruit(Name,N),

 

 

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

Prolog doesn't have enums, but they can be simulated using a set of facts.

 

fruit(banana,2).

fruit(cherry,4).

write_fruit_name(N) :-

fruit(Name,N),

 

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

{{works with|Rakudo|2016.01}}

 

 

enum ClassicalElement (

'Fire', # gets the value 7

Water => 10,

 

=={{header|Raven}}==

 

=={{header|Retro}}==

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

 

 

{ 'a=10 'b 'c 'd=998 'e 'f } a:enum

 

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

===Using syntax extension===

{{works with|Chez Scheme}}

'''The Implementation'''

; Form: (enum <name> <item>...)

; Where <name> is a symbol that will be the name of the enum; <item> are one or

(define sym nxint)

(set! name (cons (cons 'sym nxint) name))

'''Example Use'''

(syntax-rules ()

((_ e)

(test y)

(test z)

{{out}}

<pre>The 'foo' enum:

 

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

 

The only way to give such a variable a value without setting it explicitly is to add one to the previous such variable which (in effect) is what a C-style enum does. If you declare a variable in Wren without giving it a value, then it is set to the special value ''null'' which is no help here.

var ORANGE = 2

var PEAR = 3

var GRAPE = BANANA + 1

 

 

{{out}}

<br>

{{libheader|Wren-dynamic}}

 

var Fruit = Enum.create("Fruit", ["apple", "orange", "pear", "cherry", "banana", "grape"], 1)

System.print(Fruit.orange)

 

{{out}}

 

=={{header|XPL0}}==

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

 

=={{header|Z80 Assembly}}==

 

Keep in mind that these names do not exist at runtime and are just for the programmer's convenience. None of this "code" below actually takes up any space in the assembled program.

Monday equ 1

Tuesday equ 2

Thursday equ 4

Friday equ 5

 

===Without Explicit Values===

A lookup table is the most common method of enumeration of actual data in assembly. Each element of the table can be accessed by an index, and the starting index is zero. (The index may need to be adjusted for data sizes larger than 1 byte, i.e. doubled for 16-bit data and quadrupled for 32-bit data.) Unlike the above example, these values do indeed take up memory. Using this method when the above enumeration would suffice is incredibly wasteful.

 

;this simplifies the lookup process significantly.

Days_Of_The_Week:

call PrintString ;prints a null-terminated string to the screen.

ret ;return to basic

 

{{out}}

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