Value data Types

Integer

An integer is a whole number, i.e. one that has no fractional part. It may be represented in decimal, hexadecimal or binary:

100 (decimal), 0x64 (hexadecimal) and 0b1100100 all have the same value.

Its Type is Int.

Function dot methods on an Int

Notes

• A literal integer or a named value of Type Int may always be passed into a function or procedure that is expecting a Float.
• The Int type is intended to represent whole numbers in the range:
• • Maximum: 2⁵³ − 1 (which is 9,007,199,254,740,991)
  • Minimum value: −(2⁵³ − 1)
• If you go greater than the limit given above, the number will be accurate to approximately 17 decimal digits. Larger numbers will be rounded with zeros at the end, unless they are larger than around 2⁷⁰, when they will automatically be shown in exponential (scientific) format, as shown in the example.

Example of large numbers

   ▶ This code calculates 2 raised to the power of 50 through 72, and its output is shown below:

+main 1 +for nitem? in range(50, 73)source? 2 variable sname? set to lambda n as Int => n.toString().length()value or expression?3 variable npname? set to pow(2, n).floor()value or expression?4 call printTabprocedureName?(s(n), $"{n}"arguments?)5 call printTabprocedureName?(30 - s(np), $"{np}\n"arguments?)6 end for end main

+def main() -> None: 1 +for nitem? in range(50, 73)source?: 2 sname? = lambda n: int => n.toString().length()value or expression? # variable definition3 npname? = pow(2, n).floor()value or expression? # variable definition4 printTabprocedureName?(s(n), f"{n}"arguments?) # call procedure5 printTabprocedureName?(30 - s(np), f"{np}\n"arguments?) # call procedure6 main()

