# Operators

These are the operators in order of precedence, with the first section having the highest precedence. All the operators in a single section have the same precedence.

## Unary operators

Unary operators are the only operators taking a single operand, all other operators are binary operators with two operands.

• !: Bitwise complement.
• +: Unary plus. This has no effect on its numeric operand.
• -: Unary minus. Negates its numeric operand.
• &: Reducing and. Performs the logic and of all the bits in the operand. The result is false if and only if the operand has at least one false bit.
• |: Reducing or. Performs the logic or of all the bits in the operand. The result is true if and only if the operand has at least one true bit.
• ^: Reducing xor. Performs the logic exclusive or of all the bits in the operand. The result is false when the operand has an even number of true bits, and true when the operand has an odd number of true bits.

## Cast operator

• as: Converts the left-hand-side operand (LHS) to the type specified in the right-hand side (RHS).

## Power operator

• **: Raises the LHS to the power of the RHS.

## Multiplication and division operators

• *: Multiplication.
• /: Division. Dividing two unsized integers yields a rational number. Dividing a sized integer truncates the result towards zero.
• %: Remainer. The remainder from the division by /, such that if d = a / b and r = a % b, then a == b * d + r. Since / rounds towards zero, the sign of r is the same as the sign of a.

These opertions have left-to-right associativity, that is, a / b * c == (a / b) * c.

• +: Addition.
• -: Subtraction.

## Shifting operators

• <<: Left shift. For unsized integers, rational numbers and floating-point numbers, a << b is equivalent to a multiplied by two raised to the power of b.
• >>: Right shift. For unsigned numbers this is a logical shift, that is, the bits inserted from the left side are zeros. For signed numbers this is an arithmetic shift, that is, the bits inserted from the left side are the same as the sign bit.

The shift operators can take a negative RHS, such that a << b == a >> -b.

## Bitwise logic and concatenation operators

• &: Bitwise and.
• |: Bitwise or.
• ^: Bitwise xor.
• !&: Bitwise nand.
• !|: Bitwise nor.
• !^: Bitwise xnor.
• ~: Concatenation.

The bitwise logic and concatenation operators all have the same precedence, but mixing them is not allowed, you need to use brackets to mix logic operators. The expressions a & b & c and a ~ b ~ c are valid, but the expression a & b | c is not valid, it must be written as either (a & b) | c or a & (b | c).

## Relational operators

Unlike arithmetic operations such as addition, relational operators can have one signed operand and one unsigned operand, and the result will be logically correct. The size of the operands can also be mixed. Comparing a value of type unsigned(6) and a value of type signed(4) is equivalent to first converting both of them to signed(7), which can hold both values exactly, and then comparing the converted values.

• ==: True if LHS is equal to RHS.
• !=: True if LHS is not equal to RHS.
• <: True if LHS is less than to RHS.
• <=: True if LHS is less than or equal to to RHS.
• >: True if LHS is greater than to RHS.
• >=: True if LHS is greater than or equal to RHS.

Relational operators can be chained such that, for example, writing a <= b <= c is equivalent to writing (a <= b) and (b <= c). The operators do not need to be the same, although the expression a <= b > c, which is equivalent to (a <= b) and (b > c), does not look as natural as the previous example.