As always with these questions, the JLS holds the answer. In this case §15.26.2 Compound Assignment Operators. An extract: A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once. An example cited from §15.26.2 […] the following code is … Read more
This isn’t simply “multiple variable assignment”, it’s fully-featured pattern matching! So the following are all valid: val (a, b) = (1, 2) val Array(a, b) = Array(1, 2) val h :: t = List(1, 2) val List(a, Some(b)) = List(1, Option(2)) This is the way that pattern matching works, it’ll de-construct something into smaller parts, … Read more
The language guarantees that int is at least 16 bits, long is at least 32 bits, and long can represent at least all the values that int can represent. If you assign a long value to an int object, it will be implicitly converted. There’s no need for an explicit cast; it would merely specify … Read more
= is parsed as right-associative, but order of evaluation is left-to-right. So: The statement is parsed as a[i] = (i = 9). However, the expression i in a[i] is evaluated before the right hand side (i = 9), when i is still 0. It’s the equivalent of something like: int[] #0 = a; int #1 … Read more
A definition is where a value or function is described, i.e. the compiler or programmer is told precisely what it is, e.g. int foo() { return 1; } int var; // or, e.g. int var = 5; but this is clearer. A declaration tells the compiler, or programmer that the function or variable exists. e.g. … Read more
Simply put, arrays are not assignable. They are a “non-modifiable lvalue”. This of course begs the question: why? Please refer to this question for more information: Why does C++ support memberwise assignment of arrays within structs, but not generally? Arrays are not pointers. x here does refer to an array, though in many circumstances this … Read more
You should never expect them outperform assignments. The reason is, the compiler will use memcpy anyway when it thinks it would be faster (if you use optimize flags). If not and if the structure is reasonable small that it fits into registers, direct register manipulation could be used which wouldn’t require any memory access at … Read more
It’s a conditional assignment. From here: x = find_something() #=>nil x ||= “default” #=>”default” : value of x will be replaced with “default”, but only if x is nil or false x ||= “other” #=>”default” : value of x is not replaced if it already is other than nil or false
The other answers don’t exactly explain what’s going on here, so this is the basic problem: When you write blackKey.center.x, the blackKey.center and center.x both look like struct member accesses, but they’re actually completely different things. blackKey.center is a property access, which desugars to something like [blackKey center], which in turn desugars to something like … Read more