Merge pull request #33735 from xwu/existential-edu

Author: swift-ci

userdocs/diagnostics/protocol-type-non-conformance.md

@@ -1,46 +1,61 @@
-# Protocol type not conforming to itself
-Protocols in Swift may be used as types. Protocols as types are sometimes called existential types.
+# Protocol Types Cannot Conform to Protocols
 
+In Swift, a protocol that does not have `Self` or associated type requirements can be used as a type. You can use a variable or constant of a protocol type, also called an __existential type__, to hold a value of any conforming type:
 
 ```swift 
-protocol P {}
-
-struct S: P {}
+protocol Animal {
+    func makeNoise()
+    static var species: String { get }
+}
+struct Dog: Animal {
+    func makeNoise() { print("Woof") }
+    static var species: String = "Canus familiaris"
+}
+struct Cat: Animal {
+    func makeNoise() { print("Meow") }
+    static var species: String = "Felis catus"
+}
 
-var s: P = S() // This creates existential type because the protocol P is used as a type
+var animal: Animal // `Animal` is used here as a type.
+animal = Dog()
+animal.makeNoise() // Prints "Woof".
+animal = Cat()
+animal.makeNoise() // Prints "Meow".
 ```
 
-However, a protocol type does not conform to protocols - not even the protocol itself. 
-Allowing existential types to conform to protocols is unsound. For protocols with static method, initializer, or associated type requirements, the implementation of these requirements cannot be accessed from the protocol type - accessing these kinds of requirements must be done using a concrete type.
-
-Let's walk through the example below:
+Notice that it is possible to invoke the method `makeNoise()` on a value of type `Animal`, just as it is possible to do so on a value of concrete type `Dog` or `Cat`. However, the static property `species` is not available for the existential type:
 
 ```swift
-protocol Word: Hashable {
-    var word: String { get }
-}
+print(Dog.species)    // Prints "Canus familiaris"
+print(Cat.species)    // Prints "Felis catus"
+print(Animal.species) // error: static member 'species' cannot be used...
+```
 
-struct Singular: Word {
-    var word: String
-}
+Since a type conforms to a protocol only when it satisfies _all_ of that protocol's requirements, the existential type `Animal` does not conform to the protocol `Animal` because it cannot satisfy the protocol's requirement for the static property `species`:
 
-struct Plural: Word {
-    var word: String
+```swift
+func declareAnimalSpecies<T: Animal>(_ animal: T) {
+    animal.makeNoise()
+    print("My species is known as \(T.species)")
 }
 
-let singularWord = Singular(word: "mango")
-let pluralWord = Plural(word: "mangoes")
-
-let wordPairDict: [Word: Word] = [singularWord: pluralWord] // Error
+let dog = Dog()
+declareAnimalSpecies(dog)
+// Prints:
+// "Woof"
+// "My species is known as Canus familiaris"
+declareAnimalSpecies(animal)
+// error: protocol type 'Animal' cannot conform to 'Animal'...
 ```
 
-One workaround to fix this problem is to use type erasure for the protocol `Word`. Think of type erasure as a way to hide an object's type. Since `Word` is of type `Hashable`, we already have `AnyHashable` type erasure available in the standard library which we can easily use here.
+In general, any initializers, static members, and associated types required by a protocol can be used only via conforming concrete types. Although Swift allows a protocol that requires initializers or static members to be used as a type, that type _does not and cannot_ conform to the protocol itself.
 
-```swift 
-// The fix
-let wordPairDict: [AnyHashable: AnyHashable] = [singularWord: pluralWord]
-```
+Currently, even if a protocol `P` requires no initializers or static members, the existential type `P` does not conform to `P` (with exceptions below). This restriction allows library authors to add such requirements (initializers or static members) to an existing protocol without breaking their users' source code.
+
+Concrete types that _do_ conform to protocols can provide functionality similar to that of existential types. For example, the standard library provides the `AnyHashable` type for `Hashable` values. Manual implementation of such __type erasure__ can require specific knowledge of the semantic requirements for each protocol involved and is beyond the scope of this discussion.
+
+For more on using existential types, see [Protocols as Types](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html#ID275) in _The Swift Programming Language_.
 
-# Exceptions
-`@objc` protocol type with no static requirements however do conform to its own protocol. Another exception is the `Error` Swift protocol.
+## Exceptions
 
+The Swift protocol `Error` has no required members and, when used as a type, conforms to itself; `@objc` protocols with no static requirements can also be used as types that conform to themselves.