Learn how to use protocols and generics to build powerful and reusable structures, classes, enumerations, and functions that work with a variety of different types.

Protocols and Generics

When defining a protocol, we might want to provide a default implementation of its properties and functions. This is useful in cases where the implementation of the functions and properties remain the same across the classes, structs, and enums that conform to this protocol.

Take protocol `PenSelling` defined below:

```swift
protocol PenSelling {
    var penPrice: Int { get }
    func price(withPenCount count: Int) -> Int
}
```

Any store that sells pens needs to have a price for each pen and a method to calculate the total price for `count` pens.

We can use a *protocol extension* to provide default implementations for both:

```swift
extension PenSelling {
    var penPrice: Int {
        return 2
    }
    func price(withPenCount count: Int) -> Int {
        return penPrice * count
    }
}
```

In an extension for a protocol, you can provide default implementations of its requirements.

Any stores that conform to this protocol will automatically have a `penPrice` of 2	 and the above implementation of `price(withPenCount:)` *without writing any code*!

```swift
struct Bookstore: PenSelling {
    let name: String
}
let miasStore = Bookstore(name: "Mia's Books")
print(miasStore.price(withPenCount: 10)) // prints 20
```

Conforming types can also choose to provide their own implementations for any or all of the properties and methods.

```swift
struct ArtStore: PenSelling {
    let name: String
    var penPrice: Int = 5
}
let noahsStore = ArtStore(name: "Noah's Art Supplies")
print(noahsStore.price(withPenCount: 10)) // prints 50
```


Protocol Extensions

We saw in an earlier exercise that protocols can be used as types on some occasions.

```swift
let favoriteNumber: Int = 7
let length: Double = 423.4
let purchase: String = "chair"

let describableThings: [CustomStringConvertible] = [5, "hello", [1,2,3]]

for thing in describableThings {
    print(thing.description)
}

// prints, 5, "hello", [1,2,3]
```

Protocols can also be used as return types in functions:

```swift
func getDescribableThing() -> CustomStringConvertible {
    return Bool.random() ? "hello" : 3
}

print(getDescribableThing()) // prints "hello" or 3
```

But when we try it with some protocols, we get an error!

```swift
func getHashbleThing() -> Hashable {
    return Bool.random() ? "hello" : 3
}
// Error: protocol 'Hashable' can only be used as a generic constraint because it has Self or associated type requirements.
```

This doesn't work because `Hashable` has an associated type alongside it.  Swift always needs to make sure it understands what all of the types will be, and allowing us to return a `Hashable` thing could mean that Swift tries to use different associated type properties.

We can resolve this with **Opaque Types**.  Opaque types allow us to hide the specific data type that is being returned from the caller. The caller doesn’t need to know the exact type being returned in this case, only that the function should return something that conforms to `Hashable`.

To return an opaque type, we can use the `some` keyword:

```swift
func getHashbleThing() -> some Hashable {
    return Bool.random() ? "hello" : 3
}
```

Closer, but this still won't compile!  That's because if we use an opaque type, all of the underlying types have to be the same.

```swift
func getHashbleThing() -> some Hashable {
    return Bool.random() ? "hello" : "goodbye"
}
```

Opaque types don't let us return different types, but they do let us hide information from the caller.  This can be useful if you want to keep certain elements of your code private so that callers won't try to use elements in ways they shouldn't.



Opaque Types

Classes, structs, and enums can also be generic, which means they can work with many different types. Here’s a simple example:

```swift
struct InformationWrapper<T> {
    var information: T
}
```

When creating instances of generic types, the instance is locked into the type it used.  It can’t be assigned to an instance of the same struct with a different underlying type.

```swift
var stringWrapper = InformationWrapper(information: "Hello!")
var intWrapper = InformationWrapper(information: 5)
stringWrapper = InformationWrapper(information: 4.0) // ERROR: Cannot convert value of type 'Double' to expected argument type 'String'
```

Just like for generic functions, you can also specify that the type must conform to one or more protocols:

```swift
struct HashableInformationWrapper<T: Hashable> {
    var information: T
}
```

Many structs in the Swift standard library are generic!  Arrays are one major example.  The syntax below isn’t as common, but is a valid way to define arrays:

```swift
let strArr: Array<String> = Array()
let intArr: Array<Int> = Array()
```

Both `strArr` and `intArr` are of type `Array`.  The type specified in angle braces states what kind of array it is.  Just like for our custom struct `InformationWrapper`, once `strArr` is defined as an array of `String`s, it can’t be assigned to an array of any other underlying type.

Generic Types

Animal structures conform to a protocol Flying by implementing a fly method.

Protocols are an important part of the Swift programming language. A protocol is a set of standards that classes, structs, or enums can choose to implement in their own ways. These standards come in the form of properties and functions. 
Since its inception, Swift has often been referred to as a protocol-oriented language, because protocols were designed to be heavily used while building apps. When a struct conforms to a protocol, it must implement a set of methods or properties, then it gains a set of abilities.

