Operators

Member access

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

Function call

• Enclose arguments in parentheses (): print('Hello'), 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:

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

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:

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

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

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

At operator

Use the at @ operator for retrieving objects. For more information see, At-operator.

If operator

Use the if operator for conditional evaluation.

variable = IF expression THEN expression ELSE expression

Example:

val max = if (a >= b) a else b
return max