Computations

Computations are operations returning values. They do not modify the memory.

TEXT

(text [C0 = COMPUTATION] ... [CN = COMPUTATION])

Returns a text node containing the text representation of C0 … CN.

VARIABLE | REFERENCE

(var {String})

Returns the value of the variable {String}, or a reference to it if applicable. Structure members can be accessed by using . in {String}.

SEQUENCE | PROCEDURE

(sequence {String})

Returns a [SEQUENCE] value corresponding to the sequence named {String}. Said sequence can be defined at a later point.

STRUCTURE FIELD ACCESS

{Structure Var Name}.{Field Name}
(field {String} [STRUCTURE VAR])

Accesses the {String} field of the structure [STRUCTURE VAR]. Using . to access fields is recommended over the use of this operator.

STRUCTURE FIELD VALUE

(get_field {String} [STRUCTURE])
Returns the value of the {String} field of the structure [STRUCTURE].

TEMPORARY VARIABLES

(let (({V0 = String} [C0 = COMPUTATION]) ... ({VN = String} [CN = COMPUTATION])) [R = COMPUTATION])

Defines a hierarchical level and local variables {V0} … {VN} with values [C0] … [CN], and returns the value of [R].

CAST

(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].

RANDOM NUMBER

(rand [I0 = INT] [IN = INT])

Returns a random number between I0 and IN (inclusive).

Basic Operators

BOOL OPERATORS

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

MATH OPERATORS

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

COMPARISON OPERATORS

(= [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.