Operators on TrustLang

Creating objects and assignment

Mon, 01 Jan 0001 00:00:00 +0000

Creating objects

TrustLang uses several operators to create objects:

Operators

Mon, 01 Jan 0001 00:00:00 +0000

Arithmetic operators

The arithmetic operators of TrustLang are applicable to numeric types and to assignment forms. Each binary operator has a paired analog op=, which performs the operation and assigns the result to the left operand (a += 1;):

Operator	Action
`+` / `+=`	addition
`-` / `-=`	subtraction
`` / `=`	multiplication (also applicable for repeating strings)
`/` / `/=`	division (the result is a floating-point number)
`//` / `//=`	integer division rounded toward the smaller value (as in Python)
`%` / `%=`	remainder of integer division

There is no separate exponentiation operator (the power is computed by a function/repeated multiplication). Arithmetic of rational numbers and :BigInteger is a separate strict branch: mixing with floating-point numbers requires an explicit conversion (see Numbers and tensors).

Conditions and loops

Mon, 01 Jan 0001 00:00:00 +0000

In TrustLang there is no if keyword: a condition is checked by a construct that in meaning corresponds to the mathematical “follows” — two dashes and an angle bracket -->. The notation is easily combined into chains for checking several conditions of the “else if” kind. Below the construct is shown in both forms — the DSL macro and the base syntax (about the two notation forms see Macros and DSL):

Context manager (with)

Mon, 01 Jan 0001 00:00:00 +0000

The single statement for capturing a reference and synchronizing access to an object (*ref, *ref(...)) is executed for one action. Capturing a reference/synchronization object is a relatively slow operation, so performing it for each action is inefficient. The context manager (with) captures several references/objects at once and performs a group of actions under a common lock, and also serves for automatic resource release (RAII) when leaving the block.

In the base syntax — the operator **( ... ); in DSL it corresponds to the macro @with (see Keyword syntax (DSL)). Comparison of the notation forms using the example of capturing-locking a reference:

Expressions and statements

Mon, 01 Jan 0001 00:00:00 +0000

In TrustLang any construct is an expression and returns a value, so it can be nested inside other expressions. Statements are separated by a semicolon ;; a group of statements is enclosed in a code block { ... }. The basic rules of blocks and expressions are described in Syntax.

Handling of emergencies and guarantees of resource release are related to the Memory model, and typing operators — to the Type system.

Return, interrupts and error handling

Mon, 01 Jan 0001 00:00:00 +0000

A sequence of commands (a code block) can be interrupted at any point by special interrupt statements. TrustLang uses two kinds of interrupts, which in meaning correspond to their notation:

“positive” interrupt ++ — return of a value/through-flow (analog of return);
“negative” interrupt -- — error (analog of throw).

An interrupt can return a value: ++ 'String' ++ — return a string, -- err -- — “throw” an error (a rough analog of throw err). If no value is specified, the interrupt returns nothing (an empty value).