I'm wondering why the below code generates the strange results, and compiler doesn't show any error or warning. This looks like an extremely efficient source of bugs.
val a = 10 * 20 +
10 * 30
val b = 10 * 20
+ 10 * 30
val c = (
(10 * 20)
+ (10 * 30)
)
val d = (10 * 20)
+ (10 * 30)
println(a)
println(b)
println(c)
println(d)
And the output is:
500
200
500
200
Kotlin has optional semicolons, it allows and encourages source code to omit a statement separator (i.e. semicolon ;). As a result, it can get hard for the compiler to guess what you, as a programmer, actually intend to do:
val b = 10 * 20
+ 10 * 30
Will be compiled to an assignment of b = 500 and a second statement that results in 300 but never gets assigned to anything (same with d). How would you consider the compiler to know that the second line is actually part of the first expression? It's valid on its own.
This thread gives further details.
I looks like I was lucky to use an operator which also has unary version +.
The problem is that Kotlin allows for a kind of expressions which do nothing in fact like this:
12345
I can also have:
- 12345
which is just a negative number. I can also have positive number:
+ 12345
So in this case:
val a = 20 +
30
I have one expression, as the + requires another argument, which can be found in the next line.
However here I have two expressions
val a = 20
+ 30
The variable a will have value 20 and the second expression will do nothing.
However there is no unary version of *, so this works:
val a = 10 *
20
and a == 200, and this makes a compilation error:
val a = 10
* 20
Error:(397, 17) Kotlin: Expecting an element
Adding semicolons doesn't change anything, as the last expression is still not valid, and causes the compilation error.
And you can always use brackets:
val x = (10
+ 20)