Operator precedence

Operator precedence
You are encouraged to solve this task according to the task description, using any language you may know.

This page uses content from Wikipedia. The original article was at Operators in C and C++. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance)

Provide a list of precedence and associativity of all the operators and constructs that the language utilizes in descending order of precedence such that an operator which is listed on some row will be evaluated prior to any operator that is listed on a row further below it. Operators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same level of precedence, in the given direction.

ALGOL 68

The coder may define new operators and both those and the pre-defined ones may be overloaded and their priorities may be changed.

Array, Procedure, Dereference, Selection and Generator operations

priority	Operation	+Algol68Rev0	+Algol68G
Effectively 12 (Primary)	dereferencing, deproceduring(~,~), subscripting[~], rowing[~,] & slicing[~:~]		currying(~,), diag, trnsp, row, col
Effectively 11 (Secondary)	of (selection), loc & heap (generators)	→	new (generator)

These are technically not operators, rather they are considered "units associated with names"

Monadic operators

priority (Tertiary)	Algol68 "Worthy characters"	+Algol68Rev0&1	+Algol68C,G	+Algol68Rev0
10	not, up, down, lwb, upb, -, abs, arg, bin, entier, leng, level, odd, repr, round, shorten	¬, ↑, ↓, ⌊, ⌈	~, norm, trace, t, det, inv	lws, ups, ⎩, ⎧, btb, ctb

Standard dyadic operators with associated priorities

priority (Tertiary)	Algol68 "Worthy characters"	+Algol68Rev0&1	+Algol68C,G	+Algol68Rev0
9	+*, i	+×, ⊥		!
8	shl, shr, **, up, down, lwb, upb	↑, ↓, ⌊, ⌈		lws, ups, ⎩, ⎧
7	*, /,  %, over,  %*, mod, elem	×, ÷, ÷×, ÷*, %×, □		÷:
6	-, +
5	<, lt, <=, le, >=, ge, >, gt	≤, ≥
4	=, eq, /=, ne	≠	~=
3	&, and	∧		/\
2	or	∨		\/
1	minusab, plusab, timesab, divab, overab, modab, plusto, -:=, +:=, *:=, /:=, %:=, %*:=, +=:	×:=, ÷:=, ÷×:=, ÷*:=,  %×:=		minus, plus, div, overb, modb, ÷::=, prus

Note: Tertiaries include names nil and ○.

Assignation and identity relations etc

Again, these are technically not operators, rather they are considered "units associated with names"

priority (Quaternaries)	Algol68 "Worthy characters"	+Algol68Rev0&1	+Algol68C	+Algol68Rev0
Effectively 0	:=, =:, = , :=:, :/=:, is, isnt, at , @	:≠:, :	:~=:	ct, ::, ctab, ::=, .., is not

Note: Quaternaries include names skip and ~.

Algol 68 also includes (something like) C's ternary conditions, e.g.:

• case ~ in ~ ouse ~ in ~ out ~ esac or simply "( ~ | ~ |: ~ | ~ | ~ )",
• if ~ then ~ elif ~ then ~ else ~ fi or simply "( ~ | ~ |: ~ | ~ | ~ )",

