Removing optionals

let products: [Category : [Product]] = [
    .dairy: [
        Product(name: "Milk", category: .dairy),
        Product(name: "Butter", category: .dairy)
    ],
    .vegetables: [
        Product(name: "Cucumber", category: .vegetables),
        Product(name: "Lettuce", category: .vegetables)
    ]
]

While the above works, it will require us to write code like this in order to - 

for example - only display all dairy products:

if let dairyProducts = products[.dairy] {
    guard !dairyProducts.isEmpty else {
        renderEmptyView()
        return
    }

    render(dairyProducts)
} else {
    renderEmptyView()
}

That's fine, but it could be nicer. Inserting new products, however, 

becomes much more of a hassle:  

class ShoppingCart {
    private(set) var products = [Category : [Product]]()

    func add(_ product: Product) {
        if var productsInCategory = products[product.category] {
            productsInCategory.append(product)
            products[product.category] = productsInCategory
        } else {
            products[product.category] = [product]
        }
    }
}

To be a collection

struct ProductCollection {
    typealias DictionaryType = [Category : [Product]]

    // Underlying, private storage, that is the same type of dictionary
    // that we previously was using at the call site
    private var products = DictionaryType()

    // Enable our collection to be initialized with a dictionary
    init(products: DictionaryType) {
        self.products = products
    }
}

Next, we'll make it conform to Collection by implementing the protocol requirements.

Most of what we'll do is simply forward calls to the underlying products dictionary

and let that do the "heavy lifting": 

extension ProductCollection: Collection {
    // Required nested types, that tell Swift what our collection contains
    typealias Index = DictionaryType.Index
    typealias Element = DictionaryType.Element

    // The upper and lower bounds of the collection, used in iterations
    var startIndex: Index { return products.startIndex }
    var endIndex: Index { return products.endIndex }

    // Required subscript, based on a dictionary index
    subscript(index: Index) -> Iterator.Element {
        get { return products[index] }
    }

    // Method that returns the next index when iterating
    func index(after i: Index) -> Index {
        return products.index(after: i)
    }
}

for (category, productsInCategory) in products {
    ...
}

Or use an operation like map on it:

let categories = productCollection.map { $0.key }

Custom collection APIs

extension ProductCollection {
    subscript(category: Category) -> [Product] {
        get { return products[category] ?? [] }
        set { products[category] = newValue }
    }
}

extension ProductCollection {
    mutating func insert(_ product: Product) {
        var productsInCategory = self[product.category]
        productsInCategory.append(product)
        self[product.category] = productsInCategory
    }
}

We can now go back to our original product handling code, and update it to be much 

nicer.For reading: 

let dairyProducts = products[.dairy]

if dairyProducts.isEmpty {
    renderEmptyView()
} else {
    render(dairyProducts)
}

And writing:

class ShoppingCart {
    private(set) var products = ProductCollection()

    func add(product: Product) {
        products.insert(product)
    }
}

Becoming expressible by a literal

let products: ProductCollection = [
    .dairy: [
        Product(name: "Milk", category: .dairy),
        Product(name: "Butter", category: .dairy)
    ],
    .vegetables: [
        Product(name: "Cucumber", category: .vegetables),
        Product(name: "Lettuce", category: .vegetables)
    ]
]

extension ProductCollection: ExpressibleByDictionaryLiteral {
    typealias Key = Category
    typealias Value = [Product]

    init(dictionaryLiteral elements: (Category, [Product])...) {
        for (category, productsInCategory) in elements {
            products[category] = productsInCategory
        }
    }
}

Conclusion

• Xcode 8.3.3
• Cocoapods 1.3.0.beta.2
• Firebase iOS SDK 4.0.3

Last day, when I was working on the api calls using almofire, I came across a weird looking method call which was something like creating an object of almofire and then calling a method with the object created ,followed by another method after a dot(.), followed by another method so far and so on…

Alamofire.request("https://httpbin.org/get")
    .validate(statusCode: 200..<300)
    .validate(contentType: ["application/json"])
    .responseData { response in
        switch response.result {
        case .success:
            print("Validation Successful")
        case .failure(let error):
            print(error)
        }
    }

• Making functions chainable is quite easy and can allow us to write using an almost DSL-like syntax. 

• We’ll add a new function that does something and then return self. It's that simple.

Chaining methods example:

class APICaller {
    var url:URL?
    var method = HTTPMethods.get
    var params:[String:String]?
    enum HTTPMethods: String { // http methods
        case get = "GET"
        case post = "POST"
        case put = "PUT"
        case patch = "PATCH"
        case delete = "DELETE"
    }
    
    func urlString(_ urlString: String?) -> APICaller {
        
        if let urlString = urlString {
        self.url = URL(string: urlString)
        }
        return self
    }
    
    func method(_ method:HTTPMethods) -> APICaller {
        self.method = method
        return self
    }
    
