View mode: basic / threaded / horizontal-split · Log in · Help
March 13, 2012
Simple operator precidence chart (and associativity)?
I'm reading through D's grammar spec, and maybe it's just not enough sleep 
or some such, but my brain is turning to mud:

Is there a simple operator precidence chart somewhere? (Also, for 
associativity: Assign and OpAssign are right-associative and everything else 
is left-associative, correct?)
March 13, 2012
Re: Simple operator precidence chart (and associativity)?
On 03/13/2012 11:29 PM, Nick Sabalausky wrote:
> I'm reading through D's grammar spec, and maybe it's just not enough sleep
> or some such, but my brain is turning to mud:
>
> Is there a simple operator precidence chart somewhere?


I don't think there is, but I think I can create one:

!                 // 1 template instantiation
=>                // 2 goesto, binds weaker to the right
. ++ -- ( [       // 3 postfix operators
^^                // 4 power (right-associative)
& ++ -- * - + ! ~ // 5 prefix operators
* / %             // 6 multiplicative operators
+ - ~             // 7 additive operators
>> << >>>         // 8 shift operators
== != > < >= <= \ // 9 relational operators
!> !< !>= !<= <>\
!<> <>= !<>= in \
!in is !is
&                 // 10 bitwise AND (ambiguous with 9)
^                 // 11 bitwise XOR (ambiguous with 9)
|                 // 12 bitwise OR  (ambiguous with 9)
&&                // 13 logical AND
||                // 14 logical OR
?:                // 15 conditional operator
/= &= |= -= += \  // 16 assignment operators (right-associative)
<<= >>= >>>= = \
*= %= ^= ^^= ~=
=>                // 17 goesto, binds stronger to the left
,                 // 18 comma operator
..                // range (not actually an operator)


> (Also, for
> associativity: Assign and OpAssign are right-associative and everything else
> is left-associative, correct?)
>
>

Power is right-associative too.
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
On Tuesday, March 13, 2012 18:29:03 Nick Sabalausky wrote:
> I'm reading through D's grammar spec, and maybe it's just not enough sleep
> or some such, but my brain is turning to mud:
> 
> Is there a simple operator precidence chart somewhere? (Also, for
> associativity: Assign and OpAssign are right-associative and everything else
> is left-associative, correct?)

For all of the operators which come from C/C++, the operator precendence chart 
from C/C++ should work:

http://en.cppreference.com/w/cpp/language/operator_precedence

It's how the D-specific ones fit in that gets harder to figure out. IIRC TDPL has 
an operator precedence table though, so you should be able to look there.

- Jonathan M Davis
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
"Timon Gehr" <timon.gehr@gmx.ch> wrote in message 
news:jjokc7$t3j$1@digitalmars.com...
> On 03/13/2012 11:29 PM, Nick Sabalausky wrote:
>> I'm reading through D's grammar spec, and maybe it's just not enough 
>> sleep
>> or some such, but my brain is turning to mud:
>>
>> Is there a simple operator precidence chart somewhere?
>
>
> I don't think there is, but I think I can create one:
>

Thanks!

> == != > < >= <= \ // 9 relational operators
> !> !< !>= !<= <>\
> !<> <>= !<>= in \
> !in is !is
> &                 // 10 bitwise AND (ambiguous with 9)
> ^                 // 11 bitwise XOR (ambiguous with 9)
> |                 // 12 bitwise OR  (ambiguous with 9)

Ah, see, that's what I was tripping up on. I thought there seemed to be 
something slightly odd going on with those (and then from there I started 
second-guessing everything). It seemed almost like these had both ordered 
priorities *and* the same priority.

So how exactly does this part work then?

>
>> (Also, for
>> associativity: Assign and OpAssign are right-associative and everything 
>> else
>> is left-associative, correct?)
>>
>>
>
> Power is right-associative too.

Oh that's right. I keep forgetting we have that now.
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
On 03/14/2012 01:20 AM, Nick Sabalausky wrote:
> "Timon Gehr"<timon.gehr@gmx.ch>  wrote in message

>> >> << >>>         // 8 shift operators
>> == !=>  <  >=<= \ // 9 relational operators
>> !>  !<  !>= !<=<>\
>> !<>  <>= !<>= in \
>> !in is !is
>> &                 // 10 bitwise AND (ambiguous with 9)
>> ^                 // 11 bitwise XOR (ambiguous with 9)
>> |                 // 12 bitwise OR  (ambiguous with 9)
>
> Ah, see, that's what I was tripping up on. I thought there seemed to be
> something slightly odd going on with those (and then from there I started
> second-guessing everything). It seemed almost like these had both ordered
> priorities *and* the same priority.
>
> So how exactly does this part work then?
>

It is a special case. If a bitwise operator appears next to a relational 
operator, then the expression has to be parenthesised for 
disambiguation. You can think of it as a partial order:

                    ...
                     |
              shift operators
                    ^ ^
                   /   \
                  /  bitwise AND
                 /       \
                /      bitwise XOR
               /            \
relational operators      bitwise OR
                ^           ^
                 \         /
                  \       /
                   \     /
                    \   /
                 logical AND
                      ^
                      |
                 logical OR
                      ^
                      |
                     ...

The precedence of bitwise operators cannot be compared with the 
precedence of relational operators, and D disallows programs that cannot 
be parsed unambiguously.
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
"Timon Gehr" <timon.gehr@gmx.ch> wrote in message 
news:jjpmov$305u$1@digitalmars.com...
> On 03/14/2012 01:20 AM, Nick Sabalausky wrote:
>> "Timon Gehr"<timon.gehr@gmx.ch>  wrote in message
>
>>> >> << >>>         // 8 shift operators
>>> == !=>  <  >=<= \ // 9 relational operators
>>> !>  !<  !>= !<=<>\
>>> !<>  <>= !<>= in \
>>> !in is !is
>>> &                 // 10 bitwise AND (ambiguous with 9)
>>> ^                 // 11 bitwise XOR (ambiguous with 9)
>>> |                 // 12 bitwise OR  (ambiguous with 9)
>>
>> Ah, see, that's what I was tripping up on. I thought there seemed to be
>> something slightly odd going on with those (and then from there I started
>> second-guessing everything). It seemed almost like these had both ordered
>> priorities *and* the same priority.
>>
>> So how exactly does this part work then?
>>
>
> It is a special case. If a bitwise operator appears next to a relational 
> operator, then the expression has to be parenthesised for disambiguation. 
> You can think of it as a partial order:
>
>                     ...
>                      |
>               shift operators
>                     ^ ^
>                    /   \
>                   /  bitwise AND
>                  /       \
>                 /      bitwise XOR
>                /            \
> relational operators      bitwise OR
>                 ^           ^
>                  \         /
>                   \       /
>                    \     /
>                     \   /
>                  logical AND
>                       ^
>                       |
>                  logical OR
>                       ^
>                       |
>                      ...
>
> The precedence of bitwise operators cannot be compared with the precedence 
> of relational operators, and D disallows programs that cannot be parsed 
> unambiguously.

Ok, I see. Thanks.
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
On 14-3-2012 0:14, Timon Gehr wrote:
> I don't think there is, but I think I can create one:
>
> ! // 1 template instantiation
> => // 2 goesto, binds weaker to the right
> . ++ -- ( [ // 3 postfix operators
> ^^ // 4 power (right-associative)
> & ++ -- * - + ! ~ // 5 prefix operators
> * / % // 6 multiplicative operators
> + - ~ // 7 additive operators
>  >> << >>> // 8 shift operators
> == != > < >= <= \ // 9 relational operators
> !> !< !>= !<= <>\
> !<> <>= !<>= in \
> !in is !is
> & // 10 bitwise AND (ambiguous with 9)
> ^ // 11 bitwise XOR (ambiguous with 9)
> | // 12 bitwise OR (ambiguous with 9)
> && // 13 logical AND
> || // 14 logical OR
> ?: // 15 conditional operator
> /= &= |= -= += \ // 16 assignment operators (right-associative)
> <<= >>= >>>= = \
> *= %= ^= ^^= ~=
> => // 17 goesto, binds stronger to the left
> , // 18 comma operator
> .. // range (not actually an operator)

The TDPL has a list of expressions in decreasing precedence
on pages 61-63. Some of these operators, like <> or ^^= are
not listed there.

Is there a difference between != and <> ?

Why is the "goesto" operator listed twice? Is that accidental?

Jos
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
On 03/14/2012 01:23 PM, Jos van Uden wrote:
> On 14-3-2012 0:14, Timon Gehr wrote:
>> I don't think there is, but I think I can create one:
>>
>> ! // 1 template instantiation
>> => // 2 goesto, binds weaker to the right
>> . ++ -- ( [ // 3 postfix operators
>> ^^ // 4 power (right-associative)
>> & ++ -- * - + ! ~ // 5 prefix operators
>> * / % // 6 multiplicative operators
>> + - ~ // 7 additive operators
>> >> << >>> // 8 shift operators
>> == != > < >= <= \ // 9 relational operators
>> !> !< !>= !<= <>\
>> !<> <>= !<>= in \
>> !in is !is
>> & // 10 bitwise AND (ambiguous with 9)
>> ^ // 11 bitwise XOR (ambiguous with 9)
>> | // 12 bitwise OR (ambiguous with 9)
>> && // 13 logical AND
>> || // 14 logical OR
>> ?: // 15 conditional operator
>> /= &= |= -= += \ // 16 assignment operators (right-associative)
>> <<= >>= >>>= = \
>> *= %= ^= ^^= ~=
>> => // 17 goesto, binds stronger to the left
>> , // 18 comma operator
>> .. // range (not actually an operator)
>
> The TDPL has a list of expressions in decreasing precedence
> on pages 61-63. Some of these operators, like <> or ^^= are
> not listed there.

Some guys want to deprecate <>, but I think it is actually quite nice. 
^^ and ^^= were added after TDPL was released afaik.

>
> Is there a difference between != and <> ?

Yes, != gives true when at least one of the arguments is NAN, while <> 
gives false if at least one of the arguments is NAN.

!= means not equal.
<> means ordered, but not equal.

There is also <>=, which just means ordered, etc.

>
> Why is the "goesto" operator listed twice? Is that accidental?
>

That is intentional. It binds stronger to the left than to the right, 
for example:

x+x=>x+x

will be parsed as:

x+(x=>(x+x))

(It could be argued that => is not a proper 'operator', but an operator 
precedence parser can be slightly more efficient if it is treated as one.)
March 14, 2012
Re: Simple operator precidence chart (and associativity)?
On 13/03/2012 23:14, Timon Gehr wrote:
<snip>
>> (Also, for
>> associativity: Assign and OpAssign are right-associative and everything else
>> is left-associative, correct?)
>>
>>
>
> Power is right-associative too.

You forgot the conditional operator.

And the relational operators are non-associative (a == b == c or similar is illegal).

Stewart.
Top | Discussion index | About this forum | D home