In addition to functional support, MethodScript supports traditional operators.
This allows you to write more readable code, by
using more standard symbols instead of only functions. Using operators instead of functions is highly recommended for
all code, though the functional usage will continue to remain supported, and may be more readable in rare cases.

Consider the following perfectly valid code:

<%CODE|
if(and(equals(@var, 3), lte(2, @var2))){
	msg('Something');
}
%>

This is fairly hard to read, and could quickly get even more complicated and harder to read the more conditions you add.
Instead, you can use ''infix'' notation now, using standard C/Java operators. The same code as above, converted to the
infix notation looks like:

<%CODE|
if(@var == 3 && 2 <= @var2){
	msg('Something');
}
%>

Besides being less typing, it's much easier for a human to read, thanks to the operators. "@var equals 3 and 2 is less than or equal to
@var2" as opposed to "and equals @var 3 lte 2 @var2". Using parenthesis is also supported, to force an order of operations:

<%CODE|
if((@var == 3) && (2 <= @var2)){
	msg('Something');
}
%>

The following operators are supported, and their order of operations is from top to bottom. Note that all
operators are simply converted to the functional notation, so if your code is incorrect, the errors you
get will specify function names. Associativity tells in which order operators with equal priority are executed. This can be left (to right), right (to left) or non-assoc (not allowed to combine or nest).

{| class="wikitable"
|-
! Type
! Symbol
! Function Conversion
! Associativity
! Notes
|-
| ''Postfix''
| ++ --
| {{function|postinc}}/{{function|postdec}}
| Non-assoc
| This is only considered postfix when it comes after an identifier: @i++
|-
| ''Array Sub-indices''
| %%NOWIKI|[ ]%%
| {{function|array_get}}
| Left
| Using square braces allows for array accesses, and in combination with the <code>=</code> sign, setting sub-indices.
If the array set appears on the right hand side of an assignment, or in a general statement without an assign, it is an
array_get operation. If it appears on the left hand side of an assignment, it is an array_set operation. The brackets
apply to the element just preceding, for instance with <code>@var['index']</code>, it is assumed that <code>@var</code>
is an array or array like value. Empty braces, <code>[]</code>, when on the left hand side works as an array push, and
when on the right hand side, or in a general statement without an assign, it is an array clone operation (which ultimately
still uses array_get). Sub-strings within strings may be pulled out using the bracket notation as well, and slices are supported.
<code>array(1, 2, 3)[1..2]</code> returns an array with 2 elements in it, namely 2 and 3. <code>'string'[0]</code> returns
's', and <code>'string'[0..1]</code> returns 'st'.
|-
| %%NOWIKI|( )%%
| {{function|execute}}
| Left
| Using parenthesis after a Callable allows for shorthand execution instead of using the execute function. Callables
are for instance closures and proc references, among a few others. These are first class values, and can be executed
in a number of ways, for instance if we define @c as <code>closure @c = closure() { msg('hi'); };</code> then we can
execute it as <code>@c();</code>.
|-
| ''Unary''
| ! ++ --
| {{function|not}}/{{function|inc}}/{{function|dec}}
| Non-assoc
| These are ''unary'' operators, they only operate on one identifier
|-
| ''Exponential''
| **
| {{function|pow}}
| Left
|
|-
| ''Multiplicative''
| * / %
| {{function|multiply}}/{{function|divide}}/{{function|mod}}
| Left
|
|-
| ''Additive''
| + - .
| {{function|add}}/{{function|subtract}}/{{function|concat}}
| Left
| If a minus or plus sign is used to denote the sign of a number, it is handled slightly differently, for instance, ''2 + -1'' does not use any subtraction
|-
| ''Relational''
| &lt; &gt; &lt;= &gt;=
| {{function|lt}}/{{function|gt}}/{{function|lte}}/{{function|gte}}
| Left
|
|-
| ''Equality''
| == != === !==
| {{function|equals}}/{{function|nequals}}/{{function|sequals}}/{{function|snequals}}
| Left
| There is no operational equivalent for equals_ic
|-
| ''Logical AND''
| &&
| {{function|and}}
| Left
|
|-
| ''Logical OR''
| &#124;&#124;
| {{function|or}}
| Left
|
|-
| ''Assignment''
| = += -= *= /= .= []= []+= []-= []*= []/= [].=
| {{function|assign}}/{{function|array_set}}/{{function|array_push}}
| Right
| There is no single functional equivalent except for = per se, <code>@var += 1</code> is equivalent to
<code>assign(@var, add(@var, 1))</code>, etc. += uses {{function|add}},
-= uses {{function|subtract}}, *= uses {{function|multiply}}, /= uses {{function|divide}}, and .= uses {{function|concat}}.
Square brackets with an assign indicate that a value is being assigned to the array element at the index that is given between the square brackets.
If no index is given, the value is appended to the end of the array.
|}

Note the lack of bitwise operators, which are usually standard in other languages. These are not provided, because the
operators are infrequently used, and may be used for other operations in the future. The functions themselves,
{{function|bit_not}}, {{function|bit_and}}, and {{function|bit_or}} still exist, so no functionality has been removed.

Also of note, auto-concatenation always takes lowest priority to all other operations.

When in strict mode, use of functional notation instead of operators triggers a compiler warning. This warning is
suppressible, however.

{{LearningTrail}}
