begin enum 1 _apple _banana _cherry end enum

begin enum _appleExplicit = 10 _bananaExplicit = 15 _cherryExplicit = 30 end enum

print "_apple ="; _apple print "_banana ="; _banana print "_cherry ="; _cherry print print "_appleExplicit ="; _appleExplicit print "_bananaExplicit ="; _bananaExplicit print "_cherryExplicit ="; _cherryExplicit

Output

```txt

_apple = 1
_banana = 2
_cherry = 3

_appleExplicit = 10
_bananaExplicit = 15
_cherryExplicit = 30

Go

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

const (
	apple = iota
	banana
	cherry
)

The above is equivalent to,

const (
	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:

type fruit int

const (
	apple fruit = iota
	banana
	cherry
)

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

type fruit int

const (
	apple  fruit = 0
	banana fruit = 1
	cherry fruit = 2
)

Groovy

Enumerations:

enum Fruit { apple, banana, cherry }

enum ValuedFruit {
    apple(1), banana(2), cherry(3);
    def value
    ValuedFruit(val) {value = val}
    String toString() { super.toString() + "(${value})" }
}

println Fruit.values()
println ValuedFruit.values()

{{out}}

[apple, banana, cherry]
[apple(1), banana(2), cherry(3)]

Haskell

data Fruit = Apple | Banana | Cherry deriving Enum

Huginn

enum FRUIT {
  APPLE,
  BANANA,
  CHERRY
}

Inform 7

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

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

[sentence form]
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.
The numeric value of cherry is 3.

[table form]
Fruit is a kind of value. The fruits are defined by the Table of Fruits.

Table of Fruits
fruit	numeric value
apple	1
banana	2
cherry	3

=={{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 := [ "apple", "banana", "cherry", "apple" ]  # a list keeps ordered data
  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
  fruits["cherry"] := 3

J

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

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

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.

   fruit=: ;:'apple banana cherry'

Now you can get the name associated with an index:

   2 { fruit
+------+
|cherry|
+------+

And you can get the index associated with a name:

  fruit i.<'banana'
1

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

   (<'banana') +&.(fruit&i.)  <'banana'
+------+
|cherry|
+------+

And, you can iterate over the values (though an example of that is probably beyond the scope of this task), along with numerous other variations on these themes.

A person could reasonably argue that enums were introduced in some languages to work around deficiencies in array handling in those languages.

Java

{{works with|Java|1.5+}}

enum Fruits{
   APPLE, BANANA, CHERRY
}

Or:

enum Fruits{
  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.

JavaScript

In javascript, usually used for this a strings.

// enum fruits { apple, banana, cherry }

var f = "apple";

if(f == "apple"){
    f = "banana";
}

jq

Finite, ordered enumerations can be represented in jq as JSON arrays, e.g. ["apple", "banana", "cherry"], or as sequences, e.g. ("apple", "banana", "cherry"). The latter interpretation corresponds to the idea of '''enumerating''' a collection, and also dovetails with the concept of infinite enumerations.

Countably-infinite ordered enumerations can be represented by generators, e.g. the non-negative natural numbers can be represented by the jq expression:

 1 | while(true; .+1)

Finite, unordered enumerations can be represented as JSON objects, as in the JSON section of this article. In this context, it is worth noting that jq allows a shorthand notation for specifying objects, so that we can for example write:

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

JSON

{"fruits" : { "apple" : null, "banana" : null, "cherry" : null }
{"fruits" : { "apple" : 0, "banana" : 1, "cherry" : 2 }

JScript.NET

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

Julia

@enum Fruits APPLE BANANA CHERRY

{{out}}

julia> Fruits
Enum Fruits:
APPLE = 0
BANANA = 1
CHERRY = 2

Kotlin

// version 1.0.5-2

enum class Animals {
    CAT, DOG, ZEBRA
}

enum class Dogs(val id: Int) {
    BULLDOG(1), TERRIER(2), WOLFHOUND(4)
}

fun main(args: Array<String>) {
    for (value in Animals.values()) println("${value.name.padEnd(5)} : ${value.ordinal}")
    println()
    for (value in Dogs.values()) println("${value.name.padEnd(9)} : ${value.id}")
}

{{out}}

CAT   : 0
DOG   : 1
ZEBRA : 2

BULLDOG   : 1
TERRIER   : 2
WOLFHOUND : 4

Lingo

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):

-- parent script "Enumeration"

property ancestor

on new (me)
  data = [:]
  repeat with i = 2 to the paramCount
    data[param(i)] = i-1
  end repeat
  me.ancestor = data
  return me
end

on setAt (me)
  -- do nothing
end

on setProp (me)
  -- do nothing
end

on deleteAt (me)
  -- do nothing
end

on deleteProp (me)
  -- do nothing
end

on addProp (me)
  -- do nothing
end

enumeration = script("Enumeration").new("APPLE", "BANANA", "CHERRY")

put enumeration["BANANA"]
-- 2

-- try to change a value after construction (fails)
enumeration["BANANA"] = 666
put enumeration["BANANA"]
-- 2

-- try to change a value after construction using setProp (fails)
enumeration.setProp("BANANA", 666)
put enumeration["BANANA"]
-- 2

-- try to delete a value after construction (fails)
enumeration.deleteAt(2)
put enumeration["BANANA"]
-- 2

-- try to delete a value after construction using deleteProp (fails)
enumeration.deleteProp("BANANA")
put enumeration["BANANA"]
-- 2

-- try to add a new value after construction (fails)
enumeration["FOO"] = 666
put enumeration["FOO"]
-- <Void>

-- try to add a new value after construction using addProp (fails)
enumeration.addProp("FOO", 666)
put enumeration["FOO"]
-- <Void>

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.

M2000 Interpreter

Module Checkit {
      \\ need revision 15, version 9.4
      Enum Fruit  {apple, banana, cherry}
      Enum Fruit2  {apple2=10, banana2=20, cherry2=30}
      Print apple, banana, cherry
      Print apple2, banana2, cherry2
      Print Len(apple)=0
      Print Len(banana)=1
      Print Len(cherry)=2
      Print Len(cherry2)=2, Cherry2=30, Type$(Cherry2)="Fruit2"

      k=each(Fruit)
      While k {
            \\ name of variable, value, length from first (0, 1, 2)
            Print Eval$(k), Eval(k), k^
      }
      m=apple
      Print Eval$(m)="apple"
      Print Eval(m)=m
      m++
      Print Eval$(m)="banana"
      Try {
            \\ error, m is an object
            m=100
      }
      Try {
            \\ error not the same type
            m=apple2
      }
      Try {
            \\ read only can't change
            apple2++
      }
      m++
      Print Eval$(m)="cherry", m
      k=Each(Fruit2 end to start)
      While k {
             Print Eval$(k), Eval(k) , k^
             CheckByValue(Eval(k))
      }
      m2=apple2
      Print "-------------------------"
      CheckByValue(m2)
      CheckByReference(&m2)
      Print m2

      Sub CheckByValue(z as Fruit2)
            Print Eval$(z), z
      End Sub

      Sub CheckByReference(&z as Fruit2)
            z++
            Print Eval$(z), z
      End Sub
}
Checkit

M4

define(`enums',
   `define(`$2',$1)`'ifelse(eval($#>2),1,`enums(incr($1),shift(shift($@)))')')
define(`enum',
   `enums(1,$@)')
enum(a,b,c,d)
`c='c

{{out}}

c=3

Mathematica

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

MapIndexed[Set, {A, B, F, G}]
->{{1}, {2}, {3}, {4}}

A
->{1}

B
->{2}

G
->{4}

=={{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 = {'apple', [1 2 3], 'cherry',1+2i}

stuff =

    'apple'    [1x3 double]    'cherry'    [1.000000000000000 + 2.000000000000000i]

Metafont

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

vardef enum(expr first)(text t) =
save ?; ? := first;
forsuffixes e := t: e := ?; ?:=?+1; endfor
enddef;

Usage example:

enum(1, Apple, Banana, Cherry);
enum(5, Orange, Pineapple, Qfruit);
show Apple, Banana, Cherry, Orange, Pineapple, Qfruit;

end

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

TYPE Fruit = {Apple, Banana, Cherry};

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

```modula3
ORD(Fruit.Apple); (* Returns 0 *)
VAL(0, Fruit); (* Returns Fruit.Apple *)

Nemerle

enum Fruit {
    |apple
    |banana
    |cherry
}

enum Season {
    |winter = 1
    |spring = 2
    |summer = 3
    |autumn = 4
}

Nim

type Fruits = enum Apple, Banana, Cherry

type Fruits = enum Apple = 0, Banana = 1, Cherry = 2 # with values

type Fruits {.pure.} = enum Apple, Banana, Cherry # scoped enum
var i: int = Apple # error for scoped enum

type Fruits = enum Apple = "Apple", Banana = "Banana", Cherry = "Cherry" # with string literals

Objeck

enum Color := -3 {
  Red,
  White,
  Blue
}

enum Dog {
  Pug,
  Boxer,
  Terrier
}

=={{header|Objective-C}}== With iOS 6+ SDK / Mac OS X 10.8+ SDK:

typedef NS_ENUM(NSInteger, fruits) { apple, banana, cherry };

typedef NS_ENUM(NSInteger, fruits) { apple = 0, banana = 1, cherry = 2 };

OCaml

type fruit =
  | Apple
  | Banana
  | Cherry

Oforth

In Oforth, you use symbols to define enumerations.Symbols are strings that are identical : if two symbols are equal (==), they are the same object.

You can't define explicit values for these symbols as they a themseelves values.

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

[ $apple, $banana, $cherry ] const: Fruits

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:

declare
  fun {IsFruit A}
     {Member A [apple banana cherry]}
  end
in
  {Show {IsFruit banana}}

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

declare
  Apple = 1
  Banana = 2
  Cherry = 3

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

declare
  proc {Enumeration Xs}
     Xs = {List.number 1 {Length Xs} 1}
  end

  [Apple Banana Cherry] = {Enumeration}
in
  {Show Cherry}

Pascal

Standard Pascal as per ISO 7185 only allows contiguous lists of identifiers as enumerated type definitions. An explicit index may not be specified, but [[#Delphi|Delphi]] and [[#Free Pascal|Free Pascal]] allow this. However, it is guaranteed, that the ordinal value will correspond to the member’s position in the list (0-based).

type
	phase = (red, green, blue);

Perl

# Using an array
my @fruits = qw(apple banana cherry);

# Using a hash
my %fruits = ( apple => 0, banana => 1, cherry => 2 );

Perl 6

{{works with|Rakudo|2016.01}}

; # Numbered 0 through 2.

enum ClassicalElement (
    Earth => 5,
    'Air',  # gets the value 6
    'Fire', # gets the value 7
    Water => 10,
);

Phix

enum apple, banana, orange
enum apple=5, banana=10, orange=15

PHP

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

// If you are inside a class scope
class Fruit {
  const APPLE = 0;
  const BANANA = 1;
  const CHERRY = 2;
}

// Then you can access them as such
$value = Fruit::APPLE;

// Or, you can do it using define()
define("FRUIT_APPLE", 0);
define("FRUIT_BANANA", 1);
define("FRUIT_CHERRY", 2);

PicoLisp

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

(de enum "Args"
   (mapc def "Args" (range 1 (length "Args"))) )

And used in this way:

: (enum A B C D E F)
-> F

: A
-> 1
: B
-> 2
: F
-> 6

PL/I

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

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

PowerShell

Without explicit values. {{works with|PowerShell|5}}

Enum fruits {
    Apple
    Banana
    Cherry
}
[fruits]::Apple
[fruits]::Apple + 1
[fruits]::Banana + 1

Output:

Apple
Banana
Cherry

With explicit values. {{works with|PowerShell|5}}

Enum fruits {
    Apple = 10
    Banana = 15
    Cherry = 30
}
[fruits]::Apple
[fruits]::Apple + 1
[fruits]::Banana + 1

Apple
11
16

PureBasic

Basic Enumeration is defined as

Enumeration
   #Apple
   #Banana
   #Cherry
EndEnumeration

This can also be adjusted to the form

Enumeration 10200 Step 12
  #Constant1           ; 10200
  #Constant2           ; 10212
  #Constant3           ; 10224
  #Constant4 = 10117   ; 10117
  #Constant5           ; 10229
EndEnumeration

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;

Enumeration #PB_Compiler_EnumerationValue
  #Constant_A           ; 10241
  #Constant_B           ; 10242
EndEnumeration

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

;This starts the enumeration of a named group 'NamedGroup'.
Enumeration NamedGroup 5
  #Green                ; 5
  #Orange               ; 6
EndEnumeration

;EnumerationBinary will use values that are a double of the previous value (or starting value).
EnumerationBinary
  #North                ; 1
  #West                 ; 2
  #South                ; 4
  #East                 ; 8
EndEnumeration

;This continues the enumeration of the previously named group 'NamedGroup'.
Enumeration NamedGroup
  #Yellow               ; 7
  #Red                  ; 8
EndEnumeration

Python

Python: Version 3.4+

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

 from enum import Enum
>>> Contact = Enum('Contact', 'FIRST_NAME, LAST_NAME, PHONE')
>>> Contact.__members__
mappingproxy(OrderedDict([('FIRST_NAME', <Contact.FIRST_NAME: 1>), ('LAST_NAME', <Contact.LAST_NAME: 2>), ('PHONE', <Contact.PHONE: 3>)]))
>>>
>>> # Explicit
>>> class Contact2(Enum):
	FIRST_NAME = 1
	LAST_NAME = 2
	PHONE = 3


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

FIRST_NAME, LAST_NAME, PHONE = range(3)

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

vars().update((key,val) for val,key in enumerate(("FIRST_NAME","LAST_NAME","PHONE")))

R

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

 factor(c("apple", "banana", "cherry"))
# [1] apple  banana cherry
# Levels: 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.

Racket

#lang racket

;; Like other Lisps, Racketeers prefer using symbols directly instead of
;; numeric definitions, and lists of symbols instead of bitwise
;; combinations
(define fruits '(apple banana cherry))

;; In Typed Racket, a type can be defined for a specific set of symbols
;; (define-type Fruit (U 'apple 'banana 'cherry))

;; The conventional approach is possible too, of course
(define APPLE  1)
(define BANANA 2)
(define CHERRY 4)

;; And finally, when dealing with foreign functions it is useful to
;; translate idiomatic Racket values (= symbols) to/from integers.
;; Racket's ffi has two ways to do this -- either an enumeration (for
;; independent integer constants) or a bitmask (intended to represent
;; sets using bitwise or):
(require ffi/unsafe)
(define _fruit  (_enum '(APPLE = 1
                         BANANA
                         CHERRY = 4)))
(define _fruits (_bitmask '(APPLE = 1
                            BANANA = 2
                            CHERRY = 4)))

;; Normally, Racket code will just use plain values (a symbol for the
;; first, and a list of symbols for the second) and the foreign side
;; sees the integers.  But do demonstrate this, we can use the primitive
;; raw functionality to see how the translation works:
(require (only-in '#%foreign ctype-scheme->c ctype-c->scheme))

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

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

Raven

{ 'apple' 0 'banana' 1 'cherry' 2 } as fruits

Retro

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

needs enum'
( Creating a series of values )
0 ^enum'enum| a b c d |

( Create values individually )
0 ^enum'enum a  ^enum'enum b

The actual values for each subsequent enumerated value created are determined by the '''^enum'step''' function. This defaults to incrementing by 1, but can be altered as desired:

with enum'
[ 10 * ] is step
0 ^enum'enum| a b c d |

REXX

REXX has no types, and therefore has no enumeration type.

However, in the spirit of enumeration, REXX programmers can use stemmed arrays for enumerating constants (shown below).

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

/*REXX program illustrates a method of  enumeration  of  constants via  stemmed arrays. */
fruit.=0                              /*the default for all possible "FRUITS."  (zero). */
           fruit.apple      =   65
           fruit.cherry     =    4
           fruit.kiwi       =   12
           fruit.peach      =   48
           fruit.plum       =   50
           fruit.raspberry  =   17
           fruit.tomato     = 8000
           fruit.ugli       =    2
           fruit.watermelon =    0.5  /*◄─────────── could also be specified as:   1/2  */

                                            /*A method of using a list (of some fruits).*/
@fruits= 'apple apricot avocado banana bilberry blackberry blackcurrant blueberry baobab',
         'boysenberry breadfruit cantaloupe cherry chilli chokecherry citron coconut',
         'cranberry cucumber currant date dragonfruit durian eggplant elderberry fig',
         'feijoa gac gooseberry grape grapefruit guava honeydew huckleberry jackfruit',
         'jambul juneberry kiwi kumquat lemon lime lingenberry loquat lychee mandarin',
         'mango mangosteen nectarine orange papaya passionfruit peach pear persimmon',
         'physalis pineapple pitaya pomegranate pomelo plum pumpkin rambutan raspberry',
         'redcurrant satsuma squash strawberry tangerine tomato ugli watermelon zucchini'

/*╔════════════════════════════════════════════════════════════════════════════════════╗
  ║Parental warning: sex is discussed below: PG─13.  Most berries don't have "berry" in║
  ║their name.  A  berry  is a  simple fruit  produced from a single ovary.  Some true ║
  ║berries are: pomegranate, guava, eggplant, tomato, chilli, pumpkin, cucumber, melon,║
  ║and citruses.  Blueberry  is a  false  berry;  blackberry is an  aggregate  fruit;  ║
  ║and strawberry is an  accessory  fruit.  Most nuts are fruits.  The following aren't║
  ║true nuts: almond, cashew, coconut, macadamia, peanut, pecan, pistachio, and walnut.║
  ╚════════════════════════════════════════════════════════════════════════════════════╝*/

                               /*  ┌─◄── due to a Central America blight in 1922; it was*/
                               /*  ↓     called the Panama disease (a soil─borne fungus)*/
if fruit.banana=0  then say "Yes!  We have no bananas today."               /* (sic) */
if fruit.kiwi \=0  then say "We gots "   fruit.kiwi    ' hairy fruit.'      /*   "   */
if fruit.peach\=0  then say "We gots "   fruit.peach   ' fuzzy fruit.'      /*   "   */

maxL=length('  fruit   ')                        /*ensure this header title can be shown*/
maxQ=length(' quantity ')                        /*   "     "    "      "    "   "   "  */
say
     do p    =0  for 2                           /*the first pass finds the maximums.   */
         do j=1  for words(@fruits)              /*process each of the names of fruits. */
         @=word(@fruits, j)                      /*obtain a fruit name from the list.   */
         #=value('FRUIT.'@)                      /*   "   the quantity of a fruit.      */
         if \p  then do                          /*is this the first pass through ?     */
                     maxL=max(maxL, length(@))   /*the longest (widest) name of a fruit.*/
                     maxQ=max(maxQ, length(#))   /*the widest width quantity of fruit.  */
                     iterate  /*j*/              /*now, go get another name of a fruit. */
                     end
         if j==1  then say center('fruit', maxL)    center("quantity", maxQ)
         if j==1  then say copies('─'    , maxL)    copies("─"       , maxQ)
         if #\=0  then say  right( @     , maxL)     right( #        , maxQ)
         end   /*j*/
     end       /*p*/
                                                 /*stick a fork in it,  we're all done. */

'''output'''

Yes!  We have no bananas today.
We gots  12  hairy fruit.
We gots  48  fuzzy fruit.

   fruit      quantity
──────────── ──────────
       apple         65
      cherry          4
        kiwi         12
       peach         48
        plum         50
   raspberry         17
      tomato       8000
        ugli          2
  watermelon        0.5

Ring

apple = 0
banana = 1
cherry = 2
see "apple : " + apple + nl
see "banana : " + banana + nl
see "cherry : " + cherry + nl

Ruby

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

module Fruits
  APPLE  = 0
  BANANA = 1
  CHERRY = 2
end

# It is possible to use a symbol if the value is unrelated.

FRUITS = [:apple, :banana, :cherry]
val = :banana
FRUITS.include?(val)      #=> true

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

module Card
  # constants
  SUITS = %i(Clubs Hearts Spades Diamonds)
  SUIT_VALUE = SUITS.each_with_index.to_h               # version 2.1+
# SUIT_VALUE = Hash[ SUITS.each_with_index.to_a ]       # before it
  #=> {:Clubs=>0, :Hearts=>1, :Spades=>2, :Diamonds=>3}

  PIPS = %i(2 3 4 5 6 7 8 9 10 Jack Queen King Ace)
  PIP_VALUE = PIPS.each.with_index(2).to_h              # version 2.1+
# 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}
end

Rust

enum Fruits {
    Apple,
    Banana,
    Cherry
}

enum FruitsWithNumbers {
    Strawberry = 0,
    Pear = 27,
}

fn main() {
    // Access to numerical value by conversion
    println!("{}", FruitsWithNumbers::Pear as u8);
}

Scala

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

sealed abstract class Fruit
case object Apple extends Fruit
case object Banana extends Fruit
case object Cherry extends Fruit

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

object Fruit extends Enumeration {
  val Apple, Banana, Cherry = Value
}

Scheme

(define apple 0)
(define banana 1)
(define cherry 2)

(define (fruit? atom)
  (or (equal? 'apple atom)
      (equal? 'banana atom)
      (equal? 'cherry atom)))

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

Seed7

const type: fruits is new enum
    apple, banana, cherry
  end enum;

Shen

(tc +)

(datatype fruit

  if (element? Fruit [apple banana cherry])
  _____________
  Fruit : fruit;)

Sidef

Implicit:

enum {Apple, Banana, Cherry};   # numbered 0 through 2

Explicit:

enum {
    Apple=3,
    Banana,         # gets the value 4
    Cherry="a",
    Orange,         # gets the value "b"
};

Slate

As just unique objects:

define: #Fruit &parents: {Cloneable}.
Fruit traits define: #Apple -> Fruit clone.
Fruit traits define: #Banana -> Fruit clone.
Fruit traits define: #Cherry -> Fruit clone.

As labels for primitive values:

define: #Apple -> 1.
define: #Banana -> 2.
define: #Cherry -> 3.

As a namespace:

ensureNamespace: #fruit &slots: {#Apple -> 1. #Banana -> 2. #Cherry -> 3}.

Using a dictionary:

define: #fruit &builder: [{#Apple -> 1. #Banana -> 2. #Cherry -> 3} as: Dictionary].

Standard ML

datatype fruit =
  Apple
| Banana
| Cherry

Swift

enum Fruit {
    case Apple
    case Banana
    case Cherry
}
// or
enum Fruit {
    case Apple, Banana, Cherry
}

enum Season : Int {
    case Winter = 1
    case Spring = 2
    case Summer = 3
    case Autumn = 4
}

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:]]

proc enumerate {name values} {
    interp alias {} $name: {} lsearch $values
    interp alias {} $name@ {} lindex $values
}

it would be used like this:

enumerate fruit {apple blueberry cherry date elderberry}

fruit: date
#   ==> prints "3"
fruit@ 2
#   ==> prints "cherry"

Toka

Toka has no data types, and therefore no actual enumeration type. There is an optional library function which does provide a way to create enumerated values easily though.

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

needs enum
0 enum| apple banana carrot |
10 enum| foo bar baz |

VBA

Like Visual Basic .NET, actually:

'this enumerates from 0
Enum fruits
  apple
  banana
  cherry
End Enum

'here we use our own enumeration
Enum fruits2
  pear = 5
  mango = 10
  kiwi = 20
  pineapple = 20
End Enum


Sub test()
Dim f As fruits
  f = apple
  Debug.Print "apple equals "; f
  Debug.Print "kiwi equals "; kiwi
  Debug.Print "cherry plus kiwi plus pineapple equals "; cherry + kiwi + pineapple
End Sub

{{out}}

test
apple equals  0
kiwi equals  20
cherry plus kiwi plus pineapple equals  42

Visual Basic .NET

' Is this valid?!
Enum fruits
apple
banana
cherry
End Enum

' This is correct
Enum fruits
apple = 0
banana = 1
cherry = 2
End Enum

XPL0

def \Fruit\ Apple, Banana, Cherry;      \Apple=0, Banana=1, Cherry=2
def     Apple=1, Banana=2, Cherry=4;

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 RGB_COLOR{  // put color names in a name space
   const RED =0xf00;
   const BLUE=0x0f0, GREEN = 0x00f;
   const CYAN=BLUE + GREEN;  // → 0x0ff
}
println(RGB_COLOR.BLUE);

{{out}}

240

const X0=N;        // --> 0
const A=N,B=N,C=N; // --> 1,2,3
const{ _n=-1; }    // reset Enum, this should be a const space function
const X=N;	   // -->0

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

#continuing ...
z:=N;      // -->2 NOT 1 as it is set AFTER Y (compile time vs parse time)
const Y=N; // -->1! because it is set before z

zonnon

module Enumerations;
type
	Fruits = (apple,banana,cherry);

var
	deserts,i: Fruits;

begin
		deserts := Fruits.banana;
		writeln("ord(deserts): ",integer(deserts):2);

		for i := Fruits.apple to Fruits.cherry do
			writeln(integer(i):2)
		end
end Enumerations.

{{Out}}

ord(deserts):  1
 0
 1
 2

{{omit from|PARI/GP}} {{omit from|Maxima}} {{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} {{omit from|ZX Spectrum Basic}} {{omit from|Axe}}