1. Cocoa Design Patterns
in Swift
@MicheleTitolo

4. • New language features
• Functional patterns
• Patterns in Swift
• Anti-patterns
What we’ll cover

5. New language features

6. Tuples

7. Tuples group multiple values
into a single compound value.

8. let http404Error = (404, "Not Found")
println(http404Error.0)

9. var http200Response: (statusCode: Int, statusText: String,
hasBody: Bool)
http200Response.statusCode = 200
http200Response.statusText = "OK"
http200Response.hasBody = true

10. You can put any kind
of object in a tuple

11. Generics

12. <T>

13. More than just an id

14. Abstraction

15. Create functions without
declaring type

16. struct Stack<T> {
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
}

17. <T: Equitable>

18. AnyObject

19. ...used a lot more like id

20. Closures

21. “Closures are behaviors
with attached state”
- Peter Norvig

22. Like blocks, but better!

23. var closure = { (params) -> returnType in
statements
}

24. let

25. Immutable variable

26. var myString: String? = someFucntion()
if let greeting = myString {
println(greeting)
}
else {
println("Not a string")
}

27. Structs + Enums

28. Structs:
Pass-by-value

29. struct Rect {
var origin: Point
var size: Size
}

30. Structs can have methods, and
conform to protocols

31. Enums:
also pass-by-value

32. Also can conform
to protocols and have methods

33. enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func description() -> String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
case .King:
return "king"
default:
return String(self.toRaw())
}
}
}

34. Functional Patterns

35. Function Passing

36. func printExcitedly(string: String){
println(string + "!!!!!!!")
}
var excitedFunc = printExcitedly

37. Pass functions into functions

38. func printVeryExcitedly(excitedFunction: (String) -> Void,
message: String){
excitedFunction(message.uppercaseString)
}
printVeryExcitedly(printExcitedly, "Hello");

39. Return functions
from functions

40. func beExcited(excitementLevel: Int) -> (String) -> Void {
...
}

41. Patterns

42. Composition

43. ...because we can pass
functions!

44. The OO way

45. class Car {
let numWheels: Int
let numCylinders: Int
init (numWheels: Int, numCylinders: Int) {
self.numWheels = numWheels
self.numCylinders = numCylinders
}
}
var newCar = Car(numWheels: 4,numCylinders: 4)
var otherCar = Car(numWheels: 4, numCylinders: 6)

46. var motorcycle = ??

47. class Motorcycle {
...
}

48. This is not ideal

49. protocol Vehicle {
var numWheels: Int {get set}
var numCylinders: Int {get set}
func drive()
}

50. Better

51. How do we handle this at
scale?

54. struct WheelSet {
var wheelSize: Int
var wheelFrictionCoefficient: Float
}
struct BodyType {
var numWheels: Int
var wheels: WheelSet
var wheelBase: Float
}
enum EngineType: Int {
case Automatic, Manual
}
protocol Vehicle {
var body: BodyType {get set}
var transmission: EngineType {get set}
func drive(force: Float)
func turn(speed: Float)
}

55. Better

56. ...but we can still improve

57. Factories

58. Abstract away object
creation and composition

59. protocol VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle
}
class VehicleFactory: VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle {}
}

60. protocol VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle
}
class VehicleFactory: VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle {}
}
class MotorcycleFactory: VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle {}
}

61. This still looks very OO

62. class VehicleFactory {
func wheelSetGenerator(wheelSize: Int,
friction: Float) -> WheelSet {
return WheelSet(wheelSize: wheelSize,
wheelFrictionCoefficient: friction)
}
func generateBodyType(wheelCount: Int,
wheelType: WheelSet,
wheelBase: Float) -> (Void) -> BodyType {
func bodyGen() -> BodyType {
return BodyType(numWheels:wheelCount,
wheels:wheelType,
wheelBase:wheelBase)
}
return bodyGen
}
func createVehicle(
bodyGenerator:(wheelCount: Int,
wheelType: WheelSet,
wheelBase: Float) -> BodyType,
transmission: EngineType) -> Vehicle {}
}

