Protocol-Oriented Programming in Swift

2
Protocol-oriented programming in Swift
Rostyslav Kobyzskyi
Software Engineer
16th Nov, 2016

3
1. Classes and problems
2. Start with Protocol
3. Using Protocols
4. Examples
5. Questions
Agenda

Dave Abrahams
• David Abrahams is a computer
programmer and author
• Abrahams became a member of
the C++ Standards Committee
in 1996
• In 2013 Abrahams became an
employee at Apple Inc, where
he is involved in the
development of the Swift
programming language

Classes
• Encapsulation
• Access Control
• Abstraction
• Namespace
• Expressive Syntax
• Extensibility

1. Implicit Sharing
A
B
Ponies

1. Implicit Sharing
B
Ponies
$@#$%?

1. Implicit Sharing
• Defensive Copy
• Inefficiency
• Race Condition
• Locks
• More Inefficiency
• Deadlock
• Complexity
• Bugs!

Values don’t Share.
That’s a good thing
Classes? They overshare…

2. Inheritance
Subclass
Stored
Properties
Superclass

2. Inheritance
One superclass
Subclass
Stored
Properties
Superclass

Instance
2. Inheritance
One superclass
Single Inheritance
Subclass
Stored
Properties
Superclass

Instance
2. Inheritance
One superclass
Single Inheritance
Super class may have Stored Properties
Subclass
Stored
Properties
Superclass
Stored
Properties

Instance
2. Inheritance
One superclass
Single Inheritance
• You must accept them
Subclass
Stored
Properties
Superclass
Stored
Properties

2. Inheritance
One superclass
Single Inheritance
• Initialization problem
Instance
Subclass
Stored
Properties
Superclass
Stored
Properties

2. Inheritance
One superclass
Single Inheritance
• Don’t break superclass invariants!
Instance
Subclass
Stored
Properties
Superclass
Stored
Properties

2. Inheritance
One superclass
Single Inheritance
• Don’t break superclass invariants!
Know what/how to override (and when not)
Instance
Subclass
Stored
Properties
Superclass
Stored
Properties

3. Lost Type Relationships
class Ordered {
func precedes(other: Ordered) -> Bool
}
func binarySearch(sortedKeys: [Ordered], forKey k: Ordered) -> Int {
var lo = 0, hi = sortedKeys.count
while hi > lo {
let mid = lo + (hi - lo) / 2
if sortedKeys[mid].precedes(k) { lo = mid + 1 }
else { hi = mid }
}
return lo
}

class Ordered {
func precedes(other: Ordered) -> Bool { }
}

class Ordered {
}
{ fatalError(“implement me!”) }

class Ordered {
}
{ fatalError(“implement me!”) } X

class Ordered {
}
class Number: Ordered {
var value: Double = 0
override fund precedes(other: Ordered) -> Bool {
return value < other.value
}
}

class Ordered {
}
}
}

class Ordered {
}
}
}
`Ordered` does not have a member named `value`

`Ordered` does not have a member named `value`
class Ordered {
}
class Label: Ordered { var text: String = “” ... }
}
}

class Ordered {
}
class Label: Ordered { var text: String = “” ... }
return value < (other as! Number).value
}
}

A better Abstraction
Mechanism
• Support value types (and classes)
• Support static type relationships (and dynamic dispatch)
• Non-monolithic
• Doesn’t impose instance data on models
• Doesn’t impose initialization burdens on models
• Makes clear what to implement

Swift is Protocol-Oriented
Programming Language

Starting override with Protocols
class Ordered {
}
}
}

class Ordered {
}
}
}

protocol Ordered {
}
}
}

protocol Ordered {
}
}
}
{ fatalError(“implement me!”) }
Protocol methods may not have bodies

protocol Ordered {
}
}
}
Method does not override any method
from superclass

protocol Ordered {
}
return value < (other as! Number).value}
}

protocol Ordered {
}
struct Number: Ordered {
fund precedes(other: Ordered) -> Bool {
}
}

protocol Ordered {
}
fund precedes(other: Number) -> Bool {
}
}

protocol Ordered {
}
}
}
Protocol requires function ‘precedes’ with type ‘(Oredered)’ -> Bool
candidate has non-matching type (`Number`) -> Bool

protocol Ordered {
func precedes(other: Self) -> Bool
}
}
}
Self requirement

Using out Protocol
while hi > lo {
else { hi = mid }
}
return lo
}

Using out Protocol
while hi > lo {
else { hi = mid }
}
return lo
}
Protocol ‘Ordered’ can only be used as a generic constraint
because if has Self or associated type requirements

Using out Protocol
func binarySearch<T: Ordered>(sortedKeys: [T], forKey k: T) -> Int {
while hi > lo {
else { hi = mid }
}
return lo
}

Two-world of Protocols
Without Self Requirement With Self Requirement
func precedes(other: Ordered) -> Bool func precedes(other: Self) -> Bool

Usable as a type
sort(inout a: [Ordered])
Only usable as a generic constraint
sort<T: Ordered>(inout a: [T])

Usable as a type
Every model must deal with all others
Models are free from interaction

Usable as a type
Dynamic dispatch
Static dispatch

Usable as a type
Dynamic dispatch
Less optimizable
Static dispatch
More optimizable

