The Order of Precedence of Programming Language Operators - Maple Programming Help

Home : Support : Online Help : Programming : Operations : Operators : operators/precedence

The Order of Precedence of Programming Language Operators

Description

 • The order of precedence of all Maple programming language operators is as follows, from highest to lowest binding strengths:

 (on the right) :- (left associative) || (left associative) (on the left) :- (left associative) (on the right) :: (non-associative) (on the left) postfix ++ and -- (left-associative) (on the right) prefix ++ and -- (right-associative) &-operators (except &*) (left associative) &&-operators (right associative) ! (left associative) ^, @@, %^ (non-associative) ., *, &*, /, @, intersect, %., %*, %/ (left associative) (on the right) mod (non-associative) +, -, union, minus, %+, %- (left associative) (on the left) mod (non-associative) .., subset (non-associative) <, <=, >, >=, =, <>, in (non-associative) \$ (non-associative) not (right associative) and (left associative) or (left associative) xor (left associative) implies (non-associative) -> (right associative) , (left associative) assuming (left associative) :=, +=, -=, *=, .=, /=, mod=, ^=, ,=, ||=, and=, or=, xor=, implies=, union=, intersect=, minus= (non-associative)

 • Note that $^$ and $@@$ are defined to be non-associative and therefore a^b^c is invalid in Maple.  (Parentheses must be used.)
 • Note that the precedence of mod is different on the right than on the left.  (See examples.)
 • The evaluation of expressions involving the logical operators proceeds in an intelligent manner which exploits more than the simple associativity and precedence of these operators. Namely, the left operand of the operators and, or, xor, and implies is always evaluated first and the evaluation of the right operand is avoided if the truth value of the expression can be deduced from the value of the left operand alone.
 • The module member selection operator $:-$ has special rules for simplification and evaluation. It is simplified immediately and automatically to the local instance of the module member name that it denotes. It is not possible to manipulate an $:-$ expression as a compound data structure. The expression appearing to the left of the $:-$ operator must evaluate to a module (it is an error, otherwise), and the symbol appearing to the right of the $:-$ operator must be the name of an exported member of that module.
 • The precedence of elementwise operators matches that of the operator being applied element-wise.

Operator Precedence Examples

 Because the ^ operator is non-associative, a^b^c returns an error.
 > a^b^c;
 However, both (a^b)^c and a^(b^c) are valid.
 > (a^b)^c;
 ${\left({{a}}^{{b}}\right)}^{{c}}$ (1)
 > a^(b^c);
 ${{a}}^{{{b}}^{{c}}}$ (2)
 Because a procedure cannot be a parameter, (a -> b) -> c returns an error. However, a -> b -> c is valid syntax and means a -> (b -> c).
 > a -> b -> c;
 ${a}{↦}{b}{↦}{c}$ (3)
 > a -> (b -> c);
 ${a}{↦}{b}{↦}{c}$ (4)
 > (a -> b) -> c;
 On the right side, the precedence of the mod operator is higher than the precedence of the + operator.
 > a + b mod c + d;
 $\left({\mathrm{modp}}{}\left({a}{+}{b}{,}{c}\right)\right){+}{d}$ (5)
 Neutral operators beginning with a single & are left-associative, while those beginning with && are right associative.
 > a &+ b &+ c;
 $\left({a}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{&+}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{b}\right)\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{&+}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{c}$ (6)
 > a &&+ b &&+ c;
 ${a}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{&&+}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}\left({b}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{&&+}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{c}\right)$ (7)