Examples 31-35

Author: tib

contents/[31]protocols/index.md

@@ -4,46 +4,167 @@ description: ""
 order: 31
 ---
 
+A protocol is defined by the `protocol` keyword followed by the name, which conventionally starts with a capital letter. Protocol names usually describe a capability or a role.
 
-foo
+```swift
+protocol Vehicle {
+    
+    var name: String { get set }
+    var mph: Double { get }
+    
+    func drive()
+    func estimatedTime(for _: Double) -> Double
+}
+```
+
+See a `Car` structs conforming to the `Vehicle` protocol:: 
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
+struct Car: Vehicle {
+    
+    var name: String
+    var mph: Double
+    
+    func drive() {
+        print("Driving the \(name) at \(mph) mph.")
+    }
+    
+    func estimatedTime(for distance: Double) -> Double {
+        distance / mph
+    }
+}
 
-z = x + y // addition
-print(z) // => 10
+```
 
-z = x - y // subtraction
-print(z) // => 0
+Just like structs, enums can conform to protocols too. This means you require all instances of an enum to provide certain properties and methods as defined by the protocol. The implementation is a bit different of course:
 
-z = x * y // multiplication
-print(z) // => 25
+```swift
 
-z = x / y // division
-print(z) // => 1
+enum Airplane: Vehicle {
+    case boeing(name: String, mph: Double)
+    case airbus(name: String, mph: Double)
+
+    var name: String {
+        get {
+            switch self {
+            case .boeing(let name, _), .airbus(let name, _):
+                return name
+            }
+        }
+        set {
+            switch self {
+            case .boeing(_, let mph):
+                self = .boeing(name: newValue, mph: mph)
+            case .airbus(_, let mph):
+                self = .airbus(name: newValue, mph: mph)
+            }
+        }
+    }
+
+    var mph: Double {
+        switch self {
+        case .boeing(_, let mph), .airbus(_, let mph):
+            return mph
+        }
+    }
+
+    private var type: String {
+        switch self {
+        case .airbus(_, _): "Airbus"
+        case .boeing(_, _): "Boeing"
+        }
+    }
+
+    func drive() {
+        print("Flying the \(type) \(name) at \(mph) mph.")
+    }
+
+    func estimatedTime(for distance: Double) -> Double {
+        distance / mph
+    }
+}
+```
 
 
-var x = 10
+When instances are created from struct `Car` and `Airplane` which both conform to `Vehicle` protocol, you can use the protocol as a type, by explicitly marking the `currentVehicle` as `Vehicle`:
 
-x += 2 // addition
-print(x) // => 12
+```swift
+var currentVehicle: Vehicle = Car(name: "Tesla", mph: 150)
+currentVehicle.drive()
+print(currentVehicle.estimatedTime(for: 6000))
 
-x -= 2 // subtraction
-print(x) // => 10
+currentVehicle = Airplane.boeing(name: "777-9", mph: 500)
+currentVehicle.drive()
+print(currentVehicle.estimatedTime(for: 6000))
+```
+
+By conforming to the same protocol, different types can be used interchangeably. In the snippet below, `vehicles` is a constant which holds an array of various types adapting `Vehicle`. Hence, these types can be stored together and processed in a uniform way: 
+
+```swift
+let vehicles: [Vehicle] = [
+    // ...
+]
 
-x *= 2 // multiplication
-print(x) // => 20
+let distanceToReach: Double = 6000
 
-x /= 2 // division
-print(x) // => 10
+for vehicle in vehicles {
+    let time = vehicle.estimatedTime(for: distanceToReach)
+    print("Using a \(vehicle.name) it takes \(time) hours to travel \(distanceToReach) miles.")
+}
 ```
 
-bar
+Thanks to protocols as types, you can create an array that holds different kinds of vehicles. We can also use a protocol type as function parameters:
+
+```swift
+func goToTheCheckpoint(using vehicle: Vehicle) {
+    vehicle.drive()
+}
 
