# Operators · Chromia Docs (concept)

> Arithmetic operators operate on numerical values, which can be either literals or variables, and they yield a single numerical result.

Source: https://docs.chromia.com/rell/language-features/expressions/operators/

# Operators

On this page

* [Member access](#member-access)
* [Function call](#function-call)
* [Element access](#element-access)
* [Arithmetic operators](#arithmetic-operators)
* [Relational operators](#relational-operators)
* [Equality operators](#equality-operators)
* [Null check operator](#null-check-operator)
* [Logical operators](#logical-operators)
* [Assignment operators](#assignment-operators)
* [At operator](#at-operator)
* [If operator](#if-operator)

### Member access

* Use the dot `.` to access members of objects: `user.name`, `s.sub(5, 10)`

### Function call

* Enclose arguments in parentheses `()`:
  [`print('Hello')`](https://docs.chromia.com/pages/rell-stdlib/-rell-system-library/root/print/), `value.to_text()`

### Element access

* Use square brackets `[]` to access elements by index: `values[i]`

### Arithmetic operators

Arithmetic operators operate on numerical values, which can be either literals or variables, and they yield a single
numerical result.

| Operator | Description |
| --- | --- |
| `+` | The addition (`+`) operator produces the sum of numeric operands or string concatenation. |
| `-` | The subtraction (`-`) operator subtracts the two operands, producing their difference. |
| `*` | The multiplication (`*`) operator produces the product of the operands. |
| `/` | The division (`/`) operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor. |
| `%` | The modulus (`%`) operator returns the remainder of two numbers. |
| `++` | The increment (`++`) operator increments (adds one to) its operand and returns the value before or after the increment. |
| `--` | The decrement (`--`) operator decrements (subtracts one from) its operand and returns the value before or after the decrement. |

### Relational operators

A comparison operator evaluates its operands and produces a Boolean value that indicates whether the comparison is true.

| Operator | Description |
| --- | --- |
| `<` | The less than (`<`) operator returns `true` if the left operand is less than the right operand, and `false` otherwise. |
| `>` | The greater than (`>`) operator returns `true` if the left operand is greater than the right operand, and `false` otherwise. |
| `<=` | The less than or equal (`<=`) operator returns `true` if the left operand is less than or equal to the right operand, and `false` otherwise. |
| `>=` | The greater than or equal (`>=`) operator returns `true` if the left operand is greater than or equal to the right operand, and `false` otherwise. |
| `in` | The `in` operator determines whether an element is present in a specified collection, such as a range, set, map, or any iterable data structure. It returns `True` if the element is found in the collection and `False` otherwise. While it is often used to verify the existence of an element within a collection, it is not primarily used for checking object properties. |
| `not in` | The `not in` operator determines whether an element is not present in a specified collection, such as a range, set, map, or any iterable data structure. It returns `True` if the element is not found in the collection and `False` otherwise. |

### Equality operators

The outcome of assessing an equality operator is consistently in the Boolean data type, determined by the truth or
falsity of the comparison.

| Operator | Description |
| --- | --- |
| `==` | The equality (`==`) operator checks whether its two operands are equal, returning a Boolean result. |
| `!=` | The inequality (`!=`) operator checks whether its two operands are not equal, returning a Boolean result. |
| `===` | The strict equality (`===`) operator checks whether its two operands are equal, returning a Boolean result. Unlike the equality operator, the strict equality operator always considers operands of different types to be different. |
| `!==` | The strict inequality (`!==`) operator checks whether its two operands are not equal, returning a Boolean result. Unlike the inequality operator, the strict inequality operator always considers operands of different types to be different. |

Operators `==` and `!=` compare values. For complex types (collections, tuples, structs), they recursively compare
member values, and for entity values, they compare object IDs.

Operators `===` and `!==` compare references, not values. Use them with types: tuple, struct, list, set, map, GTV, and
range.

Example:

Rell

```
val x = [1, 2, 3];
val y = list(x);
print(x == y);   //true - values are equal
print(x === y);  //false - two different objects
```

### Null check operator

The null check operator `??` is a unary operator that checks if an expression is not null, returning a Boolean result.
It is equivalent to using `!= null`.

| Operator | Description |
| --- | --- |
| `??` | The null check (`??`) operator checks if an expression is not null, returning `true` if the expression is not null and `false` if it is null. |

Example:

Rell

```
val u = user @? { .name == 'Bob' };
if (u??) {
    // "u" is not null
}
```

This code is equivalent to:

Rell

```
val u = user @? { .name == 'Bob' };
if (u != null) {
    // "u" is not null
}
```

### Logical operators

Logical operators can be defined as a type of operators that help us to combine multiple conditional statements. There
are three types of logical operators in Rell: `AND`, `OR` and `NOT` operators.

| Operator | Description |
| --- | --- |
| `and` | The logical `and` operator returns `true` when both conditions under evaluation are true, otherwise it returns `false`. |
| `or` | The logical `or` operator returns `true` if any one of the given conditions is true. It returns `false` if both conditions under evaluation are false. |
| `not` | The logical `not` operator accepts a single value as an input and returns the inverse of the same. This is a unary operator unlike the `and` and `or` operators. |

### Assignment operators

An assignment operator sets the value of its left operand according to the value of its right operand. It's translated
to an update statement.

| Operator | Description |
| --- | --- |
| `=` | The assignment (`=`) operator assigns a value to a variable. The assignment operation evaluates to the assigned value. |
| `*=` | The multiplication assignment (`*=`) operator performs multiplication on the two operands and assigns the result to the left operand. |
| `/=` | The division assignment (`/=`) operator performs division on the two operands and assigns the result to the left operand. |
| `%=` | The remainder assignment (`%=`) operator performs remainder on the two operands and assigns the result to the left operand. |
| `+=` | The addition assignment (`+=`) operator performs addition on the two operands and assigns the result to the left operand. |
| `-=` | The subtraction assignment (`-=`) operator performs subtraction on the two operands and assigns the result to the left operand. |

Example:

You can specify an arbitrary expression returning a entity, a nullable entity, or a collection of entities:

Plain text

```
val u = user @? { .name == 'Bob' };
update u ( salary += 5000 );
```

You can modify a single attribute by a regular assignment syntax:

Plain text

```
val u = user @ { .name == 'Bob' };
u.salary += 5000;
```

### At operator

Use the at `@` operator for retrieving objects. For more information see,
[At-operator](https://docs.chromia.com/rell/language-features/database/overview/#-operator).

### If operator

Use the `if` operator for conditional evaluation.

Plain text

```
variable = IF expression THEN expression ELSE expression
```

Example:

Rell

```
function max_of(a: integer, b: integer) {
    val max = if (a >= b) a else b;
    return max;
}

print(max_of(7, 3));   // 7
```

For the full form, including `when` and value block arms, see [Conditional expressions](https://docs.chromia.com/rell/language-features/expressions/conditional-expressions/).

[View this page on docs.chromia.com](https://docs.chromia.com/rell/language-features/expressions/operators/)Content mirrored from the live docs
