The operators in Maia are generally identical to those in C, except that Maia adds bitslice and rotate operators, and some attribute operators. None of the C operators related to pointers are supported. Where the operators are identical, Maia and C have identical precedence and associativity. The primary difference from C is that most Maia operators may also be optionally sized and signed.

A 'signed' operator is one which sign-extends its inputs (which are expected to be 2's complement), and which may also possibly have a different behaviour from its unsigned counterpart (signed and unsigned comparisons have different behaviour, for example). A signed operator is specified by immediately following the base operator with a # character.

A sized operator is one which carries out an explicitly-sized operation; it is specified by immediately following the base operator (and the # character, if there is one) with a $ character and a decimal integer.

Various operators also have an ASCII equivalent form, as well as the standard form. Some examples of operators are:

+$10   10-bit integer addition
/#$20  Signed 20-bit integer division
<=#    Signed integer less-than-or-equal
.SLE   Signed integer less-than-or-equal
=#     Sign-extending assignment

Note that assignment is an operator in both Maia and C (unlike VHDL and Verilog). From a hardware perspective, an assignment is an operation which is essentially identical to, for example, a shift. Assignments may therefore be signed, and sized, as for any other operator.

Floating-point operators use a slightly different format. These operators cannot be signed, and operate on (conceptually, at least) only three different data sizes: IEC60559 single, double, and extended. Floating-point operators are normally prefixed with .F, and the integer 1, 2, or 3, to specify the required size (the integer defaults to 2 if it is omitted). Some examples are:

.F3-   Extended subtraction (or unary minus, depending on context)
.F2*   Double multiply
.F1<=  Single less-than-or-equal
.FLE   Double less-than-or-equal

When considering the data types (bit and var, and their specialisations) Maia's type system is essentially hardware-oriented. Operators generally specify precisely the required operation, rather than relying on the compiler to deduce the required operation from the surrounding context. Writing an expression in Maia is not unlike drawing a circuit diagram of the expression, where each logic unit must be correctly labelled.

However, in many circumstances it would be tedious to continuously write +$10, for example, where a data path is known to be exclusively 10-bit. Maia does therefore deduce the required operator size when a base unsized integer or logic operator is used. The procedure used is the normal one: for binary operators, for example, an unsized operator is assumed to be the same size as the larger of the two operands. Note that this is very different from the Verilog procedure for operator sizing, which involves an analysis from the leaves of the expression, up to the destination, and back again.

The form of an operator is potentially complex, and may be enclosed in parentheses if preferred. These operations are all identical:

var8 i, j, k;
i = j -#$10 k;     // 10-bit 2's complement subtraction
i = j-#$10k;       // the operators are tokens; whitespace is not required
i = j (-#$10) k;