Expressions - Vala Reference Manual

## 4. Expressions

Expressions are short pieces of code that define an action that should be taken when they are reached during a program's execution. Such an operation can be arithmetical, calling a method, instantiating a type, and so on. All expressions evaluate to a single value of a particular type - this value can then be used in another expression, either by combing the expressions together, or by assigning the value to an identifier.

When expressions are combined together (e.g. add two numbers, then multiply the result by another: 5 + 4 * 3), then the order in which the sub-expressions are evaluated becomes significant. Parentheses are used to mark out which expressions should be nested within others, e.g. (5 + 4) * 3 implies the addition expression is nested inside the multiplication expression, and so must be evaluated first.

When identifiers are used in expressions they evaluate to their value, except when used in assignment. The left handed side of an assignment are a special case of expressions where an identifier is not considered an expression in itself and is therefore not evaluated. Some operations combine assignment with another operation (e.g. increment operations,) in which cases an identifier can be thought of as an expression initially, and then just an identifier for assignment after the overall expression has been evaluated.

> primary-expression: literal template member-access-expression pointer-member-access-expression element-access-expression postfix-expression class-instantiation-expression array-instantiation-expression struct-instantiation-expression invocation-expression sizeof-expression typeof-expression unary-expression: primary-expression sign-expression logical-not-expression bitwise-not-expression prefix-expression ownership-transfer-expression cast-expression pointer-expression expression: conditional-expression assignment-expression lambda-expression

### 4.1 Literal expressions

Each literal expression instantiates its respective type with the value given.

Integer types... -?[:digit:]+

Floating point types... -?[:digit:]+(.[:digit:]+)?

