An expression is a part of an instruction used to determine or evaluate a single object.

The simplest form of an expression consists of a literal or an object reference, as shown below:

// simple expressions consisting of a literal
"123" // string
123   // integer
'a'   // character
yes   // yes_no

// simple expressions consisting of an object reference
c_identifier  // constant
v_name        // variable
i_index       // input argument
o_result      // output argument
a_city        // attribute

An expression is often used in assignment instructions. Thus, in the following instruction, an expression consisting of the string "Hello" is assigned to variable greeting of type string:

var string greeting = "Hello"

A more complex expression can be defined by repeatedly getting the value of an attribute or the result of a command from an intermediate result of the expression. This can be done as follows:

Both ways (i.e. getting attributes, and getting results of commands) can be combined, as follows:

const zero_positive32 character_count = c_orange.co_convert_to_XML.a_item_count

There is no limit for the complexity of an expression, but well written programs rarely surpass 5 levels of nesting.

The resulting type of an expression is always the type of the last object evaluated.

Consider again the following instruction:

const zero_positive32 character_count = c_orange.co_convert_to_XML.a_item_count

In this case the first type encountered during the evaluation of the expression is product (the type of c_orange). Then, after evaluating co_convert_to_XML, the intermediate result is of type string (because co_convert_to_XML returns a string object), and the final result is an object of type zero_positive32 (because that's the type of attribute item_count in type string). Hence, the type of the entire expression is zero_positive32.

Because Obix is a statically typed language, the compiler always checks the type compatibility of an expression assigned to an object reference.

For more information about static typing please refer to:

Expressions are often used to do arithmetic calculations.

Suppose, for example, we want to compute 3 * 4 + 5 * 17, and assign the result to variable result.

A multiplication on an integer object is done in Obix with command multiply, and two numbers can be added with command add. Thus, the code looks like this:

var positive32 result = 3.multiply(4).add(5.multiply(17))

It is important to note that the mathematical precedence rule 'multiplication before addition' requires us to write

3.multiply(4).add(5.multiply(17))

instead of

3.multiply(4).add(5).multiply(17)

which would indeed compute (3 * 4 + 5) * 17.

The above code shows the 'pure OO way' to do it. Obviously, this is quite error-prone, because it is a bit cumbersome to write and the mathematical precedence rules have to be observed and programmed manually. Moreover, the expression

3.multiply(4).add(5.multiply(17))

is certainly less readable than

3 * 4 + 5 * 17

Therefore, Obix provides expression operators, and the precedence rules (e.g. multiplication before addition) are built into the language.

The benefit is that the above instruction can now simply be rewritten as:

var positive32 result = 3 * 4 + 5 * 17

The compiler implicitly converts this instruction into the first one, so that we don't need anymore to care about it.

An expression operator is a symbol used as a replacement (or shortcut) for a command.

For example, the expression operator * (multiply) is a shortcut for command multiply, which means that

3 * 4

is equivalent to

3.multiply(4)

The following table lists the operators defined in Obix.

Expression operators are typically used with scalar types (e.g. integers, strings, booleans), but there usage is not limited to these types. They can be used with any other type, as long as the command represented by the operator exists in the type.

For example, suppose we create a new type complex_number with commands add and multiply. If c1 and c2 are variables of type complex_number, then

c1 = c1.add(c1.multiply(c2))

can more simply be written as

c1 = c1 + c1 * c2

The following table lists the precedences of Obix's expression operators. A higher priority means prioritized evaluation. For example, a multiplication is evaluated before an addition.

The syntax of an expression is shown below:

Instructions that use expressions: