Real World Generics In Swift

REAL WORLD GENERICS IN
SWIFT
@VADYMMARKOV

ABOUT ME
let me = Developer(
name: "Vadym Markov",
specialisation: "iOS",
company: "Hyper Interaktiv AS",
interests: [
"Technology",
"Open Source",
"Music"
]
)

DEFINITION
▸ Generic programming is a way to write functions
and data types without being specific about the
types they use 
▸ Generic code enables you to write flexible,
reusable functions and types that can work with
any type, subject to requirements that you define

GENERICS AND SWIFT
▸ Generics are one of the most powerful
features of Swift
▸ Much of the Swift standard library is built
with generic code
▸ You’ve already been using generics, even if
you didn’t realise it

SWIFT STANDARD LIBRARY
// Array
var array = [String]()
// Dictionary
var dictionary = [String: String]()
// Enum
var string1 = Optional<String>.Some("Swift")
var string2 = Optional<String>.None == nil

THE PROBLEM
struct IntQueue {
private var items = [Int]()
mutating func enqueue(item: Int) {
items.append(item)
}
mutating func dequeue() -> Int? {
return items.removeFirst()
}
func peek() -> Int? {
return items.first
}
func isEmpty() -> Bool {
return items.isEmpty
}
}

SOLUTION?
struct AnyQueue {
private var items = [Any]()
mutating func enqueue(item: Any) {
items.append(item)
}
mutating func dequeue() -> Any? {
}
func peek() -> Any? {
return items.first
}
}
}

SO NOW WE ARE ABLE TO PUSH STRINGS TO THE STACK, RIGHT?
YES BUT…
▸ We are losing type safety
▸ We also need to do a lot of casting

SOLUTION!
struct Queue<T> {
private var items = [T]()
mutating func enqueue(item: T) {
items.append(item)
}
mutating func dequeue() -> T? {
}
func peek() -> T? {
return items.first
}
}
}

SOLUTION!
var stringQueue = Queue<String>()
stringQueue.enqueue("String")
stringQueue.dequeue() // "String"
var intQueue = Queue<Int>()
intQueue.enqueue(1)
intQueue.dequeue() // 1

GENERIC TYPES
class DataSource<Model, Cell: UITableViewCell> : NSObject,
UITableViewDataSource, UITableViewDelegate {
let cellIdentifier: String
let configureCell: (Model, Cell) -> Void
var cellHeight: CGFloat = 64
var items = [Model]()
var action: (Model -> Void)?
init(cellIdentifier: String,
configureCell: (Model, Cell) -> Void) {
self.cellIdentifier = cellIdentifier
self.configureCell = configureCell
}
// ...

// MARK: - UITableViewDataSource
func numberOfSectionsInTableView(tableView: UITableView) -> Int {
return 1
}
func tableView(tableView: UITableView,
numberOfRowsInSection section: Int) -> Int {
return items.count
}
cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier(
cellIdentifier,
forIndexPath: indexPath)
let item = items[indexPath.item]
if let cell = cell as? Cell {
configureCell(item, cell)
}
return cell
}

// MARK: - UITableViewDelegate
heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
return cellHeight
}
didSelectRowAtIndexPath indexPath: NSIndexPath) {
tableView.deselectRowAtIndexPath(indexPath, animated: true)
guard let action = action else { return }
let item = items[indexPath.row]
action(item)
}

class TeamController: UITableViewController {
static let reusableIdentifier = "TeamCellIdentifier"
var developers = [Developer]()
lazy var dataSource: DataSource<Developer, TableViewCell> = {
[unowned self] in
let dataSource = DataSource(
cellIdentifier: TeamController.reusableIdentifier,
configureCell: self.configureCell)
dataSource.action = self.selectCell
return dataSource
}()
// ...
func configureCell(developer: Developer, cell: TableViewCell) {
cell.textLabel?.text = developer.name
cell.imageView?.image = UIImage(named: "placeholder"))
}
func selectCell(developer: Developer) {
UIApplication.sharedApplication().openURL(developer.githubURL)
}
}

