[swift-evolution] Equatability for enums with associated values

[Adam Shin]

When using enums with associated values, it's often necessary to check for
equality between two enum objects in some way. That can lead to boilerplate
code like this:

enum Option {
    case foo(String)
    case bar(Int)
case zip
}

func ==(lhs: Option, rhs: Option) -> Bool {
    switch (lhs, rhs) {
    case (.foo(let a), .foo(let b)) where a == b: return true
    case (.bar(let a), .bar(let b)) where a == b: return true
    case (.zip, .zip): return true
    default: return false
    }
}

..which results in code duplication and opens the door to potential logic
errors.

Instead, what if enums with associated values were automatically Equatable
when all their associated values were Equatable? That would remove the need
for such boilerplate code.

The Swift language guide states that custom classes and structs don't
receive a default implementation of the == operator because the compiler
can't guess what "equality" means for them. However, I think this could
make sense for enums. An enum case, even with associated values, seems
closer to a value itself than an object with logic and state.

I'd be interested to hear any thoughts on this. Would this be a beneficial
addition?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170113/e3c7f365/attachment.html>