Generics represent another important concept that was introduced in Swift to make functions and protocols more generalizable. Generics allow developers to write functions, classes, structs, and enums that can use different data types.  An `Array` is a generic structure because you can make an `Array` of `Strings`, `Int`s, or any other type.

Both protocols and generics are heavily used in iOS development, so it’s important to understand how they work. Let’s dive in!


Introduction

Congratulations! You’ve completed a pretty long and complex lesson. You learned how to:

- Define and conform to custom protocols
- Conform to protocols in the Swift standard library
- Use protocol inheritance
- Provide default protocol implementation using protocol extensions
- Define generic functions
- Define generic types
- Define generic protocols with associated types 
- Write functions that return opaque types


You’ll be using protocols and generics extensively as an iOS developer, so make sure to review these concepts!

Conclusion

Generics are an important part of the Swift programming language. They allow us to create functions that make few assumptions about the underlying data types of its arguments and can be used with multiple data types. 

Consider the following function:

```swift
func max(x: Double, y: Double) -> Double {
    return x > y ? x : y
}
```
The above function accepts two `Double` type arguments and returns the maximum among the two.  What if we wanted to find the max of two `Int` type values? We cannot do it using the above function as it accepts only `Double` arguments. So, we’d have to write a different function.
```swift
func max(x: Int, y: Int) -> Int {
    return x > y ? x : y
}
```
It would take a long time to write out a function for each type!

Fortunately, using Generics, we can construct a function that accepts both `Int`s and `Double`s.

```swift
func max<T: Comparable>(x: T, y: T) -> T {
    return x > y ? x : y
}
```

The function name `max` is accompanied by `<T: Comparable>`. `T` denotes the placeholder data type and is enclosed within angular brackets. 