protocol CacheAware {
func object<T: Cachable>(key: String,
completion: (object: T?) -> Void)
}
class DiskStorage: CacheAware {
func object<T: Cachable>(key: String,
completion: (object: T?) -> Void) {
// ...
}
}
// String must conform Cachable
let storage = DiskStorage(name: "Unknown")
storage.add("string", object: "My string”)
storage.object("string") { (object: String?) in }
GENERIC FUNCTIONS

struct ViewModel: Mappable {
// ...
var meta = [String : AnyObject]()
func meta<T>(key: String, _ defaultValue: T) -> T {
return meta[key] as? T ?? defaultValue
}
}
let modelFoo = ViewModel(title: "foo", meta: ["id" : 1])
modelFoo.meta("id", 0) // 1
modelFoo.meta("foo", "bar") // bar
GENERIC FUNCTIONS

WHAT ABOUT PROTOCOLS?
▸Protocols in Swift cannot be deﬁned
generically using type parameters. 
▸Instead, protocols can deﬁne what are
known as associated types.

ASSOCIATED TYPES
protocol Cachable {
typealias CacheType
static func decode(data: NSData) -> CacheType?
func encode() -> NSData?
}
extension String: Cachable {
typealias CacheType = String
static func decode(data: NSData) -> CacheType? {
// ...
}
func encode() -> NSData? { // ... }
}

ASSOCIATED TYPES
let list: [Cachable] = []
▸ Cachable represents a set of types rather than a
single type
▸ In an array of Cachable, you are not be able to say
anything about the return type of the decode()
method

HOW COULD IT LOOK LIKE?
let list : [Cachable<String>] = []
let’s imagine Swift supporting generic
parameterised protocols

MORE EXAMPLES: OPERATORS
infix operator ?= { associativity right precedence 90 }
public func ?=<T>(inout left: T, right: T?) {
guard let value = right else { return }
left = value
}
public func ?=<T>(inout left: T?, right: T?) {
guard let value = right else { return }
left = value
}
// ...
func testIfLetAssignment() {
let hyper = NSURL(string: "hyper.no")!
let faultyURL = NSURL(string: "/http")
var testURL: NSURL?
testURL ?= hyper // "hyper.no"
testURL ?= faultyURL // "hyper.no"
}

MORE EXAMPLES: PROTOCOL EXTENSIONS
protocol Queueable {
func process() -> Bool
}
extension Array where Element : Queueable {
mutating func processQueue(from: Int, to: Int,
process: ((element: Element) -> Void)) {
// ...
}
}
var testQueue = [Object(), Object()]
testQueue.processQueue()

MORE EXAMPLES: ENUMS
enum Result<T, ErrorType> {
case Success(T)
case Failure(ErrorType)
}
struct UFO {
enum Error: ErrorType {
case NotFound
}
}
func recognizeUFO(completion: Result<UFO, UFO.Error> -> Void) {
var ufo: UFO?
// Some async complex calculations
if let result = ufo {
completion(Result.Success(result))
} else {
completion(Result.Failure(UFO.Error.NotFound))
}
}

WHY GENERICS?
▸ Type safety
▸ Less code duplication
▸ No type casting hell
▸ Public API ﬂexibility
▸ Abstraction is fun

RESOURCES
▸ https://developer.apple.com/swift/
▸ https://github.com/hyperoslo/Orchestra
▸ https://github.com/hyperoslo/Cache
▸ https://github.com/hyperoslo/Spots
▸ https://github.com/hyperoslo/Sugar

QUESTIONS?
HTTPS://GITHUB.COM/VADYMMARKOV
@VADYMMARKOV

Real World Generics In Swift

More Related Content

What's hot (20)

Similar to Real World Generics In Swift (20)

Recently uploaded (20)

Real World Generics In Swift