Strings... "[^"\n]*". """.*"""

Booleans... true|false

A final literal expression is `null`. This expression evaluates to a non-typed data instance, which is a legal value for any nullable type (see Types/Nullable types.)

### 4.2 Member access

To access members of another scope.

> member-access-expression: [ primary-expression . ] identifier

If no inner expression is supplied, then the identifier will be looked up starting from the current scope (for example a local variable in a method). Otherwise, the scope of the inner expression will be used. The special identifier this (without inner expression) inside an instance method will refer to the instance of the type symbol (class, struct, enum, etc.).

### 4.3 Element access

> element-access-expression: container [ indexes ] container: expression indexes: expression [ , indexes ]

Element access can be used for:

- Accessing an element of a container at the given indexes

- Assigning an element to a container at the given indexes. In this case the element access expression is the left handed side of an assignment.

Element access can be used on strings, arrays and types that have get and/or set methods.

- On strings you can only access characters, it's not possible to assign any value to an element.

- On arrays, it's possible to both access an element or assign to an element. The type of the element access expression is the same as the array element type.

Element access can also be used with complex types (such as class, struct, etc.) as containers:

- If a get method exists accepting at least one argument and returning a value, then indexes will be used as arguments and the return value as element.

- If a set method exists accepting at least two arguments and returns void, then indexes will be used as arguments and the assigned value as last argument..

### 4.4 Arithmetic operations

Binary operators, taking one argument on each side. Each argument is an expression returning an appropriate type.

Applicable, unless said otherwise, where both operands evaluate to numeric types (integer or floating point).

Where at least one operand is a of floating point type, the result will be the same type as the largest floating point type involved. Where both operands are of integer types, the result will have the same type as the largest of the integer types involved.

Addition/Subtraction:

> additive-expression: multiplicative-expression multiplicative-expression + multiplicative-expression multiplicative-expression - multiplicative-expression sign-expression: + unary-expression - unary-expression

Adds/Subtracts the second argument to/from the first. Negations is equivalent to subtraction the operand from 0.

Overflow?

Multiplication/Division:

> multiplicative-expression: unary-expression unary-expression * unary-expression unary-expression / unary-expression unary-expression % unary-expression

Multiplies/divides the first argument by the second.

If both operands are of integer types, then the result will be the quotient only of the calculation (equivalent to the precise answer rounded down to an integer value.) If either operand is of a floating point type, then the result will be as precise as possible within the boundaries of the result type (which is worked out from the basic arithmetic type rules.)

### 4.5 Relational operations

Result in a value of bool type.

Applicable for comparing two instances of any numeric type, or two instances of string type. Where numeric with at least one floating point type instance, operands are both converted to the largest floating point type involved. Where both operands are of integer type, both are converted to the largest integer type involved. When both are strings, they are lexically compared somehow.

> equality-expression: relational-expression relational-expression == relational-expression relational-expression != relational-expression relational-expression: shift-expression shift-expression < relational-expression shift-expression <= relational-expression shift-expression > relational-expression shift-expression >= relational-expression is-expression as-expression

### 4.6 Increment/decrement operations

> postfix-expression: primary-expression ++ primary-expression -- prefix-expression: ++ unary-expression -- unary-expression

Postfix and prefix expressions:

    var postfix = i++;
    var prefix = --j;

are equivalent to:

    var postfix = i;
    i += 1;

    j -= 1;
    var prefix = j;

### 4.7 Logical operations

Applicable to boolean type operands, return value is of boolean type. No non boolean type instances are automatically converted.

> logical-or-expression: logical-and-expression || logical-and-expression

Documentation

> logical-and-expression: contained-in-expression && contained-in-expression

Documentation

> logical-not-expression: ! expression

### 4.8 Bitwise operations

All only applicable to integer types.

> bitwise-or-expression: bitwise-xor-expression | bitwise-xor-expression bitwise-xor-expression: bitwise-and-expression ^ bitwise-and-expression bitwise-and-expression: equality-expression & equality-expression bitwise-not-expression: ~ expression

Documentation

> shift-expression: additive-expression << additive-expression additive-expression >> additive-expression

Shifts the bits of the left argument left/right by the number represented by the second argument.

Undefined for shifting further than data size, e.g. with a 32 bit integer...

Documentation

### 4.9 Assignment operations

Value assigned to identifier on left. Type must match.

When assignment includes another operation natural result type must match the declared type of variable which is the left hand side of the expression. e.g. Let a be an int instance with the value 1, a += 0.5 is not allowed, as the natural result type of 1 + 0.5 is a float, not an int.

> assignment-expression: simple-assignment-expression number-assignment-expression simple-assignment-expression: conditional-expression = expression number-assignment-expression: conditional-expression += expression conditional-expression -= expression conditional-expression *= expression conditional-expression /= expression conditional-expression %= expression conditional-expression |= expression conditional-expression &= expression conditional-expression ^= expression conditional-expression <<= expression conditional-expression >>= expression

A simple assignment expression assigns the right handed side value to the left handed side. It is necessary that the left handed side expression is a valid lvalue. Other assignments:

    result += value;
    result <<= value;
    ...

Are equivalent to simple assignments:

    result = result + value;
    result = result << value;
    ...

### 4.10 Invocation expressions

> invocation-expression: [ yield ] primary-expression ( [ arguments ] ) arguments: expression [ , arguments]

The expression can refer to any callable: a method, a delegate or a signal. The type of the expression depends upon the return type of the callable symbol. Each argument expression type must be compatible against the respective callable parameter type. If an argument is not provided for a parameter then:

If the callable has an ellipsis parameter, then any number of arguments of any type can be provided past the ellipsis.

Delegates... See Delegates

Firing a signal is basically the same. See Classes/Signals

### 4.11 Class instantiation

To instantiate a class (create an instance of it) use the `new` operator. This operator takes a the name of the class, and a list of zero or more arguments to be passed to the creation method.

> class-instantiation-expression: new type-name ( arguments ) arguments: expression [ , arguments ]

### 4.12 Struct instantiation

> struct-instantiation-expression: type-name ( arguments ) [ { initializer } ] initializer: field-name = expression [ , initializer ] arguments: expression [ , arguments ]

### 4.13 Array instantiation

This expression will create an array of the given size. The second approach shown below is a shorthand to the first one.

> array-instantiation-expression: new type-name [ sizes ] [ { [ initializer ] } ] { initializer } sizes: expression [ , sizes ] initializer: expression [ , initializer ]

Sizes expressions must evaluate either to an integer type or an enum value. Initializer expressions type must be compatible with the array element type.

### 4.14 Conditional expressions

Allow a conditional in a single expression.

> conditional-expression: boolean-expression [ ? conditional-true-clause : conditional-false-clause ] boolean-expression: coalescing-expression conditional-true-clause: expression conditional-false-clause expression

First boolean-expression is evaluated. If true, then the conditional-true-clause is evaluated, and its result is the result of the conditional expression. If the boolean expression evaluates to false, then the conditional-false-clause is evaluated, and its result becomes the result of the conditional expression.

### 4.15 Coalescing expressions

> coalescing-expression: nullable-expression [ ?? coalescing-expression ] nullable-expression: logical-or-expression

### 4.16 Flag operations

Flag types are a variation on enumerated types, in which any number of flag values can be combined in a single instance of the flag type. There are therefore operations available to combine several values in an instance, and to find out which values are represented in an instance.

> flag-combination-expression: expression | expression

Where both expressions evaluate to instances of the same flag type, the result of this expression is a new instance of the flag type in which all values represented by either operand are represented.

> flag-recombination-expression: expression ^ expression

Where both expressions evaluate to instances of the same flag type, the result of this expression is a new instance of the flag type in which all values represented by exactly one of the operands are represented.

> flag-separation-expression: expression & expression

Where both expressions evaluate to instances of the same flag type, the result of this expression is a new instance of the flag type in which all values represented by both operands are represented.

> flag-in-expression: expression in expression

Where both expressions evaluate to instances of the same flag type, the result of this expression is a boolean. The result will be true if the left-handed flag is set into the right-handed flags.

### 4.17 Type operations

> is-expression: shift-expression is type-name

Performs a runtime type check on the instance resulting from evaluating the the nested expression. If the instance is an instance of the type described (with, for example, a class or interface name,) the overall expression evaluates to true.

Casting:

> cast-expression: (!) unary-expression ( type-name ) unary-expression

A cast expression returns the instance created in the nested expression as an instance of the type described. If the nested expression evaluates to an instance of a type that is not also an instance of the given type, the expression is not valid. If you are not sure whether the cast is valid, instead use an "as" expression.

> as-expression: shift-expression as type-name

An "as" expression combines an "is" expression and a cast operation, with the latter depending on the former. If the nested expression evaluates to an instance of the given type, then a cast is performed and the expression evaluates to the result of the nested expression cast as the given type. Otherwise, the result is null.

> sizeof-expression: sizeof ( type-name ) typeof-expression: typeof ( type-name )

### 4.18 Ownership transfer expressions

> ownership-transfer-expression: (owned) unary-expression

When an instance of a reference type is assigned to a variable or field, it is possible to request that the ownership of the instance is passed to the new field or variable. The precise meaning of this depends on the reference type, for an explanation of ownership, see Concepts/References and ownership. The identifier in this expression must refer to an instance of a reference type.

Note that similar syntax is used to define that a method parameter should take ownership of a value assigned to it. For this, see Methods.

### 4.19 Lambda expressions

> lambda-expression: params => body params: [ direction ] identifier ( [ param-names ] ) param-names: [ direction ] identifier [ , param-names ] direction: out ref body: statement-block expression

### 4.20 Pointer expressions

> addressof-expression: & unary-expression

The "address of" expression evaluates to a pointer to the inner expression. Valid inner expressions are:

- Variables (local variables, fields and parameters)

- Element access whose container is an array or a pointer

  pointer-indirection-expression:

The pointer indirection evaluates to the value pointed to by the inner expression. The inner expression must be a valid pointer type and it must not be a pointer to a reference type (for example pointer indirection to a type `SomeClass*` is not possible).

> pointer-member-access-expression: primary-expression -> identifier

This expression evaluates to the value of the member identified by the identifier. The inner expression must be a valid pointer type and the member must be in the scope of the base type of the pointer type.