Integrity of parentheses?



Does the Julia language guarantee evaluation order where parentheses are used to isolate subexpressions? For example, if one writes

d = a + (b - c)

can we be sure that the subtraction is performed first? This is important in implementing algorithms where one attempts to control roundoff.

I didn’t find a statement to this effect in the manual, but it appears to be the case in my (very limited) investigations. Note that some languages (e.g. Fortran) do have such a guarantee, but others (e.g. C, at least when I learned it) do not. Even if it’s true in practice now, without a guarantee (and tests!) some future “optimization” may break it.

julia> Meta.@lower d = a + (b - c)
:($(Expr(:thunk, CodeInfo(
 1 ─ %1 = b - c      
 │   %2 = a + %1     
 │        d = %2      
 └──      return %2     

might be a useful tool to see what is happening “under the hood”.


Yes, this is guaranteed and is the main purpose of parenthesizing arithmetic expressions.


Are you sure about your statement about C? I only know of undefined order in which modifying operators take effect, e.g. (++i)*(++i) is not defined, but I would first consult a reference on the question wether a + (b + c) can legally evaluated as (a + b) + c in C.


It’s not valid to do (a + b) + c. It’s the order that’s undefined, not the operation preformed


Harbison and Steele explicitly say that a C compiler may reorder evaluation of such expressions, and the references I could find online do not disagree.


C compiler has flags to allow that, but doing such transformation changes the operation preformed so it’s not allowed by the standard.


Thanks Stefan, I hoped that would be the case.


And note that they are removing/have removed this undefinedness in c and c++ standard. On my phone so I can’t find the proposal about it.