In the very first Swift Talk we built a tiny library, leveraging ’s structs and generics for type-safety and testability. This was in June 201, and we were still working with 2.2. A lot has changed since then — so let’s revisit the code and make use of ’s latest tricks!

The basic idea was to separate the description of an endpoint from the code executing the network request. The description includes not only the URL, but also the function that can turn from the network into the desired result:

struct Resource<A> {
    let url: URL
    let parse: (Data) -> A?
}

The parse function takes Data and turns it into an optional A. The advantage of using Data is that we can deal with any endpoint, irrespective of the data format. But let’s face it, more often than not we’re dealing with JSON. So we wrote the following initializer to make it easier to create JSON resources:

extension Resource {
    init(url: URL, parseJSON: @escaping (Any) -> A?) {
        self.url = url
        self.parse = { data in
            let json = try? JSONSerialization.jsonObject(with: data, options: [])
            return json.flatMap(parseJSON)
        }
    }
}

In the meantime Swift gained the protocol that makes it super easy to encode and decode values conforming to it. As Aurélien Noce pointed out on Twitter, this makes a very nice addition to this tiny networking library. We can write another initializer on Resource for types that conform to the Decodable protocol:

extension Resource where A: Decodable {
    init(url: URL) {
        self.url = url
        self.parse = { try? JSONDecoder().decode(A.self, from: $0) }
    }
}

This makes it super easy to create resources for Decodable types. For example:

struct Episode: Codable {
    let id: String
    let title: String
}

let allEpisodes = Resouce<[Episode]>(url: url)
Webservice().load(allEpisodes) { print($0) }

Since arrays are also decodable if their elements are, we can create a resource for all episodes — including the function that parses data from the network — in a single line. In fact, we didn’t have to write any parsing code ourselves.

Of course this only works if you can determine how your data is being represented in JSON. In projects you’ll often not have this possibility. However, it’s still a great technique for quick experiments and prototyping!



Source link
Based Blockchain Network

LEAVE A REPLY

Please enter your comment!
Please enter your name here