+static void main() { 1 +foreach (nitem? in range(50, 73)source?) { 2 var sname? = lambda int n => n.toString().length()value or expression?;3 var npname? = pow(2, n).floor()value or expression?;4 printTabprocedureName?(s(n), $"{n}"arguments?); // call procedure5 printTabprocedureName?(30 - s(np), $"{np}\n"arguments?); // call procedure6 } }

+Sub main() 1 +For Each nitem? In range(50, 73)source? 2 Dim sname? = lambda n As Integer => n.toString().length()value or expression? ' variable definition3 Dim npname? = pow(2, n).floor()value or expression? ' variable definition4 printTabprocedureName?(s(n), $"{n}"arguments?) ' call procedure5 printTabprocedureName?(30 - s(np), $"{np}\n"arguments?) ' call procedure6 Next n End Sub

+static void main() { 1 +foreach (nitem? in range(50, 73)source?) { 2 var sname? = lambda int n => n.toString().length()value or expression?;3 var npname? = pow(2, n).floor()value or expression?;4 printTabprocedureName?(s(n), String.format("%", n)arguments?); // call procedure5 printTabprocedureName?(30 - s(np), String.format("%\n", np)arguments?); // call procedure6 } }

---

Floating point

A floating point number is a decimal number (also known as a Real number) that may have both integer and fractional parts.

It may be written using exponential (scientific) notation, e.g. 120.0 can be written as 1.20e2, and 0.012 as 1.20e-2

Function dot methods on a Float

Notes

• The limits on floating point numbers are:
  • Maximum value: just over 1.0 × 10³⁰⁸
  • Minimum value: approximately 5.0 × 10^-324
• A variable that has been defined as being of Type Float may not be passed as an argument into a method that requires an Int, nor as an index into a List even if the variable contains no fractional part. It may, however, be converted into an Int before passing, using the function floor or ceiling.
• If you wish to define a variable to be of Type Float, but initialise it with an integer value, then add .0 on the end of the whole number, as in:
  variable hourname? set to 3.0value or expression?0 hourname? = 3.0value or expression? # variable definition0 var hourname? = 3.0value or expression?;0 Dim hourname? = 3.0value or expression? ' variable definition0 var hourname? = 3.0value or expression?;0
• Any variable or expression that evaluates to an Int may always be used where a Float is expected.

Boolean

A Boolean value is either true or false.

The keywords true and false must be written in lower case.

Function dot methods on a Boolean

Reference data Types

String

A String represents text, i.e. a sequence of zero or more characters.

Character sets

When typing from the keyboard into a literal string all the basic ASCII characters (0x20 to 0x7e) and '£' can be input.

You cannot use Alt+numeric-keypad to enter accented letters or other special characters in the extended ASCII range (0x80 to 0xff).

You can, however, copy any text from outside Elan and paste it into a string, whether ASCII, extended ASCII or UTF-8 encoded.

To insert a character from the full range, you use its Unicode (codepoint) value, in decimal or hexadecimal, by means of function unicode:

These examples 'interpolate' the output of function unicode by using a $ before the string and curly braces within it (see Interpolated fields).

Manipulating strings

Strings can be built from other strings by concatenation using the plus operator, for example:

A newline may be inserted within a string with \n:

When editing and you leave the field, the newline will be implicitly applied in your code.

As in most languages, strings are immutable. When you apply any operation or function with the intent of modifying an existing string, the existing string is never changed. Instead, the operation or function will return a new string that is based on the original, but with the specified differences.

You can loop through a string picking each of its characters sequentially using the for loop.

Function dot methods on a String

Interpolated fields in strings

Strings support interpolation, that is you can insert the values of variables or simple expressions within the string by enclosing them in curly braces and prefixing the string with a $:

If a and b have values 3 and 17:

If velocity and fuel have values 3.0 and 50.4:

And, for the area of a circle:

Standard data structures

Elan has two mutable data structure Types List and Dictionary, and three immutable data structure Types HashSet, Stack and Queue.

The contents of these structures are referred to as items (or sometimes elements).

The values of items in a mutable structure may be changed directly by calling the various procedure dot methods defined for each structure Type.

The values of items in an immutable structure cannot be changed directly, and so have no procedure dot methods defined for them: rather, the methods called on them create new copies of the structures containing specified changes.

Since procedure methods may be called only from within the main routine or a procedure, it is also possible to make changes via function dot methods, which return a copy of the data structure with specified changes: that is why all such methods have names starting 'with'.

Immutable data structures are intended specifically to facilitate the Functional Programming paradigm, but some are also useful within other programming paradigms.

All six contain values (and keys in the case of a Dictionary) of only a single Type, that Type being specified either explicitly (as in <of Int>), or implicitly if the structure is created using a literal definition.

This table summarises the creation and reference to these structures. Details of their methods follow.

List

The List Type defines a data structure containing n items of any single Type, including basic value Types, structure Types such as List, and user-defined Types such as a Class.

Items in a List of n items are indexed from 0 to n-1.

To create a List, use either of:

• Method createList to define its length and the initial value (and implicitly the Type) of its items:
  variable aListname? set to createList(10, "no one")value or expression?0 aListname? = createList(10, "no one")value or expression? # variable definition0 var aListname? = createList(10, "no one")value or expression?;0 Dim aListname? = createList(10, "no one")value or expression? ' variable definition0 var aListname? = createList(10, "no one")value or expression?;0
• Define an empty List of the required type, and use the procedure methods listed below to populate it:
  variable aList set to new List<of String>() Code does not parse as Elan. variable aList set to new List<of String>() Code does not parse as Elan. variable aList set to new List<of String>() Code does not parse as Elan. variable aList set to new List<of String>() Code does not parse as Elan. variable aList set to new List<of String>() Code does not parse as Elan.
call aList.initialiseprocedureName?(10, "no one"arguments?)0 aList.initialiseprocedureName?(10, "no one"arguments?) # call procedure0 aList.initialiseprocedureName?(10, "no one"arguments?); // call procedure0 aList.initialiseprocedureName?(10, "no one"arguments?) ' call procedure0 aList.initialiseprocedureName?(10, "no one"arguments?); // call procedure0
call aList.appendprocedureName?("4"arguments?)0 aList.appendprocedureName?("4"arguments?) # call procedure0 aList.appendprocedureName?("4"arguments?); // call procedure0 aList.appendprocedureName?("4"arguments?) ' call procedure0 aList.appendprocedureName?("4"arguments?); // call procedure0

The item at index ix in List aList can then be changed using a set instruction and a valid index value in square brackets:

• set aList[ix]variableName? to "Smith"value or expression?0 aList[ix]variableName? = "Smith"value or expression? # change variable0 aList[ix]variableName? = "Smith"value or expression?; // change variable0 aList[ix]variableName? = "Smith"value or expression? ' change variable0 aList[ix]variableName? = "Smith"value or expression?; // change variable0

A List's size can be dynamically changed using the procedure methods listed below.

Deconstructing a List

A List may be split (deconstructed) into new named values using indexes and the methods head, tail and subList:

• To extract the first item in a List:
  variable headItemname? set to myList[0]value or expression?0 headItemname? = myList[0]value or expression? # variable definition0 var headItemname? = myList[0]value or expression?;0 Dim headItemname? = myList[0]value or expression? ' variable definition0 var headItemname? = myList[0]value or expression?;0
  or
  set heatItemvariableName? to myList.head()value or expression?0 heatItemvariableName? = myList.head()value or expression? # change variable0 heatItemvariableName? = myList.head()value or expression?; // change variable0 heatItemvariableName? = myList.head()value or expression? ' change variable0 heatItemvariableName? = myList.head()value or expression?; // change variable0
• To form a new List of all but the first item in a List:
  variable tailListname? set to myList.tail()value or expression?0 tailListname? = myList.tail()value or expression? # variable definition0 var tailListname? = myList.tail()value or expression?;0 Dim tailListname? = myList.tail()value or expression? ' variable definition0 var tailListname? = myList.tail()value or expression?;0
  If the original list contains only one item, the new List will be the empty List.
• To get some other portion of a List, use the method subList:
  set shortListvariableName? to myList.subList(1, 5)value or expression?0 shortListvariableName? = myList.subList(1, 5)value or expression? # change variable0 shortListvariableName? = myList.subList(1, 5)value or expression?; // change variable0 shortListvariableName? = myList.subList(1, 5)value or expression? ' change variable0 shortListvariableName? = myList.subList(1, 5)value or expression?; // change variable0

In all these cases the items indexed must exist, else a runtime error will stop the program.

Lists of lists

Two dimensional arrays

Understood as a grid, a 2D array is a List of 'columns' each of which is a List of 'row' items, i.e. it is a List of Lists in which the column number is the x coordinate, and the row number is the y coordinate.

To create a 2D array that holds a value of a single Type in every cell, you define such a List of Lists thus:

• Use method createListOfLists to set the size of, and initial value in, every x,y position:
  variable array2Dname? set to createListOfLists(cols, rows, value)value or expression?0 array2Dname? = createListOfLists(cols, rows, value)value or expression? # variable definition0 var array2Dname? = createListOfLists(cols, rows, value)value or expression?;0 Dim array2Dname? = createListOfLists(cols, rows, value)value or expression? ' variable definition0 var array2Dname? = createListOfLists(cols, rows, value)value or expression?;0
• For the special case of Block graphics, use 40 columns and 30 rows or (more simply):
  variable gridname? set to createBlockGraphics(value)value or expression?0 gridname? = createBlockGraphics(value)value or expression? # variable definition0 var gridname? = createBlockGraphics(value)value or expression?;0 Dim gridname? = createBlockGraphics(value)value or expression? ' variable definition0 var gridname? = createBlockGraphics(value)value or expression?;0

The item at index ix,iy in a 2D array can be accessed and changed using its two coordinates in square brackets:

• variable valuename? set to array2D[ix][iy]value or expression?0 valuename? = array2D[ix][iy]value or expression? # variable definition0 var valuename? = array2D[ix][iy]value or expression?;0 Dim valuename? = array2D[ix][iy]value or expression? ' variable definition0 var valuename? = array2D[ix][iy]value or expression?;0
• set array2D[ix][iy]variableName? to 7value or expression?0 array2D[ix][iy]variableName? = 7value or expression? # change variable0 array2D[ix][iy]variableName? = 7value or expression?; // change variable0 array2D[ix][iy]variableName? = 7value or expression? ' change variable0 array2D[ix][iy]variableName? = 7value or expression?; // change variable0

Higher dimensional arrays

For a 3D array, you can, for example, define:

• variable array3D set to new List<of List<of List<of Float>>>() Code does not parse as Elan. variable array3D set to new List<of List<of List<of Float>>>() Code does not parse as Elan. variable array3D set to new List<of List<of List<of Float>>>() Code does not parse as Elan. variable array3D set to new List<of List<of List<of Float>>>() Code does not parse as Elan. variable array3D set to new List<of List<of List<of Float>>>() Code does not parse as Elan.

and refer to a cell using three indexes in square brackets.

Procedure methods on a List

Where an argument provides a new value for an item in a List, that value must be of the same Type as defined for the List's items.

Function dot methods on a List

Dictionary

A Dictionary is like a List whose items are pairs but, instead of having a numeric index, each item has a key plus an associated value. The Dictionary is a set of key:value pairs.

The key's Type must be one of Int, Float, String or Boolean. The values may be of any Type. The Types of both keys and values are fixed when the Dictionary is created.

Procedure method on a Dictionary

Function dot methods on a Dictionary

HashSet

A HashSet (also referred to merely as a Set) is a standard data structure containing Set members, that works somewhat like a List with two important differences:

• The value of a Set member may appear only once: if a member being added to a HashSet has the same value as an existing member in the Set then the Set remains the same as before.
• The values in a HashSet are not indexed: two Sets with the same contents but defined in a different sequence, can still be compared correctly with methods equals and notEqualTo.
• There are no methods that modify an existing Set but several, e.g. add and remove, return a new HashSet that is based on the original Set or Sets with specified differences.

This enables a Set to work like a mathematical set so that it is possible to perform standard set operations such as union and intersection.

When creating a HashSet, the Type of its members must be specified in the form HashSet<of String>.

You can add members: individually with add, or multiply with addFromList. And you can create a new HashSet from an existing List by calling asSet on it.

Example of creating a Set from a literal List and changing its content:

Function dot methods on a HashSet

Stack and Queue

• Stack and Queue are similar data structures except that Stack is 'LIFO' (last in, first out), while Queue is FIFO (first in, first out). The names of the methods for adding/removing are different, but there are also common methods.
• Both a Stack and a Queue are defined with the Type of the items that they can contain, similarly to how List has a specified item Type, though with different syntax. The Type is specified in the form shown below e.g. Stack<of String>, Queue<of Int>, Stack<of (Float, Float)>, Queue<of Square>.
• Both Stack and Queue are dynamically extensible, like a List. There is no need (or means) to specify a size limit as they will continue to expand until, eventually, the computer's memory limit is reached.
• This same syntax is used to specify the Type if you want to pass a Stack or Queue into a function, or specify it as the return Type.
• Stack and Queue have two methods in common: length and peek. peek returns the next item to be removed, without actually removing it.
• The methods for adding and removing an item are different for Stack and Queue, as shown here:

Function dot methods on a Stack

Function dot methods on a Queue