And (unlike C's comma operator) the ";" can be used to indicate statements are done sequentially, where as the "," indicates that the statements can be done "collaterally", e.g. in parallel. Or a parallel clause can be used to force statements to be executed in parallel, e.g. par( ~, ~, ... )

Key: The super scripts indicate the following:

• ALGOL 68^Rev0 indicates Algol 68 Final Report (Essentially Revision 0)
• ALGOL 68^Rev0&1 indicates Algol 68 Revised Report (Essentially Revision 1)
• ALGOL 68^C indicates Cambridge University Algol 68[1].
• ALGOL 68^G indicates Algol 68 Genie[2]

C++

The following is a table that lists the precedence and associativity of all the operators in the C and C++ languages. An operator's precedence is unaffected by overloading.

Precedence	Operator	Description	Associativity
1 highest	::	Scope resolution (C++ only)	Left-to-right
2	++	Suffix increment
	--	Suffix decrement
	()	Function call
	[]	Array subscripting
	.	Element selection by reference
	->	Element selection through pointer
	typeid()	Run-time type information (C++ only) (see typeid)
	const_cast	Type cast (C++ only) (see const cast)
	dynamic_cast	Type cast (C++ only) (see dynamic cast)
	reinterpret_cast	Type cast (C++ only) (see reinterpret cast)
	static_cast	Type cast (C++ only) (see static cast)
3	++	Prefix increment	Right-to-left
	--	Prefix decrement
	+	Unary plus
	-	Unary minus
	!	Logical NOT
	~	Bitwise NOT
	(type)	Type cast
	*	Indirection (dereference)
	&	Address-of
	sizeof	Size-of
	new, new[]	Dynamic memory allocation (C++ only)
	delete, delete[]	Dynamic memory deallocation (C++ only)
4	.*	Pointer to member (C++ only)	Left-to-right
	->*	Pointer to member (C++ only)
5	*	Multiplication
	/	Division
	%	Modulo (remainder)
6	+	Addition
	-	Subtraction
7	<<	Bitwise left shift
	>>	Bitwise right shift
8	<	Less than
	<=	Less than or equal to
	>	Greater than
	>=	Greater than or equal to
9	==	Equal to
	!=	Not equal to
10	&	Bitwise AND
11	^	Bitwise XOR (exclusive or)
12	|	Bitwise OR (inclusive or)
13	&&	Logical AND
14	||	Logical OR
15	?:	Ternary conditional (see ?:)	Right-to-left
16	=	Direct assignment
	+=	Assignment by sum
	-=	Assignment by difference
	*=	Assignment by product
	/=	Assignment by quotient
	%=	Assignment by remainder
	<<=	Assignment by bitwise left shift
	>>=	Assignment by bitwise right shift
	&=	Assignment by bitwise AND
	^=	Assignment by bitwise XOR
	|=	Assignment by bitwise OR
17	throw	Throw operator (exceptions throwing, C++ only)
18	,	Comma	Left-to-right

For quick reference, see also this equivalent, color-coded table.

Fortran

• Fortran77 standard.
• Fortran [3]

Operators	Details
Function calls
**	Numeric
*, /	Numeric
+, -	Unary numeric operators
+, -	Binary numeric operators
//	String
FROM, TO
.EQ., .GE., .GT., .LE., .LT., .NE., ==, >=, >, <=, <, /=	Relational
.NOT., #	Logical
.AND., &	Logical
.OR., |	Logical
.EQV., .NEQV.	Logical
,
(, )
Start and End of an expression

Go

Precedence	Operators
Highest	Unary operators: + - ! ^ * & <-
5	* /  % << >> & &^
4	+ - | ^
3	==  != < <= > >=
2	&&
1	||

Binary operators of the same precedence associate from left to right. Associativity has no meaning for unary operators.

Syntactic elements not in the list are not considered operators in Go; if they present ambiguity in order of evaluation, the ambiguity is resolved by other rules specific to those elements.

J

Precedence	Grammatical classification	Associativity
highest	conjunctions	long left scope
	adverbs
lowest	verbs	long right scope

See http://www.jsoftware.com/help/dictionary/partsofspeech.htm for tokens in each grammatical class.

Note that other parts of speech do not have any precedence, because they are not "operators".

Note that this is an imprecise statement of the grammatical rules. For a complete treatment, see http://www.jsoftware.com/help/dictionary/dicte.htm

Here's an informal treatment of the grammar:

Conjunctions require a left and right argument, either of which may be a noun or a verb. If one argument is omitted the conjunction is curried with the remaining argument, forming an adverb (if the right argument is omitted, the precedence of the conjunction is treated as lower than the precedence of a verb).

Adverbs require a single left argument, which may be a noun or a verb.

Verbs require a right argument which must be a noun and may accept an optional left argument (which must also be a noun). Unless we're working with a dangling (rightmost) conjunction, verbs have lower precedence than adverbs and conjunctions.

Nouns are not operators and accept no arguments.

The result of a verb must be a noun.

The result of an adverb or a conjunction can have any one of these grammatical classifications, and verb results are typical (and, thus, the result of an adverb or a conjunction may accept further arguments). Adverbs and conjunctions serve a role analogous to that of macros in other languages.

Java

This is well-documented on the Oracle website.

Mathematica

Here is an outline:

Precedence	Class	Examples
highest	Extensions of symbol names	x_, #2 , e::s, etc.
	Function application variants	e[e], e@@e, etc.
	Power-related operators	√e, e^e, etc.
	Multiplication-related operators	∇e, e/e, e⊗e, e e, etc.
	Addition-related operators	e⊕e, e+e, e⋃e, etc.
	Relational operators	e==e, e∼e, e∈e, etc.
	Arrow and vector operators	e↗e, e⇌e, etc.
	Logic operators	e&&e, e∨e, e⊢e, etc.
	Pattern and rule operators	e, e->e, e/.e, etc.
	Pure function operator	e&
	Assignment operators	e=e, e:=e, etc.
lowest	Compound expression	e;e

There is a table of precedence of all operators on the page "tutorial/OperatorInputForms" in Mathematica help.

OCaml

This table contains the precedence and associativity of operators and other expression constructs in OCaml, including user-defined operators.

Perl 6

See this table for a list of the precedence levels. Perl 6 is an operator-rich language (and users may define more operators at will), so instead of listing all the operators in the table, representative operators are listed for some of the precedence levels; see later in the same file for a more complete list of predefined operators at each precedence level.

PHP

Operator Precedence

Python

See this table and the whole page for details on Python version 3.x An excerpt of which is this table:

Precedence	Operator	Description
lowest	lambda	Lambda expression
	if – else	Conditional expression
	or	Boolean OR
	and	Boolean AND
	not x	Boolean NOT
	in, not in, is, is not, <, <=, >, >=, !=, ==	Comparisons, including membership tests and identity tests,
	|	Bitwise OR
	^	Bitwise XOR
	&	Bitwise AND
	<<, >>	Shifts
	+, -	Addition and subtraction
	*, /, //, %	Multiplication, division, remainder [1]
	+x, -x, ~x	Positive, negative, bitwise NOT
	**	Exponentiation [2]
	x[index], x[index:index], x(arguments...), x.attribute	Subscription, slicing, call, attribute reference
highest	(expressions...), [expressions...], {key:datum...}, {expressions...}	Binding or tuple display, list display, dictionary display, set display

Footnotes

1. The % operator is also used for string formatting; the same precedence applies.
2. The power operator ** binds less tightly than an arithmetic or bitwise unary operator on its right, that is, 2**-1 is 0.5.

REXX

<lang rexx>/*

╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║ The following is a table that lists the precedence and associativity ║
║ of all the operators in the (classic) REXX language.                 ║
║                                                                      ║
║     1   is the highest precedence.                                   ║
║                                                                      ║
╠══════════╤════════╤══════════════════════════════════════════════════╣
║          │        │                                                  ║
║precedence│operator│               description                        ║
║          │        │                                                  ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    1     │   -    │  uniary minus                                    ║
║          │   +    │  uniary plus                                     ║
║          │   \    │  logical not                                     ║
║          │        ├──(the following aren't supported by all REXXes)──╢
║          │   ¬    │  logical not                                     ║
║          │   ~    │  logical not                                     ║
║          │   ^    │  logical not                                     ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    2     │   **   │  exponention    (integer power)                  ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    3     │   *    │  multiplication                                  ║
║          │   /    │  division                                        ║
║          │   %    │  integer division                                ║
║          │   //   │  modulus   (remainder division, sign of dividend)║
║          │  / /   │  modulus   (any 2 or 3 character operators may   ║
║          │        │             have whitespace between characters.) ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    4     │   +    │  addition                                        ║
║          │   -    │  subtraction                                     ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    5     │   ||   │  concatenation                                   ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    6     │   &    │  logical AND                                     ║
║          │   |    │  logical OR      (inclusive OR)                  ║
║          │   &&   │  logical XOR     (exclusive OR)                  ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    7     │[blank] │  concatenation                                   ║
║          │[abuttal│  concatenation                                   ║
╟──────────┼────────┼──────────────────────────────────────────────────╢
║    8     │   =    │  equal to                                        ║
║          │   ==   │  exactly equal to   (also, strictly equal to)    ║
║          │   \=   │  not equal to                                    ║
║          │   <>   │  not equal to  (also, less than or greater   to) ║
║          │   ><   │  not equal to  (also, greater to or less than)   ║
║          │   >    │  greater than                                    ║
║          │   >=   │  greater than or equal to                        ║
║          │   <    │  less than                                       ║
║          │   <=   │  less than or equal to                           ║
║          │   >>   │  exactly greater than                            ║
║          │   <<   │  exactly less than                               ║
║          │  <<=   │  exactly less than or equal to                   ║
║          │  >>=   │  exactly greater than or equal to                ║
║          │        ├──(the following aren't supported by all REXXes)──╢
║          │   /=   │  not equal to                                    ║
║          │   ¬=   │  not equal to                                    ║
║          │   ~=   │  not equal to                                    ║
║          │   ^=   │  not equal to                                    ║
║          │  /==   │  not exactly equal to                            ║
║          │  \==   │  not exactly equal to                            ║
║          │  ¬==   │  not exactly equal to                            ║
║          │  ~==   │  not exactly equal to                            ║
║          │  ^==   │  not exactly equal to                            ║
║          │   /<   │  not less than                                   ║
║          │   ~<   │  not less than                                   ║
║          │   ¬<   │  not less than                                   ║
║          │   ^<   │  not less than                                   ║
║          │   />   │  not greater than                                ║
║          │   ¬>   │  not greater than                                ║
║          │   ~>   │  not greater than                                ║
║          │   ^>   │  not greater than                                ║
║          │  /<=   │  not less than or equal to                       ║
║          │  ¬<=   │  not less than or equal to                       ║
║          │  ~<=   │  not less than or equal to                       ║
║          │  ^<=   │  not less than or equal to                       ║
║          │  />=   │  not greater than or equal to                    ║
║          │  ¬>=   │  not greater than or equal to                    ║
║          │  ~>=   │  not greater than or equal to                    ║
║          │  ^>=   │  not greater than or equal to                    ║
║          │  \>>   │  not exactly greater than                        ║
║          │  ¬>>   │  not exactly greater than                        ║
║          │  ~>>   │  not exactly greater than                        ║
║          │  ^>>   │  not exactly greater than                        ║
║          │  \<<   │  not exactly less than                           ║
║          │  ¬<<   │  not exactly less than                           ║
║          │  ~<<   │  not exactly less than                           ║
║          │  ^<<   │  not exactly less than                           ║
╚══════════╧════════╧══════════════════════════════════════════════════╝   */</lang>

Tcl

Tcl only supports operators within an expression context (such as the expr command, which lists the operators with more detail):

Precedence	Operator	Description
highest	- + ~ !	Unary minus, unary plus, bit-wise NOT, logical NOT.
	**	Exponentiation. Right-to-left associative.
	* / %	Multiply, divide, remainder.
	+ -	Add and subtract.
	<< >>	Left and right shift.
	< > <= >=	Boolean less, greater, less than or equal, and greater than or equal.
	== !=	Boolean equal and not equal.
	eq ne	Boolean string equal and string not equal.
	in ni	List containment and negated list containment.
	&	Bit-wise AND.
	^	Bit-wise exclusive OR.
	|	Bit-wise OR. Valid for integer operands only.
	&&	Logical AND. Evaluates its second operand lazily.
	||	Logical OR. Evaluates its second operand lazily.
lowest	x ? y : z	If-then-else, as in C. Evaluates its second and third operands lazily.

XPL0

All operations of equal precedence are evaluated (associate) left-to-right.

Precedence	Operator	Description
highest	() ,	Grouping, comma separator (constructs)
	- + addr @	Unary minus, unary plus, address of a variable
	<< >> ->>	Left and right logical shifts, arithmetic shift right
	* /	Multiply and divide
	+ -	Add and subtract
	= # < <= > >=	Comparisons: equal, not equal, less than, etc.
	~ not	Bitwise NOT
	& and	Bitwise AND
	! or | xor	Bitwise OR and exclusive OR
lowest	if-then-else	If expression