Enumerated Values
I'm not going to pretend that I'm an expert on the subject, but i have done some research on them and I feel confident that I can explain to you how they work.
How it Works
Basically and enumerated type is a type with predefined items/elements in them. The code for one looks as such (dont freak out I will be going over it line by line).
| Turing: |
OK, I'm sure some of you are going "WTF?!?!", so let me explain.
Declaring your Enumerated Type
First line:
| Turing: |
Now, if you've been following the Turing Walkthrough (you have right?), you will already know about types, if not however, i suggest you go take a look at the tutorial on types first. Now on to the code. Basically what this line has done is created the enumerated type colours and given it the predefined elements of red, green and blue. Note that you can have as many or as few values as you wish.
If you wish to find out which position the element you are looking for is in you simply have to make use of the ord function. Eg.
| Turing: |
What will that put out you ask? Let's take a look:
Output wrote:
0
So if you wish to find out what position the element is truly in just add 1 to the ordinal value to give you that elements position in the enumerated type.
On to lines 2-4 of the code.
Assigning values of Enumerated Types to Variables
| Turing: |
All this is doing is initializing the three variables c, d, and e to a value in our enumerated type colours. Note that when you assign a value to a varible its type has to be that of your enumberated type (eg. if your enumerated type is called foo, you variable type has to be foo in order to accept any value from the enumerated type foo).
Now I'm sure some of you are wondering what succ and pred do. succ gives a varible the value of an enumerated type succeed by one of a current variable (or hardcoded value if you wish), while pred does the opposite, it gives the predecessing value to a variable.
So what we have at the moment is a program with the enumerated type colours and three variables, c, d and e containing the values colours.green (green), colours.blue (blue) and colours.red (red) respectively.
Output:
Now lets output our information to the screen:
Output wrote:
1
2
0
Now lets see how we arrived at that shall we? First we have our simple put statements:
| Turing: |
Remember how i told you before that you can find position with ord? Well this is how. So all this is doing is ouputting the ordinal value of the values from our enumerated type. But what if we wanted to find out what the information that was contained was? Simple. Just output it using put.
| Turing: |
put c put d put e |
Output wrote:
green
blue
red
Great, I know how to use them, but what can I do now?
Good question. Enumerated types can be a very helpful thing when it comes to arrays. Using them, you can have an easier time to identify certain elements of an array. This can be particularily helpful when it comes to things such as RPGs where you would usually have some sort of armour, weapon etc. So using our knowledge of enumerated types we can help keep track of our elements of the array.
Using the example from above (an RPG) you can do something like this:
| Turing: |
type equipped : enum (armour, weapon, boots, shield) var items : array 0..3 of string := init ("steel plating","longsword","elvenskin boots","gold shield") put items(ord(equipped.shield)) |
In this way, we can more easily keep track of our arrays through the use of enumerated types and descriptive variable names. Note that this is very similiar to a hash, which in other language is like calling an element of an array through other means than an integer value.
Just remember that for some reason the people at holtsoft didnt want you using enumerated types in anything at all (eg. you cant use colours.red from our example for Draw.FillBox). But if you really wanted to do something like that you could create an enumerated type with color names for each of the 255 colors, and call them with their ordinal value if you absolutely nuts. Instead stick to the idea of using them as hashes and whatever you may see them as.
However I am not going to pretend to be an expert, so if you have anything to add, PM me with what you want me to add and I'll edit this tutorial.
In Closing
Well I hope that you learned something from this, and I hope to hear from you guys
Good Luck.
UPDATES: Added in a part for potential usages, showed how the color example could work if you put in enough work
the changes that you have suggested have been included (is that what you wanted? you will have to read through to check 
) I hope people will learn from this