Enumeration should derive CanEqual

[soronpo]

When using an enumeration, we expect pattern matching on the objects to work by default even under strictEquality.

Compiler version

v3.1.0-RC1

Minimized code

import scala.language.strictEquality
enum FooBar:
  case Foo, Bar

def check(fb : FooBar): Unit =
  fb match
    case FooBar.Foo =>
    case FooBar.Bar =>

Output

Values of types FooBar and FooBar cannot be compared with == or !=
Values of types FooBar and FooBar cannot be compared with == or !=

Expectation

No error.

[soronpo]

If it's not an actual bug, then it's at least missing proper documentation under the enum/equality section.

[soronpo]

I noticed that the strictEquality tests explicitly derive CanEqual for enums. Therefore I conclude that this is not an overlook, but an intended design decision, and we are missing documentation under the enum and equality sections.

[bishabosha]

note that case classes and case objects also do not derive CanEqual by default

[jducoeur]

True, but I'm with @soronpo here: I believe any reasonable programmer would expect this to just work, and I'm having trouble coming up with a reasonable argument why one would ever not want this to be true. IMO, this one's a design bug, and should be tweaked.

[bishabosha]

True, but I'm with @soronpo here: I believe any reasonable programmer would expect this to just work, and I'm having trouble coming up with a reasonable argument why one would ever not want this to be true. IMO, this one's a design bug, and should be tweaked.

they did before 0.13.0-RC1, but was removed by #5843

[soronpo]

I started a thread on contributors.
https://contributors.scala-lang.org/t/enumeration-does-not-derive-canequal-for-strictequality/5280

[bishabosha]

Paraphrasing @smarter It would potentially be problematic if you define custom equals for your enum, and then that case should probably not derive CanEqual

[soronpo]

Paraphrasing @smarter It would potentially be problematic if you define custom equals for your enum, and then that case should probably not derive CanEqual

IMO, if you define an enum you want to do basic patten matching. If not, then you don't want an enum.

[jducoeur]

Right -- enum is syntax sugar for the common cases. There are all sorts of edge cases where it isn't quite appropriate, but I would guess that custom equals is one of the more unusual ones. (Like, I don't recall ever doing so for an enumeration, personally.)

[Lasering]

Somewhat related enums whose cases are singletons should also derive Ordering with this implementation:

given Ordering[T] = Ordering.by(_.ordinal)

Alternatively add the above code to the SingletonEnumCompanion in the #14136 PR