Computations are values. They may read from the memory, but do not modify it.

`(text [C0: COMPUTATION]...[CN: COMPUTATION])`

Returns a `text`

value containing the text representation of `C0`

…`CN`

.

**Examples:** `(text just a few strings)`

,
`(text (string just a single string))`

, `(text There are (+ 3 1) lights!)`

,
`(text (text (text well...)))`

.

**Aliases:** `text`

.

`(var {String})`

Returns the value of the variable `{String}`

, or a reference to it if
applicable. In cases where no `text`

or `string`

value is expected, using
`{String}`

instead of `(var {String})`

will work as a shortcut.

Structure members can be accessed by using `.`

in `{String}`

. Collection
(`list`

or `set`

) elements can be similarly accessed by their index.

**Examples:** `(var my_list)`

, `(var my_list.0)`

, `(var my_list.0.name)`

.

**Aliases:** `var`

, `variable`

.

`(string {String})`

Returns a `string`

value corresponding to `{String}`

. This can be used
to disambiguate strings and variable names, as well as to create strings with
spaces.

**Examples:**
`(string just a single string)`

, `(string var0_is_not_a_var)`

**Aliases:** `string`

.

`(sequence {String})`

Returns a `[SEQUENCE]`

value corresponding to the sequence named `{String}`

.
Said sequence can be defined at a later point.

**Examples:** `(sequence the_cave)`

, `(sequence end_credits)`

.

**Aliases:** `seq`

, `sequence`

.

`{Structure Variable Name}.{Field Name}`

`(struct:field {String} [STRUCTURE])`

Accesses the `{String}`

field of the structure `[STRUCTURE]`

. Using `.`

to
access fields is recommended over the use of this operator when possible. The
returned value can act as a reference.

**Examples:** `claude.health_points`

, `(struct:field health_points jack)`

,
`(struct:field stamina (car (list:pop_left character_list)))`

**Aliases:** `struct:field`

, `struct:get`

, `struct:getfield`

,
`struct:get_field`

.

```
(let
(
({V0: String} [C0: COMPUTATION])
...
({VN: String} [CN: COMPUTATION])
)
[result: COMPUTATION]
)
```

Defines a hierarchical level and local variables `V0`

… `VN`

with values `C0`

… `CN`

, and returns the value of `result`

.

**Examples:**

**Aliases:**

`(cast [TYPE] [COMPUTATION*])`

Transforms `[COMPUTATION*]`

into a value of type `[TYPE]`

. Note that the variable
shorthand cannot be used for `[COMPUTATION*]`

. The following type changes are
allowed:

`[FLOAT]`

to`[FLOAT]`

,`[INT]`

, and`[STRING]`

.`[INT]`

to`[FLOAT]`

,`[INT]`

, and`[STRING]`

.`[BOOL]`

to`[BOOL]`

and`[STRING]`

.`[STRING]`

to`[BOOL]`

(`true`

and`false`

),`[FLOAT]`

,`[INT]`

, and`[STRING]`

.

**Examples:**

**Aliases:**

`(rand [I0: INT] [IN: INT])`

Returns a random number between `I0`

and `IN`

(inclusive).

**Examples:**

**Aliases:**

`(and [B0: BOOL] ... [BN: BOOL])`

Standard conjunction (minimum of 2 arguments).

`(or [B0: BOOL] ... [BN: BOOL])`

Standard disjunction (minimum of 2 arguments).

`(not [BOOL])`

Standard negation.

`(implies [B0: BOOL] [B1: BOOL])`

Standard implication.

`(one_in [B0: BOOL] ... [BN: BOOL])`

true if, and only if, exactly one of the operands is true.

**Examples:**

**Aliases:**

All operands must be of the same type, which is also the type returned by the operation.

`(+ [N0: NUMBER] ... [NN: NUMBER])`

Standard addition (minimum of 2 arguments).

`(- [N0: NUMBER] ... [NN: NUMBER])`

Standard substraction (minimum of 2 arguments).

`(* [N0: NUMBER] ... [NN: NUMBER])`

Standard multiplication (minimum of 2 arguments).

`(/ [N0: NUMBER] [N1: NUMBER])`

Standard division. Note that a division on integers is indeed a integer division.

`(^ [N0: NUMBER] [N1: NUMBER])`

Standard exponentiation.

`(% [I0: INT] [I1: INT])`

Standard modulo operation.

`(min [N0: NUMBER] ... [NN: NUMBER])`

Lowest value among the operands.

`(max [N0: NUMBER] ... [NN: NUMBER])`

Highest value among the operands.

`(clamp [N0: NUMBER] [N1: NUMBER] [N2: NUMBER])`

Equivalent to `(max N0 (min N1 N2))`

.

`(abs [NUMBER])`

Positive value of `[NUMBER]`

.

**Examples:**

**Aliases:**

`(= [C0: COMPUTATION] ... [CN: COMPUTATION])`

True if, and only if, all operands are equal.

`(< [C0: COMPARABLE] [C1: COMPARABLE])`

True if, and only if, `C0`

is strictly lower than `C1`

.

`(=< [C0: COMPARABLE] [C1: COMPARABLE])`

True if, and only if, `C0`

is lower or equal to/than `C1`

.

`(> [C0: COMPARABLE] [C1: COMPARABLE])`

True if, and only if, `C0`

is strictly higher than `C1`

.

`(>= [C0: COMPARABLE] [C1: COMPARABLE])`

True if, and only if, `C0`

is higher or equal to/than `C1`

.

**Examples:**

**Aliases:**