`: Comparable` shows that `T` conforms to the `Comparable` protocol but we don’t know `T`’s exact type. Conformance to `Comparable` is necessary in this case because it guarantees that values `x` and `y` can be compared with each other. More about `Comparable` [here](https://developer.apple.com/documentation/swift/comparable). 

Both `Int` and `Double` conform to `Comparable`, so this function can be used with both `Int` and `Double` types. However, both arguments have to be of the same type. 

This is how the function can be called with `Int` values:
```swift
let maxInt = max(x: 10, y: 12)
```
And this is how it can be called with `Double` values:
```swift
let maxDouble = max(x: 22.87, y: 66.23)
```

It is also possible to have generic functions that allow different data types in their arguments.
```swift
func buildSingleEntryDictionary<Key, Value>(withKey key: Key, andValue value: Value) -> [Key: Value] {
    var dict = [Key: Value]()
    dict[key] = value
    return dict
}
 
let populations = buildSingleEntryDictionary(withKey: "India", andValue: 1.37)
let classes = buildSingleEntryDictionary(withKey: "Ms. Frizzle", andValue: ["Arnold", "Carlos", "Dorothy"])
```

By using generics, you can create functions that work with different types!

Generic Functions

So far we have seen protocols that classes or structs can adopt to add more capabilities and perform more operations. However, the protocols we have discussed only work on specific data types. Consider the following protocol:


```swift
protocol ValuePrinting {
    var value: String { get }
    func printValue()
}

```
This protocol works only with a value of type `String`. If someone wanted to conform to `ValuePrinting` with a value of an `Int`, they would have to write a separate protocol.

The above problem could be solved using a generic protocol that can accept data of any type. The `MessagePrinting` protocol can be rewritten as follows:

 ```swift
protocol ValuePrinting {
    associatedtype T
    var value: T { get }
    func printValue()
}

```
In the above definition, we have used `associatedtype T`, which means it is left to the conforming class or struct to specify what that type should be. Therefore, the type of the `value` property will be inferred in the implementation of the conforming type. 

We can implement `ValuePrinting` using a  `String`:
```swift
struct StringPrinter: ValuePrinting {
    let value: String
    
    func printValue() {
        print("My string value is \(value)")
    }
}

```

And we can also implement `ValuePrinting` using a `Double`:

```swift
struct DoublePrinter: ValuePrinting {
    let value: Double
    
    func printValue() {
        print("My double value is \(value)")
    }
}
```	


Associated Types

A protocol defines a blueprint or a set of requirements that are needed to accomplish a particular task. Classes, structs, and enums can conform to protocols by providing an implementation of the protocol’s functions and properties.

The definitions of protocols are very similar to classes and structs. However, in the case of protocols, the definition does not implement the properties and functions. Instead, the class or struct that adopts the protocol handles the implementation of the properties and methods. Any type that satisfies the requirements of the protocol as described above is said to *conform* to the protocol.



```swift
protocol WelcomeMessagePrinting {
	func printHello(message: String)
}
```

In the example above, we have a protocol named `WelcomeMessagePrinting`. Inside the protocol, there is a function called `printHello()`. This function would be implemented by the class or struct that adopts `WelcomeMessagePrinting`.

```swift
struct MyStruct: WelcomeMessagePrinting {
    func printHello(message: String) {
        print(message)
    }
}
```

As mentioned earlier, properties can also be a part of protocols.

```swift
protocol WelcomeMessagePrinting {
	var helloMessage: String { get }
	func printHello()
}
```
Notice that in the above example we have introduced a `String` type property named `helloMessage`. There are a couple of things to know here:
* The protocol definition must specify if the conforming class/struct/enum needs to implement just the getter for the property or both the getter and setter methods. 
* If the property is defined as `get`, then the conforming type can choose to either provide the getter method, which is the minimum requirement or provide both the getter and setter methods.

Let’s now create a struct that conforms to `WelcomeMessagePrinting`:
```swift
struct Hello: WelcomeMessagePrinting {
    var helloMessage: String {
        return "Welcome"
    }
    
    func printHello() {
        print(helloMessage)
    }
}
```
Note that to add protocol conformance, the struct `Hello` needs to be followed by a `:` and the protocol name. 

Sometimes protocols have multiple functions and the implementation can be long, so it is common to move the protocol implementation to a separate extension as follows:
```swift
extension Hello: HelloPrinting {
    var helloMessage: String {
        return "Welcome"
    }
    
    func printHello() {
        print(helloMessage)
    }
}
```
The `printHello()` function can then be called as follows:
```swift
let hello = Hello()
hello.printHello() // Prints: Welcome
```

Multiple types can conform to the same protocol. For instance, in the following example we have `NewUserWelcomeView` struct conforming to `WelcomeMessagePrinting`:
```swift
struct NewUserWelcomeView: WelcomeMessagePrinting {
    var helloMessage: String = "Thanks for signing up!"
    func printHello() {
        print(helloMessage)
    }
}
```
And then the `ReturningUserWelcomeView` also conforms to `WelcomeMessagePrinting`:
```swift
struct ReturningUserWelcomeView: WelcomeMessagePrinting {
    var helloMessage: String = "Welcome back!"
    func printHello() {
        print(helloMessage)
    }
}
```

Note that the `helloMessage` for the structs above are different - that’s the flexibility that protocols allow us.

We can invoke the `printHello()` function on instances of the structs as given below:
```swift
var view: WelcomeMessagePrinting
view = NewUserWelcomeView()
view.printHello() // Prints: Thanks for signing up!
view = ReturningUserWelcomeView()
view.printHello() // Prints: Welcome back!
```
Note that `view` is declared as `WelcomeMessagePrinting` type, which means that it can be of any type that conforms to the `WelcomeMessagePrinting` protocol.

Protocols

In the previous exercise, we saw how to create our own protocols. The Swift standard library includes many useful protocols that you can have your structures, classes, or enums conform to. A useful example is `Hashable`.

The `Hashable` protocol is used to make structs, classes, and enums able to be added to `Set`s and `Dictionaries`. To conform to `Hashable`, a struct, class, or enum either needs to have a `hashValue` property or to have only properties that already conform to `Hashable`. Most basic Swift types conform to `Hashable`. The following code won’t compile:

```swift
struct Resident {
    var name: String
    var age: Int
    var address: String
    var socialSecurityNum: String
}
 
let taxesByResident = [Resident: Double]() // ERROR: Type 'Resident' does not conform to protocol 'Hashable'
```

We can make this code compile by adding the `Hashable` protocol to `Resident`:

```swift
struct Resident: Hashable {
    let name: String
    let age: Int
    let address: String
    let socialSecurityNum: String
}
 
let taxesByResident = [Resident: Double]()
```

`Hashable` is just one of many protocols in Swift! For more on common protocols, check out the link [here](https://developer.apple.com/documentation/swift/adopting_common_protocols) to Apple's documentation.

Protocols in the Swift Standard Library

A protocol can inherit from another protocol, like a class can inherit from another class.  Protocols can even inherit from multiple protocols at the same time!

A struct, class, or enum that conforms to a protocol must implement all requirements from the protocol as well as any of the protocols that it inherits from.

```swift
protocol Viewer {
    func login()
    func logout()
    func showContent()
}

protocol Creator: Viewer {
    func uploadNewContent(name: String)
}

struct VideoContentCreator: Creator {
    func login() {
        print("Successfully logged in")
    }
    func logout() {
        print("Successfully logged out")
    }
    func showContent() {
        print("Here are the new videos")
    }
    func uploadNewContent(name: String) {
        print("Thanks for uploading your new video: \(name)!")
    }
}
```
In the example above, we have a protocol `Viewer` that has three functions. The protocol `Creator` inherits `Viewer` and adds another function of its own. Since the `VideoContentCreator` struct conforms to the `Creator` protocol, it has to implement all the functions laid down in `Viewer` and `Creator`.