63. let factory: VehicleFactory = VehicleFactory()
let motorcycleWheelSet: WheelSet = factory.wheelSetGenerator(28, friction: 0.5)
let motorcycleBodyGen = factory.generateBodyType(2,
wheelType:motorcycleWheelSet,
wheelBase: 45)
let motorcycle = factory.createVehicle(motorcycleBodyGen, transmission: .Manual)
let electricMotorcycle = factory.createVehicle(motorcycleBodyGen,
transmission: .Auomatic)

64. Factories in Swift can be
incredibly flexible

65. Command

66. A delegate chain
that returns a function

67. protocol Commander {
func commandSomething(String) -> (Int) -> Dictionary<String, String>
}
class ViewController: {
let delegate: Commander
}

68. Why is this better
than closures?

69. It’s more explicit

70. It’s more flexible

71. Enumeration

72. Not the type enum!

73. We have new ways of
transforming collections

74. [1,2,3,4].map {
(var number) -> Int in
return number * number
}

75. var array = [3, 2, 5, 1, 4]
array.sort { $0 < $1 }

76. let array = [1, 2, 3, 4, 5]
let reversedArray = array.reverse()
// reversedArray = [5, 4, 3, 2, 1]

77. And of course, this is useful for
more than just math

78. var vehicles = [suv, motorcycle, electricMotorcycle, car, truck]
var manualVehicles = vehicles.filter {
(var vehicle: Vehicle) -> Vehicle in
return (vehicle.transmission == .Manual)
}
// manualVehicles = [motorcycle, truck]

79. Encapsulate better

80. func meanMedianMode(a: Array<Int>) -> (mean:Int, median:Int, mode:Int) {
var mean = findMean(a)
var median = findMedian(a)
var mode = findMode(a)
return (mean, median, mode)
}

81. Tuples with names are
incredibly useful

82. Anti-Patterns

83. No changes to
handling protocols

84. This is the slide I was hoping
to put something magical on

85. class ViewController: UIViewController, UITableViewDataSource {
var tableView: UITableView
func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) ->
UITableViewCell! {
var cell : UITableViewCell = tableView.dequeueReusableCellWithIdentifier("Cell") as
UITableViewCell
if (cell == nil) {
cell = UITableViewCell(style: UITableViewCellStyle.Default, reuseIdentifier: "Cell")
}
cell.textLabel.text = "Hello World"
return cell
}
func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {
return 1
}
}

86. Protocols are first class citizens
in Swift, just like in Obj-c

87. Tuples all the way down

89. Yes, you can put a tuple in a
tuple

90. These are temporary data
structures

91. We have better OO
tools available

92. Operator overloading

93. Don’t overload default
operators

94. func decode(json: JSON) -> User? {
return _JSONObject(json) >>> { d in
User.create <^>
d["id"] >>> _JSONInt <*>
d["name"] >>> _JSONString <*>
d["email"] >>> _JSONString
}
}

95. Operators make code
harder to read

96. Type is still important

97. Getting classes from
AnyObject are kind of a pain

99. Still be explicit when you can

100. var music: [String: String] = ["AC/DC": "Hells Bells",
"Red Hot Chili Peppers": "Californication"]

101. In Summary

102. Swift gives us new tools

103. But Objective-C, and its
patterns, aren’t going away
anytime soon

104. More Swift!
• Today 11:30am
Interoperating Swift with Lower Level Code
by Stephan Tramer in Terrace
• Tomorrow 1:45pm
Functional Programming in Swift
by Chris Eidhof in Vail

105. Resources
• Swift Programming Guide from Apple
• Design Patterns in Dynamic Programming by Peter
Norvig
• Erica Sadun’s many blog posts on Swift
• Functional Programming in Swift, ebook by Objc.io
founders (See Chris’ talk tomorrow!)
• Instance Methods and Curried Functions in Swift by Ole
Begemann

106. Thanks!
@MicheleTitolo