    func parameters(_ params:[String:String]) -> APICaller {
        self.params = params
        return self
    }
    
    func response(response:@escaping([String:AnyObject]) -> Void) {
        // create URLRequest with the http method, url, parameters etc and do the api call using URLSession method.. say use DataTask.
        let resultDictionary = ["result":["Result values1","Result values2","Result values3","Result values4"]]
        // let resultDictionary be the output of the API call made. Now, call the completion closure and pass the value .
        //DispatchQueue.main.async {
            response(resultDictionary as [String:AnyObject])
       // }
    }
}

An api call normally have a url, an http method and parameters.

If we use the class to make an API call,it will look something like this.

let params = [“key1”:”value1",”key2":”value2"]APICaller().urlString(“www.google.com").method(.post).parameters(params).response { 

(resultDict) inprint(resultDict[“result”]!)}//----------------
// prints the following in console. 

("Result values1", 

 "Result values2", 

 "Result values3", 

 "Result values4") 

1. Create an instance of APICaller class.
2. Call urlString method with a string as parameter. This will set the url property in APICaller class and return self .
3. Call method method which set the method property of APICaller class and return self .
4. Call parameters method which sets the parameters for the api call and return self .
5. Finally, call the method called response which has a trailing closure as parameter. Here, do the API call stuff and on success or failure, call the callback closure with the result object. Here the closure takes only a dictionary of type Dictionary<String,AnyObject>.

Our objective is to write less code which makes more sense!!!

Equatable

struct Book {
    let title: String
    let author: String
}

extension Book: Equatable {
    static func ==(lhs: Book, rhs: Book) -> Bool {
        guard lhs.title == rhs.title else {
            return false
        }

        guard lhs.author == rhs.author else {
            return false
        }

        return true
    }
}

Instance equatable

// Protocols with the 'class' constraint can only be conformed to
// by classes, enabling us to assume that an object will be used.
protocol InventoryDataSource: class {
    var numberOfItems: Int { get }

    func item(at index: Int) -> Item
}

class InventoryManager {
    var dataSource: InventoryDataSource? {
        // 'oldValue' is a magic variable that always contains the
        // previous value of the property when a new one is set
        didSet { dataSourceDidChange(from: oldValue) }
    }

    private func dataSourceDidChange(from previousDataSource: InventoryDataSource?) {
        // We don't want to reload if the same data source is re-assigned
        guard previousDataSource !== dataSource else {
            return
        }

        reload()
    }
}

Hashable

extension Book: Hashable {
    var hashValue: Int {
        return title.appending(author).hashValue
    }
}

class BookStore {
    var inventory = [Book]()
    var uniqueBooks = Set()

    func add(_ book: Book) {
        // Inventory will contain all books, including duplicates
        inventory.append(book)

        // By using a set (which we can, now that 'Book' conforms to 'Hashable')
        // we can guarantee that 'uniqueBooks' only contains unique values
        uniqueBooks.insert(book)
    }
}

Hashable for protocol types

class Circle {
    var radius: CGFloat {
        didSet { renderer?.enqueue(self) }
    }
    var strokeColor: UIColor {
        didSet { renderer?.enqueue(self) }
    }
    weak var renderer: Renderer?
}

extension Circle: Renderable {
    func render(in context: CGContext) {
       context.drawCircle(withRadius: radius, strokeColor: strokeColor)
    }
}

ObjectIdentifier

func enqueue(_ renderable: Renderable) {
    let identifier = ObjectIdentifier(renderable)
}

class RenderableWrapper {
    fileprivate let renderable: Renderable

    init(renderable: Renderable) {
        self.renderable = renderable
    }
}

extension RenderableWrapper: Renderable {
    func render(in context: CGContext) {
        // Forward the call to the underlying instance
        renderable.render(in: context)
    }
}

extension RenderableWrapper: Equatable {
    static func ==(lhs: RenderableWrapper, rhs: RenderableWrapper) -> Bool {
        // Compare the underlying instances
        return lhs.renderable === rhs.renderable
    }
}

extension RenderableWrapper: Hashable {
    var hashValue: Int {
        // Use the instance's unique identifier for hashing
        return ObjectIdentifier(renderable).hashValue
    }
}

class Renderer {
    private var objectsNeedingRendering = Set()

    func enqueue(_ renderable: Renderable) {
        // Since we use a 'Set', duplicates will automatically be
        // discarded, we don't have to write any code for it
        let wrapper = RenderableWrapper(renderable: renderable)
        objectsNeedingRendering.insert(wrapper)
    }

    func screenDidDraw() {
        // Start by emptying the queue
        let objects = objectsNeedingRendering
        objectsNeedingRendering = []

        // Render each object
        for object in objects {
            let context = makeContext()
            object.render(in: context)
        }
    }
}

Conclusion