Operators

This page lists every operator the lexer recognizes and describes its meaning. Operators are grouped by category. Where an operator’s behavior is described in detail elsewhere — for example, in the type-system pages — the relevant link is given.

Arithmetic

Prefix ++a increments and yields the new value. Postfix a++ increments and yields the previous value. The same applies to --.

^ is right-associative — 2 ^ 3 ^ 2 groups as 2 ^ (3 ^ 2) = 2 ^ 9 = 512. It binds tighter than *, /, and %, so 4 * 2 ^ 3 is 4 * (2 ^ 3) = 32. Unary - binds tighter still, so -10 ^ 2 is (-10) ^ 2 = 100, matching calculator-style math conventions.

Integer-on-integer ^ produces an i64 result regardless of operand widths, because power grows fast enough that picking the wider operand’s type would silently truncate (2 ^ 10 typed as i8 would otherwise overflow to 0). When either operand is a float, the result is f64. Negative integer exponents yield 0 from the integer helper; cast the base to a float ((x as f64) ^ -1) to get a fractional result.

Compound assignment

Each compound-assignment operator combines an arithmetic or bitwise operation with =. a OP= b modifies a in place; the target must be assignable.

Comparison

Each comparison produces a bool. Operands must have matching types.

For class instances and enum variants, == and != compare reference identity — a == b is true when both sides refer to the same object. Two distinct class instances with equal field values compare unequal. Two references to the same enum variant compare equal because every variant is a singleton; references to different variants of the same enum compare unequal regardless of their field values. The ordering operators < / <= / > / >= are not defined on class or enum types in this release.

Logical

and and or are keywords, not symbols. Both short-circuit — the right operand is evaluated only when the left operand does not determine the result.

Bitwise

The bitwise operators are defined on integer types only. Their compound forms (&=, |=) appear in the Compound assignment table.

Bitwise XOR currently has no dedicated operator. ^ is reserved for power; a future release may reintroduce XOR under a different token if a need surfaces.

Assignment

The compound forms appear in the Compound assignment table.

Type query

These three operators all take a value on the left and a type or collection on the right. They are written infix with the keyword between the operands:

value is i32
value as string
key   in map

Member access

Meta-access

The :: operator on the right-hand side of a type or value, followed by an uppercase metakeyword, queries a compile-time property of the operand. The result is a constant — the compiler resolves it during compilation.

let max = i32::MAX;          // largest representable i32
let len = "Hello"::LENGTH;   // 5

let s = "Hello";
let n = s::LENGTH;           // 5

The operand may be either a type (i32::MAX, f64::SIZE) or a value (s::LENGTH, pair::SIZE). When the operand is a value, the metakeyword resolves against the value’s type and, where relevant, against the value itself.

The full set of metakeywords:

Metakeyword spellings are uppercase exactly as listed above. Lower-case forms are not legal.

Range and spread

Null handling

See Nullable Types for the full nullability rules.

Conditional

The conditional expression is right-associative and may be chained.

Indexing and call

These two are technically not separate operators but parts of the postfix-expression grammar; they appear here because they are the two ways an expression accesses a value through another expression.

Arrows

Three arrow forms appear in declarations and expressions:

The exact contexts in which each arrow is legal are described on the relevant declaration pages.

Special characters

The lexer also recognizes the following single characters in dedicated roles. Most appear inside other constructs rather than as stand-alone operators.