-```sh
-swift main.swift
+let car = Car(name: "Tesla", mph: 150)
+goToTheCheckpoint(using: car)
+
+let airplane = Airplane.boeing(name: "777-9", mph: 500)
+goToTheCheckpoint(using: airplane)
+```
+
+Just like protocols can require properties or functions, they can also require initializers, asking conforming types to provide a specific way of initialization. To require an initializer, declare it like this:
+
+```swift
+protocol Identifiable {
+    var id: String { get }
+
+    init(id: String) 
+}
+
+struct User: Identifiable {
+    var id: String
+    
+    init(id: String) {  
+        self.id = id
+    }
+}
+
+let user = User(id: "12345")  
+```
+
+What if you want to allow that initialization can fail? For example, maybe you only want to create an instance of `Adult` if it's `age` is above `18`. You can declare failable initializers with `init?` when initialization might fail:
+
+```swift
+protocol AgeRestricted {
+    init?(age: Int)
+}
+
+struct Adult: AgeRestricted {
+    var age: Int
+    
+    init?(age: Int) {
+        guard age >= 18 else { return nil }
+        self.age = age
+    }
+}
+
+let adult = Adult(age: 20)
+let minor = Adult(age: 16)
 ```
 
-baz
+If you pass something under 18, initialization fails and `nil` is returned.

contents/[32]generics/index.md

@@ -4,46 +4,74 @@ description: ""
 order: 32
 ---
 
+Generics functions are here to help us reuse code, avoid redundancy and even do it in a type-safe way. Instead of writing multiple functions, we can use a "generic placeholder" type, in this case, we call that `T` and we write it right after the function name inside `<>`. 
 
-foo
+The main point is that these placeholders can stand for any type, based on how you use the function. The placeholder will be resolved—with the actual type—when you call the function:
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
+func returnFirst<T>(_ array: [T]) -> T {
+    array[0]
+}
 
-z = x + y // addition
-print(z) // => 10
+let strings: [String] = ["apple", "banana", "cherry"]
+let firstString = returnFirst(strings)
+print(firstString)
 
-z = x - y // subtraction
-print(z) // => 0
+let numbers: [Int] = [20, 10, 1]
+let firstInt = returnFirst(numbers)
+print(firstInt)
+```
 
-z = x * y // multiplication
-print(z) // => 25
+You can also apply constraints to generics functions. The function `duplicate` takes an array of generic type, but with one condition: it needs to conform to the `Numeric` protocol. 
 
-z = x / y // division
-print(z) // => 1
+```swift
+func duplicate<T: Numeric>(_ array: [T]) -> [T] {
+    array.map { $0 * 2 }
+}
 
+let integers: [Int] = [4, 2, 6, 9]
+print(duplicate(integers))
 
-var x = 10
+let doubles: [Double] = [3.14, 4.20, 6.9]
+print(duplicate(doubles))
 
-x += 2 // addition
-print(x) // => 12
+let strings: [String] = ["a", "b", "c"]
+print(duplicate(strings)) // compiler error
+```
 
-x -= 2 // subtraction
-print(x) // => 10
+There's another way to do this, which you've seen before: using the where clause. You can also apply constraints by using the `where` keyword after the function:
 
-x *= 2 // multiplication
-print(x) // => 20
+```swift
+func duplicate<T: Numeric>(_ array: [T]) -> [T] {
+    array.map { $0 * 2 }
+}
 
-x /= 2 // division
-print(x) // => 10
+func duplicate<T>(_ array: [T]) -> [T] where T: Numeric {
+    array.map { $0 * 2 }
+}
 ```
 
-bar
+You can declare as many different generic parameters as you need, just list them each in separate angle brackets (`<>`), separated by commas `(,)`. Angle brackets tell the compiler to expect a placeholder type, not a concrete one.
 
-```sh
-swift main.swift
+```swift
+func mapValues<T, U>(
+    _ array: [T],
+    transform: (T) -> U
+) -> [U] {
+    var newArray: [U] = []
+    for item in array {
+        let newItem = transform(item)
+        newArray.append(newItem)
+    }
+    return newArray
+}
+
+let numbers: [Int] = [4, 2, 6, 9]
+let strings: [String] = mapValues(numbers) { number in
+    String(number) + " items"
+}
+print(strings)
 ```
 
-baz
+You can go further and add constraints to multiple generic parameters too, even having specified constraints for each parameter.
+