A Primitive “Render”
struct Renderer {
func moveTo(p: CGPoint) { print(“moveTo((p.x), (p.y))”) }
func lineTo(p: CGPoint) { print(“lineTo((p.x), (p.y))”) }
func arcAt(center: CGPoint, radius: CGFloat,
startAngler: CGFloat, endAngle: CGFloat) {
print(“arcAt((center), radius: (radius)),” +
+ “ startAngle: (startAngle), endAngle: (endAngle)”)
}
}

Drawable
protocol Drawable {
func draw(randerer: Renderer)
}

Polygon
protocol Drawable {
}
struct Polygon: Drawable {
func draw(renderer: Renderer) {
renderer.moveTo(corners.last!)
for p in corners {
renderer.lineTo(p)
}
}
var corners: [CGPoint] = []
}

Circle
protocol Drawable {
}
struct Circle: Drawable {
renderer.artAt(center, radius: radius,
startAngle: 0.0, endAngle: twoPi)
}
}
var center: CGPoint
var radius: CGFloat
}

Diagram
protocol Drawable {
}
struct Diagram: Drawable {
for f in elements {
f.draw(renderer)
}
}
var elements: [Drawable] = []
}

Test It!
var circle = Circle(
center: CGPoint(x: 187.5, y: 333.5),
radius: 93.75
)

Test It!
radius: 93.75
)
var triangle = Polygon(corners: [
CGPoint(x: 187.5, y: 427.25),
CGPoint(x: 268.69, y: 286.625),
CGPoint(x: 106.31, y: 286.625)
])

Test It!
radius: 93.75
)
CGPoint(x: 187.5, y: 427.25),
CGPoint(x: 268.69, y: 286.625),
CGPoint(x: 106.31, y: 286.625)
])
var diagram = Diagram(elements: [circle: triangle])

Test It!
radius: 93.75
)
CGPoint(x: 187.5, y: 427.25),
CGPoint(x: 268.69, y: 286.625),
CGPoint(x: 106.31, y: 286.625)
])
var diagram = Diagram(elements: [circle: triangle])
diagram.draw(Renderer())

Renderer as Protocol
struct Renderer {
}
}
struct Renderer {
}
}

protocol Renderer {
}
}
struct Renderer {
}
}

protocol Renderer {
func moveTo(p: CGPoint)
func lineTo(p: CGPoint)
startAngler: CGFloat, endAngle: CGFloat)
}
struct Renderer {
}
}

protocol Renderer {
}
struct TestRenderer: Renderer {
}
}

Rendering with CoreGraphics
Retroactive modeling
protocol Renderer {
}

protocol Renderer {
}
extension CGContext: Renderer {
func moveTo(p: CGPoint) { }
func lineTo(p: CGPoint) { }
startAngler: CGFloat, endAngle: CGFloat) { }
}

extension CGContext: Renderer {
func moveTo(p: CGPoint) {
CGContextMoveToPoint(self, p.x, p.y)
}
func lineTo(p: CGPoint) {
CGContextAddLineToPoint(self, p.x, p.y)
}
let arc = CGPathCreateMutable()
CGPathAddArc(arc, nil, center.x, center.y, radius,
startAngle, endAngle, true)
CGContextAddPath(self, arc)
}
}

Protocols and Generics for Testability
So much better than mocks
struct Bubble: Drawable {
func draw(r: Renderer) {
r.arcAt(center, radius, startAngle: 0, endAngle: twoPi)
r.arcAt(highlightCenter, radius: highlightRadius,
startAngle: 0, endAngle: twoPi
)
}
}

r.arcAt(highlightCenter, radius: highlightRadius,
startAngle: 0, endAngle: twoPi
)
}
}
}
}

r.circleAt(center, radius)
r.arcAt(highlightCenter, radius: highlightRadius)
}
}
r.circleAt(center, radius)
}
}

Adding a Circle Primitive
protocol Renderer {
func arcAt(
center: CGPoint, radius: CGFloat,
startAngle: CGFloat, endAngle: CGFloat)
)
}

protocol Renderer {
func circleAt(center: CGPoint, radius: CGFloat)
func arcAt(
)
}

protocol Renderer {
func arcAt(
)
}
New requirement

protocol Renderer {
func arcAt(
)
}
extension TestRenderer {
func circleAt(center: CGPoint, radius: CGFloat) {
arcAt(center, radius: radius, startAngle: 0, endAngle: twoPi)
}
}

protocol Renderer {
func arcAt(
)
}
extension CGContext {
}
}

Protocol Extension
protocol Renderer {
func arcAt(
)
}
extension Renderer {
}
}
New!

Protocol Extension
protocol Renderer {
func arcAt(
)
}
}
}
Shared Implementation

Protocol Extension
func circleAt(center: CGPoint, radius: CGFloat) { ... }
func rectagleAt(edges: CGRect) { ... }
}
extension TestRenderer: Renderer {
}

Protocol Extension
}
}
let r = TestRenderer()
r.circleAt(origin, radius: 1)
r.rectangleAt(edges)

Protocol Extension
customization point
}
}
let r: Renderer = TestRenderer()
r.circleAt(origin, radius: 1)
r.rectangleAt(edges)

92
Thank you
Rostyslav
Software Engineer
rostyslav.kobyzskyi@globallogic.com
+38-093-254-3392

Protocol-Oriented Programming in Swift

More Related Content

What's hot

Viewers also liked

Similar to Protocol-Oriented Programming in Swift

More from GlobalLogic Ukraine

Recently uploaded

Protocol-Oriented Programming in Swift