Computations

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

TEXT

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

Returns a text value containing the text representation of C0CN.

Examples: (text just a few strings), (text (string just a single string)), (text There are (+ 3 1) lights!), (text (text (text well...))).

Aliases: text.

VARIABLE | REFERENCE

(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 {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 | PROCEDURE

(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 FIELD ACCESS

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

TEMPORARY VARIABLES

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

Defines a hierarchical level and local variables V0VN with values C0CN, and returns the value of result.

Examples:

Aliases:

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

Examples:

Aliases:

RANDOM NUMBER

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

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

Examples:

Aliases:

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.

Examples:

Aliases:

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

Examples:

Aliases:

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.

Examples:

Aliases: