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: