Table of Contents

Glossary

This glossary defines common terms used in the Expr documentation.

For exact syntax, see Formal reference. For behavior details, follow the related chapter links.

A

Term Meaning Related
Argument A value passed to a function, method, class constructor, or built-in object constructor. Functions, Methods and properties
Array A built-in collection object that stores ordered values. array, Collections
Assignment Storing a value into a variable, field, or writable property. Variables and assignment
Assignment result The value produced by an assignment expression. Normal and compound assignment return the assigned value. Expression rules

B

Term Meaning Related
Block A sequence of statements inside braces. Blocks can create local scopes and can also produce a value. Control flow, Scope and set
Built-in function A global function registered by Expr or the host application. Built-in functions
Built-in method A method available on core values such as strings and numbers. Built-in methods
Built-in object An object type or global object provided by Expr or the host application. Built-in objects

C

Term Meaning Related
Callback A callable reference stored by an object and invoked later, often by a timer, GUI object, serial monitor, or host operation. Execution model and sessions
Callable reference An object value that refers to a function, method, or built-in callable target. Host objects can use callable references as callbacks. Type system, Objects
Class A user-defined object template declared with `class`. Calling the class name creates an object instance. Classes and user-defined objects
Class constructor The code in a class body that runs when a class is called to create an object. Classes and user-defined objects
Compatibility option A parser or host mode enabled for a specific host context, such as named operators or G-code hash variables. Host integration
Compound assignment An assignment form such as `+=`, `-=`, `*=`, `/=`, or `**=` that reads the target, applies an operator, and stores the result. Variables and assignment, Operators
Constructor A callable name that creates an object. This can be a user class constructor or a built-in object constructor such as `array()` or `timer(…)`. Objects, Classes and user-defined objects

D

Term Meaning Related
Data buffer Binary or byte-oriented data stored in a `bytes` object. bytes
Declaration A top-level definition such as `function`, `class`, or `include`. Formal reference

E

Term Meaning Related
Evaluation Running parsed Expr code in an evaluation context connected to a session. Execution model and sessions
Evaluation context The temporary runtime context used during one evaluation. It contains call state, local scopes, output routing, and the active session connection. Execution model and sessions
Evaluation result The final value produced by a script or expression. Execution model and sessions
Expression A piece of Expr code that produces a value or side effect. Assignments, function calls, blocks, `if`, and loops are expressions. Expression rules
Expr PlanetCNC Expression language, used for runtime customization, automation, custom dialogs, G-code integration, probing, ATC scripts, and other host scripting tasks. Reference

F

Term Meaning Related
Field A named value stored on a user-defined object instance. Classes and user-defined objects
Function A callable piece of code. Functions can be built-in or user-defined with `function`. Functions
Function parameter A local name bound to an argument value when a function, method, or class constructor is called. Functions, Scope and set

G

Term Meaning Related
G-code compatibility Host-enabled behavior used when Expr is called from G-code expression evaluation. Host integration
Global object A predefined object available directly by name, such as `settings`, `controller`, `session`, or `python`. Global objects

H

Term Meaning Related
Hash variable G-code compatibility syntax such as `#1`, `#name`, or `#<name>`. When enabled by the host, Expr variables and G-code parameters refer to the same names in that context. Lexical basics, Host integration
Host The application embedding Expr. The host chooses sessions, output routing, exposed objects, include paths, and compatibility options. Host integration

I

Term Meaning Related
Include A parse-time import of another Expr file. Include system
Include alias A namespace name supplied by `include 'file.expr' as Name`. Imported functions and classes use the alias namespace. Include system
Instance An object created by calling a class constructor or built-in object constructor. Objects, Classes and user-defined objects

L

Term Meaning Related
Local scope A temporary scope for local variables, usually created by blocks, functions, methods, or constructors. Scope and set
Local variable A variable created with `set` or by parameter binding. It exists only in its local scope. Scope and set

M

Term Meaning Related
Map A built-in collection object that stores key-value pairs. map, Collections
Method A function called through an object, such as `obj.Name(…)`. User classes define methods with `function` inside the class body. Methods and properties, Classes and user-defined objects
Method call A call using member syntax, such as `text.trim()` or `obj.Update(value)`. Methods and properties

N

Term Meaning Related
NaN A numeric value meaning not a valid number. It is still a number type, but not a finite usable number. Type system, none and nan functions
Named operator Compatibility operator word such as `AND`, `OR`, `NOT`, `DIV`, `MOD`, `EQ`, or `NE`. Named operators require host compatibility mode. Operators, Host integration
Namespace A qualifier before a function or class name, such as `Math::Add`. Namespaces help avoid name collisions. Include system, Functions
None The `none()` value. It represents no value, a missing value, or a cleared variable. Type system, none and nan functions

O

Term Meaning Related
Object A value that contains state and exposes methods or properties. Arrays, maps, GUI controls, timers, serial ports, and user class instances are objects. Objects
Object constructor A built-in callable that creates an object, such as `array()`, `map()`, `timer(…)`, or `serial()`. Built-in objects
Object field A named value stored on a user-defined object instance. Classes and user-defined objects
Output sink The destination selected by the host for text produced by `print()` and related functions. Host integration, Output, Formatting, Clipboard, and Errors

P

Term Meaning Related
Parameter A local name listed in a function, method, or class constructor declaration. It receives an argument value when called. Functions
Parse error An error detected before script execution starts, such as invalid syntax or an invalid declaration position. Error model
Property A named value exposed by an object through member syntax, such as `obj.name`. Some properties are read-only and some are writable. Methods and properties

R

Term Meaning Related
Recursive include An include chain that reaches a file already being parsed. Expr rejects recursive include chains. Include system
Root variable A session-level variable visible from the root/session scope. It can persist between evaluations when the same named session is reused. Variables and assignment, Execution model and sessions
Runtime error An error detected while code is running, such as a type error, divide-by-zero, unknown function, or host operation failure. Error model

S

Term Meaning Related
Scope A name lookup and storage region. Expr uses root/session scope, local scopes, and object field scope. Scope and set
Script Expr source text evaluated by the host. A script can be a short expression, a file, an include file, or a larger automation program. Host integration
Session A named state container that stores root variables, user functions, user classes, global objects, and the last result. Execution model and sessions, session
Session variable A root variable stored in the active session. Variables and assignment
Short-circuit Logical behavior where the right operand is skipped when the result is already known. && and || short-circuit. ^^ does not. Expression rules, Operators
Statement A unit of source code in a program or block. Many Expr statements are expressions followed by `;`. Formal reference
String A text value. Strings have methods for parsing, searching, splitting, trimming, and conversion. Type system, Built-in methods

T

Term Meaning Related
This The current object inside a class constructor or method. Classes and user-defined objects
Truthiness The rule used to convert a value to true or false for `if`, loops, logical operators, and the conditional operator. Type system, Expression rules
Type conversion Converting a value to another representation, usually through value methods such as `.to_string()` or `.to_num()`. Type system, Built-in methods

U

Term Meaning Related
User function A script-defined function declared with `function`. Functions
User-defined object An object created from an Expr class. Classes and user-defined objects

V

Term Meaning Related
Value A runtime result such as `none()`, number, string, or object. Type system
Variable A named storage location for a value. Variables can be root/session variables, local variables, parameters, or object fields. Variables and assignment

W

Term Meaning Related
Wrapper marker Host or G-code embedding syntax such as {! ... !} around Expr text. Wrapper markers are not core Expr syntax. Host integration

Previous: Formal reference

Reference index: Reference