[swift-evolution] [Proposal] Explicit Synthetic Behaviour

[Tony Allevato]

On Thu, Sep 7, 2017 at 10:39 AM Gwendal Roué <gwendal.roue at gmail.com> wrote:

> Le 7 sept. 2017 à 14:45, Tony Allevato <tony.allevato at gmail.com> a écrit :
>
> Right, let's make sure we're talking about the right thing here. Gwendal,
> your issue isn't with synthesis in the form of Codable or the new additions
> to Equatable/Hashable which are opt-in-by-conformance, it's with the
> specific case of raw value enums or enums without associated values where
> the synthesis is implicit with no way to opt-out. That's a big difference.
>
>
> Yes.
>
> I can definitely see the latter being an issue if it were more widespread,
> and I'd be supportive of those enums being required to declare their
> conformance for consistency (though it would be source breaking).
>
>
> Yes, unfortunately.
>
>
> However, I still haven't seen a real issue that has come up because of the
> distinction being drawn here between default implementations vs.
> implementations that can access other parts of the concrete type. It sounds
> like this discussion is trying to protect against a hypothetical problem
> that hasn't happened yet and may not happen; it would be helpful to show
> some motivating real-world cases where this is indeed a severe problem.
>
>
> Yes. I'm not talking about implementation itself. I know this has been the
> main topic until I have tried to bring in the topic of the consequences of
> non-avoidable synthesis (extra methods that may conflict with userland
> methods).
>
> If you ask me for a real-world case, then I think I gave one. Let me
> rephrase it:
>
> it's impossible to define a value-backed enum without getting free
> Equatable conformance. This free conformance is sometimes unwanted, and I
> gave the example of DSLs. Now this problem is not *severe*. It's more a
> blind spot in the language, and finally just an unwanted side-effect of a
> compiler convenience,
>

Again, this is not the issue that Haravikk is describing in this thread.

I'll clarify—your issue is specifically with the fact that enums with raw
values and enums without associated values receive Equatable even without
explicitly conforming to it, and therefore users have no way of opting out
of it. This predates SE-0185, and I didn't propose making any changes to
the conformance of those enums for source compatibility reasons, though I
wouldn't be opposed to it because it makes them consistent across the board.

Haravikk's argument is about synthesized conformances like Codable and
Equatable/Hashable in SE-0185, where the user must explicitly conform the
type to those protocols. His claim is that that act of opting in is not
sufficient and that it is still dangerous if those synthesized conformances
can access members that are not also declared in the protocol. That's a
completely separate issue to yours, and one that I hope he'll present more
evidence of. Right now, requiring that you not only explicitly conform to
the protocol but also explicitly request the synthesis feels like a
solution without an actual problem, and is a situation we already have
today with default method implementations.


>
> This example gives a little argument, but still an argument, for "explicit
> synthetic behavior", the topic of this thread.
>
> Gwendal Roué
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170907/3572b9bf/attachment.html>