Complex data types

Arrays

Arrays are created by adding [] after any basic type. The following list represents valid arrays:

• string[]

• boolean[]

• number[][]

• integer[]

• date[][][]

• interval[]

You can also create arrays for a user-defined structure:

• Person[][]

Key-

value arrays

Arrays

in SIL where positions in the list

act as keys. Key-value arrays (or maps) are declared

like regular arrays.

Learn more about

using the indexing operator to create key-value maps and retrieve values from them.

Structures

Structures are user-defined data types. A structure in SIL is like a container that can hold different types of data together. The syntax for defining a structure is:

struct 

    type1 field1;
    type2 field2;
    // ... more fields
}

The type of each field can be a

basic data type, a user-defined structure

, a self-referential structure, or arrays of these types.

The following examples show how to define a structure with each type:

    // Can use same type multiple times
}
struct Department {
    string name;
    Department parent;            // A Department can reference itself
    Department[] subDepartments;  // Can have array of same type
}

To access the value of a field from a variable in a structure, use the syntax

:

<varName>.<fieldName>

You can initialize structures field-by-field:

emp.workAddress.city = "Work City";

Alternatively, you can do a one-line initialization, including nested initialization:

struct 

Nested initialization

Literals

Literals are fixed values that appear directly in the code. In SIL, literals are used to represent constant values of different data types.

nil;           // alternative syntax

Variables

Variables are named containers that use the data types.

They are like labeled boxes that can hold specific values.

// Variable format: <data type> <variable name>

// Variable declaration:
string name;    // A container that can hold text
number pi;         // A container that can hold decimal numbers

//You can also have an array of the type of variable#
{ variable1, variable2, variable3 }.    // where variable# can also be an array

You can create an array from variables as illustrated in the following example:

// First, declare some variables
string name1 = "John";
string name2 = "Jane";
string name3 = "Bob";

// Create an array from these variables
string[] names = {name1, name2, name3};
// Result: names = {"John", "Jane", "Bob"}

You can also create array variables:

// First, declare some array variables
string[] teamA = {"John", "Jane"};
string[] teamB = {"Bob", "Alice"};
string[] teamC = {"Charlie", "David"};

// Create an array of arrays from these variables
string[][] allTeams = {teamA, teamB, teamC};
// Result: allTeams = {
//     {"John", "Jane"},
//     {"Bob", "Alice"},
//     {"Charlie", "David"}
// }

Variable declaration and initialization

To give value to your variables, you initialize them either when you declare them or later.

string employeeName;               // Just declaring
employeeName = "John";             // Initializing after declaration

string employeeAge = 25;           // Declare and initialize at once

// More examples of variable declaration
integer random = 2;
number pi = 3.14;
boolean valid;
date today = currentDate();
interval spent = "1h 30m";
interval estimate = "2d" - spent;
number [][] matrix = {{0,1}, {2,3}, {4,5}};

Constants

Variables can be made

readonly by adding the keyword

const

before the data type when the variable is first defined.

const string COMMA = ",";
const number PI = 3.14;

Explicit type casting

When types are compatible, SIL automatically converts one type to another. Automatic conversion can lead to ambiguous results. If you want to tell SIL how to convert a type, use explicit type casting with the following syntax:

(<target_type>)varname

 The following example illustrates how explicit type casting returns accurate results:

integer n = 1;
number x = 3.14;
string s = "2";

//Ambiguous - could mean different things:
return n + s; // 

User-defined functions

SIL comes with many out-of-the-box functions by SIL, but allows you to define local functions, referred to as user-defined routines (UDRs). To define and declare a function, use this general syntax:

function <name>(<type> param1, <type> param2, ...) {
   Instruction1;
   ...
   InstructionN;
   return <value>;
}

For additional details, check the User-defined routines (UDRs) topic.