A modern programming language that makes developers happier.

kotlinlang

Idea suggests to simplify `0f == (-0f)` as `false`, which is wrong

```Although negative zero and positive zero are generally considered equal for comparison purposes, some programming language relational operators and similar constructs treat them as distinct. According to the Java Language Specification,[5] comparison and equality operators treat them as equal, but Math.min() and Math.max() distinguish them (officially starting with Java version 1.1 but actually with 1.1.1), as do the comparison methods equals(), compareTo() and even compare() of classes Float and Double```

Doesn't matter, the _IDE_ shouldn't suggest replacing any expression that returns `true`  with `false`.

oh that's interesting, because I assumed it returns false, given Java spec, and OPs confusion was for different reasons

Well your quote says:
&gt; According to the Java Language Specification,[5] comparison and equality operators treat them as equal

```but Math.min() and Math.max() distinguish them (officially starting with Java version 1.1 but actually with 1.1.1), as do the comparison methods equals(), compareTo() and even compare() of classes Float and Double```

They are equal according to `==` , but not according to `Float.equals`.

From the `java.lang.Float.equals` docs:
&gt;If f1 represents +0.0f while f2 represents -0.0f, or vice versa, the equal test has the value false, even though 0.0f==-0.0f has the value true.

Not really it turns out:
```
val posPrimitive: Float = 0.0f
val negPrimitive: Float = -0.0f

val posBoxed: Float? = posPrimitive
val negBoxed: Float? = negPrimitive

println(posPrimitive == negPrimitive)   //true
println(posBoxed == negBoxed)           //true
println(posBoxed?.equals(negBoxed))     //false
```

Now I'm confused myself, I would have expected `true, false, true`.

```println(posPrimitive.equals(negPrimitive))   //false```

That boxes the primitives and calls the actual `Float.equals` function, so according to the docs that makes sense.

So, I managed to get Karel confused.. excellent ^^

Turns out there literally is a special case for floats in the compiler: <https://kotlinlang.org/docs/reference/equality.html#floating-point-numbers-equality>