operator-precedence

I did some reading up on JLS 15.7.4 and 15.12.4.2 , but it doesn't guarantee that there won't be any compiler/runtime optimization that would change the order in which method arguments are evaluated. Assume the following code: public static void main (String[] args) { MyObject obj = new MyObject(); methodRelyingOnEvalOrder(obj, obj.myMethod()); } public static Object methodRelyingOnEvalOrder(MyObject obj, Object input) { if (obj.myBoolean()) return null; else return input; } Is it guaranteed that the compiler or runtime will not do a false optimization such as the following? This optimization

Similarly (-1==-1 & 1==1) is also False. Apologies if this is something obvious but I can't find an explanation for it. & is the bitwise AND operator. As mentioned in the documentation , Bitwise operators have higher precedence than logical operators, so 0 == 0 & 1 == 1 Becomes 0 == (0 & 1) == 1 And you can imagine it goes downhill from there: 0 == (0 & 1) == 1 => 0 == 0 == 1 => 0 == 0 and 0 == 1 => True and False => False Assuming what you wanted was a logical AND , the python way to do that would be using and : 0 == 0 and 1 == 1 Which gives you True as you'd expect. Lets break this up. The

Will the differences below matter significantly in C#? int a, b; double result; result = (double)a / b; result = a / (double)b; result = (double)a / (double)b; Which one do you use? The cast will occur before the division. In your examples, it doesn't matter which one you do as if one operand is a double, the runtime will cast/convert the other to a double as well. This looks like a micro-optimization - not something worth worrying about or dealing with unless measurements show it is indeed a bottleneck. I do this: result = (double)a / (double)b; It may be strictly unnecessary, but generally I

Python docs say that * and / have the same precedence. I know that expressions in python are evaluated from left to right. Can i rely in that and assume that j j/m is always equal to (j j)/m avoiding the parentheses? If this is the case can i assume that this holds for operators with the same precedence in general? ps: The question as it is fine for my purposes, i came to it while reading integer-only code (like the above example) without parentheses, which at the time looked a lot suspicious to me. Yes - different operators with the same precedence are left-associative; that is, the two

Why are the parentheses needed here? Are there some precedence rules I should know? scala> 'x' match { case _ => 1 } + 1 <console>:1: error: ';' expected but identifier found. 'x' match { case _ => 1 } + 1 ^ scala> ('x' match { case _ => 1 }) + 1 res2: Int = 2 Thanks! As Agilesteel says, a match is not considered as a simple expression, nor is an if statement, so you need to surround the expression with parentheses. From The Scala Language Specification , 6 Expressions, p73, the match is an Expr, as is an if. Only SimpleExpr are accepted either side of the + operator. To convert an Expr into a

I have this expression: y[i] = ( z[i] == a && b || c ) Which of these elements ( && , || , == ) have the priority? Can you please show the order of operations with brackets? First == , then && , then || . Your expression will be evaluated as y[i] = (((z[i] == a) && b) || c) . https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html Alex The priority list: == && || This would be : y[i] = ((( (z[i]) == a )&& b) || c) ref: http://introcs.cs.princeton.edu/java/11precedence/ The actual expression is evaluated as y[i] = ( ((z[i] == a) && b) || c ) You probably want to look here for

Suppose in the current directory there is a file named somecode.py , and a directory named somecode which contains an __init__.py file. Now I run some other Python script from this directory which executes import somecode . Which file will be imported - somecode.py or somecode/__init__.py ? Is there even a defined and reliable search order in which this is resolved? Oh, and does anyone have a reference to official documentation for this behavior? :-) Packages will be imported before modules. Illustrated: % tree . . |-- foo | |-- __init__.py | `-- __init__.pyc `-- foo.py foo.py : % cat foo.py