Control-Flow on TrustLang

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):

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).

Reflections on structured programming

Sun, 31 Dec 2023 00:00:00 +0000

31 Dec 2023 at 11:53

Initially I wanted to title the article in some provocative way, for example, “How science can turn into religion”, “Trapped in the distortions of the meaning of structured programming” or “What you were not told about structured programming”, but in the end I still kept the current title and I hope it does not irritate the readers. And although the other titles are more clickbaity, nevertheless they still reflect the meaning of the article to a greater extent than the neutral “reflections”.