A boolean value has two possible values, the truth values. These truth values are false and true. The value false means that a property is not fulfilled. A value true means the presence of a property. Boolean variables are initialized with the value false.

In mathematics, various symbols are used for unary and binary boolean operators. These operators are also present in Chi. The most commonly used boolean operators are not, and, and or. The names of the operators, the symbols in mathematics and the symbols in the language are presented in the following table:

Examples of boolean expressions are the following. If z equals true, then the value of (not z) equals false. If s equals false, and t equals true, then the value of the expression (s or t) becomes true.

The result of the unary not, the binary and and or operators, for two variables p and q is given in the following table:

If p = true and q = false, we find for p or q the value true (third line in the table).

Often there are several variants of entities, like types of products, available resources, available machine types, and so on.

One way of coding them is give each a unique number, which results in code with a lot of small numbers that are not actually numbers, but refer to one variant.

Another way is to give each variant a name (which often already exists), and use those names instead.

For example, to model a traffic light:

The enum TrafficColor line lists the available traffic colors. With this definition, a new type TrafficColor is created, which you can use like any other type. The line TrafficColor light = RED; creates a new variable called light and initializes it to the value RED.

In the language, two types of numbers are available: integer numbers and real numbers. Integer numbers are whole numbers, denoted by type int e.g. 3, -10, 0. Real numbers are used to present numbers with a fraction, denoted by type real. E.g. 3.14, 2.7e6 (the scientific notation for 2.7 million). Note that real numbers must either have a fraction or use the scientific notation, to let the computer know you mean a real number (instead of an integer number). Integer variables are initialized with 0. Real variables are initialized with 0.0.

For numbers, the normal arithmetic operators are defined. Expressions can be constructed with these operators. The arithmetic operators for numbers are listed in the following table:

The priority of the operators is given from high to low. The unary operators have the strongest binding, and the + and - the weakest binding. So, -3^2 is read as (-3)^2 and not -(3^2), because the priority rules say that the unary operator binds stronger than the raising to the power operator. Binding in expressions can be changed by the use of parentheses.

The integer division, denoted by div, gives the biggest integral number smaller or equal to x / y. The integer remainder, denoted by mod, gives the remainder after division x - y * (x div y). So, 7 div 3 gives 2 and -7 div 3 gives -3, 7 mod 3 gives 1 and -7 mod 3 gives 2.

The rule for the result of an operation is as follows. The real division and raising to the power operations always produce a value of type real. Otherwise, if both operands (thus x and y) are of type int, the result of the operation is of type int. If one of the operands is of type real, the result of the operation is of type real.

Conversion functions exist to convert a real into an integer. The function ceil converts a real to the smallest integer value not less than the real, the function floor gives the biggest integer value smaller than or equal to the real, and the function round rounds the real to the nearest integer value (or up, if it ends on .5).

Between two numbers a relational operation can be defined. If for example variable x is smaller than variable y, the expression x < y equals true. The relational operators, with well-known semantics, are listed in the following table:

Variables of type string contains a sequence of characters. A string is enclosed by double quotes. An example is "Manufacturing line". Strings can be composed from different strings. The concatenation operator (+) adds one string to another, for example "One" + " " + "string" gives "One string". Moreover the relational operators (<, <=, ==, != >=, and >) can be used to compare strings alphabetically, e.g. "a" < "aa" < "ab" < "b". String variables are initialized with the empty string "".

A type person is a tuple with two fields, a 'name' field of type string, and an 'age' field of type int, is denoted by:

A projection operator fetches a field from a tuple. We define two persons:

And we can speak of eva.name and adam.age, denoting the name of eva ("eva") and the age of adam (27). We can assign a field in a tuple to another variable:

This means that the age of eva is assigned tot variable ae, and the new age of eva becomes eva.age + 1.

By using a multi assignment statement all values of a tuple can be copied into separate variables:

This assignment copies the name of eva into variable name of type string and her age into age of type int.

A list is an ordered collection of elements of the same type. They are useful to model anything where duplicate values may occur or where order of the values is significant. Examples are waiting customers in a shop, process steps in a recipe, or products stored in a warehouse. Various operations are defined for lists.

An element can be fetched by indexing. This indexing operation does not change the content of the variable. The first element of a list has index 0. The last element of a list has index size(xs) - 1. A negative index, say m, starts from the back of the list, or equivalently, at offset size(xs) + m from the front. You cannot index non-existing elements. Some examples, with xs = [7, 8, 3, 5, 9] are:

In the figure below, the list with indices is visualized. A common name for the first element of a list (i.e., x[0]) is the head of a list. Similarly, the last element of a list (xs[-1]) is also known as head right.

A part of a list can be fetched by slicing. The slicing operation does not change the content of the list, it copies a contiguous sequence of a list. The result of a slice operation is again a list, even if the slice contains just one element.

Slicing is denoted by xs[i:j]. The slice of xs[i:j] is defined as the sequence of elements with index k such that i <= k < j. Note the upper bound j is noninclusive. If i is omitted use 0. If j is omitted use size(xs). If i is greater than or equal to j, the slice is empty. If i or j is negative, the index is relative to the end of the list: size(xs) + i or size(xs) + j is substituted. Some examples with xs = [7, 8, 3, 5, 9]:

The list of all but the first elements (xs[1:]) is often called tail and xs[:-1] is also known as tail right. Below, the slicing operator is visualized:

Two lists can be 'glued' together into a new list. The glue-ing or concatenation of a list with elements 7, 8, 3 and a list with elements 5, and 9 is denoted by:

An element can be added to a list at the rear or at the front. The action is performed by transforming the element into a list and then concatenate these two lists. In the next example the value 5 is added to the rear, respectively the front, of a list:

Elements also can be removed from a list. The del function removes by position, e.g. del(xs, 2) returns the list xs without its third element (since positions start at index 0). Removing a value by value can be performed by the subtraction operator -. For instance, consider the following subtractions:

Every element in the list at the right is searched in the list at the left, and if found, the first occurrence is removed. In the first example, element 2 is removed. In the second example, only the first value 4 is removed and the second value (at position 3) is kept. In the third example, nothing is removed, since value 8 is not in the list at the left.

When the list at the right is longer than one element, the operation is repeated. For example, consider xs - ys, whereby xs = [1, 2, 3, 4, 5] and ys = [6, 4, 2, 3]. The result is computed as follows:

Lists have two relational operators, the equal operator and the not-equal operator. The equal operator (==) compares two lists. If the lists have the same number of elements and all the elements are pair-wise the same, the result of the operation is true, otherwise false. The not-equal operator (!=) does the same check, but with an opposite result. Some examples, with xs = [7, 8, 3]:

The membership operator (in) checks if an element is in a list. Some examples, with xs = [7, 8, 3]:

A list variable is initialized with a list with zero elements, for example in:

The initial value of xs equals <int>[].

A list can be initialized with a number, denoting the number of elements in the list:

This declaration creates a list with 2 elements, whereby each element of type int is initialized. The initial value of ys equals [0, 0]. Another example with a list of lists:

This declaration initializes variable zm with the value [ [0, 0], [0, 0], [0, 0], [0, 0] ].

Set operators for union, intersection and difference are present. The table below gives the name, the mathematical notation and the notation in the Chi language:

The union of two sets merges the values of both sets into one, that is, the result is the collection of values that appear in at least one of the arguments of the union operation. Some examples:

All permutations with the elements 3, 5, 7, 8 and 9 are correct (sets have no order, all permutations are equivalent). To keep sets readable the elements are sorted in increasing order in this tutorial.

Values that occur in both arguments, appear only one time in the result (sets silently discard duplicate elements). For example:

The intersection of two sets gives a set with the common elements, that is, all values that occur in both arguments. Some examples:

Set difference works much like subtraction on lists, except elements occur at most one time (and have no order). The operation computes 'remaining elements'. The result is a new set containing all values from the first set which are not in the second set. Some examples:

The membership operator in works on sets too:

Elements of dictionaries are stored according to a key, while lists elements are ordered by a (relative) position, and set elements are not ordered at all. A dictionary can grow and shrink by adding or removing elements respectively, like a list or a set. An element of a dictionary is accessed by the key of the element.

The dictionary variable d of type dict(string : int) is given by:

Retrieving values of the dictionary by using the key:

Using a non-existing key to retrieve a value results in a error message.

A new value can be assigned to the variable by selecting the key of the element:

This assignment changes the value of the "john" item to 35. The assignment can also be used to add new items:

Membership testing of keys in dictionaries can be done with the in operator:

Merging two dictionaries is done by adding them together. The value of the second dictionary is used when a key exists in both dictionaries:

The left dictionary is copied, and updated with each item of the right dictionary.

Removing elements can be done with subtraction, based on key values. Lists and sets can also be used to denote which keys should be removed. A few examples for p is {1 : 1, 2 : 2}:

Subtracting keys that do not exist in the left dictionary is allowed and has no effect.