The title of this thread was not meant as a rhetorical question. I started this thread because I was not sure whether I had all the arguments for co-operative equality. In the discussion that followed I did not see any new arguments for it, but several serious new arguments against.
Here’s the case against co-operative equality:
- it is very slow
- It is not an equivalence relation
- It “breaks” the one operation that is fast and has a chance of being an equivalence:
- It therefore “breaks” usage of Java collections from Scala.
- it is a mess to specify correctly
“Break” means: We can construct examples where the outcome violates important laws.
get is at least twice as slow in Scala than in Java because it has to use co-operative equality. Other operations are also affected.
Not an equivalence: The culprit here is
NaN. The IEEE floating point standard mandates
NaN != NaN
and that’s what the JVM implements, One can have a philosophical discussion whether that makes sense or not (and there are good arguments for both sides), but the fact is that we will not go against an established standard. The problem is then that with co-operative equality this irregularity, which was restricted to floating point comparisons only, now gets injected into our universal equality relation. I remember having seen bug reports about this. Users get bitten because
mutable.Map[Any, Int](NaN -> 1).get(NaN)
None instead of a
Now things get ironical. People might turn to Java collections instead of Scala collections to solve the two problems above. Java collections are based on
equals instead of
==. Unfortunately, cooperative equality means that
equals in Scala is also broken! Consider:
scala> NaN equals NaN
res1: Boolean = true
scala> (NaN, 1) equals (NaN, 1)
res2: Boolean = false
Similarly, but dually,
scala> 1 equals 1L
res3: Boolean = false
scala> Some(1) equals Some(1L)
res4: Boolean = true
equals is not even a congruence anymore! In other words, our well-intentioned attempt to improve the API of
== has actually ruined the API of
equals! (and, no, there’s no easy way to fix this).
Breaks Java collections. The illogical implementation of
equals is a problem if we want to use Java collections with Scala case classes as keys.
Messy to specify. That was my original complaint and I have already written too much about it.
For me the most enlightening comments in this thread were the one by @scottcarey where he showed that we need two notions of equality, one an equivalence and the other not, and the one by @LPTK where he showed the problems with
So I am now convinced that we should do what we can to drop cooperative equality on
Any (and by extension on all unbounded generic type parameters). As @Ichoran notes, the big problem here is migration. And I am not sure I have a good answer yet, except, try it out on large code bases and see what happens. Hopefully, the instances where the change matters will be far and few between.