[swift-evolution] Equatable auto-write func == Proposal

[Jérôme Duquennoy]

Hi guys,

It would be awesome if with this evolution, we could also auto-write equality operators for enum with equatable payloads.

Today, considering this enum

enum SimpleEnum {
  case case1
  case case2
}

the condition SimpleEnum.case1 == SimpleEnum.case1 compiles and return true.

But if the enum has a payload

enum EnumWithPayload {
  case integer(value: Int)
  case float(value: Float)
}

the condition EnumWithPayload.integer(value: 1) == EnumWithPayload.integer(value: 1) does not compile: operator == does not exist for that type.

Hand-writing this missing equality operator turns out to be pretty fastidious and error prone, notably because you might prefer to not use a “default” case, to take advantage of the completeness check of the compiler.
So you have to write n * (n-1) cases and that can be a lot of cases !

Jerome

> Good point.
> 
> The real push here is that when the programmer *does* declare a type Equatable and the op == has an obvious implementation, that the programmer shouldn’t have to manually implement it him/herself. This would apply only to types that have been declared Equatable and that consist of exclusively properties which have all also been declared Equatable.
> 
> This would work much like the Haskell Eq class.
> 
> > On Sep 12, 2016, at 12:03 PM, Robert Widmann<devteam.codafi at gmail.com>wrote:
> > 
> > Please be careful when wording this proposal. You want derived conformances, but don't obscure that message with the claim that every type admits a useful Equatable instance. It is most certainly not the case that every value type has a useful (read [mostly]: decidable) equality. A few counterexamples, the type of lazy streams (https://github.com/typelift/Swiftz/blob/swift-develop/Swiftz/Stream.swift#L24<https://github.com/typelift/Swiftz/blob/swift-develop/Swiftz/Stream.swift#L24>) requires infinite space to evaluate a useful answer. The type of functions [without a modulus of continuity] also don't admit a useful, or even canonical, equality (in Swift at least).
> > 
> > ~Robert Widmann
> > 
> > 2016/09/10 8:24、Daniel Tartaglia via swift-evolution<swift-evolution at swift.org<mailto:swift-evolution at swift.org>>のメッセージ:
> > 
> > > Now that Swift 3 is out the door, I’m going to float this proposal again…
> > > 
> > > Given that every value type should be equatable (rational here): https://www.andrewcbancroft.com/2015/07/01/every-swift-value-type-should-be-equatable/<https://www.andrewcbancroft.com/2015/07/01/every-swift-value-type-should-be-equatable/>
> > > And that many, if not most, value types consist of properties that are value types.
> > > Then the language should make it easy to conform to the Equatable protocol.
> > > 
> > > In other words, if I declare my value type as Equatable, and it is exclusively composed of value types that are already equatable, then implementing the actual == function should be optional (or maybe even forbidden.)
> > > 
> > > Implementing == in such cases is tedious boilerplate that the compiler should be able to infer on its own.
> > > 
> > > Does anybody want to help me write up an official proposal?
> 
> 
> 
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20160919/f9b0b2f7/attachment-0001.html>