Script language reference

For the full syntax and function catalog, use the original Script reference. Function availability depends on the execution context. Neuron Script evaluates expressions to values. A sequence returns its resulting value and may also change variables in its execution context. The examples below use the Waher.Script 2.15.0 language; the quickstart introduces expressions with their inputs and expected results.

Find the syntax you need

Task	Syntax	Read more
Assign or compare a value	`Count:=2`, `Count=2`	Assignment and comparison
Choose between two values	`condition ? yes : no`	Conditions
Supply a default for an optional value	`Label ?? "Untitled"`	Null fallback
Reuse a calculation	`Square(x):=x^2`, `x->x^2`	Functions
Repeat an action	`for`, `foreach`, `while`	Loops
Transform or filter a collection	`[q*12:q in Quantities]`	Ranges and comprehensions
Unpack a vector	`[Quantity,UnitPrice]:=[3,12]`	Unpack values
Use an expression in a contract	`value="{Count+1}"`	Embed Script in XML

Values and names

42
3.5
true
false
"text"
'also text'
null

Variable names are case-sensitive: Count and count can hold different values. Keep one spelling in your contract parameters, machine variables, and expressions. An unknown input is an error; define it before evaluation. The language also supports complex numbers, big integers, rational numbers, physical quantities, and host-provided objects. Check the receiving parameter or XML value type before using them.

Assignment and comparison

Count:=2;
count:=3;
Count+count

This returns 5. := assigns; = compares. Use semicolons between statements. A newline is formatting, not a substitute for an unambiguous statement separator.

Operators

Purpose	Syntax
Arithmetic	`+`, `-`, `*`, `/`, `^`
Remainder	`mod`, such as `7 mod 3`, which returns `1`
Comparison	`=`, `!=`, `<`, `<=`, `>`, `>=`
Boolean conditions	`AND`, `OR`, `NOT`
Grouping	Parentheses, such as `(2+3)*4`

Multiplication binds more tightly than addition: 2+3*4 returns 14. Use parentheses for mixed expressions when they make the intended order clearer. XML attributes must escape < as < and & as &.

Conditions

Count:=2;
if Count>=2 then "Complete" else "Waiting"

This returns "Complete". The condition chooses an expression result; it does not change the machine’s state by itself. State transitions are defined by the machine XML. For a short expression, use condition ? valueIfTrue : valueIfFalse:

Count:=2;
Count>=2 ? "Complete" : "Waiting"

This also returns "Complete". With Count:=0, it returns "Waiting". Only the selected branch is evaluated. Prefer the longer if form when either branch needs a substantial calculation.

Null fallback

Use ?? to provide a default when an optional input contains null:

Label:=null;
Label ?? "Untitled"

This returns "Untitled". A supplied 0 or false is retained: Value:=0; Value ?? 10 returns 0. Choose defaults that match your contract’s meaning; required values should be validated rather than silently replaced. In this runtime, ?? also uses the fallback when evaluating its left side raises an error: Number("bad") ?? 10 returns 10. A missing variable can also trigger the fallback. Keep required-input validation explicit so a fallback does not conceal a misspelled name or invalid value.

Functions

Square(x):=x^2;
Square(9)

This returns 81. Built-in functions and package extensions have their own signatures and context requirements. See functions and execution context. Built-in function names are case-insensitive: abs(-3) and ABS(-3) each return 3. This differs from variable names. Use the documented function casing consistently.

Lambda expressions

A lambda defines a function with ->. Put multiple arguments in parentheses:

LineTotal:=(quantity,price)->quantity*price;
LineTotal(3,12)

This returns 36. Use a named function for a calculation you want readers to recognize; a lambda is useful when a function itself needs to be stored or passed as a value. See the original lambda reference for argument forms.

Variable scope in a function

A user-defined function evaluates with its own variable bindings. In the selected runtime, scalar assignments inside the function do not replace the caller’s bindings:

Count:=5;
SetCount(x):=(Count:=x);
SetCount(2);
Count

This returns 5. The function’s argument and the assigned Count exist in the function call’s scope. A new variable created only inside that call is not available to the caller afterward. Return a result and assign it in the caller when you want to update a value:

Count:=5;
Next(x):=x+1;
Count:=Next(Count);
Count

This returns 6. Function variable scope is separate from machine persistence. It is not a transaction rollback mechanism for mutable host objects or external actions. The supplied scope tests cover scalar bindings.

Loops

Total:=0;
for i:=1 to 4 do Total:=Total+i;
Total

This returns 10. Keep work bounded when expressions execute as part of a contract or event. Language support for a loop does not guarantee a host permits every use of it. Use foreach when you already have the values to process:

Total:=0;
foreach Quantity in [1,2,3] do Total:=Total+Quantity;
Total

