Скачать или смотреть Understanding Contradictory Protocol Conformances in Swift

Dive into the world of Swift programming to solve the mystery behind contradictory protocol conformances, exploring how Swift's `Equatable` behaves with multiple protocol extensions.
---
This video is based on the question https://stackoverflow.com/q/63879028/ asked by the user 'Roman' ( https://stackoverflow.com/u/2167345/ ) and on the answer https://stackoverflow.com/a/63879314/ provided by the user 'Sweeper' ( https://stackoverflow.com/u/5133585/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Contradictory protocol conformances

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Contradictory Protocol Conformances in Swift

When working with Swift, you might stumble upon some unexpected behaviors, especially when dealing with protocol conformances. A common perplexity arises from the interaction of multiple protocol extensions with the Equatable protocol. One such instance is illustrated in the following code snippet:

[[See Video to Reveal this Text or Code Snippet]]

You might expect that printing a == b would yield a false result due to the contradictory nature of the custom equality operators implemented in Test1 and Test2. However, this is not the case. Let's dive deeper into this behavior to understand why it occurs and how Swift handles such situations.

The Core of the Issue

The crux of the problem lies in how Swift determines which == operator to call. In this scenario:

The Test struct conforms to Equatable, but this conformance is not derived from the custom operators defined in the protocol extensions. Instead, it is due to Swift's auto-generated implementation of Equatable, which checks if all properties are also Equatable.

Since both Test1 and Test2 define the == operator, you would expect one of them to be invoked. However, because Test is being considered on its own (not as Test1 or Test2), neither extension's == method is chosen.

Key Takeaways

1. Auto-Generated Equatable Implementation

Swift auto-generates an implementation of Equatable for types that have properties all conforming to Equatable. Thus, when both Test1 and Test2 have conflicting implementations, and Test is not explicitly using these extensions, Swift's generic implementation prevails.

2. Static Binding in Protocol Extensions

Methods in extensions use static binding, meaning if you have multiple definitions for a method (like ==), the compiler will select a definition based on the compile-time type, which in this case is Test. As such:

[[See Video to Reveal this Text or Code Snippet]]

By adding a non-Equatable property x, the auto-generated == operator is eliminated, which prompts the compiler to look for candidates from Test1 and Test2. Now you will receive an error, clearly indicating that there are duplicate == operators available.

3. Resolving the Ambiguity

To avoid ambiguity and clearly define behavior, you can either:

Remove one of the protocol extensions to ensure that only one == implementation exists.

Explicitly define what you want the == operator to do without relying on auto-generated behavior.

Conclusion

Understanding the intricacies of Swift’s protocol conformance can save you from unexpected runtime behavior. When dealing with protocols and their extensions, particularly regarding Equatable, always remember how Swift determines method resolution based on the static binding and compile-time types. By clarifying your protocol implementations, you can ensure that your code behaves predictably and as intended.

Whether you are a novice or an experienced Swift developer, diving into these nuanced details will greatly enhance your understanding of the language's capabilities and idiosyncrasies. Happy coding!