The evaluator supports the following variable types:

boolboolean (true or false)n/an/a
intsigned 32-bit integer-21474836482147483647
uintunsigned 32-bit integer04294967295
int64signed 64-bit integer-92233720368547758089223372036854775807
uint64unsigned 64-bit integer018446744073709551615
doubledouble-precision floating point1.7E-3081.7E+308
datedate/time1601-01-01 00:00:009999-12-31 23:59:59
mapvalue containern/an/a

When you initialise a variable, some types are inferred automatically:

ExampleInitialises as
x = true;bool
x = false;bool
x = 15;uint
x = -15;int
x = 5000000000;uint64
x = -5000000000;int64
x = 1185.15;double
x = "string";str
x = [a = 1; b = 2;];map

There are two ways you can explicity initialise a variable as a certain type. This is required for date and path variables which are always initialised from strings.

  • You can use the As operator, for example d = "2023-08-20" as date;
  • You can use the : operator, for example d: date = "2023-08-20";

For example, to initialise a variable as a path as opposed to a plain string:

p = "C:\Windows" as path;
p = p + "System32";

--> "C:\Windows\System32"

Note in the above example that the final string contains a backslash between "Windows" and "System32" - that's because it was initialised as a path variable, and adding strings to path variables adds path separators automatically.

See the documentation for the As operator for more details on explicit initialisation. The : operator uses the same type keywords as the As operator does.

The evaluator will implicitly convert variable types if needed. For example, if you call a function that's documented as taking an int but you pass it a uint, and int64 or even a str, the value will be converted automatically (assuming such a conversion is possible, of course).

You can use the TypeOf function to determine a variable's type.

Variable names

Ordinary variables must begin with a letter; after that, they can contain any number of letters, numbers or symbols like _ and $.

The evaluator also lets you access external variables that begin with a $ sign. For example, a function that uses @set name Jon and then invokes evaluator code would be able to access that variable using the name $name. External variables scoped to tabs and Listers can be accessed, for example $glob:name would let you get or set a globally scoped variable from within the evaluator.

Normally, attempting to use the value of a variable that doesn't exist causes an error, however for compatibility reasons, variables that begin with a $ allow this - if they haven't been previously defined they'll simply return an empty string.

You can also access environment variables from evaluation code as you can in normal functions. For example,

--> C:\Program Files

You can set environment variables from evaluation code too but note that this only affects the environment inside Opus itself - globally the rest of the system won't see the changed value.

Numeric constants

You can express numeric constants in a number of ways:

  • Plain decimal numbers such as 15 or -15.
  • Hexadecimal numbers such as 0xe.
  • Size values such as 5kb, 21gb, 1.75tb (note: only supports binary units.)
  • Date units using suffixes h (hour), m (minute), s (second), d (day), M (month) and y (year) when adding to or subtracting from dates.
  • Fractional numbers such as 1185.15.
  • true and false are also available as boolean constants.
  • pi is predefined as the value of π.
Value containers

A value container is a variable that can contain other variables - similar to a struct in C++ or a map in JavaScript.

Value containers are defined using the [ ] operator. The square brackets act like a scope - within the brackets, variables you assign will become members of the container. For example,

// defines an empty container
x = [ ];

// defines a container with three members
x = [ a = 5; b = 10; c = "hello!"; ];

After a value container is created and / or initialised, you can access its member variables (or add new ones) using the . operator.

--> hello!

x.c = Left(x.c, 5) + " world!";
--> hello world!