This returns 6. Use while when the condition determines how many iterations are needed:

x:=0;
while x<3 do x:=x+1;
x

This returns 3. Update the condition’s inputs so the loop can finish.

Collections

A vector groups ordered values. Indexes start at zero:

v:=[10,20,30];
v[1]

This returns 20. Count(v) returns the number of entries; Sum(v) adds numeric entries. Construct a matrix from row vectors. Matrix indexing uses column first, then row:

m:=[[1,2],[3,4]];
m[1,0]

This returns 2, the second column of the first row. Both indexes start at zero. An object groups named fields:

o:={Count:2, Label:"Ready"};
o.Count

This returns 2. Operators can apply across collection elements: Sum([1,2,3]+10) returns 36. Confirm the returned shape when supplying a scalar contract parameter.

Ranges and comprehensions

A range supplies values to iterate over. 1..4 includes 1, 2, 3, and 4. Add a step with |: 1..7|2 includes 1, 3, 5, and 7. For example, Sum(1..4) returns 10. A comprehension creates a vector by evaluating an expression for each input:

Quantities:=[1,2,3];
Totals:=[q*12:q in Quantities];
Totals

This returns [12,24,36]. Sum(Totals) returns 72. The expression before : produces each result; q in Quantities supplies its input. To select existing values, put the source before : and the condition after it:

Quantities:=[0,2,-1,3];
Positive:=[q in Quantities:q>0];
Positive

This returns [2,3]. If no values match, the result is an empty vector. Filtering is useful for selecting values to process; it does not validate or reject the original input. Use bounded inputs in contract expressions. See the original reference for comprehensions and element selection.

Unpack values

Assignment can match a vector pattern and bind its elements to names:

[Quantity,UnitPrice]:=[3,12];
Quantity*UnitPrice

This returns 36. The expected shape matters: assigning [3] to this two-element pattern fails. Check externally supplied data before unpacking it. See assignment pattern matching for more patterns.

Convert values explicitly

Number("12.5") returns numeric 12.5; String(12.5) returns the text "12.5". The aliases Num and Str are also tested in the selected core runtime. Number("not a number") raises an evaluation error. Validate user input before conversion and avoid evaluating input as executable Script. See the tested function reference for precise examples and supported argument cases.

Errors

Handle invalid input before using it. 2+ is a syntax error; UnknownInput+1 fails if the variable is absent. A false validation result is different from a failure to evaluate the expression. The language supports try/catch/finally. For example:

try Number("bad") catch 0

This returns 0 in the selected core runtime. Only choose a fallback when it has the intended meaning; treating invalid payment input as zero can hide an error. A state machine also has XML-level failure controls. Verify the state reached after failure rather than suppressing an error that should reject an action.

Comments

Use // for a line comment and /* ... */ for a block comment. Explain why a rule exists rather than restating the expression. Comments are language text and must still be escaped if placed in an XML attribute.

Embed Script in XML

For a scriptable action attribute, wrap the calculated expression in braces, as in value="{Count+1}". A literal such as content="Done" is not a script. Calc and Script elements contain expression text directly. Use CDATA when it makes comparison operators easier to read:

<Script xmlns="https://paiwise.tagroot.io/Schema/StateMachines.xsd"><![CDATA[
  NextCount:=Count+1;
]]></Script>

This fragment assigns an action variable; it does not persist it. Follow it with the appropriate PersistVariable action in a complete, validated machine.

Keep evaluation context explicit

Contract expressions see the values supplied by the contract context. Machine expressions may additionally see initialized variables and event data. .NET interoperation and package functions are subject to host restrictions. Use only documented inputs and functions, and test the complete contract on the target Neuron.

Authoring resources

Neuron Script

Tools and documentation

Find the syntax you need

Values and names

Assignment and comparison

Operators

Conditions

Null fallback

Functions

Lambda expressions

Variable scope in a function

Loops

Collections

Ranges and comprehensions

Unpack values

Convert values explicitly

Errors

Comments

Embed Script in XML

Keep evaluation context explicit

​Find the syntax you need

​Values and names

​Assignment and comparison

​Operators

​Conditions

​Null fallback

​Functions

​Lambda expressions

​Variable scope in a function

​Loops

​Collections

​Ranges and comprehensions

​Unpack values

​Convert values explicitly

​Errors

​Comments

​Embed Script in XML

​Keep evaluation context explicit

Find the syntax you need

Values and names

Assignment and comparison

Operators

Conditions

Null fallback

Functions

Lambda expressions

Variable scope in a function

Loops

Collections

Ranges and comprehensions

Unpack values

Convert values explicitly

Errors

Comments

Embed Script in XML

Keep evaluation context explicit